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)); }