Fixing bugs after exception handling changed

alexeyzimarev · alexeyzimarev · commit 95f1324207d6 · 2022-01-17T13:57:19.000+01:00
diff --git a/docs/support/README.md b/docs/support/README.md
@@ -62,7 +62,7 @@ Here are contribution guidelines:
  - No licence header for tested.
  - Code must build for .NET Standard 2.0, .NET 5, and .NET 6.
  - Test must run on .NET 6.
- - Use `autocrlf=true` (`git config --global core.autocrlf true` [http://help.github.com/dealing-with-lineendings/])
+ - Use `autocrlf=true` (`git config --global core.autocrlf true`)
  
 ### Sponsor
  
diff --git a/src/RestSharp.Serializers.Xml/XmlDeserializer.cs b/src/RestSharp.Serializers.Xml/XmlDeserializer.cs
@@ -37,11 +37,12 @@ public class XmlDeserializer : IXmlDeserializer, IWithRootElement, IWithDateForm
         if (string.IsNullOrEmpty(response.Content))
             return default;
 
-        var doc  = XDocument.Parse(response.Content);
-        var root = doc.Root;
+        var doc         = XDocument.Parse(response.Content);
+        var root        = doc.Root;
+        var rootElement = response.RootElement ?? RootElement;
 
-        if (RootElement != null && doc.Root != null)
-            root = doc.Root.DescendantsAndSelf(RootElement.AsNamespaced(Namespace)).SingleOrDefault();
+        if (rootElement != null && doc.Root != null)
+            root = doc.Root.DescendantsAndSelf(rootElement.AsNamespaced(Namespace)).SingleOrDefault();
 
         // autodetect xml namespace
         if (Namespace.IsEmpty())
diff --git a/src/RestSharp/Parameters/FileParameter.cs b/src/RestSharp/Parameters/FileParameter.cs
@@ -43,7 +43,7 @@ public record FileParameter {
         Name          = name;
         FileName      = fileName;
         GetFile       = getFile;
-        ContentType   = contentType ?? "application/octet-stream";
+        ContentType   = contentType ?? Serializers.ContentType.Binary;
     }
 
     /// <summary>
@@ -80,7 +80,7 @@ public static FileParameter Create(
         string       fileName,
         string?      contentType = null
     )
-        => new(name, fileName, getFile, contentType ?? Serializers.ContentType.File);
+        => new(name, fileName, getFile, contentType ?? Serializers.ContentType.Binary);
 
     public static FileParameter FromFile(string fullPath, string? name = null, string? contentType = null) {
         if (!File.Exists(Ensure.NotEmptyString(fullPath, nameof(fullPath))))
diff --git a/src/RestSharp/Request/RestRequestExtensions.cs b/src/RestSharp/Request/RestRequestExtensions.cs
@@ -304,14 +304,16 @@ public static RestRequest AddFile(
     public static RestRequest AddBody(this RestRequest request, object obj, string? contentType = null) {
         if (contentType == null) {
             return request.RequestFormat switch {
-                DataFormat.Json => request.AddJsonBody(obj, contentType ?? ContentType.Json),
-                DataFormat.Xml  => request.AddXmlBody(obj, contentType ?? ContentType.Xml),
-                _               => request.AddParameter(new BodyParameter("", obj.ToString()!, contentType ?? ContentType.Plain))
+                DataFormat.Json   => request.AddJsonBody(obj, contentType ?? ContentType.Json),
+                DataFormat.Xml    => request.AddXmlBody(obj, contentType ?? ContentType.Xml),
+                DataFormat.Binary => request.AddParameter(new BodyParameter("", obj, contentType ?? ContentType.Binary)),
+                _                 => request.AddParameter(new BodyParameter("", obj.ToString()!, contentType ?? ContentType.Plain))
             };
         }
 
         return
             obj is string str            ? request.AddParameter(new BodyParameter("", str, contentType)) :
+            obj is byte[] bytes          ? request.AddParameter(new BodyParameter("", bytes, contentType)) :
             contentType.Contains("xml")  ? request.AddXmlBody(obj, contentType) :
             contentType.Contains("json") ? request.AddJsonBody(obj, contentType) :
                                            throw new ArgumentException("Non-string body found with unsupported content type", nameof(obj));
diff --git a/src/RestSharp/Response/RestResponse.cs b/src/RestSharp/Response/RestResponse.cs
@@ -50,7 +50,8 @@ public static RestResponse<T> FromResponse(RestResponse response)
             Server            = response.Server,
             StatusCode        = response.StatusCode,
             StatusDescription = response.StatusDescription,
-            Request           = response.Request
+            Request           = response.Request,
+            RootElement       = response.RootElement
         };
 }
 
@@ -92,13 +93,18 @@ async Task<RestResponse> GetDefaultResponse() {
                 Request           = request,
                 Headers           = httpResponse.Headers.GetHeaderParameters(),
                 ContentHeaders    = httpResponse.Content.Headers.GetHeaderParameters(),
-                Cookies           = cookieCollection
+                Cookies           = cookieCollection,
+                RootElement       = request.RootElement
             };
 
             Exception? MaybeException()
                 => httpResponse.IsSuccessStatusCode
                     ? null
+#if NETSTANDARD
                     : new HttpRequestException($"Request failed with status code {httpResponse.StatusCode}");
+#else
+                    : new HttpRequestException($"Request failed with status code {httpResponse.StatusCode}", null, httpResponse.StatusCode);
+#endif
 
             Task<Stream?> ReadResponse() => httpResponse.ReadResponse(cancellationToken);
 
diff --git a/src/RestSharp/Response/RestResponseBase.cs b/src/RestSharp/Response/RestResponseBase.cs
@@ -120,6 +120,11 @@ public abstract class RestResponseBase {
     /// HTTP protocol version of the request
     /// </summary>
     public Version? Version { get; set; }
+    
+    /// <summary>
+    /// Root element of the serialized response content, only works if deserializer supports it 
+    /// </summary>
+    public string? RootElement { get; set; }
 
     /// <summary>
     /// Assists with debugging responses by displaying in the debugger output
diff --git a/src/RestSharp/RestClient.Async.cs b/src/RestSharp/RestClient.Async.cs
@@ -134,11 +134,13 @@ static RestResponse AddError(RestResponse response, Exception exception, Cancell
         return response;
     }
 
-    static RestResponse ThrowIfError(RestResponse response) {
+    internal static RestResponse ThrowIfError(RestResponse response) {
         var exception = response.GetException();
-        return exception != null ? throw exception : response;
-    }
+        if (exception != null) throw exception;
 
+        return response;
+    }
+    
     static HttpMethod AsHttpMethod(Method method)
         => method switch {
             Method.Get     => HttpMethod.Get,
diff --git a/src/RestSharp/RestClient.Serialization.cs b/src/RestSharp/RestClient.Serialization.cs
@@ -54,7 +54,7 @@ internal RestResponse<T> Deserialize<T>(RestRequest request, RestResponse raw) {
             // Only attempt to deserialize if the request has not errored due
             // to a transport or framework exception.  HTTP errors should attempt to
             // be deserialized
-            if (response.ErrorException == null) {
+            if (response.Content != null) {
                 var handler = GetContentDeserializer(raw, request.RequestFormat);
 
                 // Only continue if there is a handler defined else there is no way to deserialize the data.
diff --git a/src/RestSharp/RestClient.cs b/src/RestSharp/RestClient.cs
@@ -25,10 +25,14 @@ namespace RestSharp;
 /// <summary>
 /// Client to translate RestRequests into Http requests and process response result
 /// </summary>
-public partial class RestClient {
+public partial class RestClient : IDisposable {
     public CookieContainer CookieContainer { get; }
 
-    public string[] AcceptedContentTypes { get; private set; } = null!;
+    /// <summary>
+    /// Content types that will be sent in the Accept header. The list is populated from the known serializers.
+    /// If you need to send something else by default, set this property to a different value.
+    /// </summary>
+    public string[] AcceptedContentTypes { get; set; } = null!;
 
     HttpClient HttpClient { get; }
 
@@ -168,7 +172,9 @@ void DoBuildUriValidations(RestRequest request) {
         if (Options.BaseUrl == null && !request.Resource.ToLowerInvariant().StartsWith("http"))
             throw new ArgumentOutOfRangeException(
                 nameof(request),
-                "Request resource doesn't contain a valid scheme for an empty client base URL"
+                "Request resource doesn't contain a valid scheme for an empty base URL of the client"
             );
     }
+
+    public void Dispose() => HttpClient.Dispose();
 }
diff --git a/src/RestSharp/RestClientExtensions.Json.cs b/src/RestSharp/RestClientExtensions.Json.cs
@@ -108,7 +108,7 @@ public static async Task<HttpStatusCode> PostJsonAsync<TRequest>(
         TRequest          request,
         CancellationToken cancellationToken = default
     ) where TRequest : class {
-        var restRequest = new RestRequest().AddJsonBody(request);
+        var restRequest = new RestRequest(resource).AddJsonBody(request);
         return client.PutAsync<TResponse>(restRequest, cancellationToken);
     }
 
diff --git a/src/RestSharp/RestClientExtensions.cs b/src/RestSharp/RestClientExtensions.cs
@@ -156,13 +156,13 @@ public static Task<RestResponse<T>> ExecuteAsync<T>(
     /// <returns></returns>
     public static async Task<T?> GetAsync<T>(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteGetAsync<T>(request, cancellationToken).ConfigureAwait(false);
-        ThrowIfError(response);
+        RestClient.ThrowIfError(response);
         return response.Data;
     }
 
     public static async Task<RestResponse> GetAsync(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteGetAsync(request, cancellationToken).ConfigureAwait(false);
-        ThrowIfError(response);
+        RestClient.ThrowIfError(response);
         return response;
     }
 
@@ -177,13 +177,13 @@ public static async Task<RestResponse> GetAsync(this RestClient client, RestRequ
     /// <returns></returns>
     public static async Task<T?> PostAsync<T>(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecutePostAsync<T>(request, cancellationToken).ConfigureAwait(false);
-        ThrowIfError(response);
+        RestClient.ThrowIfError(response);
         return response.Data;
     }
 
     public static async Task<RestResponse> PostAsync(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecutePostAsync(request, cancellationToken).ConfigureAwait(false);
-        ThrowIfError(response);
+        RestClient.ThrowIfError(response);
         return response;
     }
 
@@ -198,13 +198,13 @@ public static async Task<RestResponse> PostAsync(this RestClient client, RestReq
     /// <returns></returns>
     public static async Task<T?> PutAsync<T>(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteAsync<T>(request, Method.Put, cancellationToken).ConfigureAwait(false);
-        ThrowIfError(response);
+        RestClient.ThrowIfError(response);
         return response.Data;
     }
 
     public static async Task<RestResponse> PutAsync(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteAsync(request, Method.Put, cancellationToken).ConfigureAwait(false);
-        ThrowIfError(response);
+        RestClient.ThrowIfError(response);
         return response;
     }
 
@@ -219,13 +219,13 @@ public static async Task<RestResponse> PutAsync(this RestClient client, RestRequ
     /// <returns></returns>
     public static async Task<T?> HeadAsync<T>(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteAsync<T>(request, Method.Head, cancellationToken).ConfigureAwait(false);
-        ThrowIfError(response);
+        RestClient.ThrowIfError(response);
         return response.Data;
     }
 
     public static async Task<RestResponse> HeadAsync(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteAsync(request, Method.Head, cancellationToken).ConfigureAwait(false);
-        ThrowIfError(response);
+        RestClient.ThrowIfError(response);
         return response;
     }
 
@@ -240,13 +240,13 @@ public static async Task<RestResponse> HeadAsync(this RestClient client, RestReq
     /// <returns></returns>
     public static async Task<T?> OptionsAsync<T>(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteAsync<T>(request, Method.Options, cancellationToken).ConfigureAwait(false);
-        ThrowIfError(response);
+        RestClient.ThrowIfError(response);
         return response.Data;
     }
 
     public static async Task<RestResponse> OptionsAsync(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteAsync(request, Method.Options, cancellationToken).ConfigureAwait(false);
-        ThrowIfError(response);
+        RestClient.ThrowIfError(response);
         return response;
     }
 
@@ -261,13 +261,13 @@ public static async Task<RestResponse> OptionsAsync(this RestClient client, Rest
     /// <returns></returns>
     public static async Task<T?> PatchAsync<T>(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteAsync<T>(request, Method.Patch, cancellationToken).ConfigureAwait(false);
-        ThrowIfError(response);
+        RestClient.ThrowIfError(response);
         return response.Data;
     }
 
     public static async Task<RestResponse> PatchAsync(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteAsync(request, Method.Patch, cancellationToken).ConfigureAwait(false);
-        ThrowIfError(response);
+        RestClient.ThrowIfError(response);
         return response;
     }
 
@@ -282,13 +282,13 @@ public static async Task<RestResponse> PatchAsync(this RestClient client, RestRe
     /// <returns></returns>
     public static async Task<T?> DeleteAsync<T>(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteAsync<T>(request, Method.Delete, cancellationToken).ConfigureAwait(false);
-        ThrowIfError(response);
+        RestClient.ThrowIfError(response);
         return response.Data;
     }
 
     public static async Task<RestResponse> DeleteAsync(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteAsync(request, Method.Delete, cancellationToken).ConfigureAwait(false);
-        ThrowIfError(response);
+        RestClient.ThrowIfError(response);
         return response;
     }
 
@@ -313,9 +313,4 @@ public static RestClient UseXml(this RestClient client) {
         client.AssignAcceptedContentTypes();
         return client;
     }
-    
-    static void ThrowIfError(RestResponse response) {
-        var exception = response.GetException();
-        if (exception != null) throw exception;
-    }
 }
diff --git a/src/RestSharp/Serializers/ContentType.cs b/src/RestSharp/Serializers/ContentType.cs
@@ -15,20 +15,18 @@
 namespace RestSharp.Serializers;
 
 public static class ContentType {
-    public const string Json = "application/json";
-
-    public const string Xml = "application/xml";
-
-    public const string Plain = "text/plain";
-
-    public const string File = "application/octet-stream";
-
-    public const string GZip = "application/x-gzip";
+    public const string Json   = "application/json";
+    public const string Xml    = "application/xml";
+    public const string Plain  = "text/plain";
+    public const string Binary = "application/octet-stream";
+    public const string GZip   = "application/x-gzip";
 
     public static readonly Dictionary<DataFormat, string> FromDataFormat =
         new() {
             { DataFormat.Xml, Xml },
-            { DataFormat.Json, Json },
+            { DataFormat.Json, Json }, 
+            { DataFormat.None, Plain }, 
+            { DataFormat.Binary, Binary }
         };
 
     public static readonly string[] JsonAccept = {
diff --git a/src/RestSharp/Serializers/Xml/DotNetXmlDeserializer.cs b/src/RestSharp/Serializers/Xml/DotNetXmlDeserializer.cs
@@ -42,7 +42,7 @@ public class DotNetXmlDeserializer : IXmlDeserializer {
 
         using var stream = new MemoryStream(Encoding.GetBytes(response.Content!));
 
-        var serializer = new System.Xml.Serialization.XmlSerializer(typeof(T));
+        var serializer = new System.Xml.Serialization.XmlSerializer(typeof(T), Namespace);
 
         return (T?)serializer.Deserialize(stream);
     }
diff --git a/test/RestSharp.IntegrationTests/DefaultParameterTests.cs b/test/RestSharp.IntegrationTests/DefaultParameterTests.cs
@@ -1,12 +1,20 @@
 using System.Net;
+using RestSharp.IntegrationTests.Fixtures;
 using RestSharp.Tests.Shared.Fixtures;
 
 namespace RestSharp.IntegrationTests;
 
+[Collection(nameof(TestServerCollection))]
 public class DefaultParameterTests : IDisposable {
-    readonly SimpleServer _server;
-
-    public DefaultParameterTests() => _server = SimpleServer.Create(RequestHandler.Handle);
+    readonly TestServerFixture _fixture;
+    readonly ITestOutputHelper _testOutputHelper;
+    readonly SimpleServer      _server;
+
+    public DefaultParameterTests(TestServerFixture fixture, ITestOutputHelper testOutputHelper) {
+        _fixture          = fixture;
+        _testOutputHelper = testOutputHelper;
+        _server           = SimpleServer.Create(RequestHandler.Handle);
+    }
 
     public void Dispose() => _server.Dispose();
 
@@ -34,7 +42,7 @@ public async Task Should_add_default_and_request_url_get_parameters() {
 
     [Fact]
     public async Task Should_not_throw_exception_when_name_is_null() {
-        var client  = new RestClient($"{_server.Url}{{foo}}/").AddDefaultParameter("foo", "bar", ParameterType.UrlSegment);
+        var client  = new RestClient($"{_fixture.Server.Url}/request-echo").AddDefaultParameter("foo", "bar", ParameterType.UrlSegment);
         var request = new RestRequest("{foo1}").AddParameter(null, "value", ParameterType.RequestBody);
 
         await client.ExecuteAsync(request);
diff --git a/test/RestSharp.IntegrationTests/Fixtures/TestServer.cs b/test/RestSharp.IntegrationTests/Fixtures/TestServer.cs
@@ -26,6 +26,9 @@ public sealed class HttpServer {
 
     const string Address = "http://localhost:5151";
 
+    public const string ContentResource = "content";
+    public const string TimeoutResource = "timeout";
+
     public HttpServer(ITestOutputHelper output = null) {
         var builder = WebApplication.CreateBuilder();
 
@@ -40,16 +43,17 @@ public HttpServer(ITestOutputHelper output = null) {
         // GET
         _app.MapGet("success", () => new TestResponse { Message = "Works!" });
         _app.MapGet("echo", (string msg) => msg);
-        _app.MapGet("timeout", async () => await Task.Delay(2000));
-        _app.MapPut("timeout", async () => await Task.Delay(2000));
+        _app.MapGet(TimeoutResource, async () => await Task.Delay(2000));
+        _app.MapPut(TimeoutResource, async () => await Task.Delay(2000));
         // ReSharper disable once ConvertClosureToMethodGroup
         _app.MapGet("status", (int code) => Results.StatusCode(code));
         _app.MapGet("headers", HandleHeaders);
+        _app.MapGet("request-echo", async context => await context.Request.BodyReader.AsStream().CopyToAsync(context.Response.BodyWriter.AsStream()));
         _app.MapDelete("delete", () => new TestResponse { Message = "Works!" });
 
         // PUT
         _app.MapPut(
-            "content",
+            ContentResource,
             async context => {
                 var content = await context.Request.Body.StreamToStringAsync();
                 await context.Response.WriteAsync(content);
diff --git a/test/RestSharp.IntegrationTests/PutTests.cs b/test/RestSharp.IntegrationTests/PutTests.cs
diff --git a/test/RestSharp.IntegrationTests/RestSharp.IntegrationTests.csproj b/test/RestSharp.IntegrationTests/RestSharp.IntegrationTests.csproj
diff --git a/test/RestSharp.IntegrationTests/StatusCodeTests.cs b/test/RestSharp.IntegrationTests/StatusCodeTests.cs
diff --git a/test/RestSharp.Serializers.Xml.Tests/XmlSerializerTests.cs b/test/RestSharp.Serializers.Xml.Tests/XmlSerializerTests.cs
diff --git a/test/RestSharp.Tests.Shared/Fixtures/WebServer.cs b/test/RestSharp.Tests.Shared/Fixtures/WebServer.cs

Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ public static async Task<HttpStatusCode> PostJsonAsync<TRequest>(`
`108`	`108`	`TRequest request,`
`109`	`109`	`CancellationToken cancellationToken = default`
`110`	`110`	`) where TRequest : class {`
`111`		`- var restRequest = new RestRequest().AddJsonBody(request);`
	`111`	`+ var restRequest = new RestRequest(resource).AddJsonBody(request);`
`112`	`112`	`return client.PutAsync<TResponse>(restRequest, cancellationToken);`
`113`	`113`	`}`
`114`	`114`