Release: v10.0.40

CR.Exceptions.AspNet.UnitTests/CR.Exceptions.AspNet.UnitTests.csproj

@@ -8,11 +8,16 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="coverlet.collector" Version="6.0.4" />
-    <PackageReference Include="FluentAssertions" Version="8.10.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
-    <PackageReference Include="xunit" Version="2.9.3" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.4" />
+    <PackageReference Include="coverlet.collector" Version="10.0.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.8.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="xunit.v3" Version="3.2.2" />
   </ItemGroup>
 
   <ItemGroup>

CR.Exceptions.AspNet.UnitTests/CrExceptionHandlerTests.cs

@@ -1,59 +1,74 @@
-using FluentAssertions;
-using Microsoft.AspNetCore.Diagnostics;
+using Microsoft.AspNetCore.Diagnostics;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.DependencyInjection;
+using System.Diagnostics;
 using System.Text.Json;
-using System.Text.Json.Nodes;
-using Xunit.Abstractions;
 
 namespace CR.Exceptions.AspNet.UnitTests;
 
 public sealed class CrExceptionHandlerTests
 {
+    private static readonly JsonSerializerOptions _prettyJsonOptions = new(JsonSerializerOptions.Web) { WriteIndented = true };
+
     private readonly ITestOutputHelper _output;
-    private readonly JsonSerializerOptions _jsonOptions;
 
     public CrExceptionHandlerTests(ITestOutputHelper output)
     {
         _output = output;
-        _jsonOptions = new()
-        {
-            WriteIndented = true,
-            PropertyNameCaseInsensitive = true
-        };
     }
 
     [Fact]
     public Task Should_Return_404_For_NotFoundException()
     {
-        return ShouldReturnStatusCode(new TestNotFoundException(), StatusCodes.Status404NotFound);
+        return AssertHandlerResult(
+            new TestNotFoundException(),
+            StatusCodes.Status404NotFound,
+            canCreateActivity: true);
     }
 
     [Fact]
     public Task Should_Return_500_For_UnhandledException()
     {
-        return ShouldReturnStatusCode(new Exception("Something went wrong"), StatusCodes.Status500InternalServerError);
+        return AssertHandlerResult(
+            new Exception("Unknown exception"),
+            StatusCodes.Status500InternalServerError,
+            canCreateActivity: true);
+    }
+
+    [Fact]
+    public Task Should_Return_500_For_UnhandledException_When_Activity_Is_Missing()
+    {
+        return AssertHandlerResult(
+            new Exception("Unknown exception"),
+            StatusCodes.Status500InternalServerError,
+            canCreateActivity: false);
     }
 
-    private async Task ShouldReturnStatusCode(Exception exception, int expectedStatusCode)
+    private async Task AssertHandlerResult(Exception exception, int expectedStatusCode, bool canCreateActivity)
     {
-        using var provider = CreateServiceProvider();
+        using var activity = canCreateActivity
+            ? new Activity("TestActivity").Start()
+            : null;
 
+        using var provider = CreateServiceProvider();
         var handler = provider.GetRequiredService<IExceptionHandler>();
-        var context = CreateContext();
 
-        var result = await handler.TryHandleAsync(
-            context,
-            exception,
-            CancellationToken.None);
+        using var responseStream = new MemoryStream();
+        var context = CreateContext(responseStream);
+
+        var isHandled = await handler.TryHandleAsync(context, exception, CancellationToken.None);
 
-        await LogResponseBody(context);
+        Assert.True(isHandled);
+        Assert.Equal(expectedStatusCode, context.Response.StatusCode);
+        Assert.Contains("application/problem+json", context.Response.ContentType);
 
-        result.Should().BeTrue();
-        context.Response.StatusCode.Should().Be(expectedStatusCode);
+        responseStream.Position = 0;
 
-        var problem = await DeserializeProblemDetails(context);
-        AssertProblemDetails(problem!, context, expectedStatusCode);
+        var problem = await JsonSerializer.DeserializeAsync<CustomProblemDetails>(responseStream, JsonSerializerOptions.Web);
+        var expectedTraceId = activity?.TraceId.ToHexString() ?? context.TraceIdentifier;
+
+        AssertProblemDetails(problem, context, expectedStatusCode, expectedTraceId);
     }
 
     private static ServiceProvider CreateServiceProvider()
@@ -64,55 +79,40 @@ private static ServiceProvider CreateServiceProvider()
             .BuildServiceProvider();
     }
 
-    private static DefaultHttpContext CreateContext()
+    private static DefaultHttpContext CreateContext(MemoryStream responseStream)
     {
         return new DefaultHttpContext
         {
-            Response =
-            {
-                Body = new MemoryStream()
-            }
+            Request = { Path = "/api/test" },
+            Response = { Body = responseStream }
         };
     }
 
