public GlobalExceptionMiddlewareTests()
{
_optionsMock = new Mock <IWireMockMiddlewareOptions>();
_optionsMock.SetupAllProperties();
_responseMapperMock = new Mock <IOwinResponseMapper>();
_responseMapperMock.SetupAllProperties();
_responseMapperMock.Setup(m => m.MapAsync(It.IsAny <ResponseMessage>(), It.IsAny <IResponse>())).Returns(Task.FromResult(true));
_sut = new GlobalExceptionMiddleware(null, _optionsMock.Object, _responseMapperMock.Object);
}
public static void UseCustomExceptionHandler(this IApplicationBuilder app, ILogger logger, IOptions <JsonOptions> options)
{
app.UseExceptionHandler(appError =>
{
appError.Run(async context =>
{
// Use exceptionHandlerPathFeature to process the exception (for example,
// logging), but do NOT expose sensitive error information directly to
// the client.
IExceptionHandlerFeature exceptionHandlerPathFeature = context.Features.Get <IExceptionHandlerFeature>();
logger.Error($"[API-Error] => {exceptionHandlerPathFeature.Error}");
await GlobalExceptionMiddleware.HandleAsync(context, exceptionHandlerPathFeature.Error, options);
});
});
}
public async Task MiddlewareShouldWriteACustomErrorToResponseWhenAnHttpExceptionIsThrown()
{
//Arrange
var errorMessage = "Test error";
var errorCode = "1234";
var statusCode = HttpStatusCode.NotFound;
var middleware = new GlobalExceptionMiddleware(next: (innerHttpContext) =>
{
throw new HttpException(statusCode, errorCode, errorMessage);
},
this._logger.Object);
var context = new DefaultHttpContext();
context.Response.Body = new MemoryStream();
//Act
await middleware.InvokeAsync(context);
context.Response.Body.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(context.Response.Body);
var streamText = reader.ReadToEnd();
var result = JsonConvert.DeserializeObject <ResponseBaseDto>(streamText);
//Assert
Assert.IsNotNull(result);
Assert.IsInstanceOf <ResponseBaseDto>(result);
Assert.AreEqual(statusCode, result.StatusCode);
Assert.IsNotNull(result.Data);
var resultError = JsonConvert.DeserializeObject <ErrorResponse>(result.Data.ToString());
Assert.IsInstanceOf <ErrorResponse>(resultError);
Assert.AreEqual(errorCode, resultError.ErrorCode);
Assert.AreEqual(errorMessage, resultError.ErrorMessage);
Assert.AreEqual(Resources.ErrorDescription_Generic, resultError.ErrorDescription);
//Verify logging took place
this._logger.Verify(x => x.Log(LogLevel.Error,
It.IsAny <EventId>(),
It.IsAny <It.IsAnyType>(),
It.IsAny <Exception>(),
(Func <It.IsAnyType, Exception, string>)It.IsAny <object>()), Times.Once);
}
