/// <summary> /// Overenie, či je URI generovana rovnaka ako identifikátor URI generovaný akčným volaním. /// </summary> /// <typeparam name="TController">Type of expected redirect controller.</typeparam> /// <param name="request">HttpRequestMessage to use for generating the route URI.</param> /// <param name="routeName">Route name from the HTTP configuration routes.</param> /// <param name="routeValues">Route values dictionary of string-object pairs.</param> /// <param name="expectedActionCall">Method call expression indicating the expected action.</param> /// <param name="failedValidationAction">Action to call in case of failed validation.</param> public static void Validate <TController>( HttpRequestMessage request, string routeName, IDictionary <string, object> routeValues, LambdaExpression expectedActionCall, Action <string, string, string> failedValidationAction) where TController : ApiController { var urlHelper = new UrlHelper(request); var actualUri = urlHelper.Route(routeName, routeValues); var expectedRouteValues = RouteExpressionParser.Parse <TController>(expectedActionCall).ToRouteValueDictionary(); var expectedUri = urlHelper.Route(routeName, expectedRouteValues); if (expectedUri == null) { failedValidationAction( "to redirect to", "a specific URI", string.Format("such URI could not be resolved from the '{0}' route template", routeName)); } if (actualUri != expectedUri) { failedValidationAction( "to redirect to", string.Format("'{0}'", expectedUri), string.Format("in fact redirected to '{0}'", actualUri)); } }
public static string ExpressionLink(this IUrlHelper urlHelper, LambdaExpression lambdaExpression) { var routeValues = RouteExpressionParser.Parse(lambdaExpression, considerParameterDescriptors: true); return(urlHelper.Action( routeValues.Action, routeValues.ControllerName, routeValues.ActionArguments.ToSortedRouteValues())); }
public void ParseControllerAndActionWithRouteAttributeControllerActionNameAndParametersAreParsed() { Expression <Action <RouteController> > expr = c => c.Index(); var result = RouteExpressionParser.Parse(expr); Assert.Equal("Route", result.ControllerName); Assert.Equal("Index", result.Action); Assert.Equal(0, result.ActionArguments.Count); }
public void ParseControllerAndActionWithoutParametersControllerAndActionNameAreParsed( Expression <Action <NormalController> > action, string controllerName, string actionName) { var result = RouteExpressionParser.Parse(action); Assert.Equal(controllerName, result.ControllerName); Assert.Equal(actionName, result.Action); Assert.Equal(0, result.ActionArguments.Count); }
public void ParseShouldParseReturningMethods() { Expression <Func <WebApiController, IHttpActionResult> > expression = c => c.OkResultAction(); var result = RouteExpressionParser.Parse <WebApiController>(expression); Assert.IsNotNull(result); Assert.AreEqual(typeof(WebApiController), result.Controller); Assert.AreEqual("OkResultAction", result.Action); Assert.AreEqual(0, result.Arguments.Count); }
public void ParseShouldParseVoidMethods() { Expression <Action <WebApiController> > expression = c => c.EmptyAction(); var result = RouteExpressionParser.Parse <WebApiController>(expression); Assert.IsNotNull(result); Assert.AreEqual(typeof(WebApiController), result.Controller); Assert.AreEqual("EmptyAction", result.Action); Assert.AreEqual(0, result.Arguments.Count); }
public void ParseShouldParseMethodWithActionNameAttribute() { Expression <Func <WebApiController, IHttpActionResult> > expression = c => c.VariousAttributesAction(); var result = RouteExpressionParser.Parse <WebApiController>(expression); Assert.IsNotNull(result); Assert.AreEqual(typeof(WebApiController), result.Controller); Assert.AreEqual("NormalAction", result.Action); Assert.AreEqual(0, result.Arguments.Count); }
public void ParseNonMethodCallExceptionThrowsInvalidOperationException() { var exception = Assert.Throws <InvalidOperationException>(() => { Expression <Action <NormalController> > expr = c => new object(); RouteExpressionParser.Parse(expr); }); Assert.Equal("Provided expression is not valid - expected instance method call but instead received other type of expression.", exception.Message); }
public void ParseNonControllerActionThrowsInvalidOperationException() { var exception = Assert.Throws <InvalidOperationException>(() => { Expression <Action <RequestModel> > expr = c => c.SomeMethod(); RouteExpressionParser.Parse(expr); }); Assert.Equal("Method SomeMethod in class RequestModel is not a valid controller action.", exception.Message); }
public void ParseStaticMethodCallThrowsInvalidOperationException() { var exception = Assert.Throws <InvalidOperationException>(() => { Expression <Action <NormalController> > expr = c => NormalController.StaticCall(); RouteExpressionParser.Parse(expr); }); Assert.Equal("Provided expression is not valid - expected instance method call but instead received static method call.", exception.Message); }
public void ParseCustomConventionsCustomConventionsAreParsedWithNoParameters() { Expression <Action <ConventionsController> > expr = c => c.ConventionsAction(1); var result = RouteExpressionParser.Parse(expr); Assert.Equal("ChangedController", result.ControllerName); Assert.Equal("ChangedAction", result.Action); Assert.Equal(1, result.ActionArguments.Count); Assert.True(result.ActionArguments.ContainsKey("id")); Assert.Equal(1, result.ActionArguments["id"].Value); }
public void ParsePocoControllerControllerActionNameAndParametersAreParsed() { Expression <Action <PocoController> > expr = c => c.Action(1); var result = RouteExpressionParser.Parse(expr); Assert.Equal("Poco", result.ControllerName); Assert.Equal("Action", result.Action); Assert.Equal(1, result.ActionArguments.Count); Assert.True(result.ActionArguments.ContainsKey("id")); Assert.Equal(1, result.ActionArguments["id"].Value); }
public void ParseCustomConventionsCustomConventionsAreParsed() { Expression <Action <ConventionsController> > expr = c => c.ConventionsAction(1); var result = RouteExpressionParser.Parse(expr, considerParameterDescriptors: true); Assert.Equal("ChangedController", result.ControllerName); Assert.Equal("ChangedAction", result.Action); Assert.Equal(1, result.ActionArguments.Count); Assert.True(result.ActionArguments.ContainsKey("ChangedParameter")); Assert.Equal(1, result.ActionArguments["ChangedParameter"].Value); }
public void ParseInAreaControllerControllerActionNameAndAreaAreParsed() { Expression <Action <InAreaController> > expr = c => c.Action(1); var result = RouteExpressionParser.Parse(expr); Assert.Equal("InArea", result.ControllerName); Assert.Equal("Action", result.Action); Assert.Equal(2, result.ActionArguments.Count); Assert.True(result.ActionArguments.ContainsKey("id")); Assert.Equal(1, result.ActionArguments["id"].Value); Assert.True(result.ActionArguments.ContainsKey("area")); Assert.Equal("MyArea", result.ActionArguments["area"].Value); }
public void ParseShouldParseVoidMethodsWithParameters() { var requestModel = new RequestModel(); Expression <Action <WebApiController> > expression = c => c.EmptyActionWithParameters(1, requestModel); var result = RouteExpressionParser.Parse <WebApiController>(expression); Assert.IsNotNull(result); Assert.AreEqual(typeof(WebApiController), result.Controller); Assert.AreEqual("EmptyActionWithParameters", result.Action); Assert.AreEqual(2, result.Arguments.Count); Assert.AreEqual(1, result.Arguments["id"].Value); Assert.AreEqual(requestModel, result.Arguments["model"].Value); }
public void ParseShouldParseReturningMethodsWithParameters() { var requestModel = new RequestModel(); Expression <Func <WebApiController, IHttpActionResult> > expression = c => c.OkResultActionWithRequestBody(1, requestModel); var result = RouteExpressionParser.Parse <WebApiController>(expression); Assert.IsNotNull(result); Assert.AreEqual(typeof(WebApiController), result.Controller); Assert.AreEqual("OkResultActionWithRequestBody", result.Action); Assert.AreEqual(2, result.Arguments.Count); Assert.AreEqual(1, result.Arguments["id"].Value); Assert.AreEqual(requestModel, result.Arguments["model"].Value); }
public void ParseControllerAndActionWithPrimitiveParametersControllerActionNameAndParametersAreParsed( Expression <Action <NormalController> > action, string controllerName, string actionName, IDictionary <string, object> routeValues) { var result = RouteExpressionParser.Parse(action); Assert.Equal(controllerName, result.ControllerName); Assert.Equal(actionName, result.Action); Assert.Equal(routeValues.Count, result.ActionArguments.Count); foreach (var routeValue in routeValues) { Assert.True(result.ActionArguments.ContainsKey(routeValue.Key)); Assert.Equal(routeValue.Value, result.ActionArguments[routeValue.Key].Value); } }
public void ParseActionWithCustomRouteConstraintsRouteConstraintsAreParsed() { Expression <Action <RouteConstraintController> > expr = c => c.Action(1, 2); var result = RouteExpressionParser.Parse(expr); Assert.Equal("CustomController", result.ControllerName); Assert.Equal("CustomAction", result.Action); Assert.Equal(3, result.ActionArguments.Count); Assert.True(result.ActionArguments.ContainsKey("id")); Assert.Equal("5", result.ActionArguments["id"].Value); Assert.True(result.ActionArguments.ContainsKey("key")); Assert.Equal("value", result.ActionArguments["key"].Value); Assert.True(result.ActionArguments.ContainsKey("anotherId")); Assert.Equal(2, result.ActionArguments["anotherId"].Value); }
/// <summary> /// /// </summary> /// <param name="actionCallExpression"></param> public void ParseActionCallExpression(LambdaExpression actionCallExpression) { _expectedActionInvokeInfo = _routeExpressionParser.Parse(actionCallExpression); var isActionMethod = _actionDescriptorCollectionProvider .ActionDescriptors .Items .OfType <ControllerActionDescriptor>() .Any(x => x.MethodInfo == _expectedActionInvokeInfo.ActionMethodInfo); if (isActionMethod) { return; } var actionText = _expectedActionInvokeInfo.ActionMethodInfo.GetActionText(x => x.Name); throw new ArgumentException($"Method {actionText} is not a valid controller action", nameof(actionCallExpression)); }
public void ParseControllerAndActionWithObjectParametersControllerActionNameAndParametersAreParsed() { Expression <Action <NormalController> > expr = c => c.ActionWithMultipleParameters(1, "string", new RequestModel { Integer = 1, String = "Text" }); var result = RouteExpressionParser.Parse(expr); Assert.Equal("Normal", result.ControllerName); Assert.Equal("ActionWithMultipleParameters", result.Action); Assert.Equal(3, result.ActionArguments.Count); Assert.Equal(1, result.ActionArguments["id"].Value); Assert.Equal("string", result.ActionArguments["text"].Value); Assert.IsAssignableFrom <RequestModel>(result.ActionArguments["model"].Value); var model = (RequestModel)result.ActionArguments["model"].Value; Assert.Equal(1, model.Integer); Assert.Equal("Text", model.String); }
public static string ExpressionLink( this IUrlHelper urlHelper, LambdaExpression lambdaExpression, out ICollection <string> ignoredRouteKeys) { var routeValues = RouteExpressionParser.Parse(lambdaExpression, considerParameterDescriptors: true); var ignoredKeys = routeValues .ActionArguments .Where(a => ExpressionParser.IsIgnoredArgument(a.Value.Value)) .Select(a => a.Key) .ToList(); ignoredRouteKeys = ignoredKeys; return(urlHelper.Action( routeValues.Action, routeValues.ControllerName, routeValues.ActionArguments.ToSortedRouteValues(kvp => !ignoredKeys.Contains(kvp.Key)))); }
public ExpressionParsedRouteContext GetExpectedRouteInfo() { return(this.expectedRouteInfo ?? (this.expectedRouteInfo = RouteExpressionParser.Parse(this.actionCallExpression))); }
private ExpressionParsedRouteInfo GetExpectedRouteInfo <TController>() where TController : ApiController { return(this.expectedRouteInfo ?? (this.expectedRouteInfo = RouteExpressionParser.Parse <TController>(this.actionCallExpression))); }