public async void MiddlewareShouldCatchNonBusinessExceptionsWithInternalServerErrorAndNoResponse() { var message = Guid.NewGuid().ToString(); RequestDelegate requestDelegate = (innerHttpContext) => throw new InvalidOperationException(message); var middleware = new ExceptionHandlingMiddleware(requestDelegate, _loggerMock.Object); var context = new DefaultHttpContext(); context.Response.Body = new MemoryStream(); await middleware.Invoke(context); context.Response.Body.Seek(0, SeekOrigin.Begin); using (var reader = new StreamReader(context.Response.Body)) { var streamText = reader.ReadToEnd(); Assert.Empty(streamText); } Assert.Equal((int)HttpStatusCode.InternalServerError, context.Response.StatusCode); _loggerMock.Verify( x => x.Log <object>( LogLevel.Error, It.IsAny <EventId>(), It.Is <object>(y => y.ToString() == message), It.IsAny <Exception>(), It.IsAny <Func <object, Exception, string> >()), Times.Once()); }
public async Task Write_400_Response_If_ValidationException_Is_Thrown() { var failures = new List <ValidationFailure> { new ValidationFailure("name", "name can not be empty") }; var exception = new ValidationException(failures); Task next(HttpContext context) { throw exception; } var middleware = new ExceptionHandlingMiddleware(next); var context = HttpContextFactory.Create(); await middleware.Invoke(context); Assert.AreEqual("application/json", context.Response.ContentType); Assert.AreEqual(400, context.Response.StatusCode); var failuresResponse = await context.Response.ReadAsAsync <List <ValidationFailure> >(); Assert.AreEqual(exception.Errors.ToList()[0].ErrorMessage, failuresResponse[0].ErrorMessage); }
public async Task WhenExecutingExceptionMiddleware_GivenAnHttpContextWithNoException_TheResponseShouldBeEmpty() { ExceptionHandlingMiddleware baseExceptionMiddleware = CreateExceptionHandlingMiddleware(innerHttpContext => Task.CompletedTask); await baseExceptionMiddleware.Invoke(_context); Assert.Equal(200, _context.Response.StatusCode); Assert.Null(_context.Response.ContentType); Assert.Equal(0, _context.Response.Body.Length); }
public async void Should_logSuccessMessage() { //Arrange var mockedLogger = Mock.Of <ILogger <ExceptionHandlingMiddleware> >(); var correlationMiddleWare = new ExceptionHandlingMiddleware(mockedLogger); var sentMessage = new { Field = "value" }; var envelope = new MessagingEnvelope(new System.Collections.Generic.Dictionary <string, string>(), sentMessage); Task next() => Task.CompletedTask; //Act await correlationMiddleWare.Invoke(new MessagingContext(envelope, string.Empty, null), default, next);
private async Task <string> AssertTest(DefaultHttpContext context, ExceptionHandlingMiddleware middleware) { context.Response.Body = new MemoryStream(); await middleware.Invoke(context); context.Response.Body.Seek(0, SeekOrigin.Begin); var reader = new StreamReader(context.Response.Body); var streamText = reader.ReadToEnd(); return(streamText); }
public async Task GivenAnInternalServerException_WhenMiddlewareIsExecuted_ThenMessageShouldBeOverwritten() { ExceptionHandlingMiddleware baseExceptionMiddleware = CreateExceptionHandlingMiddleware(innerHttpContext => throw new Exception("Unhandled exception.")); baseExceptionMiddleware.ExecuteResultAsync(Arg.Any <HttpContext>(), Arg.Any <IActionResult>()).Returns(Task.CompletedTask); await baseExceptionMiddleware.Invoke(_context); await baseExceptionMiddleware .Received() .ExecuteResultAsync( Arg.Any <HttpContext>(), Arg.Is <ContentResult>(x => x.Content == DicomApiResource.InternalServerError)); }
public async Task GivenAnException_WhenMiddlewareIsExecuted_ThenCorrectStatusCodeShouldBeRetruned(Exception exception, HttpStatusCode expectedStatusCode) { ExceptionHandlingMiddleware baseExceptionMiddleware = CreateExceptionHandlingMiddleware(innerHttpContext => throw exception); baseExceptionMiddleware.ExecuteResultAsync(Arg.Any <HttpContext>(), Arg.Any <IActionResult>()).Returns(Task.CompletedTask); await baseExceptionMiddleware.Invoke(_context); await baseExceptionMiddleware .Received() .ExecuteResultAsync( Arg.Any <HttpContext>(), Arg.Is <ContentResult>(x => x.StatusCode == (int)expectedStatusCode)); }
public async Task Call_Next_If_No_Exception() { var isCalled = false; Task next(HttpContext context) { isCalled = true; return(Task.FromResult(0)); } var middleware = new ExceptionHandlingMiddleware(next); await middleware.Invoke(null); Assert.IsTrue(isCalled); }
public async Task It_returns_500_when_unhandled_exception_is_thrown() { const int expected = StatusCodes.Status500InternalServerError; var e = new FormatException(); var next = ThrowableRequestDelegate(e); var sut = new ExceptionHandlingMiddleware(next); await sut.Invoke(_httpContext); var actual = _httpContext.Response.StatusCode; Assert.Equal(expected, actual); }
public async Task It_returns_404_when_rss_not_parsable_is_thrown() { const int expected = StatusCodes.Status404NotFound; var e = new RssNotParsableException(); var next = ThrowableRequestDelegate(e); var sut = new ExceptionHandlingMiddleware(next); await sut.Invoke(_httpContext); var actual = _httpContext.Response.StatusCode; Assert.Equal(expected, actual); }
public async Task Write_500_Response_If_Anonther_Is_Thrown() { var exception = new Exception("input invalid"); Task next(HttpContext context) { throw exception; } var middleware = new ExceptionHandlingMiddleware(next); var context = HttpContextFactory.Create(); await middleware.Invoke(context); Assert.AreEqual("application/json", context.Response.ContentType); Assert.AreEqual(500, context.Response.StatusCode); Assert.AreEqual(exception.Message, await context.Response.ReadAsAsync <string>()); }
public async Task Write_404_Response_If_NotFound_Is_Thrown() { var exception = new NotFoundException("Category", 1); Task next(HttpContext context) { throw exception; } var middleware = new ExceptionHandlingMiddleware(next); var context = HttpContextFactory.Create(); await middleware.Invoke(context); Assert.AreEqual("application/json", context.Response.ContentType); Assert.AreEqual(404, context.Response.StatusCode); Assert.AreEqual(exception.Message, await context.Response.ReadAsAsync <string>()); }
public async void MiddlewareShouldCatchBusinessExceptionsWithBadRequestAndMessageTest() { var message = Guid.NewGuid().ToString(); RequestDelegate requestDelegate = (innerHttpContext) => throw new BusinessException(message); var middleware = new ExceptionHandlingMiddleware(requestDelegate, _loggerMock.Object); var context = new DefaultHttpContext(); context.Response.Body = new MemoryStream(); await middleware.Invoke(context); context.Response.Body.Seek(0, SeekOrigin.Begin); using (var reader = new StreamReader(context.Response.Body, Encoding.UTF8)) { var streamText = reader.ReadToEnd(); Assert.Equal(message, streamText); } Assert.Equal((int)HttpStatusCode.BadRequest, context.Response.StatusCode); }