Merge branch 'us1882' of github.com:sendgrid/sendgrid-csharp into us1882

5 files changed, 261 insertions, 46 deletions

diff --git a/SendGrid/SendGridMail/Header.cs b/SendGrid/SendGridMail/Header.cs
index 6023214..c1138d8 100755
--- a/SendGrid/SendGridMail/Header.cs
+++ b/SendGrid/SendGridMail/Header.cs
@@ -7,24 +7,33 @@ namespace SendGridMail
 {

     public class Header : IHeader

     {

-        public void AddTo(IEnumerable<string> recipients)

+        private readonly HeaderSettingsNode _settings;

+

+        public Header()

         {

-            throw new NotImplementedException();

+            _settings = new HeaderSettingsNode();

         }

 

         public void AddSubVal(string tag, IEnumerable<string> substitutions)

         {

-            throw new NotImplementedException();

+            var keys = new List<String> {"data", "sub", tag};

+            _settings.AddArray(keys, substitutions);

         }

 

         public void AddUniqueIdentifier(IDictionary<string, string> identifiers)

         {

-            throw new NotImplementedException();

+            foreach (var key in identifiers.Keys)

+            {

+                var keys = new List<String> {"data", "unique_args", key};

+                var value = identifiers[key];

+                _settings.AddSetting(keys, value);

+            }

         }

 

         public void SetCategory(string category)

         {

-            throw new NotImplementedException();

+            var keys = new List<String> {"data", "category"};

+            _settings.AddSetting(keys, category);

         }

 

         public void Enable(string filter)

@@ -39,28 +48,50 @@ namespace SendGridMail
 

         public void AddFilterSetting(string filter, IEnumerable<string> settings, string value)

         {

-            throw new NotImplementedException();

+            var keys = new List<string>() { "data", "filters", filter, "settings" }.Concat(settings).ToList();

+            _settings.AddSetting(keys, value);

         }

 

         public void AddHeader(MailMessage mime)

         {

-            throw new NotImplementedException();

+            mime.Headers.Add("x-smtpapi", AsJson());

         }

 

         public String AsJson()

         {

-            return "";

+            if(_settings.IsEmpty()) return "";

+            return _settings.ToJson();

         }

 

-

-        internal class FilterNode

+        internal class HeaderSettingsNode

         {

-            private Dictionary<String, FilterNode> _branches;

+            private readonly Dictionary<String, HeaderSettingsNode> _branches;

+            private IEnumerable<String> _array; 

             private String _leaf;

 

-            public FilterNode()

+            public HeaderSettingsNode()

             {

-                _branches = new Dictionary<string, FilterNode>();

+                _branches = new Dictionary<string, HeaderSettingsNode>();

+            }

+

+            public void AddArray(List<String> keys, IEnumerable<String> value)

+            {

+                if (keys.Count == 0)

+                {

+                    _array = value;

+                }

+                else

+                {

+                    if (_leaf != null || _array != null)

+                        throw new ArgumentException("Attempt to overwrite setting");

+

+                    var key = keys.First();

+                    if (!_branches.ContainsKey(key))

+                        _branches[key] = new HeaderSettingsNode();

+

+                    var remainingKeys = keys.Skip(1).ToList();

+                    _branches[key].AddArray(remainingKeys, value);

+                }

             }

 

             public void AddSetting(List<String> keys, String value)

@@ -71,15 +102,18 @@ namespace SendGridMail
                 }

                 else

                 {

-                    var key = keys[0];

+                    if(_leaf != null || _array != null) 

+                        throw new ArgumentException("Attempt to overwrite setting");

+                    

+                    var key = keys.First();

                     if (!_branches.ContainsKey(key))

-                        _branches[key] = new FilterNode();

+                        _branches[key] = new HeaderSettingsNode();

+                    

                     var remainingKeys = keys.Skip(1).ToList();

                     _branches[key].AddSetting(remainingKeys, value);

                 }

             }

 

-

             public String GetSetting(params String[] keys)

             {

                 return GetSetting(keys.ToList());

@@ -96,6 +130,22 @@ namespace SendGridMail
                 return _branches[key].GetSetting(remainingKeys);

             }

 

+            public IEnumerable<String> GetArray(params String[] keys)

+            {

+                return GetArray(keys.ToList());

+            }

+

+            public IEnumerable<String> GetArray(List<String> keys)

+            {

+                if (keys.Count == 0)

+                    return _array;

+                var key = keys.First();

+                if (!_branches.ContainsKey(key))

+                    throw new ArgumentException("Bad key path!");

+                var remainingKeys = keys.Skip(1).ToList();

+                return _branches[key].GetArray(remainingKeys);

+            }

+

             public String GetLeaf()

             {

                 return _leaf;

@@ -104,8 +154,18 @@ namespace SendGridMail
             public String ToJson()

             {

                 if (_branches.Count > 0)

-                    return "{" + String.Join(",", _branches.Keys.Select(k => '"' + k + '"' + ":" + _branches[k].ToJson())) + "}";

-                return JsonUtils.Serialize(_leaf);

+                    return "{" + String.Join(",", _branches.Keys.Select(k => JsonUtils.Serialize(k)  + " : " + _branches[k].ToJson())) + "}";

+                if (_leaf != null)

+                    return JsonUtils.Serialize(_leaf);

+                if (_array != null)

+                    return "[" + String.Join(", ", _array.Select(i => JsonUtils.Serialize(i))) + "]";

+                return "{}";

+            }

+

+            public bool IsEmpty()

+            {

+                if (_leaf != null) return false;

+                return _branches == null || _branches.Keys.Count == 0;

             }

         }

     }

