reactiveui · clairernovotny · Nov 11, 2018 · Nov 9, 2018 · Nov 9, 2018 · Nov 11, 2018
diff --git a/README.md b/README.md
@@ -634,3 +634,25 @@ public class HomeController : Controller
     }
 }
 ```
+
+### Handling exceptions
+
+To encapsulate any exceptions that may come from a service, you can catch an `ApiException` which contains request- and response information. Refit also supports the catching of validation exceptions that are thrown by a service implementing the RFC 7807 specification for problem details due to bad requests. For specific information on the problem details of the validation exception, simply catch `ValidationApiException`:
+
+```csharp
+// ...
+try
+{
+   var result = await awesomeApi.GetFooAsync("bar");
+}
+catch (ValidationApiException validationException)
+{
+   // handle validation here by using validationException.Content, 
+   // which is type of ProblemDetails according to RFC 7807
+}
+catch (ApiException exception)
+{
+   // other exception handling
+}
+// ...
+```
diff --git a/Refit.Tests/ResponseTests.cs b/Refit.Tests/ResponseTests.cs
@@ -68,5 +68,37 @@ public async Task AliasAsCannotBeUsedToAliasFieldNamesInResponses()
             Assert.Null(result.ShortNameForAlias);
         }
 
+        /// <summary>
+        /// Test to verify if a ValidationException is thrown for a Bad Request in terms of RFC 7807
+        /// </summary>
+        [Fact]
+        public async Task ThrowsValidationException()
+        {
+            var expectedContent = new ProblemDetails
+            {
+                Detail = "detail",
+                Errors = { { "Field1", new string[] { "Problem1" } }, { "Field2", new string[] { "Problem2" } } },
+                Instance = "instance",
+                Status = 1,
+                Title = "title",
+                Type = "type"
+            };
+            var expectedResponse = new HttpResponseMessage(HttpStatusCode.BadRequest);
+            expectedResponse.Content = new StringContent(JsonConvert.SerializeObject(expectedContent));
+            expectedResponse.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/problem+json");
+            mockHandler.Expect(HttpMethod.Get, "http://api/aliasTest")
+                .Respond(req => expectedResponse);
+
+            var actualException = await Assert.ThrowsAsync<ValidationApiException>(() => fixture.GetTestObject());
+            Assert.NotNull(actualException.Content);
+            Assert.Equal("detail", actualException.Content.Detail);
+            Assert.Equal("Problem1", actualException.Content.Errors["Field1"][0]);
+            Assert.Equal("Problem2", actualException.Content.Errors["Field2"][0]);
+            Assert.Equal("instance", actualException.Content.Instance);
+            Assert.Equal(1, actualException.Content.Status);
+            Assert.Equal("title", actualException.Content.Title);
+            Assert.Equal("type", actualException.Content.Type);
+
+        }
     }
 }
diff --git a/Refit/ApiException.cs b/Refit/ApiException.cs
@@ -25,7 +25,7 @@ public class ApiException : Exception
         public bool HasContent => !string.IsNullOrWhiteSpace(Content);
         public RefitSettings RefitSettings { get; set; }
 
-        ApiException(HttpRequestMessage message, HttpMethod httpMethod, HttpStatusCode statusCode, string reasonPhrase, HttpResponseHeaders headers, RefitSettings refitSettings = null) :
+        protected ApiException(HttpRequestMessage message, HttpMethod httpMethod, HttpStatusCode statusCode, string reasonPhrase, HttpResponseHeaders headers, RefitSettings refitSettings = null) :
             base(CreateMessage(statusCode, reasonPhrase))
         {
             RequestMessage = message;
@@ -47,10 +47,16 @@ public static async Task<ApiException> Create(HttpRequestMessage message, HttpMe
             var exception = new ApiException(message, httpMethod, response.StatusCode, response.ReasonPhrase, response.Headers, refitSettings);
 
             if (response.Content == null)
+            {
                 return exception;
+            }
 
             try
             {
+                if (response.Content.Headers.ContentType.MediaType.Equals("application/problem+json"))
+                {
+                    exception = ValidationApiException.Create(exception);
+                }
                 exception.ContentHeaders = response.Content.Headers;
                 exception.Content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
                 response.Content.Dispose();

diff --git a/Refit/ProblemDetails.cs b/Refit/ProblemDetails.cs
@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+
+namespace Refit
+{
+    /// <summary>
+    /// The object representing the details about a ValidationException caught by a service implementing RFC 7807.
+    /// </summary>
+    public class ProblemDetails
+    {
+        /// <summary>
+        /// Collection of resulting errors for the request.
+        /// </summary>
+        public Dictionary<string, string[]> Errors { get; set; } = new Dictionary<string, string[]>();
+
+        /// <summary>
+        /// A URI reference that identifies the problem type.
+        /// </summary>
+        public string Type { get; set; } = "about:blank";
+
+        /// <summary>
+        /// A short, human-readable summary of the problem type.
+        /// </summary>
+        public string Title { get; set; }
+
+        /// <summary>
+        /// The HTTP status code generated by the origin server for this occurrence of the problem.
+        /// </summary>
+        public int Status { get; set; }
+
+        /// <summary>
+        /// A human-readable explanation specific to this occurrence of the problem.
+        /// </summary>
+        public string Detail { get; set; }
+
+        /// <summary>
+        /// A URI reference that identifies the specific occurrence of the problem.
+        /// </summary>
+        public string Instance { get; set; }
+    }
+
+}
diff --git a/Refit/ValidationApiException.cs b/Refit/ValidationApiException.cs
@@ -0,0 +1,33 @@
+using System;
+
+namespace Refit
+{
+    /// <summary>
+    /// An ApiException that is raised according to RFC 7807, which contains problem details for validation exceptions.
+    /// </summary>
+    [Serializable]
+    public class ValidationApiException : ApiException
+    {
+
+        ValidationApiException(ApiException apiException) :
+            base(apiException.RequestMessage, apiException.HttpMethod, apiException.StatusCode, apiException.ReasonPhrase, apiException.Headers, apiException.RefitSettings)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new instance of a ValidationException from an existing ApiException.
+        /// </summary>
+        /// <param name="exception">An instance of an ApiException to use to build a ValidationException.</param>
+        /// <returns>ValidationApiException</returns>
+        public static ValidationApiException Create(ApiException exception)
+        {
+            return new ValidationApiException(exception);
+        }
+
+        /// <summary>
+        /// The problem details of the RFC 7807 validation exception.
+        /// </summary>
+        public new ProblemDetails Content => GetContentAs<ProblemDetails>();
+
+    }
+}