/// <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));
}
}
/// <summary>
/// Indicates that route values should be extracted from the provided action call expression adding the given additional values.
/// </summary>
/// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
/// <param name="builder">Instance of <see cref="IBaseTestBuilderWithComponentBuilder{TBuilder}"/> type.</param>
/// <param name="additionalRouteValues">Anonymous object containing route values.</param>
/// <returns>The same component builder.</returns>
public static TBuilder WithRouteData <TBuilder>(
this IBaseTestBuilderWithComponentBuilder <TBuilder> builder,
object additionalRouteValues)
where TBuilder : IBaseTestBuilder
{
var actualBuilder = (BaseTestBuilderWithComponentBuilder <TBuilder>)builder;
actualBuilder.TestContext.PreMethodInvocationDelegate += () =>
{
var testContext = actualBuilder.TestContext;
if (testContext.RouteDataMethodCall != null)
{
testContext.RouteData = RouteExpressionParser.ResolveRouteData(
TestApplication.Router,
testContext.RouteDataMethodCall);
}
if (testContext.RouteData == null)
{
testContext.RouteData = new RouteData();
testContext.RouteData.Routers.Add(TestApplication.Router);
}
testContext.RouteData.Values.Add(additionalRouteValues);
};
return(actualBuilder.Builder);
}
/// <summary>
///
/// </summary>
/// <param name="actionInvokeInfoCache"></param>
/// <param name="routeExpressionParser"></param>
/// <param name="actionDescriptorCollectionProvider"></param>
public RouteTesterMapsToRouteAssert(
ActualActionInvokeInfoCache actionInvokeInfoCache,
RouteExpressionParser routeExpressionParser,
IActionDescriptorCollectionProvider actionDescriptorCollectionProvider)
{
_actionInvokeInfoCache = actionInvokeInfoCache;
_routeExpressionParser = routeExpressionParser;
_actionDescriptorCollectionProvider = actionDescriptorCollectionProvider;
}
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 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 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);
}
private void SetRouteData(LambdaExpression actionCall)
{
if (this.resolveRouteValues)
{
this.TestContext.RouteData = RouteExpressionParser.ResolveRouteData(TestApplication.Router, actionCall);
RouteExpressionParser.ApplyAdditionaRouteValues(
this.additionalRouteValues,
this.TestContext.RouteData.Values);
}
}
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 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 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 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 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 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 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);
}
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)));
}