diff --git a/SendGrid/SendGridMail/IHeader.cs b/SendGrid/SendGridMail/IHeader.cs
index a9464ed..f55eadd 100755
--- a/SendGrid/SendGridMail/IHeader.cs
+++ b/SendGrid/SendGridMail/IHeader.cs
@@ -6,16 +6,64 @@ using System.Text;
 

 namespace SendGridMail

 {

+    /// <summary>

+    /// Represents the additional functionality to add SendGrid specific mail headers

+    /// </summary>

     public interface IHeader

     {

-        void AddTo(IEnumerable<String> recipients);

+        /// <summary>

+        /// This adds a substitution value to be used during the mail merge.  Substitutions

+        /// will happen in order added, so calls to this should match calls to addTo in the mail message.

+        /// </summary>

+        /// <param name="tag">string to be replaced in the message</param>

+        /// <param name="substitutions">substitutions to be made, one per recipient</param>

         void AddSubVal(String tag, IEnumerable<String> substitutions);

+

+        /// <summary>

+        /// This adds parameters and values that will be bassed back through SendGrid's

+        /// Event API if an event notification is triggered by this email.

+        /// </summary>

+        /// <param name="identifiers">parameter value pairs to be passed back on event notification</param>

         void AddUniqueIdentifier(IDictionary<String, String> identifiers);

+

+        /// <summary>

+        /// This sets the category for this email.  Statistics are stored on a per category

+        /// basis, so this can be useful for tracking on a per group basis.

+        /// </summary>

+        /// <param name="category">categories applied to the message</param>

         void SetCategory(String category);

+

+        /// <summary>

+        /// Shortcut method for enabling a filter.

+        /// </summary>

+        /// <param name="filter">The name of the filter to enable</param>

         void Enable(String filter);

+

+        /// <summary>

+        /// Shortcut method for disabling a filter.

+        /// </summary>

+        /// <param name="filter">The name of the filter to disable</param>

         void Disable(String filter);

+

+        /// <summary>

+        /// Allows you to specify a filter setting.  You can find a list of filters and settings here:

+        /// http://docs.sendgrid.com/documentation/api/web-api/filtersettings/

+        /// </summary>

+        /// <param name="filter">The name of the filter to set</param>

+        /// <param name="settings">The multipart name of the parameter being set</param>

+        /// <param name="value">The value that the settings name will be assigning</param>

         void AddFilterSetting(String filter, IEnumerable<String> settings, String value);

+

+        /// <summary>

+        /// Attaches the SendGrid headers to the MIME.

+        /// </summary>

+        /// <param name="mime">the MIME to which we are attaching</param>

         void AddHeader(MailMessage mime);

+

+        /// <summary>

+        /// Converts the filter settings into a JSON string.

+        /// </summary>

+        /// <returns>String representation of the SendGrid headers</returns>

         String AsJson();

     }

 }

diff --git a/SendGrid/Tests/TestHeader.cs b/SendGrid/Tests/TestHeader.cs
index e4a0814..76025aa 100755
--- a/SendGrid/Tests/TestHeader.cs
+++ b/SendGrid/Tests/TestHeader.cs
@@ -1,6 +1,7 @@
 using System;

 using System.Collections.Generic;

 using System.Linq;

+using System.Net.Mail;

 using System.Text;

 using Moq;

 using NUnit.Framework;

