public void CreateRoute_IfBuilderContraintsIsNotNullAndConstraintsPropertyIsNull_UsesBuilderConstraints()
{
// Arrange
HttpRouteValueDictionary existingConstraints = new HttpRouteValueDictionary();
Mock <RouteProviderAttribute> productMock = CreateProductUnderTestMock();
productMock.SetupGet(p => p.Constraints).Returns((HttpRouteValueDictionary)null);
IDirectRouteProvider product = productMock.Object;
HttpRouteEntry expectedEntry = CreateEntry();
HttpRouteValueDictionary constraints = null;
DirectRouteBuilder builder = null;
builder = CreateBuilder(() =>
{
constraints = builder.Constraints;
return(null);
});
builder.Constraints = existingConstraints;
DirectRouteProviderContext context = CreateContext((i) => builder);
// Act
HttpRouteEntry ignore = product.CreateRoute(context);
// Assert
Assert.Same(existingConstraints, constraints);
}
public void CompareTo_Returns0_ForEquivalentRoutes()
{
HttpRouteEntry x = CreateRouteEntry("Employees/{id}");
HttpRouteEntry y = CreateRouteEntry("Employees/{id}");
Assert.Equal(0, x.CompareTo(y));
}
public decimal GetPrecedence(IDictionary <string, object> constraints)
{
// Each precedence digit corresponds to one decimal place. For example, 3 segments with precedences 2, 1,
// and 4 results in a combined precedence of 2.14 (decimal).
IList <PathContentSegment> segments = PathSegments.OfType <PathContentSegment>().ToArray();
decimal precedence = 0;
uint divisor = 1; // The first digit occupies the one's place.
for (int i = 0; i < segments.Count; i++)
{
PathContentSegment segment = segments[i];
int digit = HttpRouteEntry.GetPrecedenceDigit(segment, constraints);
Contract.Assert(digit >= 0 && digit < 10);
precedence = precedence + Decimal.Divide(digit, divisor);
// The next digit occupies the subsequent place (always after the decimal point and growing to the
// right).
divisor *= 10;
}
return(precedence);
}
public void CompareTo_ComparesCorrectly(string earlier, string later)
{
HttpRouteEntry x = CreateRouteEntry(earlier);
HttpRouteEntry y = CreateRouteEntry(later);
Assert.True(x.CompareTo(y) < 0);
Assert.True(y.CompareTo(x) > 0);
}
private static void AddRouteEntries(HttpSubRouteCollection collector, string prefix,
IReadOnlyCollection <IDirectRouteProvider> providers, IEnumerable <ReflectedHttpActionDescriptor> actions,
IInlineConstraintResolver constraintResolver)
{
foreach (IDirectRouteProvider routeProvider in providers)
{
HttpRouteEntry entry = CreateRouteEntry(prefix, routeProvider, actions,
constraintResolver);
collector.Add(entry);
}
}
public void CompareTo_RespectsOrder(int prefixOrder1, int prefixOrder2, int order1, int order2, int expectedValue)
{
HttpRouteEntry x = new HttpRouteEntry()
{
PrefixOrder = prefixOrder1, Order = order1
};
HttpRouteEntry y = new HttpRouteEntry()
{
PrefixOrder = prefixOrder2, Order = order2
};
Assert.Equal(expectedValue, x.CompareTo(y));
}
private static HttpRouteEntry CreateRouteEntry(string routePrefix, IDirectRouteProvider provider,
IEnumerable <ReflectedHttpActionDescriptor> actions, IInlineConstraintResolver constraintResolver)
{
Contract.Assert(provider != null);
DirectRouteProviderContext context = new DirectRouteProviderContext(routePrefix, actions,
constraintResolver);
HttpRouteEntry entry = provider.CreateRoute(context);
if (entry == null)
{
throw Error.InvalidOperation(SRResources.TypeMethodMustNotReturnNull,
typeof(IDirectRouteProvider).Name, "CreateRoute");
}
return(entry);
}
public void CreateRoute_IfBuilderContraintsIsNotNull_AddsConstraintsFromPropertyWhenBuilding()
{
// Arrange
HttpRouteValueDictionary existingConstraints = new HttpRouteValueDictionary();
string existingConstraintKey = "ExistingContraintKey";
object existingConstraintValue = "ExistingContraint";
existingConstraints.Add(existingConstraintKey, existingConstraintValue);
HttpRouteValueDictionary additionalConstraints = new HttpRouteValueDictionary();
string additionalConstraintKey = "NewConstraintKey";
string additionalConstraintValue = "NewConstraint";
additionalConstraints.Add(additionalConstraintKey, additionalConstraintValue);
Mock <RouteProviderAttribute> productMock = CreateProductUnderTestMock();
productMock.SetupGet(p => p.Constraints).Returns(additionalConstraints);
IDirectRouteProvider product = productMock.Object;
HttpRouteEntry expectedEntry = CreateEntry();
HttpRouteValueDictionary constraints = null;
DirectRouteBuilder builder = null;
builder = CreateBuilder(() =>
{
constraints = builder.Constraints;
return(null);
});
builder.Constraints = existingConstraints;
DirectRouteProviderContext context = CreateContext((i) => builder);
// Act
HttpRouteEntry ignore = product.CreateRoute(context);
// Assert
Assert.Same(existingConstraints, constraints);
Assert.Equal(2, constraints.Count);
Assert.True(constraints.ContainsKey(existingConstraintKey));
Assert.Same(existingConstraintValue, constraints[existingConstraintKey]);
Assert.True(constraints.ContainsKey(additionalConstraintKey));
Assert.Same(additionalConstraintValue, constraints[additionalConstraintKey]);
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpRoute" /> class.
/// </summary>
/// <param name="routeTemplate">The route template.</param>
/// <param name="order">The subroute order.</param>
/// <param name="defaults">The default values.</param>
/// <param name="constraints">The route constraints.</param>
/// <param name="actions">The actions that are reachable via this route.</param>
public static HttpRoute BuildDirectRoute(
string routeTemplate,
int order,
HttpRouteValueDictionary defaults,
HttpRouteValueDictionary constraints,
IEnumerable <ReflectedHttpActionDescriptor> actions)
{
HttpRoute route = new HttpRoute(routeTemplate, defaults: defaults, constraints: constraints, dataTokens: null, handler: null);
if (actions != null)
{
route.DataTokens[RouteKeys.OrderDataTokenKey] = order;
route.DataTokens[RouteKeys.PrecedenceDataTokenKey] = HttpRouteEntry.GetPrecedence(route.ParsedRoute, constraints);
route.DataTokens[RouteKeys.ActionsDataTokenKey] = actions.AsArray();
}
return(route);
}
public void CreateRoute_DelegatesToContextCreateBuilderBuild()
{
// Arrange
string expectedTemplate = "RouteTemplate";
IDirectRouteProvider product = CreateProductUnderTest(expectedTemplate);
HttpRouteEntry expectedEntry = CreateEntry();
DirectRouteBuilder builder = CreateBuilder(() => expectedEntry);
DirectRouteProviderContext context = CreateContext((template) =>
template == expectedTemplate ? builder : new DirectRouteBuilder(new ReflectedHttpActionDescriptor[0]));
// Act
HttpRouteEntry entry = product.CreateRoute(context);
// Assert
Assert.Same(expectedEntry, entry);
}
public void CreateRoute_UsesNamePropertyWhenBuilding()
{
// Arrange
string expectedName = "RouteName";
RouteProviderAttribute product = CreateProductUnderTest();
product.Name = expectedName;
string name = null;
DirectRouteBuilder builder = null;
builder = CreateBuilder(() =>
{
name = builder.Name;
return(null);
});
DirectRouteProviderContext context = CreateContext((i) => builder);
// Act
HttpRouteEntry ignore = product.CreateRoute(context);
// Assert
Assert.Same(expectedName, name);
}
public void CreateRoute_UsesOrderPropertyWhenBuilding()
{
// Arrange
int expectedOrder = 123;
RouteProviderAttribute product = CreateProductUnderTest();
product.Order = expectedOrder;
int order = 0;
DirectRouteBuilder builder = null;
builder = CreateBuilder(() =>
{
order = builder.Order;
return(null);
});
DirectRouteProviderContext context = CreateContext((i) => builder);
// Act
HttpRouteEntry ignore = product.CreateRoute(context);
// Assert
Assert.Equal(expectedOrder, order);
}
