public void ShouldAddRouteIfProvidedWhenConfigureIsInvoked() { var route = new HttpRoute("testroute"); controller = new DummyController(); controller.ConfigureForTesting(request, "testroute", route); controller.Configuration.Routes.ShouldContain(route); }
public static void Register(HttpConfiguration config) { // Web API 配置和服务 // Web API 路由 config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{action}/{id}", defaults: new { id = RouteParameter.Optional }//, //constraints:new{sss=new HttpMethodConstraint(HttpMethod.Post)} ); HttpRouteValueDictionary defaults = new HttpRouteValueDictionary(); //defaults.Add("controller", "Demo"); //defaults.Add("action", "Get"); defaults.Add("val", 0); HttpRouteValueDictionary constraints = new HttpRouteValueDictionary(); constraints.Add("val",new DoubleRouteConstraint()); HttpRoute route = new HttpRoute("customer/{controller}/{action}/{val}", defaults, constraints); config.Routes.Add("CustomerApi",route); }
public void Ctor_PreservesWhitespaceInRouteTemplate() { string whitespace = " "; HttpRoute httpRoute = new HttpRoute(whitespace); Assert.Equal(whitespace, httpRoute.RouteTemplate); }
public void ShouldSetRouteDataWithControllerInformationWhenConfigureIsInvoked() { controller = new DummyController(); var route = new HttpRoute("testroute"); controller.ConfigureForTesting(new HttpRequestMessage(), "testroute", route); var addedRoute = controller.Configuration.Routes["testroute"]; addedRoute.ShouldEqual(route); }
public void GetRouteData_HandlesUrlEncoding(string id) { HttpRoute route = new HttpRoute("{controller}/{id}"); Uri uri = new Uri("http://localhost/test/" + id + "/"); IHttpRouteData routeData = route.GetRouteData("", new HttpRequestMessage(HttpMethod.Get, uri)); Assert.Equal("test", routeData.Values["controller"]); Assert.Equal(id, routeData.Values["id"]); }
public void GetRouteData_HandlesUrlEncoding(string id) { HttpRoute route = new HttpRoute("{controller}/{id}"); Uri uri = new Uri("http://localhost/test/" + id + "/"); IHttpRouteData routeData = route.GetRouteData( "", new HttpRequestMessage(HttpMethod.Get, uri) ); Assert.Equal("test", routeData.Values["controller"]); Assert.Equal(id, routeData.Values["id"]); }
public static void Register(System.Web.Http.HttpConfiguration config) { // Web API configuration and services // Web API routes config.MapHttpAttributeRoutes(); HttpRoute route=new HttpRoute(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); }
public void Configure(HttpRouteCollection routeCollection) { foreach (var routeCounfiguration in Configurations) { var defaultParameters = routeCounfiguration.DefaultParameters ?? Enumerable.Empty<RouteConfigurationParameter>(); var routeValueDictionary = BuildHttpRouteValueDictionary(defaultParameters); var route = new HttpRoute(routeCounfiguration.Template, routeValueDictionary); routeCollection.Add(routeCounfiguration.Name, route); } }
public void GetRouteDataDoesNotMatch(string uriTemplate, string virtualPathRoot, string requestUri) { HttpRoute route = new HttpRoute(uriTemplate); route.Defaults.Add("controller", "Customer"); route.Defaults.Add("id", "999"); HttpRequestMessage request = new HttpRequestMessage(); request.RequestUri = new Uri(requestUri); IHttpRouteData data = route.GetRouteData(virtualPathRoot, request); // Assert Assert.Null(data); }
public void GetVirtualPath_GeneratesPathWithoutRouteData() { var route = new HttpRoute("{controller}"); var request = new HttpRequestMessage(); var values = new HttpRouteValueDictionary() { { "httproute", true }, { "controller", "Customers" } }; IHttpVirtualPathData virtualPath = route.GetVirtualPath(request, values); Assert.NotNull(virtualPath); Assert.Equal("Customers", virtualPath.VirtualPath); }
public void GetRouteDataShouldMatch(string uriTemplate, string virtualPathRoot, string requestUri) { HttpRoute route = new HttpRoute(uriTemplate); route.Defaults.Add("controller", "Customer"); route.Defaults.Add("id", "999"); HttpRequestMessage request = new HttpRequestMessage(); request.RequestUri = new Uri(requestUri); IHttpRouteData data = route.GetRouteData(virtualPathRoot, request); // Assert Assert.NotNull(data); IDictionary<string, object> expectedResult = new Dictionary<string, object>(); expectedResult["controller"] = "Customer"; expectedResult["id"] = "999"; Assert.Equal(expectedResult, data.Values, new DictionaryEqualityComparer()); }
/// <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] = route.ParsedRoute.GetPrecedence(constraints); route.DataTokens[RouteKeys.ActionsDataTokenKey] = actions.AsArray(); } return(route); }
public void GetVirtualPath_GetsValuesInCaseInsensitiveWay(string controllerKey) { var route = new HttpRoute("{controller}"); var request = new HttpRequestMessage(); request.SetRouteData( new HttpRouteData(route, new HttpRouteValueDictionary() { { "controller", "Employees" } })); var values = new HttpRouteValueDictionary() { { "httproute", true }, { controllerKey, "Customers" } }; IHttpVirtualPathData virtualPath = route.GetVirtualPath(request, values); Assert.NotNull(virtualPath); Assert.Equal("Customers", virtualPath.VirtualPath); }
public void HttpSubRouteCollection_Throws_OnDuplicateNamedRoute() { // Arrange var collection = new HttpSubRouteCollection(); var route1 = new HttpRoute("api/Person"); var route2 = new HttpRoute("api/Car"); collection.Add(new HttpRouteEntry("route", route1)); var expectedError = "A route named 'route' is already in the route collection. Route names must be unique." + Environment.NewLine + Environment.NewLine + "Duplicates:" + Environment.NewLine + "api/Car" + Environment.NewLine + "api/Person"; // Act & Assert Assert.Throws <InvalidOperationException>(() => collection.Add(new HttpRouteEntry("route", route2)), expectedError); }
public IEnumerable<string> Get() { string routeTemplate = "weather/{areacode}/{days}"; IHttpRoute route = new HttpRoute(routeTemplate); route.Defaults.Add("days", 2); HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "/"); IHttpVirtualPathData pathData; //1. 不能提供路由变量areacode的值 Dictionary<string, object> values = new Dictionary<string, object>(); pathData = route.GetVirtualPath(request, values); yield return pathData == null ? "N/A" : pathData.VirtualPath; //2. values无Key为"httproute"的元素 values.Add("areaCode", "028"); pathData = route.GetVirtualPath(request, values); yield return pathData == null ? "N/A" : pathData.VirtualPath; //3. 所有的路由变量值通过values提供 values.Add("httproute", true); values.Add("days", 3); IHttpRouteData routeData = new HttpRouteData(route); routeData.Values.Add("areacode", "0512"); routeData.Values.Add("days", 4); request.SetRouteData(routeData); pathData = route.GetVirtualPath(request, values); yield return pathData == null ? "N/A" : pathData.VirtualPath; //4. 所有的路由变量值通过request提供 values.Clear(); values.Add("httproute", true); pathData = route.GetVirtualPath(request, values); yield return pathData == null ? "N/A" : pathData.VirtualPath; //5. 采用定义在HttpRoute上的默认值(days = 2) routeData.Values.Remove("days"); pathData = route.GetVirtualPath(request, values); yield return pathData == null ? "N/A" : pathData.VirtualPath; }
public int CompareTo(HttpRouteEntry other) { Contract.Assert(other != null); // Order by prefixes first if (PrefixOrder > other.PrefixOrder) { return(1); } else if (PrefixOrder < other.PrefixOrder) { return(-1); } // Then order by the attribute order if (Order > other.Order) { return(1); } else if (Order < other.Order) { return(-1); } HttpRoute httpRoute1 = Route as HttpRoute; HttpRoute httpRoute2 = other.Route as HttpRoute; if (httpRoute1 != null && httpRoute2 != null) { int comparison = Compare(httpRoute1, httpRoute2); if (comparison != 0) { return(comparison); } } // Compare the route templates alphabetically to ensure the sort is stable and deterministic in almost all cases return(String.Compare(RouteTemplate, other.RouteTemplate, StringComparison.OrdinalIgnoreCase)); }
public void GetActionDirectRoutes_IfDirectRouteProviderReturnsRouteWithEmptyActionDescriptors_Throws() { // Arrange HttpRouteValueDictionary dataTokens = new HttpRouteValueDictionary { { RouteDataTokenKeys.Actions, new HttpActionDescriptor[0] } }; HttpRoute route = new HttpRoute(null, null, null, dataTokens); RouteEntry entry = new RouteEntry(name: null, route: route); var factories = new[] { CreateStubRouteFactory(entry) }; var action = CreateStubActionDescriptor("IgnoreAction"); var constraintResolver = new Mock <IInlineConstraintResolver>(MockBehavior.Strict).Object; var provider = new AccessibleDirectRouteProvider(); // Act & Assert string expectedMessage = "The route does not have any associated action descriptors. Routing requires " + "that each direct route map to a non-empty set of actions."; Assert.Throws <InvalidOperationException>( () => provider.GetActionDirectRoutes(action, factories, constraintResolver), expectedMessage); }
public IEnumerable<UriResolutionResult> Get() { string routeTemplate = "movies/{genre}/{title}/{id}"; IHttpRoute route = new HttpRoute(routeTemplate); IHttpRouteConstraint contraint = new HttpMethodConstraint(HttpMethod.Post); route.Constraints.Add("httpMethod", contraint); string requestUri = "http://www.artech.com/api/movies/romance/titanic/001"; HttpRequestMessage request1 = new HttpRequestMessage(HttpMethod.Get, requestUri); HttpRequestMessage request2 = new HttpRequestMessage(HttpMethod.Post, requestUri); string root1 = "/"; string root2 = "/api/"; IHttpRouteData routeData1 = route.GetRouteData(root1, request1); IHttpRouteData routeData2 = route.GetRouteData(root1, request2); IHttpRouteData routeData3 = route.GetRouteData(root2, request1); IHttpRouteData routeData4 = route.GetRouteData(root2, request2); yield return new UriResolutionResult(root1,"GET", routeData1 != null); yield return new UriResolutionResult(root1,"POST", routeData2 != null); yield return new UriResolutionResult(root2,"GET", routeData3 != null); yield return new UriResolutionResult(root2, "POST", routeData4 != null); }
// Disabled tests until we can rely on a Microsoft.Owin implementation that provides a // URI that handles the following encoded characters: % \ ? # // Tracked by https://aspnetwebstack.codeplex.com/workitem/1054 //[InlineData("%24")] //[InlineData(@"\")] //[InlineData("?#")] public void Invoke_CreatesUri_ThatGeneratesCorrectlyDecodedStrings(string decodedId) { var handler = CreateOKHandlerStub(); var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false); var environment = CreateEnvironment("GET", "http", "localhost", "/vroot", "/api/customers/" + decodedId); var adapter = new HttpMessageHandlerAdapter(env => TaskHelpers.Completed(), handler, bufferPolicySelector); var route = new HttpRoute("api/customers/{id}"); adapter.Invoke(environment).Wait(); IHttpRouteData routeData = route.GetRouteData("/vroot", handler.Request); Assert.NotNull(routeData); Assert.Equal(decodedId, routeData.Values["id"]); }
private HttpResponseMessage ExecuteSelfHostRequest(string url, string controller, object data, string mediaType) { HttpConfiguration config = new HttpConfiguration(); IHttpRoute routeData; if (!config.Routes.TryGetValue(controller, out routeData)) { HttpRoute route = new HttpRoute("{controller}/{action}", new HttpRouteValueDictionary(controller)); config.Routes.Add(controller, route); } HttpControllerDispatcher dispatcher = new HttpControllerDispatcher(config); HttpServer server = new HttpServer(config, dispatcher); HttpMessageInvoker invoker = new HttpMessageInvoker(server); string serializedChangeSet = String.Empty; if (mediaType == "application/json") { JsonSerializer serializer = new JsonSerializer() { PreserveReferencesHandling = PreserveReferencesHandling.Objects, TypeNameHandling = TypeNameHandling.All }; MemoryStream ms = new MemoryStream(); JsonWriter writer = new JsonTextWriter(new StreamWriter(ms)); serializer.Serialize(writer, data); writer.Flush(); ms.Seek(0, 0); serializedChangeSet = Encoding.UTF8.GetString(ms.GetBuffer()).TrimEnd('\0'); } else { DataContractSerializer ser = new DataContractSerializer(data.GetType(), GetTestKnownTypes()); MemoryStream ms = new MemoryStream(); ser.WriteObject(ms, data); ms.Flush(); ms.Seek(0, 0); serializedChangeSet = Encoding.UTF8.GetString(ms.GetBuffer()).TrimEnd('\0'); } HttpRequestMessage request = TestHelpers.CreateTestMessage(url, HttpMethod.Post, config); request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(mediaType)); request.Content = new StringContent(serializedChangeSet, Encoding.UTF8, mediaType); return invoker.SendAsync(request, CancellationToken.None).Result; }
public void Invoke_CreatesUri_ThatGeneratesCorrectlyDecodedStrings(string decodedId) { var handler = CreateOKHandlerStub(); var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false); var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers/" + decodedId); var options = CreateValidOptions(handler, bufferPolicySelector); var adapter = CreateProductUnderTest(options); var route = new HttpRoute("api/customers/{id}"); adapter.Invoke(new OwinContext(environment)).Wait(); IHttpRouteData routeData = route.GetRouteData("/vroot", handler.Request); Assert.NotNull(routeData); Assert.Equal(decodedId, routeData.Values["id"]); }
private HttpServer GetTestCitiesServer(HttpConfiguration config) { HttpControllerDispatcher dispatcher = new HttpControllerDispatcher(config); HttpRoute route = new HttpRoute("{controller}/{action}", new HttpRouteValueDictionary("Cities")); config.Routes.Add("cities", route); HttpServer server = new HttpServer(config, dispatcher); return server; }
private static IHttpRoute RebuildRouteInternal(HttpRouteInformation routeInformation, HttpConfiguration cfg, Dictionary<Type, HttpControllerDescriptor> controllerDescriptors) { var route = new HttpRoute(routeInformation.RouteTemplate, new HttpRouteValueDictionary(routeInformation.Defaults), new HttpRouteValueDictionary(routeInformation.Constraints), new HttpRouteValueDictionary(routeInformation.DataTokens), null); object value; if (route.DataTokens.TryGetValue(InfoDataTokenKey, out value)) { var descriptorInformations = (HttpActionDescriptorInformation[])value; var descriptors = new HttpActionDescriptor[descriptorInformations.Length]; for (var index = 0; index < descriptorInformations.Length; index++) { var descriptorInformation = descriptorInformations[index]; HttpControllerDescriptor controllerDescriptor; if (controllerDescriptors.TryGetValue(descriptorInformation.ControllerType, out controllerDescriptor) == false) controllerDescriptors[descriptorInformation.ControllerType] = controllerDescriptor = new HttpControllerDescriptor(cfg, descriptorInformation.ControllerName, descriptorInformation.ControllerType); var descriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, descriptorInformation.MethodInfo); foreach (var pair in descriptorInformation.Properties) descriptor.Properties.AddOrUpdate(pair.Key, pair.Value, (_, __) => pair.Value); descriptors[index] = descriptor; } route.DataTokens.Remove(InfoDataTokenKey); route.DataTokens[ActionsDataTokenKey] = descriptors; } return route; }
/// <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] = route.ParsedRoute.GetPrecedence(constraints); route.DataTokens[RouteKeys.ActionsDataTokenKey] = actions.AsArray(); } return route; }
/// <summary> /// Builds the contents for the route table based on the attributes /// found on a specific controller type. /// </summary> /// <param name="routes"></param> /// <param name="controllerType"></param> private static void BuildControllerRoutes(HttpRouteCollection routes, Type controllerType) { var attributes = (HttpRouteAttribute[]) controllerType.GetCustomAttributes(typeof(HttpRouteAttribute), true); string controller = controllerType.Name; // Translate the somewhat weird controller name into one the routing system // understands, by removing the Controller part from the name. if (controller.EndsWith("Controller", StringComparison.Ordinal)) { controller = controller.Substring(0, controller.IndexOf("Controller")); } foreach (var attribute in attributes) { var routeValuesDictionary = new HttpRouteValueDictionary(); routeValuesDictionary.Add("controller", controller); // Create the route and attach the default route handler to it. var route = new HttpRoute(attribute.UriTemplate, routeValuesDictionary, new HttpRouteValueDictionary(), new HttpRouteValueDictionary()); routes.Add(Guid.NewGuid().ToString(), route); } }
private static IHttpRouteData GetRouteData() { HttpRoute route = new HttpRoute(); HttpRouteData routeData = new HttpRouteData(route); return routeData; }
/// <summary> /// Builds the contents for the route table based on the attributes /// found on the method of a specific controller. /// </summary> /// <param name="routes"></param> /// <param name="controllerType"></param> /// <param name="method"></param> private static void BuildControllerMethodRoutes(HttpRouteCollection routes, Type controllerType, MethodInfo method) { // Grab the http route attributes from the current method. var attributes = (HttpRouteAttribute[]) method.GetCustomAttributes(typeof(HttpRouteAttribute), true); if (attributes.Length != 0) { // Automatically grab the controller name and action name // from the method and controller type. string action = method.Name; string controller = controllerType.Name; // Translate the somewhat weird controller name into one the routing system // understands, by removing the Controller part from the name. if (controller.EndsWith("Controller", StringComparison.Ordinal)) { controller = controller.Substring(0, controller.IndexOf("Controller")); } // Generate a route for every HTTP route attribute found on the method foreach (var attribute in attributes) { var routeValueDictionary = new HttpRouteValueDictionary(); routeValueDictionary.Add("controller", controller); routeValueDictionary.Add("action", action); ResolveOptionalRouteParameters(attribute.UriTemplate, method, routeValueDictionary); // Create the route and attach the default route handler to it. var route = new HttpRoute(attribute.UriTemplate, routeValueDictionary, new HttpRouteValueDictionary(), new HttpRouteValueDictionary()); routes.Add(Guid.NewGuid().ToString(), route); } } }