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 IPipelineBuilder UseExceptionHandler(Func <HttpContext, Task <IActionResult> > executeFunctions) { PipelineBuilder builder = new PipelineBuilder(this._httpContextAccessor); var middleware = new ExceptionHandlingMiddleware(); return(builder.Use(middleware) .Use(new FunctionsMiddleware(executeFunctions))); }
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 ExceptionHandlingMiddlewareTests() { _innerFunction = Substitute.For <IDummyRequestDelegate>(); _next = async(context) => { await _innerFunction.CallMe(context); await Task.CompletedTask; }; _middleware = Substitute.ForPartsOf <ExceptionHandlingMiddleware>(_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 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);
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 WhenANormalRequestIsMade() { // Arrange RequestDelegate next = (HttpContext hc) => Task.CompletedTask; var middleware = new ExceptionHandlingMiddleware(next); var context = new DefaultHttpContext(); await AssertTest(context, middleware); context.Response.StatusCode .Should() .Be((int)HttpStatusCode.OK); }
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 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 WhenANotFoundExceptionIsRaised() { var middleware = new ExceptionHandlingMiddleware((innerHttpContext) => { throw new NotFoundException("Not found"); }); var context = new DefaultHttpContext(); var streamText = await AssertTest(context, middleware); streamText.Should().BeEquivalentTo("Not found"); context.Response.StatusCode .Should() .Be((int)HttpStatusCode.NotFound); }
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 WhenAnUnExpectedExceptionIsRaised() { var middleware = new ExceptionHandlingMiddleware(next: (innerHttpContext) => { throw new Exception("Test"); }); var context = new DefaultHttpContext(); var streamText = await AssertTest(context, middleware); streamText.Should().BeEquivalentTo("Bad Request"); context.Response.StatusCode .Should() .Be((int)HttpStatusCode.BadRequest); }
public async Task ExecuteAsync_CommonException_HandlesException() { var exceptionHandler = new SyncPingCommonExceptionHandler(); var middleware = new ExceptionHandlingMiddleware <Ping, int>(new[] { exceptionHandler }); var query = new Ping(); var handler = new BrokenPingHandler(); var actual = await middleware.ExecuteAsync( query, () => handler.HandleAsync(query, default), default ); actual.Should().Be(exceptionHandler.Value); }
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 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 ExecuteAsync_MultipleExceptionHandlers_UsesConcreteHandler() { var concreteExceptionHandler = new SyncPingConcreteExceptionHandler(); var middleware = new ExceptionHandlingMiddleware <Ping, int>( new IQueryExceptionHandler <Ping, int>[] { new SyncPingCommonExceptionHandler(), concreteExceptionHandler } ); var query = new Ping(); var handler = new BrokenPingHandler(); var actual = await middleware.ExecuteAsync( query, () => handler.HandleAsync(query, default), default ); actual.Should().Be(concreteExceptionHandler.Value); }
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); }
public ExceptionHandlingMiddlewareTest() { _httpContext.Response.Body = _responseStream; _sut = new ExceptionHandlingMiddleware(_next); }