Edited the IRestClient to have the execute functions return IRestResponse

jmartin84 · jmartin84 · commit c952138c8367 · 2012-03-03T13:09:25.000-06:00
instead of the derived type to allow for more natural mocking without
having to cast the mock object and added an extension method for
converting responses to generic reponses

 	modified:   RestSharp/Deserializers/DotNetXmlDeserializer.cs
 	modified:   RestSharp/Deserializers/IDeserializer.cs
 	modified:   RestSharp/Deserializers/JsonDeserializer.cs
 	modified:   RestSharp/Deserializers/XmlAttributeDeserializer.cs
 	modified:   RestSharp/Deserializers/XmlDeserializer.cs
 	new file:   RestSharp/Extensions/ResponseExtensions.cs
 	modified:   RestSharp/IRestClient.cs
 	modified:   RestSharp/RestClient.Async.cs
 	modified:   RestSharp/RestClient.Sync.cs
 	modified:   RestSharp/RestClient.cs
 	modified:   RestSharp/RestClientExtensions.cs
 	modified:   RestSharp/RestResponse.cs
 	modified:   RestSharp/RestSharp.csproj
diff --git a/RestSharp/Deserializers/DotNetXmlDeserializer.cs b/RestSharp/Deserializers/DotNetXmlDeserializer.cs
@@ -30,7 +30,7 @@ public class DotNetXmlDeserializer : IDeserializer
 
 		public string RootElement { get; set; }
 
