Add initial tests

thinkingserious · thinkingserious · commit a98265a59678 · 2016-03-08T21:53:11.000-08:00
diff --git a/.gitignore b/.gitignore
@@ -3,8 +3,8 @@ CSharpHTTPClient/bin/
 Example/bin/
 CSharpHTTPClient/obj/
 Example/obj/
-CSharpHTTPClient/Tests/bin/
-CSharpHTTPClient/Tests/obj/
+UnitTest/bin/
+UnitTest/obj/
 *.suo
 CSharpHTTPClient/*/bin/
 CSharpHTTPClient/*/obj/
diff --git a/CSharpHTTPClient/CSharpHTTPClient.sln b/CSharpHTTPClient/CSharpHTTPClient.sln
@@ -7,6 +7,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CSharpHTTPClient", "CSharpH
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Example", "..\Example\Example.csproj", "{490AD14D-B821-435A-BEC8-F4DFE34E6556}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UnitTest", "..\UnitTest\UnitTest.csproj", "{DF845C59-4B39-4A8A-AC89-E5336B57076B}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -21,6 +23,10 @@ Global
 		{490AD14D-B821-435A-BEC8-F4DFE34E6556}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{490AD14D-B821-435A-BEC8-F4DFE34E6556}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{490AD14D-B821-435A-BEC8-F4DFE34E6556}.Release|Any CPU.Build.0 = Release|Any CPU
