public void ExecuteAsync_IfInnerResultTaskIsCanceled_ReturnsCanceledTask()
{
// Arrange
List <string> log = new List <string>();
HttpActionContext actionContext = ContextUtil.CreateActionContext();
var exceptionFilter = CreateExceptionFilter((ec, ct) =>
{
log.Add("exceptionFilter");
return(Task.Factory.StartNew(() => { }));
});
var filters = new IExceptionFilter[] { exceptionFilter };
IExceptionLogger exceptionLogger = CreateStubExceptionLogger();
IExceptionHandler exceptionHandler = CreateStubExceptionHandler();
var actionResult = CreateStubActionResult(TaskHelpers.Canceled <HttpResponseMessage>());
IHttpActionResult product = CreateProductUnderTest(actionContext, filters, exceptionLogger,
exceptionHandler, actionResult);
// Act
var result = product.ExecuteAsync(CancellationToken.None);
// Assert
Assert.NotNull(result);
result.WaitUntilCompleted();
Assert.Equal(TaskStatus.Canceled, result.Status);
Assert.Equal(new string[] { "exceptionFilter" }, log.ToArray());
}
public RescueFilter(IPipe <TRescueContext> rescuePipe, IExceptionFilter exceptionFilter,
RescueContextFactory <TContext, TRescueContext> rescueContextFactory)
{
_rescuePipe = rescuePipe;
_exceptionFilter = exceptionFilter;
_rescueContextFactory = rescueContextFactory;
}
public async Task ExecuteAsync_IfFaultedTaskExceptionIsUnhandled_PreservesExceptionStackTrace()
{
// Arrange
Exception originalException = CreateExceptionWithStackTrace();
string expectedStackTrace = originalException.StackTrace;
using (HttpRequestMessage request = CreateRequest())
{
HttpActionContext context = CreateActionContext(request);
IExceptionFilter[] filters = new IExceptionFilter[0];
IExceptionLogger exceptionLogger = CreateStubExceptionLogger();
IExceptionHandler exceptionHandler = CreateStubExceptionHandler();
IHttpActionResult innerResult = CreateStubActionResult(
CreateFaultedTask <HttpResponseMessage>(originalException));
IHttpActionResult product = CreateProductUnderTest(context, filters, exceptionLogger, exceptionHandler,
innerResult);
// Act & Assert
var exception = await Assert.ThrowsAsync <InvalidOperationException>(
() => product.ExecuteAsync(CancellationToken.None));
Assert.NotNull(expectedStackTrace);
Assert.NotNull(exception);
Assert.NotNull(exception.StackTrace);
Assert.True(exception.StackTrace.StartsWith(expectedStackTrace));
}
}
public async Task ExecuteAsync_IfInnerResultTaskIsSuccessful_ReturnsSuccessTask()
{
// Arrange
List <string> log = new List <string>();
HttpActionContext actionContext = ContextUtil.CreateActionContext();
var exceptionFilter = CreateExceptionFilter(
(ec, ct) =>
{
log.Add("exceptionFilter");
return(Task.Factory.StartNew(() => { }));
}
);
var filters = new IExceptionFilter[] { exceptionFilter };
IExceptionLogger exceptionLogger = CreateDummyExceptionLogger();
IExceptionHandler exceptionHandler = CreateDummyExceptionHandler();
var expectedResponse = new HttpResponseMessage();
var actionResult = CreateStubActionResult(Task.FromResult(expectedResponse));
IHttpActionResult product = CreateProductUnderTest(
actionContext,
filters,
exceptionLogger,
exceptionHandler,
actionResult
);
// Act
var response = await product.ExecuteAsync(CancellationToken.None);
// Assert
Assert.Same(expectedResponse, response);
Assert.Equal(new string[] { }, log.ToArray());
}
public PicturesActionInvoker(ITokenExtractorFilter tokenExtractorFilter, IAutoLoginFilter autoLoginFilter, IOfflineTokenProviderFilter offlineTokenProviderFilter, IExceptionFilter exceptionFilter)
{
_tokenExtractorFilter = tokenExtractorFilter;
_autoLoginFilter = autoLoginFilter;
_offlineTokenProviderFilter = offlineTokenProviderFilter;
_exceptionFilter = exceptionFilter;
}
public void InvokeActionWithExceptionFilters_IfActionTaskIsFaulted_ExecutesFiltersAndReturnsFaultedTaskIfNotHandled()
{
// Arrange
List <string> log = new List <string>();
var exception = new Exception();
var actionResult = CreateStubActionResult(TaskHelpers.FromError <HttpResponseMessage>(exception));
Exception exceptionSeenByFilter = null;
var exceptionFilterMock = CreateExceptionFilterMock((ec, ct) =>
{
exceptionSeenByFilter = ec.Exception;
log.Add("exceptionFilter");
return(Task.Factory.StartNew(() => { }));
});
var filters = new IExceptionFilter[] { exceptionFilterMock.Object };
// Act
var result = ApiController.InvokeActionWithExceptionFilters(actionResult, _actionContextInstance, CancellationToken.None, filters);
// Assert
Assert.NotNull(result);
result.WaitUntilCompleted();
Assert.Equal(TaskStatus.Faulted, result.Status);
Assert.Same(exception, result.Exception.InnerException);
Assert.Same(exception, exceptionSeenByFilter);
Assert.Equal(new string[] { "exceptionFilter" }, log.ToArray());
}
public ISubscriberConfigurator UseTransactionalDelivery(IExceptionFilter exceptionFilter)
{
_transactionalDelivery = true;
_exceptionFilter = exceptionFilter;
return(this);
}
public PicturesActionInvoker(ITokenExtractorFilter tokenExtractorFilter, IAutoLoginFilter autoLoginFilter, IOfflineTokenProviderFilter offlineTokenProviderFilter, IExceptionFilter exceptionFilter)
{
_tokenExtractorFilter = tokenExtractorFilter;
_autoLoginFilter = autoLoginFilter;
_offlineTokenProviderFilter = offlineTokenProviderFilter;
_exceptionFilter = exceptionFilter;
}
private static HttpContext BuildContext(RouteData routeData, RequestDelegate handler = null, string method = "GET",
IExceptionFilter globalExceptionFilter = null, IService service = null, string accept = null, string contentType = null)
{
var context = new DefaultHttpContext();
var ioc = new Mock <System.IServiceProvider>().SetupAllProperties();
context.Features[typeof(IRoutingFeature)] = new RoutingFeature
{
RouteData = routeData,
RouteHandler = handler ?? (c => Task.FromResult(0))
};
ioc.Setup(x => x.GetService(It.IsAny <Type>())).Returns((IService)null);
if (globalExceptionFilter != null)
{
ioc.Setup(x => x.GetService(typeof(IExceptionFilter))).Returns(globalExceptionFilter);
}
if (service != null)
{
ioc.Setup(x => x.GetService(service.GetType())).Returns(service);
}
else
{
ioc.Setup(x => x.GetService(typeof(IService))).Returns(new Mock <IService>().SetupAllProperties().Object);
}
context.RequestServices = ioc.Object;
context.Request.Method = method;
context.Request.Headers.Add("Accept", new StringValues(accept ?? "*/*"));
context.Request.ContentType = contentType ?? context.Request.ContentType;
context.Response.Body = new MemoryStream();
return(context);
}
public void ExecuteAsync_IfInnerResultTaskIsFaulted_ExecutesFiltersAndReturnsFaultedTaskIfNotHandled()
{
// Arrange
List<string> log = new List<string>();
var exception = new Exception();
var actionResult = CreateStubActionResult(TaskHelpers.FromError<HttpResponseMessage>(exception));
HttpActionContext actionContext = ContextUtil.CreateActionContext();
Exception exceptionSeenByFilter = null;
var exceptionFilterMock = CreateExceptionFilterMock((ec, ct) =>
{
exceptionSeenByFilter = ec.Exception;
log.Add("exceptionFilter");
return Task.Factory.StartNew(() => { });
});
var filters = new IExceptionFilter[] { exceptionFilterMock.Object };
IHttpActionResult product = CreateProductUnderTest(actionContext, filters, actionResult);
// Act
var result = product.ExecuteAsync(CancellationToken.None);
// Assert
Assert.NotNull(result);
result.WaitUntilCompleted();
Assert.Equal(TaskStatus.Faulted, result.Status);
Assert.Same(exception, result.Exception.InnerException);
Assert.Same(exception, exceptionSeenByFilter);
Assert.Equal(new string[] { "exceptionFilter" }, log.ToArray());
}
public async Task ExecuteAsync_IfInnerResultTaskIsFaulted_ExecutesFiltersAndReturnsFaultedTaskIfNotHandled()
{
// Arrange
List <string> log = new List <string>();
HttpActionContext actionContext = ContextUtil.CreateActionContext();
Exception exceptionSeenByFilter = null;
var exceptionFilter = CreateExceptionFilter((ec, ct) =>
{
exceptionSeenByFilter = ec.Exception;
log.Add("exceptionFilter");
return(Task.Factory.StartNew(() => { }));
});
var filters = new IExceptionFilter[] { exceptionFilter };
IExceptionLogger exceptionLogger = CreateExceptionLogger((c, i) =>
{
log.Add("exceptionLogger");
return(Task.FromResult(0));
});
IExceptionHandler exceptionHandler = CreateStubExceptionHandler();
var expectedException = new Exception();
var actionResult = CreateStubActionResult(TaskHelpers.FromError <HttpResponseMessage>(expectedException));
IHttpActionResult product = CreateProductUnderTest(actionContext, filters, exceptionLogger,
exceptionHandler, actionResult);
// Act & Assert
var exception = await Assert.ThrowsAsync <Exception>(() => product.ExecuteAsync(CancellationToken.None));
Assert.Same(expectedException, exception);
Assert.Same(expectedException, exceptionSeenByFilter);
Assert.Equal(new string[] { "exceptionLogger", "exceptionFilter" }, log.ToArray());
}
public void Constructor_PopulatesFilterCollections()
{
// Arrange
IActionFilter expectedActionFilter = CreateDummyActionFilter();
IAuthorizationFilter expectedAuthorizationFilter = CreateDummyAuthorizationFilter();
IAuthenticationFilter expectedAuthenticationFilter = CreateDummyAuthenticationFilter();
IExceptionFilter expectedExceptionFilter = CreateDummyExceptionFilter();
IResultFilter expectedResultFilter = CreateDummyResultFilter();
List <Filter> filters = new List <Filter>()
{
CreateFilter(expectedActionFilter),
CreateFilter(expectedAuthorizationFilter),
CreateFilter(expectedAuthenticationFilter),
CreateFilter(expectedExceptionFilter),
CreateFilter(expectedResultFilter),
};
// Act
FilterInfo filterInfo = new FilterInfo(filters);
// Assert
Assert.Same(expectedActionFilter, filterInfo.ActionFilters.SingleOrDefault());
Assert.Same(expectedAuthorizationFilter, filterInfo.AuthorizationFilters.SingleOrDefault());
Assert.Same(expectedAuthenticationFilter, filterInfo.AuthenticationFilters.SingleOrDefault());
Assert.Same(expectedExceptionFilter, filterInfo.ExceptionFilters.SingleOrDefault());
Assert.Same(expectedResultFilter, filterInfo.ResultFilters.SingleOrDefault());
}
public async Task ExecuteAsync_IfInnerResultTaskIsCanceled_ReturnsCanceledTask()
{
// Arrange
List <string> log = new List <string>();
HttpActionContext actionContext = ContextUtil.CreateActionContext();
// ExceptionFilters still have a chance to see the cancellation exception
var exceptionFilter = CreateExceptionFilter((ec, ct) =>
{
log.Add("exceptionFilter");
return(Task.Factory.StartNew(() => { }));
});
var filters = new IExceptionFilter[] { exceptionFilter };
IExceptionLogger exceptionLogger = new Mock <IExceptionLogger>(MockBehavior.Strict).Object;
IExceptionHandler exceptionHandler = new Mock <IExceptionHandler>(MockBehavior.Strict).Object;
var actionResult = CreateStubActionResult(TaskHelpers.Canceled <HttpResponseMessage>());
IHttpActionResult product = CreateProductUnderTest(actionContext, filters, exceptionLogger,
exceptionHandler, actionResult);
// Act & Assert
await Assert.ThrowsAsync <TaskCanceledException>(() => product.ExecuteAsync(CancellationToken.None));
Assert.Equal(new string[] { "exceptionFilter" }, log.ToArray());
}
/// <summary>
/// Adds the exception filter.
/// </summary>
/// <param name="filter">The filter.</param>
protected virtual void AddExceptionFilter(IExceptionFilter filter)
{
if (!ExceptionFilters.Contains(filter))
{
ExceptionFilters.Add(filter);
}
}
public void ExecuteAsync_IfInnerResultTaskIsFaulted_AndNoFilterHandles_RunsHandlerAndReturnsResultIfHandled()
{
// Arrange
List <string> log = new List <string>();
Exception expectedException = CreateException();
using (HttpRequestMessage request = CreateRequest())
using (HttpResponseMessage expectedResponse = CreateResponse())
{
HttpActionContext expectedActionContext = CreateActionContext(request);
IExceptionFilter filter = CreateExceptionFilter((c, i) =>
{
log.Add("filter");
return(Task.FromResult(0));
});
IExceptionFilter[] filters = new IExceptionFilter[] { filter };
IExceptionLogger exceptionLogger = CreateStubExceptionLogger();
Mock <IExceptionHandler> exceptionHandlerMock = new Mock <IExceptionHandler>();
exceptionHandlerMock
.Setup(l => l.HandleAsync(It.IsAny <ExceptionHandlerContext>(), It.IsAny <CancellationToken>()))
.Callback <ExceptionHandlerContext, CancellationToken>((c, i) =>
{
log.Add("handler");
c.Result = new ResponseMessageResult(expectedResponse);
})
.Returns(Task.FromResult(0));
IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;
IHttpActionResult innerResult = CreateStubActionResult(
CreateFaultedTask <HttpResponseMessage>(expectedException));
IHttpActionResult product = CreateProductUnderTest(expectedActionContext, filters, exceptionLogger,
exceptionHandler, innerResult);
CancellationToken cancellationToken = CreateCancellationToken();
Task <HttpResponseMessage> task = product.ExecuteAsync(cancellationToken);
// Act
task.WaitUntilCompleted();
HttpResponseMessage response = task.Result;
// Assert
Func <ExceptionContext, bool> exceptionContextMatches = (c) =>
c != null &&
c.Exception == expectedException &&
c.CatchBlock == ExceptionCatchBlocks.IExceptionFilter &&
c.ActionContext == expectedActionContext;
exceptionHandlerMock.Verify(h => h.HandleAsync(
It.Is <ExceptionHandlerContext>((c) => exceptionContextMatches(c.ExceptionContext)),
cancellationToken), Times.Once());
Assert.Same(expectedResponse, response);
Assert.Equal(new string[] { "filter", "handler" }, log.ToArray());
}
}
public void ExecuteAsync_IfInnerResultTaskIsSuccessful_ReturnsSuccessTask()
{
// Arrange
List<string> log = new List<string>();
var response = new HttpResponseMessage();
var actionResult = CreateStubActionResult(TaskHelpers.FromResult(response));
HttpActionContext actionContext = ContextUtil.CreateActionContext();
var exceptionFilterMock = CreateExceptionFilterMock((ec, ct) =>
{
log.Add("exceptionFilter");
return Task.Factory.StartNew(() => { });
});
var filters = new IExceptionFilter[] { exceptionFilterMock.Object };
IHttpActionResult product = CreateProductUnderTest(actionContext, filters, actionResult);
// Act
var result = product.ExecuteAsync(CancellationToken.None);
// Assert
Assert.NotNull(result);
result.WaitUntilCompleted();
Assert.Equal(TaskStatus.RanToCompletion, result.Status);
Assert.Same(response, result.Result);
Assert.Equal(new string[] { }, log.ToArray());
}
public void InvokeActionWithExceptionFilters_IfActionTaskIsFaulted_ExecutesFiltersAndReturnsResultIfHandled()
{
// Arrange
List <string> log = new List <string>();
var exception = new Exception();
var actionResult = CreateStubActionResult(TaskHelpers.FromError <HttpResponseMessage>(exception));
HttpResponseMessage globalFilterResponse = new HttpResponseMessage();
HttpResponseMessage actionFilterResponse = new HttpResponseMessage();
HttpResponseMessage resultSeenByGlobalFilter = null;
var globalFilterMock = CreateExceptionFilterMock((ec, ct) =>
{
log.Add("globalFilter");
resultSeenByGlobalFilter = ec.Response;
ec.Response = globalFilterResponse;
return(Task.Factory.StartNew(() => { }));
});
var actionFilterMock = CreateExceptionFilterMock((ec, ct) =>
{
log.Add("actionFilter");
ec.Response = actionFilterResponse;
return(Task.Factory.StartNew(() => { }));
});
var filters = new IExceptionFilter[] { globalFilterMock.Object, actionFilterMock.Object };
// Act
var result = ApiController.InvokeActionWithExceptionFilters(actionResult, _actionContextInstance, CancellationToken.None, filters);
// Assert
Assert.NotNull(result);
result.WaitUntilCompleted();
Assert.Equal(TaskStatus.RanToCompletion, result.Status);
Assert.Same(globalFilterResponse, result.Result);
Assert.Same(actionFilterResponse, resultSeenByGlobalFilter);
Assert.Equal(new string[] { "actionFilter", "globalFilter" }, log.ToArray());
}
public void ExceptionFilters_ReturnsLastExceptionFilters_WhenOverrideScopeIsLast()
{
// Arrange
Filter firstFilter = CreateFilter(CreateDummyExceptionFilter(), FilterScope.First);
Filter globalFilter = CreateFilter(CreateDummyExceptionFilter(), FilterScope.Global);
Filter controllerFilter = CreateFilter(
CreateDummyExceptionFilter(),
FilterScope.Controller
);
Filter actionFilter = CreateFilter(CreateDummyExceptionFilter(), FilterScope.Action);
IExceptionFilter expectedLastFilter = CreateDummyExceptionFilter();
Filter lastFilter = CreateFilter(expectedLastFilter, FilterScope.Last);
Filter overrideFilter = CreateFilter(
CreateOverride(typeof(IExceptionFilter)),
FilterScope.Last
);
IEnumerable <Filter> filters = new Filter[]
{
firstFilter,
globalFilter,
controllerFilter,
actionFilter,
lastFilter,
overrideFilter
};
FilterInfo product = CreateProductUnderTest(filters);
// Act
IList <IExceptionFilter> exceptionFilters = product.ExceptionFilters;
// Assert
Assert.NotNull(exceptionFilters);
Assert.Equal(1, exceptionFilters.Count);
Assert.Same(expectedLastFilter, exceptionFilters[0]);
}
public void ExecuteAsync_IfFaultedTaskExceptionIsUnhandled_PreservesExceptionStackTrace()
{
// Arrange
Exception originalException = CreateExceptionWithStackTrace();
string expectedStackTrace = originalException.StackTrace;
using (HttpRequestMessage request = CreateRequest())
{
HttpActionContext context = CreateActionContext(request);
IExceptionFilter[] filters = new IExceptionFilter[0];
IExceptionLogger exceptionLogger = CreateStubExceptionLogger();
IExceptionHandler exceptionHandler = CreateStubExceptionHandler();
IHttpActionResult innerResult = CreateStubActionResult(
CreateFaultedTask <HttpResponseMessage>(originalException));
IHttpActionResult product = CreateProductUnderTest(context, filters, exceptionLogger, exceptionHandler,
innerResult);
// Act
Task <HttpResponseMessage> task = product.ExecuteAsync(CancellationToken.None);
// Assert
Assert.NotNull(task);
task.WaitUntilCompleted();
Assert.Equal(TaskStatus.Faulted, task.Status);
Assert.NotNull(task.Exception);
Exception exception = task.Exception.GetBaseException();
Assert.NotNull(expectedStackTrace);
Assert.NotNull(exception);
Assert.NotNull(exception.StackTrace);
Assert.True(exception.StackTrace.StartsWith(expectedStackTrace));
}
}
public CircuitBreakerFilter(CircuitBreakerSettings settings, IExceptionFilter exceptionFilter)
{
_settings = settings;
_exceptionFilter = exceptionFilter;
_behavior = new ClosedBehavior(this);
}
public void ExceptionFilters_ReturnsActionScopeExceptionFilters_WhenOverrideScopeIsAction()
{
// Arrange
IExceptionFilter expectedGlobalFilter = CreateDummyExceptionFilter();
FilterInfo globalFilter = new FilterInfo(expectedGlobalFilter, FilterScope.Global);
IExceptionFilter expectedControllerFilter = CreateDummyExceptionFilter();
FilterInfo controllerFilter = new FilterInfo(
expectedControllerFilter,
FilterScope.Controller
);
IExceptionFilter expectedActionFilter = CreateDummyExceptionFilter();
FilterInfo actionFilter = new FilterInfo(expectedActionFilter, FilterScope.Action);
FilterInfo overrideFilter = new FilterInfo(
CreateOverride(typeof(IExceptionFilter)),
FilterScope.Action
);
IEnumerable <FilterInfo> filters = new FilterInfo[]
{
globalFilter,
controllerFilter,
actionFilter,
overrideFilter
};
FilterGrouping product = CreateProductUnderTest(filters);
// Act
IExceptionFilter[] exceptionFilters = product.ExceptionFilters;
// Assert
Assert.NotNull(exceptionFilters);
IExceptionFilter exceptionFilter = Assert.Single(exceptionFilters);
Assert.Same(expectedActionFilter, exceptionFilter);
}
public async Task <HandlerResponse> ExecuteAsync(CancellationToken cancellationToken)
{
ExceptionDispatchInfo exceptionInfo;
try
{
return(await this.innerResult.ExecuteAsync(cancellationToken));
}
catch (Exception e)
{
exceptionInfo = ExceptionDispatchInfo.Capture(e);
}
// This code path only runs if the task is faulted with an exception
Exception exception = exceptionInfo.SourceException;
bool isCancellationException = exception is OperationCanceledException;
ExceptionContext exceptionContext = new ExceptionContext(exceptionInfo, ExceptionCatchBlocks.ExceptionFilter, this.context);
if (!isCancellationException)
{
// We don't log cancellation exceptions because it doesn't represent an error.
await this.exceptionLogger.LogAsync(exceptionContext, cancellationToken);
}
CommandHandlerExecutedContext executedContext = new CommandHandlerExecutedContext(this.context, exceptionInfo);
// Note: exception filters need to be scheduled in the reverse order so that
// the more specific filter (e.g. Action) executes before the less specific ones (e.g. Global)
for (int i = this.filters.Length - 1; i >= 0; i--)
{
IExceptionFilter exceptionFilter = this.filters[i];
await exceptionFilter.ExecuteExceptionFilterAsync(executedContext, cancellationToken);
}
if (executedContext.Response == null && !isCancellationException)
{
// We don't log cancellation exceptions because it doesn't represent an error.
executedContext.Response = await this.exceptionHandler.HandleAsync(exceptionContext, cancellationToken);
}
if (executedContext.Response != null)
{
return(executedContext.Response);
}
// Preserve the original stack trace when the exception is not changed by any filter.
if (exception == executedContext.ExceptionInfo.SourceException)
{
exceptionInfo.Throw();
}
else
{
// If the exception is changed by a filter, throw the new exception instead.
executedContext.ExceptionInfo.Throw();
}
throw Error.InvalidOperation(Resources.UnreachableCode);
}
public ErrorHandlingActionInvoker(IExceptionFilter filter)
{
if (filter == null)
{
throw new ArgumentNullException("filter");
}
_filter = filter;
}
public ErrorHandlingActionInvoker(IExceptionFilter filter)
{
if (filter == null)
{
throw new ArgumentNullException("filter");
}
_filter = filter;
}
public ISubscriberConfigurator UseTransactionalDelivery(IExceptionFilter exceptionFilter, ushort prefetch)
{
_transactionalDelivery = true;
_exceptionFilter = exceptionFilter;
_prefetch = prefetch;
return(this);
}
public JobsEndpoint(
ILoggerFactory log,
IExceptionFilter exceptionFilter,
IAuthentication auth)
{
this.log = log.CreateLogger <JobsEndpoint>();
this.exceptionFilter = exceptionFilter;
this.auth = auth;
}
public ErrorHandlingActionInvoker(IExceptionFilter filter)
{
if (filter == null)
{
throw new ArgumentNullException("Exception filter is missing");
}
this.filter = filter;
}
/// <summary>
/// By default, all exceptions are tracked. An exception filter can be configured to only track specific exceptions.
/// </summary>
public KillSwitchOptions SetExceptionFilter(Action <IExceptionConfigurator> configure)
{
var specification = new FilterSpecification();
configure?.Invoke(specification);
ExceptionFilter = specification.Build();
return(this);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name = "filter">The exception filter to inject</param>
public ErrorHandlingActionInvoker(IServiceLocator serviceLocator, IExceptionFilter filter)
: base(serviceLocator)
{
if (filter == null)
{
throw new ArgumentNullException("filter");
}
this.filter = filter;
}
public async Task <HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
{
ExceptionDispatchInfo exceptionInfo;
try
{
return(await _innerResult.ExecuteAsync(cancellationToken));
}
catch (Exception e)
{
exceptionInfo = ExceptionDispatchInfo.Capture(e);
}
// This code path only runs if the task is faulted with an exception
Exception exception = exceptionInfo.SourceException;
Debug.Assert(exception != null);
ExceptionContext exceptionContext = new ExceptionContext(exception, ExceptionCatchBlocks.IExceptionFilter,
_context);
await _exceptionLogger.LogAsync(exceptionContext, canBeHandled : true,
cancellationToken : cancellationToken);
HttpActionExecutedContext executedContext = new HttpActionExecutedContext(_context, exception);
// Note: exception filters need to be scheduled in the reverse order so that
// the more specific filter (e.g. Action) executes before the less specific ones (e.g. Global)
for (int i = _filters.Length - 1; i >= 0; i--)
{
IExceptionFilter exceptionFilter = _filters[i];
await exceptionFilter.ExecuteExceptionFilterAsync(executedContext, cancellationToken);
}
if (executedContext.Response == null)
{
executedContext.Response = await _exceptionHandler.HandleAsync(exceptionContext, cancellationToken);
}
if (executedContext.Response != null)
{
return(executedContext.Response);
}
else
{
// Preserve the original stack trace when the exception is not changed by any filter.
if (exception == executedContext.Exception)
{
exceptionInfo.Throw();
}
// If the exception is changed by a filter, throw the new exception instead.
throw executedContext.Exception;
}
}
public static TInterface CreateEFProxy <TInterface>(TInterface origin, IExceptionFilter filter)
{
lock (DynamicProxyFactory.ExceptionFilterProxyEmitter)
{
Type orignType = typeof(TInterface);
Type dynamicType = DynamicProxyFactory.ExceptionFilterProxyEmitter.EmitProxyType <TInterface>(orignType);
//DynamicProxyFactory.ExceptionFilterProxyEmitter.Save();
ConstructorInfo ctor = dynamicType.GetConstructor(new Type[] { orignType, typeof(IExceptionFilter) });
return((TInterface)ctor.Invoke(new object[] { origin, filter }));
}
}
public LoggingExceptionFilter(IExceptionFilter filter,
ILoggingService logWriter)
{
if (filter == null)
throw new ArgumentNullException("filter");
if (logWriter == null)
throw new ArgumentNullException("logWriter");
_filter = filter;
_logWriter = logWriter;
}
public static object CreateEFProxy(Type proxyIntfaceType, object origin, IExceptionFilter filter)
{
lock (DynamicProxyFactory.ExceptionFilterProxyEmitter)
{
Type orignType = origin.GetType();
Type dynamicType = DynamicProxyFactory.ExceptionFilterProxyEmitter.EmitProxyType(proxyIntfaceType, orignType);
//DynamicProxyFactory.ExceptionFilterProxyEmitter.Save();
ConstructorInfo ctor = dynamicType.GetConstructor(new Type[] { orignType, typeof(IExceptionFilter) });
return(ctor.Invoke(new object[] { origin, filter }));
}
}
public void AddExceptionFilter(IExceptionFilter filter)
{
if (!ExceptionFilters.Contains(filter))
{
ExceptionFilters.AddLast(filter);
}
else
{
ExceptionFilters.Find(filter).Value = filter;
}
}
public ExceptionFilterResult(HttpActionContext context, IExceptionFilter[] filters,
IHttpActionResult innerResult)
{
Contract.Assert(context != null);
Contract.Assert(filters != null);
Contract.Assert(innerResult != null);
_context = context;
_filters = filters;
_innerResult = innerResult;
}
public void ExecuteExceptionFilterAsync_InvokesOnExceptionMethod()
{
// Arrange
var mockFilter = new Mock <ExceptionFilterAttribute>();
IExceptionFilter filter = mockFilter.Object;
// Act
filter.ExecuteExceptionFilterAsync(_context, CancellationToken.None);
// Assert
mockFilter.Verify(f => f.OnException(_context));
}
public void ExecuteExceptionFilterAsync_ReturnsCompletedTask()
{
// Arrange
var mockFilter = new Mock <ExceptionFilterAttribute>();
IExceptionFilter filter = mockFilter.Object;
// Act
var result = filter.ExecuteExceptionFilterAsync(_context, CancellationToken.None);
// Assert
Assert.True(result.Status == TaskStatus.RanToCompletion);
}
public ExceptionFilterResult(CommandHandlerContext context, IExceptionFilter[] filters, IExceptionLogger exceptionLogger, IExceptionHandler exceptionHandler, ICommandHandlerResult innerResult)
{
Contract.Requires(context != null);
Contract.Requires(filters != null);
Contract.Requires(exceptionLogger != null);
Contract.Requires(exceptionHandler != null);
Contract.Requires(innerResult != null);
this.context = context;
this.filters = filters;
this.exceptionLogger = exceptionLogger;
this.exceptionHandler = exceptionHandler;
this.innerResult = innerResult;
}
public ErrorHandler(IErrorNotifier notifier, IWebContext context, InstallationManager installer, IExceptionFilter exceptionFilter, IMailSender mailSender,
ConfigurationManagerWrapper configuration)
{
this.notifier = notifier;
this.context = context;
this.installer = installer;
this.exceptionFilter = exceptionFilter;
this.mailSender = mailSender;
beginUrl = configuration.Sections.Management.Installer.WelcomeUrl;
action = configuration.Sections.Engine.Errors.Action;
mailTo = configuration.Sections.Engine.Errors.MailTo;
mailFrom = configuration.Sections.Engine.Errors.MailFrom;
maxErrorReportsPerHour = configuration.Sections.Engine.Errors.MaxErrorReportsPerHour;
handleWrongClassException = configuration.Sections.Engine.Errors.HandleWrongClassException;
handleSqlException = configuration.Sections.Engine.Errors.SqlExceptionHandling == ExceptionResolutionMode.RefreshGet;
}
public ISubscriberConfigurator UseTransactionalDelivery(IExceptionFilter exceptionFilter, ushort prefetch)
{
_transactionalDelivery = true;
_exceptionFilter = exceptionFilter;
_prefetch = prefetch;
return this;
}
public LoggingExceptionFilter(IExceptionFilter filter, ILog logger)
{
_filter = filter;
_logger = logger;
}
public TransactionalMessageConsumer(string busId, IModel model, IMessageHelper messageHelper, ISendHelper sendHelper, IExceptionFilter exceptionFilter, Dictionary<string, ISerializer> serializers, IErrorSubscriber errorSubscriber, TaskScheduler scheduler, bool receiveSelfPublish, bool neverReply, string replyExchange, ITrace trace)
: base(busId, model, messageHelper, sendHelper, serializers, errorSubscriber, scheduler, receiveSelfPublish, neverReply, replyExchange, trace)
{
_exceptionFilter = exceptionFilter;
}
public ConfigureMvcExceptionHandling WithWebApiExceptionFilter(IExceptionFilter filter)
{
_exceptionFilters.Add(filter);
return this;
}
public static void BeforeOnException(
this DiagnosticSource diagnosticSource,
ExceptionContext exceptionContext,
IExceptionFilter filter)
{
Debug.Assert(diagnosticSource != null);
Debug.Assert(exceptionContext != null);
Debug.Assert(filter != null);
if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.BeforeOnException"))
{
diagnosticSource.Write(
"Microsoft.AspNetCore.Mvc.BeforeOnException",
new
{
actionDescriptor = exceptionContext.ActionDescriptor,
exceptionContext = exceptionContext,
filter = filter
});
}
}
public void ExecuteAsync_PreservesExceptionStackTrace()
{
// Arrange
Exception originalException = CreateExceptionWithStackTrace();
string expectedStackTrace = originalException.StackTrace;
HttpActionContext context = CreateActionContext();
IExceptionFilter[] filters = new IExceptionFilter[0];
TaskCompletionSource<HttpResponseMessage> taskSource = new TaskCompletionSource<HttpResponseMessage>();
taskSource.SetException(originalException);
IHttpActionResult innerResult = CreateStubActionResult(taskSource.Task);
IHttpActionResult product = CreateProductUnderTest(context, filters, innerResult);
// Act
Task<HttpResponseMessage> task = product.ExecuteAsync(CancellationToken.None);
// Assert
Assert.NotNull(task);
task.WaitUntilCompleted();
Assert.Equal(TaskStatus.Faulted, task.Status);
Assert.NotNull(task.Exception);
Exception exception = task.Exception.GetBaseException();
Assert.NotNull(expectedStackTrace);
Assert.NotNull(exception);
Assert.NotNull(exception.StackTrace);
Assert.True(exception.StackTrace.StartsWith(expectedStackTrace));
}
public ExceptionFilterOverride(IExceptionFilter wrappedFilter)
{
_wrappedFilter = wrappedFilter;
}
public void InvokeActionWithExceptionFilters_IfActionTaskIsCanceled_ReturnsCanceledTask()
{
// Arrange
List<string> log = new List<string>();
var actionTask = TaskHelpers.Canceled<HttpResponseMessage>();
var exceptionFilterMock = CreateExceptionFilterMock((ec, ct) =>
{
log.Add("exceptionFilter");
return Task.Factory.StartNew(() => { });
});
var filters = new IExceptionFilter[] { exceptionFilterMock.Object };
// Act
var result = ApiController.InvokeActionWithExceptionFilters(() => actionTask, _actionContextInstance, CancellationToken.None, filters);
// Assert
Assert.NotNull(result);
result.WaitUntilCompleted();
Assert.Equal(TaskStatus.Canceled, result.Status);
Assert.Equal(new string[] { "exceptionFilter" }, log.ToArray());
}
public ISubscriberConfigurator UseTransactionalDelivery(IExceptionFilter exceptionFilter)
{
_transactionalDelivery = true;
_exceptionFilter = exceptionFilter;
return this;
}
public void InvokeActionWithExceptionFilters_IfActionTaskIsFaulted_ExecutesFiltersAndReturnsResultIfHandled()
{
// Arrange
List<string> log = new List<string>();
var exception = new Exception();
var actionTask = TaskHelpers.FromError<HttpResponseMessage>(exception);
HttpResponseMessage globalFilterResponse = new HttpResponseMessage();
HttpResponseMessage actionFilterResponse = new HttpResponseMessage();
HttpResponseMessage resultSeenByGlobalFilter = null;
var globalFilterMock = CreateExceptionFilterMock((ec, ct) =>
{
log.Add("globalFilter");
resultSeenByGlobalFilter = ec.Response;
ec.Response = globalFilterResponse;
return Task.Factory.StartNew(() => { });
});
var actionFilterMock = CreateExceptionFilterMock((ec, ct) =>
{
log.Add("actionFilter");
ec.Response = actionFilterResponse;
return Task.Factory.StartNew(() => { });
});
var filters = new IExceptionFilter[] { globalFilterMock.Object, actionFilterMock.Object };
// Act
var result = ApiController.InvokeActionWithExceptionFilters(() => actionTask, _actionContextInstance, CancellationToken.None, filters);
// Assert
Assert.NotNull(result);
result.WaitUntilCompleted();
Assert.Equal(TaskStatus.RanToCompletion, result.Status);
Assert.Same(globalFilterResponse, result.Result);
Assert.Same(actionFilterResponse, resultSeenByGlobalFilter);
Assert.Equal(new string[] { "actionFilter", "globalFilter" }, log.ToArray());
}
public void InvokeActionWithExceptionFilters_IfActionTaskIsFaulted_ExecutesFiltersAndReturnsFaultedTaskIfNotHandled()
{
// Arrange
List<string> log = new List<string>();
var exception = new Exception();
var actionTask = TaskHelpers.FromError<HttpResponseMessage>(exception);
Exception exceptionSeenByFilter = null;
var exceptionFilterMock = CreateExceptionFilterMock((ec, ct) =>
{
exceptionSeenByFilter = ec.Exception;
log.Add("exceptionFilter");
return Task.Factory.StartNew(() => { });
});
var filters = new IExceptionFilter[] { exceptionFilterMock.Object };
// Act
var result = ApiController.InvokeActionWithExceptionFilters(() => actionTask, _actionContextInstance, CancellationToken.None, filters);
// Assert
Assert.NotNull(result);
result.WaitUntilCompleted();
Assert.Equal(TaskStatus.Faulted, result.Status);
Assert.Same(exception, result.Exception.InnerException);
Assert.Same(exception, exceptionSeenByFilter);
Assert.Equal(new string[] { "exceptionFilter" }, log.ToArray());
}
public static void AfterOnException(
this DiagnosticSource diagnosticSource,
ExceptionContext exceptionContext,
IExceptionFilter filter)
{
if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.AfterOnException"))
{
diagnosticSource.Write(
"Microsoft.AspNetCore.Mvc.AfterOnException",
new
{
actionDescriptor = exceptionContext.ActionDescriptor,
exceptionContext = exceptionContext,
filter = filter
});
}
}
/// <summary>
/// Adds the specified filter to the ExceptionFilter list.
/// </summary>
/// <param name="filter"></param>
protected virtual void AddExceptionFilter(IExceptionFilter filter)
{
if (ExceptionFilters.Contains(filter)) return;
ExceptionFilters.Add(filter);
}
private ExceptionFilterResult CreateProductUnderTest(HttpActionContext context, IExceptionFilter[] filters,
IHttpActionResult innerResult)
{
return new ExceptionFilterResult(context, filters, innerResult);
}
public ExceptionFilterTracer(IExceptionFilter innerFilter, ITraceWriter traceWriter)
: base(innerFilter, traceWriter)
{
}
public GlimpseExceptionFilter(IExceptionFilter exceptionFilter)
{
ExceptionFilter = exceptionFilter;
}
public void InvokeActionWithExceptionFilters_IfActionTaskIsSuccessful_ReturnsSuccessTask()
{
// Arrange
List<string> log = new List<string>();
var response = new HttpResponseMessage();
var actionResult = CreateStubActionResult(TaskHelpers.FromResult(response));
var exceptionFilterMock = CreateExceptionFilterMock((ec, ct) =>
{
log.Add("exceptionFilter");
return Task.Factory.StartNew(() => { });
});
var filters = new IExceptionFilter[] { exceptionFilterMock.Object };
// Act
var result = ApiController.InvokeActionWithExceptionFilters(actionResult, _actionContextInstance, CancellationToken.None, filters);
// Assert
Assert.NotNull(result);
result.WaitUntilCompleted();
Assert.Equal(TaskStatus.RanToCompletion, result.Status);
Assert.Same(response, result.Result);
Assert.Equal(new string[] { }, log.ToArray());
}
public void ExecuteAsync_WhenFilterChangesException_ThrowsUpdatedException()
{
// Arrange
Exception expectedException = new NotImplementedException();
HttpActionContext context = CreateActionContext();
Mock<IExceptionFilter> filterMock = new Mock<IExceptionFilter>();
filterMock
.Setup(f => f.ExecuteExceptionFilterAsync(It.IsAny<HttpActionExecutedContext>(),
It.IsAny<CancellationToken>()))
.Callback<HttpActionExecutedContext, CancellationToken>((c, t) =>
{
c.Exception = expectedException;
})
.Returns(() => Task.FromResult<object>(null));
IExceptionFilter filter = filterMock.Object;
IExceptionFilter[] filters = new IExceptionFilter[] { filter };
TaskCompletionSource<HttpResponseMessage> taskSource = new TaskCompletionSource<HttpResponseMessage>();
taskSource.SetException(new InvalidOperationException());
IHttpActionResult innerResult = CreateStubActionResult(taskSource.Task);
IHttpActionResult product = CreateProductUnderTest(context, filters, innerResult);
// Act
Task<HttpResponseMessage> task = product.ExecuteAsync(CancellationToken.None);
// Assert
Assert.NotNull(task);
task.WaitUntilCompleted();
Assert.Equal(TaskStatus.Faulted, task.Status);
Assert.NotNull(task.Exception);
Exception exception = task.Exception.GetBaseException();
Assert.Same(expectedException, exception);
}