@@ -12,14 +13,82 @@ namespace Tests
     public class TestHeader

     {

         [Test]

-        public void TestAddTo()

+        public void TestAddSubVal()

         {

-            var foo = new Mock<IHeader>();

-            foo.Setup(m => m.Enable("foo"));

+            var test = new Header();

+            test.AddSubVal("foo", new List<string>{"bar", "raz"});

+            var result = test.AsJson();

+            Assert.AreEqual("{\"data\" : {\"sub\" : {\"foo\" : [\"bar\", \"raz\"]}}}", result);            

+        }

+

+        [Test]

+        public void TestAddUniqueIdentifier()

+        {

+            var test = new Header();

+            test.AddUniqueIdentifier(new Dictionary<string, string>(){{"foo", "bar"}});

+            var result = test.AsJson();

+            Assert.AreEqual("{\"data\" : {\"unique_args\" : {\"foo\" : \"bar\"}}}", result);

+        }

+

+        [Test]

+        public void TestSetCategory()

+        {

+            var test = new Header();

+            test.SetCategory("foo");

+            var result = test.AsJson();

+            Assert.AreEqual("{\"data\" : {\"category\" : \"foo\"}}", result);

+        }

 

-            var bar = new SendGrid(foo.Object);

-            Assert.AreEqual(1, 2, "I suck");

+        [Test]

+        public void TestEnable()

+        {

+            var test = new Header();

+            test.Enable("foo");

+            var result = test.AsJson();

+            Assert.AreEqual("{\"data\" : {\"filters\" : {\"foo\" : {\"settings\" : {\"enable\" : \"1\"}}}}}", result); 

+        }

+

+        [Test]

+        public void TestDisable()

+        {

+            var test = new Header();

+            test.Disable("foo");

+            var result = test.AsJson();

+            Assert.AreEqual("{\"data\" : {\"filters\" : {\"foo\" : {\"settings\" : {\"enable\" : \"0\"}}}}}", result);

+        }

+

+        [Test]

+        public void TestAddFilterSetting()

+        {

+            var test = new Header();

+            test.AddFilterSetting("foo", new List<string> { "a", "b" }, "bar");

+            var result = test.AsJson();

+            Assert.AreEqual("{\"data\" : {\"filters\" : {\"foo\" : {\"settings\" : {\"a\" : {\"b\" : \"bar\"}}}}}}", result);

+            

+        }

+

+        [Test]

+        public void TestAddHeader()

+        {

+            var test = new Header();

+            test.AddSubVal("foo", new List<string> { "a", "b" });

+            var mime = new MailMessage();

+            test.AddHeader(mime);

+            var result = mime.Headers.Get("x-smtpapi");

+            Assert.AreEqual("{\"data\" : {\"sub\" : {\"foo\" : [\"a\", \"b\"]}}}", result);

+        }

+

+        [Test]

+        public void TestAsJson()

+        {

+            var test = new Header();

+            var result = test.AsJson();

+            Assert.AreEqual("", result);

 

+            test = new Header();

+            test.AddSubVal("foo", new List<string>{"a", "b"});

+            result = test.AsJson();

+            Assert.AreEqual("{\"data\" : {\"sub\" : {\"foo\" : [\"a\", \"b\"]}}}", result);

         }

     }

 }

diff --git a/SendGrid/Tests/TestJsonUtils.cs b/SendGrid/Tests/TestJsonUtils.cs
index b06e153..b8f4aae 100755
--- a/SendGrid/Tests/TestJsonUtils.cs
+++ b/SendGrid/Tests/TestJsonUtils.cs
@@ -12,11 +12,6 @@ namespace Tests
         {

             Assert.AreEqual("1", JsonUtils.Serialize(1));

             Assert.AreEqual("\"\\\"foo\\\"\"", JsonUtils.Serialize("\"foo\""));

-

-            var arg = Encoding.UTF8.GetString(Encoding.ASCII.GetBytes("добры дзень"));

-            var result = JsonUtils.Serialize(arg);

-            System.Console.WriteLine(arg + " => " + result);

-            Assert.AreEqual("", result);

         }

     }

 }

diff --git a/SendGrid/Tests/TestTreeNode.cs b/SendGrid/Tests/TestTreeNode.cs
index 4b8a28f..1701d74 100755
--- a/SendGrid/Tests/TestTreeNode.cs
+++ b/SendGrid/Tests/TestTreeNode.cs
@@ -1,7 +1,6 @@
 using System;

 using System.Collections.Generic;

 using System.Linq;

-using System.Text;

 using NUnit.Framework;

 using SendGridMail;

 

