private static IEdmModel CreateModel()
{
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
EntitySetConfiguration <Entity> entities = builder.EntitySet <Entity>("entities");
builder.EntitySet <RelatedEntity>("related");
NavigationPropertyConfiguration entityToRelated =
entities.EntityType.HasOptional <RelatedEntity>((e) => e.Related);
entities.HasNavigationPropertyLink(entityToRelated, (a, b) => new Uri("aa:b"), false);
entities.HasOptionalBinding((e) => e.Related, "related");
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
ODataModelBuilder modelBuilder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
modelBuilder
.EntityType <DerivedTypeA>()
.DerivesFrom <BaseType>();
modelBuilder
.EntityType <DerivedTypeB>()
.DerivesFrom <BaseType>();
return(modelBuilder.GetEdmModel());
}
public void CanCreateAbstractEntityType()
{
var builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
builder
.EntityType <Vehicle>()
.Abstract();
var model = builder.GetEdmModel();
var edmCustomerType = model.FindType(typeof(Vehicle).FullName) as IEdmEntityType;
Assert.True(edmCustomerType != null);
Assert.True(edmCustomerType.IsAbstract);
}
public void GetEdmModel_SetsOptionalParameter()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType;
var functionBuilder = movie.Function("Watch");
functionBuilder.Parameter <int>("int").HasDefaultValue("42");
functionBuilder.Parameter <Nullable <int> >("nullableOfInt").HasDefaultValue("null");
functionBuilder.Parameter <string>("string").Optional();
functionBuilder.Parameter <decimal>("decimal");
functionBuilder.Parameter <double>("double").Required();
functionBuilder.Returns <int>();
// Act
IEdmModel model = builder.GetEdmModel();
//Assert
var function = Assert.Single(model.SchemaElements.OfType <IEdmFunction>());
// int
var parameter = function.FindParameter("int");
Assert.NotNull(parameter);
IEdmOptionalParameter optionalParameter = Assert.IsType <EdmOptionalParameter>(parameter);
Assert.Equal("42", optionalParameter.DefaultValueString);
// int?
parameter = function.FindParameter("nullableOfInt");
Assert.NotNull(parameter);
optionalParameter = Assert.IsType <EdmOptionalParameter>(parameter);
Assert.Equal("null", optionalParameter.DefaultValueString);
// string
parameter = function.FindParameter("string");
Assert.NotNull(parameter);
optionalParameter = Assert.IsType <EdmOptionalParameter>(parameter);
Assert.Null(optionalParameter.DefaultValueString);
// decimal & double
foreach (var name in new[] { "decimal", "double" })
{
parameter = function.FindParameter(name);
Assert.NotNull(parameter);
Assert.IsNotType <EdmOptionalParameter>(parameter);
IEdmOperationParameter operationParameter = Assert.IsType <EdmOperationParameter>(parameter);
}
}
public void CanConfigureSingleProperty_MultipleBindingPath_For_NavigationProperties_WithComplex_Multiple()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
builder
.EntitySet <BindingCustomer>("Customers")
.Binding
.HasSinglePath(c => c.Location)
.HasRequiredBinding(a => a.City, "Cities_A");
builder
.EntitySet <BindingCustomer>("Customers")
.Binding
.HasSinglePath(c => c.Address)
.HasRequiredBinding(a => a.City, "Cities_B");
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
var customers = model.EntityContainer.FindEntitySet("Customers");
Assert.NotNull(customers);
// "BindingCustomer" entity type
var customer = model.AssertHasEntityType(typeof(BindingCustomer));
Assert.Empty(customer.NavigationProperties());
// "BindingAddress" complex type
var address = model.AssertHasComplexType(typeof(BindingAddress));
var cityProperty = address.AssertHasNavigationProperty(model, "City", typeof(BindingCity), isNullable: false, multiplicity: EdmMultiplicity.One);
var bindings = customers.FindNavigationPropertyBindings(cityProperty).ToList();
Assert.Equal(2, bindings.Count());
Assert.Equal("City, City", String.Join(", ", bindings.Select(e => e.NavigationProperty.Name)));
Assert.NotNull(bindings.SingleOrDefault(c => c.Target.Name == "Cities_A"));
Assert.NotNull(bindings.SingleOrDefault(c => c.Target.Name == "Cities_B"));
Assert.NotNull(bindings.SingleOrDefault(c => c.Path.Path == "Location/City"));
Assert.NotNull(bindings.SingleOrDefault(c => c.Path.Path == "Address/City"));
// "BindingCity" entity type
model.AssertHasEntityType(typeof(BindingCity));
}
private static IEdmModel GetEdmModel()
{
if (_edmModel == null)
{
ODataModelBuilder modelBuilder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
modelBuilder.EntityType <DerivedTypeA>().DerivesFrom <BaseType>();
modelBuilder.EntityType <DerivedTypeB>().DerivesFrom <BaseType>();
modelBuilder.ComplexType <AComplexType>();
modelBuilder.EnumType <AEnumType>();
_edmModel = modelBuilder.GetEdmModel();
}
return(_edmModel);
}
public void ComplexCollections_Are_NotNullable_ByDefault()
{
var builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
var property =
builder
.EntityType <Customer>()
.CollectionProperty(c => c.Addresses);
var model = builder.GetEdmModel();
Assert.False(property.OptionalProperty);
var edmCustomer = model.AssertHasEntityType(typeof(Customer));
Assert.False(edmCustomer.FindProperty("Addresses").Type.IsNullable);
}
public void CanConfigureManyProperty_MultipleBindingPath_For_NavigationProperties_WithComplex()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
builder
.EntitySet <BindingCustomer>("Customers")
.Binding
.HasManyPath(c => c.Addresses)
.HasManyBinding(a => a.Cities, "Cities");
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
var customers = model.EntityContainer.FindEntitySet("Customers");
Assert.NotNull(customers);
// "BindingCustomer" entity type
var customer = model.AssertHasEntityType(typeof(BindingCustomer));
Assert.Empty(customer.NavigationProperties());
IEdmProperty addressesProperty = Assert.Single(customer.Properties());
Assert.Equal("Addresses", addressesProperty.Name);
Assert.Equal(EdmPropertyKind.Structural, addressesProperty.PropertyKind);
Assert.True(addressesProperty.Type.IsCollection());
// "BindingAddress" complex type
var address = model.AssertHasComplexType(typeof(BindingAddress));
var citiesProperty = address.AssertHasNavigationProperty(model, "Cities", typeof(BindingCity), isNullable: true, multiplicity: EdmMultiplicity.Many);
var bindings = customers.FindNavigationPropertyBindings(citiesProperty);
IEdmNavigationPropertyBinding binding = Assert.Single(bindings);
Assert.Equal("Cities", binding.NavigationProperty.Name);
Assert.Equal("Cities", binding.Target.Name);
Assert.Equal("Addresses/Cities", binding.Path.Path);
IEdmNavigationSource navSource = customers.FindNavigationTarget(citiesProperty, binding.Path);
Assert.Same(navSource, binding.Target);
// "BindingCity" entity type
model.AssertHasEntityType(typeof(BindingCity));
}
public void CreateEdmModel_WithSingleton_CanAddBindingPath_ToNavigationProperty_WithComplex()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
var motorcycle = builder.AddEntityType(typeof(Motorcycle));
var myMotor = builder.AddSingleton("MyMotor", motorcycle);
var manufacturer = builder.AddComplexType(typeof(MotorcycleManufacturer));
var address = builder.AddEntityType(typeof(ManufacturerAddress));
motorcycle.AddComplexProperty(typeof(Motorcycle).GetProperty("Manufacturer"));
var navProperty = manufacturer.AddNavigationProperty(typeof(Manufacturer).GetProperty("Address"), EdmMultiplicity.One);
var addresses = builder.AddEntitySet("Addresses", address);
myMotor.AddBinding(navProperty, addresses, new List <MemberInfo>
{
typeof(Motorcycle).GetProperty("Manufacturer"),
typeof(Manufacturer).GetProperty("Address")
});
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
var motorcycleEdmType = model.AssertHasEntityType(typeof(Motorcycle));
Assert.Empty(motorcycleEdmType.NavigationProperties());
var manufacturerEdmType = model.AssertHasComplexType(typeof(MotorcycleManufacturer));
var edmNavProperty = manufacturerEdmType.AssertHasNavigationProperty(model, "Address",
typeof(ManufacturerAddress), isNullable: false, multiplicity: EdmMultiplicity.One);
var myMotorSingleton = model.EntityContainer.FindSingleton("MyMotor");
Assert.NotNull(myMotorSingleton);
var bindings = myMotorSingleton.FindNavigationPropertyBindings(edmNavProperty);
var binding = Assert.Single(bindings);
Assert.Equal("Address", binding.NavigationProperty.Name);
Assert.Equal("Addresses", binding.Target.Name);
Assert.Equal("Manufacturer/Address", binding.Path.Path);
}
public void AddBinding_For_NavigationPropertyInHierarchy_DoesnotThrows()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock();
var vehicle = builder.AddEntityType(typeof(Vehicle));
var motorcycle = builder.AddEntityType(typeof(Motorcycle));
var manufacturer = builder.AddEntityType(typeof(MotorcycleManufacturer));
var manufacturers = builder.AddEntitySet("manufacturers", manufacturer);
var navProperty = motorcycle.AddNavigationProperty(typeof(Motorcycle).GetProperty("Manufacturer"), EdmMultiplicity.One);
var vehicles = builder.AddEntitySet("vehicles", vehicle);
// Act & Assert
ExceptionAssert.DoesNotThrow(() => vehicles.AddBinding(navProperty, manufacturers));
}
public void CanCreateMediaTypeEntity()
{
// Arrange
var builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
builder
.EntityType <Vehicle>()
.MediaType();
// Act
var model = builder.GetEdmModel();
var edmCustomerType = model.FindType(typeof(Vehicle).FullName) as IEdmEntityType;
// Assert
Assert.True(edmCustomerType != null);
Assert.True(edmCustomerType.HasStream);
}
private static IEdmModel CreateModelForFullMetadata(bool sameLinksForIdAndEdit, bool sameLinksForEditAndRead)
{
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
EntitySetConfiguration <MainEntity> mainSet = builder.EntitySet <MainEntity>("MainEntity");
Func <EntityInstanceContext <MainEntity>, Uri> idLinkFactory = (e) =>
CreateAbsoluteUri("/MainEntity/id/" + e.GetPropertyValue("Id").ToString());
mainSet.HasIdLink(idLinkFactory, followsConventions: true);
if (!sameLinksForIdAndEdit)
{
Func <EntityInstanceContext <MainEntity>, Uri> editLinkFactory =
(e) => CreateAbsoluteUri("/MainEntity/edit/" + e.GetPropertyValue("Id").ToString());
mainSet.HasEditLink(editLinkFactory, followsConventions: false);
}
if (!sameLinksForEditAndRead)
{
Func <EntityInstanceContext <MainEntity>, Uri> readLinkFactory =
(e) => CreateAbsoluteUri("/MainEntity/read/" + e.GetPropertyValue("Id").ToString());
mainSet.HasReadLink(readLinkFactory, followsConventions: false);
}
EntityTypeConfiguration <MainEntity> main = mainSet.EntityType;
main.HasKey <int>((e) => e.Id);
main.Property <short>((e) => e.Int16);
NavigationPropertyConfiguration mainToRelated = mainSet.EntityType.HasRequired((e) => e.Related);
main.Action("DoAlways").ReturnsCollectionFromEntitySet <MainEntity>("MainEntity").HasActionLink((c) =>
CreateAbsoluteUri("/MainEntity/DoAlways/" + c.GetPropertyValue("Id")),
followsConventions: true);
main.Action("DoSometimes").ReturnsCollectionFromEntitySet <MainEntity>(
"MainEntity").HasActionLink((c) =>
CreateAbsoluteUri("/MainEntity/DoSometimes/" + c.GetPropertyValue("Id")),
followsConventions: false);
mainSet.HasNavigationPropertyLink(mainToRelated, (c, p) => new Uri("/MainEntity/RelatedEntity/" +
c.GetPropertyValue("Id"), UriKind.Relative), followsConventions: true);
EntitySetConfiguration <RelatedEntity> related = builder.EntitySet <RelatedEntity>("RelatedEntity");
return(builder.GetEdmModel());
}
public void EntityKeyConvention_DoesnotFigureOutKeyPropertyIfIgnored()
{
MockType baseType =
new MockType("BaseType")
.Property(typeof(int), "ID", new NotMappedAttribute());
ODataConventionModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataConventionModelBuilder>();
builder.AddEntityType(baseType);
IEdmModel model = builder.GetEdmModel();
IEdmEntityType baseEntity = model.AssertHasEntityType(baseType);
Assert.Empty(baseEntity.Properties());
Assert.Empty(baseEntity.Key());
}
public void EnumPropertyLimitation()
{
// Arrange
var builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>().Add_Color_EnumType();
var entityTypeConfiguration = builder.EntityType <EntityTypeWithEnumTypePropertyTestModel>();
entityTypeConfiguration.EnumProperty(c => c.RequiredColor).IsOptional().IsConcurrencyToken();
// Act
var model = builder.GetEdmModel();
var complexType = model.SchemaElements.OfType <IEdmStructuredType>().Single();
IEdmStructuralProperty requiredColor = complexType.Properties().SingleOrDefault(p => p.Name == "RequiredColor") as IEdmStructuralProperty;
// Assert
Assert.NotNull(requiredColor);
Assert.True(requiredColor.Type.IsNullable);
Assert.Equal(EdmConcurrencyMode.Fixed, requiredColor.ConcurrencyMode);
}
public void GetEdmModel_SetsNullableIfParameterTypeIsReferenceType()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType;
var actionBuilder = movie.Action("Watch");
actionBuilder.Parameter <string>("string").OptionalParameter = false;
actionBuilder.Parameter <string>("nullaleString");
actionBuilder.Parameter <Address>("address").OptionalParameter = false;
actionBuilder.Parameter <Address>("nullableAddress");
actionBuilder.EntityParameter <Customer>("customer").OptionalParameter = false;
actionBuilder.EntityParameter <Customer>("nullableCustomer");
actionBuilder.CollectionParameter <Address>("addresses").OptionalParameter = false;
actionBuilder.CollectionParameter <Address>("nullableAddresses");
actionBuilder.CollectionEntityParameter <Customer>("customers").OptionalParameter = false;
actionBuilder.CollectionEntityParameter <Customer>("nullableCustomers");
// Act
IEdmModel model = builder.GetEdmModel();
//Assert
IEdmOperation action = Assert.Single(model.SchemaElements.OfType <IEdmAction>());
Assert.False(action.FindParameter("string").Type.IsNullable);
Assert.True(action.FindParameter("nullaleString").Type.IsNullable);
Assert.False(action.FindParameter("address").Type.IsNullable);
Assert.True(action.FindParameter("nullableAddress").Type.IsNullable);
Assert.False(action.FindParameter("customer").Type.IsNullable);
Assert.True(action.FindParameter("nullableCustomer").Type.IsNullable);
Assert.False(action.FindParameter("addresses").Type.IsNullable);
Assert.True(action.FindParameter("nullableAddresses").Type.IsNullable);
// Follow up: https://github.com/OData/odata.net/issues/98
// Assert.False(action.FindParameter("customers").Type.IsNullable);
Assert.True(action.FindParameter("nullableCustomers").Type.IsNullable);
}
public void CanCreateFunctionWithCollectionReturnTypeViaEntitySetPath()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
EntityTypeConfiguration <Customer> customer = builder.EntityType <Customer>();
EntityTypeConfiguration <Order> order = builder.EntityType <Order>();
customer.HasMany <Order>(c => c.Orders);
FunctionConfiguration getOrders = customer.Function("GetOrders").ReturnsCollectionViaEntitySetPath <Order>("bindingParameter/Orders");
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
IEdmFunction function = Assert.Single(model.SchemaElements.OfType <IEdmFunction>());
Assert.Equal(EdmExpressionKind.Path, function.EntitySetPath.ExpressionKind);
Assert.Equal("bindingParameter/Orders", string.Join("/", ((IEdmPathExpression)(function.EntitySetPath)).Path));
}
public void FailingToConfigureNavigationLinks_Results_In_ArgumentException_When_BuildingNavigationLink()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
builder.EntitySet <EntitySetLinkConfigurationTest_Product>("Products").HasManyBinding(p => p.Orders, "Orders");
var model = builder.GetEdmModel();
IEdmEntitySet products = model.EntityContainer.EntitySets().Single(s => s.Name == "Products");
IEdmNavigationProperty ordersProperty = products.EntityType().DeclaredNavigationProperties().Single();
var linkBuilder = model.GetNavigationSourceLinkBuilder(products);
// Act & Assert
Assert.ThrowsArgument(
() => linkBuilder.BuildNavigationLink(new EntityInstanceContext(), ordersProperty, ODataMetadataLevel.Default),
"navigationProperty",
"No NavigationLink factory was found for the navigation property 'Orders' from entity type 'System.Web.OData.Builder.EntitySetLinkConfigurationTest_Product' on entity set or singleton 'Products'. " +
"Try calling HasNavigationPropertyLink on the NavigationSourceConfiguration.");
}
public void CanCreateFunctionWithEntityReturnTypeViaEntitySetPath()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock();
EntityTypeConfiguration <Customer> customer = builder.EntityType <Customer>();
EntityTypeConfiguration <Order> order = builder.EntityType <Order>();
order.HasRequired <Customer>(o => o.Customer);
FunctionConfiguration getOrderCustomer = order.Function("GetOrderCustomer").ReturnsEntityViaEntitySetPath <Customer>("bindingParameter/Customer");
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
IEdmFunction function = Assert.Single(model.SchemaElements.OfType <IEdmFunction>());
Assert.Equal(EdmExpressionKind.Path, function.EntitySetPath.ExpressionKind);
Assert.Equal("bindingParameter/Customer", string.Join("/", ((IEdmPathExpression)(function.EntitySetPath)).Path));
}
public void GetEdmModel_SetReturnTypeAsNullable()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType;
movie.Function("Watch1").Returns <Address>();
movie.Function("Watch2").Returns <Address>().ReturnNullable = false;
// Act
IEdmModel model = builder.GetEdmModel();
//Assert
IEdmOperation function = model.SchemaElements.OfType <IEdmFunction>().First(e => e.Name == "Watch1");
Assert.True(function.ReturnType.IsNullable);
function = model.SchemaElements.OfType <IEdmFunction>().First(e => e.Name == "Watch2");
Assert.False(function.ReturnType.IsNullable);
}
private IEdmModel GetEdmModel(HttpConfiguration configuration)
{
ODataConventionModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataConventionModelBuilder>(configuration);
builder.EntitySet <ConventionCustomer>("ConventionCustomers");
builder.EntitySet <ConventionOrder>("ConventionOrders");
builder.ComplexType <ConventionPerson>();
builder.EntityType <ConventionCustomer>().ComplexProperty <ConventionAddress>(c => c.Address);
// Top level action import
ActionConfiguration createConventionCustomerById = builder.Action("CreateConventionCustomerById");
createConventionCustomerById.Parameter <int>("ID");
createConventionCustomerById.ReturnsFromEntitySet <ConventionCustomer>("ConventionCustomers");
// Top level action import without parameter and with a collection of primitive return type
ActionConfiguration topCollectionPrimitiveAction = builder.Action("CreateCollectionMessages");
topCollectionPrimitiveAction.ReturnsCollection <string>();
// Top level function import
FunctionConfiguration getAllCustomers = builder.Function("GetAllConventionCustomers");
getAllCustomers.ReturnsCollectionFromEntitySet <ConventionCustomer>("ConventionCustomers");
// Top level function import with one parameter
FunctionConfiguration getCustomersById = builder.Function("GetConventionCustomerById");
getCustomersById.IsComposable = true;
getCustomersById.Parameter <int>("CustomerId");
getCustomersById.ReturnsFromEntitySet <ConventionCustomer>("ConventionCustomers");
// Top level function import with two parameters
FunctionConfiguration getOrder = builder.Function("GetConventionOrderByCustomerIdAndOrderName");
getOrder.Parameter <int>("CustomerId");
getOrder.Parameter <string>("OrderName");
getOrder.ReturnsFromEntitySet <ConventionOrder>("ConventionOrders");
return(builder.GetEdmModel());
}
public void GetEdmModel_SetsDateTimeAsParameterType_WorksForDefaultConverter()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType;
var functionBuilder = movie.Function("DateTimeFunction");
functionBuilder.Parameter <DateTime>("dateTime");
functionBuilder.Parameter <DateTime?>("nullableDateTime");
functionBuilder.CollectionParameter <DateTime>("collectionDateTime");
functionBuilder.CollectionParameter <DateTime?>("nullableCollectionDateTime");
functionBuilder.Returns <DateTime>();
// Act
IEdmModel model = builder.GetEdmModel();
//Assert
IEdmOperation function = Assert.Single(model.SchemaElements.OfType <IEdmFunction>());
Assert.Equal("DateTimeFunction", function.Name);
Assert.Equal("Edm.DateTimeOffset", function.ReturnType.FullName());
Assert.False(function.ReturnType.IsNullable);
IEdmOperationParameter parameter = function.FindParameter("dateTime");
Assert.Equal("Edm.DateTimeOffset", parameter.Type.FullName());
Assert.False(parameter.Type.IsNullable);
parameter = function.FindParameter("nullableDateTime");
Assert.Equal("Edm.DateTimeOffset", parameter.Type.FullName());
Assert.True(parameter.Type.IsNullable);
parameter = function.FindParameter("collectionDateTime");
Assert.Equal("Collection(Edm.DateTimeOffset)", parameter.Type.FullName());
Assert.False(parameter.Type.IsNullable);
parameter = function.FindParameter("nullableCollectionDateTime");
Assert.Equal("Collection(Edm.DateTimeOffset)", parameter.Type.FullName());
Assert.True(parameter.Type.IsNullable);
}
public void ApplyTo_Does_Not_Replace_Original_OrderBy_With_Missing_Keys()
{
// Arrange
var model = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>()
.Add_Customers_No_Keys_EntitySet().GetEdmModel();
var message = new HttpRequestMessage(
HttpMethod.Get,
new Uri("http://server/service/Customers?$orderby=Name")
);
// Act
var queryOptions = new ODataQueryOptions(new ODataQueryContext(model, typeof(Customer)), message);
OrderByQueryOption originalOption = queryOptions.OrderBy;
ODataQuerySettings querySettings = new ODataQuerySettings();
IQueryable finalQuery = queryOptions.ApplyTo(new Customer[0].AsQueryable(), querySettings);
// Assert
Assert.ReferenceEquals(originalOption, queryOptions.OrderBy);
}
public void CreateEdmModel_WithSingleton()
{
// Arrange
var builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
var singleton = builder.Singleton <Company>("OsCorp");
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
Assert.NotNull(model);
var container = model.SchemaElements.OfType <IEdmEntityContainer>().SingleOrDefault();
Assert.NotNull(container);
var osCorp = container.FindSingleton("OsCorp");
Assert.NotNull(osCorp);
Assert.Equal("Company", osCorp.EntityType().Name);
}
public void GetEdmModel_SetsNullableIffParameterTypeIsNullable()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType;
var actionBuilder = movie.Action("Watch");
actionBuilder.Parameter <int>("int");
actionBuilder.Parameter <Nullable <int> >("nullableOfInt");
actionBuilder.Parameter <string>("string");
// Act
IEdmModel model = builder.GetEdmModel();
//Assert
IEdmOperation action = Assert.Single(model.SchemaElements.OfType <IEdmAction>());
Assert.False(action.FindParameter("int").Type.IsNullable);
Assert.True(action.FindParameter("nullableOfInt").Type.IsNullable);
Assert.True(action.FindParameter("string").Type.IsNullable);
}
public void ODataFormatter_CanReadDelta_WithAlias(string propertyName, string propertyNameAlias, string propertyJsonValue, object expectedValue)
{
// Arrange
ODataConventionModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataConventionModelBuilder>();
builder.ModelAliasingEnabled = true;
builder.EntityType <DeltaModelWithAlias>();
builder.EntitySet <DeltaModelWithAlias>("ignored");
IEdmModel model = builder.GetEdmModel();
IEnumerable <ODataMediaTypeFormatter> odataFormatters = ODataMediaTypeFormatters.Create();
Delta <DeltaModelWithAlias> delta;
using (HttpRequestMessage request = new HttpRequestMessage {
RequestUri = new Uri("http://localhost")
})
{
IEdmEntitySet entitySet = model.EntityContainer.EntitySets().Single();
HttpConfiguration config = new HttpConfiguration();
config.MapODataServiceRoute("default", "", model);
request.ODataProperties().RouteName = "default";
request.SetConfiguration(config);
request.ODataProperties().Model = model;
request.ODataProperties().Path = new ODataPath(new EntitySetPathSegment(entitySet));
IEnumerable <MediaTypeFormatter> perRequestFormatters = odataFormatters.Select(
(f) => f.GetPerRequestFormatterInstance(typeof(Delta <DeltaModelWithAlias>), request, null));
HttpContent content = new StringContent(String.Format("{{ '{0}' : {1} }}", propertyNameAlias, propertyJsonValue));
content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json");
// Act
delta = content.ReadAsAsync <Delta <DeltaModelWithAlias> >(perRequestFormatters).Result;
}
// Assert
Assert.Equal(delta.GetChangedPropertyNames(), new[] { propertyName });
object value;
Assert.True(delta.TryGetPropertyValue(propertyName, out value));
Assert.Equal(expectedValue, value);
}
public void BoundFunction_ForEnumTypeInODataModelBuilder()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>().Add_Color_EnumType();
EntityTypeConfiguration <EnumModel> entityTypeConfiguration = builder.EntityType <EnumModel>();
FunctionConfiguration functionConfiguration = entityTypeConfiguration.Function("BoundFunction");
functionConfiguration.Parameter <Color?>("Color");
functionConfiguration.Returns <Color>();
// Act & Assert
IEdmModel model = builder.GetEdmModel();
IEdmFunction function = model.FindDeclaredOperations("Default.BoundFunction").Single() as IEdmFunction;
IEdmTypeReference color = function.Parameters.Single(p => p.Name == "Color").Type;
IEdmTypeReference returnType = function.ReturnType;
IEdmEnumType colorType = model.SchemaElements.OfType <IEdmEnumType>().Single(e => e.Name == "Color");
Assert.True(color.IsNullable);
Assert.Same(colorType, color.Definition);
Assert.Same(colorType, returnType.Definition);
}
public void ApplyTo_Picks_DefaultOrder(string oDataQuery, Type elementType, string expectedExpression)
{
IQueryable query = Array.CreateInstance(elementType, 0).AsQueryable();
var modelBuilder = ODataModelBuilderMocks.GetModelBuilderMock <ODataConventionModelBuilder>();
modelBuilder.AddEntitySet("entityset", modelBuilder.AddEntityType(elementType));
var model = modelBuilder.GetEdmModel();
var message = new HttpRequestMessage(
HttpMethod.Get,
new Uri("http://server/service/entityset?" + oDataQuery)
);
var options = new ODataQueryOptions(new ODataQueryContext(model, elementType), message);
IQueryable finalQuery = options.ApplyTo(query);
string queryExpression = ExpressionStringBuilder.ToString(finalQuery.Expression);
queryExpression = queryExpression.Substring(queryExpression.IndexOf("OrderBy"));
Assert.Equal(queryExpression, expectedExpression);
}
public void ApplyTo_Builds_Default_OrderBy_No_Keys(string oDataQuery, bool ensureStableOrdering, string expectedExpression)
{
var model = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>().Add_Customer_No_Keys_EntityType().Add_Customers_No_Keys_EntitySet().GetEdmModel();
var message = new HttpRequestMessage(
HttpMethod.Get,
new Uri("http://server/service/Customers?" + oDataQuery)
);
var options = new ODataQueryOptions(new ODataQueryContext(model, typeof(Customer)), message);
ODataQuerySettings querySettings = new ODataQuerySettings
{
EnsureStableOrdering = ensureStableOrdering
};
IQueryable finalQuery = options.ApplyTo(new Customer[0].AsQueryable(), querySettings);
string queryExpression = ExpressionStringBuilder.ToString(finalQuery.Expression);
queryExpression = queryExpression.Substring(queryExpression.IndexOf("]") + 2);
Assert.Equal(queryExpression, expectedExpression);
}
public void CanAddBinding_For_DerivedNavigationProperty()
{
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
var vehicle = builder.AddEntityType(typeof(Vehicle));
var motorcycle = builder.AddEntityType(typeof(Motorcycle)).DerivesFrom(vehicle);
var manufacturer = builder.AddEntityType(typeof(MotorcycleManufacturer));
var manufacturers = builder.AddEntitySet("manufacturers", manufacturer);
var navProperty = motorcycle.AddNavigationProperty(typeof(Motorcycle).GetProperty("Manufacturer"), EdmMultiplicity.One);
var vehicles = builder.AddEntitySet("vehicles", vehicle);
vehicles.AddBinding(navProperty, manufacturers);
IEdmModel model = builder.GetEdmModel();
var motorcycleEdmType = model.AssertHasEntityType(typeof(Motorcycle));
var edmNavProperty = motorcycleEdmType.AssertHasNavigationProperty(model, "Manufacturer", typeof(MotorcycleManufacturer), isNullable: false, multiplicity: EdmMultiplicity.One);
Assert.Equal(
"manufacturers",
model.EntityContainer.FindEntitySet("vehicles").FindNavigationTarget(edmNavProperty).Name);
}
public void CanDefinePropertyOnDerivedType_NotPresentInBaseEdmType_ButPresentInBaseClrType()
{
var builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
builder
.EntityType <Motorcycle>()
.DerivesFrom <Vehicle>()
.Property(m => m.Model);
var model = builder.GetEdmModel();
var edmVehicle = model.AssertHasEntityType(typeof(Vehicle));
Assert.Null(edmVehicle.BaseEntityType());
Assert.Equal(0, edmVehicle.Properties().Count());
var edmMotorcycle = model.AssertHasEntityType(typeof(Motorcycle));
Assert.Equal(edmVehicle, edmMotorcycle.BaseEntityType());
Assert.Equal(1, edmMotorcycle.Properties().Count());
edmMotorcycle.AssertHasPrimitiveProperty(model, "Model", EdmPrimitiveTypeKind.Int32, isNullable: false);
}
