public void BuildRouteValueDictionaryWithNullExpressionThrowsArgumentNullException()
{
Assert.ThrowsArgumentNull(
() => ExpressionHelper.GetRouteValuesFromExpression <TestController>(null),
"action"
);
}
public static string BuildUrlFromExpression <TController>(RequestContext context, RouteCollection routeCollection, Expression <Action <TController> > action) where TController : Controller
{
RouteValueDictionary routeValues = ExpressionHelper.GetRouteValuesFromExpression(action);
VirtualPathData vpd = routeCollection.GetVirtualPathForArea(context, routeValues);
return((vpd == null) ? null : vpd.VirtualPath);
}
private static string GetQueryStringArguments <TController>(HtmlHelper helper,
Expression <Action <TController> > action, string linkText, string controllerUrlName, string actionName)
where TController : Controller
{
RouteValueDictionary routingValues = ExpressionHelper.GetRouteValuesFromExpression <TController>(action);
string routePortion = helper.RouteCollection.GetVirtualPath(helper.ViewContext.RequestContext, routingValues).VirtualPath;
string controllerAndActionUrlPortion = controllerUrlName + "/" + actionName;
// If there's a "?" in the querystring, then take everything from the "?"
// and onwards as the parameters to the URL
if (routePortion.IndexOf('?') > -1)
{
return(routePortion.Substring(routePortion.IndexOf('?')));
}
// If the controllerAndActionUrlPortion + "/" is found in the querystring, then it implies
// that there are parameters, so take everything after the controllerAndActionUrlPortion,
// including the "/"
else if (routePortion.IndexOf(controllerAndActionUrlPortion + "/") > -1)
{
return(routePortion.Substring(routePortion.IndexOf(controllerAndActionUrlPortion + "/") +
controllerAndActionUrlPortion.Length));
}
else
{
return("");
}
}
public static string BuildUrlFromExpression <TController>(RequestContext context, RouteCollection routeCollection, Expression <Action <TController> > action) where TController : Controller
{
var routeInfo = ExpressionHelper.GetRouteInfoFromExpression(routeCollection, action);
VirtualPathData vpd = routeCollection.GetVirtualPathForArea(context, routeInfo.Key, routeInfo.Value);
return((vpd == null) ? null : vpd.VirtualPath);
}
protected void AssertRedirectedTo <TController>(ActionResult actionResult,
Expression <Action <TController> > action)
where TController : Controller
{
RouteValueDictionary routeValues = ExpressionHelper.GetRouteValuesFromExpression(action);
AssertRedirectedTo(actionResult, routeValues);
}
public MvcHtmlString RenderAction <TController>(Expression <Action <TController> > action) where TController : Controller
{
var helper = GetHtmlHelper();
var routeValues = ExpressionHelper.GetRouteValuesFromExpression(action);
return(helper.Action((string)routeValues["action"], (string)routeValues["controller"], routeValues));
}
public void BuildRouteValueDictionaryWithoutControllerSuffixThrowsInvalidOperationException()
{
// Arrange
Expression <Action <TestControllerNot> > index = (c => c.Index(123));
// Act & Assert
ExceptionHelper.ExpectArgumentException(
() => ExpressionHelper.GetRouteValuesFromExpression(index),
"Controller name must end in 'Controller'." + Environment.NewLine + "Parameter name: action");
}
public void BuildRouteValueDictionary_TargetsNonActionMethod_Throws()
{
// Arrange
Expression <Action <TestController> > expr = (c => c.NotAnAction());
// Act & assert
Assert.Throws <InvalidOperationException>(
delegate { ExpressionHelper.GetRouteValuesFromExpression(expr); },
@"The method 'NotAnAction' is marked [NonAction] and cannot be called directly.");
}
public void BuildRouteValueDictionary_TargetsAsynchronousCompletedMethod_Throws()
{
// Arrange
Expression <Action <TestAsyncController> > expr = (c => c.AsynchronousCompleted());
// Act & assert
Assert.Throws <InvalidOperationException>(
delegate { ExpressionHelper.GetRouteValuesFromExpression(expr); },
@"The method 'AsynchronousCompleted' is an asynchronous completion method and cannot be called directly.");
}
public void BuildRouteValueDictionaryWithControllerBaseClassThrowsInvalidOperationException()
{
// Arrange
Expression <Action <Controller> > index = (c => c.Dispose());
// Act & Assert
ExceptionHelper.ExpectArgumentException(
() => ExpressionHelper.GetRouteValuesFromExpression(index),
"Cannot route to class named 'Controller'." + Environment.NewLine + "Parameter name: action");
}
public void BuildRouteValueDictionaryWithNonMethodExpressionThrowsInvalidOperationException()
{
// Arrange
Expression <Action <TestController> > expression = c => new TestController();
// Act & Assert
ExceptionHelper.ExpectArgumentException(
() => ExpressionHelper.GetRouteValuesFromExpression <TestController>(expression),
"Expression must be a method call." + Environment.NewLine + "Parameter name: action");
}
public void GetInputNameFromPropertyExpressionReturnsPropertyName()
{
// Arrange
Expression <Func <TestModel, int> > expression = m => m.IntProperty;
// Act
string name = ExpressionHelper.GetInputName(expression);
// Assert
Assert.AreEqual("IntProperty", name);
}
public void GetInputNameFromPropertyWithTwoMethodCallExpressionReturnsPropertyName()
{
// Arrange
Expression <Func <TestModel, string> > expression = m => m.IntProperty.ToString().ToUpper();
// Act
string name = ExpressionHelper.GetInputName(expression);
// Assert
Assert.AreEqual("IntProperty", name);
}
public void GetInputNameFromExpressionWithTwoPropertiesUsesWholeExpression()
{
// Arrange
Expression <Func <TestModel, int> > expression = m => m.StringProperty.Length;
// Act
string name = ExpressionHelper.GetInputName(expression);
// Assert
Assert.AreEqual("StringProperty.Length", name);
}
public static string Action <TController>(this UrlHelper url, Expression <Action <TController> > action) where TController : Controller
{
if (url == null)
{
throw new ArgumentNullException("url");
}
RouteValueDictionary routeValues = ExpressionHelper.GetRouteValuesFromExpression(action);
return(url.RouteUrl(routeValues));
}
public static RedirectToRouteResult RedirectToAction <TController>(this Controller controller, Expression <Action <TController> > action) where TController : Controller
{
if (controller == null)
{
throw new ArgumentNullException("controller");
}
var routeInfo = ExpressionHelper.GetRouteInfoFromExpression(RouteTable.Routes, action);
return(new RedirectToRouteResult(routeInfo.Key, routeInfo.Value));
}
public static RedirectToRouteResult RedirectToAction <TController>(this Controller controller, Expression <Action <TController> > action) where TController : Controller
{
if (controller == null)
{
throw new ArgumentNullException("controller");
}
RouteValueDictionary routeValues = ExpressionHelper.GetRouteValuesFromExpression(action);
return(new RedirectToRouteResult(routeValues));
}
public void BuildRouteValueDictionaryAddsControllerNameToDictionary()
{
// Arrange
Expression <Action <TestController> > index = (c => c.Index(123));
// Act
RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(index);
// Assert
Assert.AreEqual("Test", rvd["Controller"]);
}
public void BuildRouteValueDictionaryFromExpressionReturnsCorrectDictionary()
{
// Arrange
Expression <Action <TestController> > index = (c => c.Index(123));
// Act
RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(index);
// Assert
Assert.AreEqual("Test", rvd["Controller"]);
Assert.AreEqual("Index", rvd["Action"]);
Assert.AreEqual(123, rvd["page"]);
}
public void BuildRouteValueDictionary_TargetsSynchronousMethodOnAsyncController_ReturnsOriginalName()
{
// Arrange
Expression <Action <TestAsyncController> > expr = (c => c.Synchronous());
// Act
RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(expr);
// Assert
Assert.AreEqual("Synchronous", rvd["action"]);
Assert.AreEqual("TestAsync", rvd["controller"]);
Assert.IsFalse(rvd.ContainsKey("area"));
}
public void BuildRouteValueDictionaryFromNonConstantExpressionReturnsCorrectDictionary()
{
// Arrange
Expression <Action <TestController> > index = (c => c.About(Foo));
// Act
RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(index);
// Assert
Assert.AreEqual("Test", rvd["Controller"]);
Assert.AreEqual("About", rvd["Action"]);
Assert.AreEqual("FooValue", rvd["s"]);
}
public void BuildRouteValueDictionary_TargetsAsynchronousAsyncMethod_StripsSuffix()
{
// Arrange
Expression <Action <TestAsyncController> > expr = (c => c.AsynchronousAsync());
// Act
RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(expr);
// Assert
Assert.AreEqual("Asynchronous", rvd["action"]);
Assert.AreEqual("TestAsync", rvd["controller"]);
Assert.IsFalse(rvd.ContainsKey("area"));
}
public void BuildRouteValueDictionary_TargetsRenamedMethod_UsesNewName()
{
// Arrange
Expression <Action <TestController> > expr = (c => c.Renamed());
// Act
RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(expr);
// Assert
Assert.AreEqual("NewName", rvd["action"]);
Assert.AreEqual("Test", rvd["controller"]);
Assert.IsFalse(rvd.ContainsKey("area"));
}
private static RouteValueDictionary PrepareRvd <TController>(HtmlHelper helper, Expression <Action <TController> > action) where TController : Controller
{
RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(action);
foreach (var entry in helper.ViewContext.RouteData.Values)
{
if (!rvd.ContainsKey(entry.Key))
{
rvd.Add(entry.Key, entry.Value);
}
}
return(rvd);
}
public void BuildRouteValueDictionary_TargetsControllerWithAreaAttribute_AddsAreaName()
{
// Arrange
Expression <Action <ControllerWithAreaController> > expr = c => c.Index();
// Act
RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(expr);
// Assert
Assert.AreEqual("Index", rvd["action"]);
Assert.AreEqual("ControllerWithArea", rvd["controller"]);
Assert.AreEqual("the area name", rvd["area"]);
}
public static void RenderAction <TController>(this HtmlHelper helper, Expression <Action <TController> > action) where TController : Controller
{
RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(action);
foreach (var entry in helper.ViewContext.RouteData.Values)
{
if (!rvd.ContainsKey(entry.Key))
{
rvd.Add(entry.Key, entry.Value);
}
}
RenderRoute(helper, rvd);
}
public static MvcHtmlString ActionLink <TController>(
this HtmlHelper helper,
Expression <Action <TController> > action,
string linkText,
object htmlAttributes
) where TController : Controller
{
RouteValueDictionary routingValues = ExpressionHelper.GetRouteValuesFromExpression(
action
);
return(helper.RouteLink(
linkText,
routingValues,
HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes)
));
}
// todo: Move to a Seleno.Mvc project if established
public TPage To <TController, TPage>(Expression <Action <TController> > action, IDictionary <string, object> routeValues = null)
where TController : Controller
where TPage : UiComponent, new()
{
var requestContext = new RequestContext(FakeHttpContext.Root(), new RouteData());
var actionRouteValues = ExpressionHelper.GetRouteValuesFromExpression(action);
if (routeValues != null)
{
foreach (var v in routeValues)
{
actionRouteValues[v.Key] = v.Value;
}
}
var urlHelper = new UrlHelper(requestContext, _routeCollection);
var relativeUrl = urlHelper.RouteUrl(new RouteValueDictionary(actionRouteValues));
return(To <TPage>(relativeUrl));
}
public MenuItem Action <TController>(Expression <Action <TController> > expression) where TController : System.Web.Mvc.Controller
{
var valuesFromExpression = ExpressionHelper.GetRouteValuesFromExpression(expression);
this.ControllerName = (string)valuesFromExpression["Controller"];
this.ActionName = (string)valuesFromExpression["Action"];
this.Area = (string)valuesFromExpression["Area"];
var call = ((MethodCallExpression)expression.Body).Method;
var allowAnonymousAttribute = (AllowAnonymousAttribute)call.GetCustomAttributes(typeof(AllowAnonymousAttribute), true).FirstOrDefault();
this.AllowAnonymous = allowAnonymousAttribute != null;
if (!this.AllowAnonymous)
{
var authorizeAttributes = call.GetCustomAttributes(typeof(AuthorizeAttribute), true).Cast <AuthorizeAttribute>().ToArray();
if (authorizeAttributes.Length == 0)
{
if (call.DeclaringType != null)
{
authorizeAttributes = call.DeclaringType.GetCustomAttributes(typeof(AuthorizeAttribute), true).Cast <AuthorizeAttribute>().ToArray();
}
if (authorizeAttributes.Length == 0)
{
authorizeAttributes = GlobalFilters.Filters.Where(filter => filter.Instance is AuthorizeAttribute).Select(filter => filter.Instance).Cast <AuthorizeAttribute>().ToArray();
}
}
if (authorizeAttributes.Length == 0)
{
this.AllowAnonymous = true;
}
else
{
var roles = new List <string>();
foreach (var authorizeAttribute in authorizeAttributes)
{
if (!string.IsNullOrWhiteSpace(authorizeAttribute.Roles))
{
var newRoles = authorizeAttribute.Roles.Split(',');
roles.AddRange(newRoles);
}
}
this.Roles = roles.Select(role => role.Trim()).ToArray();
}
}
if (!this.IsDivider && !this.IsHeader && string.IsNullOrEmpty(this.Text))
{
if (this.ActionName.ToLowerInvariant().Equals("index"))
{
this.Text = this.ControllerName;
}
else if (this.ControllerName.ToLowerInvariant().Equals("home"))
{
this.Text = this.ActionName;
}
else
{
this.Text = this.ActionName + " " + this.ControllerName;
}
}
return(this);
}
protected string GetUrl <TController>(Expression <Action <TController> > action) where TController : Controller
{
return(GetUrl(ExpressionHelper.GetRouteValuesFromExpression(action)));
}
