private static RoutingContext CreateRoutingContext(string virtualPathRoot, HttpRequestMessage request)
{
// Note: we don't validate host/port as this is expected to be done at the host level
string requestPath = "/" + request.RequestUri.GetComponents(UriComponents.Path, UriFormat.Unescaped);
// This code is optimized for the common path being an exact case match on the virtual path string.
// An Ordinal (case-sensitive) comparison is significantly faster than OrdinalIgnoreCase.
if (!requestPath.StartsWith(virtualPathRoot, StringComparison.Ordinal))
{
if (!requestPath.StartsWith(virtualPathRoot, StringComparison.OrdinalIgnoreCase))
{
return(RoutingContext.Invalid());
}
}
string relativeRequestPath = null;
int virtualPathLength = virtualPathRoot.Length;
if (requestPath.Length > virtualPathLength && requestPath[virtualPathLength] == '/')
{
relativeRequestPath = requestPath.Substring(virtualPathLength + 1);
}
else
{
relativeRequestPath = requestPath.Substring(virtualPathLength);
}
return(RoutingContext.Valid(RouteParser.SplitUriToPathSegmentStrings(relativeRequestPath)));
}
internal HttpRoute(
string routeTemplate,
HttpRouteValueDictionary defaults,
HttpRouteValueDictionary constraints,
HttpRouteValueDictionary dataTokens,
HttpMessageHandler handler,
HttpParsedRoute parsedRoute
)
{
_routeTemplate = routeTemplate == null ? String.Empty : routeTemplate;
_defaults = defaults ?? new HttpRouteValueDictionary();
_constraints = constraints ?? new HttpRouteValueDictionary();
_dataTokens = dataTokens ?? new HttpRouteValueDictionary();
Handler = handler;
if (parsedRoute == null)
{
// The parser will throw for invalid routes.
ParsedRoute = RouteParser.Parse(routeTemplate);
}
else
{
ParsedRoute = parsedRoute;
}
}
protected Dictionary <string, string> ToRouteValues(Uri uri)
{
RouteParser parser = new RouteParser(Route.Replace("$PathName", PathName));
Dictionary <string, string> values = parser.ParseRouteInstance(uri.ToString());
return(values);
}
/// <summary>Creates a route builder that can build a route matching this context.</summary>
/// <param name="template">The route template.</param>
/// <param name="constraintResolver">
/// The inline constraint resolver to use, if any; otherwise, <see langword="null"/>.
/// </param>
/// <returns>A route builder that can build a route matching this context.</returns>
public IDirectRouteBuilder CreateBuilder(string template, IInlineConstraintResolver constraintResolver)
{
DirectRouteBuilder builder = new DirectRouteBuilder(_actions, _targetIsAction);
#if ASPNETWEBAPI
string prefixedTemplate = BuildRouteTemplate(_prefix, template);
#else
string prefixedTemplate = BuildRouteTemplate(_areaPrefix, _controllerPrefix, template ?? String.Empty);
#endif
ValidateTemplate(prefixedTemplate);
if (constraintResolver != null)
{
TRouteDictionary defaults = new TRouteDictionary();
TRouteDictionary constraints = new TRouteDictionary();
string detokenizedTemplate = InlineRouteTemplateParser.ParseRouteTemplate(prefixedTemplate, defaults,
constraints, constraintResolver);
TParsedRoute parsedRoute = RouteParser.Parse(detokenizedTemplate);
decimal precedence = RoutePrecedence.Compute(parsedRoute, constraints);
builder.Defaults = defaults;
builder.Constraints = constraints;
builder.Template = detokenizedTemplate;
builder.Precedence = precedence;
builder.ParsedRoute = parsedRoute;
}
else
{
builder.Template = prefixedTemplate;
}
return(builder);
}
public void TestExpectedBehavior()
{
var tokenizer = new RouteTokenizer();
var parser = new RouteParser();
var route = "/the/path/{to}/*/{glory}";
var token = tokenizer.Tokenize(route);
var routeInformation = parser.Parse(route, token);
Assert.AreEqual(2, routeInformation.Parameter.Length);
Assert.AreEqual("to", routeInformation.Parameter[0]);
Assert.AreEqual("glory", routeInformation.Parameter[1]);
Assert.AreEqual("the", routeInformation.Segments[0].Name);
Assert.AreEqual(RouteSegmentType.Static, routeInformation.Segments[0].Type);
Assert.AreEqual("path", routeInformation.Segments[1].Name);
Assert.AreEqual(RouteSegmentType.Static, routeInformation.Segments[1].Type);
Assert.AreEqual("to", routeInformation.Segments[2].Name);
Assert.AreEqual(RouteSegmentType.Parameter, routeInformation.Segments[2].Type);
Assert.AreEqual("*", routeInformation.Segments[3].Name);
Assert.AreEqual(RouteSegmentType.Wildcard, routeInformation.Segments[3].Type);
Assert.AreEqual("glory", routeInformation.Segments[4].Name);
Assert.AreEqual(RouteSegmentType.Parameter, routeInformation.Segments[4].Type);
}
public void ShouldNotGetPatternForEmptyURL()
{
RouteParser parser;
parser = new RouteParser();
Assert.ThrowsException <ArgumentNullException>(() => parser.GetPattern(null));
Assert.ThrowsException <ArgumentNullException>(() => parser.GetPattern(""));
}
internal ParsedRoute ToParsedRoute()
{
if (parsedRoute == null)
{
parsedRoute = RouteParser.Parse(GetRouteUrl());
}
return(parsedRoute);
}
public virtual TypeRoute ParseRoute(string uri)
{
RouteParser parser = new RouteParser(Route);
TypeRoute route = (TypeRoute)parser.ParseRouteInstance(uri).ToInstance(this.GetType());
route.ParseMethod();
return(route);
}
public Bootstrapper(HttpContextBase httpContext, RouteCollection routes, RouteParser routeParser,
JavascriptRouteGenerator jsRouteGenerator)
{
HttpContext = httpContext;
Routes = routes;
RouteParser = routeParser;
JsRouteGenerator = jsRouteGenerator;
}
public void ParseParameterRouteTest()
{
var route = RouteParser.Parse("api/customers/{id}");
Assert.AreEqual(3, route.Count);
Assert.IsInstanceOf <LiteralRouteItem>(route[0]);
Assert.IsInstanceOf <LiteralRouteItem>(route[1]);
Assert.IsInstanceOf <ParameterRouteItem>(route[2]);
}
public void Parse_NullRoute()
{
// Arrange
var parser = new RouteParser();
var commandName = "";
// Act
var param = parser.Parse(null, out commandName);
}
public void Parse_RouteWithOneRequiredAndOneOptinalInTheWrongOrder()
{
// Arrange
var parser = new RouteParser();
var commandName = "";
// Act
var param = parser.Parse("ls filter? path", out commandName);
}
public void Parse_EmptyRoute()
{
// Arrange
var parser = new RouteParser();
var commandName = "";
// Act
var param = parser.Parse("", out commandName);
}
public void Parse_RouteWithOneRequiredAndOneOptinalInTheWrongOrder()
{
// Arrange
var parser = new RouteParser();
var commandName = "";
// Act
var param = parser.Parse("ls filter? path", out commandName);
}
public void ShouldGetPatternForURLWithVariableAndFilters()
{
RouteParser parser;
string result;
parser = new RouteParser();
result = parser.GetPattern("/root/API/Books/{id}?author={authorID}&year={yearNumber}");
Assert.AreEqual(@"^/root/API/Books/(?<id>[^/&]+)\?author=(?<authorID>[^/&]+)&year=(?<yearNumber>[^/&]+)$", result);
}
public void Parse_EmptyRoute()
{
// Arrange
var parser = new RouteParser();
var commandName = "";
// Act
var param = parser.Parse("", out commandName);
}
public void Parse_NullRoute()
{
// Arrange
var parser = new RouteParser();
var commandName = "";
// Act
var param = parser.Parse(null, out commandName);
}
public void ShouldGetPatternForRootURL()
{
RouteParser parser;
string result;
parser = new RouteParser();
result = parser.GetPattern("/root");
Assert.AreEqual("^/root$", result);
}
public void ShouldGetPatternForMediumStaticURL()
{
RouteParser parser;
string result;
parser = new RouteParser();
result = parser.GetPattern("/root/API/Books/1");
Assert.AreEqual("^/root/API/Books/1$", result);
}
public void ShouldGetPatternForURLStartingWithSlash()
{
RouteParser parser;
string result;
parser = new RouteParser();
result = parser.GetPattern("/root/API");
Assert.AreEqual("^/root/API$", result);
}
public void ShouldGetPatternForURLWithVariableBis()
{
RouteParser parser;
string result;
parser = new RouteParser();
result = parser.GetPattern("/root/API/Books/{id}/Name");
Assert.AreEqual("^/root/API/Books/(?<id>[^/&]+)/Name$", result);
}
public void ParseParameterRouteItemAtMiddlePositionTest()
{
var route = RouteParser.Parse("api/customers/{id}/orders");
Assert.AreEqual(4, route.Count);
Assert.IsInstanceOf <LiteralRouteItem>(route[0]);
Assert.IsInstanceOf <LiteralRouteItem>(route[1]);
Assert.IsInstanceOf <ParameterRouteItem>(route[2]);
Assert.IsInstanceOf <LiteralRouteItem>(route[3]);
}
public void RequestParserCanTakeJustADomain()
{
RouteParser parser = new RouteParser("{Protocol}://{Domain}");
Dictionary <string, string> values = parser.ParseRouteInstance("http://v-o.bamapps.net");
RequestRoute route = values.ToInstance <RequestRoute>();
Expect.AreEqual(2, values.Count, $"Expected 2 but got {values.Count}");
Expect.AreEqual("http", route.Protocol);
Expect.AreEqual("v-o.bamapps.net", route.Domain);
}
public void RequestParserCanTakeEmptyPath()
{
RouteParser parser = new RouteParser("{Protocol}://{Domain}/{PathAndQuery}");
Dictionary <string, string> values = parser.ParseRouteInstance("http://v-o.bamapps.net/");
RequestRoute route = values.ToInstance <RequestRoute>();
Expect.AreEqual(3, values.Count, $"Expected 3 but got {values.Count}");
Expect.AreEqual("http", route.Protocol);
Expect.AreEqual("v-o.bamapps.net", route.Domain);
Expect.AreEqual("", route.PathAndQuery);
}
private void PopulateActionDescriptions(HttpActionDescriptor actionDescriptor, IHttpRoute route, string localPath, Collection <ApiDescription> apiDescriptions)
{
string apiDocumentation = GetApiDocumentation(actionDescriptor);
HttpParsedRoute parsedRoute = RouteParser.Parse(localPath);
// parameters
IList <ApiParameterDescription> parameterDescriptions = CreateParameterDescriptions(actionDescriptor, parsedRoute, route.Defaults);
// expand all parameter variables
string finalPath;
if (!TryExpandUriParameters(route, parsedRoute, parameterDescriptions, out finalPath))
{
// the action cannot be reached due to parameter mismatch, e.g. routeTemplate = "/users/{name}" and GetUsers(id)
return;
}
// request formatters
ApiParameterDescription bodyParameter = parameterDescriptions.FirstOrDefault(description => description.Source == ApiParameterSource.FromBody);
IEnumerable <MediaTypeFormatter> supportedRequestBodyFormatters = bodyParameter != null?
actionDescriptor.Configuration.Formatters.Where(f => f.CanReadType(bodyParameter.ParameterDescriptor.ParameterType)) :
Enumerable.Empty <MediaTypeFormatter>();
// response formatters
ResponseDescription responseDescription = CreateResponseDescription(actionDescriptor);
Type returnType = responseDescription.ResponseType ?? responseDescription.DeclaredType;
IEnumerable <MediaTypeFormatter> supportedResponseFormatters = (returnType != null && returnType != typeof(void)) ?
actionDescriptor.Configuration.Formatters.Where(f => f.CanWriteType(returnType)) :
Enumerable.Empty <MediaTypeFormatter>();
// Replacing the formatter tracers with formatters if tracers are present.
supportedRequestBodyFormatters = GetInnerFormatters(supportedRequestBodyFormatters);
supportedResponseFormatters = GetInnerFormatters(supportedResponseFormatters);
// get HttpMethods supported by an action. Usually there is one HttpMethod per action but we allow multiple of them per action as well.
IList <HttpMethod> supportedMethods = GetHttpMethodsSupportedByAction(route, actionDescriptor);
foreach (HttpMethod method in supportedMethods)
{
apiDescriptions.Add(new ApiDescription
{
Documentation = apiDocumentation,
HttpMethod = method,
RelativePath = finalPath,
ActionDescriptor = actionDescriptor,
Route = route,
SupportedResponseFormatters = new Collection <MediaTypeFormatter>(supportedResponseFormatters.ToList()),
SupportedRequestBodyFormatters = new Collection <MediaTypeFormatter>(supportedRequestBodyFormatters.ToList()),
ParameterDescriptions = new Collection <ApiParameterDescription>(parameterDescriptions),
ResponseDescription = responseDescription
});
}
}
private static RouteEntry CreateRouteEntry(string routeTemplate)
{
var route = new RouteBuilder().BuildDirectRoute(routeTemplate, new[] { "GET" }, "Controller", "Action", null, null);
return(new RouteEntry()
{
Route = route,
RouteTemplate = routeTemplate,
ParsedRoute = RouteParser.Parse(route.Url)
});
}
public void ShouldGetPatternForStaticURLWithSpecialChars()
{
RouteParser parser;
string result;
parser = new RouteParser();
result = parser.GetPattern("/root/API/Books.Test/1");
Assert.AreEqual(@"^/root/API/Books\.Test/1$", result);
result = parser.GetPattern("/root/API/Books?author={authorID}&year={yearNumber}");
Assert.AreEqual(@"^/root/API/Books\?author=(?<authorID>[^/&]+)&year=(?<yearNumber>[^/&]+)$", result);
}
public void Parse_CanParseSimpleRouteWithTrailingSpace()
{
// Arrange
var parser = new RouteParser();
var commandName = "";
// Act
parser.Parse("ls ", out commandName);
// Assert
Assert.AreEqual("ls", commandName);
}
public void ApiRouteDescriptorParseTest()
{
RouteParser parser = new RouteParser("{Protocol}://{Domain}/api/{PathAndQuery}");
Dictionary <string, string> values = parser.ParseRouteInstance("bam://bamapps.net/api/v1/monkey/5");
Expect.AreEqual(3, values.Count, $"Expected 3 but got {values.Count}");
RequestRoute route = values.ToInstance <RequestRoute>();
Expect.AreEqual("bam", route.Protocol);
Expect.AreEqual("bamapps.net", route.Domain);
Expect.AreEqual("v1/monkey/5", route.PathAndQuery);
}
public void Parse_CanParseSimpleRouteWithTrailingSpace()
{
// Arrange
var parser = new RouteParser();
var commandName = "";
// Act
parser.Parse("ls ", out commandName);
// Assert
Assert.AreEqual("ls", commandName);
}
public void TestSlashInParameter()
{
var tokenizer = new RouteTokenizer();
var parser = new RouteParser();
var route = "/malformed/{rou/te}";
var token = tokenizer.Tokenize(route);
Assert.Throws<RouteParsingException>(() => {
parser.Parse(route, token);
});
}
public void Parse_RouteWithSingleOptionalParameter()
{
// Arrange
var parser = new RouteParser();
var commandName = "";
// Act
var param = parser.Parse("ls filter?", out commandName);
// Assert
Assert.AreEqual(1, param.Count);
Assert.AreEqual("filter", param.First().Key);
Assert.AreEqual(ParameterType.Optional, param.First().Value);
}
public void Parse_RouteWithSingleOptionalParameter()
{
// Arrange
var parser = new RouteParser();
var commandName = "";
// Act
var param = parser.Parse("ls filter?", out commandName);
// Assert
Assert.AreEqual(1, param.Count);
Assert.AreEqual("filter", param.First().Key);
Assert.AreEqual(ParameterType.Optional, param.First().Value);
}
public bool Parse(string pathAndQuery)
{
Type currentType = GetType();
DataRoute instance = (DataRoute)currentType.Construct();
RouteParser parser = new RouteParser(instance.Route);
Dictionary <string, string> values = parser.ParseRouteInstance(pathAndQuery);
instance = (DataRoute)values.ToInstance(currentType);
if (instance.IsValid())
{
this.CopyProperties(instance);
return(true);
}
return(false);
}
private static decimal Compute(string template)
{
DefaultInlineConstraintResolver resolver = new DefaultInlineConstraintResolver();
#if ASPNETWEBAPI
HttpRouteValueDictionary defaults = new HttpRouteValueDictionary();
HttpRouteValueDictionary constraints = new HttpRouteValueDictionary();
#else
RouteValueDictionary defaults = new RouteValueDictionary();
RouteValueDictionary constraints = new RouteValueDictionary();
#endif
string standardRouteTemplate = InlineRouteTemplateParser.ParseRouteTemplate(template,
defaults, constraints, new DefaultInlineConstraintResolver());
var parsedRoute = RouteParser.Parse(standardRouteTemplate);
return(RoutePrecedence.Compute(parsedRoute, constraints));
}
private void Awake()
{
var regex = RouteParser.Parse(_path, _exact);
_route = new Route(_path, regex);
var router = this.FindRouter();
if (router == null)
{
throw new Exception("No RouterComponent found in parents");
}
router.OnLocationChanged += OnLocationChanged;
OnLocationChanged(router.CurrentLocation);
}
public void ShouldFailToParseInvalidControllerName()
{
Mock<Type> mockController = new Mock<Type>();
mockController.Setup(x => x.Name).Returns(c_controllerName);
try
{
RouteParser rp = new RouteParser(mockController.Object, null, null);
}
catch (ApplicationException)
{
// expected behaviour is for the ctor to throw because
// the type name does end with "Controller"
return;
}
Assert.Fail("RouteParser is not validating the controller name must end in \"Controller\"");
}
private void Test()
{
RouteParser _parser = new RouteParser();
IHeader header = _parser.Parse("Route",
new StringReader(
"<sip:bigbox3.site3.atlanta.com;lr>,\r\n <sip:server10.biloxi.com)"));
Assert.IsType(typeof(Route), header);
var route = (Route)header;
Assert.Equal("bigbox3.site3.atlanta.com", route.Items[0].Uri.Domain);
Assert.Equal("sip", route.Items[0].Uri.Scheme);
Assert.True(route.Items[0].IsLoose);
Assert.Equal("server10.biloxi.com", route.Items[1].Uri.Domain);
Assert.Equal("sip", route.Items[1].Uri.Scheme);
Assert.False(route.Items[1].IsLoose);
}
public void Parse_RouteWithTwoOptionalParameters()
{
// Arrange
var parser = new RouteParser();
var commandName = "";
// Act
var param = parser.Parse("ls filter? path?", out commandName);
// Assert
Assert.AreEqual(2, param.Count);
Assert.AreEqual("filter", param.First().Key);
Assert.AreEqual(ParameterType.Optional, param.First().Value);
Assert.AreEqual("path", param.Skip(1).Take(1).Single().Key);
Assert.AreEqual(ParameterType.Optional, param.Skip(1).Take(1).Single().Value);
}
public void ShouldOverrideUrlUsingIsRoot()
{
RouteParser rp = new RouteParser(m_mockController, m_mockAction, new RouteAttribute { Url = "account/login", IsRoot = true });
Assert.AreEqual("", rp.Url);
}
public void ShouldParseActionName()
{
RouteParser rp = new RouteParser(m_mockController, m_mockAction, null);
Assert.AreEqual(c_actionName, rp.ActionName);
}
public void ShouldParseConstraints()
{
RouteParser rp = new RouteParser(m_mockController, m_mockAction, null);
RouteValueDictionary expected = new RouteValueDictionary(new {
Numeric = "^[0-9]$"
});
RoutingAssert.AreDictionariesEqual(expected, rp.Constraints);
}
public Parser()
{
_tokenizer = new RouteTokenizer();
_parser = new RouteParser();
}
public void Parse_RouteWithTwoOptionalParameters()
{
// Arrange
var parser = new RouteParser();
var commandName = "";
// Act
var param = parser.Parse("ls filter? path?", out commandName);
// Assert
Assert.AreEqual(2, param.Count);
Assert.AreEqual("filter", param.First().Key);
Assert.AreEqual(ParameterType.Optional, param.First().Value);
Assert.AreEqual("path", param.Skip(1).Take(1).Single().Key);
Assert.AreEqual(ParameterType.Optional, param.Skip(1).Take(1).Single().Value);
}
public void ShouldParseOrder()
{
RouteParser rp = new RouteParser(m_mockController, m_mockAction, m_routeAttribute);
Assert.AreEqual(99, rp.Order);
}
public void ShouldOverrideDefaultControllerAndActionNames()
{
Mock<MethodInfo> mockAction = new Mock<MethodInfo>();
mockAction
.Setup(x => x.Name)
.Returns(c_actionName);
mockAction
.Setup(x => x.DeclaringType)
.Returns(m_mockController);
mockAction
.Setup(x => x.GetCustomAttributes(typeof(RouteDefaultAttribute), true))
.Returns(new RouteDefaultAttribute[] {
new RouteDefaultAttribute {
Name = "controller",
Value = "plibble"
},
new RouteDefaultAttribute {
Name = "Page",
Value = 1
}
});
RouteParser rp = new RouteParser(m_mockController, mockAction.Object, null);
RouteValueDictionary expected = new RouteValueDictionary(new {
controller = "plibble",
action = c_actionName,
Page = 1
});
RoutingAssert.AreDictionariesEqual(expected, rp.Defaults);
}
public void ShouldParseRouteName()
{
RouteParser rp = new RouteParser(m_mockController, m_mockAction, m_routeAttribute);
Assert.AreEqual("HomeLink", rp.RouteName);
}
public void ShouldParseUrl()
{
RouteParser rp = new RouteParser(m_mockController, m_mockAction, m_routeAttribute);
Assert.AreEqual("home", rp.Url);
}
public Bootstrapper(HttpContextBase httpContext, RouteCollection routes, RouteParser routeParser)
{
HttpContext = httpContext;
Routes = routes;
RouteParser = routeParser;
}
public void ShouldParseDefaults()
{
RouteParser rp = new RouteParser(m_mockController, m_mockAction, null);
RouteValueDictionary expected = new RouteValueDictionary(new {
controller = c_controllerName,
action = c_actionName,
Page = 1 }
);
RoutingAssert.AreDictionariesEqual(expected, rp.Defaults);
}
public void ShouldParseControllerName()
{
RouteParser rp = new RouteParser(m_mockController, null, null);
Assert.AreEqual(c_controllerName, rp.ControllerName);
}
public void ShouldParseEmptyUrlAsControllerAction()
{
RouteParser rp = new RouteParser(m_mockController, m_mockAction, new RouteAttribute { Url = "" });
Assert.AreEqual(String.Format("{0}/{1}", c_controllerName, c_actionName), rp.Url);
}
public void ShouldFailToParseInvalidUrl()
{
RouteParser rp = new RouteParser(m_mockController, m_mockAction, new RouteAttribute { Url = "/account/login" });
try
{
string s = rp.Url;
}
catch (ApplicationException)
{
// expected behaviour is for the ctor to throw because
// the type name does end with "Controller"
return;
}
Assert.Fail("RouteParser is not validating the route attribute url properly");
}