@@ -11,47 +10,91 @@ namespace Tests
     public class TestTreeNode

     {

         [Test]

-        public void TestAddToTree()

+        public void TestAddSetting()

         {

-            var test = new Header.FilterNode();

+            var test = new Header.HeaderSettingsNode();

             test.AddSetting(new List<string>(), "foo");

             Assert.AreEqual("foo", test.GetLeaf(), "Get the leaf of the first node");

 

-            test = new Header.FilterNode();

-            test.AddSetting(new List<string>() { "foo" }, "bar");

+            test = new Header.HeaderSettingsNode();

+            test.AddSetting(new List<string> { "foo" }, "bar");

             Assert.AreEqual("bar", test.GetSetting(new List<string>(){"foo"}), "Get the item in the first branch 'foo', make sure its set to 'bar'");

 

-            test = new Header.FilterNode();

-            test.AddSetting(new List<string>(){"foo"}, "bar");

+            test = new Header.HeaderSettingsNode();

+            test.AddSetting(new List<string> {"foo"}, "bar");

             Assert.AreEqual("bar", test.GetSetting("foo"), "tests the convienence get setting function that omits the lists stuff...");

 

-            test = new Header.FilterNode();

-            test.AddSetting(new List<string>() { "foo", "bar", "raz" }, "foobar");

+            test = new Header.HeaderSettingsNode();

+            test.AddSetting(new List<string> { "foo", "bar", "raz" }, "foobar");

             Assert.AreEqual("foobar", test.GetSetting("foo", "bar", "raz"), "tests a tree that is multiple branches deep");

 

-

-            test = new Header.FilterNode();

-            test.AddSetting(new List<string>() { "foo", "bar", "raz" }, "foobar");

-            test.AddSetting(new List<string>() { "barfoo", "barbar", "barraz" }, "barfoobar");

+            test = new Header.HeaderSettingsNode();

+            test.AddSetting(new List<string> { "foo", "bar", "raz" }, "foobar");

+            test.AddSetting(new List<string> { "barfoo", "barbar", "barraz" }, "barfoobar");

             Assert.AreEqual("foobar", test.GetSetting("foo", "bar", "raz"), "tests a tree that has multiple branches");

             Assert.AreEqual("barfoobar", test.GetSetting("barfoo", "barbar", "barraz"), "tests the other branch");

+

+            test = new Header.HeaderSettingsNode();

+            test.AddSetting(new List<string> { "foo" }, "bar");

+            try

+            {

+                test.AddSetting(new List<string> {"foo", "raz"}, "blam");

+                Assert.Fail("exception not thrown");

+            }

+            catch (ArgumentException ex)

+            {

+                Assert.AreEqual("Attempt to overwrite setting", ex.Message);

+            }

+

         }

 

         [Test]

         public void TestToJSON()

         {

-            var test = new Header.FilterNode();

+            var test = new Header.HeaderSettingsNode();

             test.AddSetting(new List<string>() { "foo", "bar", "raz" }, "foobar");

             

             var result = test.ToJson();

-            Assert.AreEqual("{\"foo\":{\"bar\":{\"raz\":\"foobar\"}}}", result);

+            Assert.AreEqual("{\"foo\" : {\"bar\" : {\"raz\" : \"foobar\"}}}", result);

 

-            test = new Header.FilterNode();

+            test = new Header.HeaderSettingsNode();

             test.AddSetting(new List<string>() { "foo", "bar", "raz" }, "foobar");

             test.AddSetting(new List<string>() { "barfoo", "barbar", "barraz" }, "barfoobar");

             

             result = test.ToJson();

-            Assert.AreEqual("{\"foo\":{\"bar\":{\"raz\":\"foobar\"}},\"barfoo\":{\"barbar\":{\"barraz\":\"barfoobar\"}}}", result);

+            Assert.AreEqual("{\"foo\" : {\"bar\" : {\"raz\" : \"foobar\"}},\"barfoo\" : {\"barbar\" : {\"barraz\" : \"barfoobar\"}}}", result);

+

+            test = new Header.HeaderSettingsNode();

+            test.AddArray(new List<string>{"foo"}, new List<string>{"bar", "raz"});

+            result = test.ToJson();

+            Assert.AreEqual("{\"foo\" : [\"bar\", \"raz\"]}", result);

+

+        }

+

+        [Test]

+        public void TestAddArray()

+        {

+            var test = new Header.HeaderSettingsNode();

+            test.AddArray(new List<string>{"foo", "bar"}, new string[]{"raz", "blam"});

+            var result = test.GetArray("foo", "bar");

+            Assert.AreEqual(result.ToList()[0], "raz");

+            Assert.AreEqual(result.ToList()[1], "blam");

+        }

+

+        [Test]

+        public void TestIsEmpty()

+        {

+            var test = new Header.HeaderSettingsNode();

+            Assert.IsTrue(test.IsEmpty());

+

+            test = new Header.HeaderSettingsNode();

+            test.AddSetting(new List<string>{"foo"}, "bar");

+            Assert.IsFalse(test.IsEmpty());

+

+            test = new Header.HeaderSettingsNode();

+            test.AddArray(new List<string> { "raz" }, new List<string>{"blam"});

+            Assert.IsFalse(test.IsEmpty());

+

         }

     }

 }