custom exception factory for deserialization exceptions (#1862)

Co-authored-by: Teddy Assefa <[email protected]>
reactiveui · Oct 6, 2024 · 5331e71 · 5331e71
1 parent faa1f68
commit 5331e71
Show file tree

Hide file tree

Showing 4 changed files with 205 additions and 17 deletions.
diff --git a/README.md b/README.md
@@ -1426,7 +1426,20 @@ var gitHubApi = RestService.For<IGitHubApi>("https://api.github.com",
     });
 ```
 
-Note that exceptions raised when attempting to deserialize the response are not affected by this.
+For exceptions raised when attempting to deserialize the response use DeserializationExceptionFactory described bellow.
+
+#### Providing a custom `DeserializationExceptionFactory`
+
+You can override default deserialization exceptions behavior that are raised by the `DeserializationExceptionFactory` when processing the result by providing a custom exception factory in `RefitSettings`. For example, you can suppress all deserialization exceptions with the following:
+
+```csharp
+var nullTask = Task.FromResult<Exception>(null);
+
+var gitHubApi = RestService.For<IGitHubApi>("https://api.github.com",
+    new RefitSettings {
+        DeserializationExceptionFactory = (httpResponse, exception) => nullTask;
+    });
+```
 
 #### `ApiException` deconstruction with Serilog
 

diff --git a/Refit.Tests/DeserializationExceptionFactoryTests.cs b/Refit.Tests/DeserializationExceptionFactoryTests.cs
@@ -0,0 +1,154 @@
+using System.Net;
+using System.Net.Http;
+using RichardSzalay.MockHttp;
+using Xunit;
+
+namespace Refit.Tests;
+
+public class DeserializationExceptionFactoryTests
+{
+    public interface IMyService
+    {
+        [Get("/get-with-result")]
+        Task<int> GetWithResult();
+    }
+
+    [Fact]
+    public async Task NoDeserializationExceptionFactory_WithSuccessfulDeserialization()
+    {
+        var handler = new MockHttpMessageHandler();
+        var settings = new RefitSettings()
+        {
+            HttpMessageHandlerFactory = () => handler,
+        };
+
+        var intContent = 123;
+        handler
+            .Expect(HttpMethod.Get, "http://api/get-with-result")
+            .Respond(HttpStatusCode.OK, new StringContent($"{intContent}"));
+
+        var fixture = RestService.For<IMyService>("http://api", settings);
+
+        var result = await fixture.GetWithResult();
+
+        handler.VerifyNoOutstandingExpectation();
+
+        Assert.Equal(intContent, result);
+    }
+
+    [Fact]
+    public async Task NoDeserializationExceptionFactory_WithUnsuccessfulDeserialization()
+    {
+        var handler = new MockHttpMessageHandler();
+        var settings = new RefitSettings()
+        {
+            HttpMessageHandlerFactory = () => handler,
+        };
+
+        handler
+            .Expect(HttpMethod.Get, "http://api/get-with-result")
+            .Respond(HttpStatusCode.OK, new StringContent("non-int-result"));
+
+        var fixture = RestService.For<IMyService>("http://api", settings);
+
+        var thrownException = await Assert.ThrowsAsync<ApiException>(() => fixture.GetWithResult());
+        Assert.Equal("An error occured deserializing the response.", thrownException.Message);
+
+        handler.VerifyNoOutstandingExpectation();
+    }
+
+    [Fact]
+    public async Task ProvideFactoryWhichReturnsNull_WithSuccessfulDeserialization()
+    {
+        var handler = new MockHttpMessageHandler();
+        var settings = new RefitSettings()
+        {
+            HttpMessageHandlerFactory = () => handler,
+            DeserializationExceptionFactory = (_, _) => Task.FromResult<Exception>(null)
+        };
+
+        var intContent = 123;
+        handler
+            .Expect(HttpMethod.Get, "http://api/get-with-result")
+            .Respond(HttpStatusCode.OK, new StringContent($"{intContent}"));
+
+        var fixture = RestService.For<IMyService>("http://api", settings);
+
+        var result = await fixture.GetWithResult();
+
+        handler.VerifyNoOutstandingExpectation();
+
+        Assert.Equal(intContent, result);
+    }
+
+    [Fact]
+    public async Task ProvideFactoryWhichReturnsNull_WithUnsuccessfulDeserialization()
+    {
+        var handler = new MockHttpMessageHandler();
+        var settings = new RefitSettings()
+        {
+            HttpMessageHandlerFactory = () => handler,
+            DeserializationExceptionFactory = (_, _) => Task.FromResult<Exception>(null)
+        };
+
+        handler
+            .Expect(HttpMethod.Get, "http://api/get-with-result")
+            .Respond(HttpStatusCode.OK, new StringContent("non-int-result"));
+
+        var fixture = RestService.For<IMyService>("http://api", settings);
+
+        var result = await fixture.GetWithResult();
+
+        handler.VerifyNoOutstandingExpectation();
+
+        Assert.Equal(default, result);
+    }
+
+    [Fact]
+    public async Task ProvideFactoryWhichReturnsException_WithUnsuccessfulDeserialization()
+    {
+        var handler = new MockHttpMessageHandler();
+        var exception = new Exception("Unsuccessful Deserialization Exception");
+        var settings = new RefitSettings()
+        {
+            HttpMessageHandlerFactory = () => handler,
+            DeserializationExceptionFactory = (_, _) => Task.FromResult<Exception>(exception)
+        };
+
+        handler
+            .Expect(HttpMethod.Get, "http://api/get-with-result")
+            .Respond(HttpStatusCode.OK, new StringContent("non-int-result"));
+
+        var fixture = RestService.For<IMyService>("http://api", settings);
+
+        var thrownException = await Assert.ThrowsAsync<Exception>(() => fixture.GetWithResult());
+        Assert.Equal(exception, thrownException);
+
+        handler.VerifyNoOutstandingExpectation();
+    }
+
+    [Fact]
+    public async Task ProvideFactoryWhichReturnsException_WithSuccessfulDeserialization()
+    {
+        var handler = new MockHttpMessageHandler();
+        var exception = new Exception("Unsuccessful Deserialization Exception");
+        var settings = new RefitSettings()
+        {
+            HttpMessageHandlerFactory = () => handler,
+            DeserializationExceptionFactory = (_, _) => Task.FromResult<Exception>(exception)
+        };
+
+        var intContent = 123;
+        handler
+            .Expect(HttpMethod.Get, "http://api/get-with-result")
+            .Respond(HttpStatusCode.OK, new StringContent($"{intContent}"));
+
+        var fixture = RestService.For<IMyService>("http://api", settings);
+
+        var result = await fixture.GetWithResult();
+
+        handler.VerifyNoOutstandingExpectation();
+
+        Assert.Equal(intContent, result);
+    }
+}
diff --git a/Refit/RefitSettings.cs b/Refit/RefitSettings.cs
@@ -92,6 +92,12 @@ public Func<
         /// </summary>
         public Func<HttpResponseMessage, Task<Exception?>> ExceptionFactory { get; set; }
 
+        /// <summary>
+        /// Supply a function to provide <see cref="Exception"/> when deserialization exception is encountered.
+        /// If function returns null - no exception is thrown.
+        /// </summary>
+        public Func<HttpResponseMessage, Exception, Task<Exception?>>? DeserializationExceptionFactory { get; set; }
+
         /// <summary>
         /// Defines how requests' content should be serialized. (defaults to <see cref="SystemTextJsonContentSerializer"/>)
         /// </summary>

diff --git a/Refit/RequestBuilderImplementation.cs b/Refit/RequestBuilderImplementation.cs
@@ -356,14 +356,19 @@ object itemValue
                         catch (Exception ex)
                         {
                             //if an error occured while attempting to deserialize return the wrapped ApiException
-                            e = await ApiException.Create(
-                                "An error occured deserializing the response.",
-                                resp.RequestMessage!,
-                                resp.RequestMessage!.Method,
-                                resp,
-                                settings,
-                                ex
-                            );
+                            if (settings.DeserializationExceptionFactory != null)
+                                e = await settings.DeserializationExceptionFactory(resp, ex).ConfigureAwait(false);
+                            else
+                            {
+                                e = await ApiException.Create(
+                                    "An error occured deserializing the response.",
+                                    resp.RequestMessage!,
+                                    resp.RequestMessage!.Method,
+                                    resp,
+                                    settings,
+                                    ex
+                                );
+                            }
                         }
 
                         return ApiResponse.Create<T, TBody>(
@@ -387,14 +392,24 @@ e as ApiException
                         }
                         catch (Exception ex)
                         {
-                            throw await ApiException.Create(
-                                "An error occured deserializing the response.",
-                                resp.RequestMessage!,
-                                resp.RequestMessage!.Method,
-                                resp,
-                                settings,
-                                ex
-                            );
+                            if (settings.DeserializationExceptionFactory != null)
+                            {
+                                var customEx = await settings.DeserializationExceptionFactory(resp, ex).ConfigureAwait(false);
+                                if (customEx != null)
+                                    throw customEx;
+                                return default;
+                            }
+                            else
+                            {
+                                throw await ApiException.Create(
+                                    "An error occured deserializing the response.",
+                                    resp.RequestMessage!,
+                                    resp.RequestMessage!.Method,
+                                    resp,
+                                    settings,
+                                    ex
+                                );
+                            }
                         }
                     }
                 }