public async void SelectAsync_AmbiguousActions_LogIsCorrect() { // Arrange var sink = new TestSink(); var loggerFactory = new TestLoggerFactory(sink, enabled: true); var actions = new ActionDescriptor[] { new ActionDescriptor() { DisplayName = "A1" }, new ActionDescriptor() { DisplayName = "A2" }, }; var selector = CreateSelector(actions, loggerFactory); var routeContext = CreateRouteContext("POST"); var actionNames = string.Join(Environment.NewLine, actions.Select(action => action.DisplayName)); var expectedMessage = "Request matched multiple actions resulting in " + $"ambiguity. Matching actions: {actionNames}"; // Act await Assert.ThrowsAsync<AmbiguousActionException>(async () => { await selector.SelectAsync(routeContext); }); // Assert Assert.Empty(sink.Scopes); Assert.Single(sink.Writes); Assert.Equal(expectedMessage, sink.Writes[0].State?.ToString()); }
public virtual object ApplyQueryOptions(object value, HttpRequest request, ActionDescriptor descriptor) { var elementClrType = TypeHelper.GetImplementedIEnumerableType(value.GetType()); var model = request.ODataProperties().Model; if (model == null) { throw Error.InvalidOperation(SRResources.QueryGetModelMustNotReturnNull); } var queryContext = new ODataQueryContext( model, elementClrType, request.ODataProperties().Path); var queryOptions = new ODataQueryOptions(queryContext, request); var enumerable = value as IEnumerable; if (enumerable == null) { // response is single entity. return value; } // response is a collection. var query = (value as IQueryable) ?? enumerable.AsQueryable(); return queryOptions.ApplyTo(query, new ODataQuerySettings { HandleNullPropagation = HandleNullPropagationOption.True }); }
public async void SelectAsync_NoMatchedActions_LogIsCorrect() { // Arrange var sink = new TestSink(); var loggerFactory = new TestLoggerFactory(sink); var routeContext = CreateRouteContext("POST"); var actions = new ActionDescriptor[0]; var selector = CreateSelector(actions, loggerFactory); // Act var action = await selector.SelectAsync(routeContext); // Assert Assert.Equal(1, sink.Scopes.Count); var scope = sink.Scopes[0]; Assert.Equal(typeof(DefaultActionSelector).FullName, scope.LoggerName); Assert.Equal("DefaultActionSelector.SelectAsync", scope.Scope); Assert.Equal(1, sink.Writes.Count); var write = sink.Writes[0]; Assert.Equal(typeof(DefaultActionSelector).FullName, write.LoggerName); Assert.Equal("DefaultActionSelector.SelectAsync", write.Scope); var values = Assert.IsType<DefaultActionSelectorSelectAsyncValues>(write.State); Assert.Equal("DefaultActionSelector.SelectAsync", values.Name); Assert.Empty(values.ActionsMatchingRouteConstraints); Assert.Empty(values.ActionsMatchingActionConstraints); Assert.Empty(values.FinalMatches); Assert.Null(values.SelectedAction); // (does not throw) Assert.NotEmpty(values.Summary); }
public void OnBeforeAction(ActionDescriptor actionDescriptor, HttpContext httpContext, RouteData routeData) { string name = this.GetNameFromRouteContext(routeData); var telemetry = httpContext.RequestServices.GetService<RequestTelemetry>(); if (!string.IsNullOrEmpty(name) && telemetry != null && telemetry is RequestTelemetry) { name = httpContext.Request.Method + " " + name; ((RequestTelemetry)telemetry).Name = name; } }
public async void SelectAsync_MatchedActions_LogIsCorrect() { // Arrange var sink = new TestSink(); var loggerFactory = new TestLoggerFactory(sink); var matched = new ActionDescriptor() { MethodConstraints = new List<HttpMethodConstraint>() { new HttpMethodConstraint(new string[] { "POST" }), }, Parameters = new List<ParameterDescriptor>(), }; var notMatched = new ActionDescriptor() { Parameters = new List<ParameterDescriptor>(), }; var actions = new ActionDescriptor[] { matched, notMatched }; var selector = CreateSelector(actions, loggerFactory); var routeContext = CreateRouteContext("POST"); // Act var action = await selector.SelectAsync(routeContext); // Assert Assert.Equal(1, sink.Scopes.Count); var scope = sink.Scopes[0]; Assert.Equal(typeof(DefaultActionSelector).FullName, scope.LoggerName); Assert.Equal("DefaultActionSelector.SelectAsync", scope.Scope); // There is a record for IsEnabled and one for WriteCore. Assert.Equal(2, sink.Writes.Count); var enabled = sink.Writes[0]; Assert.Equal(typeof(DefaultActionSelector).FullName, enabled.LoggerName); Assert.Equal("DefaultActionSelector.SelectAsync", enabled.Scope); Assert.Null(enabled.State); var write = sink.Writes[1]; Assert.Equal(typeof(DefaultActionSelector).FullName, write.LoggerName); Assert.Equal("DefaultActionSelector.SelectAsync", write.Scope); var values = Assert.IsType<DefaultActionSelectorSelectAsyncValues>(write.State); Assert.Equal("DefaultActionSelector.SelectAsync", values.Name); Assert.NotEmpty(values.ActionsMatchingRouteConstraints); Assert.NotEmpty(values.ActionsMatchingRouteAndMethodConstraints); Assert.NotEmpty(values.ActionsMatchingWithConstraints); Assert.Equal(matched, values.SelectedAction); }
public void EmptyResult_ExecuteResult_IsANoOp() { // Arrange var emptyResult = new EmptyResult(); var httpContext = new Mock<HttpContext>(MockBehavior.Strict); var routeData = new RouteData(); var actionDescriptor = new ActionDescriptor(); var context = new ActionContext(httpContext.Object, routeData, actionDescriptor); // Act & Assert (does not throw) emptyResult.ExecuteResult(context); }
public IActionInvoker GetInvoker(RequestContext requestContext, ActionDescriptor descriptor) { var controllerActionDescriptor = descriptor as ControllerBasedActionDescriptor; if (controllerActionDescriptor != null) { return new ControllerActionInvoker( requestContext, controllerActionDescriptor, _actionResultFactory, _serviceProvider); } return null; }
public async void SelectAsync_MatchedActions_LogIsCorrect() { // Arrange var sink = new TestSink(); var loggerFactory = new TestLoggerFactory(sink); var matched = new ActionDescriptor() { ActionConstraints = new List<IActionConstraintMetadata>() { new HttpMethodConstraint(new string[] { "POST" }), }, Parameters = new List<ParameterDescriptor>(), }; var notMatched = new ActionDescriptor() { Parameters = new List<ParameterDescriptor>(), }; var actions = new ActionDescriptor[] { matched, notMatched }; var selector = CreateSelector(actions, loggerFactory); var routeContext = CreateRouteContext("POST"); // Act var action = await selector.SelectAsync(routeContext); // Assert Assert.Equal(1, sink.Scopes.Count); var scope = sink.Scopes[0]; Assert.Equal(typeof(DefaultActionSelector).FullName, scope.LoggerName); Assert.Equal("DefaultActionSelector.SelectAsync", scope.Scope); Assert.Equal(1, sink.Writes.Count); var write = sink.Writes[0]; Assert.Equal(typeof(DefaultActionSelector).FullName, write.LoggerName); Assert.Equal("DefaultActionSelector.SelectAsync", write.Scope); var values = Assert.IsType<DefaultActionSelectorSelectAsyncValues>(write.State); Assert.Equal("DefaultActionSelector.SelectAsync", values.Name); Assert.Equal<ActionDescriptor>(actions, values.ActionsMatchingRouteConstraints); Assert.Equal<ActionDescriptor>(new[] { matched }, values.ActionsMatchingActionConstraints); Assert.Equal(matched, Assert.Single(values.FinalMatches)); Assert.Equal(matched, values.SelectedAction); }
public void HttpStatusCodeResult_ExecuteResultSetsResponseStatusCode() { // Arrange var result = new HttpStatusCodeResult(StatusCodes.Status404NotFound); var httpContext = new DefaultHttpContext(); var routeData = new RouteData(); var actionDescriptor = new ActionDescriptor(); var context = new ActionContext(httpContext, routeData, actionDescriptor); // Act result.ExecuteResult(context); // Assert Assert.Equal(StatusCodes.Status404NotFound, httpContext.Response.StatusCode); }
public void Accept_MatchesForMachingRequestContentType(string contentType) { // Arrange var constraint = new ConsumesAttribute("application/json", "text/xml"); var action = new ActionDescriptor() { FilterDescriptors = new List<FilterDescriptor>() { new FilterDescriptor(constraint, FilterScope.Action) } }; var context = new ActionConstraintContext(); context.Candidates = new List<ActionSelectorCandidate>() { new ActionSelectorCandidate(action, new [] { constraint }), }; context.CurrentCandidate = context.Candidates[0]; context.RouteContext = CreateRouteContext(contentType: contentType); // Act & Assert Assert.True(constraint.Accept(context)); }
public async Task SelectAsync_ConstraintsInOrder_MultipleStages() { // Arrange var best = new ActionDescriptor() { ActionConstraints = new List<IActionConstraintMetadata>() { new BooleanConstraint() { Pass = true, Order = 0, }, new BooleanConstraint() { Pass = true, Order = 1, }, new BooleanConstraint() { Pass = true, Order = 2, }, }, }; var worst = new ActionDescriptor() { ActionConstraints = new List<IActionConstraintMetadata>() { new BooleanConstraint() { Pass = true, Order = 0, }, new BooleanConstraint() { Pass = true, Order = 1, }, new BooleanConstraint() { Pass = true, Order = 3, }, }, }; var actions = new ActionDescriptor[] { best, worst }; var selector = CreateSelector(actions); var context = CreateRouteContext("POST"); // Act var action = await selector.SelectAsync(context); // Assert Assert.Same(action, best); }
public async Task SelectAsync_CustomProvider() { // Arrange var actionWithConstraints = new ActionDescriptor() { ActionConstraints = new List<IActionConstraintMetadata>() { new BooleanConstraintMarker() { Pass = true }, } }; var actionWithoutConstraints = new ActionDescriptor() { Parameters = new List<ParameterDescriptor>(), }; var actions = new ActionDescriptor[] { actionWithConstraints, actionWithoutConstraints, }; var selector = CreateSelector(actions); var context = CreateRouteContext("POST"); // Act var action = await selector.SelectAsync(context); // Assert Assert.Same(action, actionWithConstraints); }
public async Task SelectAsync_ActionConstraintFactory_ReturnsNull() { // Arrange var nullConstraint = new ActionDescriptor() { ActionConstraints = new List<IActionConstraintMetadata>() { new ConstraintFactory() { }, } }; var actions = new ActionDescriptor[] { nullConstraint }; var selector = CreateSelector(actions); var context = CreateRouteContext("POST"); // Act var action = await selector.SelectAsync(context); // Assert Assert.Same(action, nullConstraint); }
public ActionContext([NotNull] RouteContext routeContext, [NotNull] ActionDescriptor actionDescriptor) : this(routeContext.HttpContext, routeContext.RouteData, actionDescriptor) { }
public IActionInvoker CreateInvoker(RequestContext requestContext) { ActionDescriptor descriptor = _actionDescriptorProvider.CreateDescriptor(requestContext); return _actionInvokerProvider.GetInvoker(requestContext, descriptor); }
public void Accept_ForNoRequestType_ReturnsTrueForAllConstraints(string contentType) { // Arrange var constraint1 = new ConsumesAttribute("application/json"); var actionWithConstraint = new ActionDescriptor() { FilterDescriptors = new List<FilterDescriptor>() { new FilterDescriptor(constraint1, FilterScope.Action) } }; var constraint2 = new ConsumesAttribute("text/xml"); var actionWithConstraint2 = new ActionDescriptor() { FilterDescriptors = new List<FilterDescriptor>() { new FilterDescriptor(constraint2, FilterScope.Action) } }; var actionWithoutConstraint = new ActionDescriptor(); var context = new ActionConstraintContext(); context.Candidates = new List<ActionSelectorCandidate>() { new ActionSelectorCandidate(actionWithConstraint, new [] { constraint1 }), new ActionSelectorCandidate(actionWithConstraint2, new [] { constraint2 }), }; context.RouteContext = CreateRouteContext(contentType: contentType); // Act & Assert context.CurrentCandidate = context.Candidates[0]; Assert.True(constraint1.Accept(context)); context.CurrentCandidate = context.Candidates[1]; Assert.True(constraint2.Accept(context)); }
public async Task SelectAsync_Ambiguous() { // Arrange var expectedMessage = "Multiple actions matched. " + "The following actions matched route data and had all constraints satisfied:" + Environment.NewLine + Environment.NewLine + "Ambiguous1" + Environment.NewLine + "Ambiguous2"; var actions = new ActionDescriptor[] { CreateAction(area: null, controller: "Store", action: "Buy"), CreateAction(area: null, controller: "Store", action: "Buy"), CreateAction(area: null, controller: "Store", action: "Cart"), }; actions[0].DisplayName = "Ambiguous1"; actions[1].DisplayName = "Ambiguous2"; var selector = CreateSelector(actions); var context = CreateRouteContext("GET"); context.RouteData.Values.Add("controller", "Store"); context.RouteData.Values.Add("action", "Buy"); // Act var ex = await Assert.ThrowsAsync<AmbiguousActionException>(async () => { await selector.SelectAsync(context); }); // Assert Assert.Equal(expectedMessage, ex.Message); }
private async Task InvokeActionAsync(RouteContext context, ActionDescriptor actionDescriptor) { var services = context.HttpContext.RequestServices; Debug.Assert(services != null); var actionContext = new ActionContext(context.HttpContext, context.RouteData, actionDescriptor); var contextAccessor = services.GetRequiredService<IScopedInstance<ActionContext>>(); contextAccessor.Value = actionContext; var invokerFactory = services.GetRequiredService<IActionInvokerFactory>(); var invoker = invokerFactory.CreateInvoker(actionContext); if (invoker == null) { throw new InvalidOperationException( Resources.FormatActionInvokerFactory_CouldNotCreateInvoker( actionDescriptor.DisplayName)); } await invoker.InvokeAsync(); }
private bool MatchDynamicConstraints(ActionDescriptor descriptor, RouteContext context) { return descriptor.DynamicConstraints == null || descriptor.DynamicConstraints.All(c => c.Accept(context)); }
private async Task InvokeActionAsync(RouteContext context, ActionDescriptor actionDescriptor) { var services = context.HttpContext.RequestServices; Debug.Assert(services != null); var actionContext = new ActionContext(context.HttpContext, context.RouteData, actionDescriptor); var optionsAccessor = services.GetRequiredService<IOptions<MvcOptions>>(); actionContext.ModelState.MaxAllowedErrors = optionsAccessor.Options.MaxModelValidationErrors; var contextAccessor = services.GetRequiredService<IScopedInstance<ActionContext>>(); contextAccessor.Value = actionContext; var invokerFactory = services.GetRequiredService<IActionInvokerFactory>(); var invoker = invokerFactory.CreateInvoker(actionContext); if (invoker == null) { LogActionSelection(actionSelected: true, actionInvoked: false, handled: context.IsHandled); throw new InvalidOperationException( Resources.FormatActionInvokerFactory_CouldNotCreateInvoker( actionDescriptor.DisplayName)); } await invoker.InvokeAsync(); }
public void OnResourceExecuting_ForAContentTypeMatch_IsNoOp(string contentType) { // Arrange var httpContext = new DefaultHttpContext(); httpContext.Request.ContentType = contentType; var consumesFilter = new ConsumesAttribute("application/json", "application/xml"); var actionWithConstraint = new ActionDescriptor() { ActionConstraints = new List<IActionConstraintMetadata>() { consumesFilter }, FilterDescriptors = new List<FilterDescriptor>() { new FilterDescriptor(consumesFilter, FilterScope.Action) } }; var actionContext = new ActionContext(httpContext, new RouteData(), actionWithConstraint); var resourceExecutingContext = new ResourceExecutingContext(actionContext, new[] { consumesFilter }); // Act consumesFilter.OnResourceExecuting(resourceExecutingContext); // Assert Assert.Null(resourceExecutingContext.Result); }
public async Task SelectAsync_Fallback_ToActionWithoutConstraints() { // Arrange var nomatch1 = new ActionDescriptor() { ActionConstraints = new List<IActionConstraintMetadata>() { new BooleanConstraint() { Pass = true, Order = 0, }, new BooleanConstraint() { Pass = true, Order = 1, }, new BooleanConstraint() { Pass = false, Order = 2, }, }, }; var nomatch2 = new ActionDescriptor() { ActionConstraints = new List<IActionConstraintMetadata>() { new BooleanConstraint() { Pass = true, Order = 0, }, new BooleanConstraint() { Pass = true, Order = 1, }, new BooleanConstraint() { Pass = false, Order = 3, }, }, }; var best = new ActionDescriptor(); var actions = new ActionDescriptor[] { best, nomatch1, nomatch2 }; var selector = CreateSelector(actions); var context = CreateRouteContext("POST"); // Act var action = await selector.SelectAsync(context); // Assert Assert.Same(action, best); }
private async Task InvokeActionAsync(RouteContext context, ActionDescriptor actionDescriptor) { var actionContext = new ActionContext(context.HttpContext, context.RouteData, actionDescriptor); _actionContextAccessor.ActionContext = actionContext; var invoker = _actionInvokerFactory.CreateInvoker(actionContext); if (invoker == null) { throw new InvalidOperationException( Resources.FormatActionInvokerFactory_CouldNotCreateInvoker( actionDescriptor.DisplayName)); } await invoker.InvokeAsync(); }
public async Task SelectAsync_WithCatchAll_NoMatch() { // Arrange var actions = new ActionDescriptor[] { CreateAction(area: null, controller: "Store", action: "Buy"), CreateAction(area: null, controller: "Store", action: "Buy"), CreateAction(area: null, controller: "Store", action: "Buy"), }; actions[0].RouteConstraints.Add(new RouteDataActionConstraint("country", "CA")); actions[1].RouteConstraints.Add(new RouteDataActionConstraint("country", "US")); actions[2].RouteConstraints.Add(RouteDataActionConstraint.CreateCatchAll("country")); var selector = CreateSelector(actions); var context = CreateRouteContext("GET"); context.RouteData.Values.Add("controller", "Store"); context.RouteData.Values.Add("action", "Buy"); // Act var action = await selector.SelectAsync(context); // Assert Assert.Null(action); }
private static ActionDescriptor CreateAction(string area, string controller, string action) { var actionDescriptor = new ActionDescriptor() { Name = string.Format("Area: {0}, Controller: {1}, Action: {2}", area, controller, action), RouteConstraints = new List<RouteDataActionConstraint>(), }; actionDescriptor.RouteConstraints.Add( area == null ? new RouteDataActionConstraint("area", RouteKeyHandling.DenyKey) : new RouteDataActionConstraint("area", area)); actionDescriptor.RouteConstraints.Add( controller == null ? new RouteDataActionConstraint("controller", RouteKeyHandling.DenyKey) : new RouteDataActionConstraint("controller", controller)); actionDescriptor.RouteConstraints.Add( action == null ? new RouteDataActionConstraint("action", RouteKeyHandling.DenyKey) : new RouteDataActionConstraint("action", action)); return actionDescriptor; }
/// <summary> /// Sets the value of an property in the <see cref="ActionDescriptor.Properties"/> collection using /// the provided value of <typeparamref name="T"/> as the key. /// </summary> /// <typeparam name="T">The type of the property.</typeparam> /// <param name="actionDescriptor">The action descriptor.</param> /// <param name="value">The value of the property.</param> public static void SetProperty <T>([NotNull] this ActionDescriptor actionDescriptor, [NotNull] T value) { actionDescriptor.Properties[typeof(T)] = value; }
public void Accept_UnrecognizedMediaType_SelectsTheCandidateWithoutConstraintIfPresent(string contentType) { // Arrange var actionWithoutConstraint = new ActionDescriptor(); var constraint1 = new ConsumesAttribute("application/json"); var actionWithConstraint = new ActionDescriptor() { FilterDescriptors = new List<FilterDescriptor>() { new FilterDescriptor(constraint1, FilterScope.Action) } }; var constraint2 = new ConsumesAttribute("text/xml"); var actionWithConstraint2 = new ActionDescriptor() { FilterDescriptors = new List<FilterDescriptor>() { new FilterDescriptor(constraint2, FilterScope.Action) } }; var context = new ActionConstraintContext(); context.Candidates = new List<ActionSelectorCandidate>() { new ActionSelectorCandidate(actionWithConstraint, new [] { constraint1 }), new ActionSelectorCandidate(actionWithConstraint2, new [] { constraint2 }), new ActionSelectorCandidate(actionWithoutConstraint, new List<IActionConstraint>()), }; context.RouteContext = CreateRouteContext(contentType: contentType); // Act & Assert context.CurrentCandidate = context.Candidates[0]; Assert.False(constraint1.Accept(context)); context.CurrentCandidate = context.Candidates[1]; Assert.False(constraint2.Accept(context)); }
public async Task SelectAsync_PrefersActionWithConstraints() { // Arrange var actionWithConstraints = new ActionDescriptor() { MethodConstraints = new List<HttpMethodConstraint>() { new HttpMethodConstraint(new string[] { "POST" }), }, Parameters = new List<ParameterDescriptor>(), }; var actionWithoutConstraints = new ActionDescriptor() { Parameters = new List<ParameterDescriptor>(), }; var actions = new ActionDescriptor[] { actionWithConstraints, actionWithoutConstraints }; var selector = CreateSelector(actions); var context = CreateRouteContext("POST"); // Act var action = await selector.SelectAsync(context); // Assert Assert.Same(action, actionWithConstraints); }
/// <summary> /// Determines whether the action selection is valid for the specified route context. /// </summary> /// <param name="routeContext">The route context.</param> /// <param name="action">Information about the action.</param> /// <returns> /// <see langword="true"/> if the action selection is valid for the specified context; /// otherwise, <see langword="false"/>. /// </returns> public abstract bool IsValidForRequest(RouteContext routeContext, ActionDescriptor action);
public async Task SelectAsync_ConstraintsRejectAll_DifferentStages() { // Arrange var action1 = new ActionDescriptor() { ActionConstraints = new List<IActionConstraintMetadata>() { new BooleanConstraint() { Pass = false, Order = 0 }, new BooleanConstraint() { Pass = true, Order = 1 }, }, }; var action2 = new ActionDescriptor() { ActionConstraints = new List<IActionConstraintMetadata>() { new BooleanConstraint() { Pass = true, Order = 0 }, new BooleanConstraint() { Pass = false, Order = 1 }, }, }; var actions = new ActionDescriptor[] { action1, action2 }; var selector = CreateSelector(actions); var context = CreateRouteContext("POST"); // Act var action = await selector.SelectAsync(context); // Assert Assert.Null(action); }
private RouteContext CreateRouteContext( ActionDescriptor actionDescriptor = null, IActionSelector actionSelector = null, IActionInvokerFactory invokerFactory = null, ILoggerFactory loggerFactory = null, IOptions<MvcOptions> optionsAccessor = null, object notificationListener = null) { var mockContextAccessor = new Mock<IScopedInstance<ActionContext>>(); if (actionDescriptor == null) { var mockAction = new Mock<ActionDescriptor>(); actionDescriptor = mockAction.Object; } if (actionSelector == null) { var mockActionSelector = new Mock<IActionSelector>(); mockActionSelector.Setup(a => a.SelectAsync(It.IsAny<RouteContext>())) .Returns(Task.FromResult(actionDescriptor)); actionSelector = mockActionSelector.Object; } if (invokerFactory == null) { var mockInvoker = new Mock<IActionInvoker>(); mockInvoker.Setup(i => i.InvokeAsync()) .Returns(Task.FromResult(true)); var mockInvokerFactory = new Mock<IActionInvokerFactory>(); mockInvokerFactory.Setup(f => f.CreateInvoker(It.IsAny<ActionContext>())) .Returns(mockInvoker.Object); invokerFactory = mockInvokerFactory.Object; } if (loggerFactory == null) { loggerFactory = NullLoggerFactory.Instance; } if (optionsAccessor == null) { optionsAccessor = new MockMvcOptionsAccessor(); } var notifier = new Notifier(new NotifierMethodAdapter()); if (notificationListener != null) { notifier.EnlistTarget(notificationListener); } var httpContext = new Mock<HttpContext>(); httpContext.Setup(h => h.RequestServices.GetService(typeof(IScopedInstance<ActionContext>))) .Returns(mockContextAccessor.Object); httpContext.Setup(h => h.RequestServices.GetService(typeof(IActionSelector))) .Returns(actionSelector); httpContext.Setup(h => h.RequestServices.GetService(typeof(IActionInvokerFactory))) .Returns(invokerFactory); httpContext.Setup(h => h.RequestServices.GetService(typeof(ILoggerFactory))) .Returns(loggerFactory); httpContext.Setup(h => h.RequestServices.GetService(typeof(MvcMarkerService))) .Returns(new MvcMarkerService()); httpContext.Setup(h => h.RequestServices.GetService(typeof(IOptions<MvcOptions>))) .Returns(optionsAccessor); httpContext.Setup(h => h.RequestServices.GetService(typeof(INotifier))) .Returns(notifier); return new RouteContext(httpContext.Object); }
private static HttpContext GetHttpContext(ActionDescriptor actionDescriptor) { var actionProvider = new Mock<IActionDescriptorProvider>(MockBehavior.Strict); actionProvider .SetupGet(p => p.Order) .Returns(DefaultOrder.DefaultFrameworkSortOrder); actionProvider .Setup(p => p.OnProvidersExecuting(It.IsAny<ActionDescriptorProviderContext>())) .Callback<ActionDescriptorProviderContext>(c => c.Results.Add(actionDescriptor)); actionProvider .Setup(p => p.OnProvidersExecuted(It.IsAny<ActionDescriptorProviderContext>())) .Verifiable(); var context = new Mock<HttpContext>(); context.Setup(o => o.RequestServices .GetService(typeof(IEnumerable<IActionDescriptorProvider>))) .Returns(new[] { actionProvider.Object }); context.Setup(o => o.RequestServices .GetService(typeof(IActionDescriptorsCollectionProvider))) .Returns(new DefaultActionDescriptorsCollectionProvider(context.Object.RequestServices)); return context.Object; }
private bool IsApplicable(ActionDescriptor actionDescriptor) { // If there are multiple IConsumeActionConstraints which are defined at the class and // at the action level, the one closest to the action overrides the others. To ensure this // we take advantage of the fact that ConsumesAttribute is both an IActionFilter and an // IConsumeActionConstraint. Since filterdescriptor collection is ordered (the last filter is the one // closest to the action), we apply this constraint only if there is no IConsumeActionConstraint after this. return actionDescriptor.FilterDescriptors.Last( filter => filter.Filter is IConsumesActionConstraint).Filter == this; }
private bool MatchDynamicConstraints(ActionDescriptor descriptor, RouteContext context) { return(descriptor.DynamicConstraints == null || descriptor.DynamicConstraints.All(c => c.Accept(context))); }