Refactored tests for custom exception handler

Author: Bart Koelman

test/JsonApiDotNetCoreExampleTests/Acceptance/Extensibility/CustomErrorHandlingTests.cs

@@ -0,0 +1,37 @@
+using System;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Serialization.Objects;
+using Microsoft.Extensions.Logging;
+
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.ExceptionHandling
+{
+    public sealed class AlternateExceptionHandler : ExceptionHandler
+    {
+        public AlternateExceptionHandler(ILoggerFactory loggerFactory, IJsonApiOptions options)
+            : base(loggerFactory, options)
+        {
+        }
+
+        protected override LogLevel GetLogLevel(Exception exception)
+        {
+            if (exception is ConsumerArticleIsNoLongerAvailableException)
+            {
+                return LogLevel.Warning;
+            }
+
+            return base.GetLogLevel(exception);
+        }
+
+        protected override ErrorDocument CreateErrorDocument(Exception exception)
+        {
+            if (exception is ConsumerArticleIsNoLongerAvailableException articleException)
+            {
+                articleException.Errors[0].Meta.Data.Add("support",
+                    $"Please contact us for info about similar articles at {articleException.SupportEmailAddress}.");
+            }
+
+            return base.CreateErrorDocument(exception);
+        }
+    }
+}

test/JsonApiDotNetCoreExampleTests/IntegrationTests/ExceptionHandling/AlternateExceptionHandler.cs

@@ -0,0 +1,11 @@
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.ExceptionHandling
+{
+    public sealed class ConsumerArticle : Identifiable
+    {
+        [Attr]
+        public string Code { get; set; }
+    }
+}

test/JsonApiDotNetCoreExampleTests/IntegrationTests/ExceptionHandling/ConsumerArticle.cs

@@ -0,0 +1,23 @@
+using System.Net;
+using JsonApiDotNetCore.Errors;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.ExceptionHandling
+{
+    public sealed class ConsumerArticleIsNoLongerAvailableException : JsonApiException
+    {
+        public string ArticleCode { get; }
+        public string SupportEmailAddress { get; }
+
+        public ConsumerArticleIsNoLongerAvailableException(string articleCode, string supportEmailAddress)
+            : base(new Error(HttpStatusCode.Gone)
+            {
+                Title = "The requested article is no longer available.",
+                Detail = $"Article with code '{articleCode}' is no longer available."
+            })
+        {
+            ArticleCode = articleCode;
+            SupportEmailAddress = supportEmailAddress;
+        }
+    }
+}

test/JsonApiDotNetCoreExampleTests/IntegrationTests/ExceptionHandling/ConsumerArticleIsNoLongerAvailableException.cs

@@ -0,0 +1,39 @@
+using System.Threading;
+using System.Threading.Tasks;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Hooks;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Queries;
+using JsonApiDotNetCore.Repositories;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Services;
+using Microsoft.Extensions.Logging;
+
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.ExceptionHandling
+{
+    public sealed class ConsumerArticleService : JsonApiResourceService<ConsumerArticle>
+    {
+        private const string _supportEmailAddress = "company@email.com";
+
+        public ConsumerArticleService(IResourceRepositoryAccessor repositoryAccessor, IQueryLayerComposer queryLayerComposer,
+            IPaginationContext paginationContext, IJsonApiOptions options, ILoggerFactory loggerFactory,
+            IJsonApiRequest request, IResourceChangeTracker<ConsumerArticle> resourceChangeTracker,
+            IResourceHookExecutorFacade hookExecutor)
+            : base(repositoryAccessor, queryLayerComposer, paginationContext, options, loggerFactory, request,
+                resourceChangeTracker, hookExecutor)
+        {
+        }
+
+        public override async Task<ConsumerArticle> GetAsync(int id, CancellationToken cancellationToken)
+        {
+            var consumerArticle = await base.GetAsync(id, cancellationToken);
+
+            if (consumerArticle.Code.StartsWith("X"))
+            {
+                throw new ConsumerArticleIsNoLongerAvailableException(consumerArticle.Code, _supportEmailAddress);
+            }
+
+            return consumerArticle;
+        }
+    }
+}

test/JsonApiDotNetCoreExampleTests/IntegrationTests/ExceptionHandling/ConsumerArticleService.cs