-    private async Task<ProblemDetailsResponse> DeserializeProblemDetails(HttpContext context)
+    private void AssertProblemDetails(CustomProblemDetails? problem, HttpContext context, int expectedStatusCode, string? expectedTraceId)
     {
-        context.Response.Body.Position = 0;
+        Assert.NotNull(problem);
 
-        return (await JsonSerializer.DeserializeAsync<ProblemDetailsResponse>(
-            context.Response.Body, _jsonOptions))!;
-    }
+        _output.WriteLine(JsonSerializer.Serialize(problem, options: _prettyJsonOptions));
 
-    private async Task LogResponseBody(DefaultHttpContext context)
-    {
-        context.Response.Body.Position = 0;
-        var jsonNode = await JsonNode.ParseAsync(context.Response.Body);
-        _output.WriteLine(jsonNode?.ToJsonString(_jsonOptions));
-    }
+        Assert.False(string.IsNullOrEmpty(problem.Type));
+        Assert.False(string.IsNullOrEmpty(problem.Title));
+        Assert.False(string.IsNullOrEmpty(problem.Detail));
 
-    private static void AssertProblemDetails(ProblemDetailsResponse problem, HttpContext context, int expectedStatusCode)
-    {
-        problem.Should().NotBeNull();
+        Assert.Equal(expectedStatusCode, problem.Status);
+        Assert.Equal(context.Request.Path, problem.Instance);
 
-        problem.Type.Should().NotBeNullOrWhiteSpace();
-        problem.Title.Should().NotBeNullOrWhiteSpace();
-        problem.Detail.Should().NotBeNullOrWhiteSpace();
+        Assert.True(problem.Extensions.TryGetValue(
+                ProblemDetailsExtensionNames.TraceId,
+                out var traceId));
 
-        problem.Status.Should().Be(expectedStatusCode);
-        problem.Instance.Should().Be(context.Request.Path);
+        Assert.Equal(expectedTraceId, traceId?.ToString());
 
-        problem.TraceId.Should().NotBeNullOrWhiteSpace();
-        problem.Errors.Should().NotBeNull().And.NotBeEmpty();
+        Assert.NotNull(problem.Errors);
+        Assert.NotEmpty(problem.Errors);
     }
 
-    private sealed class ProblemDetailsResponse
+    private sealed class CustomProblemDetails : ProblemDetails
     {
-        public string? Type { get; set; }
-        public string? Title { get; set; }
-        public int? Status { get; set; }
-        public string? Detail { get; set; }
-        public string? Instance { get; set; }
-        public string? TraceId { get; set; }
         public CrError[]? Errors { get; set; }
     }
 }

CR.Exceptions.AspNet.UnitTests/ExceptionStatusCodeOptionsTests.cs

@@ -0,0 +1,34 @@
+using Microsoft.AspNetCore.Http;
+
+namespace CR.Exceptions.AspNet.UnitTests;
+
+public sealed class ExceptionStatusCodeOptionsTests
+{
+    [Fact]
+    public void Should_Return_404_For_NotFoundException()
+    {
+        var statusCode = GetStatusCodeFor(new TestNotFoundException());
+        Assert.Equal(StatusCodes.Status404NotFound, statusCode);
+    }
+
+    [Fact]
+    public void Should_Return_Null_For_UnregisteredException()
+    {
+        var statusCode = GetStatusCodeFor(new TestUnregisteredException());
+        Assert.Null(statusCode);
+    }
+
+    private static int? GetStatusCodeFor(CrException exception)
+    {
+        return new ExceptionStatusCodeOptions()
+            .AddDefaultMappings()
+            .FindHttpStatusCode(exception);
+    }
+
+    private sealed class TestUnregisteredException : CrException
+    {
+        public TestUnregisteredException() : base([new("TestUnregistered", "Test message")], "Unregistered")
+        {
+        }
+    }
+}

CR.Exceptions.AspNet.UnitTests/TestNotFoundException.cs

@@ -1,6 +1,6 @@
 namespace CR.Exceptions.AspNet.UnitTests;
 
