private static ResourceExecutingContext CreateResourceExecutingContext(IFilterMetadata[] filters)
{
return new ResourceExecutingContext(
CreateActionContext(),
filters,
new List<IValueProviderFactory>());
}
public FilterItem(FilterDescriptor descriptor, IFilterMetadata filter)
: this(descriptor)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
Filter = filter;
}
private void ApplyFilterToContainer(object actualFilter, IFilterMetadata filterMetadata)
{
Debug.Assert(actualFilter != null, "actualFilter should not be null");
Debug.Assert(filterMetadata != null, "filterMetadata should not be null");
var container = actualFilter as IFilterContainer;
if (container != null)
{
container.FilterDefinition = filterMetadata;
}
}
/// <summary>
/// Creates a new <see cref="FilterDescriptor"/>.
/// </summary>
/// <param name="filter">The <see cref="IFilterMetadata"/>.</param>
/// <param name="filterScope">The filter scope.</param>
/// <remarks>
/// If the <paramref name="filter"/> implements <see cref="IOrderedFilter"/>, then the value of
/// <see cref="Order"/> will be taken from <see cref="IOrderedFilter.Order"/>. Otherwise the value
/// of <see cref="Order"/> will default to <c>0</c>.
/// </remarks>
public FilterDescriptor(IFilterMetadata filter, int filterScope)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
Filter = filter;
Scope = filterScope;
var orderedFilter = Filter as IOrderedFilter;
if (orderedFilter != null)
{
Order = orderedFilter.Order;
}
}
public async Task ProducesContentAttribute_FormatFilterAttribute_Active()
{
// Arrange
var producesContentAttribute = new ProducesAttribute("application/xml");
var formatFilter = new Mock<IFormatFilter>();
formatFilter.Setup(f => f.IsActive)
.Returns(true);
var filters = new IFilterMetadata[] { producesContentAttribute, formatFilter.Object };
var resultExecutingContext = CreateResultExecutingContext(filters);
var next = new ResultExecutionDelegate(
() => Task.FromResult(CreateResultExecutedContext(resultExecutingContext)));
// Act
await producesContentAttribute.OnResultExecutionAsync(resultExecutingContext, next);
// Assert
var objectResult = Assert.IsType<ObjectResult>(resultExecutingContext.Result);
Assert.Equal(0, objectResult.ContentTypes.Count);
}
public static void ResourceFilterShortCircuited(
this ILogger logger,
IFilterMetadata filter)
{
_resourceFilterShortCircuit(logger, filter, null);
}
/// <summary>
/// Configures the specified <paramref name="filter"/> to apply to all Razor Pages.
/// </summary>
/// <param name="conventions">The <see cref="PageConventionCollection"/> to configure.</param>
/// <param name="filter">The <see cref="IFilterMetadata"/> to add.</param>
/// <returns>The <see cref="PageConventionCollection"/>.</returns>
public static PageConventionCollection ConfigureFilter(this PageConventionCollection conventions, IFilterMetadata filter)
{
if (conventions == null)
{
throw new ArgumentNullException(nameof(conventions));
}
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
conventions.AddFolderApplicationModelConvention("/", model => model.Filters.Add(filter));
return(conventions);
}
private static ResultExecutingContext CreateResultExecutingContext(IFilterMetadata filter)
{
return new ResultExecutingContext(
CreateActionContext(),
new IFilterMetadata[] { filter, },
new NoOpResult(),
controller: new object());
}
public static void ActionFilterShortCircuited(
this ILogger logger,
IFilterMetadata filter)
{
_actionFilterShortCircuit(logger, filter, null);
}
public static partial void ResultFilterShortCircuited(this ILogger logger, IFilterMetadata resultFilter);
public static void AuthorizationFailure(
this ILogger logger,
IFilterMetadata filter)
{
_authorizationFailure(logger, filter, null);
}
public ResourceExecutingContext CreateResourceExecutingContext(IFilterMetadata[] filters)
{
var context = new ResourceExecutingContext(
MockActionContext,
filters,
new List<IValueProviderFactory>());
return context;
}
public void OnProvidersExecuting(ActionInvokerProviderContext context)
{
var actionDescriptor = context.ActionContext.ActionDescriptor as PageActionDescriptor;
if (actionDescriptor != null)
{
var itemCount = actionDescriptor.FilterDescriptors?.Count ?? 0;
var filterItems = new List <FilterItem>(itemCount);
for (var i = 0; i < itemCount; i++)
{
var item = new FilterItem(actionDescriptor.FilterDescriptors[i]);
filterItems.Add(item);
}
var filterProviderContext = new FilterProviderContext(context.ActionContext, filterItems);
for (var i = 0; i < _filterProviders.Length; i++)
{
_filterProviders[i].OnProvidersExecuting(filterProviderContext);
}
for (var i = _filterProviders.Length - 1; i >= 0; i--)
{
_filterProviders[i].OnProvidersExecuted(filterProviderContext);
}
var filters = new IFilterMetadata[filterProviderContext.Results.Count];
for (var i = 0; i < filterProviderContext.Results.Count; i++)
{
filters[i] = filterProviderContext.Results[i].Filter;
}
var compiledType = _loader.Load(actionDescriptor);
var compiledActionDescriptor = new CompiledPageActionDescriptor(actionDescriptor)
{
PageType = compiledType.GetTypeInfo(),
HandlerMethods = new List <HandlerMethodDescriptor>(),
};
foreach (var method in compiledType.GetTypeInfo().GetMethods())
{
if (method.Name.StartsWith("OnGet") ||
method.Name.StartsWith("OnPost"))
{
compiledActionDescriptor.HandlerMethods.Add(new HandlerMethodDescriptor()
{
Method = method,
});
}
}
context.Result = new PageActionInvoker(
_diagnosticSource,
_logger,
_factory,
_selector,
_metadataProvider,
_tempDataFactory,
_viewOptions,
filters,
_valueProviderFactories,
context.ActionContext,
compiledActionDescriptor);
}
}
/// <summary>
/// Registers a filter as global application model convention.
/// </summary>
/// <param name="filter">A custom filter to register.</param>
/// <param name="controllerPredicate">A controller predicate for more granular application of the filter.</param>
/// <param name="actionPredicate">An action predicate for more granular application of the filter.</param>
/// <param name="selectorPredicate">A selector predicate for more granular application of the filter.</param>
public static void AddGlobalFilter(this MvcOptions opts, IFilterMetadata filter, Func <ControllerModel, bool> controllerPredicate = null, Func <ActionModel, bool> actionPredicate = null,
Func <SelectorModel, bool> selectorPredicate = null)
{
opts.Conventions.Insert(0, new GlobalFilterApplicationModelConvention(controllerPredicate, actionPredicate, selectorPredicate, filter));
}
private static ResourceExecutingContext CreateResourceExecutingContext(IFilterMetadata[] filters)
{
return new ResourceExecutingContext(
CreateActionContext(),
filters);
}
public InstancedFilterFactory(IFilterMetadata instance, int order)
{
_instance = instance;
Order = order;
}
public static partial void ResourceFilterShortCircuited(ILogger logger, IFilterMetadata resourceFilter);
public static partial void AuthorizationFailure(ILogger logger, IFilterMetadata authorizationFilter);
public static void ActionFilterShortCircuited(
this ILogger logger,
IFilterMetadata filter)
{
_actionFilterShortCircuit(logger, filter, null);
}
public static partial void PageFilterShortCircuited(
this ILogger logger,
IFilterMetadata pageFilter);
/// <summary>
/// Adds a filter to the current MVC setup to run on every call in this hosted test server.
/// </summary>
/// <param name="filter">The filter to add.</param>
/// <exception cref="ArgumentNullException">When the <paramref name="filter"/> is <c>null</c>.</exception>
public void AddFilter(IFilterMetadata filter)
{
Guard.NotNull(filter, "Filter cannot be 'null'");
_filters.Add(filter);
}
public GlobalFilterApplicationModelConvention(
Func <ControllerModel, bool> controllerPredicate, Func <ActionModel, bool> actionPredicate, Func <SelectorModel, bool> selectorPredicate, IFilterMetadata filter)
{
_controllerPredicate = controllerPredicate ?? (c => true);
_actionPredicate = actionPredicate ?? (a => true);
_selectorPredicate = selectorPredicate ?? (s => true);
_filter = filter;
}
public static partial void ExceptionFilterShortCircuited(this ILogger logger, IFilterMetadata exceptionFilter);
public static void AfterExecutingMethodOnFilter(this ILogger logger, string filterType, string methodName, IFilterMetadata filter)
{
_afterExecutingMethodOnFilter(logger, filterType, methodName, filter.GetType().ToString(), null);
}
public static void ResourceFilterShortCircuited(
this ILogger logger,
IFilterMetadata filter)
{
_resourceFilterShortCircuit(logger, filter, null);
}
public ResourceExecutingContext CreateResourceExecutingContext(IFilterMetadata[] filters)
{
var context = new ResourceExecutingContext(
MockActionContext,
filters);
return context;
}
private static ResultExecutingContext CreateResultExecutingContext(IFilterMetadata[] filters)
{
return new ResultExecutingContext(
CreateActionContext(),
filters,
new ObjectResult("Some Value"),
controller: new object());
}
private TestControllerActionInvoker CreateInvoker(
IFilterMetadata[] filters,
bool actionThrows = false,
int maxAllowedErrorsInModelState = 200)
{
var actionDescriptor = new ControllerActionDescriptor()
{
FilterDescriptors = new List<FilterDescriptor>(),
Parameters = new List<ParameterDescriptor>(),
};
if (actionThrows)
{
actionDescriptor.MethodInfo = typeof(ControllerActionInvokerTest).GetMethod("ThrowingActionMethod");
}
else
{
actionDescriptor.MethodInfo = typeof(ControllerActionInvokerTest).GetMethod("ActionMethod");
}
var httpContext = new Mock<HttpContext>(MockBehavior.Loose);
var http = GetHttpContext();
var httpRequest = http.Request;
var httpResponse = http.Response;
httpContext.SetupGet(c => c.Request).Returns(httpRequest);
httpContext.SetupGet(c => c.Response).Returns(httpResponse);
httpContext
.Setup(o => o.RequestServices.GetService(typeof(ILoggerFactory)))
.Returns(NullLoggerFactory.Instance);
httpResponse.Body = new MemoryStream();
var formatter = new Mock<IOutputFormatter>();
formatter
.Setup(f => f.CanWriteResult(It.IsAny<OutputFormatterCanWriteContext>()))
.Returns(true);
formatter
.Setup(f => f.WriteAsync(It.IsAny<OutputFormatterWriteContext>()))
.Returns<OutputFormatterWriteContext>(async c =>
{
await c.HttpContext.Response.WriteAsync(c.Object.ToString());
});
var options = new MvcOptions();
options.OutputFormatters.Add(formatter.Object);
var optionsAccessor = new Mock<IOptions<MvcOptions>>();
optionsAccessor
.SetupGet(o => o.Value)
.Returns(options);
httpContext
.Setup(o => o.RequestServices.GetService(typeof(IOptions<MvcOptions>)))
.Returns(optionsAccessor.Object);
var actionContext = new ActionContext(
httpContext: httpContext.Object,
routeData: new RouteData(),
actionDescriptor: actionDescriptor);
var filterProvider = new Mock<IFilterProvider>(MockBehavior.Strict);
filterProvider
.Setup(fp => fp.OnProvidersExecuting(It.IsAny<FilterProviderContext>()))
.Callback<FilterProviderContext>(context =>
{
foreach (var filterMetadata in filters)
{
var filter = new FilterItem(
new FilterDescriptor(filterMetadata, FilterScope.Action),
filterMetadata);
context.Results.Add(filter);
}
});
filterProvider
.Setup(fp => fp.OnProvidersExecuted(It.IsAny<FilterProviderContext>()))
.Verifiable();
var actionArgumentsBinder = new Mock<IControllerActionArgumentBinder>();
actionArgumentsBinder.Setup(
b => b.BindActionArgumentsAsync(It.IsAny<ControllerContext>(), It.IsAny<object>()))
.Returns(Task.FromResult<IDictionary<string, object>>(new Dictionary<string, object>()));
filterProvider
.SetupGet(fp => fp.Order)
.Returns(-1000);
var invoker = new TestControllerActionInvoker(
actionContext,
new[] { filterProvider.Object },
new MockControllerFactory(this),
actionDescriptor,
new IInputFormatter[0],
actionArgumentsBinder.Object,
new IModelBinder[0],
new IModelValidatorProvider[0],
new IValueProviderFactory[0],
new NullLoggerFactory().CreateLogger<ControllerActionInvoker>(),
new DiagnosticListener("Microsoft.AspNet"),
maxAllowedErrorsInModelState);
return invoker;
}
private static ActionExecutingContext CreateActionExecutingContext(IFilterMetadata filter)
{
return new ActionExecutingContext(
CreateActionContext(),
new IFilterMetadata[] { filter, },
new Dictionary<string, object>(),
controller: new object());
}
public static partial void AfterExecutingMethodOnFilter(this ILogger logger, string filterType, string method, IFilterMetadata filter);
public static void PageFilterShortCircuited(
this ILogger logger,
IFilterMetadata filter)
{
_pageFilterShortCircuit(logger, filter, null);
}
private TestControllerActionInvoker CreateInvoker(
IFilterMetadata[] filters,
bool actionThrows = false,
int maxAllowedErrorsInModelState = 200)
{
var actionDescriptor = new ControllerActionDescriptor()
{
FilterDescriptors = new List<FilterDescriptor>(),
Parameters = new List<ParameterDescriptor>(),
};
if (actionThrows)
{
actionDescriptor.MethodInfo = typeof(ControllerActionInvokerTest).GetMethod("ThrowingActionMethod");
}
else
{
actionDescriptor.MethodInfo = typeof(ControllerActionInvokerTest).GetMethod("ActionMethod");
}
var httpContext = new Mock<HttpContext>(MockBehavior.Loose);
var httpRequest = new DefaultHttpContext().Request;
var httpResponse = new DefaultHttpContext().Response;
httpContext.SetupGet(c => c.Request).Returns(httpRequest);
httpContext.SetupGet(c => c.Response).Returns(httpResponse);
httpContext.Setup(o => o.RequestServices.GetService(typeof(ILogger<ObjectResult>)))
.Returns(new Mock<ILogger<ObjectResult>>().Object);
httpResponse.Body = new MemoryStream();
var formatter = new Mock<IOutputFormatter>();
formatter
.Setup(f => f.CanWriteResult(It.IsAny<OutputFormatterContext>(), It.IsAny<MediaTypeHeaderValue>()))
.Returns(true);
formatter
.Setup(f => f.WriteAsync(It.IsAny<OutputFormatterContext>()))
.Returns<OutputFormatterContext>(async c =>
{
await c.HttpContext.Response.WriteAsync(c.Object.ToString());
});
var options = new MvcOptions();
options.OutputFormatters.Add(formatter.Object);
var optionsAccessor = new Mock<IOptions<MvcOptions>>();
optionsAccessor
.SetupGet(o => o.Options)
.Returns(options);
httpContext
.Setup(o => o.RequestServices.GetService(typeof(IOptions<MvcOptions>)))
.Returns(optionsAccessor.Object);
var actionContext = new ActionContext(
httpContext: httpContext.Object,
routeData: new RouteData(),
actionDescriptor: actionDescriptor);
var filterProvider = new Mock<IFilterProvider>(MockBehavior.Strict);
filterProvider
.Setup(fp => fp.OnProvidersExecuting(It.IsAny<FilterProviderContext>()))
.Callback<FilterProviderContext>(context =>
{
foreach (var filter in filters.Select(f => new FilterItem(null, f)))
{
context.Results.Add(filter);
}
});
filterProvider.Setup(fp => fp.OnProvidersExecuted(It.IsAny<FilterProviderContext>()))
.Verifiable();
filterProvider.SetupGet(fp => fp.Order)
.Returns(DefaultOrder.DefaultFrameworkSortOrder);
var invoker = new TestControllerActionInvoker(
actionContext,
new[] { filterProvider.Object },
new MockControllerFactory(this),
actionDescriptor,
new IInputFormatter[0],
new IOutputFormatter[0],
Mock.Of<IControllerActionArgumentBinder>(),
new IModelBinder[0],
new IModelValidatorProvider[0],
new IValueProviderFactory[0],
new ActionBindingContextAccessor(),
new NullLoggerFactory().CreateLogger<ControllerActionInvoker>(),
new Notifier(new ProxyNotifierMethodAdapter()),
maxAllowedErrorsInModelState);
return invoker;
}
private TestControllerActionInvoker CreateInvoker(
IFilterMetadata filter,
bool actionThrows = false,
int maxAllowedErrorsInModelState = 200)
{
return CreateInvoker(new[] { filter }, actionThrows, maxAllowedErrorsInModelState);
}
public FilterItem([NotNull] FilterDescriptor descriptor, [NotNull] IFilterMetadata filter)
: this(descriptor)
{
Filter = filter;
}
public static void AuthorizationFailure(
this ILogger logger,
IFilterMetadata filter)
{
_authorizationFailure(logger, filter, null);
}
public void Setup()
{
testEnvironment = new TestEnvironment(services => { services.AddSingleton <ControllerConvention>(); });
controllerConvention = testEnvironment.ServiceProvider.GetRequiredService <ControllerConvention>();
someFilter = new AuthorizeFilter();
}
