public static IEdmModel GetEdmModelV2()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Order>("Orders");
builder.Singleton <Order>("VipOrder");
builder.Singleton <Category>("Categories");
var functionWithComplexTypeParameter = builder.EntityType <Order>().Function("CanMoveToAddress").Returns <bool>();
functionWithComplexTypeParameter.Parameter <Address>("address");
// function with optional parameters
var functionWithOptional = builder.EntityType <Order>().Function("GetWholeSalary").ReturnsCollectionFromEntitySet <Order>("Orders");
functionWithOptional.Parameter <int>("minSalary");
functionWithOptional.Parameter <int>("maxSalary").Optional();
functionWithOptional.Parameter <int>("aveSalary").HasDefaultValue("129");
// Function 1
var function = builder.Function("RateByOrder");
function.Parameter <int>("order");
function.Returns <int>();
// Function 2
function = builder.Function("CalcByOrder");
function.Parameter <string>("name");
function.Parameter <int>("order");
function.Returns <int>();
return(builder.GetEdmModel());
}
private IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Customer>("FormatCustomers");
builder.Singleton<Customer>("This"); // Singleton
return builder.GetEdmModel();
}
private IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Singleton <EmployeeModel>("Boss");
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModelV1()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.Singleton <Customer>("Me");
var function = builder.Function("RateByOrder");
function.Parameter <int>("order");
function.Returns <int>();
var action = builder.EntityType <Customer>().Action("RateByName");
action.Parameter <string>("name");
action.Parameter <int>("age");
action.Returns <string>();
// bound action
ActionConfiguration boundAction = builder.EntityType <Customer>().Action("BoundAction");
boundAction.Parameter <int>("p1");
boundAction.Parameter <Address>("p2");
boundAction.Parameter <Color?>("color");
boundAction.CollectionParameter <string>("p3");
boundAction.CollectionParameter <Address>("p4");
boundAction.CollectionParameter <Color?>("colors");
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModelV2()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Order>("Orders");
builder.Singleton <Order>("VipOrder");
var functionWithComplexTypeParameter = builder.EntityType <Order>().Function("CanMoveToAddress").Returns <bool>();
functionWithComplexTypeParameter.Parameter <Address>("address");
// Function 1
var function = builder.Function("RateByOrder");
function.Parameter <int>("order");
function.Returns <int>();
// Function 2
function = builder.Function("CalcByOrder");
function.Parameter <string>("name");
function.Parameter <int>("order");
function.Returns <int>();
return(builder.GetEdmModel());
}
public IEdmModel RegisterEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
// Entity Sets
builder.EntitySet <Employee>("Employees");
// Singleton
builder.Singleton <Company>("Northwind");
// Action
builder.EntityType <Employee>()
.Action("UpdateNotes")
.Parameter <string>("Notes");
// Bound Funtion
builder.EntityType <Employee>().Collection
.Function("SellToHomeTown")
.ReturnsCollection <Employee>();
// Unbound Function
builder.Function("GetRandomRegion")
.Returns <Region>();
return(builder.GetEdmModel());
}
public void SelfLinksGenerationConvention_Uses_WithCast_IfDerivedTypeHasNavigationProperty_ForSingleton()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var myVehicle = builder.Singleton <Vehicle>("MyVehicle");
IEdmModel model = builder.GetEdmModel();
IEdmSingleton vehicleEdmSingleton = model.EntityContainer.FindSingleton("MyVehicle");
IEdmEntityType carType = model.AssertHasEntityType(typeof(Car));
HttpRequestMessage request = GetODataRequest(model);
NavigationSourceLinkBuilderAnnotation linkBuilder = model.GetNavigationSourceLinkBuilder(vehicleEdmSingleton);
var serializerContext = new ODataSerializerContext {
Model = model, NavigationSource = vehicleEdmSingleton, Url = request.GetUrlHelper()
};
var entityContext = new EntityInstanceContext(serializerContext, carType.AsReference(), new Car {
Model = 2014, Name = "Contoso"
});
// Act
EntitySelfLinks selfLinks = linkBuilder.BuildEntitySelfLinks(entityContext, ODataMetadataLevel.FullMetadata);
// Assert
Assert.Equal("http://localhost/MyVehicle", selfLinks.IdLink.ToString());
Assert.Equal("http://localhost/MyVehicle/System.Web.OData.Builder.TestModels.Car", selfLinks.EditLink.ToString());
}
public void NavigationLinksGenerationConvention_GeneratesLinksWithoutCast_ForDeclaredProperties_OnSingleton()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Singleton <Car>("Contoso");
builder.EntitySet <Manufacturer>("manufacturers");
IEdmModel model = builder.GetEdmModel();
IEdmSingleton vehicleEdmSingleton = model.EntityContainer.FindSingleton("Contoso");
IEdmEntityType carType = model.AssertHasEntityType(typeof(Car));
IEdmNavigationProperty carManufacturerProperty = carType.AssertHasNavigationProperty(model, "Manufacturer", typeof(CarManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne);
HttpConfiguration configuration = new HttpConfiguration();
string routeName = "Route";
configuration.MapODataServiceRoute(routeName, null, model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.SetConfiguration(configuration);
request.ODataProperties().RouteName = routeName;
NavigationSourceLinkBuilderAnnotation linkBuilder = model.GetNavigationSourceLinkBuilder(vehicleEdmSingleton);
var serializerContext = new ODataSerializerContext {
Model = model, NavigationSource = vehicleEdmSingleton, Url = request.GetUrlHelper()
};
var entityContext = new EntityInstanceContext(serializerContext, carType.AsReference(), new Car {
Model = 2014, Name = "Contoso2014"
});
Uri uri = linkBuilder.BuildNavigationLink(entityContext, carManufacturerProperty, ODataMetadataLevel.FullMetadata);
Assert.Equal("http://localhost/Contoso/Manufacturer", uri.AbsoluteUri);
}
public void SelfLinksGenerationConvention_Uses_WithoutCast_IfDerivedTypeDoesnotHaveNavigationProperty_ForSingleton()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var myMotorcycle = builder.Singleton <Motorcycle>("MyMotor");
IEdmModel model = builder.GetEdmModel();
IEdmSingleton vehicleEdmSingleton = model.EntityContainer.FindSingleton("MyMotor");
IEdmEntityType sportbikeType = model.AssertHasEntityType(typeof(SportBike));
HttpRequestMessage request = GetODataRequest(model);
NavigationSourceLinkBuilderAnnotation linkBuilder = model.GetNavigationSourceLinkBuilder(vehicleEdmSingleton);
var serializerContext = new ODataSerializerContext {
Model = model, NavigationSource = vehicleEdmSingleton, Url = request.GetUrlHelper()
};
var entityContext = new EntityInstanceContext(serializerContext, sportbikeType.AsReference(), new SportBike {
Model = 2014, Name = "Ninja"
});
// Act
EntitySelfLinks selfLinks = linkBuilder.BuildEntitySelfLinks(entityContext, ODataMetadataLevel.FullMetadata);
// Assert
Assert.Equal("http://localhost/MyMotor", selfLinks.IdLink.ToString());
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.Namespace = "Golf.Product";
builder.ContainerName = "Golf.ProductContainer";
builder.EntitySet <Catalog>("Catalogs");
builder.EntitySet <Category>("Categories");
builder.EntitySet <Family>("Families");
builder.EntitySet <Model.Product>("Products");
var areBestSellingProducts =
builder.EntityType <Model.Product>().Collection.Function("GetSets");
areBestSellingProducts.ReturnsCollectionFromEntitySet <Model.Product>("Products");
areBestSellingProducts.Namespace = "Golf.Product.Functions";
var updateAllClubsToRightHanded = builder.EntityType <Model.Product>().Collection.Action("SetAllProductsAsRightHanded");
updateAllClubsToRightHanded.Namespace = "Golf.Product.Actions";
builder.Singleton <Catalog>("US Catalog");
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration <ETagsCustomer> eTagsCustomersSet = builder.EntitySet <ETagsCustomer>("ETagsCustomers");
SingletonConfiguration <ETagsCustomer> eTagsCustomerSingleton = builder.Singleton <ETagsCustomer>("ETagsCustomer");
EntityTypeConfiguration <ETagsCustomer> eTagsCustomers = eTagsCustomersSet.EntityType;
eTagsCustomers.Property(c => c.Id).IsConcurrencyToken();
eTagsCustomers.Property(c => c.Name).IsConcurrencyToken();
eTagsCustomers.Property(c => c.BoolProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.ByteProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.CharProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.DecimalProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.DoubleProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.ShortProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.LongProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.SbyteProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.FloatProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.UshortProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.UintProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.UlongProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.GuidProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.DateTimeOffsetProperty).IsConcurrencyToken();
return(builder.GetEdmModel());
}
public static void Register(HttpConfiguration config)
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntityType <Product>();
builder.EntityType <Manufacturer>();
builder.EntitySet <Product>("Products");
builder.EntitySet <Manufacturer>("Manufacturers");
foreach (var manufacturer in _manufacturers)
{
builder.Singleton <Manufacturer>(manufacturer);
}
config.Count().Filter().OrderBy().Expand().Select().MaxTop(null);
var conventions = ODataRoutingConventions.CreateDefaultWithAttributeRouting("ODataRoute", config);
conventions.Insert(0, new ManufacturerRoutingConvention());
config.MapODataServiceRoute("ODataRoute",
null,
builder.GetEdmModel(),
new DefaultODataPathHandler(),
conventions
);
}
public void NavigationLinksGenerationConvention_GeneratesLinksWithoutCast_ForDeclaredProperties_OnSingleton()
{
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.Singleton <Car>("Contoso");
builder.EntitySet <Manufacturer>("manufacturers");
IEdmModel model = builder.GetEdmModel();
IEdmSingleton vehicleEdmSingleton = model.EntityContainer.FindSingleton("Contoso");
IEdmEntityType carType = model.AssertHasEntityType(typeof(Car));
IEdmNavigationProperty carManufacturerProperty = carType.AssertHasNavigationProperty(model, "Manufacturer", typeof(CarManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne);
var configuration = RoutingConfigurationFactory.Create();
string routeName = "Route";
configuration.MapODataServiceRoute(routeName, null, model);
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost", configuration, routeName);
NavigationSourceLinkBuilderAnnotation linkBuilder = model.GetNavigationSourceLinkBuilder(vehicleEdmSingleton);
linkBuilder.AddNavigationPropertyLinkBuilder(carManufacturerProperty, new NavigationLinkBuilder((context, property) => context.GenerateNavigationPropertyLink(property, includeCast: false), false));
var serializerContext = ODataSerializerContextFactory.Create(model, vehicleEdmSingleton, request);
var entityContext = new ResourceContext(serializerContext, carType.AsReference(), new Car {
Model = 2014, Name = "Contoso2014"
});
Uri uri = linkBuilder.BuildNavigationLink(entityContext, carManufacturerProperty, ODataMetadataLevel.MinimalMetadata);
Assert.Equal("http://localhost/Contoso/Manufacturer", uri.AbsoluteUri);
}
private static IEdmModel GetEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.Singleton<Corporation>("Oscorp");
builder.EntitySet<Subsidiary>("OscorpSubs");
return builder.GetEdmModel();
}
private static IEdmModel GetBinaryModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <RawValueEntity>("RawValue");
builder.Singleton <RawValueEntity>("RawSingletonValue");
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <DynamicCustomer>("DynamicCustomers");
builder.Singleton <DynamicSingleCustomer>("DynamicSingleCustomer");
return(builder.GetEdmModel());
}
private IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.EntitySet <Customer>("FormatCustomers");
builder.Singleton <Customer>("This"); // Singleton
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.Singleton<Customer>("Me");
builder.EntitySet<Order>("Orders");
builder.EntitySet<Customer>("Customers");
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel(WebRouteConfiguration configuration)
{
ODataConventionModelBuilder builder = configuration.CreateConventionModelBuilder();
builder.EntitySet <DynamicCustomer>("DynamicCustomers");
builder.Singleton <DynamicSingleCustomer>("DynamicSingleCustomer");
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.Singleton <Corporation>("Oscorp");
builder.EntitySet <Subsidiary>("OscorpSubs");
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.Singleton <Customer>("Me");
builder.EntitySet <Order>("Orders");
builder.EntitySet <Customer>("Customers");
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder model = new ODataConventionModelBuilder();
model.EntitySet <Customer>("Customers");
model.Singleton <Customer>("Me");
model.ComplexType <Address>();
return(model.GetEdmModel());
}
public static IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Address>("Address");
builder.EntitySet <AddressType>("AddressType");
builder.EntitySet <BusinessEntity>("BusinessEntity");
builder.EntitySet <BusinessEntityAddress>("BusinessEntityAddress");
builder.EntitySet <BusinessEntityContact>("BusinessEntityContact");
builder.EntitySet <ContactType>("ContactType");
builder.EntitySet <CountryRegion>("CountryRegion");
builder.EntitySet <EmailAddress>("EmailAddress");
builder.EntitySet <Password>("Password");
builder.EntitySet <Person>("Person");
builder.EntitySet <PersonPhone>("PersonPhone");
builder.EntitySet <PhoneNumberType>("PhoneNumberType");
builder.EntitySet <StateProvince>("StateProvince");
EntitySetConfiguration <EntityWithEnum> entitesWithEnum
= builder.EntitySet <EntityWithEnum>("EntityWithEnum");
FunctionConfiguration functionEntitesWithEnum
= entitesWithEnum.EntityType.Collection.Function("PersonSearchPerPhoneType");
functionEntitesWithEnum.Parameter <PhoneNumberTypeEnum>("PhoneNumberTypeEnum");
functionEntitesWithEnum.ReturnsCollectionFromEntitySet <EntityWithEnum>("EntityWithEnum");
EntitySetConfiguration <ContactType> contactType = builder.EntitySet <ContactType>("ContactType");
var actionY = contactType.EntityType.Action("ChangePersonStatus");
actionY.Parameter <string>("Level");
actionY.Returns <bool>();
var changePersonStatusAction = contactType.EntityType.Collection.Action("ChangePersonStatus");
changePersonStatusAction.Parameter <string>("Level");
changePersonStatusAction.Returns <bool>();
EntitySetConfiguration <Person> persons = builder.EntitySet <Person>("Person");
FunctionConfiguration myFirstFunction = persons.EntityType.Collection.Function("MyFirstFunction");
myFirstFunction.ReturnsCollectionFromEntitySet <Person>("Person");
builder.ContainerName = "SqliteContext";
builder.EntitySet <AnimalType>("AnimalType");
builder.EntitySet <EventData>("EventData");
builder.EntitySet <Player>("Player");
builder.EntityType <PlayerStats>();
SingletonConfiguration <SkillLevels> skillLevels = builder.Singleton <SkillLevels>("SkillLevels");
builder.EntityType <SkillLevel>();
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.Singleton <User>("Me").HasRequiredBinding(u => u.Pdp, "Pdps");
builder.EntitySet <Pdp>("Pdps").HasRequiredBinding(p => p.BLIS, "BLISs");
builder.EntitySet <BLISFacetDomain>("BLISs").HasManyBinding(b => b.Entries, "Facets");
return(builder.GetEdmModel());
}
public Task <IEdmModel> GetModelAsync(ModelContext context, CancellationToken cancellationToken)
{
var modelBuilder = new ODataConventionModelBuilder();
modelBuilder.Namespace = "Jetsons";
modelBuilder.EntitySet <Company>("competitors");
modelBuilder.Singleton <Company>("company");
return(Task.FromResult(modelBuilder.GetEdmModel()));
}
private static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration <ETagsCustomer> eTagsCustomersSet = builder.EntitySet <ETagsCustomer>("ETagsCustomers");
EntityTypeConfiguration <ETagsCustomer> eTagsCustomers = eTagsCustomersSet.EntityType;
SingletonConfiguration <ETagsCustomer> eTagsCustomerSingleton = builder.Singleton <ETagsCustomer>("ETagsCustomer");
eTagsCustomers.Property(c => c.Id).IsConcurrencyToken();
eTagsCustomers.Property(c => c.Name).IsConcurrencyToken();
return(builder.GetEdmModel());
}
public Task <IEdmModel> GetModelAsync(ModelContext context, CancellationToken cancellationToken)
{
var modelBuilder = new ODataConventionModelBuilder();
modelBuilder.Namespace = "Microsoft.OData.Service.Sample.TrippinInMemory.Models";
modelBuilder.EntitySet <Person>("People");
modelBuilder.EntitySet <Airline>("Airlines");
modelBuilder.EntitySet <Airport>("Airports");
modelBuilder.Singleton <Person>("Me");
return(Task.FromResult(modelBuilder.GetEdmModel()));
}
public void SelectAction_ReturnsNull_IfPostToNavigationPropertyBindingToNonCollectionValuedNavigationProperty(string path)
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Company>("Companies");
builder.Singleton <Company>("MyCompany");
builder.EntitySet <Employee>("Employees");
builder.Singleton <Employee>("Tony");
IEdmModel model = builder.GetEdmModel();
ODataPath odataPath = new DefaultODataPathHandler().Parse(model, "http://any/", path);
HttpControllerContext controllerContext = CreateControllerContext("Post");
var actionMap = GetMockActionMap();
// Act
string selectedAction = new NavigationRoutingConvention().SelectAction(odataPath, controllerContext, actionMap);
// Assert
Assert.Null(selectedAction);
}
public void SelectAction_ReturnsNull_IfPostToNavigationPropertyBindingToNonCollectionValuedNavigationProperty(string path)
{
// Arrange
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.EntitySet <Company>("Companies");
builder.Singleton <Company>("MyCompany");
builder.EntitySet <Employee>("Employees");
builder.Singleton <Employee>("Tony");
IEdmModel model = builder.GetEdmModel();
ODataPath odataPath = new DefaultODataPathHandler().Parse(model, "http://any/", path);
var request = RequestFactory.Create(HttpMethod.Post, "http://localhost/");
var emptyActionMap = SelectActionHelper.CreateActionMap();
// Act
string selectedAction = SelectActionHelper.SelectAction(new NavigationRoutingConvention(), odataPath, request, emptyActionMap);
// Assert
Assert.Null(selectedAction);
}
public static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Singleton <Trustframework>("trustframework");
builder.EntitySet <TrustframeworkPolicy>("trustframeworkPolicies");
AddRestoreAction(builder);
builder.EnableLowerCamelCase();
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.Namespace = "AirVinyl";
builder.ContainerName = "AirVinylContainer";
builder.EntitySet <Person>("People");
//builder.EntitySet<VinylRecord>("VinylRecords");
builder.EntitySet <RecordStore>("RecordStores");
var isHighRatedFunction = builder.EntityType <RecordStore>().Function("IsHighRated");
isHighRatedFunction.Returns <bool>();
isHighRatedFunction.Parameter <int>("minimumRating");
isHighRatedFunction.Namespace = "AirVinyl.Functions";
var areRatedByFunction = builder.EntityType <RecordStore>().Collection.Function("AreRatedBy");
areRatedByFunction.ReturnsCollectionFromEntitySet <RecordStore>("RecordStore");
areRatedByFunction.CollectionParameter <int>("personIds");
areRatedByFunction.Namespace = "AirVinyl.Functions";
var getHighRatedRecordStoresFunction = builder.Function("GetHighRatedRecordStores");
getHighRatedRecordStoresFunction.Parameter <int>("minimumRating");
getHighRatedRecordStoresFunction.ReturnsCollectionFromEntitySet <RecordStore>("RecordStores");
getHighRatedRecordStoresFunction.Namespace = "AirVinyl.Functions";
var rateAction = builder.EntityType <RecordStore>().Action("Rate");
rateAction.Returns <bool>();
rateAction.Parameter <int>("rating");
rateAction.Parameter <int>("personId");
rateAction.Namespace = "AirVinyl.Actions";
var removeRatingsAction = builder.EntityType <RecordStore>().Collection.Action("RemoveRatings");
removeRatingsAction.Returns <bool>();
removeRatingsAction.Parameter <int>("personId");
removeRatingsAction.Namespace = "AirVinyl.Actions";
var removeRecordStoreRatingsAction = builder.Action("RemoveRecordStoreRatings");
removeRecordStoreRatingsAction.Parameter <int>("personId");
removeRecordStoreRatingsAction.Namespace = "AirVinyl.Actions";
builder.Singleton <Person>("Tim");
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration <Partner> partnersConfiguration = builder.EntitySet <Partner>("Partners");
EntityTypeConfiguration <Partner> partnerConfiguration = partnersConfiguration.EntityType;
partnerConfiguration.Collection.Action("ResetDataSource");
// Singleton "Umbrella"
SingletonConfiguration <Company> umbrellaConfiguration = builder.Singleton <Company>("Umbrella");
//umbrellaConfiguration.EntityType.Action("ResetDataSource");
umbrellaConfiguration.EntityType.Function("GetPartnersCount").Returns <int>();
// Singleton "MonstersInc"
SingletonConfiguration <Company> monstersIncConfiguration = builder.Singleton <Company>("MonstersInc");
//monstersIncConfiguration.EntityType.Action("ResetDataSource");
monstersIncConfiguration.EntityType.Function("GetPartnersCount").Returns <int>();
builder.Namespace = typeof(Company).Namespace;
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModelV1()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.Singleton <Customer>("Me");
var function = builder.Function("RateByOrder");
function.Parameter <int>("order");
function.Returns <int>();
return(builder.GetEdmModel());
}
public static IEdmModel GetConventionModel(string singletonName)
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration<Partner> partnersConfiguration = builder.EntitySet<Partner>("Partners");
EntityTypeConfiguration<Partner> partnerConfiguration = partnersConfiguration.EntityType;
partnerConfiguration.Collection.Action("ResetDataSource");
SingletonConfiguration<Company> companyConfiguration = builder.Singleton<Company>(singletonName);
companyConfiguration.EntityType.Action("ResetDataSource");
companyConfiguration.EntityType.Function("GetPartnersCount").Returns<int>();
builder.Namespace = typeof (Company).Namespace;
return builder.GetEdmModel();
}
public static IEdmModel GetConventionModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var paymentInstrumentType = builder.EntityType<PaymentInstrument>();
builder.EntitySet<Account>("Accounts");
builder.Singleton<Account>("AnonymousAccount");
AddBoundActionsAndFunctions(builder);
builder.Namespace = typeof(Account).Namespace;
return builder.GetEdmModel();
}
public static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration<Employee> employeesConfiguration = builder.EntitySet<Employee>("Employees");
EntityTypeConfiguration<Employee> employeeConfiguration = employeesConfiguration.EntityType;
employeeConfiguration.Collection.Action("ResetDataSource");
SingletonConfiguration<Company> companyConfiguration = builder.Singleton<Company>("Umbrella");
companyConfiguration.EntityType.Action("ResetDataSource");
companyConfiguration.EntityType.Function("GetEmployeesCount").Returns<int>();
builder.Namespace = typeof(Company).Namespace;
return builder.GetEdmModel();
}
public void ODataMetadataSerializer_Works_ForSingleton()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Singleton<Customer>("Me");
builder.EntitySet<Order>("MyOrders");
IEdmModel model = builder.GetEdmModel();
ODataMetadataSerializer serializer = new ODataMetadataSerializer();
MemoryStream stream = new MemoryStream();
IODataResponseMessage message = new ODataMessageWrapper(stream);
ODataMessageWriterSettings settings = new ODataMessageWriterSettings();
// Act
serializer.WriteObject(model, typeof(IEdmModel), new ODataMessageWriter(message, settings, model), new ODataSerializerContext());
// Assert
stream.Seek(0, SeekOrigin.Begin);
string result = new StreamReader(stream).ReadToEnd();
Assert.Contains("<Singleton Name=\"Me\" Type=\"System.Web.OData.Formatter.Serialization.Models.Customer\">", result);
}
public void SelfLinksGenerationConvention_Uses_WithCast_IfDerivedTypeHasNavigationProperty_ForSingleton()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var myVehicle = builder.Singleton<Vehicle>("MyVehicle");
IEdmModel model = builder.GetEdmModel();
IEdmSingleton vehicleEdmSingleton = model.EntityContainer.FindSingleton("MyVehicle");
IEdmEntityType carType = model.AssertHasEntityType(typeof(Car));
HttpRequestMessage request = GetODataRequest(model);
NavigationSourceLinkBuilderAnnotation linkBuilder = model.GetNavigationSourceLinkBuilder(vehicleEdmSingleton);
var serializerContext = new ODataSerializerContext { Model = model, NavigationSource = vehicleEdmSingleton, Url = request.GetUrlHelper() };
var entityContext = new EntityInstanceContext(serializerContext, carType.AsReference(), new Car { Model = 2014, Name = "Contoso" });
// Act
EntitySelfLinks selfLinks = linkBuilder.BuildEntitySelfLinks(entityContext, ODataMetadataLevel.Default);
// Assert
Assert.Equal("http://localhost/MyVehicle/System.Web.OData.Builder.TestModels.Car", selfLinks.IdLink);
}
public void SelfLinksGenerationConvention_Uses_WithoutCast_IfDerivedTypeDoesnotHaveNavigationProperty_ForSingleton()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var myMotorcycle = builder.Singleton<Motorcycle>("MyMotor");
IEdmModel model = builder.GetEdmModel();
IEdmSingleton vehicleEdmSingleton = model.EntityContainer.FindSingleton("MyMotor");
IEdmEntityType sportbikeType = model.AssertHasEntityType(typeof(SportBike));
HttpRequestMessage request = GetODataRequest(model);
NavigationSourceLinkBuilderAnnotation linkBuilder = model.GetNavigationSourceLinkBuilder(vehicleEdmSingleton);
var serializerContext = new ODataSerializerContext { Model = model, NavigationSource = vehicleEdmSingleton, Url = request.GetUrlHelper() };
var entityContext = new EntityInstanceContext(serializerContext, sportbikeType.AsReference(), new SportBike { Model = 2014, Name = "Ninja" });
// Act
EntitySelfLinks selfLinks = linkBuilder.BuildEntitySelfLinks(entityContext, ODataMetadataLevel.Default);
// Assert
Assert.Equal("http://localhost/MyMotor", selfLinks.IdLink);
}
public void ModelBuilder_Products()
{
var modelBuilder = new ODataConventionModelBuilder();
modelBuilder.EntitySet<Product>("Products");
modelBuilder.Singleton<Product>("Book"); // singleton
var model = modelBuilder.GetEdmModel();
Assert.Equal(model.SchemaElements.OfType<IEdmSchemaType>().Count(), 3);
var product = model.AssertHasEntitySet(entitySetName: "Products", mappedEntityClrType: typeof(Product));
Assert.Equal(4, product.StructuralProperties().Count());
Assert.Equal(1, product.NavigationProperties().Count());
product.AssertHasKey(model, "ID", EdmPrimitiveTypeKind.Int32);
product.AssertHasPrimitiveProperty(model, "ID", EdmPrimitiveTypeKind.Int32, isNullable: false);
product.AssertHasPrimitiveProperty(model, "Name", EdmPrimitiveTypeKind.String, isNullable: true);
product.AssertHasPrimitiveProperty(model, "ReleaseDate", EdmPrimitiveTypeKind.DateTimeOffset, isNullable: true);
product.AssertHasComplexProperty(model, "Version", typeof(ProductVersion), isNullable: true);
product.AssertHasNavigationProperty(model, "Category", typeof(Category), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne);
var singletonProduct = model.AssertHasSingleton(singletonName: "Book", mappedEntityClrType: typeof(Product));
Assert.Same(singletonProduct, product);
var category = model.AssertHasEntityType(mappedEntityClrType: typeof(Category));
Assert.Equal(2, category.StructuralProperties().Count());
Assert.Equal(1, category.NavigationProperties().Count());
category.AssertHasKey(model, "ID", EdmPrimitiveTypeKind.String);
category.AssertHasPrimitiveProperty(model, "ID", EdmPrimitiveTypeKind.String, isNullable: false);
category.AssertHasPrimitiveProperty(model, "Name", EdmPrimitiveTypeKind.String, isNullable: true);
category.AssertHasNavigationProperty(model, "Products", typeof(Product), isNullable: false, multiplicity: EdmMultiplicity.Many);
var version = model.AssertHasComplexType(typeof(ProductVersion));
Assert.Equal(2, version.StructuralProperties().Count());
version.AssertHasPrimitiveProperty(model, "Major", EdmPrimitiveTypeKind.Int32, isNullable: false);
version.AssertHasPrimitiveProperty(model, "Minor", EdmPrimitiveTypeKind.Int32, isNullable: false);
}
public void ModelBuilder_BindsToTheClosestEntitySet_ForNavigationProperties()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Vehicle>("vehicles");
builder.Singleton<Vehicle>("MyVehicle");
builder.EntitySet<CarManufacturer>("car_manufacturers");
builder.EntitySet<MotorcycleManufacturer>("motorcycle_manufacturers");
IEdmModel model = builder.GetEdmModel();
model.AssertHasEntitySet("vehicles", typeof(Vehicle));
IEdmEntitySet vehicles = model.EntityContainer.FindEntitySet("vehicles");
model.AssertHasSingleton("MyVehicle", typeof(Vehicle));
IEdmSingleton singleton = model.EntityContainer.FindSingleton("MyVehicle");
IEdmEntityType car = model.AssertHasEntityType(typeof(Car));
IEdmEntityType motorcycle = model.AssertHasEntityType(typeof(Motorcycle));
IEdmEntityType sportbike = model.AssertHasEntityType(typeof(SportBike));
// for entity set
Assert.Equal(2, vehicles.NavigationPropertyBindings.Count());
vehicles.AssertHasNavigationTarget(
car.AssertHasNavigationProperty(model, "Manufacturer", typeof(CarManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne),
"car_manufacturers");
vehicles.AssertHasNavigationTarget(
motorcycle.AssertHasNavigationProperty(model, "Manufacturer", typeof(MotorcycleManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne),
"motorcycle_manufacturers");
vehicles.AssertHasNavigationTarget(
sportbike.AssertHasNavigationProperty(model, "Manufacturer", typeof(MotorcycleManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne),
"motorcycle_manufacturers");
// for singleton
Assert.Equal(2, singleton.NavigationPropertyBindings.Count());
singleton.AssertHasNavigationTarget(
car.AssertHasNavigationProperty(model, "Manufacturer", typeof(CarManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne),
"car_manufacturers");
singleton.AssertHasNavigationTarget(
motorcycle.AssertHasNavigationProperty(model, "Manufacturer", typeof(MotorcycleManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne),
"motorcycle_manufacturers");
singleton.AssertHasNavigationTarget(
sportbike.AssertHasNavigationProperty(model, "Manufacturer", typeof(MotorcycleManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne),
"motorcycle_manufacturers");
}
public void ModelBuilder_OnSingleton_BindsToAllEntitySets()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<CarManufacturer>("CarManfacturers");
builder.EntitySet<MotorcycleManufacturer>("MotoerCycleManfacturers");
builder.Singleton<Vehicle>("MyVehicle");
builder.Singleton<Car>("Contoso");
builder.Singleton<Motorcycle>("MyMotorcycle");
builder.Singleton<SportBike>("Gianta");
builder.Singleton<CarManufacturer>("Fordo");
builder.Singleton<MotorcycleManufacturer>("Yayaham");
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
// one for motorcycle manufacturer and one for car manufacturer
IEdmSingleton vehicle = model.EntityContainer.FindSingleton("MyVehicle");
Assert.Equal(2, vehicle.NavigationPropertyBindings.Count());
// one for car manufacturer
IEdmSingleton car = model.EntityContainer.FindSingleton("Contoso");
Assert.Equal(1, car.NavigationPropertyBindings.Count());
// one for motorcycle manufacturer
IEdmSingleton motorcycle = model.EntityContainer.FindSingleton("MyMotorcycle");
Assert.Equal(1, motorcycle.NavigationPropertyBindings.Count());
// one for motorcycle manufacturer
IEdmSingleton sportbike = model.EntityContainer.FindSingleton("Gianta");
Assert.Equal(1, sportbike.NavigationPropertyBindings.Count());
// no navigation
IEdmSingleton carManufacturer = model.EntityContainer.FindSingleton("Fordo");
Assert.Equal(0, carManufacturer.NavigationPropertyBindings.Count());
// no navigation
IEdmSingleton motorcycleManufacturer = model.EntityContainer.FindSingleton("Yayaham");
Assert.Equal(0, motorcycleManufacturer.NavigationPropertyBindings.Count());
}
public void ModelBuilder_OnSingleton_OnlyHasOneBinding_WithoutAnyEntitySets()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Singleton<Employee>("Gibs");
// Act
IEdmModel model = builder.GetEdmModel();
Assert.NotNull(model); // Guard
IEdmSingleton singleton = model.EntityContainer.FindSingleton("Gibs");
// Assert
Assert.NotNull(singleton);
Assert.Single(singleton.NavigationPropertyBindings);
Assert.Equal("Boss", singleton.NavigationPropertyBindings.Single().NavigationProperty.Name);
}
public void NavigationLinksGenerationConvention_GeneratesLinksWithoutCast_ForDeclaredProperties_OnSingleton()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Singleton<Car>("Contoso");
builder.EntitySet<Manufacturer>("manufacturers");
IEdmModel model = builder.GetEdmModel();
IEdmSingleton vehicleEdmSingleton = model.EntityContainer.FindSingleton("Contoso");
IEdmEntityType carType = model.AssertHasEntityType(typeof(Car));
IEdmNavigationProperty carManufacturerProperty = carType.AssertHasNavigationProperty(model, "Manufacturer", typeof(CarManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne);
HttpConfiguration configuration = new HttpConfiguration();
string routeName = "Route";
configuration.Routes.MapODataServiceRoute(routeName, null, model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.SetConfiguration(configuration);
request.ODataProperties().RouteName = routeName;
NavigationSourceLinkBuilderAnnotation linkBuilder = model.GetNavigationSourceLinkBuilder(vehicleEdmSingleton);
var serializerContext = new ODataSerializerContext { Model = model, NavigationSource = vehicleEdmSingleton, Url = request.GetUrlHelper() };
var entityContext = new EntityInstanceContext(serializerContext, carType.AsReference(), new Car { Model = 2014, Name = "Contoso2014" });
Uri uri = linkBuilder.BuildNavigationLink(entityContext, carManufacturerProperty, ODataMetadataLevel.Default);
Assert.Equal("http://localhost/Contoso/Manufacturer", uri.AbsoluteUri);
}
private static IEdmModel GetBinaryModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<RawValueEntity>("RawValue");
builder.Singleton<RawValueEntity>("RawSingletonValue");
return builder.GetEdmModel();
}
public void ModelBuilder_OnSingleton_HasBindings_WithEntitySet()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Singleton<Employee>("Gates");
builder.EntitySet<Customer>("Customers");
// Act
IEdmModel model = builder.GetEdmModel();
Assert.NotNull(model); // Guard
IEdmSingleton singleton = model.EntityContainer.FindSingleton("Gates");
Assert.NotNull(singleton); // Guard
// Assert
Assert.Equal(2, singleton.NavigationPropertyBindings.Count());
var employeeType = model.AssertHasEntityType(typeof(Employee));
var salePersonType = model.AssertHasEntityType(typeof(SalesPerson));
var customerType = model.AssertHasEntityType(typeof(Customer));
var bossProperty = employeeType.AssertHasNavigationProperty(model, "Boss", typeof(Employee), true, EdmMultiplicity.ZeroOrOne);
var customerProperty = salePersonType.AssertHasNavigationProperty(model, "Customers", typeof(Customer), true, EdmMultiplicity.Many);
Assert.Equal(EdmNavigationSourceKind.Singleton, singleton.FindNavigationTarget(bossProperty).NavigationSourceKind());
Assert.Equal(EdmNavigationSourceKind.EntitySet, singleton.FindNavigationTarget(customerProperty).NavigationSourceKind());
}
private static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<DynamicCustomer>("DynamicCustomers");
builder.Singleton<DynamicSingleCustomer>("DynamicSingleCustomer");
return builder.GetEdmModel();
}
private static IEdmModel SetupModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
// Different types of navigation sources and navigation properties.
builder.EntitySet<ETagCustomer>("Customers");
builder.EntitySet<ETagOrder>("Orders");
builder.EntityType<ETagSpecialOrder>().DerivesFrom<ETagOrder>();
builder.Singleton<ETagOrder>("BestOrder");
builder.EntitySet<ETagAddress>("Addresses");
// Entity without ETag to test that we only write entities with ETag.
builder.EntitySet<NonEtagEntity>("NonEtagEntity");
// Just a simplification for referencing the types in cast segments.
foreach (var type in builder.StructuralTypes)
{
type.Namespace = "Test";
}
IEdmModel model = builder.GetEdmModel();
return model;
}
private static IEdmModel BuildModel()
{
var mb = new ODataConventionModelBuilder();
mb.EntitySet<Customer>("Customers");
mb.EntitySet<Navigation>("Navigations");
mb.Singleton<Navigation>("BestNavigation");
mb.EntityType<SpecialNavigation>().DerivesFrom<Navigation>();
// This is just a convenience for unit testing.
foreach (StructuralTypeConfiguration structuralType in mb.StructuralTypes)
{
structuralType.Namespace = "Test";
}
return mb.GetEdmModel();
}
private static IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.ContainerName = "Container";
builder.Namespace = "org.odata";
// Action with no overloads
builder.EntitySet<Vehicle>("Vehicles").EntityType.Action("Drive");
builder.Singleton<Vehicle>("MyVehicle");
// Valid overloads of "Wash" bound to different entities
builder.EntityType<Motorcycle>().Action("Wash");
builder.EntityType<Car>().Action("Wash");
builder.EntityType<Car>().Action("NSAction").Namespace = "customize";
EdmModel model = (EdmModel)builder.GetEdmModel();
// Invalid overloads of action "Park". These two actions must have different names or binding types
// but differ only in that the second has a 'mood' parameter.
IEdmEntityType entityType = model.SchemaElements.OfType<IEdmEntityType>().Single(e => e.Name == "Car");
var park = new EdmAction(
"org.odata",
"Park",
returnType: null,
isBound: true,
entitySetPathExpression: null);
park.AddParameter("bindingParameter", new EdmEntityTypeReference(entityType, isNullable: false));
model.AddElement(park);
IEdmTypeReference stringType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, isNullable: true);
park = new EdmAction(
"org.odata",
"Park",
returnType: null,
isBound: true,
entitySetPathExpression: null);
park.AddParameter("bindingParameter", new EdmEntityTypeReference(entityType, isNullable: false));
park.AddParameter("mood", stringType);
model.AddElement(park);
return model;
}
private IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Singleton<EmployeeModel>("Boss");
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Namespace = "ODataSamples.WebApiService.Models";
builder.ContainerName = "DefaultContainer";
builder.EntitySet<Person>("People");
builder.EntitySet<Airport>("Airports");
builder.EntitySet<Airline>("Airlines");
builder.Singleton<Person>("Me");
// Customer - Order scenarios
builder.EntitySet<Customer>("Customers");
builder.EntitySet<Order>("Orders");
#region Unbound Function & Action
builder.Action("ResetDataSource");
//TODO : Double type has some issue.
var GetNearestAirportFun = builder.Function("GetNearestAirport");
GetNearestAirportFun.Parameter<double>("lat");
GetNearestAirportFun.Parameter<double>("lon");
GetNearestAirportFun.ReturnsFromEntitySet<Airport>("Airports");
#endregion
#region Person Function & Action
var personType = builder.EntityType<Person>();
personType.Function("GetFavoriteAirline")
.ReturnsFromEntitySet<Airline>("Airlines");
//TODO: Fix this issue, the return type can't be "Trip".
personType.Function("GetFriendsTrips")
.ReturnsCollectionFromEntitySet<Airline>("Airlines")
.Parameter<string>("userName");
var shareTripAction = personType.Action("ShareTrip");
shareTripAction.Parameter<string>("userName");
shareTripAction.Parameter<int>("tripId");
#endregion
#region Trip Function & Action
// TODO: The request will fail, should fix this issue.
// GET odata/People('russellwhyte')/Trips(1001)/ODataSamples.WebApiService.Models.GetInvolvedPeople()
var tripType = builder.EntityType<Trip>();
tripType.Function("GetInvolvedPeople")
.ReturnsCollectionFromEntitySet<Person>("People");
#endregion
#region Add Navigation Target
var edmModel = builder.GetEdmModel();
var peopleEntitySet = edmModel.EntityContainer.FindEntitySet("People") as EdmEntitySet;
var meSingleton = edmModel.EntityContainer.FindSingleton("Me") as EdmSingleton;
var flightEntityType = edmModel.FindDeclaredType("ODataSamples.WebApiService.Models.Flight") as EdmEntityType;
var propertyAriline = flightEntityType.FindProperty("Airline") as EdmNavigationProperty;
var propertyFrom = flightEntityType.FindProperty("From") as EdmNavigationProperty;
var propertyTo = flightEntityType.FindProperty("To") as EdmNavigationProperty;
var targetAirlines = edmModel.EntityContainer.FindEntitySet("Airlines");
var targetAirports = edmModel.EntityContainer.FindEntitySet("Airports");
peopleEntitySet.AddNavigationTarget(propertyAriline, targetAirlines);
peopleEntitySet.AddNavigationTarget(propertyFrom, targetAirports);
peopleEntitySet.AddNavigationTarget(propertyTo, targetAirports);
meSingleton.AddNavigationTarget(propertyAriline, targetAirlines);
meSingleton.AddNavigationTarget(propertyFrom, targetAirports);
meSingleton.AddNavigationTarget(propertyTo, targetAirports);
#endregion
return edmModel;
}
public void SelectAction_ReturnsNull_IfPostToNavigationPropertyBindingToNonCollectionValuedNavigationProperty(string path)
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Company>("Companies");
builder.Singleton<Company>("MyCompany");
builder.EntitySet<Employee>("Employees");
builder.Singleton<Employee>("Tony");
IEdmModel model = builder.GetEdmModel();
ODataPath odataPath = new DefaultODataPathHandler().Parse(model, "http://any/", path);
HttpControllerContext controllerContext = CreateControllerContext("Post");
var actionMap = GetMockActionMap();
// Act
string selectedAction = new NavigationRoutingConvention().SelectAction(odataPath, controllerContext, actionMap);
// Assert
Assert.Null(selectedAction);
}
