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