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 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 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 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 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 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"); }