public TestInit()
{
var testAssembly = Assembly.Load(new AssemblyName("AspNet.Mvc.TypedRouting.Test"));
// Run the full controller and action model building
// in order to simulate the default MVC behavior.
var options = new TestOptionsManager <MvcOptions>();
var applicationPartManager = new ApplicationPartManager();
applicationPartManager.FeatureProviders.Add(new ControllerFeatureProvider());
applicationPartManager.ApplicationParts.Add(new AssemblyPart(testAssembly));
var modelProvider = new DefaultApplicationModelProvider(options);
var provider = new ControllerActionDescriptorProvider(
applicationPartManager,
new[] { modelProvider },
options);
var serviceCollection = new ServiceCollection();
var list = new List <IActionDescriptorProvider>()
{
provider,
};
serviceCollection.AddSingleton(typeof(IEnumerable <IActionDescriptorProvider>), list);
serviceCollection.AddSingleton(typeof(IActionDescriptorCollectionProvider), typeof(ActionDescriptorCollectionProvider));
ExpressionRouteHelper.Initialize(serviceCollection.BuildServiceProvider());
}
/// <summary>
/// Generates an absolute URL using the specified route name, <see cref="Expression{TDelegate}"/> for an action method,
/// from which action name, controller name and route values are resolved, and the specified additional route values.
/// </summary>
/// <typeparam name="TController">Controller, from which the action is specified.</typeparam>
/// <param name="routeName">The name of the route that is used to generate the URL.</param>
/// <param name="action">
/// The <see cref="Expression{TDelegate}"/>, from which action name,
/// controller name and route values are resolved.
/// </param>
/// <param name="values">An object that contains additional route values.</param>
/// <returns>The generated absolute URL.</returns>
public static string Link <TController>(
this IUrlHelper helper,
string routeName,
Expression <Action <TController> > action,
object values)
{
var expressionRouteValues = ExpressionRouteHelper.Resolve(action, values, addControllerAndActionToRouteValues: true);
return(helper.Link(routeName, expressionRouteValues.RouteValues));
}
public void Resolve_NonControllerAction_ThrowsInvalidOperationException()
{
// Act
var exception = Assert.Throws <InvalidOperationException>(() =>
{
ExpressionRouteHelper.Resolve <RequestModel>(c => c.SomeMethod());
});
// Assert
Assert.Equal("Method SomeMethod in class RequestModel is not a valid controller action.", exception.Message);
}
public void Resolve_NonMethodCallException_ThrowsInvalidOperationException()
{
// Act
var exception = Assert.Throws <InvalidOperationException>(() =>
{
ExpressionRouteHelper.Resolve <NormalController>(c => new object());
});
// Assert
Assert.Equal("Expression is not valid - expected instance method call but instead received other type of expression.", exception.Message);
}
public void Resolve_StaticMethodCall_ThrowsInvalidOperationException()
{
// Act
var exception = Assert.Throws <InvalidOperationException>(() =>
{
ExpressionRouteHelper.Resolve <NormalController>(c => NormalController.StaticCall());
});
// Assert
Assert.Equal("Expression is not valid - expected instance method call but instead received static method call.", exception.Message);
}
public void Resolve_ControllerAndActionWithoutParameters_ControllerAndActionNameAreResolved(
Expression <Action <NormalController> > action, string controllerName, string actionName)
{
// Act
var result = ExpressionRouteHelper.Resolve(action);
// Assert
Assert.Equal(controllerName, result.Controller);
Assert.Equal(actionName, result.Action);
Assert.Empty(result.RouteValues);
}
/// <summary>
/// Redirects to the specified action by
/// using <see cref="Expression{TDelegate}"/> for an action method,
/// from which action name, controller name and route values are resolved,
/// and the specified additional route values.
/// </summary>
/// <typeparam name="TController">Controller, from which the action is specified.</typeparam>
/// <param name="action">
/// The <see cref="Expression{TDelegate}"/>, from which action name,
/// controller name and route values are resolved.
/// </param>
/// <param name="routeValues">Additional route data to use for generating the URL.</param>
/// <returns>The created <see cref="RedirectToActionResult"/> for the response.</returns>
public static RedirectToActionResult RedirectToAction <TController>(
this TController controller,
Expression <Action <TController> > action,
object routeValues)
where TController : Controller
{
var expressionRouteValues = ExpressionRouteHelper.Resolve(action, routeValues);
return(controller.RedirectToAction(
expressionRouteValues.Action,
expressionRouteValues.RouteValues));
}
public void Resolve_PocoController_ControllerActionNameAndParametersAreResolved()
{
// Act
var result = ExpressionRouteHelper.Resolve <PocoController>(c => c.Action(1));
// Assert
Assert.Equal("Poco", result.Controller);
Assert.Equal("Action", result.Action);
Assert.Equal(1, result.RouteValues.Count);
Assert.True(result.RouteValues.ContainsKey("id"));
Assert.Equal(1, result.RouteValues["id"]);
}
/// <summary>
/// Redirects to the specified route with <see cref="RedirectToActionResult.Permanent"/> set to true by
/// using <see cref="Expression{TDelegate}"/> for an action method,
/// from which action name, controller name and route values are resolved,
/// and the specified additional route values.
/// </summary>
/// <typeparam name="TRedirectController">Controller, from which the action is specified.</typeparam>
/// <param name="routeName">The name of the route to use for generating the URL.</param>
/// <param name="action">
/// The <see cref="Expression{TDelegate}"/>, from which action name,
/// controller name and route values are resolved.
/// </param>
/// <param name="routeValues">Additional route data to use for generating the URL.</param>
/// <returns>The created <see cref="RedirectToRouteResult"/> for the response.</returns>
public static RedirectToRouteResult RedirectToRoutePermanent <TRedirectController>(
this Controller controller,
string routeName,
Expression <Action <TRedirectController> > action,
object routeValues)
{
var expressionRouteValues = ExpressionRouteHelper.Resolve(action, routeValues, addControllerAndActionToRouteValues: true);
return(controller.RedirectToRoutePermanent(
routeName,
expressionRouteValues.RouteValues));
}
/// <summary>
/// Redirects to the specified action with <see cref="RedirectToActionResult.Permanent"/> set to true by
/// using <see cref="Expression{TDelegate}"/> for an action method,
/// from which action name, controller name and route values are resolved,
/// and the specified additional route values.
/// </summary>
/// <typeparam name="TRedirectController">Controller, from which the action is specified.</typeparam>
/// <param name="action">
/// The <see cref="Expression{TDelegate}"/>, from which action name,
/// controller name and route values are resolved.
/// </param>
/// <param name="routeValues">Additional route data to use for generating the URL.</param>
/// <returns>The created <see cref="RedirectToActionResult"/> for the response.</returns>
public static RedirectToActionResult RedirectToActionPermanent <TRedirectController>(
this Controller controller,
Expression <Action <TRedirectController> > action,
object routeValues)
{
var expressionRouteValues = ExpressionRouteHelper.Resolve(action, routeValues);
return(controller.RedirectToActionPermanent(
expressionRouteValues.Action,
expressionRouteValues.Controller,
routeValues));
}
public void Resolve_CustomConventions_CustomConventionsAreResolved()
{
// Act
var result = ExpressionRouteHelper.Resolve <ConventionsController>(c => c.ConventionsAction(1));
// Assert
Assert.Equal("ChangedController", result.Controller);
Assert.Equal("ChangedAction", result.Action);
Assert.Equal(1, result.RouteValues.Count);
Assert.True(result.RouteValues.ContainsKey("ChangedParameter"));
Assert.Equal(1, result.RouteValues["ChangedParameter"]);
}
private static string Action <TController>(
this IUrlHelper helper,
Expression <Action <TController> > action,
UrlActionContext actionContext)
{
var expressionRouteValues = ExpressionRouteHelper.Resolve(action, actionContext.Values);
actionContext.Controller = expressionRouteValues.Controller;
actionContext.Action = expressionRouteValues.Action;
actionContext.Values = expressionRouteValues.RouteValues;
return(helper.Action(actionContext));
}
/// <summary>
/// Creates a <see cref="CreatedAtActionResult"/> object that produces a Created (201) response
/// by using <see cref="Expression{TDelegate}"/> for selecting the action.
/// </summary>
/// <typeparam name="TRedirectController">Controller, from which the action is specified.</typeparam>
/// <param name="action">
/// The <see cref="Expression{TDelegate}"/>, from which action name,
/// controller name and route values are resolved.
/// </param>
/// <param name="routeValues">Additional route data to use for generating the URL.</param>
/// <param name="value">The content value to format in the entity body.</param>
/// <returns>The created <see cref="CreatedAtActionResult"/> for the response.</returns>
public static CreatedAtActionResult CreatedAtAction <TRedirectController>(
this Controller controller,
Expression <Action <TRedirectController> > action,
object routeValues,
object value)
{
var expressionRouteValues = ExpressionRouteHelper.Resolve(action, routeValues);
return(controller.CreatedAtAction(
expressionRouteValues.Action,
expressionRouteValues.Controller,
routeValues,
value));
}
/// <summary>
/// Creates a <see cref="CreatedAtRouteResult"/> object that produces a Created (201) response.
/// </summary>
/// <typeparam name="TRedirectController">Controller, from which the action is specified.</typeparam>
/// <param name="routeName">The name of the route to use for generating the URL.</param>
/// <param name="action">
/// The <see cref="Expression{TDelegate}"/>, from which action name,
/// controller name and route values are resolved.
/// </param>
/// <param name="routeValues">Additional route data to use for generating the URL.</param>
/// <param name="value">The content value to format in the entity body.</param>
/// <returns>The created <see cref="CreatedAtRouteResult"/> for the response</returns>
public static CreatedAtRouteResult CreatedAtRoute <TRedirectController>(
this Controller controller,
string routeName,
Expression <Action <TRedirectController> > action,
object routeValues,
object value)
{
var expressionRouteValues = ExpressionRouteHelper.Resolve(action, routeValues, addControllerAndActionToRouteValues: true);
return(controller.CreatedAtRoute(
routeName,
expressionRouteValues.RouteValues,
value));
}
public void Resolve_InAreaController_ControllerActionNameAndAreaAreResolved()
{
// Act
var result = ExpressionRouteHelper.Resolve <InAreaController>(c => c.Action(1));
// Assert
Assert.Equal("InArea", result.Controller);
Assert.Equal("Action", result.Action);
Assert.Equal(2, result.RouteValues.Count);
Assert.True(result.RouteValues.ContainsKey("id"));
Assert.Equal(1, result.RouteValues["id"]);
Assert.True(result.RouteValues.ContainsKey("area"));
Assert.Equal("MyArea", result.RouteValues["area"]);
}
public void Resolve_ActionWithCustomRouteConstraints_RouteConstraintsAreResolved()
{
// Act
var result = ExpressionRouteHelper.Resolve <RouteConstraintController>(c => c.Action(1, 2));
// Assert
Assert.Equal("CustomController", result.Controller);
Assert.Equal("CustomAction", result.Action);
Assert.Equal(3, result.RouteValues.Count);
Assert.True(result.RouteValues.ContainsKey("id"));
Assert.Equal("5", result.RouteValues["id"]);
Assert.True(result.RouteValues.ContainsKey("key"));
Assert.Equal("value", result.RouteValues["key"]);
Assert.True(result.RouteValues.ContainsKey("anotherId"));
Assert.Equal(2, result.RouteValues["anotherId"]);
}
public void Resolve_ControllerAndActionWithPrimitiveParameters_ControllerActionNameAndParametersAreResolved(
Expression <Action <NormalController> > action, string controllerName, string actionName, IDictionary <string, object> routeValues)
{
// Act
var result = ExpressionRouteHelper.Resolve(action);
// Assert
Assert.Equal(controllerName, result.Controller);
Assert.Equal(actionName, result.Action);
Assert.Equal(routeValues.Count, result.RouteValues.Count);
foreach (var routeValue in routeValues)
{
Assert.True(result.RouteValues.ContainsKey(routeValue.Key));
Assert.Equal(routeValue.Value, result.RouteValues[routeValue.Key]);
}
}
public void Resolve_ControllerAndActionWithObjectParameters_ControllerActionNameAndParametersAreResolved()
{
// Act
var result = ExpressionRouteHelper.Resolve <NormalController>(c => c.ActionWithMultipleParameters(1, "string", new RequestModel {
Integer = 1, String = "Text"
}));
// Assert
Assert.Equal("Normal", result.Controller);
Assert.Equal("ActionWithMultipleParameters", result.Action);
Assert.Equal(3, result.RouteValues.Count);
Assert.Equal(1, result.RouteValues["id"]);
Assert.Equal("string", result.RouteValues["text"]);
Assert.IsAssignableFrom <RequestModel>(result.RouteValues["model"]);
var model = (RequestModel)result.RouteValues["model"];
Assert.Equal(1, model.Integer);
Assert.Equal("Text", model.String);
}
/// <summary>
/// Allows using typed expression based link generation in ASP.NET Core MVC application.
/// </summary>
public static void UseTypedRouting(this IRouteBuilder routeBuilder)
{
ExpressionRouteHelper.Initialize(routeBuilder.ServiceProvider);
}
