public void MapMvcAttributeRoutes_WithControllerRoute_ExcludesAttributeRoute()
{
// Arrange
var controllerType = typeof(MixedRoutingController);
// Act
var entries = AttributeRoutingMapper.GetAttributeRoutes(controllerType);
// Assert
var controllerEntry = Assert.Single(
entries,
r => !r.Route.Defaults.ContainsKey("action")
);
Assert.Same(
controllerType,
controllerEntry.Route.GetTargetControllerDescriptor().ControllerType
);
var actionMethods = controllerEntry.Route.GetTargetActionDescriptors().ToArray();
Assert.Single(actionMethods);
Assert.Single(actionMethods, a => a.ActionName == "GoodAction");
var actionEntry = Assert.Single(entries, r => r.Route.Defaults.ContainsKey("action"));
Assert.Equal(
"DirectRouteAction",
Assert.Single(actionEntry.Route.GetTargetActionDescriptors()).ActionName
);
}
public void MapMvcAttributeRoutes_WithControllerRoute()
{
// Arrange
var controllerType = typeof(AnotherController);
// Act
var entries = AttributeRoutingMapper.GetAttributeRoutes(controllerType);
// Assert
var controllerEntry = Assert.Single(
entries,
r => !r.Route.Defaults.ContainsKey("action")
);
Assert.Same(
controllerType,
controllerEntry.Route.GetTargetControllerDescriptor().ControllerType
);
var actionMethods = controllerEntry.Route.GetTargetActionDescriptors().ToArray();
Assert.Equal(2, actionMethods.Length);
Assert.Single(actionMethods, a => a.ActionName == "RegularAction");
Assert.Single(actionMethods, a => a.ActionName == "AnotherAction");
}
/// <summary>
/// Maps the attribute-defined routes for the application.
/// </summary>
/// <param name="routes"></param>
/// <param name="controllerTypes">The controller types to scan.</param>
/// <param name="constraintResolver">
/// The <see cref="IInlineConstraintResolver"/> to use for resolving inline constraints in route templates.
/// </param>
public static void MapAttributeRoutes(RouteCollection routes, IEnumerable <Type> controllerTypes,
IInlineConstraintResolver constraintResolver)
{
AttributeRoutingMapper mapper = new AttributeRoutingMapper(new RouteBuilder2(constraintResolver));
SubRouteCollection subRoutes = new SubRouteCollection();
mapper.AddRouteEntries(subRoutes, controllerTypes);
IReadOnlyCollection <RouteEntry> entries = subRoutes.Entries;
if (entries.Count > 0)
{
RouteCollectionRoute aggregrateRoute = new RouteCollectionRoute(subRoutes);
routes.Add(aggregrateRoute);
// This sort is here to enforce a static ordering for link generation using these routes.
// We don't apply dynamic criteria like ActionSelectors on link generation, but we can use the static
// ones.
RouteEntry[] sorted = entries
.OrderBy(r => r.Route.GetOrder())
.ThenBy(r => r.Route.GetPrecedence())
.ToArray();
AddGenerationHooksForSubRoutes(routes, sorted);
}
}
/// <summary>
/// Maps the attribute-defined routes for the application.
/// </summary>
/// <param name="routes"></param>
/// <param name="controllerTypes">The controller types to scan.</param>
/// <param name="constraintResolver">The <see cref="IInlineConstraintResolver"/> to use for resolving inline constraints in route templates.</param>
public static void MapMvcAttributeRoutes(this RouteCollection routes, IEnumerable<Type> controllerTypes, IInlineConstraintResolver constraintResolver)
{
List<RouteEntry> routeEntries = new AttributeRoutingMapper(new RouteBuilder(constraintResolver)).MapMvcAttributeRoutes(controllerTypes);
foreach (var routeEntry in routeEntries)
{
routes.Add(routeEntry.Name, routeEntry.Route);
}
}
public void MapMvcAttributeRoutes_DoesNotTryToInferRouteNames()
{
var controllerType = typeof(MyController);
var routeEntries = AttributeRoutingMapper.GetAttributeRoutes(controllerType);
var routeEntry = Assert.Single(routeEntries);
Assert.Null(routeEntry.Name);
}
public void MapMvcAttributeRoutes_RespectsActionNameAttribute()
{
var controllerDescriptor = new ReflectedAsyncControllerDescriptor(typeof(MyController));
var mapper = new AttributeRoutingMapper(new RouteBuilder());
var routeEntries = mapper.MapMvcAttributeRoutes(controllerDescriptor);
var routeEntry = Assert.Single(routeEntries);
Assert.Equal("ActionName", routeEntry.Route.Defaults["action"]);
}
public void MapMvcAttributeRoutes_DoesNotTryToInferRouteNames()
{
var controllerDescriptor = new ReflectedAsyncControllerDescriptor(typeof(MyController));
var mapper = new AttributeRoutingMapper(new RouteBuilder());
var routeEntries = mapper.MapMvcAttributeRoutes(controllerDescriptor);
var routeEntry = Assert.Single(routeEntries);
Assert.Null(routeEntry.Name);
}
public void MapMvcAttributeRoutes_DoesNotTryToInferRouteNames()
{
var controllerType = typeof(MyController);
var routeEntries = AttributeRoutingMapper.GetAttributeRoutes(controllerType);
var routeEntry = Assert.Single(routeEntries);
Assert.True(routeEntry.Name == null || routeEntry.Name.StartsWith("MethodInfo!", StringComparison.Ordinal));
}
public void MapMvcAttributeRoutes_RespectsActionNameAttribute()
{
var controllerDescriptor = new ReflectedAsyncControllerDescriptor(typeof(MyController));
var mapper = new AttributeRoutingMapper(new RouteBuilder());
var routeEntries = mapper.MapMvcAttributeRoutes(controllerDescriptor);
var routeEntry = Assert.Single(routeEntries);
Assert.Equal("ActionName", routeEntry.Route.Defaults["action"]);
}
public void MapMvcAttributeRoutes_DoesNotTryToInferRouteNames()
{
var controllerDescriptor = new ReflectedAsyncControllerDescriptor(typeof(MyController));
var mapper = new AttributeRoutingMapper(new RouteBuilder());
var routeEntries = mapper.MapMvcAttributeRoutes(controllerDescriptor);
var routeEntry = Assert.Single(routeEntries);
Assert.Null(routeEntry.Name);
}
public void MapMvcAttributeRoutes_WithControllerRoute_AndNoReachableActions()
{
// Arrange
var controllerType = typeof(NoActionsController);
// Act
var entries = AttributeRoutingMapper.GetAttributeRoutes(controllerType);
// Assert
Assert.Empty(entries);
}
public void MapMvcAttributeRoutes_WithControllerRoute_AndNoReachableActions()
{
// Arrange
var controllerDescriptor = new ReflectedAsyncControllerDescriptor(typeof(NoActionsController));
var mapper = new AttributeRoutingMapper(new RouteBuilder2());
// Act
var entries = mapper.MapMvcAttributeRoutes(controllerDescriptor);
// Assert
Assert.Empty(entries);
}
public void MapMvcAttributeRoutes_RespectsActionNameAttribute()
{
// Arrange
var controllerType = typeof(MyController);
// Act
var routeEntries = AttributeRoutingMapper.GetAttributeRoutes(controllerType);
// Assert
var routeEntry = Assert.Single(routeEntries);
Assert.Equal("ActionName", routeEntry.Route.Defaults["action"]);
}
public void MapMvcAttributeRoutes_ValidatesConstraints()
{
// Arrange
var controllerType = typeof(InvalidConstraintController);
string expectedMessage =
"The constraint entry 'custom' on the route with route template 'invalidconstraint/{action}' " +
"must have a string value or be of a type which implements 'System.Web.Routing.IRouteConstraint'.";
// Act & Assert
Assert.Throws <InvalidOperationException>(() => AttributeRoutingMapper.GetAttributeRoutes(controllerType), expectedMessage);
}
public void MapMvcAttributeRoutes_SetsTargetIsAction()
{
// Arrange
var controllerType = typeof(MixedRoutingController);
// Act
var entries = AttributeRoutingMapper.GetAttributeRoutes(controllerType);
// Assert
var controllerEntry = Assert.Single(entries, r => !r.Route.Defaults.ContainsKey("action"));
Assert.False(controllerEntry.Route.GetTargetIsAction());
var actionEntry = Assert.Single(entries, r => r.Route.Defaults.ContainsKey("action"));
Assert.True(actionEntry.Route.GetTargetIsAction());
}
public void MapMvcAttributeRoutes_WithControllerRoute()
{
// Arrange
var controllerDescriptor = new ReflectedAsyncControllerDescriptor(typeof(AnotherController));
var mapper = new AttributeRoutingMapper(new RouteBuilder2());
// Act
var entries = mapper.MapMvcAttributeRoutes(controllerDescriptor);
// Assert
var controllerEntry = Assert.Single(entries.Where(r => !r.Route.Defaults.ContainsKey("action")));
Assert.Same(controllerDescriptor, controllerEntry.Route.GetTargetControllerDescriptor());
var actionMethods = controllerEntry.Route.GetTargetActionDescriptors().ToArray();
Assert.Equal(2, actionMethods.Length);
Assert.Single(actionMethods, a => a.ActionName == "RegularAction");
Assert.Single(actionMethods, a => a.ActionName == "AnotherAction");
}