@@ -0,0 +1,16 @@
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Controllers;
+using JsonApiDotNetCore.Services;
+using Microsoft.Extensions.Logging;
+
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.ExceptionHandling
+{
+    public sealed class ConsumerArticlesController : JsonApiController<ConsumerArticle>
+    {
+        public ConsumerArticlesController(IJsonApiOptions options, ILoggerFactory loggerFactory,
+            IResourceService<ConsumerArticle> resourceService)
+            : base(options, loggerFactory, resourceService)
+        {
+        }
+    }
+}

test/JsonApiDotNetCoreExampleTests/IntegrationTests/ExceptionHandling/ConsumerArticlesController.cs

@@ -0,0 +1,14 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.ExceptionHandling
+{
+    public sealed class ErrorDbContext : DbContext
+    {
+        public DbSet<ConsumerArticle> ConsumerArticles { get; set; }
+
+        public ErrorDbContext(DbContextOptions<ErrorDbContext> options)
+            : base(options)
+        {
+        }
+    }
+}

test/JsonApiDotNetCoreExampleTests/IntegrationTests/ExceptionHandling/ErrorDbContext.cs

@@ -0,0 +1,85 @@
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using FluentAssertions;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Middleware;
+using JsonApiDotNetCore.Serialization.Objects;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Xunit;
+
+namespace JsonApiDotNetCoreExampleTests.IntegrationTests.ExceptionHandling
+{
+    public sealed class ExceptionHandlerTests
+        : IClassFixture<IntegrationTestContext<TestableStartup<ErrorDbContext>, ErrorDbContext>>
+    {
+        private readonly IntegrationTestContext<TestableStartup<ErrorDbContext>, ErrorDbContext> _testContext;
+
+        public ExceptionHandlerTests(IntegrationTestContext<TestableStartup<ErrorDbContext>, ErrorDbContext> testContext)
+        {
+            _testContext = testContext;
+
+            FakeLoggerFactory loggerFactory = null;
+
+            testContext.ConfigureLogging(options =>
+            {
+                loggerFactory = new FakeLoggerFactory();
+
+                options.ClearProviders();
+                options.AddProvider(loggerFactory);
+                options.SetMinimumLevel(LogLevel.Warning);
+            });
+
+            testContext.ConfigureServicesBeforeStartup(services =>
+            {
+                if (loggerFactory != null)
+                {
+                    services.AddSingleton(_ => loggerFactory);
+                }
+            });
+
+            testContext.ConfigureServicesAfterStartup(services =>
+            {
+                services.AddResourceService<ConsumerArticleService>();
+                services.AddScoped<IExceptionHandler, AlternateExceptionHandler>();
+            });
+        }
+
+        [Fact]
+        public async Task Logs_and_produces_error_response_for_custom_exception()
+        {
+            // Arrange
+            var loggerFactory = _testContext.Factory.Services.GetRequiredService<FakeLoggerFactory>();
+            loggerFactory.Logger.Clear();
+
+            var consumerArticle = new ConsumerArticle
+            {
+                Code = "X123"
+            };
+
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
+            {
+                dbContext.ConsumerArticles.Add(consumerArticle);
+                await dbContext.SaveChangesAsync();
+            });
+
+            var route = "/consumerArticles/" + consumerArticle.StringId;
+
+            // Act
+            var (httpResponse, responseDocument) = await _testContext.ExecuteGetAsync<ErrorDocument>(route);
+
+            // Assert
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Gone);
+
+            responseDocument.Errors.Should().HaveCount(1);
+            responseDocument.Errors[0].StatusCode.Should().Be(HttpStatusCode.Gone);
+            responseDocument.Errors[0].Title.Should().Be("The requested article is no longer available.");
+            responseDocument.Errors[0].Detail.Should().Be("Article with code 'X123' is no longer available.");
+            responseDocument.Errors[0].Meta.Data["support"].Should().Be("Please contact us for info about similar articles at company@email.com.");
+
+            loggerFactory.Logger.Messages.Should().HaveCount(1);
+            loggerFactory.Logger.Messages.Single().Text.Should().Contain("Article with code 'X123' is no longer available.");
+        }
+    }
+}