public async Task Test_CustomExceptionMiddleWareResponse_Success()
{
//Arrange
var context = new DefaultHttpContext();
context.Response.Body = new MemoryStream();
var middleware = new ExceptionMiddleware(next: (a) =>
{
throw new Exception("This is a custom message");
},
(ex, context) => Process(ex, context));
//Act
await middleware.Invoke(context);
context.Response.Body.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(context.Response.Body);
var streamText = await reader.ReadToEndAsync().ConfigureAwait(false);
var objResponse = JsonConvert.DeserializeObject <CustomErrorResponse>(streamText);
//Validate
Assert.True(context.Response.StatusCode == StatusCodes.Status500InternalServerError);
Assert.True(objResponse.CustomStatusCode == 999);
Assert.True(objResponse.CustomMessage == "This is a custom message.");
Assert.True(objResponse.CustomRequestID == "CustomRequestIs-999");
}
public async Task ExceptionMiddleware_Capture_ForeignKey_Reference_Sql_Exception()
{
// Arrange
var defaultContext = new DefaultHttpContext();
defaultContext.Response.Body = new MemoryStream();
var loggerMock = new Mock <ILogger <ExceptionMiddleware> >();
// Act
var middlewareInstance = new ExceptionMiddleware(next: (innerHttpContext) =>
{
throw MakeSqlException(547);
}, logger: loggerMock.Object);
await middlewareInstance.InvokeAsync(defaultContext);
// Assert
defaultContext.Response.Body.Seek(0, SeekOrigin.Begin);
var body = new StreamReader(defaultContext.Response.Body).ReadToEnd();
body.Should().Contain("409");
body.Should().Contain("This item cannot be deleted.");
body.Should().Contain("errorCode");
body.Should().Contain("errorType");
body.Should().Contain("errorMessage");
body.Should().Contain("errorDate");
}
public async Task Invoke_NoHandlersAdded_DefaultDelegateCalled(NullLoggerFactory loggerFactory,
Mock <IServiceProvider> serviceProviderMock, string exceptionMessage,
string path, string method)
{
//Arrange
var requestDelegate = new RequestDelegate(httpContext => throw new Exception(exceptionMessage));
var httpContextMock = new HttpContextMock();
httpContextMock.HttpResponseMock.SetupSet(m => m.StatusCode = 500).Verifiable();
httpContextMock.HttpResponseMock.SetupSet(m => m.ContentType = "application/problem+json").Verifiable();
httpContextMock.HttpRequestMock.SetupGet(r => r.Path).Returns("/" + path);
httpContextMock.HttpRequestMock.SetupGet(r => r.Method).Returns(method);
var expectedResponse = new ProblemDetails()
{
Status = 500,
Title = exceptionMessage
};
var expectedBody = JObject.FromObject(expectedResponse);
var middleware = new ExceptionMiddleware(requestDelegate, loggerFactory, serviceProviderMock.Object);
await middleware.Invoke(httpContextMock.Object);
//Assert
httpContextMock.HttpResponseMock.Verify();
JToken.DeepEquals(expectedBody, JObject.Parse(httpContextMock.HttpResponseMock.ActualBody));
}
public async Task InvokeAsync_ValidationExceptionThrownInsideMiddleware_ContextResponseModifiedAsync()
{
//arrange
string expectedOutput = "{\"Message\":\"Bad Request\"}";
var middleWare = new ExceptionMiddleware(next: async(innerHttpContext) =>
{
await Task.Run(() =>
{
throw new ValidationException("Bad Request");
});
}, loggerFactory);
var context = new DefaultHttpContext();
context.Response.Body = new MemoryStream();
//act
await middleWare.InvokeAsync(context);
//assert
context.Response.Body.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(context.Response.Body);
var body = reader.ReadToEnd();
Assert.Equal(expectedOutput, body);
}
public async Task GivenRequestThrowsCustomExceptionWithoutUSerMessage_SetsErrorResponse()
{
// Arrange
var exception = new DiagnoseaTestException(ExceptionCode.EntityNotFound, "TM");
Task CurrentRequest(HttpContext c) => throw exception;
var classUnderTest = new ExceptionMiddleware(CurrentRequest, _exceptionMapping);
var context = GetDefaultHttpContext();
// Act
await classUnderTest.InvokeAsync(context);
// Assert
var message = await GetExceptionResponse(context);
Assert.Multiple(() =>
{
var statusCode = _exceptionMapping[typeof(DiagnoseaTestException)];
Assert.That(context.Response.StatusCode, Is.EqualTo((int)statusCode));
Assert.That(message.ExceptionCode, Is.EqualTo(exception.ExceptionCode));
Assert.That(message.TechnicalMessage, Is.EqualTo(exception.TechnicalMessage));
Assert.That(message.UserMessage, Is.Null);
});
}
public async Task ExceptionMiddleware_Capture_Any_Exception()
{
// Arrange
var defaultContext = new DefaultHttpContext();
defaultContext.Response.Body = new MemoryStream();
var loggerMock = new Mock <ILogger <ExceptionMiddleware> >();
// Act
var middlewareInstance = new ExceptionMiddleware(next: (innerHttpContext) =>
{
throw new Exception("Server Error");
}, logger: loggerMock.Object);
await middlewareInstance.InvokeAsync(defaultContext);
// Assert
defaultContext.Response.Body.Seek(0, SeekOrigin.Begin);
var body = new StreamReader(defaultContext.Response.Body).ReadToEnd();
body.Should().Contain("500");
body.Should().Contain("Server Error");
body.Should().Contain("errorCode");
body.Should().Contain("errorType");
body.Should().Contain("errorMessage");
body.Should().Contain("errorDate");
}
private static List <HttpMiddleware> GetMiddlewares(
HttpMiddleware functionMiddleware,
IServerlessLogger serverlessLogger,
IHttpContextAccessor acessor,
bool allowAnonymous)
{
var exceptionMiddleware = new ExceptionMiddleware(serverlessLogger);
var loggerMiddleware = new LoggerMiddleware(serverlessLogger);
var headerMiddleware = new HeaderMiddleware();
List <HttpMiddleware> middlewares = null;
if (allowAnonymous)
{
middlewares = MiddlewaresWithoutAuth(
functionMiddleware,
exceptionMiddleware,
loggerMiddleware,
headerMiddleware);
}
else
{
middlewares = MiddlewaresWithAuth(
functionMiddleware,
serverlessLogger,
acessor,
exceptionMiddleware,
loggerMiddleware,
headerMiddleware);
}
return(middlewares);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
var routeBuilder = new RouteBuilder(app);
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
// Enable middleware to serve generated Swagger as a JSON endpoint.
app.UseSwagger();
// Enable middleware to serve swagger-ui (HTML, JS, CSS, etc.),
// specifying the Swagger JSON endpoint.
app.UseSwaggerUI(c =>
{
c.DocExpansion(DocExpansion.None);
c.RoutePrefix = string.Empty;
c.SwaggerEndpoint("/swagger/v1/swagger.json", "Todo V1.0");
});
// Serialize all exceptions to JSON
var jsonExceptionMiddleware = new ExceptionMiddleware(app.ApplicationServices.GetRequiredService <IHostingEnvironment>());
app.UseExceptionHandler(new ExceptionHandlerOptions {
ExceptionHandler = jsonExceptionMiddleware.Invoke
});
app.UseAuthentication();
app.UseMvc();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseCors(builder => builder.AllowAnyHeader().AllowAnyMethod().AllowAnyOrigin());
// Enable middleware to serve generated Swagger as a JSON endpoint.
app.UseSwagger();
// Enable middleware to serve swagger-ui (HTML, JS, CSS, etc.),
// specifying the Swagger JSON endpoint.
app.UseSwaggerUI(c =>
{
c.RoutePrefix = string.Empty;
c.SwaggerEndpoint("/swagger/v1/swagger.json", "Voting Application");
});
// Serialize all exceptions to JSON
var jsonExceptionMiddleware = new ExceptionMiddleware(app.ApplicationServices.GetRequiredService <Microsoft.AspNetCore.Hosting.IHostingEnvironment>());
app.UseExceptionHandler(new ExceptionHandlerOptions {
ExceptionHandler = jsonExceptionMiddleware.Invoke
});
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
public async Task Should_Handle_Success()
{
// Arrange
var middleware = new ExceptionMiddleware(
(innerHttpContext) =>
{
var dummyResponse = new DummyResponse("dummy");
var json = JsonConvert.SerializeObject(dummyResponse);
var bytes = Encoding.ASCII.GetBytes(json);
innerHttpContext.Response.Body = new MemoryStream(bytes);
return(Task.CompletedTask);
},
new LoggerFactory().CreateLogger <ExceptionMiddleware>()
);
var context = new DefaultHttpContext();
context.Response.Body = new MemoryStream();
//Act
await middleware.Invoke(context);
context.Response.Body.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(context.Response.Body);
var streamText = reader.ReadToEnd();
var dummy = JsonConvert.DeserializeObject <DummyResponse>(streamText);
//Assert
Assert.Equal((int)HttpStatusCode.OK, context.Response.StatusCode);
Assert.Equal("dummy", dummy.Name);
}
public void OneTimeSetup()
{
requestDelegateMock = new Mock <RequestDelegate>();
useCaseExceptionCodeMapperMock = new Mock <IUseCaseExceptionCodeMapper>();
loggerMock = new Mock <ILogger <ExceptionMiddleware> >();
_exceptionMiddleware = new ExceptionMiddleware(requestDelegateMock.Object,
useCaseExceptionCodeMapperMock.Object, loggerMock.Object);
}
private void Setup()
{
_requestDelegateMock = new Mock <DelegateMock>();
_loggerMock = new Mock <ILoggerManager>(MockBehavior.Strict);
_exceptionMiddleware = new ExceptionMiddleware(_requestDelegateMock.Object.RequestDelegate, _loggerMock.Object);
_httpContext = new DefaultHttpContext();
_httpContext.Request.Path = _url;
ConfigureLoggerMock();
}
public async Task TestNoExceptionWithoutSentry()
{
var middleware = new ExceptionMiddleware(_loggerFactory, null);
var context = new DefaultHttpContext();
await middleware.InvokeAsync(context, (ctx) =>
{
throw new Exception();
});
}
public async Task Should_Invoke_Delegate()
{
RequestDelegateMock
.Setup(x => x.RequestDelegate(It.IsAny <HttpContext>()))
.Returns(Task.FromResult(0));
ExceptionMiddleware = new ExceptionMiddleware(RequestDelegateMock.Object.RequestDelegate);
await ExceptionMiddleware.InvokeAsync(new DefaultHttpContext());
RequestDelegateMock.Verify(x => x.RequestDelegate(It.IsAny <HttpContext>()), Times.Once);
}
public async Task Invoke_HandlerOfOtherTypeAdded_BaseDelegateCalled(NullLoggerFactory loggerFactory,
Mock <IServiceProvider> serviceProviderMock, string exceptionMessage,
string path, string method)
{
//Arrange
var expectedResponse = new TestResponse
{
Message = exceptionMessage
};
var argumentExceptionHandler = new Mock <IExceptionHandler <ArgumentException> >();
argumentExceptionHandler
.Setup(eh => eh.GetResponseDataGeneric(It.IsAny <ArgumentException>(), It.IsAny <ResponseContext>()))
.Returns((Exception exc, ResponseContext opt) => new ResponseData
{
StatusCode = 400,
Body = null
});
var exceptionHandler = new Mock <IExceptionHandler <Exception> >();
exceptionHandler
.Setup(eh => eh.GetResponseData(It.IsAny <Exception>(), It.IsAny <ResponseContext>()))
.Returns((Exception exc, ResponseContext opt) => new ResponseData
{
StatusCode = 404,
Body = expectedResponse
});
serviceProviderMock
.Setup(s => s.GetService(typeof(IExceptionHandler <ArgumentException>)))
.Returns(argumentExceptionHandler.Object);
serviceProviderMock
.Setup(s => s.GetService(typeof(IExceptionHandler <Exception>)))
.Returns(exceptionHandler.Object);
var requestDelegate =
new RequestDelegate(httpContext => throw new InvalidOperationException(exceptionMessage));
var httpContextMock = new HttpContextMock();
httpContextMock.HttpResponseMock.SetupSet(m => m.StatusCode = 404).Verifiable();
httpContextMock.HttpRequestMock.SetupGet(r => r.Path).Returns("/" + path);
httpContextMock.HttpRequestMock.SetupGet(r => r.Method).Returns(method);
var expectedBody = JObject.FromObject(expectedResponse);
var middleware = new ExceptionMiddleware(requestDelegate, loggerFactory, serviceProviderMock.Object);
//Act
await middleware.Invoke(httpContextMock.Object);
//Assert
httpContextMock.HttpResponseMock.Verify();
JToken.DeepEquals(expectedBody, JObject.Parse(httpContextMock.HttpResponseMock.ActualBody));
}
public async Task InvokeAsync_NextThrowException_ReturnsStatusCode500([Frozen] RequestDelegate next,
HttpContext context,
ExceptionMiddleware sut)
{
next.WhenForAnyArgs(x => x(Arg.Any <HttpContext>())).Throw(new Exception());
Func <Task> func = async() => await sut.InvokeAsync(context).ConfigureAwait(false);
await func.Should().NotThrowAsync().ConfigureAwait(false);
context.Response.StatusCode.Should().Be((int)HttpStatusCode.InternalServerError);
}
public async Task InvokeAsync_SuccessScenario_Test()
{
var middleware = new ExceptionMiddleware(_next.Object);
_httpContext.Response.Body = new MemoryStream(); //set body as stream
await middleware.InvokeAsync(_httpContext); // invoking the middleware fills up the stream
Assert.Equal(_httpContext.Response.StatusCode, StatusCodes.Status200OK);
Assert.Null(ReadContextResponse());
}
public ExceptionMiddlewareTests()
{
_logger = new Mock <ILoggerManager>();
_middleware = new ExceptionMiddleware(
next: (innerHttpContext) =>
{
return(Task.CompletedTask);
},
_logger.Object
);
}
public async Task Should_return_bad_request_message()
{
RequestDelegateMock
.Setup(x => x.RequestDelegate(It.IsAny <HttpContext>()))
.Returns(Task.FromException(new BadRequestException("Error")));
ExceptionMiddleware = new ExceptionMiddleware(RequestDelegateMock.Object.RequestDelegate);
await ExceptionMiddleware.InvokeAsync(HttpContext);
Assert.AreEqual((int)HttpStatusCode.BadRequest, HttpContext.Response.StatusCode);
}
public async Task Should_return_exception_message()
{
RequestDelegateMock
.Setup(x => x.RequestDelegate(It.IsAny <HttpContext>()))
.Returns(Task.FromException(new Exception()));
ExceptionMiddleware = new ExceptionMiddleware(RequestDelegateMock.Object.RequestDelegate);
await ExceptionMiddleware.InvokeAsync(HttpContext);
Assert.AreEqual("application/json", HttpContext.Response.ContentType);
Assert.AreEqual((int)HttpStatusCode.InternalServerError, HttpContext.Response.StatusCode);
}
public async Task Invoke_HandlesFunctionInvocationExceptions()
{
var ex = new FunctionInvocationException("Kaboom!");
RequestDelegate next = (ctxt) =>
{
throw ex;
};
var middleware = new ExceptionMiddleware(next, _logger);
var context = new DefaultHttpContext();
await middleware.Invoke(context);
Assert.Equal(StatusCodes.Status500InternalServerError, context.Response.StatusCode);
Assert.Empty(_loggerProvider.GetAllLogMessages());
}
public async Task CallsNextInChain()
{
bool called = false;
var classUnderTest = new ExceptionMiddleware(httpContext =>
{
called = true;
return(Task.CompletedTask);
});
var responseStream = new MemoryStream();
var mockResponse = new MockResponse(responseStream);
var mockContext = new MockHttpContext(mockResponse);
await classUnderTest.Invoke(mockContext);
called.Should().BeTrue();
}
public async Task ExceptionRequestTest(string errorText, HttpStatusCode statusCode, Type exceptionType)
{
var connection = Substitute.For <IConnection>();
var request = Substitute.For <IWebApiRequest>();
var context = new MiddlewareContext(connection, request);
var response = Substitute.For <IWebApiResponse>();
response.Content.Returns($"{{\"text\":\"{errorText}\"}}");
response.StatusCode.Returns(statusCode);
var middleware = new ExceptionMiddleware();
var exception = (UnexpectedStatusException <ErrorObject>) await Assert.ThrowsAsync(exceptionType,
() => middleware.OnRequestAsync(context, (c, t) => Task.FromResult(response)));
Assert.Equal(errorText, exception.Response?.Content.Text);
}
/// <summary>
/// This method will be invoked when exception occurs.
/// </summary>
/// <param name="context">Contains all informations about request that has been made.</param>
public override void OnException(ExceptionContext context)
{
// Creating view-model that will be used in Error view.
Error err = ExceptionMiddleware.HandleException(context.Exception);
// Indicates that thrown exception is handled.
context.ExceptionHandled = true;
context.Result = new ViewResult()
{
ViewName = "Error",
ViewData = new ViewDataDictionary(new EmptyModelMetadataProvider(), new ModelStateDictionary())
{
Model = err
}
};
}
public async Task UnexpectedStatusExceptionRequestTest()
{
const string MESSAGE = "{\"error\":\"Some nice error message\"}";
var connection = Substitute.For <IConnection>();
var request = Substitute.For <IWebApiRequest>();
var context = new MiddlewareContext(connection, request);
var response = Substitute.For <IWebApiResponse>();
response.Content.Returns(MESSAGE);
response.StatusCode.Returns((HttpStatusCode)499);
var middleware = new ExceptionMiddleware();
var exception = await Assert.ThrowsAsync <UnexpectedStatusException>(() => middleware.OnRequestAsync(context, (c, t) => Task.FromResult(response)));
Assert.Equal(MESSAGE, exception.Response?.Content);
}
public async Task ExceptionNoJsonRequestTest()
{
const string BODY = "<html><body>This is not JSON</body></html>";
var connection = Substitute.For <IConnection>();
var request = Substitute.For <IWebApiRequest>();
var context = new MiddlewareContext(connection, request);
var response = Substitute.For <IWebApiResponse>();
response.Content.Returns(BODY);
response.StatusCode.Returns(HttpStatusCode.InternalServerError);
var middleware = new ExceptionMiddleware();
var exception = await Assert.ThrowsAsync <UnexpectedStatusException>(() => middleware.OnRequestAsync(context, (c, t) => Task.FromResult(response)));
Assert.Equal(BODY, exception.Response?.Content);
}
public async Task TestUnkownReplacement()
{
var middleware = new ExceptionMiddleware(_loggerFactory, null);
var context = new DefaultHttpContext();
context.Response.Body = new MemoryStream();
await middleware.InvokeAsync(context, (ctx) => throw new Exception());
context.Response.Body.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(context.Response.Body);
var body = reader.ReadToEnd();
var exception = JsonConvert.DeserializeObject <CrpcException>(body);
Assert.Equal(CrpcCodes.Unknown, exception.Message);
Assert.Equal((int)HttpStatusCode.InternalServerError, context.Response.StatusCode);
}
public async Task TestGenericCrpcException()
{
var middleware = new ExceptionMiddleware(_loggerFactory, null);
var context = new DefaultHttpContext();
var thrownException = new CrpcException(CrpcCodes.ValidationFailed);
context.Response.Body = new MemoryStream();
await middleware.InvokeAsync(context, (ctx) => throw thrownException);
context.Response.Body.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(context.Response.Body);
var body = reader.ReadToEnd();
var exception = JsonConvert.DeserializeObject <CrpcException>(body);
Assert.Equal(CrpcCodes.ValidationFailed, exception.Message);
Assert.Equal(thrownException.StatusCode(), (int)context.Response.StatusCode);
}
public async Task Invoke_NoException_DelegateCalled(NullLoggerFactory loggerFactory,
Mock <IServiceProvider> serviceProviderMock)
{
//Arrange
var delegateWasCalled = false;
var requestDelegate = new RequestDelegate(_ =>
{
delegateWasCalled = true;
return(Task.CompletedTask);
});
var httpContext = new Mock <HttpContext>();
var middleware = new ExceptionMiddleware(requestDelegate, loggerFactory, serviceProviderMock.Object);
//Act
await middleware.Invoke(httpContext.Object);
//Assert
delegateWasCalled.Should().BeTrue();
}
public async Task Invoke_HandlesNonHttpExceptions()
{
var ex = new Exception("Kaboom!");
RequestDelegate next = (ctxt) =>
{
throw ex;
};
var middleware = new ExceptionMiddleware(next, _logger);
var context = new DefaultHttpContext();
await middleware.Invoke(context);
Assert.Equal(StatusCodes.Status500InternalServerError, context.Response.StatusCode);
var log = _loggerProvider.GetAllLogMessages().Single();
Assert.Equal("An unhandled host error has occurred.", log.FormattedMessage);
Assert.Same(ex, log.Exception);
}
