private void button2_Click(object sender, EventArgs e)
{
System.DataMisalignedException ex = new DataMisalignedException("Erro de prueba");
ServiceError svcError = Fwk.Exceptions.ExceptionHelper.GetServiceError(ex);
MessageBox.Show(svcError.GetXml());
Exception ex2 = Fwk.Exceptions.ExceptionHelper.ProcessException(svcError);
Exception ex3 = Fwk.Exceptions.ExceptionHelper.ProcessException(ex);
}
public async Task InvokeAction_InvokesAsyncActionFilter_WithExceptionThrownByActionFilter()
{
// Arrange
var exception = new DataMisalignedException();
ActionExecutedContext context = null;
var filter1 = new Mock<IAsyncActionFilter>(MockBehavior.Strict);
filter1
.Setup(f => f.OnActionExecutionAsync(It.IsAny<ActionExecutingContext>(), It.IsAny<ActionExecutionDelegate>()))
.Returns<ActionExecutingContext, ActionExecutionDelegate>(async (c, next) =>
{
context = await next();
// Handle the exception so the test doesn't throw.
Assert.False(context.ExceptionHandled);
context.ExceptionHandled = true;
})
.Verifiable();
var filter2 = new Mock<IActionFilter>(MockBehavior.Strict);
filter2.Setup(f => f.OnActionExecuting(It.IsAny<ActionExecutingContext>())).Verifiable();
filter2
.Setup(f => f.OnActionExecuted(It.IsAny<ActionExecutedContext>()))
.Callback<ActionExecutedContext>(c => { throw exception; })
.Verifiable();
var invoker = CreateInvoker(new IFilterMetadata[] { filter1.Object, filter2.Object });
// Act
await invoker.InvokeAsync();
// Assert
filter1.Verify(
f => f.OnActionExecutionAsync(It.IsAny<ActionExecutingContext>(), It.IsAny<ActionExecutionDelegate>()),
Times.Once());
filter2.Verify(f => f.OnActionExecuting(It.IsAny<ActionExecutingContext>()), Times.Once());
Assert.Same(exception, context.Exception);
Assert.Null(context.Result);
}
public async Task InvokeAction_InvokesResourceFilter_OnResourceExecuted_ThrowsUnhandledException()
{
// Arrange
var expected = new DataMisalignedException();
ResourceExecutedContext context = null;
var resourceFilter1 = new Mock<IAsyncResourceFilter>(MockBehavior.Strict);
resourceFilter1
.Setup(f => f.OnResourceExecutionAsync(It.IsAny<ResourceExecutingContext>(), It.IsAny<ResourceExecutionDelegate>()))
.Returns<ResourceExecutingContext, ResourceExecutionDelegate>(async (c, next) =>
{
context = await next();
})
.Verifiable();
var resourceFilter2 = new Mock<IResourceFilter>(MockBehavior.Loose);
resourceFilter2
.Setup(f => f.OnResourceExecuted(It.IsAny<ResourceExecutedContext>()))
.Callback<ResourceExecutedContext>((c) =>
{
throw expected;
})
.Verifiable();
var invoker = CreateInvoker(new IFilterMetadata[] { resourceFilter1.Object, resourceFilter2.Object }, actionThrows: true);
// Act
var exception = await Assert.ThrowsAsync<DataMisalignedException>(invoker.InvokeAsync);
// Assert
Assert.Same(expected, exception);
Assert.Same(expected, context.Exception);
Assert.Same(expected, context.ExceptionDispatchInfo.SourceException);
}
public async Task InvokeAction_InvokesAsyncResourceFilter_HandlesException_FromResultFilter()
{
// Arrange
var expected = new DataMisalignedException();
ResourceExecutedContext context = null;
var resourceFilter = new Mock<IAsyncResourceFilter>(MockBehavior.Strict);
resourceFilter
.Setup(f => f.OnResourceExecutionAsync(It.IsAny<ResourceExecutingContext>(), It.IsAny<ResourceExecutionDelegate>()))
.Returns<ResourceExecutingContext, ResourceExecutionDelegate>(async (c, next) =>
{
context = await next();
context.ExceptionHandled = true;
})
.Verifiable();
var resultFilter = new Mock<IResultFilter>(MockBehavior.Loose);
resultFilter
.Setup(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>()))
.Callback<ResultExecutingContext>((c) =>
{
throw expected;
});
var invoker = CreateInvoker(new IFilterMetadata[] { resourceFilter.Object, resultFilter.Object });
// Act
await invoker.InvokeAsync();
// Assert
Assert.Same(expected, context.Exception);
Assert.Same(expected, context.ExceptionDispatchInfo.SourceException);
resourceFilter.Verify(
f => f.OnResourceExecutionAsync(It.IsAny<ResourceExecutingContext>(), It.IsAny<ResourceExecutionDelegate>()),
Times.Once());
}
public async Task InvokeAction_InvokesAsyncResultFilter_WithExceptionThrownByResultFilter()
{
// Arrange
ResultExecutedContext context = null;
var exception = new DataMisalignedException();
var resultFilter1 = new Mock<IAsyncResultFilter>(MockBehavior.Strict);
resultFilter1
.Setup(f => f.OnResultExecutionAsync(It.IsAny<ResultExecutingContext>(), It.IsAny<ResultExecutionDelegate>()))
.Returns<ResultExecutingContext, ResultExecutionDelegate>(async (c, next) =>
{
context = await next();
// Handle the exception
Assert.False(context.ExceptionHandled);
context.ExceptionHandled = true;
})
.Verifiable();
var resultFilter2 = new Mock<IResultFilter>(MockBehavior.Strict);
resultFilter2
.Setup(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>()))
.Throws(exception)
.Verifiable();
var resultFilter3 = new Mock<IResultFilter>(MockBehavior.Strict);
var invoker = CreateInvoker(new IFilterMetadata[] { resultFilter1.Object, resultFilter2.Object, resultFilter3.Object });
// Act
await invoker.InvokeAsync();
// Assert
Assert.Same(exception, context.Exception);
resultFilter1.Verify(
f => f.OnResultExecutionAsync(It.IsAny<ResultExecutingContext>(), It.IsAny<ResultExecutionDelegate>()),
Times.Once());
resultFilter2.Verify(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>()), Times.Once());
}
public async Task InvokeAction_InvokesResultFilter_WithExceptionThrownByResult()
{
// Arrange
ResultExecutedContext context = null;
var exception = new DataMisalignedException();
var result = new Mock<IActionResult>(MockBehavior.Strict);
result
.Setup(r => r.ExecuteResultAsync(It.IsAny<ActionContext>()))
.Throws(exception)
.Verifiable();
var filter = new Mock<IResultFilter>(MockBehavior.Strict);
filter
.Setup(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>()))
.Callback<ResultExecutingContext>(c => c.Result = result.Object)
.Verifiable();
filter
.Setup(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>()))
.Callback<ResultExecutedContext>(c =>
{
context = c;
// Handle the exception
Assert.False(c.ExceptionHandled);
c.ExceptionHandled = true;
})
.Verifiable();
var invoker = CreateInvoker(filter.Object);
// Act
await invoker.InvokeAsync();
// Assert
Assert.Same(exception, context.Exception);
result.Verify(r => r.ExecuteResultAsync(It.IsAny<ActionContext>()), Times.Once());
filter.Verify(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>()), Times.Once());
filter.Verify(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>()), Times.Once());
}
public async Task InvokeAction_InvokesResultFilter_ExceptionGoesUnhandled()
{
// Arrange
var exception = new DataMisalignedException();
var result = new Mock<IActionResult>(MockBehavior.Strict);
result
.Setup(r => r.ExecuteResultAsync(It.IsAny<ActionContext>()))
.Throws(exception)
.Verifiable();
var filter = new Mock<IResultFilter>(MockBehavior.Strict);
filter
.Setup(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>()))
.Callback<ResultExecutingContext>(c => c.Result = result.Object)
.Verifiable();
filter.Setup(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>())).Verifiable();
var invoker = CreateInvoker(filter.Object);
// Act
await Assert.ThrowsAsync(exception.GetType(), async () => await invoker.InvokeAsync());
// Assert
result.Verify(r => r.ExecuteResultAsync(It.IsAny<ActionContext>()), Times.Once());
filter.Verify(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>()), Times.Once());
filter.Verify(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>()), Times.Once());
}
public async Task InvokeAction_InvokesResultFilter_WithExceptionThrownByResultFilter()
{
// Arrange
ResultExecutedContext context = null;
var exception = new DataMisalignedException();
var resultFilter1 = new Mock<IResultFilter>(MockBehavior.Strict);
resultFilter1.Setup(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>())).Verifiable();
resultFilter1
.Setup(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>()))
.Callback<ResultExecutedContext>(c =>
{
context = c;
// Handle the exception
Assert.False(c.ExceptionHandled);
c.ExceptionHandled = true;
})
.Verifiable();
var resultFilter2 = new Mock<IResultFilter>(MockBehavior.Strict);
resultFilter2
.Setup(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>()))
.Throws(exception)
.Verifiable();
var resultFilter3 = new Mock<IResultFilter>(MockBehavior.Strict);
var invoker = CreateInvoker(new IFilter[] { resultFilter1.Object, resultFilter2.Object, resultFilter3.Object });
// Act
await invoker.InvokeActionAsync();
// Assert
Assert.Equal(exception, context.Exception);
resultFilter1.Verify(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>()), Times.Once());
resultFilter1.Verify(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>()), Times.Once());
resultFilter2.Verify(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>()), Times.Once());
}
public async Task InvokeAction_InvokesAsyncResultFilter_WithExceptionThrownByResult()
{
// Arrange
ResultExecutedContext context = null;
var exception = new DataMisalignedException();
var result = new Mock<IActionResult>(MockBehavior.Strict);
result
.Setup(r => r.ExecuteResultAsync(It.IsAny<ActionContext>()))
.Throws(exception)
.Verifiable();
var filter = new Mock<IAsyncResultFilter>(MockBehavior.Strict);
filter
.Setup(f => f.OnResultExecutionAsync(It.IsAny<ResultExecutingContext>(), It.IsAny<ResultExecutionDelegate>()))
.Returns<ResultExecutingContext, ResultExecutionDelegate>(async (c, next) =>
{
c.Result = result.Object;
context = await next();
// Handle the exception
Assert.False(context.ExceptionHandled);
context.ExceptionHandled = true;
})
.Verifiable();
var invoker = CreateInvoker(filter.Object);
// Act
await invoker.InvokeActionAsync();
// Assert
Assert.Equal(exception, context.Exception);
result.Verify(r => r.ExecuteResultAsync(It.IsAny<ActionContext>()), Times.Once());
filter.Verify(
f => f.OnResultExecutionAsync(It.IsAny<ResultExecutingContext>(), It.IsAny<ResultExecutionDelegate>()),
Times.Once());
}
