Merge pull request #16 from Mastercard/feature/updating-restsharp

danny-gallagher · web-flow · commit 53f2f54f277b · 2023-03-02T15:04:29.000Z
Updating RestSharp Version
diff --git a/Mastercard.Developer.ClientEncryption.RestSharpV2/Interceptors/RestSharpEncryptionInterceptor.cs b/Mastercard.Developer.ClientEncryption.RestSharpV2/Interceptors/RestSharpEncryptionInterceptor.cs
@@ -1,9 +1,12 @@
 ﻿using System;
 using System.Linq;
+using System.Text.Json;
 using System.Reflection;
 using Mastercard.Developer.ClientEncryption.Core.Encryption;
-using Newtonsoft.Json;
+using Header = RestSharp.HeaderParameter;
 using RestSharp;
+using System.Collections.ObjectModel;
+using System.Collections.Generic;
 
 namespace Mastercard.Developer.ClientEncryption.RestSharpV2.Interceptors
 {
@@ -30,7 +33,7 @@ public static RestSharpEncryptionInterceptor From(EncryptionConfig config)
         /// Encrypt RestSharp request payloads.
         /// </summary>
         /// <param name="request">A RestSharp request object</param>
-        public void InterceptRequest(IRestRequest request)
+        public void InterceptRequest(RestRequest request)
         {
             if (request == null) throw new ArgumentNullException(nameof(request));
 
@@ -50,14 +53,15 @@ public void InterceptRequest(IRestRequest request)
                 var payload = bodyParam.Value;
                 if (!(payload is string))
                 {
-                    payload = request.JsonSerializer.Serialize(payload);
+                    payload = JsonSerializer.Serialize(payload);
                 }
 
                 // Encrypt fields & update headers
                 string encryptedPayload = EncryptPayload(request, payload.ToString());
 
                 // Update body and content length
-                bodyParam.Value = JsonConvert.DeserializeObject(encryptedPayload);
+                request.RemoveParameter(bodyParam);
+                request.AddBody(encryptedPayload);
                 UpdateRequestHeader(request, "Content-Length", encryptedPayload.Length);
             }
             catch (EncryptionException)
@@ -74,7 +78,7 @@ public void InterceptRequest(IRestRequest request)
         /// Decrypt RestSharp response payloads.
         /// </summary>
         /// <param name="response">A RestSharp response object</param>
-        public void InterceptResponse(IRestResponse response)
+        public void InterceptResponse(RestResponse response)
         {
             if (response == null) throw new ArgumentNullException(nameof(response));
 
@@ -109,17 +113,17 @@ public void InterceptResponse(IRestResponse response)
         /// <param name="request">A RestSharp request object</param>
         /// <param name="payload">The payload to be encrypted</param>
         /// <returns>The encrypted payload</returns>
-        internal abstract string EncryptPayload(IRestRequest request, string payload);
+        internal abstract string EncryptPayload(RestRequest request, string payload);
 
         /// <summary>
         /// Decrypt a RestSharp response payload
         /// </summary>
         /// <param name="response">A RestSharp response object</param>
         /// <param name="encryptedPayload">The encrypted payload to be decrypted</param>
         /// <returns>The decrypted payload</returns>
-        internal abstract string DecryptPayload(IRestResponse response, string encryptedPayload);
+        internal abstract string DecryptPayload(RestResponse response, string encryptedPayload);
 
-        internal static void UpdateResponseHeader(IRestResponse response, string name, object value)
+        internal static void UpdateResponseHeader(RestResponse response, string name, object value)
         {
             if (string.IsNullOrEmpty(name))
             {
@@ -128,21 +132,24 @@ internal static void UpdateResponseHeader(IRestResponse response, string name, o
             }
 
             // Scan
-            foreach (Parameter p in response.Headers)
+            List<Header> updatedHeaders = response.Headers.ToList();
+            foreach (Header p in response.Headers)
             {
                 if (p.Name.Equals(name))
                 {
-                    p.Value = value;
+                    updatedHeaders.Remove(p);
+                    updatedHeaders.Add(new Header(name, value.ToString()));
+                    response.Headers = updatedHeaders;
                     return;
                 }
             }
 
             // If we get here, there is no such header, so add one
-            var header = new Parameter(name, value.ToString(), ParameterType.HttpHeader);
-            response.Headers.Add(header);
+            updatedHeaders.Add(new Header(name, value.ToString()));
+            response.Headers = updatedHeaders;
         }
 
-        internal static void UpdateRequestHeader(IRestRequest request, string name, object value)
+        internal static void UpdateRequestHeader(RestRequest request, string name, object value)
         {
             if (string.IsNullOrEmpty(name))
             {
@@ -153,7 +160,7 @@ internal static void UpdateRequestHeader(IRestRequest request, string name, obje
             request.AddHeader(name, value.ToString());
         }
 
-        internal static string ReadAndRemoveHeader(IRestResponse response, string name)
+        internal static string ReadAndRemoveHeader(RestResponse response, string name)
         {
             var header = response.Headers.ToList().Find(h => h.Name == name);
             if (string.IsNullOrEmpty(name) || header == null)
@@ -162,15 +169,8 @@ internal static string ReadAndRemoveHeader(IRestResponse response, string name)
                 return null;
             }
 
-            // The "Headers" collection has been made read only, but we try to remove
-            // the header from the response anyway.
-            var headersField = response.GetType().GetTypeInfo().GetDeclaredField("<Headers>k__BackingField");
-            if (headersField != null)
-            {
-                var updatedHeaders = response.Headers.ToList().FindAll(h => h.Name != name);
-                headersField.SetValue(response, updatedHeaders);
-            }
-
+            var updatedHeaders = response.Headers.ToList().FindAll(h => h.Name != name);
+            response.Headers = updatedHeaders;
             return header.Value?.ToString() ?? string.Empty;
         }
     }
diff --git a/Mastercard.Developer.ClientEncryption.RestSharpV2/Interceptors/RestSharpFieldLevelEncryptionInterceptor.cs b/Mastercard.Developer.ClientEncryption.RestSharpV2/Interceptors/RestSharpFieldLevelEncryptionInterceptor.cs
@@ -25,7 +25,7 @@ public RestSharpFieldLevelEncryptionInterceptor(FieldLevelEncryptionConfig confi
         /// <param name="request">A RestSharp request object</param>
         /// <param name="payload">The payload to be encrypted</param>
         /// <returns>The encrypted payload</returns>
-        internal override string EncryptPayload(IRestRequest request, string payload)
+        internal override string EncryptPayload(RestRequest request, string payload)
         {
             // Encrypt fields & update headers
             string encryptedPayload;
@@ -54,7 +54,7 @@ internal override string EncryptPayload(IRestRequest request, string payload)
         /// <param name="response">A RestSharp response object</param>
         /// <param name="encryptedPayload">The encrypted payload to be decrypted</param>
         /// <returns>The decrypted payload</returns>
-        internal override string DecryptPayload(IRestResponse response, string encryptedPayload)
+        internal override string DecryptPayload(RestResponse response, string encryptedPayload)
         {
             // Decrypt fields & update headers
             string decryptedPayload;
diff --git a/Mastercard.Developer.ClientEncryption.RestSharpV2/Interceptors/RestSharpJweEncryptionInterceptor.cs b/Mastercard.Developer.ClientEncryption.RestSharpV2/Interceptors/RestSharpJweEncryptionInterceptor.cs
@@ -26,7 +26,7 @@ public RestSharpJweEncryptionInterceptor(JweConfig config)
         /// <param name="request">A RestSharp request object</param>
         /// <param name="payload">The payload to be encrypted</param>
         /// <returns>The encrypted payload</returns>
-        internal override string EncryptPayload(IRestRequest request, string payload)
+        internal override string EncryptPayload(RestRequest request, string payload)
         {
             return JweEncryption.EncryptPayload(payload, _config);
         }
@@ -37,7 +37,7 @@ internal override string EncryptPayload(IRestRequest request, string payload)
         /// <param name="response">A RestSharp response object</param>
         /// <param name="encryptedPayload">The encrypted payload to be decrypted</param>
         /// <returns>The decrypted payload</returns>
-        internal override string DecryptPayload(IRestResponse response, string encryptedPayload)
+        internal override string DecryptPayload(RestResponse response, string encryptedPayload)
         {
             return JweEncryption.DecryptPayload(encryptedPayload, _config);
         }
diff --git a/Mastercard.Developer.ClientEncryption.RestSharpV2/Mastercard.Developer.ClientEncryption.RestSharpV2.csproj b/Mastercard.Developer.ClientEncryption.RestSharpV2/Mastercard.Developer.ClientEncryption.RestSharpV2.csproj
@@ -34,7 +34,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="RestSharp" Version="106.12.0" />
+    <PackageReference Include="RestSharp" Version="108.0.3" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/Mastercard.Developer.ClientEncryption.Tests/NetCore2/Interceptors/RestResponseDouble.cs b/Mastercard.Developer.ClientEncryption.Tests/NetCore2/Interceptors/RestResponseDouble.cs
@@ -2,41 +2,41 @@
 using System.Collections.Generic;
 using System.Net;
 using RestSharp;
-using IRestRequest = RestSharp.IRestRequest;
-using IRestResponse = RestSharp.IRestResponse;
-using Parameter = RestSharp.Parameter;
+using RestRequest = RestSharp.RestRequest;
+using RestResponse = RestSharp.RestResponse;
 
 namespace Mastercard.Developer.ClientEncryption.Tests.NetCore.Interceptors
 {
-    internal class RestResponseDouble : IRestResponse
+    internal class RestResponseDouble : RestResponse
     {
-        public IRestRequest Request { get; set; } = null;
-        public Uri ResponseUri { get; set; } = null;
-        public string Server { get; set; }
-        public byte[] RawBytes { get; set; } = null;
-        public string ContentType { get; set; } = null;
-        public long ContentLength { get; set; }
-        public string ContentEncoding { get; set; }
-        public IList<RestResponseCookie> Cookies { get; } = null;
-        public IList<Parameter> Headers { get; }
-        public ResponseStatus ResponseStatus { get; set; }
-        public string ErrorMessage { get; set; }
-        public Exception ErrorException { get; set; }
+        public new RestRequest Request { get; set; } = null;
+        public new Uri ResponseUri { get; set; } = null;
+        public new string Server { get; set; }
+        public new byte[] RawBytes { get; set; } = null;
+        public new string ContentType { get; set; } = null;
+        public new long ContentLength { get; set; }
+        public new string ContentEncoding { get; set; }
+        public new IList<HeaderParameter> Headers { get; }
+        public new ResponseStatus ResponseStatus { get; set; }
+        public new string ErrorMessage { get; set; }
+        public new Exception ErrorException { get; set; }
         public Version ProtocolVersion { get; set; }
-        public HttpStatusCode StatusCode { get; set; } = HttpStatusCode.OK;
-        public bool IsSuccessful => true;
+        public new HttpStatusCode StatusCode { get; set; } = HttpStatusCode.OK;
+        public new bool IsSuccessful => true;
 
-        public string StatusDescription { get; set; } = null;
+        public new string StatusDescription { get; set; } = null;
 
         private Lazy<string> _content;
 
-        public RestResponseDouble(IList<Parameter> headers, string content)
+        public RestResponseDouble(IList<HeaderParameter> headers, string content)
         {
             Headers = headers;
             Content = content;
+            base.Headers = (IReadOnlyCollection<HeaderParameter>)headers;
+            base.Content = content;
         }
 
-        public string Content
+        public new string Content
         {
             get => _content.Value;
             set => _content = new Lazy<string>(() => value);
diff --git a/Mastercard.Developer.ClientEncryption.Tests/NetCore2/Interceptors/RestSharpV2CbcJweEncryptionInterceptorTest.cs b/Mastercard.Developer.ClientEncryption.Tests/NetCore2/Interceptors/RestSharpV2CbcJweEncryptionInterceptorTest.cs
@@ -4,10 +4,10 @@
 using Mastercard.Developer.ClientEncryption.Tests.NetCore.Test;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Method = RestSharp.Method;
-using Parameter = RestSharp.Parameter;
+using Header = RestSharp.HeaderParameter;
 using ParameterType = RestSharp.ParameterType;
 using RestRequest = RestSharp.RestRequest;
-using IRestResponse = RestSharp.IRestResponse;
+using RestSharp;
 
 namespace Mastercard.Developer.ClientEncryption.Tests.NetCore.Interceptors
 {
@@ -36,7 +36,7 @@ public void TestIntercept_ShouldDoNothing_WhenNoPayload()
             // WHEN
             var request = new RestRequest
             {
-                Method = Method.GET,
+                Method = Method.Get,
                 Resource = "/service"
             };
 
@@ -65,7 +65,7 @@ public void TestInterceptResponse_ShouldDecryptWithA128CBC_HS256Encryption()
             TestUtils.AssertPayloadEquals("{\"foo\":\"bar\"}", payload);
             var contentLengthHeaderParam = response.Headers.FirstOrDefault(param => param.Type == ParameterType.HttpHeader);
             Assert.IsNotNull(contentLengthHeaderParam);
-            Assert.AreEqual(payload.Length, contentLengthHeaderParam.Value);
+            Assert.AreEqual(payload.Length.ToString(), contentLengthHeaderParam.Value);
         }
 
         [TestMethod]
@@ -114,9 +114,9 @@ public void TestInterceptResponse_ShouldThrowException_WhenDecryptionFails()
             fixture.InterceptResponse(response);
         }
 
-        internal static IRestResponse RestResponseWithContentLength(string content)
+        internal static RestResponse RestResponseWithContentLength(string content)
         {
-            Parameter[] headers = { new Parameter("Content-Length", content.Length, ParameterType.HttpHeader) };
+            Header[] headers = { new Header("Content-Length", content.Length.ToString()) };
             return new RestResponseDouble(headers, content);
         }
     }
diff --git a/Mastercard.Developer.ClientEncryption.Tests/NetCore2/Interceptors/RestSharpV2FieldLevelEncryptionInterceptorTest.cs b/Mastercard.Developer.ClientEncryption.Tests/NetCore2/Interceptors/RestSharpV2FieldLevelEncryptionInterceptorTest.cs
diff --git a/Mastercard.Developer.ClientEncryption.Tests/NetCore2/Interceptors/RestSharpV2GcmJweEncryptionInterceptorTest.cs b/Mastercard.Developer.ClientEncryption.Tests/NetCore2/Interceptors/RestSharpV2GcmJweEncryptionInterceptorTest.cs

Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,12 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Linq;`
	`3`	`+using System.Text.Json;`
`3`	`4`	`using System.Reflection;`
`4`	`5`	`using Mastercard.Developer.ClientEncryption.Core.Encryption;`
`5`		`-using Newtonsoft.Json;`
	`6`	`+using Header = RestSharp.HeaderParameter;`
`6`	`7`	`using RestSharp;`
	`8`	`+using System.Collections.ObjectModel;`
	`9`	`+using System.Collections.Generic;`
`7`	`10`
`8`	`11`	`namespace Mastercard.Developer.ClientEncryption.RestSharpV2.Interceptors`
`9`	`12`	`{`
`@@ -30,7 +33,7 @@ public static RestSharpEncryptionInterceptor From(EncryptionConfig config)`
`30`	`33`	`/// Encrypt RestSharp request payloads.`
`31`	`34`	`/// </summary>`
`32`	`35`	`/// <param name="request">A RestSharp request object</param>`
`33`		`- public void InterceptRequest(IRestRequest request)`
	`36`	`+ public void InterceptRequest(RestRequest request)`
`34`	`37`	`{`
`35`	`38`	`if (request == null) throw new ArgumentNullException(nameof(request));`
`36`	`39`
`@@ -50,14 +53,15 @@ public void InterceptRequest(IRestRequest request)`
`50`	`53`	`var payload = bodyParam.Value;`
`51`	`54`	`if (!(payload is string))`
`52`	`55`	`{`
`53`		`- payload = request.JsonSerializer.Serialize(payload);`
	`56`	`+ payload = JsonSerializer.Serialize(payload);`
`54`	`57`	`}`
`55`	`58`
`56`	`59`	`// Encrypt fields & update headers`
`57`	`60`	`string encryptedPayload = EncryptPayload(request, payload.ToString());`
`58`	`61`
`59`	`62`	`// Update body and content length`
`60`		`- bodyParam.Value = JsonConvert.DeserializeObject(encryptedPayload);`
	`63`	`+ request.RemoveParameter(bodyParam);`
	`64`	`+ request.AddBody(encryptedPayload);`
`61`	`65`	`UpdateRequestHeader(request, "Content-Length", encryptedPayload.Length);`
`62`	`66`	`}`
`63`	`67`	`catch (EncryptionException)`
`@@ -74,7 +78,7 @@ public void InterceptRequest(IRestRequest request)`
`74`	`78`	`/// Decrypt RestSharp response payloads.`
`75`	`79`	`/// </summary>`
`76`	`80`	`/// <param name="response">A RestSharp response object</param>`
`77`		`- public void InterceptResponse(IRestResponse response)`
	`81`	`+ public void InterceptResponse(RestResponse response)`
`78`	`82`	`{`
`79`	`83`	`if (response == null) throw new ArgumentNullException(nameof(response));`
`80`	`84`
`@@ -109,17 +113,17 @@ public void InterceptResponse(IRestResponse response)`
`109`	`113`	`/// <param name="request">A RestSharp request object</param>`
`110`	`114`	`/// <param name="payload">The payload to be encrypted</param>`
`111`	`115`	`/// <returns>The encrypted payload</returns>`
`112`		`- internal abstract string EncryptPayload(IRestRequest request, string payload);`
	`116`	`+ internal abstract string EncryptPayload(RestRequest request, string payload);`
`113`	`117`
`114`	`118`	`/// <summary>`
`115`	`119`	`/// Decrypt a RestSharp response payload`
`116`	`120`	`/// </summary>`
`117`	`121`	`/// <param name="response">A RestSharp response object</param>`
`118`	`122`	`/// <param name="encryptedPayload">The encrypted payload to be decrypted</param>`
`119`	`123`	`/// <returns>The decrypted payload</returns>`
`120`		`- internal abstract string DecryptPayload(IRestResponse response, string encryptedPayload);`
	`124`	`+ internal abstract string DecryptPayload(RestResponse response, string encryptedPayload);`
`121`	`125`
`122`		`- internal static void UpdateResponseHeader(IRestResponse response, string name, object value)`
	`126`	`+ internal static void UpdateResponseHeader(RestResponse response, string name, object value)`
`123`	`127`	`{`
`124`	`128`	`if (string.IsNullOrEmpty(name))`
`125`	`129`	`{`
`@@ -128,21 +132,24 @@ internal static void UpdateResponseHeader(IRestResponse response, string name, o`
`128`	`132`	`}`
`129`	`133`
`130`	`134`	`// Scan`
`131`		`- foreach (Parameter p in response.Headers)`
	`135`	`+ List<Header> updatedHeaders = response.Headers.ToList();`
	`136`	`+ foreach (Header p in response.Headers)`
`132`	`137`	`{`
`133`	`138`	`if (p.Name.Equals(name))`
`134`	`139`	`{`
`135`		`- p.Value = value;`
	`140`	`+ updatedHeaders.Remove(p);`
	`141`	`+ updatedHeaders.Add(new Header(name, value.ToString()));`
	`142`	`+ response.Headers = updatedHeaders;`
`136`	`143`	`return;`
`137`	`144`	`}`
`138`	`145`	`}`
`139`	`146`
`140`	`147`	`// If we get here, there is no such header, so add one`
`141`		`- var header = new Parameter(name, value.ToString(), ParameterType.HttpHeader);`
`142`		`- response.Headers.Add(header);`
	`148`	`+ updatedHeaders.Add(new Header(name, value.ToString()));`
	`149`	`+ response.Headers = updatedHeaders;`
`143`	`150`	`}`
`144`	`151`
`145`		`- internal static void UpdateRequestHeader(IRestRequest request, string name, object value)`
	`152`	`+ internal static void UpdateRequestHeader(RestRequest request, string name, object value)`
`146`	`153`	`{`
`147`	`154`	`if (string.IsNullOrEmpty(name))`
`148`	`155`	`{`
`@@ -153,7 +160,7 @@ internal static void UpdateRequestHeader(IRestRequest request, string name, obje`
`153`	`160`	`request.AddHeader(name, value.ToString());`
`154`	`161`	`}`
`155`	`162`
`156`		`- internal static string ReadAndRemoveHeader(IRestResponse response, string name)`
	`163`	`+ internal static string ReadAndRemoveHeader(RestResponse response, string name)`
`157`	`164`	`{`
`158`	`165`	`var header = response.Headers.ToList().Find(h => h.Name == name);`
`159`	`166`	`if (string.IsNullOrEmpty(name) \|\| header == null)`
`@@ -162,15 +169,8 @@ internal static string ReadAndRemoveHeader(IRestResponse response, string name)`
`162`	`169`	`return null;`
`163`	`170`	`}`
`164`	`171`
`165`		`- // The "Headers" collection has been made read only, but we try to remove`
`166`		`- // the header from the response anyway.`
`167`		`- var headersField = response.GetType().GetTypeInfo().GetDeclaredField("<Headers>k__BackingField");`
`168`		`- if (headersField != null)`
`169`		`- {`
`170`		`- var updatedHeaders = response.Headers.ToList().FindAll(h => h.Name != name);`
`171`		`- headersField.SetValue(response, updatedHeaders);`
`172`		`- }`
`173`		`-`
	`172`	`+ var updatedHeaders = response.Headers.ToList().FindAll(h => h.Name != name);`
	`173`	`+ response.Headers = updatedHeaders;`
`174`	`174`	`return header.Value?.ToString() ?? string.Empty;`
`175`	`175`	`}`
`176`	`176`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public RestSharpJweEncryptionInterceptor(JweConfig config)`
`26`	`26`	`/// <param name="request">A RestSharp request object</param>`
`27`	`27`	`/// <param name="payload">The payload to be encrypted</param>`
`28`	`28`	`/// <returns>The encrypted payload</returns>`
`29`		`- internal override string EncryptPayload(IRestRequest request, string payload)`
	`29`	`+ internal override string EncryptPayload(RestRequest request, string payload)`
`30`	`30`	`{`
`31`	`31`	`return JweEncryption.EncryptPayload(payload, _config);`
`32`	`32`	`}`
`@@ -37,7 +37,7 @@ internal override string EncryptPayload(IRestRequest request, string payload)`
`37`	`37`	`/// <param name="response">A RestSharp response object</param>`
`38`	`38`	`/// <param name="encryptedPayload">The encrypted payload to be decrypted</param>`
`39`	`39`	`/// <returns>The decrypted payload</returns>`
`40`		`- internal override string DecryptPayload(IRestResponse response, string encryptedPayload)`
	`40`	`+ internal override string DecryptPayload(RestResponse response, string encryptedPayload)`
`41`	`41`	`{`
`42`	`42`	`return JweEncryption.DecryptPayload(encryptedPayload, _config);`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,10 +4,10 @@`
`4`	`4`	`using Mastercard.Developer.ClientEncryption.Tests.NetCore.Test;`
`5`	`5`	`using Microsoft.VisualStudio.TestTools.UnitTesting;`
`6`	`6`	`using Method = RestSharp.Method;`
`7`		`-using Parameter = RestSharp.Parameter;`
	`7`	`+using Header = RestSharp.HeaderParameter;`
`8`	`8`	`using ParameterType = RestSharp.ParameterType;`
`9`	`9`	`using RestRequest = RestSharp.RestRequest;`
`10`		`-using IRestResponse = RestSharp.IRestResponse;`
	`10`	`+using RestSharp;`
`11`	`11`
`12`	`12`	`namespace Mastercard.Developer.ClientEncryption.Tests.NetCore.Interceptors`
`13`	`13`	`{`
`@@ -36,7 +36,7 @@ public void TestIntercept_ShouldDoNothing_WhenNoPayload()`
`36`	`36`	`// WHEN`
`37`	`37`	`var request = new RestRequest`
`38`	`38`	`{`
`39`		`- Method = Method.GET,`
	`39`	`+ Method = Method.Get,`
`40`	`40`	`Resource = "/service"`
`41`	`41`	`};`
`42`	`42`
`@@ -65,7 +65,7 @@ public void TestInterceptResponse_ShouldDecryptWithA128CBC_HS256Encryption()`
`65`	`65`	`TestUtils.AssertPayloadEquals("{\"foo\":\"bar\"}", payload);`
`66`	`66`	`var contentLengthHeaderParam = response.Headers.FirstOrDefault(param => param.Type == ParameterType.HttpHeader);`
`67`	`67`	`Assert.IsNotNull(contentLengthHeaderParam);`
`68`		`- Assert.AreEqual(payload.Length, contentLengthHeaderParam.Value);`
	`68`	`+ Assert.AreEqual(payload.Length.ToString(), contentLengthHeaderParam.Value);`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`[TestMethod]`
`@@ -114,9 +114,9 @@ public void TestInterceptResponse_ShouldThrowException_WhenDecryptionFails()`
`114`	`114`	`fixture.InterceptResponse(response);`
`115`	`115`	`}`
`116`	`116`
`117`		`- internal static IRestResponse RestResponseWithContentLength(string content)`
	`117`	`+ internal static RestResponse RestResponseWithContentLength(string content)`
`118`	`118`	`{`
`119`		`- Parameter[] headers = { new Parameter("Content-Length", content.Length, ParameterType.HttpHeader) };`
	`119`	`+ Header[] headers = { new Header("Content-Length", content.Length.ToString()) };`
`120`	`120`	`return new RestResponseDouble(headers, content);`
`121`	`121`	`}`
`122`	`122`	`}`