/// <summary>
/// Creates a <see cref="RoutePattern"/> from its string representation along
/// with provided default values and constraints.
/// </summary>
/// <param name="pattern">The route pattern string to parse.</param>
/// <param name="defaults">
/// Additional default values to associated with the route pattern. May be null.
/// The provided object will be converted to key-value pairs using <see cref="RouteValueDictionary"/>
/// and then merged into the parsed route pattern.
/// </param>
/// <param name="constraints">
/// Additional constraints to associated with the route pattern. May be null.
/// The provided object will be converted to key-value pairs using <see cref="RouteValueDictionary"/>
/// and then merged into the parsed route pattern.
/// </param>
/// <returns>The <see cref="RoutePattern"/>.</returns>
public static RoutePattern Parse(string pattern, object defaults, object constraints)
{
if (pattern == null)
{
throw new ArgumentNullException(nameof(pattern));
}
var original = RoutePatternParser.Parse(pattern);
return(Pattern(original.RawText, defaults, constraints, original.PathSegments));
}
/// <summary>
/// Creates a <see cref="RoutePattern"/> from its string representation along
/// with provided default values and parameter policies.
/// </summary>
/// <param name="pattern">The route pattern string to parse.</param>
/// <param name="defaults">
/// Additional default values to associated with the route pattern. May be null.
/// The provided object will be converted to key-value pairs using <see cref="RouteValueDictionary"/>
/// and then merged into the parsed route pattern.
/// </param>
/// <param name="parameterPolicies">
/// Additional parameter policies to associated with the route pattern. May be null.
/// The provided object will be converted to key-value pairs using <see cref="RouteValueDictionary"/>
/// and then merged into the parsed route pattern.
/// Multiple policies can be specified for a key by providing a collection as the value.
/// </param>
/// <param name="requiredValues">
/// Route values that can be substituted for parameters in the route pattern. See remarks on <see cref="RoutePattern.RequiredValues"/>.
/// </param>
/// <returns>The <see cref="RoutePattern"/>.</returns>
public static RoutePattern Parse(string pattern, object?defaults, object?parameterPolicies, object?requiredValues)
{
if (pattern == null)
{
throw new ArgumentNullException(nameof(pattern));
}
var original = RoutePatternParser.Parse(pattern);
return(PatternCore(original.RawText, Wrap(defaults), Wrap(parameterPolicies), Wrap(requiredValues), original.PathSegments));
}
public void Parse_ComplexSegment_OptionalParameter_NotTheLastPart(
string template,
string parameter,
string invalid)
{
// Act and Assert
ExceptionAssert.Throws <RoutePatternException>(
() => RoutePatternParser.Parse(template),
"An optional parameter must be at the end of the segment. In the segment '" + template +
"', optional parameter '" + parameter + "' is followed by '" + invalid + "'.");
}
public void Parse_OptionalParameter()
{
// Arrange
var template = "{p?}";
var expected = Pattern(template, Segment(ParameterPart("p", null, RoutePatternParameterKind.Optional)));
// Act
var actual = RoutePatternParser.Parse(template);
// Assert
Assert.Equal <RoutePattern>(expected, actual, new RoutePatternEqualityComparer());
}
public void ParseRouteParameter_ThrowsIf_ParameterContainsSpecialCharacters(
string template,
string parameterName)
{
// Arrange
var expectedMessage = "The route parameter name '" + parameterName + "' is invalid. Route parameter " +
"names must be non-empty and cannot contain these characters: '{', '}', '/'. The '?' character " +
"marks a parameter as optional, and can occur only at the end of the parameter. The '*' character " +
"marks a parameter as catch-all, and can occur only at the start of the parameter.";
// Act & Assert
ExceptionAssert.Throws <RoutePatternException>(() => RoutePatternParser.Parse(template), expectedMessage);
}
public void Parse_SingleParameter()
{
// Arrange
var template = "{p}";
var expected = Pattern(template, Segment(ParameterPart("p")));
// Act
var actual = RoutePatternParser.Parse(template);
// Assert
Assert.Equal <RoutePattern>(expected, actual, new RoutePatternEqualityComparer());
}
public void Parse_MultipleParameters()
{
// Arrange
var template = "{p1}/{p2}/{*p3}";
var expected = Pattern(
template,
Segment(ParameterPart("p1")),
Segment(ParameterPart("p2")),
Segment(ParameterPart("p3", null, RoutePatternParameterKind.CatchAll)));
// Act
var actual = RoutePatternParser.Parse(template);
// Assert
Assert.Equal <RoutePattern>(expected, actual, new RoutePatternEqualityComparer());
}
public void Parse_MultipleLiterals()
{
// Arrange
var template = "cool/awesome/super";
var expected = Pattern(
template,
Segment(LiteralPart("cool")),
Segment(LiteralPart("awesome")),
Segment(LiteralPart("super")));
// Act
var actual = RoutePatternParser.Parse(template);
// Assert
Assert.Equal <RoutePattern>(expected, actual, new RoutePatternEqualityComparer());
}
public void Parse_ComplexSegment_PL()
{
// Arrange
var template = "{p1}-cool";
var expected = Pattern(
template,
Segment(
ParameterPart("p1"),
LiteralPart("-cool")));
// Act
var actual = RoutePatternParser.Parse(template);
// Assert
Assert.Equal <RoutePattern>(expected, actual, new RoutePatternEqualityComparer());
}
[InlineData(@"{p1:regex(([{{(])\w+)}", @"regex(([{(])\w+)")] // Not balanced {
public void Parse_RegularExpressions(string template, string constraint)
{
// Arrange
var expected = Pattern(
template,
Segment(
ParameterPart(
"p1",
null,
RoutePatternParameterKind.Standard,
Constraint(constraint))));
// Act
var actual = RoutePatternParser.Parse(template);
// Assert
Assert.Equal <RoutePattern>(expected, actual, new RoutePatternEqualityComparer());
}
public void Parse_ComplexSegment_OptionalParameterFollowingPeriod_PeriodAfterSlash()
{
// Arrange
var template = "{p2}/.{p3?}";
var expected = Pattern(
template,
Segment(ParameterPart("p2")),
Segment(
SeparatorPart("."),
ParameterPart("p3", null, RoutePatternParameterKind.Optional)));
// Act
var actual = RoutePatternParser.Parse(template);
// Assert
Assert.Equal <RoutePattern>(expected, actual, new RoutePatternEqualityComparer());
}
public void Parse_ComplexSegment_ParametersFollowingPeriod()
{
// Arrange
var template = "{p1}.{p2}";
var expected = Pattern(
template,
Segment(
ParameterPart("p1"),
LiteralPart("."),
ParameterPart("p2")));
// Act
var actual = RoutePatternParser.Parse(template);
// Assert
Assert.Equal <RoutePattern>(expected, actual, new RoutePatternEqualityComparer());
}
public void InvalidTemplate_CatchAllMarkedOptional()
{
ExceptionAssert.Throws <RoutePatternException>(
() => RoutePatternParser.Parse("{a}/{*b?}"),
"A catch-all parameter cannot be marked optional.");
}
public void InvalidTemplate_CannotContainQuestionMark()
{
ExceptionAssert.Throws <RoutePatternException>(
() => RoutePatternParser.Parse("foor?bar"),
"The literal section 'foor?bar' is invalid. Literal sections cannot contain the '?' character.");
}
public void InvalidTemplate_CannotStartWithTilde()
{
ExceptionAssert.Throws <RoutePatternException>(
() => RoutePatternParser.Parse("~foo"),
"The route template cannot start with a '~' character unless followed by a '/'.");
}
public void InvalidTemplate_WithCatchAllNotAtTheEndThrows()
{
ExceptionAssert.Throws <RoutePatternException>(
() => RoutePatternParser.Parse("foo/{p1}/{*p2}/{p3}"),
"A catch-all parameter can only appear as the last segment of the route template.");
}
public void InvalidTemplate_InvalidParameterNameWithOpenBracketThrows()
{
ExceptionAssert.Throws <RoutePatternException>(
() => RoutePatternParser.Parse("{a}/{a{aa}/{z}"),
"In a route parameter, '{' and '}' must be escaped with '{{' and '}}'.");
}
public void InvalidTemplate_SameParameterTwiceAndOneCatchAllThrows()
{
ExceptionAssert.Throws <RoutePatternException>(
() => RoutePatternParser.Parse("{aaa}/{*AAA}"),
"The route parameter name 'AAA' appears more than one time in the route template.");
}
public void InvalidTemplate_CannotHaveMoreThanOneCatchAll()
{
ExceptionAssert.Throws <RoutePatternException>(
() => RoutePatternParser.Parse("{*p1}/{*p2}"),
"A catch-all parameter can only appear as the last segment of the route template.");
}
public void InvalidTemplate_WithRepeatedParameter()
{
var ex = ExceptionAssert.Throws <RoutePatternException>(
() => RoutePatternParser.Parse("{Controller}.mvc/{id}/{controller}"),
"The route parameter name 'controller' appears more than one time in the route template.");
}