public void AddRouteComponents_Throws_IfPrefixExisted()
{
// Arrange
ODataOptions options = new ODataOptions();
IEdmModel edmModel = EdmCoreModel.Instance;
options.AddRouteComponents("odata", edmModel);
// Act
Action test = () => options.AddRouteComponents("odata", edmModel);
// Assert
ExceptionAssert.Throws <InvalidOperationException>(test, "The prefix 'odata' was already used for other Edm model.");
}
static AttributeRoutingConventionTests()
{
_edmModel = GetEdmModel();
_options = new ODataOptions();
_options.AddRouteComponents(_edmModel);
_attributeConvention = CreateConvention();
}
public void OnProvidersExecuted_AddODataRoutingSelector_WhenAttributeRoutingConvention()
{
// Arrange
ODataOptions options = new ODataOptions();
options.AddRouteComponents("odata", _model);
LoggerFactory loggerFactory = new LoggerFactory();
var logger = new Logger <AttributeRoutingConvention>(loggerFactory);
IODataPathTemplateParser parser = new DefaultODataPathTemplateParser();
IODataControllerActionConvention[] conventions = new IODataControllerActionConvention[]
{
new AttributeRoutingConvention(logger, parser)
};
ODataRoutingApplicationModelProvider provider = CreateProvider(options, conventions);
ApplicationModelProviderContext providerContext = CreateProviderContext(typeof(AttributeRoutingController));
// Act
provider.OnProvidersExecuted(providerContext);
// Assert
ControllerModel controller = Assert.Single(providerContext.Result.Controllers);
ActionModel action = Assert.Single(controller.Actions);
Assert.Equal("AnyMethodNameHere", action.ActionMethod.Name);
Assert.Single(action.Parameters);
SelectorModel selectorModel = Assert.Single(action.Selectors);
Assert.Equal("/odata/Customers({key})/Name", selectorModel.AttributeRouteModel.Template);
Assert.Contains(selectorModel.EndpointMetadata, a => a is ODataRoutingMetadata);
}
public void Register(ODataOptions options)
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Person>("PersonApi");
options.AddRouteComponents("odata", builder.GetEdmModel());
}
public void AddRouteComponents_Throws_IfRoutePrefixNull()
{
// Arrange
ODataOptions options = new ODataOptions();
// Act & Assert
ExceptionAssert.ThrowsArgumentNull(() => options.AddRouteComponents(null, EdmCoreModel.Instance, builder => { }), "routePrefix");
}
public void AddRouteComponents_Throws_IfModelNull()
{
// Arrange
ODataOptions options = new ODataOptions();
// Act & Assert
ExceptionAssert.ThrowsArgumentNull(() => options.AddRouteComponents("odata", null, builder => { }), "model");
}
public void AddRouteComponents_Strips_RoutePrefix_Leading_And_Trailing_Slashes(string routePrefix, string expectedRoutePrefix)
{
// Arrange
ODataOptions options = new ODataOptions();
IEdmModel edmModel = EdmCoreModel.Instance;
// Act
options.AddRouteComponents(routePrefix, edmModel, services => services.AddSingleton <IODataFeature, ODataFeature>());
// Assert
Assert.False(options.RouteComponents.ContainsKey(routePrefix));
Assert.True(options.RouteComponents.ContainsKey(expectedRoutePrefix));
}
public void GetRouteServices_ReturnsCorrectServiceProvider()
{
// Arrange
ODataOptions options = new ODataOptions();
IEdmModel edmModel = EdmCoreModel.Instance;
// Act
options.AddRouteComponents("odata", edmModel);
// & Assert
IServiceProvider sp = options.GetRouteServices("odata");
Assert.NotNull(sp);
}
public void AddRouteComponents_WithoutOrWithPrefix_SetModel(string prefix)
{
// Arrange
ODataOptions options = new ODataOptions();
IEdmModel edmModel = EdmCoreModel.Instance;
// Act
if (prefix == null)
{
options.AddRouteComponents(edmModel);
}
else
{
options.AddRouteComponents(prefix, edmModel);
}
// Assert
KeyValuePair <string, (IEdmModel, IServiceProvider)> model = Assert.Single(options.RouteComponents);
Assert.Equal(prefix ?? String.Empty, model.Key);
Assert.Same(edmModel, model.Value.Item1);
Assert.NotNull(model.Value.Item2);
}
public void OnProvidersExecuted_AddODataRoutingSelector_WhenEntityRoutingConvention()
{
// Arrange
ODataOptions options = new ODataOptions();
options.AddRouteComponents("odata", _model);
IODataControllerActionConvention[] conventions = new IODataControllerActionConvention[]
{
new EntityRoutingConvention()
};
ODataRoutingApplicationModelProvider provider = CreateProvider(options, conventions);
Type controllerType = typeof(CustomersController);
ApplicationModelProviderContext providerContext = CreateProviderContext(controllerType);
// Act
provider.OnProvidersExecuted(providerContext);
// Assert
ControllerModel controller = Assert.Single(providerContext.Result.Controllers);
Assert.Equal(2, controller.Actions.Count);
Assert.Collection(controller.Actions,
e =>
{
// Get()
Assert.Equal("Get", e.ActionMethod.Name);
Assert.Empty(e.Parameters);
var selector = Assert.Single(e.Selectors);
Assert.Null(selector.AttributeRouteModel);
},
e =>
{
// Get(int key)
Assert.Equal("Get", e.ActionMethod.Name);
Assert.Single(e.Parameters);
Assert.Equal(2, e.Selectors.Count);
Assert.Equal(new[] { "/odata/Customers({key})", "/odata/Customers/{key}" }, e.Selectors.Select(s => s.AttributeRouteModel.Template));
});
}
public void AddRouteComponents_WithDependencyInjection_SetModelAndServices()
{
// Arrange
ODataOptions options = new ODataOptions();
IEdmModel edmModel = EdmCoreModel.Instance;
// Act
options.AddRouteComponents("odata", edmModel, services => services.AddSingleton <IODataFeature, ODataFeature>());
// Assert
KeyValuePair <string, (IEdmModel, IServiceProvider)> model = Assert.Single(options.RouteComponents);
Assert.Equal("odata", model.Key);
Assert.Same(edmModel, model.Value.Item1);
Assert.NotNull(model.Value.Item2);
IODataFeature actual = model.Value.Item2.GetService <IODataFeature>();
Assert.IsType <ODataFeature>(actual);
}
public void GetRouteServices_ReturnsCorrectServiceProvider_When_Leading_Or_Trailing_Slashes(string routePrefix)
{
// Arrange
ODataOptions options = new ODataOptions();
IEdmModel edmModel = EdmCoreModel.Instance;
// Act
options.AddRouteComponents(routePrefix, edmModel);
// & Assert
// can retrieve service provider using original routePrefix
IServiceProvider sp = options.GetRouteServices(routePrefix);
Assert.NotNull(sp);
// can retrieve service provider using sanitized routePrefix
string sanitizedRoutePrefix = "odata";
IServiceProvider sp2 = options.GetRouteServices(sanitizedRoutePrefix);
Assert.NotNull(sp2);
}
public void AddRouteComponents_WithBatchHandler_SetModel()
{
// Arrange
ODataOptions options = new ODataOptions();
IEdmModel edmModel = EdmCoreModel.Instance;
ODataBatchHandler handler = new Mock <ODataBatchHandler>().Object;
// Act
options.AddRouteComponents(edmModel, handler);
// Assert
KeyValuePair <string, (IEdmModel, IServiceProvider)> model = Assert.Single(options.RouteComponents);
Assert.Equal(String.Empty, model.Key);
Assert.Same(edmModel, model.Value.Item1);
Assert.NotNull(model.Value.Item2);
ODataBatchHandler actual = model.Value.Item2.GetService <ODataBatchHandler>();
Assert.Same(handler, actual);
}
public void OnProvidersExecuting_DoesNothing()
{
// Arrange
ODataOptions options = new ODataOptions();
options.AddRouteComponents("odata", _model);
IODataControllerActionConvention[] conventions = new IODataControllerActionConvention[]
{
new EntitySetRoutingConvention()
};
ODataRoutingApplicationModelProvider provider = CreateProvider(options, conventions);
Type controllerType = typeof(CustomersController);
ApplicationModelProviderContext providerContext = CreateProviderContext(controllerType);
// Act
provider.OnProvidersExecuting(providerContext);
// Assert
var controller = Assert.Single(providerContext.Result.Controllers);
Assert.Collection(controller.Actions,
e =>
{
// Get()
Assert.Equal("Get", e.ActionMethod.Name);
Assert.Empty(e.Parameters);
Assert.Single(e.Selectors);
},
e =>
{
// Get(int key)
Assert.Equal("Get", e.ActionMethod.Name);
Assert.Single(e.Parameters);
Assert.Single(e.Selectors);
});
}
public Task ApplyAsync(HttpContext httpContext, CandidateSet candidates)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
IODataFeature odataFeature = httpContext.ODataFeature();
if (odataFeature.Path != null)
{
// If we have the OData path setting, it means there's some Policy working.
// Let's skip this default OData matcher policy.
return(Task.CompletedTask);
}
for (var i = 0; i < candidates.Count; i++)
{
ref CandidateState candidate = ref candidates[i];
if (!candidates.IsValidCandidate(i))
{
continue;
}
IODataRoutingMetadata metadata = candidate.Endpoint.Metadata.OfType <IODataRoutingMetadata>().FirstOrDefault();
if (metadata == null)
{
continue;
}
// Get api-version query from HttpRequest?
QueryStringApiVersionReader reader = new QueryStringApiVersionReader("api-version");
string apiVersionStr = reader.Read(httpContext.Request);
if (apiVersionStr == null)
{
candidates.SetValidity(i, false);
continue;
}
ApiVersion apiVersion = ApiVersion.Parse(apiVersionStr);
IEdmModel model = GetEdmModel(apiVersion);
if (model == null)
{
candidates.SetValidity(i, false);
continue;
}
if (!IsApiVersionMatch(candidate.Endpoint.Metadata, apiVersion))
{
candidates.SetValidity(i, false);
continue;
}
ODataTemplateTranslateContext translatorContext
= new ODataTemplateTranslateContext(httpContext, candidate.Endpoint, candidate.Values, model);
try
{
ODataPath odataPath = _translator.Translate(metadata.Template, translatorContext);
if (odataPath != null)
{
odataFeature.RoutePrefix = metadata.Prefix;
odataFeature.Model = model;
odataFeature.Path = odataPath;
ODataOptions options = new ODataOptions();
UpdateQuerySetting(options);
options.AddRouteComponents(model);
odataFeature.Services = options.GetRouteServices(string.Empty);
MergeRouteValues(translatorContext.UpdatedValues, candidate.Values);
}
else
{
candidates.SetValidity(i, false);
}
}
catch
{
candidates.SetValidity(i, false);
}
}
