public async Task Invoke_must_call_requestDelegate_invoker()
{
//Arrange
A.CallTo(() => _next.Invoke(A <HttpContext> .Ignored)).Returns(Task.FromResult(1));
//Act
await _errorHandlingMiddleware.Invoke(_httpContext);
//Assert
A.CallTo(() => _next.Invoke(A <HttpContext> .Ignored)).MustHaveHappened();
}
public async Task Writes_Unhandled_Exceptions_Thrown_In_Inner_Middlewares_As_Errors_In_Response_Body()
{
var written = false;
var httpContext = CreateHttpResponseMock(() => written = true);
Moq.Mock.Get(_next).Setup(n => n.Invoke(It.IsAny <HttpContext>())).ThrowsAsync(new InvalidOperationException("Any error"));
var mockacoContext = Moq.Mock.Of <IMockacoContext>(c => c.Errors == new List <Error>());
await _middleware.Invoke(httpContext, mockacoContext, _statusCodeOptions, _mockProvider, _logger);
written.Should().BeTrue();
}
public async void HttpContextResponseMustConsistsOfDefaultValuesIfCatchedNotProcessableException()
{
var loggerMock = new Mock <ILogger <ErrorHandlingMiddleware> >();
var errorHandlingMiddleware = new ErrorHandlingMiddleware(
next: (innerHttpContext) =>
{
throw new Exception("Something bad is happening!");
},
logger: loggerMock.Object);
var context = new DefaultHttpContext();
context.Response.Body = new MemoryStream();
await errorHandlingMiddleware.Invoke(context);
var responseMessage = "";
var expectedMessage = JsonConvert.SerializeObject(new { errorMessage = "Something bad is happening!" });
using (var memoryStream = context.Response.Body)
{
memoryStream.Position = 0;
var streamReader = new StreamReader(memoryStream);
responseMessage = streamReader.ReadToEnd();
}
Assert.Equal("application/json", context.Response.ContentType);
Assert.Equal(StatusCodes.Status500InternalServerError, context.Response.StatusCode);
Assert.Equal(expectedMessage, responseMessage);
}
public async Task ErrorHandlingMiddleware_ExceptionRaised_ReturnsInternalServerError()
{
var mockLogger = Substitute.For <ILoggerFactory>();
// Arrange
var middleware = new ErrorHandlingMiddleware(next: (innerHttpContext) =>
{
throw new Exception("Something went wrong");
}
, mockLogger);
var context = new DefaultHttpContext();
context.Response.Body = new MemoryStream();
//Act
await middleware.Invoke(context);
context.Response.Body.Seek(0, SeekOrigin.Begin);
string objResponse;
using (var reader = new StreamReader(context.Response.Body))
{
objResponse = reader.ReadToEnd();
}
//Assert
Assert.That(objResponse, Does.Contain("Something went wrong"));
Assert.That(context.Response.StatusCode, Is.EqualTo((int)HttpStatusCode.InternalServerError));
}
public async Task TestMiddleware_HttpAcceptHtml()
{
// Arrange
var logger = Mock.Of <ILogger <ErrorHandlingMiddleware> >();
var middleware = new ErrorHandlingMiddleware((innerHttpContext) =>
{
throw new System.Exception("Error", new System.Exception("inner"));
}, logger);
var context = new DefaultHttpContext();
context.Response.Body = new MemoryStream();
var headerDict = new HeaderDictionary();
var accept = @"text/html; q=0.5, application/json, text/x-dvi; q=0.8, text/x-c";
context.Request.Headers.Add(KeyValuePair.Create <string, StringValues>("Accept", accept));
// Act
await middleware.Invoke(context);
context.Response.Body.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(context.Response.Body);
var streamText = reader.ReadToEnd();
// Assert
context.Response.StatusCode
.Should()
.Be((int)HttpStatusCode.Redirect);
context.Response.Headers["Location"]
.Should().Contain(x => x == "/Error");
}
public async void HttpContextResponseMustConsistsOfValuesAccordingToEmptyCollectionException()
{
var loggerMock = new Mock <ILogger <ErrorHandlingMiddleware> >();
var errorHandlingMiddleware = new ErrorHandlingMiddleware(
next: (innerHttpContext) =>
{
throw new EmptyCollectionException("Collection is empty");
},
logger: loggerMock.Object);
var context = new DefaultHttpContext();
context.Response.Body = new MemoryStream();
await errorHandlingMiddleware.Invoke(context);
var responseMessage = "";
var expectedMessage = JsonConvert.SerializeObject(new { errorMessage = "Collection is empty" });
using (var memoryStream = context.Response.Body)
{
memoryStream.Position = 0;
var streamReader = new StreamReader(memoryStream);
responseMessage = streamReader.ReadToEnd();
}
Assert.Equal("application/json", context.Response.ContentType);
Assert.Equal(StatusCodes.Status204NoContent, context.Response.StatusCode);
Assert.Equal(expectedMessage, responseMessage);
}
public async Task ErrorHandlingMiddleware_NotFoundExceptionRaised_ReturnsNotFoundtWithId()
{
var mockLogger = Substitute.For <ILoggerFactory>();
// Arrange
var middleware = new ErrorHandlingMiddleware(next: (innerHttpContext) =>
{
throw new NotFoundException("Patient", 1);
}
, mockLogger);
var context = new DefaultHttpContext();
context.Response.Body = new MemoryStream();
//Act
await middleware.Invoke(context);
context.Response.Body.Seek(0, SeekOrigin.Begin);
string objResponse;
using (var reader = new StreamReader(context.Response.Body))
{
objResponse = reader.ReadToEnd();
}
//Assert
Assert.That(objResponse, Does.Contain("(1) was not found."));
Assert.That(context.Response.StatusCode, Is.EqualTo((int)HttpStatusCode.NotFound));
}
public async Task WhenAnUnExpectedExceptionIsRaised_ErrorHandlingMiddlewareShouldHandleItToCustomErrorResponseAndCorrectHttpStatus()
{
// Arrange
var middleware = new ErrorHandlingMiddleware((innerHttpContext) =>
{
throw new NullReferenceException("Test");
},
new NullLoggerFactory());
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 message = reader.ReadToEnd();
//Assert
message
.Should()
.BeEquivalentTo("Ops, something bad happened");
context.Response.StatusCode
.Should()
.Be((int)HttpStatusCode.BadRequest);
}
public async Task TestMiddleware_StandardBehavior()
{
// Arrange
var logger = Mock.Of <ILogger <ErrorHandlingMiddleware> >();
var middleware = new ErrorHandlingMiddleware((innerHttpContext) =>
{
throw new System.Exception("Error", new System.Exception("inner"));
}, logger);
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 pd = JsonSerializer.Deserialize <ProblemDetails>(streamText);
// Assert
pd.Type.Should().Be("about:blank");
pd.Title.Should().StartWith("error during request: ");
pd.Status.Should().Be(500);
pd.Detail.Should().Be("Error, inner");
context.Response.StatusCode
.Should()
.Be((int)HttpStatusCode.InternalServerError);
}
public async Task Writes_Unhandled_Exceptions_Thrown_In_Inner_Middlewares_As_Errors_In_Response_Body()
{
DefaultHttpContext httpContext = GetHttpContextForTest();
var anyException = new InvalidOperationException("Any error");
Moq.Mock.Get(_next).Setup(n => n.Invoke(It.IsAny <HttpContext>())).ThrowsAsync(anyException);
var mockacoContext = Moq.Mock.Of <IMockacoContext>(c => c.Errors == new List <Error>());
await _middleware.Invoke(httpContext, mockacoContext, _statusCodeOptions, _mockProvider, _logger);
var body = await ReadResponseBody(httpContext);
var bodyAsJToken = JToken.Parse(body);
bodyAsJToken.Should().NotBeNullOrEmpty();
bodyAsJToken.SelectToken("$[0].Exception.ClassName").ToString().Should().Be(anyException.GetType().FullName);
bodyAsJToken.SelectToken("$[0].Exception.Message").ToString().Should().Be(anyException.Message);
httpContext.Response.StatusCode.Should().Be(501);
httpContext.Response.ContentType.Should().Be("application/json");
}
public async Task ErrorInDeDelegateMustBeConvertedToResponseError()
{
Task ReqDelegate(HttpContext context)
{
throw new Exception("Unhandled");
}
DefaultHttpContext defaultHttpContext = new DefaultHttpContext();
ErrorHandlingMiddleware errorHandlingMiddleware = new ErrorHandlingMiddleware(ReqDelegate);
await errorHandlingMiddleware.Invoke(defaultHttpContext);
Assert.IsTrue(defaultHttpContext.Response.StatusCode == (int)HttpStatusCode.InternalServerError);
}
public async Task Error_Handling_Middleware_Success()
{
var errorHandlingMiddleware = new ErrorHandlingMiddleware(
async(innerHttpContext) =>
{
await innerHttpContext.Response.WriteAsync("test response body");
}, _mockLoggerFactory.Object);
var context = new DefaultHttpContext();
await errorHandlingMiddleware.Invoke(context);
context.Response.StatusCode.Should().Be((int)HttpStatusCode.OK);
}
public async Task ErrorHandlingMiddlewareMustCallNextDelegate()
{
var delegateWasExecuted = false;
Task ReqDelegate(HttpContext context)
{
delegateWasExecuted = true;
return(Task.CompletedTask);
}
ErrorHandlingMiddleware errorHandlingMiddleware = new ErrorHandlingMiddleware(ReqDelegate);
await errorHandlingMiddleware.Invoke(new DefaultHttpContext());
Assert.IsTrue(delegateWasExecuted);
}
public void ChangeSuccessStatusCodeTo500AndRethrowException(int requestStatusCode, int responseStatusCode)
{
// Arrange
var context = new DefaultHttpContext();
var middleware = new ErrorHandlingMiddleware(innerHttpContext =>
{
innerHttpContext.Response.StatusCode = requestStatusCode;
throw new Exception("Exception");
}, Substitute.For <ILogger <ErrorHandlingMiddleware> >());
// Act
Func <Task> action = async() => await middleware.Invoke(context);
// Assert
action.Should().Throw <Exception>().WithMessage("Exception");
context.Response.StatusCode.Should().Be(responseStatusCode);
}
private async Task <(ErrorResponse errorResponse, int statusCode)> GetResponseFromContext(ErrorHandlingMiddleware mw)
{
var context = new DefaultHttpContext();
using var memoryStream = new MemoryStream();
context.Response.Body = memoryStream;
await mw.Invoke(context);
memoryStream.Position = 0;
using var reader = new StreamReader(memoryStream);
var content = reader.ReadToEnd();
var response = JsonConvert.DeserializeObject <ErrorResponse>(content);
return(response, context.Response.StatusCode);
}
public async void Invoke_ShouldDoNothing_WhenNextThrowsNoExceptions()
{
var httpContext = new Mock <HttpContext>();
var httpResponse = new Mock <HttpResponse>();
httpContext.Setup(a => a.Response).Returns(httpResponse.Object);
RequestDelegate next = (a) =>
{
return(Task.Run(() => { }));
};
var classUnderTest = new ErrorHandlingMiddleware(next);
await classUnderTest.Invoke(httpContext.Object);
VerifyHttpResponse(httpResponse, It.IsAny <string>(), It.IsAny <int>(), Times.Never());
}
public async Task Return404StatusCodeForNotFoundException()
{
// Arrange
var context = new DefaultHttpContext();
context.Response.StatusCode = StatusCodes.Status200OK;
var middleware = new ErrorHandlingMiddleware(innerHttpContext =>
{
throw new NotFoundException();
}, Substitute.For <ILogger <ErrorHandlingMiddleware> >());
// Act
await middleware.Invoke(context);
// Assert
context.Response.StatusCode.Should().Be(StatusCodes.Status404NotFound);
}
public async Task TestMiddleware_LoginChallengeException()
{
// Arrange
var logger = Mock.Of <ILogger <ErrorHandlingMiddleware> >();
var middleware = new ErrorHandlingMiddleware((innerHttpContext) =>
{
throw new LoginChallengeException("login");
}, logger);
var context = new DefaultHttpContext();
context.Response.Body = new MemoryStream();
// Act && Assert
await Assert.ThrowsAsync <LoginChallengeException>(() => {
return(middleware.Invoke(context));
});
}
private async Task VerifyErrorHandling(Exception exception, string expectedErrorMessage, HttpStatusCode expectedResponseCode, ApiErrorCode expectedApiErrorCode)
{
// Arrange
RequestDelegate next = (innerHttpContext) => Task.FromException <Exception>(exception);
var loggerMock = new Mock <ILogger <ErrorHandlingMiddleware> >();
var contextMock = new Mock <HttpContext>();
var responseMock = new Mock <HttpResponse>();
var body = new MemoryStream();
int responseCode = 0;
loggerMock.Setup(m => m.Log(
LogLevel.Warning,
It.IsAny <EventId>(),
It.Is <FormattedLogValues>(v => v.ToString().Contains(expectedErrorMessage)),
It.IsAny <Exception>(),
It.IsAny <Func <object, Exception, string> >()
));
contextMock.SetupGet(x => x.Response).Returns(responseMock.Object);
responseMock.SetupGet(x => x.Body).Returns(body);
responseMock.SetupSet(x => x.StatusCode = It.IsAny <int>()).Callback <int>(y => responseCode = y);
var middleware = new ErrorHandlingMiddleware(next: next, logger: loggerMock.Object);
// Act
await middleware.Invoke(contextMock.Object);
body.Position = 0;
var serializedResult = Encoding.UTF8.GetString(body.ToArray());
body.Dispose();
// Assert
loggerMock.VerifyAll();
contextMock.VerifyAll();
responseMock.VerifyAll();
Assert.That(responseCode, Is.EqualTo((int)expectedResponseCode));
Assert.That(serializedResult, Is.Not.Null);
dynamic myobject = JsonConvert.DeserializeObject(serializedResult);
string errorMessage = myobject.Error;
ApiErrorCode apiErrorCode = myobject.ApiErrorCode;
Assert.That(errorMessage, Is.EqualTo(expectedErrorMessage));
Assert.That(apiErrorCode, Is.EqualTo(expectedApiErrorCode));
}
public async void ProperInformationMustBeLoggedWhenNotHandledExceptionIsRaised()
{
var context = new DefaultHttpContext();
var loggerMock = new Mock <ILogger <ErrorHandlingMiddleware> >();
var errorHandlingMiddleware = new ErrorHandlingMiddleware(
next: (innerHttpContext) =>
{
throw new Exception("Something bad is happening here!");
},
logger: loggerMock.Object);
await errorHandlingMiddleware.Invoke(context);
loggerMock.Verify(exp => exp.Log(It.Is <LogLevel>(x => x == LogLevel.Error),
It.IsAny <EventId>(),
It.IsAny <Object>(),
It.Is <Exception>(y => y.Message == "Something bad is happening here!"),
It.IsAny <Func <object, Exception, string> >()));
}
public async void Invoke_ShouldAssembleAnErrorResponse_WhenNextThrowsAnException(Exception ex, int statusCode)
{
var httpContext = new Mock <HttpContext>();
var httpResponse = new Mock <HttpResponse>();
httpContext.Setup(a => a.Response).Returns(httpResponse.Object);
httpResponse.Setup(a => a.Body).Returns(new MemoryStream());
RequestDelegate next = (a) =>
{
return(Task.FromException(ex));
};
var classUnderTest = new ErrorHandlingMiddleware(next);
await classUnderTest.Invoke(httpContext.Object);
VerifyHttpResponse(httpResponse, "application/json", statusCode, Times.Once());
}
public async Task ErrorHandlingMiddleware_ValidationExceptionRaised_ReturnsBadRquestWithValidationErrors()
{
var mockLogger = Substitute.For <ILoggerFactory>();
// Arrange
var middleware = new ErrorHandlingMiddleware(next: (innerHttpContext) =>
{
throw new ValidationException(
new List <ValidationFailure> {
new ValidationFailure("Error", "Big error")
});
}
, mockLogger);
var context = new DefaultHttpContext();
context.Response.Body = new MemoryStream();
//Act
await middleware.Invoke(context);
context.Response.Body.Seek(0, SeekOrigin.Begin);
Dictionary <string, string[]> objResponse;
using (var reader = new StreamReader(context.Response.Body))
{
var streamText = reader.ReadToEnd();
objResponse = JsonConvert.DeserializeObject <Dictionary <string, string[]> >(streamText);
}
//Assert
var firstError = objResponse.TryGetValue("Error", out string[] errors);
Assert.That(errors[0], Is.EqualTo("Big error"));
Assert.That(context.Response.StatusCode, Is.EqualTo((int)HttpStatusCode.BadRequest));
}
public async Task ExceptionTests()
{
// Arrange
var statusCode = 200;
var contentType = "";
var stream = new MemoryStream();
var fakeResponse = new Mock <HttpResponse>();
fakeResponse
.SetupSet(x => x.StatusCode)
.Callback(val => statusCode = val);
fakeResponse
.SetupSet(x => x.ContentType)
.Callback(val => contentType = val);
fakeResponse
.SetupGet(x => x.BodyPipe)
.Returns(new StreamPipeWriter(stream));
fakeResponse
.SetupGet(x => x.Body)
.Returns(stream);
var fakeHttpContext = new Mock <HttpContext>();
fakeHttpContext
.SetupGet(x => x.Response)
.Returns(fakeResponse.Object);
var handler = new ErrorHandlingMiddleware((ctx =>
{
throw new Exception("Test Exception");
}));
// Act
await handler.Invoke(fakeHttpContext.Object);
// Assert
Assert.Equal(500, statusCode);
Assert.Equal("application/json", contentType);
}
public async Task Invoke_LogsWhenExceptionIsThrown()
{
await _middleware.Invoke(new DefaultHttpContext());
_logger.Verify(o => o.Log(LogLevel.Error, It.IsAny <EventId>(), It.IsAny <object>(), It.IsAny <DivideByZeroException>(), It.IsAny <Func <object, Exception, string> >()));
}
