void AssertMultipleFilters(
Func <IComponentContext, TFilter1> registration1,
Func <IComponentContext, TFilter2> registration2,
Action <IRegistrationBuilder <TFilter1, SimpleActivatorData, SingleRegistrationStyle> > configure1,
Action <IRegistrationBuilder <TFilter2, SimpleActivatorData, SingleRegistrationStyle> > configure2)
{
var builder = new ContainerBuilder();
builder.Register <ILogger>(c => new Logger()).InstancePerDependency();
configure1(builder.Register(registration1).InstancePerApiRequest());
configure2(builder.Register(registration2).InstancePerApiRequest());
var container = builder.Build();
var provider = new AutofacWebApiFilterProvider(container);
var configuration = new HttpConfiguration {
DependencyResolver = new AutofacWebApiDependencyResolver(container)
};
var actionDescriptor = BuildActionDescriptorForGetMethod();
var filterInfos = provider.GetFilters(configuration, actionDescriptor).ToArray();
var wrapperType = GetWrapperType();
var filters = filterInfos.Select(info => info.Instance).Where(i => i.GetType() == wrapperType).ToArray();
Assert.That(filters, Has.Length.EqualTo(1));
Assert.That(filters[0], Is.InstanceOf(wrapperType));
}
private void AssertMultiControllerRegistration <TController1, TController2>(
Func <IComponentContext, TFilter1> registration,
Action <IRegistrationBuilder <TFilter1, SimpleActivatorData, SingleRegistrationStyle> > configure)
{
var builder = new ContainerBuilder();
builder.Register <ILogger>(c => new Logger()).InstancePerDependency();
var configuration = new HttpConfiguration();
configure(builder.Register(registration).InstancePerRequest());
builder.RegisterWebApiFilterProvider(configuration);
var container = builder.Build();
var provider = new AutofacWebApiFilterProvider(container);
configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container);
var wrapperType = GetWrapperType();
var firstActionDescriptor = BuildActionDescriptorForGetMethod(typeof(TController1));
var firstControllerFilters = provider.GetFilters(configuration, firstActionDescriptor).ToArray();
var firstFilter = firstControllerFilters.Select(info => info.Instance).Single(i => i.GetType() == wrapperType);
Assert.IsType(wrapperType, firstFilter);
var secondActionDescriptor = BuildActionDescriptorForGetMethod(typeof(TController2));
var secondControllerFilters = provider.GetFilters(configuration, secondActionDescriptor).ToArray();
var secondFilter = secondControllerFilters.Select(info => info.Instance).Single(i => i.GetType() == wrapperType);
Assert.IsType(wrapperType, secondFilter);
}
private void AssertNoFilter <TController>(
Func <IComponentContext, TFilter1> registration,
Action <IRegistrationBuilder <TFilter1, SimpleActivatorData, SingleRegistrationStyle> > configure)
{
var builder = new ContainerBuilder();
builder.Register <ILogger>(c => new Logger()).InstancePerDependency();
configure(builder.Register(registration).InstancePerRequest());
var configuration = new HttpConfiguration();
builder.RegisterWebApiFilterProvider(configuration);
var container = builder.Build();
var provider = new AutofacWebApiFilterProvider(container);
configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container);
var actionDescriptor = BuildActionDescriptorForGetMethod(typeof(TController));
var filterInfos = provider.GetFilters(configuration, actionDescriptor).ToArray();
var wrapperType = GetWrapperType();
var filterApplied = filterInfos.Select(info => info.Instance).Any(i => i.GetType() == wrapperType);
Assert.False(filterApplied);
}
public void ReturnsFiltersWithoutPropertyInjectionForUnregisteredDependencies()
{
var builder = new ContainerBuilder();
var container = builder.Build();
var provider = new AutofacWebApiFilterProvider(container);
var configuration = new HttpConfiguration { DependencyResolver = new AutofacWebApiDependencyResolver(container) };
var actionDescriptor = BuildActionDescriptorForGetMethod();
var filterInfos = provider.GetFilters(configuration, actionDescriptor).ToArray();
var filter = filterInfos.Select(info => info.Instance).OfType<CustomActionFilter>().Single();
Assert.That(filter.Logger, Is.Null);
}
public void FilterRegistrationsWithoutMetadataIgnored()
{
var builder = new ContainerBuilder();
builder.RegisterType<AuthorizeAttribute>().AsImplementedInterfaces();
var container = builder.Build();
var provider = new AutofacWebApiFilterProvider(container);
var configuration = new HttpConfiguration { DependencyResolver = new AutofacWebApiDependencyResolver(container) };
var actionDescriptor = BuildActionDescriptorForGetMethod();
var filterInfos = provider.GetFilters(configuration, actionDescriptor);
Assert.That(filterInfos.Select(f => f.Instance).OfType<AuthorizeAttribute>().Any(), Is.False);
}
public void ReturnsFiltersWithoutPropertyInjectionForUnregisteredDependencies()
{
var builder = new ContainerBuilder();
var container = builder.Build();
var provider = new AutofacWebApiFilterProvider(container);
var configuration = new HttpConfiguration {
DependencyResolver = new AutofacWebApiDependencyResolver(container)
};
var actionDescriptor = BuildActionDescriptorForGetMethod();
var filterInfos = provider.GetFilters(configuration, actionDescriptor).ToArray();
var filter = filterInfos.Select(info => info.Instance).OfType <CustomActionFilter>().Single();
Assert.That(filter.Logger, Is.Null);
}
public void FilterRegistrationsWithoutMetadataIgnored()
{
var builder = new ContainerBuilder();
builder.RegisterType <AuthorizeAttribute>().AsImplementedInterfaces();
var container = builder.Build();
var provider = new AutofacWebApiFilterProvider(container);
var configuration = new HttpConfiguration {
DependencyResolver = new AutofacWebApiDependencyResolver(container)
};
var actionDescriptor = BuildActionDescriptorForGetMethod();
var filterInfos = provider.GetFilters(configuration, actionDescriptor);
Assert.That(filterInfos.Select(f => f.Instance).OfType <AuthorizeAttribute>().Any(), Is.False);
}
public void InjectsFilterPropertiesForRegisteredDependencies()
{
var builder = new ContainerBuilder();
builder.Register <ILogger>(c => new Logger()).InstancePerDependency();
var container = builder.Build();
var provider = new AutofacWebApiFilterProvider(container);
var configuration = new HttpConfiguration {
DependencyResolver = new AutofacWebApiDependencyResolver(container)
};
var actionDescriptor = BuildActionDescriptorForGetMethod();
var filterInfos = provider.GetFilters(configuration, actionDescriptor).ToArray();
var filter = filterInfos.Select(info => info.Instance).OfType <CustomActionFilterAttribute>().Single();
Assert.IsAssignableFrom <ILogger>(filter.Logger);
}
static void AssertOverrideFilter <TController>(Action <ContainerBuilder> registration)
{
var builder = new ContainerBuilder();
registration(builder);
var container = builder.Build();
var provider = new AutofacWebApiFilterProvider(container);
var configuration = new HttpConfiguration {
DependencyResolver = new AutofacWebApiDependencyResolver(container)
};
var actionDescriptor = BuildActionDescriptorForGetMethod(typeof(TController));
var filterInfos = provider.GetFilters(configuration, actionDescriptor).ToArray();
var filter = filterInfos.Select(info => info.Instance).OfType <AutofacOverrideFilter>().Single();
Assert.That(filter, Is.InstanceOf <AutofacOverrideFilter>());
Assert.That(filter.AllowMultiple, Is.False);
Assert.That(filter.FiltersToOverride, Is.EqualTo(typeof(TFilterType)));
}
static void AssertSingleFilter <TFilter, TWrapper>(
Func <IComponentContext, TFilter> registration,
Action <IRegistrationBuilder <TFilter, SimpleActivatorData, SingleRegistrationStyle> > configure)
{
var builder = new ContainerBuilder();
builder.Register <ILogger>(c => new Logger()).InstancePerDependency();
configure(builder.Register(registration).InstancePerApiRequest());
var container = builder.Build();
var provider = new AutofacWebApiFilterProvider(container);
var configuration = new HttpConfiguration {
DependencyResolver = new AutofacWebApiDependencyResolver(container)
};
var actionDescriptor = BuildActionDescriptorForGetMethod();
var filterInfos = provider.GetFilters(configuration, actionDescriptor).ToArray();
var filter = filterInfos.Select(info => info.Instance).OfType <TWrapper>().Single();
Assert.That(filter, Is.InstanceOf <TWrapper>());
}
public void ResolvesMultipleFiltersOfDifferentTypes()
{
var builder = new ContainerBuilder();
builder.Register <ILogger>(c => new Logger()).InstancePerDependency();
builder.Register(c => new TestAuthenticationFilter(c.Resolve <ILogger>()))
.AsWebApiAuthenticationFilterFor <TestController>()
.InstancePerRequest();
builder.Register(c => new TestAuthorizationFilter(c.Resolve <ILogger>()))
.AsWebApiAuthorizationFilterFor <TestController>()
.InstancePerRequest();
builder.Register(c => new TestExceptionFilter(c.Resolve <ILogger>()))
.AsWebApiExceptionFilterFor <TestController>()
.InstancePerRequest();
builder.Register(c => new TestActionFilter(c.Resolve <ILogger>()))
.AsWebApiActionFilterFor <TestController>()
.InstancePerRequest();
var configuration = new HttpConfiguration();
builder.RegisterWebApiFilterProvider(configuration);
var container = builder.Build();
var provider = new AutofacWebApiFilterProvider(container);
configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container);
var actionDescriptor = BuildActionDescriptorForGetMethod();
var filterInfos = provider.GetFilters(configuration, actionDescriptor).ToArray();
var filters = filterInfos.Select(info => info.Instance).ToArray();
Assert.Single(filters.OfType <AuthenticationFilterWrapper>());
Assert.Single(filters.OfType <AuthorizationFilterWrapper>());
Assert.Single(filters.OfType <ExceptionFilterWrapper>());
Assert.Single(filters.OfType <ContinuationActionFilterWrapper>());
}
void AssertOverrideFilter <TController>(
Func <IComponentContext, TFilter1> registration,
Action <IRegistrationBuilder <TFilter1, SimpleActivatorData, SingleRegistrationStyle> > configure)
{
var builder = new ContainerBuilder();
builder.Register <ILogger>(c => new Logger()).InstancePerDependency();
configure(builder.Register(registration).InstancePerRequest());
var container = builder.Build();
var provider = new AutofacWebApiFilterProvider(container);
var configuration = new HttpConfiguration {
DependencyResolver = new AutofacWebApiDependencyResolver(container)
};
var actionDescriptor = BuildActionDescriptorForGetMethod(typeof(TController));
var filterInfos = provider.GetFilters(configuration, actionDescriptor).ToArray();
var wrapperType = GetOverrideWrapperType();
var filters = filterInfos.Select(info => info.Instance).Where(i => i.GetType() == wrapperType).ToArray();
Assert.Equal(1, filters.Length);
Assert.IsType(wrapperType, filters[0]);
}
public async void FilterOrderForAllFilterTypes()
{
// This test primarily serves as an example for
// how filters and override filters interact, particularly
// with respect to order of execution.
var actualOrder = new List <Type>();
Action <Type> record = t => actualOrder.Add(t);
var builder = new ContainerBuilder();
builder.RegisterInstance(record);
// Filters - note Autofac controls the order of each grouping of
// filter returned (the order of action filters, the order of exception
// filters, etc.) but Web API is responsible for when each group
// is executed (authorization, action, exception). Notice that it doesn't
// matter if action filters are registered before authentication filters;
// the appropriate group still executes at the right time.
builder.RegisterType <OrderTestActionFilter <A> >().AsWebApiActionFilterFor <TestControllerA>();
builder.RegisterType <OrderTestActionFilter <B> >().AsWebApiActionFilterOverrideFor <TestControllerA>();
builder.RegisterType <OrderTestActionFilter <C> >().AsWebApiActionFilterFor <TestControllerA>();
builder.RegisterType <OrderTestActionFilter <D> >().AsWebApiActionFilterOverrideFor <TestControllerA>();
builder.RegisterType <OrderTestActionFilter <E> >().AsWebApiActionFilterFor <TestControllerA>(c => c.Get());
builder.RegisterType <OrderTestActionFilter <F> >().AsWebApiActionFilterOverrideFor <TestControllerA>(c => c.Get());
builder.RegisterType <OrderTestActionFilter <G> >().AsWebApiActionFilterFor <TestControllerA>(c => c.Get());
builder.RegisterType <OrderTestActionFilter <H> >().AsWebApiActionFilterOverrideFor <TestControllerA>(c => c.Get());
builder.RegisterType <OrderTestAuthenticationFilter <A> >().AsWebApiAuthenticationFilterFor <TestControllerA>();
builder.RegisterType <OrderTestAuthenticationFilter <B> >().AsWebApiAuthenticationFilterOverrideFor <TestControllerA>();
builder.RegisterType <OrderTestAuthenticationFilter <C> >().AsWebApiAuthenticationFilterFor <TestControllerA>();
builder.RegisterType <OrderTestAuthenticationFilter <D> >().AsWebApiAuthenticationFilterOverrideFor <TestControllerA>();
builder.RegisterType <OrderTestAuthenticationFilter <E> >().AsWebApiAuthenticationFilterFor <TestControllerA>(c => c.Get());
builder.RegisterType <OrderTestAuthenticationFilter <F> >().AsWebApiAuthenticationFilterOverrideFor <TestControllerA>(c => c.Get());
builder.RegisterType <OrderTestAuthenticationFilter <G> >().AsWebApiAuthenticationFilterFor <TestControllerA>(c => c.Get());
builder.RegisterType <OrderTestAuthenticationFilter <H> >().AsWebApiAuthenticationFilterOverrideFor <TestControllerA>(c => c.Get());
builder.RegisterType <OrderTestAuthorizationFilter <A> >().AsWebApiAuthorizationFilterFor <TestControllerA>();
builder.RegisterType <OrderTestAuthorizationFilter <B> >().AsWebApiAuthorizationFilterOverrideFor <TestControllerA>();
builder.RegisterType <OrderTestAuthorizationFilter <C> >().AsWebApiAuthorizationFilterFor <TestControllerA>();
builder.RegisterType <OrderTestAuthorizationFilter <D> >().AsWebApiAuthorizationFilterOverrideFor <TestControllerA>();
builder.RegisterType <OrderTestAuthorizationFilter <E> >().AsWebApiAuthorizationFilterFor <TestControllerA>(c => c.Get());
builder.RegisterType <OrderTestAuthorizationFilter <F> >().AsWebApiAuthorizationFilterOverrideFor <TestControllerA>(c => c.Get());
builder.RegisterType <OrderTestAuthorizationFilter <G> >().AsWebApiAuthorizationFilterFor <TestControllerA>(c => c.Get());
builder.RegisterType <OrderTestAuthorizationFilter <H> >().AsWebApiAuthorizationFilterOverrideFor <TestControllerA>(c => c.Get());
builder.RegisterType <OrderTestExceptionFilter <A> >().AsWebApiExceptionFilterFor <TestControllerA>();
builder.RegisterType <OrderTestExceptionFilter <B> >().AsWebApiExceptionFilterOverrideFor <TestControllerA>();
builder.RegisterType <OrderTestExceptionFilter <C> >().AsWebApiExceptionFilterFor <TestControllerA>();
builder.RegisterType <OrderTestExceptionFilter <D> >().AsWebApiExceptionFilterOverrideFor <TestControllerA>();
builder.RegisterType <OrderTestExceptionFilter <E> >().AsWebApiExceptionFilterFor <TestControllerA>(c => c.Get());
builder.RegisterType <OrderTestExceptionFilter <F> >().AsWebApiExceptionFilterOverrideFor <TestControllerA>(c => c.Get());
builder.RegisterType <OrderTestExceptionFilter <G> >().AsWebApiExceptionFilterFor <TestControllerA>(c => c.Get());
builder.RegisterType <OrderTestExceptionFilter <H> >().AsWebApiExceptionFilterOverrideFor <TestControllerA>(c => c.Get());
var container = builder.Build();
// Set up the filter provider so we can resolve the set of filters
var provider = new AutofacWebApiFilterProvider(container);
// Controller action descriptor needed to request the list of filters
var controllerDescriptor = new HttpControllerDescriptor {
ControllerType = typeof(TestControllerA)
};
var methodInfo = typeof(TestControllerA).GetMethod("Get");
var actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, methodInfo);
// Get the filters!
// Unfortunately, this is going to get us a pretty short list
// of things - mostly Autofac filter wrappers. Autofac does lazy
// resolution of the actual filters internally, so you won't
// actually see them in this list. We have to fake an execution
// pipeline to see what's really there.
var configuration = new HttpConfiguration {
DependencyResolver = new AutofacWebApiDependencyResolver(container)
};
var filterInfos = provider.GetFilters(configuration, actionDescriptor).ToArray();
// Fake execution of the filters to force the lazy initialization.
// Each filter will record its type during execution.
//
// Set up a request and some contexts...
var request = new HttpRequestMessage();
request.SetConfiguration(configuration);
var controllerContext = new HttpControllerContext {
Configuration = configuration, Request = request
};
var actionContext = new HttpActionContext()
{
ControllerContext = controllerContext
};
var authnContext = new HttpAuthenticationContext(actionContext, null);
var actionExecutedContext = new HttpActionExecutedContext(actionContext, null);
var token = new CancellationTokenSource().Token;
// Loop through each type of filter in the order Web API would
// do it. This will give us the complete list of filters.
foreach (var fi in filterInfos.Select(f => f.Instance).OfType <AuthorizationFilterAttribute>())
{
await fi.OnAuthorizationAsync(actionContext, token);
}
foreach (var fi in filterInfos.Select(f => f.Instance).OfType <IAuthenticationFilter>())
{
await fi.AuthenticateAsync(authnContext, token);
}
foreach (var fi in filterInfos.Select(f => f.Instance).OfType <ActionFilterAttribute>())
{
await fi.OnActionExecutingAsync(actionContext, token);
}
foreach (var fi in filterInfos.Select(f => f.Instance).OfType <ExceptionFilterAttribute>())
{
await fi.OnExceptionAsync(actionExecutedContext, token);
}
// Order is:
// - Controller scoped overrides
// - Action scoped overrides
// - Controller scoped filters
// - Action scoped filters
var expectedOrder = new Type[]
{
typeof(OrderTestAuthorizationFilter <D>),
typeof(OrderTestAuthorizationFilter <B>),
typeof(OrderTestAuthorizationFilter <H>),
typeof(OrderTestAuthorizationFilter <F>),
typeof(OrderTestAuthorizationFilter <C>),
typeof(OrderTestAuthorizationFilter <A>),
typeof(OrderTestAuthorizationFilter <G>),
typeof(OrderTestAuthorizationFilter <E>),
typeof(OrderTestAuthenticationFilter <D>),
typeof(OrderTestAuthenticationFilter <B>),
typeof(OrderTestAuthenticationFilter <H>),
typeof(OrderTestAuthenticationFilter <F>),
typeof(OrderTestAuthenticationFilter <C>),
typeof(OrderTestAuthenticationFilter <A>),
typeof(OrderTestAuthenticationFilter <G>),
typeof(OrderTestAuthenticationFilter <E>),
typeof(OrderTestActionFilter <D>),
typeof(OrderTestActionFilter <B>),
typeof(OrderTestActionFilter <H>),
typeof(OrderTestActionFilter <F>),
typeof(OrderTestActionFilter <C>),
typeof(OrderTestActionFilter <A>),
typeof(OrderTestActionFilter <G>),
typeof(OrderTestActionFilter <E>),
typeof(OrderTestExceptionFilter <D>),
typeof(OrderTestExceptionFilter <B>),
typeof(OrderTestExceptionFilter <H>),
typeof(OrderTestExceptionFilter <F>),
typeof(OrderTestExceptionFilter <C>),
typeof(OrderTestExceptionFilter <A>),
typeof(OrderTestExceptionFilter <G>),
typeof(OrderTestExceptionFilter <E>),
};
Assert.Equal(expectedOrder.Length, actualOrder.Count);
for (var i = 0; i < expectedOrder.Length; i++)
{
Assert.Equal(expectedOrder[i], actualOrder[i]);
}
}
public void ResolvesMultipleFiltersOfDifferentTypes()
{
var builder = new ContainerBuilder();
builder.Register<ILogger>(c => new Logger()).InstancePerDependency();
builder.Register(c => new TestAuthenticationFilter(c.Resolve<ILogger>()))
.AsWebApiAuthenticationFilterFor<TestController>()
.InstancePerRequest();
builder.Register(c => new TestAuthorizationFilter(c.Resolve<ILogger>()))
.AsWebApiAuthorizationFilterFor<TestController>()
.InstancePerRequest();
builder.Register(c => new TestExceptionFilter(c.Resolve<ILogger>()))
.AsWebApiExceptionFilterFor<TestController>()
.InstancePerRequest();
builder.Register(c => new TestActionFilter(c.Resolve<ILogger>()))
.AsWebApiActionFilterFor<TestController>()
.InstancePerRequest();
var container = builder.Build();
var provider = new AutofacWebApiFilterProvider(container);
var configuration = new HttpConfiguration
{
DependencyResolver = new AutofacWebApiDependencyResolver(container)
};
var actionDescriptor = BuildActionDescriptorForGetMethod();
var filterInfos = provider.GetFilters(configuration, actionDescriptor).ToArray();
var filters = filterInfos.Select(info => info.Instance).ToArray();
Assert.That(filters.OfType<AuthenticationFilterWrapper>().Count(), Is.EqualTo(1));
Assert.That(filters.OfType<AuthorizationFilterWrapper>().Count(), Is.EqualTo(1));
Assert.That(filters.OfType<ExceptionFilterWrapper>().Count(), Is.EqualTo(1));
Assert.That(filters.OfType<ActionFilterWrapper>().Count(), Is.EqualTo(1));
}
