/// <summary>
///
/// </summary>
/// <param name="context"></param>
public virtual bool AppliesToAction(ODataControllerActionContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
Debug.Assert(context.Controller != null);
Debug.Assert(context.Action != null);
ActionModel action = context.Action;
if (action.Controller.ControllerType != typeof(MetadataController).GetTypeInfo())
{
return(false);
}
if (action.ActionMethod.Name == "GetMetadata")
{
ODataPathTemplate template = new ODataPathTemplate(MetadataSegmentTemplate.Instance);
action.AddSelector(context.Prefix, context.Model, template);
return(true);
}
if (action.ActionMethod.Name == "GetServiceDocument")
{
ODataPathTemplate template = new ODataPathTemplate();
action.AddSelector(context.Prefix, context.Model, template);
return(true);
}
return(false);
}
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);
}
public void ParseODataUriTemplate_ForCompositeKeys(string template)
{
// Arrange
// function with optional parameters
EdmEntityType person = new EdmEntityType("NS", "Person");
EdmStructuralProperty firstName = person.AddStructuralProperty("firstName", EdmPrimitiveTypeKind.String);
EdmStructuralProperty lastName = person.AddStructuralProperty("lastName", EdmPrimitiveTypeKind.String);
person.AddKeys(firstName, lastName);
_edmModel.AddElement(person);
EdmEntityContainer container = _edmModel.SchemaElements.OfType <EdmEntityContainer>().First();
container.AddEntitySet("People", person);
IODataPathTemplateParser parser = new DefaultODataPathTemplateParser();
// Act
ODataPathTemplate path = parser.Parse(_edmModel, template, null);
// Assert
Assert.NotNull(path);
Assert.Equal(2, path.Count);
KeySegmentTemplate keySegment = Assert.IsType <KeySegmentTemplate>(path[1]);
Assert.Equal(2, keySegment.KeyMappings.Count);
Assert.Equal(new[] { "firstName", "lastName" }, keySegment.KeyMappings.Keys);
Assert.Equal(new[] { "first", "last" }, keySegment.KeyMappings.Values);
}
public void GetTemplatesWorksForODataPathWithDollarRefOnSingleNavigation()
{
// Arrange
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
var entitySet = container.AddEntitySet("Customers", customer);
var navigation = customer.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
TargetMultiplicity = EdmMultiplicity.One,
Name = "SubCustomer",
Target = customer
});
ODataPathTemplate template = new ODataPathTemplate(
new EntitySetSegmentTemplate(entitySet),
KeySegmentTemplate.CreateKeySegment(customer, entitySet),
new NavigationLinkSegmentTemplate(navigation, entitySet));
// Act
IEnumerable <(string, string)> actual = template.GetTemplates();
// Assert
Assert.Equal(2, actual.Count());
Assert.Equal(new[]
{
"Customers({key})/SubCustomer/$ref",
"Customers/{key}/SubCustomer/$ref"
}, actual.Select(a => a.Item1));
}
/// <inheritdoc />
internal static SelectControllerResult SelectControllerImpl(ODataPath odataPath, IWebApiRequestMessage request,
IDictionary <ODataPathTemplate, IWebApiActionDescriptor> attributeMappings)
{
Dictionary <string, object> values = new Dictionary <string, object>();
foreach (KeyValuePair <ODataPathTemplate, IWebApiActionDescriptor> attributeMapping in attributeMappings)
{
ODataPathTemplate template = attributeMapping.Key;
IWebApiActionDescriptor action = attributeMapping.Value;
if (action.IsHttpMethodSupported(request.GetRequestMethodOrPreflightMethod()) && template.TryMatch(odataPath, values))
{
values["action"] = action.ActionName;
SelectControllerResult result = new SelectControllerResult(action.ControllerName, values);
return(result);
}
// It's possible that template.TryMatch inserted values in the values dict even if
// it did not match the current path. So let's clear the dict before trying
// the next template
values.Clear();
}
return(null);
}
public void AttributeMappingsIsInitialized_WithRightActionAndTemplate(Type controllerType,
string expectedPathTemplate, string expectedActionName)
{
// Arrange
HttpControllerDescriptor controller = new HttpControllerDescriptor(DependencyInjectionHelper.CreateConfigurationWithRootContainer(), "TestController",
controllerType);
ODataPathTemplate pathTemplate = new ODataPathTemplate();
Mock <IODataPathTemplateHandler> pathTemplateHandler = new Mock <IODataPathTemplateHandler>();
pathTemplateHandler
.Setup(p => p.ParseTemplate(expectedPathTemplate, controller.Configuration.GetODataRootContainer(RouteName)))
.Returns(pathTemplate)
.Verifiable();
AttributeRoutingConvention convention = new AttributeRoutingConvention(RouteName, new[] { controller }, pathTemplateHandler.Object);
// Act
convention.SelectController(new ODataPath(), new HttpRequestMessage());
// Assert
pathTemplateHandler.VerifyAll();
Assert.NotNull(convention.AttributeMappings);
Assert.Equal(expectedActionName, convention.AttributeMappings[pathTemplate].ActionName);
}
private ODataPathTemplate GetODataPathTemplate(string prefix, string pathTemplate, HttpActionDescriptor action)
{
if (prefix != null && !pathTemplate.StartsWith("/", StringComparison.Ordinal))
{
if (String.IsNullOrEmpty(pathTemplate))
{
pathTemplate = prefix;
}
else
{
pathTemplate = prefix + "/" + pathTemplate;
}
}
if (pathTemplate.StartsWith("/", StringComparison.Ordinal))
{
pathTemplate = pathTemplate.Substring(1);
}
ODataPathTemplate odataPathTemplate = null;
try
{
odataPathTemplate = ODataPathTemplateHandler.ParseTemplate(Model, pathTemplate);
}
catch (ODataException e)
{
throw Error.InvalidOperation(SRResources.InvalidODataRouteOnAction, pathTemplate, action.ActionName,
action.ControllerDescriptor.ControllerName, e.Message);
}
return(odataPathTemplate);
}
/// <inheritdoc />
public virtual bool AppliesToAction(ODataControllerActionContext context)
{
if (context == null)
{
throw Error.ArgumentNull(nameof(context));
}
Debug.Assert(context.Controller != null);
Debug.Assert(context.Action != null);
ActionModel action = context.Action;
string actionName = action.ActionMethod.Name;
// for ~$metadata
if (actionName == "GetMetadata")
{
ODataPathTemplate template = new ODataPathTemplate(MetadataSegmentTemplate.Instance);
action.AddSelector("Get", context.Prefix, context.Model, template, context.RouteOptions);
return(true);
}
// for ~/
if (actionName == "GetServiceDocument")
{
ODataPathTemplate template = new ODataPathTemplate();
action.AddSelector("Get", context.Prefix, context.Model, template, context.RouteOptions);
return(true);
}
return(false);
}
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);
}
private void ProcessHandleAll(string prefix, IEdmModel model, ControllerModel controllerModel)
{
foreach (var actionModel in controllerModel.Actions)
{
if (actionModel.ActionName == "GetNavigation")
{
ODataPathTemplate path = new ODataPathTemplate(
new EntitySetWithKeyTemplateSegment(),
new NavigationTemplateSegment());
actionModel.AddSelector("get", prefix, model, path);
}
else if (actionModel.ActionName == "GetName")
{
ODataPathTemplate path = new ODataPathTemplate(
new EntitySetWithKeyTemplateSegment(),
new StaticNameSegment());
actionModel.AddSelector("get", prefix, model, path);
}
else if (actionModel.ActionName == "Get")
{
if (actionModel.Parameters.Count == 1)
{
ODataPathTemplate path = new ODataPathTemplate(new EntitySetTemplateSegment());
actionModel.AddSelector("get", prefix, model, path);
}
else
{
ODataPathTemplate path = new ODataPathTemplate(new EntitySetWithKeyTemplateSegment());
actionModel.AddSelector("get", prefix, model, path);
}
}
}
}
public void ParseODataUriTemplate_ForFunctionImport(string template, int parameterCount)
{
// Arrange
EdmFunction getSalaray = new EdmFunction("NS", "GetWholeSalaryImport", IntType, isBound: false, entitySetPathExpression: null, isComposable: false);
getSalaray.AddParameter("minSalary", IntType);
getSalaray.AddOptionalParameter("maxSalary", IntType);
getSalaray.AddOptionalParameter("aveSalary", IntType, "129");
_edmModel.AddElement(getSalaray);
EdmEntityContainer container = _edmModel.SchemaElements.OfType <EdmEntityContainer>().First();
container.AddFunctionImport(getSalaray);
IODataPathTemplateParser parser = new DefaultODataPathTemplateParser();
// Act
ODataPathTemplate path = parser.Parse(_edmModel, template, null);
// Assert
Assert.NotNull(path);
ODataSegmentTemplate segmentTemplate = Assert.Single(path);
FunctionImportSegmentTemplate functionImportSegment = Assert.IsType <FunctionImportSegmentTemplate>(segmentTemplate);
if (parameterCount == 2)
{
Assert.Equal(new[] { "minSalary", "maxSalary" }, functionImportSegment.ParameterMappings.Keys);
Assert.Equal(new[] { "min", "max" }, functionImportSegment.ParameterMappings.Values);
}
else
{
Assert.Equal(new[] { "minSalary", "maxSalary", "aveSalary" }, functionImportSegment.ParameterMappings.Keys);
Assert.Equal(new[] { "min", "max", "ave" }, functionImportSegment.ParameterMappings.Values);
}
}
public void ParseODataUriTemplate_ForActionImport()
{
// Arrange
EdmAction setSalaray = new EdmAction("NS", "SetWholeSalaryImport", IntType, isBound: false, entitySetPathExpression: null);
setSalaray.AddParameter("minSalary", IntType);
setSalaray.AddOptionalParameter("maxSalary", IntType);
setSalaray.AddOptionalParameter("aveSalary", IntType, "129");
_edmModel.AddElement(setSalaray);
EdmEntityContainer container = _edmModel.SchemaElements.OfType <EdmEntityContainer>().First();
container.AddActionImport(setSalaray);
IODataPathTemplateParser parser = new DefaultODataPathTemplateParser();
// Act
ODataPathTemplate path = parser.Parse(_edmModel, "SetWholeSalaryImport", null);
// Assert
Assert.NotNull(path);
ODataSegmentTemplate segmentTemplate = Assert.Single(path);
ActionImportSegmentTemplate actionImportSegment = Assert.IsType <ActionImportSegmentTemplate>(segmentTemplate);
Assert.Equal("SetWholeSalaryImport", actionImportSegment.ActionImport.Name);
}
public void GetTemplatesWorks_ForEdmFunctionWithoutParameters(bool bound, string[] expects)
{
// Arrange
ODataPathTemplate template;
EdmFunction getSalaray = new EdmFunction("NS", "GetWholeSalary", IntType, isBound: bound, entitySetPathExpression: null, isComposable: false);
if (bound)
{
EdmEntityType customer = new EdmEntityType("NS", "Customer");
getSalaray.AddParameter("entityset", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(customer, false))));
template = new ODataPathTemplate(new FunctionSegmentTemplate(getSalaray, null));
}
else
{
EdmEntityContainer container = new EdmEntityContainer("NS", "Container");
template = new ODataPathTemplate(new FunctionImportSegmentTemplate(new EdmFunctionImport(container, "GetWholeSalary", getSalaray), null));
}
// Act
IEnumerable <string> items = template.GetTemplates();
// Assert
Assert.Equal(expects.Length, items.Count());
Assert.Equal(expects, items);
}
public void ParseODataUriTemplate_ForActions(string template)
{
// Arrange
// function with optional parameters
EdmAction setSalaray = new EdmAction("NS", "SetWholeSalary", IntType, isBound: true, entitySetPathExpression: null);
setSalaray.AddParameter("entityset", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(_customerType, false))));
setSalaray.AddParameter("minSalary", IntType);
setSalaray.AddOptionalParameter("maxSalary", IntType);
setSalaray.AddOptionalParameter("aveSalary", IntType, "129");
_edmModel.AddElement(setSalaray);
IODataPathTemplateParser parser = new DefaultODataPathTemplateParser();
MockServiceProvider sp = null;
if (!template.Contains("NS."))
{
sp = new MockServiceProvider(_edmModel);
}
// Act
ODataPathTemplate path = parser.Parse(_edmModel, template, sp);
// Assert
Assert.NotNull(path);
Assert.Equal(2, path.Count);
ActionSegmentTemplate actionSegment = Assert.IsType <ActionSegmentTemplate>(path[1]);
Assert.Equal("NS.SetWholeSalary", actionSegment.Action.FullName());
}
public void GetTemplatesWorks_ForEdmFunctionWithoutOptionalParameters(bool bound, string[] expects)
{
// Arrange
ODataPathTemplate template;
EdmFunction getSalaray = new EdmFunction("NS", "GetWholeSalary", IntType, isBound: bound, entitySetPathExpression: null, isComposable: false);
if (bound)
{
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
getSalaray.AddParameter("entityset", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(customer, false))));
}
getSalaray.AddParameter("minSalary", IntType);
getSalaray.AddParameter("maxSalary", IntType);
if (bound)
{
template = new ODataPathTemplate(new FunctionSegmentTemplate(getSalaray, null));
}
else
{
EdmEntityContainer container = new EdmEntityContainer("NS", "Container");
template = new ODataPathTemplate(new FunctionImportSegmentTemplate(new EdmFunctionImport(container, "GetWholeSalary", getSalaray), null));
}
// Act
IEnumerable <(string, string)> items = template.GetTemplates();
// Assert
Assert.Equal(expects.Length, items.Count());
Assert.Equal(expects, items.Select(a => a.Item1));
}
public bool AppliesToAction(ODataControllerActionContext context)
{
if (context.Action.ActionName == "Get")
{
var entitySet = context.Model.EntityContainer.FindEntitySet("Order Details");
var route = new EntitySetSegmentTemplate(entitySet);
var parameters = context.Action.ActionMethod.GetParameters();
if (parameters.Length == 0)
{
var path = new ODataPathTemplate(route);
context.Action.AddSelector("get", context.Prefix, context.Model, path, context.Options.RouteOptions);
return(true);
}
if (parameters.Length == 2 &&
parameters[0].Name == "keyOrderId" &&
parameters[1].Name == "keyProductId")
{
var keys = new Dictionary <string, string> {
{ "OrderID", "{keyOrderId}" }, { "ProductID", "{keyProductId}" }
};
var keyTemplate = new KeySegmentTemplate(keys, entitySet.EntityType(), entitySet);
var path = new ODataPathTemplate(route, keyTemplate);
context.Action.AddSelector("get", context.Prefix, context.Model, path, context.Options.RouteOptions);
return(true);
}
}
return(false);
}
public void AttributeMappingsIsInitialized_WithRightActionAndTemplate(Type controllerType,
string expectedPathTemplate, string expectedActionName)
{
// Arrange
CustomersModelWithInheritance model = new CustomersModelWithInheritance();
HttpControllerDescriptor controller = new HttpControllerDescriptor(new HttpConfiguration(), "TestController",
controllerType);
ODataPathTemplate pathTemplate = new ODataPathTemplate();
Mock <IODataPathTemplateHandler> pathTemplateHandler = new Mock <IODataPathTemplateHandler>();
pathTemplateHandler
.Setup(p => p.ParseTemplate(model.Model, expectedPathTemplate))
.Returns(pathTemplate)
.Verifiable();
AttributeRoutingConvention convention = new AttributeRoutingConvention(model.Model,
new[] { controller }, pathTemplateHandler.Object);
// Act
convention.SelectController(new ODataPath(), new HttpRequestMessage());
// Assert
pathTemplateHandler.VerifyAll();
Assert.NotNull(convention.AttributeMappings);
Assert.Equal(expectedActionName, convention.AttributeMappings[pathTemplate].ActionName);
}
public void TemplatePropertyWithOneSegment()
{
// Arrange
ODataPathTemplate path = new ODataPathTemplate(MetadataSegmentTemplate.Instance);
// Act & Assert
Assert.Equal("$metadata", path.Template);
}
public void TemplatePropertyWithNoSegments()
{
// Arrange
ODataPathTemplate path = new ODataPathTemplate();
// Act & Assert
Assert.Equal("", path.Template);
}
internal static bool ProcessNonNavigationProperty(string httpMethod, ODataControllerActionContext context,
ActionModel action,
IEdmNavigationSource navigationSource,
IEdmEntityType entityType, IEdmStructuredType castType)
{
// Action parameter should have a (string navigationProperty) parameter
if (!action.HasParameter <string>("navigationProperty"))
{
return(false);
}
// Let's only handle single-key convention, for composite key, use attribute routing or non-generic navigation.
bool hasRelatedKey = action.Parameters.Any(p => p.Name == "relatedKey"); // case sensitive?
bool hasRelatedId = action.Parameters.Any(p => p.Name == "relatedId");
IList <ODataSegmentTemplate> segments = new List <ODataSegmentTemplate>();
if (context.EntitySet != null)
{
segments.Add(new EntitySetSegmentTemplate(context.EntitySet));
segments.Add(KeySegmentTemplate.CreateKeySegment(entityType, context.EntitySet));
}
else
{
segments.Add(new SingletonSegmentTemplate(context.Singleton));
}
if (entityType != castType)
{
segments.Add(new CastSegmentTemplate(castType, entityType, navigationSource));
}
if (hasRelatedKey)
{
segments.Add(new NavigationLinkTemplateSegmentTemplate(entityType, navigationSource)
{
RelatedKey = "relatedKey"
});
}
else if (hasRelatedId)
{
segments.Add(new NavigationLinkTemplateSegmentTemplate(entityType, navigationSource)
{
RelatedKey = "relatedId"
});
}
else
{
segments.Add(new NavigationLinkTemplateSegmentTemplate(entityType, navigationSource));
}
ODataPathTemplate template = new ODataPathTemplate(segments);
action.AddSelector(httpMethod, context.Prefix, context.Model, template, context.Options?.RouteOptions);
return(true);
}
public void TranslateODataPathTemplate_ThrowsArgumentNull_Context()
{
// Arrange
DefaultODataTemplateTranslator translator = new DefaultODataTemplateTranslator();
ODataPathTemplate template = new ODataPathTemplate();
// Act & Assert
ExceptionAssert.ThrowsArgumentNull(() => translator.Translate(template, null), "context");
}
/// <inheritdoc />
public bool AppliesToAction(ODataControllerActionContext context)
{
if (context == null)
{
throw Error.ArgumentNull(nameof(context));
}
Debug.Assert(context.Singleton != null);
Debug.Assert(context.Action != null);
ActionModel action = context.Action;
string singletonName = context.Singleton.Name;
string actionMethodName = action.ActionName;
if (IsSupportedActionName(actionMethodName, singletonName, out string httpMethod))
{
// ~/Me
ODataPathTemplate template = new ODataPathTemplate(new SingletonSegmentTemplate(context.Singleton));
action.AddSelector(httpMethod, context.Prefix, context.Model, template, context.Options?.RouteOptions);
// processed
return(true);
}
// type cast
// GetFrom{EntityTypeName} or Get{SingletonName}From{EntityTypeName}
int index = actionMethodName.IndexOf("From", StringComparison.Ordinal);
if (index == -1)
{
return(false);
}
string actionPrefix = actionMethodName.Substring(0, index);
if (IsSupportedActionName(actionPrefix, singletonName, out httpMethod))
{
string castTypeName = actionMethodName.Substring(index + 4);
IEdmEntityType entityType = context.Singleton.EntityType();
// Shall we cast to base type and the type itself? I think yes.
IEdmStructuredType castType = entityType.FindTypeInInheritance(context.Model, castTypeName);
if (castType != null)
{
// ~/Me/Namespace.TypeCast
ODataPathTemplate template = new ODataPathTemplate(
new SingletonSegmentTemplate(context.Singleton),
new CastSegmentTemplate(castType, entityType, context.Singleton));
action.AddSelector(httpMethod, context.Prefix, context.Model, template, context.Options?.RouteOptions);
return(true);
}
}
return(false);
}
public void TranslateODataPathTemplate_ReturnsNull()
{
// Arrange
DefaultODataTemplateTranslator translator = new DefaultODataTemplateTranslator();
ODataPathTemplate path = new ODataPathTemplate(new MySegmentTemplate());
ODataTemplateTranslateContext context = new ODataTemplateTranslateContext();
// Act & Assert
Assert.Null(translator.Translate(path, context));
}
private static void AddSelector(string httpMethod, ODataControllerActionContext context, ActionModel action,
IEdmNavigationSource navigationSource,
IEdmStructuralProperty edmProperty,
IEdmType cast, IEdmEntityType declaringType, bool dollarValue, bool dollarCount)
{
IEdmEntitySet entitySet = navigationSource as IEdmEntitySet;
IEdmEntityType entityType = navigationSource.EntityType();
IList <ODataSegmentTemplate> segments = new List <ODataSegmentTemplate>();
if (entitySet != null)
{
segments.Add(new EntitySetSegmentTemplate(entitySet));
segments.Add(KeySegmentTemplate.CreateKeySegment(entityType, navigationSource));
}
else
{
segments.Add(new SingletonSegmentTemplate(navigationSource as IEdmSingleton));
}
if (declaringType != null && declaringType != entityType)
{
segments.Add(new CastSegmentTemplate(declaringType, entityType, navigationSource));
}
segments.Add(new PropertySegmentTemplate(edmProperty));
if (cast != null)
{
if (edmProperty.Type.IsCollection())
{
cast = new EdmCollectionType(cast.ToEdmTypeReference(edmProperty.Type.IsNullable));
}
// TODO: maybe create the collection type for the collection????
segments.Add(new CastSegmentTemplate(cast, edmProperty.Type.Definition, navigationSource));
}
if (dollarValue)
{
segments.Add(new ValueSegmentTemplate(edmProperty.Type.Definition));
}
if (dollarCount)
{
segments.Add(CountSegmentTemplate.Instance);
}
ODataPathTemplate template = new ODataPathTemplate(segments);
action.AddSelector(httpMethod.NormalizeHttpMethod(), context.Prefix, context.Model, template, context.Options?.RouteOptions);
}
public void ParseODataUriTemplateWorksAsExpected(string template, string expectedActionName)
{
// Arrange
IEdmModel model = GetEdmModel();
IODataPathTemplateParser parser = new DefaultODataPathTemplateParser();
// Act
ODataPathTemplate path = parser.Parse(model, template, null);
// Assert
Assert.NotNull(expectedActionName);
Assert.NotNull(path);
}
public void GetTemplatesReturnsCorrectWithMetadataSegment()
{
// Arrange
ODataPathTemplate path = new ODataPathTemplate(MetadataSegmentTemplate.Instance);
// Act
IEnumerable <string> templates = path.GetTemplates();
// Assert
var template = Assert.Single(templates);
Assert.Equal("$metadata", template);
}
public void GetTemplatesReturnsCorrectWithEmptySegments()
{
// Arrange
ODataPathTemplate path = new ODataPathTemplate();
// Act
IEnumerable <string> templates = path.GetTemplates();
// Assert
var template = Assert.Single(templates);
Assert.Equal("", template);
}
public void TemplatePropertyWithTwoSegments()
{
// Arrange
EdmEntityType entityType = new EdmEntityType("NS", "entity");
EdmEntityContainer container = new EdmEntityContainer("NS", "default");
EdmEntitySet entitySet = new EdmEntitySet(container, "set", entityType);
EdmAction action = new EdmAction("NS", "action", null, true, null);
ODataPathTemplate path = new ODataPathTemplate(new EntitySetSegmentTemplate(entitySet),
new ActionSegmentTemplate(action, null));
// Act & Assert
Assert.Equal("set/NS.action", path.Template);
}
public void Ctor_SetPropertiesCorrectly()
{
// Assert
IEdmModel model = EdmCoreModel.Instance;
ODataPathTemplate path = new ODataPathTemplate();
// & Act & Assert
ODataRoutingMetadata metadata = new ODataRoutingMetadata("prefix", model, path);
// Assert
Assert.Equal("prefix", metadata.Prefix);
Assert.Same(model, metadata.Model);
Assert.Same(path, metadata.Template);
}
public virtual bool AppliesToAction(ODataControllerActionContext context)
{
if (context.Action.ActionName != "GetTest")
{
return(false);
}
ODataPathTemplate path = new ODataPathTemplate(
new EntitySetTemplateSegment()
);
context.Action.AddSelector("Get", context.Prefix, context.Model, path);
return(true);
}
[InlineData(typeof(SingletonTestControllerWithPrefix), "VipCustomer/Orders", "GetVipCustomerOrdersWithPrefix")] // Singleton/Navigation
public void AttributeMappingsIsInitialized_WithRightActionAndTemplate(Type controllerType,
string expectedPathTemplate, string expectedActionName)
{
// Arrange
CustomersModelWithInheritance model = new CustomersModelWithInheritance();
HttpControllerDescriptor controller = new HttpControllerDescriptor(new HttpConfiguration(), "TestController",
controllerType);
ODataPathTemplate pathTemplate = new ODataPathTemplate();
Mock<IODataPathTemplateHandler> pathTemplateHandler = new Mock<IODataPathTemplateHandler>();
pathTemplateHandler
.Setup(p => p.ParseTemplate(model.Model, expectedPathTemplate))
.Returns(pathTemplate)
.Verifiable();
AttributeRoutingConvention convention = new AttributeRoutingConvention(model.Model,
new[] { controller }, pathTemplateHandler.Object);
// Act
convention.SelectController(new ODataPath(), new HttpRequestMessage());
// Assert
pathTemplateHandler.VerifyAll();
Assert.NotNull(convention.AttributeMappings);
Assert.Equal(expectedActionName, convention.AttributeMappings[pathTemplate].ActionName);
}
public void CtorTakingHttpConfiguration_InitializesAttributeMappings_OnFirstSelectControllerCall()
{
// Arrange
HttpConfiguration config = new HttpConfiguration();
CustomersModelWithInheritance model = new CustomersModelWithInheritance();
ODataPathTemplate pathTemplate = new ODataPathTemplate();
Mock<IODataPathTemplateHandler> pathTemplateHandler = new Mock<IODataPathTemplateHandler>();
pathTemplateHandler.Setup(p => p.ParseTemplate(model.Model, "Customers")).Returns(pathTemplate).Verifiable();
AttributeRoutingConvention convention = new AttributeRoutingConvention(model.Model, config, pathTemplateHandler.Object);
config.EnsureInitialized();
// Act
convention.SelectController(new ODataPath(), new HttpRequestMessage());
// Assert
pathTemplateHandler.VerifyAll();
Assert.NotNull(convention.AttributeMappings);
Assert.Equal("GetCustomers", convention.AttributeMappings[pathTemplate].ActionName);
}
