Add tests

Author: JamesNK

src/Middleware/Diagnostics/test/UnitTests/ExceptionHandlerMiddlewareTest.cs

@@ -22,6 +22,7 @@
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Logging.Testing;
 using Microsoft.Extensions.Options;
 using Moq;
 
@@ -81,6 +82,7 @@ public async Task ExceptionIsSetOnProblemDetailsContext()
     public async Task Invoke_ExceptionThrownResultsInClearedRouteValuesAndEndpoint()
     {
         // Arrange
+        var sink = new TestSink();
         var httpContext = CreateHttpContext();
         httpContext.SetEndpoint(new Endpoint((_) => Task.CompletedTask, new EndpointMetadataCollection(), "Test"));
         httpContext.Request.RouteValues["John"] = "Doe";
@@ -92,10 +94,39 @@ public async Task Invoke_ExceptionThrownResultsInClearedRouteValuesAndEndpoint()
                 Assert.Null(context.GetEndpoint());
                 return Task.CompletedTask;
             });
-        var middleware = CreateMiddleware(_ => throw new InvalidOperationException(), optionsAccessor);
+        var middleware = CreateMiddleware(_ => throw new InvalidOperationException(), optionsAccessor, loggerFactory: new TestLoggerFactory(sink, true));
 
         // Act & Assert
         await middleware.Invoke(httpContext);
+
+        Assert.Collection(sink.Writes, w => Assert.Equal("UnhandledException", w.EventId.Name));
+    }
+
+    [Fact]
+    public async Task Invoke_HasExceptionHandler_SuppressIExceptionHandlerLogging_HasLogs()
+    {
+        // Arrange
+        var sink = new TestSink();
+        var httpContext = CreateHttpContext();
+
+        var optionsAccessor = CreateOptionsAccessor(
+            exceptionHandler: context =>
+            {
+                context.Features.Set<IHttpResponseFeature>(new TestHttpResponseFeature());
+                return Task.CompletedTask;
+            },
+            suppressLoggingHandlingException: true);
+        var middleware = CreateMiddleware(_ => throw new InvalidOperationException(), optionsAccessor, loggerFactory: new TestLoggerFactory(sink, true));
+
+        // Act & Assert
+        await middleware.Invoke(httpContext);
+
+        Assert.Collection(sink.Writes, w => Assert.Equal("UnhandledException", w.EventId.Name));
+    }
+
+    private sealed class TestHttpResponseFeature : HttpResponseFeature
+    {
+        public override bool HasStarted => true;
     }
 
     [Fact]
@@ -126,6 +157,7 @@ public async Task Invoke_ExceptionHandlerCaptureRouteValuesAndEndpoint()
     public async Task IExceptionHandlers_CallNextIfNotHandled()
     {
         // Arrange
+        var sink = new TestSink();
         var httpContext = CreateHttpContext();
 
         var optionsAccessor = CreateOptionsAccessor();
@@ -137,14 +169,49 @@ public async Task IExceptionHandlers_CallNextIfNotHandled()
             new TestExceptionHandler(true, "3"),
         };
 
-        var middleware = CreateMiddleware(_ => throw new InvalidOperationException(), optionsAccessor, exceptionHandlers);
+        var middleware = CreateMiddleware(_ => throw new InvalidOperationException(), optionsAccessor, exceptionHandlers, loggerFactory: new TestLoggerFactory(sink, true));
 
         // Act & Assert
         await middleware.Invoke(httpContext);
 
         Assert.True(httpContext.Items.ContainsKey("1"));
         Assert.True(httpContext.Items.ContainsKey("2"));
         Assert.True(httpContext.Items.ContainsKey("3"));
+
+        Assert.Collection(sink.Writes, w => Assert.Equal("UnhandledException", w.EventId.Name));
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task IExceptionHandlers_SuppressLogging_TestLogs(bool suppressedLogs)
+    {
+        // Arrange
+        var sink = new TestSink();
+        var httpContext = CreateHttpContext();
+
+        var optionsAccessor = CreateOptionsAccessor(suppressLoggingHandlingException: suppressedLogs);
+
+        var exceptionHandlers = new List<IExceptionHandler>
+        {
+            new TestExceptionHandler(true, "1")
+        };
+
+        var middleware = CreateMiddleware(_ => throw new InvalidOperationException(), optionsAccessor, exceptionHandlers, loggerFactory: new TestLoggerFactory(sink, true));
+
+        // Act & Assert
+        await middleware.Invoke(httpContext);
+
+        Assert.True(httpContext.Items.ContainsKey("1"));
+
+        if (suppressedLogs)
+        {
+            Assert.Empty(sink.Writes);
+        }
+        else
+        {
+            Assert.Collection(sink.Writes, w => Assert.Equal("UnhandledException", w.EventId.Name));
+        }
     }
 
     [Fact]
@@ -247,32 +314,6 @@ public async Task Metrics_ExceptionThrown_Handled_Reported()
             m => AssertRequestException(m, "System.InvalidOperationException", "handled", typeof(TestExceptionHandler).FullName));
     }
 