-		public T Deserialize<T>(RestResponse response) where T : new()
+		public T Deserialize<T>(IRestResponse response) where T : new()
 		{
 			if (string.IsNullOrEmpty(response.Content))
 			{
diff --git a/RestSharp/Deserializers/IDeserializer.cs b/RestSharp/Deserializers/IDeserializer.cs
@@ -18,7 +18,7 @@ namespace RestSharp.Deserializers
 {
 	public interface IDeserializer
 	{
-		T Deserialize<T>(RestResponse response) where T : new();
+		T Deserialize<T>(IRestResponse response) where T : new();
 		string RootElement { get; set; }
 		string Namespace { get; set; }
 		string DateFormat { get; set; }
diff --git a/RestSharp/Deserializers/JsonDeserializer.cs b/RestSharp/Deserializers/JsonDeserializer.cs
@@ -37,7 +37,7 @@ public JsonDeserializer()
 			Culture = CultureInfo.InvariantCulture;
 		}
 
-		public T Deserialize<T>(RestResponse response) where T : new()
+		public T Deserialize<T>(IRestResponse response) where T : new()
 		{
 			var target = new T();
 
diff --git a/RestSharp/Deserializers/XmlAttributeDeserializer.cs b/RestSharp/Deserializers/XmlAttributeDeserializer.cs
@@ -37,7 +37,7 @@ public XmlAttributeDeserializer()
 			Culture = CultureInfo.InvariantCulture;
 		}
 
-		public T Deserialize<T>(RestResponse response) where T : new()
+		public T Deserialize<T>(IRestResponse response) where T : new()
 		{
 			if (response.Content == null)
 				return default(T);
diff --git a/RestSharp/Deserializers/XmlDeserializer.cs b/RestSharp/Deserializers/XmlDeserializer.cs
@@ -38,7 +38,7 @@ public XmlDeserializer()
 			Culture = CultureInfo.InvariantCulture;
 		}
 
-		public T Deserialize<T>(RestResponse response) where T : new()
+		public T Deserialize<T>(IRestResponse response) where T : new()
 		{
 			if (string.IsNullOrEmpty( response.Content ))
 				return default(T);
diff --git a/RestSharp/Extensions/ResponseExtensions.cs b/RestSharp/Extensions/ResponseExtensions.cs
@@ -0,0 +1,29 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace RestSharp.Extensions
+{
+    public static class ResponseExtensions
+    {
+        public static IRestResponse<T> toAsyncResponse<T>(this IRestResponse response) where T : new()
+        {
+            return new RestResponse<T>
+            {
+                ContentEncoding = response.ContentEncoding,
+                ContentLength = response.ContentLength,
+                ContentType = response.ContentType,
+                Cookies = response.Cookies,
+                ErrorMessage = response.ErrorMessage,
+                Headers = response.Headers,
+                RawBytes = response.RawBytes,
+                ResponseStatus = response.ResponseStatus,
+                ResponseUri = response.ResponseUri,
+                Server = response.Server,
+                StatusCode = response.StatusCode,
+                StatusDescription = response.StatusDescription
+            };
+        }
+    }
+}
diff --git a/RestSharp/IRestClient.cs b/RestSharp/IRestClient.cs
@@ -58,20 +58,20 @@ public interface IRestClient
 		/// 
 		/// </summary>
 		/// <param name="request"></param>
-		RestRequestAsyncHandle ExecuteAsync(IRestRequest request, Action<RestResponse, RestRequestAsyncHandle> callback);
+		RestRequestAsyncHandle ExecuteAsync(IRestRequest request, Action<IRestResponse, RestRequestAsyncHandle> callback);
 		/// <summary>
 		/// 
 		/// </summary>
 		/// <param name="request"></param>
-		RestRequestAsyncHandle ExecuteAsync<T>(IRestRequest request, Action<RestResponse<T>, RestRequestAsyncHandle> callback) where T : new();
+		RestRequestAsyncHandle ExecuteAsync<T>(IRestRequest request, Action<IRestResponse<T>, RestRequestAsyncHandle> callback) where T : new();
 
 #if FRAMEWORK
 		/// <summary>
 		/// X509CertificateCollection to be sent with request
 		/// </summary>
 		X509CertificateCollection ClientCertificates { get; set; }
-		RestResponse Execute(IRestRequest request);
-		RestResponse<T> Execute<T>(IRestRequest request) where T : new();
+		IRestResponse Execute(IRestRequest request);
+		IRestResponse<T> Execute<T>(IRestRequest request) where T : new();
 		
 		IWebProxy Proxy { get; set; }
 #endif
diff --git a/RestSharp/RestClient.Async.cs b/RestSharp/RestClient.Async.cs
@@ -30,7 +30,7 @@ public partial class RestClient
 		/// </summary>
 		/// <param name="request">Request to be executed</param>
 		/// <param name="callback">Callback function to be executed upon completion providing access to the async handle.</param>
-		public virtual RestRequestAsyncHandle ExecuteAsync(IRestRequest request, Action<RestResponse, RestRequestAsyncHandle> callback)
+		public virtual RestRequestAsyncHandle ExecuteAsync(IRestRequest request, Action<IRestResponse, RestRequestAsyncHandle> callback)
 		{
 			var http = HttpFactory.Create();
 			AuthenticateIfNeeded(this, request);
@@ -82,7 +82,7 @@ public virtual RestRequestAsyncHandle ExecuteAsync(IRestRequest request, Action<
 			return asyncHandle;
 		}
 
-		private void ProcessResponse(HttpResponse httpResponse, RestRequestAsyncHandle asyncHandle, Action<RestResponse, RestRequestAsyncHandle> callback)
+		private void ProcessResponse(HttpResponse httpResponse, RestRequestAsyncHandle asyncHandle, Action<IRestResponse, RestRequestAsyncHandle> callback)
 		{
 			var restResponse = ConvertToRestResponse(httpResponse);
 			callback(restResponse, asyncHandle);
@@ -94,11 +94,11 @@ private void ProcessResponse(HttpResponse httpResponse, RestRequestAsyncHandle a
 		/// <typeparam name="T">Target deserialization type</typeparam>
 		/// <param name="request">Request to be executed</param>
 		/// <param name="callback">Callback function to be executed upon completion</param>
-		public virtual RestRequestAsyncHandle ExecuteAsync<T>(IRestRequest request, Action<RestResponse<T>, RestRequestAsyncHandle> callback) where T : new()
+		public virtual RestRequestAsyncHandle ExecuteAsync<T>(IRestRequest request, Action<IRestResponse<T>, RestRequestAsyncHandle> callback) where T : new()
 		{
 			return ExecuteAsync(request, (response, asyncHandle) =>
 			{
-				var restResponse = (RestResponse<T>)response;
+				var restResponse = (IRestResponse<T>)response;
 				if (response.ResponseStatus != ResponseStatus.Aborted)
 				{
 					restResponse = Deserialize<T>(request, response);
diff --git a/RestSharp/RestClient.Sync.cs b/RestSharp/RestClient.Sync.cs
@@ -33,15 +33,15 @@ public byte[] DownloadData(IRestRequest request)
 		/// </summary>
 		/// <param name="request">Request to be executed</param>
 		/// <returns>RestResponse</returns>
-		public virtual RestResponse Execute(IRestRequest request)
+		public virtual IRestResponse Execute(IRestRequest request)
 		{
 			AuthenticateIfNeeded(this, request);
 
 			// add Accept header based on registered deserializers
 			var accepts = string.Join(", ", AcceptTypes.ToArray());
 			AddDefaultParameter("Accept", accepts, ParameterType.HttpHeader);
 
-			var response = new RestResponse();
+			IRestResponse response = new RestResponse();
 			try
 			{
 				response = GetResponse(request);
@@ -65,13 +65,13 @@ public virtual RestResponse Execute(IRestRequest request)
 		/// <typeparam name="T">Target deserialization type</typeparam>
 		/// <param name="request">Request to execute</param>
 		/// <returns>RestResponse[[T]] with deserialized data in Data property</returns>
-		public virtual RestResponse<T> Execute<T>(IRestRequest request) where T : new()
+		public virtual IRestResponse<T> Execute<T>(IRestRequest request) where T : new()
 		{
 			var raw = Execute(request);
 			return Deserialize<T>(request, raw);
 		}
 		
-		private RestResponse GetResponse(IRestRequest request)
+		private IRestResponse GetResponse(IRestRequest request)
 		{
 			var http = HttpFactory.Create();
 
diff --git a/RestSharp/RestClient.cs b/RestSharp/RestClient.cs
@@ -488,7 +488,7 @@ private RestResponse ConvertToRestResponse(HttpResponse httpResponse)
 			return restResponse;
 		}
 
-		private RestResponse<T> Deserialize<T>(IRestRequest request, RestResponse raw) where T : new()
+		private IRestResponse<T> Deserialize<T>(IRestRequest request, IRestResponse raw) where T : new()
 		{
 			request.OnBeforeDeserialization(raw);
 
@@ -497,10 +497,10 @@ private RestResponse ConvertToRestResponse(HttpResponse httpResponse)
 			handler.DateFormat = request.DateFormat;
 			handler.Namespace = request.XmlNamespace;
 
-			var response = new RestResponse<T>();
+			IRestResponse<T> response = new RestResponse<T>();
 			try
 			{
-				response = (RestResponse<T>)raw;
+			    response = raw.toAsyncResponse<T>();
 				response.Data = handler.Deserialize<T>(raw);
 			}
 			catch (Exception ex)
diff --git a/RestSharp/RestClientExtensions.cs b/RestSharp/RestClientExtensions.cs
@@ -10,7 +10,7 @@ public static class RestClientExtensions
         /// <param name="client">The IRestClient this method extends</param>
         /// <param name="request">Request to be executed</param>
         /// <param name="callback">Callback function to be executed upon completion</param>
-        public static RestRequestAsyncHandle ExecuteAsync(this IRestClient client, IRestRequest request, Action<RestResponse> callback)
+        public static RestRequestAsyncHandle ExecuteAsync(this IRestClient client, IRestRequest request, Action<IRestResponse> callback)
         {
             return client.ExecuteAsync(request, (response, handle) => callback(response));
         }
@@ -22,7 +22,7 @@ public static RestRequestAsyncHandle ExecuteAsync(this IRestClient client, IRest
         /// <typeparam name="T">Target deserialization type</typeparam>
         /// <param name="request">Request to be executed</param>
         /// <param name="callback">Callback function to be executed upon completion providing access to the async handle</param>
-        public static RestRequestAsyncHandle ExecuteAsync<T>(this IRestClient client, IRestRequest request, Action<RestResponse<T>> callback) where T : new()
+        public static RestRequestAsyncHandle ExecuteAsync<T>(this IRestClient client, IRestRequest request, Action<IRestResponse<T>> callback) where T : new()
         {
             return client.ExecuteAsync<T>(request, (response, asyncHandle) => callback(response));
         }
diff --git a/RestSharp/RestResponse.cs b/RestSharp/RestResponse.cs
@@ -96,11 +96,11 @@ public string Content
 		/// <summary>
 		/// Cookies returned by server with the response
 		/// </summary>
-		public IList<RestResponseCookie> Cookies { get; protected set; }
+		public IList<RestResponseCookie> Cookies { get; protected internal set; }
 		/// <summary>
 		/// Headers returned by server with the response
 		/// </summary>
-		public IList<Parameter> Headers { get; protected set; }
+		public IList<Parameter> Headers { get; protected internal set; }
 
 		private ResponseStatus _responseStatus = ResponseStatus.None;
 		/// <summary>
@@ -159,6 +159,7 @@ public static explicit operator RestResponse<T>(RestResponse response)
 				StatusDescription = response.StatusDescription
 			};
 		}
+        
 	}
 
 	/// <summary>
diff --git a/RestSharp/RestSharp.csproj b/RestSharp/RestSharp.csproj
@@ -107,6 +107,7 @@
     <Compile Include="Extensions\MonoHttp\Helpers.cs" />
     <Compile Include="Extensions\MonoHttp\HtmlEncoder.cs" />
     <Compile Include="Extensions\MonoHttp\HttpUtility.cs" />
+    <Compile Include="Extensions\ResponseExtensions.cs" />
     <Compile Include="RestClientExtensions.cs" />
     <Compile Include="Extensions\StringExtensions.cs" />
     <Compile Include="Http.Sync.cs" />

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public class DotNetXmlDeserializer : IDeserializer`
`30`	`30`
`31`	`31`	`public string RootElement { get; set; }`
`32`	`32`
`33`		`- public T Deserialize<T>(RestResponse response) where T : new()`
	`33`	`+ public T Deserialize<T>(IRestResponse response) where T : new()`
`34`	`34`	`{`
`35`	`35`	`if (string.IsNullOrEmpty(response.Content))`
`36`	`36`	`{`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ namespace RestSharp.Deserializers`
`18`	`18`	`{`
`19`	`19`	`public interface IDeserializer`
`20`	`20`	`{`
`21`		`- T Deserialize<T>(RestResponse response) where T : new();`
	`21`	`+ T Deserialize<T>(IRestResponse response) where T : new();`
`22`	`22`	`string RootElement { get; set; }`
`23`	`23`	`string Namespace { get; set; }`
`24`	`24`	`string DateFormat { get; set; }`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ public JsonDeserializer()`
`37`	`37`	`Culture = CultureInfo.InvariantCulture;`
`38`	`38`	`}`
`39`	`39`
`40`		`- public T Deserialize<T>(RestResponse response) where T : new()`
	`40`	`+ public T Deserialize<T>(IRestResponse response) where T : new()`
`41`	`41`	`{`
`42`	`42`	`var target = new T();`
`43`	`43`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ public XmlAttributeDeserializer()`
`37`	`37`	`Culture = CultureInfo.InvariantCulture;`
`38`	`38`	`}`
`39`	`39`
`40`		`- public T Deserialize<T>(RestResponse response) where T : new()`
	`40`	`+ public T Deserialize<T>(IRestResponse response) where T : new()`
`41`	`41`	`{`
`42`	`42`	`if (response.Content == null)`
`43`	`43`	`return default(T);`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public XmlDeserializer()`
`38`	`38`	`Culture = CultureInfo.InvariantCulture;`
`39`	`39`	`}`
`40`	`40`
`41`		`- public T Deserialize<T>(RestResponse response) where T : new()`
	`41`	`+ public T Deserialize<T>(IRestResponse response) where T : new()`
`42`	`42`	`{`
`43`	`43`	`if (string.IsNullOrEmpty( response.Content ))`
`44`	`44`	`return default(T);`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public partial class RestClient`
`30`	`30`	`/// </summary>`
`31`	`31`	`/// <param name="request">Request to be executed</param>`
`32`	`32`	`/// <param name="callback">Callback function to be executed upon completion providing access to the async handle.</param>`
`33`		`- public virtual RestRequestAsyncHandle ExecuteAsync(IRestRequest request, Action<RestResponse, RestRequestAsyncHandle> callback)`
	`33`	`+ public virtual RestRequestAsyncHandle ExecuteAsync(IRestRequest request, Action<IRestResponse, RestRequestAsyncHandle> callback)`
`34`	`34`	`{`
`35`	`35`	`var http = HttpFactory.Create();`
`36`	`36`	`AuthenticateIfNeeded(this, request);`
`@@ -82,7 +82,7 @@ public virtual RestRequestAsyncHandle ExecuteAsync(IRestRequest request, Action<`
`82`	`82`	`return asyncHandle;`
`83`	`83`	`}`
`84`	`84`
`85`		`- private void ProcessResponse(HttpResponse httpResponse, RestRequestAsyncHandle asyncHandle, Action<RestResponse, RestRequestAsyncHandle> callback)`
	`85`	`+ private void ProcessResponse(HttpResponse httpResponse, RestRequestAsyncHandle asyncHandle, Action<IRestResponse, RestRequestAsyncHandle> callback)`
`86`	`86`	`{`
`87`	`87`	`var restResponse = ConvertToRestResponse(httpResponse);`
`88`	`88`	`callback(restResponse, asyncHandle);`
`@@ -94,11 +94,11 @@ private void ProcessResponse(HttpResponse httpResponse, RestRequestAsyncHandle a`
`94`	`94`	`/// <typeparam name="T">Target deserialization type</typeparam>`
`95`	`95`	`/// <param name="request">Request to be executed</param>`
`96`	`96`	`/// <param name="callback">Callback function to be executed upon completion</param>`
`97`		`- public virtual RestRequestAsyncHandle ExecuteAsync<T>(IRestRequest request, Action<RestResponse<T>, RestRequestAsyncHandle> callback) where T : new()`
	`97`	`+ public virtual RestRequestAsyncHandle ExecuteAsync<T>(IRestRequest request, Action<IRestResponse<T>, RestRequestAsyncHandle> callback) where T : new()`
`98`	`98`	`{`
`99`	`99`	`return ExecuteAsync(request, (response, asyncHandle) =>`
`100`	`100`	`{`
`101`		`- var restResponse = (RestResponse<T>)response;`
	`101`	`+ var restResponse = (IRestResponse<T>)response;`
`102`	`102`	`if (response.ResponseStatus != ResponseStatus.Aborted)`
`103`	`103`	`{`
`104`	`104`	`restResponse = Deserialize<T>(request, response);`
Original file line number	Diff line number	Diff line change
`@@ -33,15 +33,15 @@ public byte[] DownloadData(IRestRequest request)`
`33`	`33`	`/// </summary>`
`34`	`34`	`/// <param name="request">Request to be executed</param>`
`35`	`35`	`/// <returns>RestResponse</returns>`
`36`		`- public virtual RestResponse Execute(IRestRequest request)`
	`36`	`+ public virtual IRestResponse Execute(IRestRequest request)`
`37`	`37`	`{`
`38`	`38`	`AuthenticateIfNeeded(this, request);`
`39`	`39`
`40`	`40`	`// add Accept header based on registered deserializers`
`41`	`41`	`var accepts = string.Join(", ", AcceptTypes.ToArray());`
`42`	`42`	`AddDefaultParameter("Accept", accepts, ParameterType.HttpHeader);`
`43`	`43`
`44`		`- var response = new RestResponse();`
	`44`	`+ IRestResponse response = new RestResponse();`
`45`	`45`	`try`
`46`	`46`	`{`
`47`	`47`	`response = GetResponse(request);`
`@@ -65,13 +65,13 @@ public virtual RestResponse Execute(IRestRequest request)`
`65`	`65`	`/// <typeparam name="T">Target deserialization type</typeparam>`
`66`	`66`	`/// <param name="request">Request to execute</param>`
`67`	`67`	`/// <returns>RestResponse[[T]] with deserialized data in Data property</returns>`
`68`		`- public virtual RestResponse<T> Execute<T>(IRestRequest request) where T : new()`
	`68`	`+ public virtual IRestResponse<T> Execute<T>(IRestRequest request) where T : new()`
`69`	`69`	`{`
`70`	`70`	`var raw = Execute(request);`
`71`	`71`	`return Deserialize<T>(request, raw);`
`72`	`72`	`}`
`73`	`73`
`74`		`- private RestResponse GetResponse(IRestRequest request)`
	`74`	`+ private IRestResponse GetResponse(IRestRequest request)`
`75`	`75`	`{`
`76`	`76`	`var http = HttpFactory.Create();`
`77`	`77`
Original file line number	Diff line number	Diff line change
`@@ -488,7 +488,7 @@ private RestResponse ConvertToRestResponse(HttpResponse httpResponse)`
`488`	`488`	`return restResponse;`
`489`	`489`	`}`
`490`	`490`
`491`		`- private RestResponse<T> Deserialize<T>(IRestRequest request, RestResponse raw) where T : new()`
	`491`	`+ private IRestResponse<T> Deserialize<T>(IRestRequest request, IRestResponse raw) where T : new()`
`492`	`492`	`{`
`493`	`493`	`request.OnBeforeDeserialization(raw);`
`494`	`494`
`@@ -497,10 +497,10 @@ private RestResponse ConvertToRestResponse(HttpResponse httpResponse)`
`497`	`497`	`handler.DateFormat = request.DateFormat;`
`498`	`498`	`handler.Namespace = request.XmlNamespace;`
`499`	`499`
`500`		`- var response = new RestResponse<T>();`
	`500`	`+ IRestResponse<T> response = new RestResponse<T>();`
`501`	`501`	`try`
`502`	`502`	`{`
`503`		`- response = (RestResponse<T>)raw;`
	`503`	`+ response = raw.toAsyncResponse<T>();`
`504`	`504`	`response.Data = handler.Deserialize<T>(raw);`
`505`	`505`	`}`
`506`	`506`	`catch (Exception ex)`