+		{DF845C59-4B39-4A8A-AC89-E5336B57076B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{DF845C59-4B39-4A8A-AC89-E5336B57076B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{DF845C59-4B39-4A8A-AC89-E5336B57076B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{DF845C59-4B39-4A8A-AC89-E5336B57076B}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/CSharpHTTPClient/Client.cs b/CSharpHTTPClient/Client.cs
@@ -9,6 +9,7 @@
 using System.Threading.Tasks;
 using System.Web.Script.Serialization;
 using System.Web;
+using System.Diagnostics;
 
 namespace SendGrid.CSharp.HTTP.Client
 {
@@ -17,43 +18,39 @@ public class Response
         public HttpStatusCode StatusCode;
         public HttpContent ResponseBody;
         public HttpResponseHeaders ResponseHeaders;
-        public Dictionary<string, dynamic> DSResponseBody;
-        public Dictionary<string, string> DSResponseHeaders;
 
         public Response(HttpStatusCode statusCode, HttpContent responseBody, HttpResponseHeaders responseHeaders)
         {
             StatusCode = statusCode;
             ResponseBody = responseBody;
             ResponseHeaders = responseHeaders;
-            DSResponseBody = DeserializeResponseBody(responseBody);
-            DSResponseHeaders = DeserializeResponseHeaders(responseHeaders);
         }
 
-        public Dictionary<string, dynamic> DeserializeResponseBody(HttpContent content)
+        public virtual Dictionary<string, dynamic> DeserializeResponseBody(HttpContent content)
         {
             JavaScriptSerializer jss = new JavaScriptSerializer();
-            var ds_content = jss.Deserialize<Dictionary<string, dynamic>>(content.ReadAsStringAsync().Result);
-            return ds_content;
+            var dsContent = jss.Deserialize<Dictionary<string, dynamic>>(content.ReadAsStringAsync().Result);
+            return dsContent;
         }
 
-        public Dictionary<string, string> DeserializeResponseHeaders(HttpResponseHeaders content)
+        public virtual Dictionary<string, string> DeserializeResponseHeaders(HttpResponseHeaders content)
         {
-            var ds_content = new Dictionary<string, string>();
+            var dsContent = new Dictionary<string, string>();
             foreach (var pair in content )
             {
-                ds_content.Add(pair.Key, pair.Value.First());
+                dsContent.Add(pair.Key, pair.Value.First());
             }
-            return ds_content;
+            return dsContent;
         }
 
     }
 
     public class Client : DynamicObject
     {
-        private string _host;
-        private Dictionary <string,string> _requestHeaders;
-        private string _version;
-        private string _urlPath;
+        public string Host;
+        public Dictionary <string,string> RequestHeaders;
+        public string Version;
+        public string UrlPath;
         public string MediaType;
         public enum Methods
         {
@@ -62,26 +59,26 @@ public enum Methods
 
         public Client(string host, Dictionary<string,string> requestHeaders = null, string version = null, string urlPath = null)
         {
-            _host = host;
+            Host = host;
             if(requestHeaders != null)
             {
-                _requestHeaders = (_requestHeaders != null)
-                    ? _requestHeaders.Union(requestHeaders).ToDictionary(pair => pair.Key, pair => pair.Value) : requestHeaders;
+                RequestHeaders = (RequestHeaders != null)
+                    ? RequestHeaders.Union(requestHeaders).ToDictionary(pair => pair.Key, pair => pair.Value) : requestHeaders;
             }
-            _version = (version != null) ? version : null;
-            _urlPath = (urlPath != null) ? urlPath : null;
+            Version = (version != null) ? version : null;
+            UrlPath = (urlPath != null) ? urlPath : null;
         }
 
         private string BuildUrl(string query_params = null)
         {
             string endpoint = null;
-            if( _version != null)
+            if( Version != null)
             {
-                endpoint = _host + "/" + _version + _urlPath;
+                endpoint = Host + "/" + Version + UrlPath;
             }
             else
             {
-                endpoint = _host + _urlPath;
+                endpoint = Host + UrlPath;
             }
 
             if (query_params != null)
@@ -105,19 +102,25 @@ private Client BuildClient(string name = null)
             string endpoint;
             if (name != null)
             {
-                endpoint = _urlPath + "/" + name;
+                endpoint = UrlPath + "/" + name;
             }
             else
             {
-                endpoint = _urlPath;
+                endpoint = UrlPath;
             }
-            _urlPath = null; // Reset the current object's state before we return a new one
-            return new Client(_host, _requestHeaders, _version, endpoint);
+            UrlPath = null; // Reset the current object's state before we return a new one
+            return new Client(Host, RequestHeaders, Version, endpoint);
         }
 
-        private void AddVersion(string version)
+        public virtual AuthenticationHeaderValue AddAuthorization(KeyValuePair<string, string> header)
         {
-            _version = version;
+            string[] split = header.Value.Split(new char[0]);
+            return new AuthenticationHeaderValue(split[0], split[1]);
+        }
+
+        public virtual void AddVersion(string version)
+        {
+            Version = version;
         }
 
         // Magic method to handle special cases
@@ -171,7 +174,13 @@ public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, o
                 result = null;
                 return false;
             }
- 
+
+        }
+
+        public async virtual Task<Response> MakeRequest(HttpClient client, HttpRequestMessage request)
+        {
+            HttpResponseMessage response = await client.SendAsync(request);
+            return new Response(response.StatusCode, response.Content, response.Headers);
         }
 
         private async Task<Response> RequestAsync(string method, String request_body = null, String query_params = null)
@@ -180,24 +189,26 @@ private async Task<Response> RequestAsync(string method, String request_body = n
             {
                 try
                 {
-                    client.BaseAddress = new Uri(_host);
+                    client.BaseAddress = new Uri(Host);
                     string endpoint = BuildUrl(query_params);
                     client.DefaultRequestHeaders.Accept.Clear();
-                    foreach (KeyValuePair<string, string> header in _requestHeaders)
+                    if(RequestHeaders != null)
                     {
-                        if(header.Key == "Authorization")
-                        {
-                            string[] split = header.Value.Split(new char[0]);
-                            client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(split[0], split[1]); ;
-                        }
-                        else if(header.Key == "Content-Type")
+                        foreach (KeyValuePair<string, string> header in RequestHeaders)
                         {
-                            MediaType = header.Value;
-                            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(MediaType));
-                        }
-                        else
-                        {
-                            client.DefaultRequestHeaders.Add(header.Key, header.Value);
+                            if (header.Key == "Authorization")
+                            {
+                                client.DefaultRequestHeaders.Authorization = AddAuthorization(header);
+                            }
+                            else if (header.Key == "Content-Type")
+                            {
+                                MediaType = header.Value;
+                                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(MediaType));
+                            }
+                            else
+                            {
+                                client.DefaultRequestHeaders.Add(header.Key, header.Value);
+                            }
                         }
                     }
 
@@ -213,8 +224,7 @@ private async Task<Response> RequestAsync(string method, String request_body = n
                         RequestUri = new Uri(endpoint),
                         Content = content
                     };
-                    HttpResponseMessage response = await client.SendAsync(request);
-                    return new Response(response.StatusCode, response.Content, response.Headers);
+                    return await MakeRequest(client, request);
 
                 }
                 catch (Exception ex)
diff --git a/Example/Example.cs b/Example/Example.cs
@@ -26,12 +26,13 @@ static void Main(string[] args)
             //Console.WriteLine(response.StatusCode);
             //Console.WriteLine(response.ResponseBody.ReadAsStringAsync().Result);
             //Console.WriteLine(response.ResponseHeaders.ToString());
-
-            foreach ( var value in response.DSResponseBody["result"])
+            var dssResponseBody = response.DeserializeResponseBody(response.ResponseBody);
+            foreach ( var value in dssResponseBody["result"])
             {
                 Console.WriteLine("name: {0}, api_key_id: {1}",value["name"], value["api_key_id"]);
             }
-            foreach (var pair in response.DSResponseHeaders)
+            var dssResponseHeaders = response.DeserializeResponseHeaders(response.ResponseHeaders);
+            foreach (var pair in dssResponseHeaders)
             {
                 Console.WriteLine("{0}: {1}", pair.Key, pair.Value);
             }
diff --git a/UnitTest/Properties/AssemblyInfo.cs b/UnitTest/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+﻿using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("UnitTest")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("UnitTest")]
+[assembly: AssemblyCopyright("Copyright ©  2016")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("df845c59-4b39-4a8a-ac89-e5336b57076b")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/UnitTest/UnitTest.cs b/UnitTest/UnitTest.cs
@@ -0,0 +1,77 @@
+﻿using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using SendGrid.CSharp.HTTP.Client;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using System.Net.Http;
+using System.Text;
+using System.Net;
+using System.Diagnostics;
+
+namespace UnitTest
+{
+    public class MockClient : Client
+    {
+        public MockClient(string host, Dictionary<string, string> requestHeaders = null, string version = null, string urlPath = null) : base (host, requestHeaders, version, urlPath)
+        {
+        }
+
+        public async override Task<Response> MakeRequest(HttpClient client, HttpRequestMessage request)
+        {
+            HttpResponseMessage response = new HttpResponseMessage();
+            response.Content = new StringContent("{'test': 'test_content'}", Encoding.UTF8, "application/json");
+            response.StatusCode = HttpStatusCode.OK;
+            return new Response(response.StatusCode, response.Content, response.Headers);
+        }
+    }
+
+    [TestClass]
+    public class TestClient
+    {
+        [TestMethod]
+        public void TestInitialization()
+        {
+            var host = "http://api.test.com";
+            Dictionary<String, String> requestHeaders = new Dictionary<String, String>();
+            var version = "v3";
+            var urlPath = "/test/url/path";
+            var test_client = new MockClient(host: host, requestHeaders: requestHeaders, version: version, urlPath: urlPath);
+            requestHeaders.Add("Authorization", "Bearer SG.XXXX");
+            requestHeaders.Add("Content-Type", "application/json");
+            requestHeaders.Add("X-TEST", "test");
+            Assert.IsNotNull(test_client);
+            Assert.AreEqual(host, test_client.Host);
+            Assert.AreEqual(requestHeaders, test_client.RequestHeaders);
+            Assert.AreEqual(version, test_client.Version);
+            Assert.AreEqual(urlPath, test_client.UrlPath);
+        }
+
+        [TestMethod]
+        public void TestReflection()
+        {
+            var host = "http://api.test.com";
+            dynamic test_client = new MockClient(host: host);
+            dynamic url1 = test_client.my.test.path;
+            Assert.AreEqual(url1.UrlPath, "/my/test/path");
+            url1 = test_client.my._("test").path;
+            Assert.AreEqual(url1.UrlPath, "/my/test/path");
+            url1 = test_client.version("v4").my.test.path;
+            Assert.AreEqual(url1.Version, "v4");
+            Assert.AreEqual(url1.UrlPath, "/my/test/path");
+            url1 = url1.final.result;
+            Assert.AreEqual(url1.UrlPath, "/my/test/path/final/result");
+        }
+
+        [TestMethod]
+        public void TestMethodCall()
+        {
+            var host = "http://api.test.com";
+            dynamic test_client = new MockClient(host: host);
+            Response response = test_client.get();
+            Assert.IsNotNull(response);
+            Assert.AreEqual(response.StatusCode, HttpStatusCode.OK);
+            var content = new StringContent("{'test': 'test_content'}", Encoding.UTF8, "application/json");
+            Assert.AreEqual(response.ResponseBody.ReadAsStringAsync().Result, content.ReadAsStringAsync().Result);
+        }
+    }
+}
diff --git a/UnitTest/UnitTest.csproj b/UnitTest/UnitTest.csproj

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`using System.Threading.Tasks;`
`10`	`10`	`using System.Web.Script.Serialization;`
`11`	`11`	`using System.Web;`
	`12`	`+using System.Diagnostics;`
`12`	`13`
`13`	`14`	`namespace SendGrid.CSharp.HTTP.Client`
`14`	`15`	`{`
`@@ -17,43 +18,39 @@ public class Response`
`17`	`18`	`public HttpStatusCode StatusCode;`
`18`	`19`	`public HttpContent ResponseBody;`
`19`	`20`	`public HttpResponseHeaders ResponseHeaders;`
`20`		`- public Dictionary<string, dynamic> DSResponseBody;`
`21`		`- public Dictionary<string, string> DSResponseHeaders;`
`22`	`21`
`23`	`22`	`public Response(HttpStatusCode statusCode, HttpContent responseBody, HttpResponseHeaders responseHeaders)`
`24`	`23`	`{`
`25`	`24`	`StatusCode = statusCode;`
`26`	`25`	`ResponseBody = responseBody;`
`27`	`26`	`ResponseHeaders = responseHeaders;`
`28`		`- DSResponseBody = DeserializeResponseBody(responseBody);`
`29`		`- DSResponseHeaders = DeserializeResponseHeaders(responseHeaders);`
`30`	`27`	`}`
`31`	`28`
`32`		`- public Dictionary<string, dynamic> DeserializeResponseBody(HttpContent content)`
	`29`	`+ public virtual Dictionary<string, dynamic> DeserializeResponseBody(HttpContent content)`
`33`	`30`	`{`
`34`	`31`	`JavaScriptSerializer jss = new JavaScriptSerializer();`
`35`		`- var ds_content = jss.Deserialize<Dictionary<string, dynamic>>(content.ReadAsStringAsync().Result);`
`36`		`- return ds_content;`
	`32`	`+ var dsContent = jss.Deserialize<Dictionary<string, dynamic>>(content.ReadAsStringAsync().Result);`
	`33`	`+ return dsContent;`
`37`	`34`	`}`
`38`	`35`
`39`		`- public Dictionary<string, string> DeserializeResponseHeaders(HttpResponseHeaders content)`
	`36`	`+ public virtual Dictionary<string, string> DeserializeResponseHeaders(HttpResponseHeaders content)`
`40`	`37`	`{`
`41`		`- var ds_content = new Dictionary<string, string>();`
	`38`	`+ var dsContent = new Dictionary<string, string>();`
`42`	`39`	`foreach (var pair in content )`
`43`	`40`	`{`
`44`		`- ds_content.Add(pair.Key, pair.Value.First());`
	`41`	`+ dsContent.Add(pair.Key, pair.Value.First());`
`45`	`42`	`}`
`46`		`- return ds_content;`
	`43`	`+ return dsContent;`
`47`	`44`	`}`
`48`	`45`
`49`	`46`	`}`
`50`	`47`
`51`	`48`	`public class Client : DynamicObject`
`52`	`49`	`{`
`53`		`- private string _host;`
`54`		`- private Dictionary <string,string> _requestHeaders;`
`55`		`- private string _version;`
`56`		`- private string _urlPath;`
	`50`	`+ public string Host;`
	`51`	`+ public Dictionary <string,string> RequestHeaders;`
	`52`	`+ public string Version;`
	`53`	`+ public string UrlPath;`
`57`	`54`	`public string MediaType;`
`58`	`55`	`public enum Methods`
`59`	`56`	`{`
`@@ -62,26 +59,26 @@ public enum Methods`
`62`	`59`
`63`	`60`	`public Client(string host, Dictionary<string,string> requestHeaders = null, string version = null, string urlPath = null)`
`64`	`61`	`{`
`65`		`- _host = host;`
	`62`	`+ Host = host;`
`66`	`63`	`if(requestHeaders != null)`
`67`	`64`	`{`
`68`		`- _requestHeaders = (_requestHeaders != null)`
`69`		`- ? _requestHeaders.Union(requestHeaders).ToDictionary(pair => pair.Key, pair => pair.Value) : requestHeaders;`
	`65`	`+ RequestHeaders = (RequestHeaders != null)`
	`66`	`+ ? RequestHeaders.Union(requestHeaders).ToDictionary(pair => pair.Key, pair => pair.Value) : requestHeaders;`
`70`	`67`	`}`
`71`		`- _version = (version != null) ? version : null;`
`72`		`- _urlPath = (urlPath != null) ? urlPath : null;`
	`68`	`+ Version = (version != null) ? version : null;`
	`69`	`+ UrlPath = (urlPath != null) ? urlPath : null;`
`73`	`70`	`}`
`74`	`71`
`75`	`72`	`private string BuildUrl(string query_params = null)`
`76`	`73`	`{`
`77`	`74`	`string endpoint = null;`
`78`		`- if( _version != null)`
	`75`	`+ if( Version != null)`
`79`	`76`	`{`
`80`		`- endpoint = _host + "/" + _version + _urlPath;`
	`77`	`+ endpoint = Host + "/" + Version + UrlPath;`
`81`	`78`	`}`
`82`	`79`	`else`
`83`	`80`	`{`
`84`		`- endpoint = _host + _urlPath;`
	`81`	`+ endpoint = Host + UrlPath;`
`85`	`82`	`}`
`86`	`83`
`87`	`84`	`if (query_params != null)`
`@@ -105,19 +102,25 @@ private Client BuildClient(string name = null)`
`105`	`102`	`string endpoint;`
`106`	`103`	`if (name != null)`
`107`	`104`	`{`
`108`		`- endpoint = _urlPath + "/" + name;`
	`105`	`+ endpoint = UrlPath + "/" + name;`
`109`	`106`	`}`
`110`	`107`	`else`
`111`	`108`	`{`
`112`		`- endpoint = _urlPath;`
	`109`	`+ endpoint = UrlPath;`
`113`	`110`	`}`
`114`		`- _urlPath = null; // Reset the current object's state before we return a new one`
`115`		`- return new Client(_host, _requestHeaders, _version, endpoint);`
	`111`	`+ UrlPath = null; // Reset the current object's state before we return a new one`
	`112`	`+ return new Client(Host, RequestHeaders, Version, endpoint);`
`116`	`113`	`}`
`117`	`114`
`118`		`- private void AddVersion(string version)`
	`115`	`+ public virtual AuthenticationHeaderValue AddAuthorization(KeyValuePair<string, string> header)`
`119`	`116`	`{`
`120`		`- _version = version;`
	`117`	`+ string[] split = header.Value.Split(new char[0]);`
	`118`	`+ return new AuthenticationHeaderValue(split[0], split[1]);`
	`119`	`+ }`
	`120`	`+`
	`121`	`+ public virtual void AddVersion(string version)`
	`122`	`+ {`
	`123`	`+ Version = version;`
`121`	`124`	`}`
`122`	`125`
`123`	`126`	`// Magic method to handle special cases`
`@@ -171,7 +174,13 @@ public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, o`
`171`	`174`	`result = null;`
`172`	`175`	`return false;`
`173`	`176`	`}`
`174`		`-`
	`177`	`+`
	`178`	`+ }`
	`179`	`+`
	`180`	`+ public async virtual Task<Response> MakeRequest(HttpClient client, HttpRequestMessage request)`
	`181`	`+ {`
	`182`	`+ HttpResponseMessage response = await client.SendAsync(request);`
	`183`	`+ return new Response(response.StatusCode, response.Content, response.Headers);`
`175`	`184`	`}`
`176`	`185`
`177`	`186`	`private async Task<Response> RequestAsync(string method, String request_body = null, String query_params = null)`
`@@ -180,24 +189,26 @@ private async Task<Response> RequestAsync(string method, String request_body = n`
`180`	`189`	`{`
`181`	`190`	`try`
`182`	`191`	`{`
`183`		`- client.BaseAddress = new Uri(_host);`
	`192`	`+ client.BaseAddress = new Uri(Host);`
`184`	`193`	`string endpoint = BuildUrl(query_params);`
`185`	`194`	`client.DefaultRequestHeaders.Accept.Clear();`
`186`		`- foreach (KeyValuePair<string, string> header in _requestHeaders)`
	`195`	`+ if(RequestHeaders != null)`
`187`	`196`	`{`
`188`		`- if(header.Key == "Authorization")`
`189`		`- {`
`190`		`- string[] split = header.Value.Split(new char[0]);`
`191`		`- client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(split[0], split[1]); ;`
`192`		`- }`
`193`		`- else if(header.Key == "Content-Type")`
	`197`	`+ foreach (KeyValuePair<string, string> header in RequestHeaders)`
`194`	`198`	`{`
`195`		`- MediaType = header.Value;`
`196`		`- client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(MediaType));`
`197`		`- }`
`198`		`- else`
`199`		`- {`
`200`		`- client.DefaultRequestHeaders.Add(header.Key, header.Value);`
	`199`	`+ if (header.Key == "Authorization")`
	`200`	`+ {`
	`201`	`+ client.DefaultRequestHeaders.Authorization = AddAuthorization(header);`
	`202`	`+ }`
	`203`	`+ else if (header.Key == "Content-Type")`
	`204`	`+ {`
	`205`	`+ MediaType = header.Value;`
	`206`	`+ client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(MediaType));`
	`207`	`+ }`
	`208`	`+ else`
	`209`	`+ {`
	`210`	`+ client.DefaultRequestHeaders.Add(header.Key, header.Value);`
	`211`	`+ }`
`201`	`212`	`}`
`202`	`213`	`}`
`203`	`214`
`@@ -213,8 +224,7 @@ private async Task<Response> RequestAsync(string method, String request_body = n`
`213`	`224`	`RequestUri = new Uri(endpoint),`
`214`	`225`	`Content = content`
`215`	`226`	`};`
`216`		`- HttpResponseMessage response = await client.SendAsync(request);`
`217`		`- return new Response(response.StatusCode, response.Content, response.Headers);`
	`227`	`+ return await MakeRequest(client, request);`
`218`	`228`
`219`	`229`	`}`
`220`	`230`	`catch (Exception ex)`
Original file line number	Diff line number	Diff line change
`@@ -26,12 +26,13 @@ static void Main(string[] args)`
`26`	`26`	`//Console.WriteLine(response.StatusCode);`
`27`	`27`	`//Console.WriteLine(response.ResponseBody.ReadAsStringAsync().Result);`
`28`	`28`	`//Console.WriteLine(response.ResponseHeaders.ToString());`
`29`		`-`
`30`		`- foreach ( var value in response.DSResponseBody["result"])`
	`29`	`+ var dssResponseBody = response.DeserializeResponseBody(response.ResponseBody);`
	`30`	`+ foreach ( var value in dssResponseBody["result"])`
`31`	`31`	`{`
`32`	`32`	`Console.WriteLine("name: {0}, api_key_id: {1}",value["name"], value["api_key_id"]);`
`33`	`33`	`}`
`34`		`- foreach (var pair in response.DSResponseHeaders)`
	`34`	`+ var dssResponseHeaders = response.DeserializeResponseHeaders(response.ResponseHeaders);`
	`35`	`+ foreach (var pair in dssResponseHeaders)`
`35`	`36`	`{`
`36`	`37`	`Console.WriteLine("{0}: {1}", pair.Key, pair.Value);`
`37`	`38`	`}`