-public sealed class TestNotFoundException : NotFoundException
+internal sealed class TestNotFoundException : NotFoundException
 {
     public TestNotFoundException() : base([new("TestNotFound", "Test Entity not found")])
     {

CR.Exceptions.AspNet/CrExceptionHandler.cs

@@ -1,20 +1,16 @@
-using CR.Exceptions.AspNet.Options;
-using Microsoft.AspNetCore.Diagnostics;
+using Microsoft.AspNetCore.Diagnostics;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.AspNetCore.WebUtilities;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
-using System.Diagnostics;
+using System.Collections.Immutable;
 
 namespace CR.Exceptions.AspNet;
 
 public sealed partial class CrExceptionHandler : IExceptionHandler
 {
-    private static readonly CrError[] DefaultInternalErrors =
-    [
-        new(ErrorCodes.InternalError, "An unexpected internal error occurred.")
-    ];
+    private static readonly ImmutableArray<CrError> DefaultInternalErrors =
+        [new("InternalError", "An unexpected internal error occurred.")];
 
     private readonly IProblemDetailsService _problemDetailsService;
     private readonly CrExceptionOptions _options;
@@ -42,15 +38,15 @@ public async ValueTask<bool> TryHandleAsync(HttpContext httpContext, Exception e
         var exceptionType = exception.GetType();
         var exceptionTypeName = exceptionType.FullName ?? exceptionType.Name;
 
-        CrError[] errors;
-        string detail;
+        var errors = DefaultInternalErrors;
+        var detail = "An unexpected error occurred.";
 
         if (exception is CrException crException)
         {
             detail = crException.Message;
             errors = crException.Errors;
 
-            var statusCode = _options.ExceptionMapping.FindHttpStatusCode(crException);
+            var statusCode = _options.StatusCodes.FindHttpStatusCode(crException);
 
             if (statusCode is null)
             {
@@ -65,33 +61,24 @@ public async ValueTask<bool> TryHandleAsync(HttpContext httpContext, Exception e
         }
         else
         {
-            detail = "An unexpected error occurred.";
-            errors = DefaultInternalErrors;
-
             LogUnhandledException(_logger, exception, exceptionTypeName);
         }
 
-        var traceId = Activity.Current?.TraceId.ToHexString() ?? httpContext.TraceIdentifier;
-        var title = ReasonPhrases.GetReasonPhrase(httpStatusCode);
+        httpContext.Response.StatusCode = httpStatusCode;
+
         var problemDetailsContext = new ProblemDetailsContext
         {
             HttpContext = httpContext,
             Exception = exception,
             ProblemDetails =
             {
-                Type = _options.ProblemDetails.Type,
                 Status = httpStatusCode,
-                Title = string.IsNullOrWhiteSpace(title) ? "An error occurred" : title,
                 Detail = detail,
                 Instance = httpContext.Request.Path
             },
         };
-
-        AddProblemDetailsExtension(problemDetailsContext.ProblemDetails, ProblemDetailsExtensionNames.TraceId, traceId);
         AddProblemDetailsExtension(problemDetailsContext.ProblemDetails, ProblemDetailsExtensionNames.Errors, errors);
 
-        httpContext.Response.StatusCode = httpStatusCode;
-
         var isWritten = await _problemDetailsService.TryWriteAsync(problemDetailsContext);
 
         if (!isWritten)

CR.Exceptions.AspNet/CrExceptionOptions.cs

@@ -0,0 +1,6 @@
+namespace CR.Exceptions.AspNet;
+
+public sealed class CrExceptionOptions
+{
+    public ExceptionStatusCodeOptions StatusCodes { get; init; } = new();
+}

CR.Exceptions.AspNet/Options/ExceptionMappingOptions.cs → CR.Exceptions.AspNet/ExceptionStatusCodeOptions.cs

@@ -1,10 +1,10 @@
-namespace CR.Exceptions.AspNet.Options;
+namespace CR.Exceptions.AspNet;
 
-public sealed class ExceptionMappingOptions
+public sealed class ExceptionStatusCodeOptions
 {
     private readonly Dictionary<Type, int> _map = [];
 
-    public ExceptionMappingOptions Map<TException>(int httpStatusCode) where TException : CrException
+    public ExceptionStatusCodeOptions Map<TException>(int httpStatusCode) where TException : CrException
     {
         if (!_map.TryAdd(typeof(TException), httpStatusCode))
         {

CR.Exceptions.AspNet/ExceptionMappingOptionsExtensions.cs → CR.Exceptions.AspNet/ExceptionStatusCodeOptionsExtensions.cs

@@ -1,13 +1,12 @@
-using CR.Exceptions.AspNet.Options;
-using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http;
 
 namespace CR.Exceptions.AspNet;
 
-public static class ExceptionMappingOptionsExtensions
+public static class ExceptionStatusCodeOptionsExtensions
 {
-    extension(ExceptionMappingOptions options)
+    extension(ExceptionStatusCodeOptions options)
     {
-        public ExceptionMappingOptions AddDefaultMappings()
+        public ExceptionStatusCodeOptions AddDefaultMappings()
         {
             return options
                 .Map<ValidationException>(StatusCodes.Status400BadRequest)