-    [Fact]
-    public async Task Metrics_ExceptionThrown_ErrorPathHandled_Reported()
-    {
-        // Arrange
-        var httpContext = CreateHttpContext();
-        var optionsAccessor = CreateOptionsAccessor(
-            exceptionHandler: context =>
-            {
-                context.Features.Set<IHttpResponseFeature>(new TestHttpResponseFeature());
-                return Task.CompletedTask;
-            },
-            exceptionHandlingPath: "/error");
-        var meterFactory = new TestMeterFactory();
-        var middleware = CreateMiddleware(_ => throw new InvalidOperationException(), optionsAccessor, meterFactory: meterFactory);
-        var meter = meterFactory.Meters.Single();
-
-        using var diagnosticsRequestExceptionCollector = new MetricCollector<long>(meterFactory, DiagnosticsMetrics.MeterName, "aspnetcore.diagnostics.exceptions");
-
-        // Act
-        await middleware.Invoke(httpContext);
-
-        // Assert
-        Assert.Collection(diagnosticsRequestExceptionCollector.GetMeasurementSnapshot(),
-            m => AssertRequestException(m, "System.InvalidOperationException", "handled", "/error"));
-    }
-
     [Fact]
     public async Task Metrics_ExceptionThrown_ResponseStarted_Skipped()
     {
@@ -471,6 +512,32 @@ public async Task Metrics_ExceptionThrown_Unhandled_Reported()
             m => AssertRequestException(m, "System.InvalidOperationException", "unhandled"));
     }
 
+    [Fact]
+    public async Task Metrics_ExceptionThrown_ErrorPathHandled_Reported()
+    {
+        // Arrange
+        var httpContext = CreateHttpContext();
+        var optionsAccessor = CreateOptionsAccessor(
+            exceptionHandler: context =>
+            {
+                context.Features.Set<IHttpResponseFeature>(new TestHttpResponseFeature());
+                return Task.CompletedTask;
+            },
+            exceptionHandlingPath: "/error");
+        var meterFactory = new TestMeterFactory();
+        var middleware = CreateMiddleware(_ => throw new InvalidOperationException(), optionsAccessor, meterFactory: meterFactory);
+        var meter = meterFactory.Meters.Single();
+
+        using var diagnosticsRequestExceptionCollector = new MetricCollector<long>(meterFactory, DiagnosticsMetrics.MeterName, "aspnetcore.diagnostics.exceptions");
+
+        // Act
+        await middleware.Invoke(httpContext);
+
+        // Assert
+        Assert.Collection(diagnosticsRequestExceptionCollector.GetMeasurementSnapshot(),
+            m => AssertRequestException(m, "System.InvalidOperationException", "handled", "/error"));
+    }
+
     private static void AssertRequestException(CollectedMeasurement<long> measurement, string exceptionName, string result, string handler = null)
     {
         Assert.Equal(1, measurement.Value);
@@ -516,14 +583,19 @@ private HttpContext CreateHttpContext()
 
     private IOptions<ExceptionHandlerOptions> CreateOptionsAccessor(
         RequestDelegate exceptionHandler = null,
-        string exceptionHandlingPath = null)
+        string exceptionHandlingPath = null,
+        bool? suppressLoggingHandlingException = null)
     {
         exceptionHandler ??= c => Task.CompletedTask;
         var options = new ExceptionHandlerOptions()
         {
             ExceptionHandler = exceptionHandler,
             ExceptionHandlingPath = exceptionHandlingPath,
         };
+        if (suppressLoggingHandlingException != null)
+        {
+            options.SuppressLoggingIExceptionHandler = suppressLoggingHandlingException.Value;
+        }
         var optionsAccessor = Mock.Of<IOptions<ExceptionHandlerOptions>>(o => o.Value == options);
         return optionsAccessor;
     }
@@ -532,14 +604,15 @@ private ExceptionHandlerMiddlewareImpl CreateMiddleware(
         RequestDelegate next,
         IOptions<ExceptionHandlerOptions> options,
         IEnumerable<IExceptionHandler> exceptionHandlers = null,
-        IMeterFactory meterFactory = null)
+        IMeterFactory meterFactory = null,
+        ILoggerFactory loggerFactory = null)
     {
         next ??= c => Task.CompletedTask;
         var listener = new DiagnosticListener("Microsoft.AspNetCore");
 
         var middleware = new ExceptionHandlerMiddlewareImpl(
             next,
-            NullLoggerFactory.Instance,
+            loggerFactory ?? NullLoggerFactory.Instance,
             options,
             listener,
             exceptionHandlers ?? Enumerable.Empty<IExceptionHandler>(),
@@ -555,9 +628,4 @@ public object GetService(Type serviceType)
             throw new NotImplementedException();
         }
     }
-
-    private class TestHttpResponseFeature : HttpResponseFeature
-    {
-        public override bool HasStarted => true;
-    }
 }