public void AppliesToControllerWithRoutePrefixWorksAsExpected() { // Arrange ControllerModel controller = ControllerModelHelpers.BuildControllerModel <WithPrefixController>("List"); ActionModel action = controller.Actions.First(); ODataControllerActionContext context = new ODataControllerActionContext(string.Empty, EdmModel, controller); AttributeRoutingConvention attributeConvention = CreateConvention(); // Act bool ok = attributeConvention.AppliesToController(context); Assert.False(ok); // Assert Assert.Equal(6, action.Selectors.Count); Assert.Equal(new[] { "Customers({key})", "Customers/{key}", "Customers", "Orders({key})", "Orders/{key}", "Orders", }, action.Selectors.Select(s => s.AttributeRouteModel.Template)); }
public CompositeKeyTest() { _configuration = new[] { typeof(MetadataController), typeof(DriverReleaseLifecycleDescriptionsController), typeof(AnyController) }.GetHttpConfiguration(); IEdmModel model = CompositeEdmModel.GetEdmModel(); // only convention routings var routingConventions = ODataRoutingConventions.CreateDefault(); routingConventions.Insert(0, new CompositeKeyRoutingConvention()); _configuration.MapODataServiceRoute("odata1", "odata", model, new DefaultODataPathHandler(), routingConventions); // only attribute routings var attrRouting = new AttributeRoutingConvention(model, _configuration); IList <IODataRoutingConvention> attributeRoutingConventions = new List <IODataRoutingConvention> { attrRouting }; _configuration.MapODataServiceRoute("odata2", "attribute", model, new DefaultODataPathHandler(), attributeRoutingConventions); HttpServer server = new HttpServer(_configuration); _client = new HttpClient(server); }
public void AppliesToControllerWithLongTemplateWorksAsExpected() { // Arrange ControllerModel controller = ControllerModelHelpers.BuildControllerModel <WithoutPrefixController>("LongAction"); ActionModel action = controller.Actions.First(); ODataControllerActionContext context = new ODataControllerActionContext(string.Empty, EdmModel, controller); AttributeRoutingConvention attributeConvention = CreateConvention(); // Act bool ok = attributeConvention.AppliesToController(context); Assert.False(ok); // Assert Assert.Equal(4, action.Selectors.Count); Assert.Equal(new[] { "/Customers({key})/Orders({relatedKey})/NS.MyOrder/Title", "/Customers({key})/Orders/{relatedKey}/NS.MyOrder/Title", "/Customers/{key}/Orders({relatedKey})/NS.MyOrder/Title", "/Customers/{key}/Orders/{relatedKey}/NS.MyOrder/Title" }, action.Selectors.Select(s => s.AttributeRouteModel.Template)); }
public void AttributeMappingsIsInitialized_WithRightActionAndTemplate(Type controllerType, string expectedPathTemplate, string expectedActionName) { // Arrange var configuration = RoutingConfigurationFactory.CreateWithRootContainer(RouteName); var serviceProvider = GetServiceProvider(configuration, RouteName); var request = RequestFactory.Create(configuration, RouteName); var descriptors = ControllerDescriptorFactory.Create(configuration, "TestController", controllerType); ODataPathTemplate pathTemplate = new ODataPathTemplate(); Mock <IODataPathTemplateHandler> pathTemplateHandler = new Mock <IODataPathTemplateHandler>(); pathTemplateHandler .Setup(p => p.ParseTemplate(expectedPathTemplate, serviceProvider)) .Returns(pathTemplate) .Verifiable(); AttributeRoutingConvention convention = new AttributeRoutingConvention(RouteName, descriptors, pathTemplateHandler.Object); // Act Select(convention, request); // Assert pathTemplateHandler.VerifyAll(); Assert.NotNull(convention.AttributeMappings); Assert.Equal(expectedActionName, convention.AttributeMappings[pathTemplate].ActionName); }
/// <summary> /// Apply Default OData attribute routing /// </summary> /// <param name="controllers">The controller models</param> internal void ApplyAttributeRouting(IList <ControllerModel> controllers) { AttributeRoutingConvention attributeRouting = _conventions.OfType <AttributeRoutingConvention>().FirstOrDefault(); if (attributeRouting == null) { return; } ODataControllerActionContext controllerActionContext = new ODataControllerActionContext { Options = _options }; foreach (var controllerModel in controllers.Where(c => !c.IsNonODataController())) { controllerActionContext.Controller = controllerModel; foreach (var actionModel in controllerModel.Actions.Where(a => !a.IsNonODataAction())) { controllerActionContext.Action = actionModel; attributeRouting.AppliesToAction(controllerActionContext); } } }
public void CtorTakingHttpConfiguration_InitializesAttributeMappings_OnFirstSelectControllerCall() { // Arrange var config = RoutingConfigurationFactory.CreateWithRootContainer(RouteName); var serviceProvider = GetServiceProvider(config, RouteName); var request = RequestFactory.Create(config, RouteName); #if NETCORE request.ODataFeature().Path = new ODataPath(); request.Method = "Get"; ControllerDescriptorFactory.Create(config, "MetadataAndService", typeof(MetadataAndServiceController)); #endif ODataPathTemplate pathTemplate = new ODataPathTemplate(); Mock <IODataPathTemplateHandler> pathTemplateHandler = new Mock <IODataPathTemplateHandler>(); pathTemplateHandler.Setup(p => p.ParseTemplate("$metadata", serviceProvider)) .Returns(pathTemplate).Verifiable(); AttributeRoutingConvention convention = CreateAttributeRoutingConvention(RouteName, config, pathTemplateHandler.Object); EnsureAttributeMapping(convention, config); // Act Select(convention, request); // Assert pathTemplateHandler.VerifyAll(); Assert.NotNull(convention.AttributeMappings); Assert.Equal("GetMetadata", convention.AttributeMappings[pathTemplate].ActionName); }
static AttributeRoutingConventionTests() { _edmModel = GetEdmModel(); _options = new ODataOptions(); _options.AddModel(_edmModel); _attributeConvention = CreateConvention(); }
public void AttributeMappingsInitialization_ThrowsInvalidOperation_IfNoConfigEnsureInitialized() { // Arrange var configuration = RoutingConfigurationFactory.CreateWithRootContainer(RouteName); AttributeRoutingConvention convention = CreateAttributeRoutingConvention(RouteName, configuration); // Act & Assert ExceptionAssert.Throws <InvalidOperationException>( () => convention.AttributeMappings, "The object has not yet been initialized. Ensure that HttpConfiguration.EnsureInitialized() is called " + "in the application's startup code after all other initialization code."); }
public void AttributeRoutingConvention_ConfigEnsureInitialized_DoesNotThrowForValidPathTemplate() { // Arrange IEdmModel model = new CustomersModelWithInheritance().Model; var configuration = RoutingConfigurationFactory.CreateWithRootContainerAndTypes( RouteName, (b => b.AddService(Microsoft.OData.ServiceLifetime.Singleton, sp => model)), typeof(TestODataController)); AttributeRoutingConvention convention = CreateAttributeRoutingConvention(RouteName, configuration); // Act & Assert ExceptionAssert.DoesNotThrow(() => EnsureAttributeMapping(convention, configuration)); }
public void AttributeRoutingConvention_ConfigEnsureInitialized_ThrowsForInvalidPathTemplate() { // Arrange var configuration = RoutingConfigurationFactory.CreateWithRootContainerAndTypes(RouteName, null, typeof(TestODataController)); #if NETCORE ControllerDescriptorFactory.Create(configuration, "TestOData", typeof(TestODataController)); #endif AttributeRoutingConvention convention = CreateAttributeRoutingConvention(RouteName, configuration); // Act & Assert ExceptionAssert.Throws <InvalidOperationException>( () => EnsureAttributeMapping(convention, configuration), "The path template 'Customers' on the action 'GetCustomers' in controller 'TestOData' is not a valid OData path template. " + "Resource not found for the segment 'Customers'."); }
public void AttributeRoutingConvention_ConfigEnsureInitialized_ThrowsForInvalidPathTemplate() { // Arrange var configuration = RoutingConfigurationFactory.CreateWithRootContainerAndTypes(RouteName, null, typeof(TestODataController)); #if NETCORE ControllerDescriptorFactory.Create(configuration, "TestOData", typeof(TestODataController)); #endif AttributeRoutingConvention convention = CreateAttributeRoutingConvention(RouteName, configuration); // Act & Assert ExceptionAssert.Throws <InvalidOperationException>( () => EnsureAttributeMapping(convention, configuration), "The path template 'Customers' on the action 'GetCustomers' in controller 'TestOData' is not a valid OData path template. " + "The operation import overloads matching 'Customers' are invalid. This is most likely an error in the IEdmModel."); }
public void AppliesToActionWithRoutePrefixWorksAsExpected() { // Arrange ControllerModel controller = ControllerModelHelpers.BuildControllerModel <WithPrefixController>("List"); ActionModel action = controller.Actions.First(); Assert.Equal(2, action.Selectors.Count); ODataControllerActionContext context = new ODataControllerActionContext(string.Empty, _edmModel, controller) { Action = action, Options = _options, }; AttributeRoutingConvention attributeConvention = CreateConvention(); // Act bool ok = _attributeConvention.AppliesToAction(context); Assert.False(ok); // Assert Assert.Equal(4, action.Selectors.Count); Assert.Collection(action.Selectors, e => { Assert.Equal("/Customers/{key}", e.AttributeRouteModel.Template); Assert.Contains(e.EndpointMetadata, a => a is ODataRoutingMetadata); }, e => { Assert.Equal("/Orders/{key}", e.AttributeRouteModel.Template); Assert.Contains(e.EndpointMetadata, a => a is ODataRoutingMetadata); }, e => { Assert.Equal("/Customers", e.AttributeRouteModel.Template); Assert.Contains(e.EndpointMetadata, a => a is ODataRoutingMetadata); }, e => { Assert.Equal("/Orders", e.AttributeRouteModel.Template); Assert.Contains(e.EndpointMetadata, a => a is ODataRoutingMetadata); }); }
public void AppliesToControllerForSingletonWorksAsExpected(string actionName, string expectedTemplate) { // Arrange ControllerModel controller = ControllerModelHelpers.BuildControllerModel <SingletonTestControllerWithPrefix>(actionName); ActionModel action = controller.Actions.First(); ODataControllerActionContext context = new ODataControllerActionContext(string.Empty, EdmModel, controller); AttributeRoutingConvention attributeConvention = CreateConvention(); // Act bool ok = attributeConvention.AppliesToController(context); Assert.False(ok); // Assert SelectorModel selector = Assert.Single(action.Selectors); Assert.NotNull(selector.AttributeRouteModel); Assert.Equal(expectedTemplate, selector.AttributeRouteModel.Template); }
private string Select(AttributeRoutingConvention convention, HttpRequestMessage request) { return(convention.SelectController(new ODataPath(), request)); }
private void EnsureAttributeMapping(AttributeRoutingConvention convention, HttpConfiguration configuration) { configuration.EnsureInitialized(); }
private ControllerActionDescriptor Select(AttributeRoutingConvention convention, HttpRequest request) { RouteContext routeContext = new RouteContext(request.HttpContext); return(convention.SelectAction(routeContext)?.FirstOrDefault()); }
private void EnsureAttributeMapping(AttributeRoutingConvention convention, IRouteBuilder routeBuilder) { var mappings = convention.AttributeMappings; }
private static IDictionary <ODataPathTemplate, HttpActionDescriptor> BuildAttributeMappings(ICollection <HttpControllerDescriptor> controllers, AttributeRoutingConvention routingConvention) { IDictionary <ODataPathTemplate, HttpActionDescriptor> attributeMappings = new Dictionary <ODataPathTemplate, HttpActionDescriptor>(); foreach (HttpControllerDescriptor controller in controllers) { if (IsODataController(controller) && ShouldMapController(controller)) { IHttpActionSelector actionSelector = controller.Configuration.Services.GetActionSelector(); ILookup <string, HttpActionDescriptor> actionMapping = actionSelector.GetActionMapping(controller); HttpActionDescriptor[] actions = actionMapping.SelectMany(a => a).ToArray(); foreach (string prefix in GetODataRoutePrefixes(controller)) { foreach (HttpActionDescriptor action in actions) { IEnumerable <ODataPathTemplate> pathTemplates = // Invoke private method routingConvention.InvokeFunction <IEnumerable <ODataPathTemplate> >("GetODataPathTemplates", prefix, action); foreach (ODataPathTemplate pathTemplate in pathTemplates) { //attributeMappings.Add(pathTemplate, new WebApiActionDescriptor(action)); attributeMappings.Add(pathTemplate, action); } } } } } return(attributeMappings); }
private static IDictionary <ODataPathTemplate, HttpActionDescriptor> GetAttributeRoutingActionMap(HttpConfiguration httpConfig, AttributeRoutingConvention routingConvention) { IHttpControllerSelector controllerSelector = httpConfig.Services.GetHttpControllerSelector(); return(BuildAttributeMappings(controllerSelector.GetControllerMapping().Values, routingConvention)); }
/// <summary> /// Maps the OData route attributes. /// </summary> /// <param name="configuration">The http configuration used to search for all the OData controllers to map.</param> public void MapODataRouteAttributes(HttpConfiguration configuration) { AttributeRoutingConvention routingConvention = new AttributeRoutingConvention(PathRouteConstraint.EdmModel, configuration); PathRouteConstraint.RoutingConventions.Insert(0, routingConvention); }