public void ComplexCollections_Are_NotNullable_ByDefault() { var builder = ODataModelBuilderMocks.GetModelBuilderMock(); var property = builder .EntityType <Customer>() .CollectionProperty(c => c.Addresses); var model = builder.GetEdmModel(); Assert.False(property.NullableProperty); var edmCustomer = model.AssertHasEntityType(typeof(Customer)); Assert.False(edmCustomer.FindProperty("Addresses").Type.IsNullable); }
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 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 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 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 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 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.Equal("Cities_A, Cities_B", String.Join(", ", bindings.Select(e => e.Target.Name))); Assert.Equal("Location/City, Address/City", String.Join(", ", bindings.Select(e => e.Path.Path))); // "BindingCity" entity type model.AssertHasEntityType(typeof(BindingCity)); }
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 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 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 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); }
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 async Task ODataFormatter_Can_Read_Delta(string propertyName, string propertyJsonValue, object expectedValue) { // Arrange ODataConventionModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataConventionModelBuilder>(); builder.EntityType <DeltaModel>(); builder.EntitySet <DeltaModel>("ignored"); IEdmModel model = builder.GetEdmModel(); IEnumerable <ODataMediaTypeFormatter> odataFormatters = ODataMediaTypeFormatters.Create(); Delta <DeltaModel> 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.SetConfiguration(config); request.EnableODataDependencyInjectionSupport("default"); request.ODataProperties().Path = new ODataPath(new EntitySetSegment(entitySet)); IEnumerable <MediaTypeFormatter> perRequestFormatters = odataFormatters.Select( (f) => f.GetPerRequestFormatterInstance(typeof(Delta <DeltaModel>), request, null)); HttpContent content = new StringContent(String.Format("{{ '{0}' : {1} }}", propertyName, propertyJsonValue)); content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json;IEEE754Compatible=true"); // Act delta = await content.ReadAsAsync <Delta <DeltaModel> >(perRequestFormatters); } // Assert Assert.Equal(new[] { propertyName }, delta.GetChangedPropertyNames()); object value; Assert.True(delta.TryGetPropertyValue(propertyName, out value)); Assert.Equal(expectedValue, value); }
public void BoundFunction_ForEnumWithLongUnderlyingTypeInODataModelBuilder() { // Arrange ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>(); builder.Add_LongEnum_EnumType(); EntityTypeConfiguration <EnumModel> entityTypeConfiguration = builder.EntityType <EnumModel>(); FunctionConfiguration functionConfiguration = entityTypeConfiguration.Function("BoundFunction"); functionConfiguration.Parameter <LongEnum>("LongEnum"); functionConfiguration.Returns <int>(); // Act & Assert IEdmModel model = builder.GetEdmModel(); IEdmFunction function = model.FindDeclaredOperations("Default.BoundFunction").Single() as IEdmFunction; IEdmTypeReference longEnumParameter = function.Parameters.Single(p => p.Name == "LongEnum").Type; IEdmEnumType longEnumType = model.SchemaElements.OfType <IEdmEnumType>().Single(e => e.Name == "LongEnum"); Assert.Same(longEnumType, longEnumParameter.Definition); Assert.Equal(EdmPrimitiveTypeKind.Int64, longEnumParameter.AsEnum().EnumDefinition().UnderlyingType.PrimitiveKind); }
public void CanAddBinding_For_DerivedNavigationProperty() { // Arrange 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); // Act IEdmModel model = builder.GetEdmModel(); // Assert var motorcycleEdmType = model.AssertHasEntityType(typeof(Motorcycle)); var edmNavProperty = motorcycleEdmType.AssertHasNavigationProperty(model, "Manufacturer", typeof(MotorcycleManufacturer), isNullable: false, multiplicity: EdmMultiplicity.One); IEdmEntitySet entitySet = model.EntityContainer.FindEntitySet("vehicles"); Assert.NotNull(entitySet); var target = entitySet.FindNavigationTarget(edmNavProperty); Assert.NotNull(target); Assert.Equal("manufacturers", target.Name); var binding = Assert.Single(entitySet.FindNavigationPropertyBindings(edmNavProperty)); Assert.Same(target, binding.Target); Assert.Equal("Microsoft.AspNet.OData.Test.Builder.TestModels.Motorcycle/Manufacturer", binding.Path.Path); }
public void CreateCollection_From_OrderByNode_Succeeds() { // Arrange ODataConventionModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataConventionModelBuilder>(); builder.EntitySet <SampleClass>("entityset"); IEdmModel model = builder.GetEdmModel(); IEdmEntityType sampleClassEntityType = model.SchemaElements.Single(t => t.Name == "SampleClass") as IEdmEntityType; Assert.NotNull(sampleClassEntityType); // Guard IEdmEntitySet entitySet = model.EntityContainer.FindEntitySet("entityset"); Assert.NotNull(entitySet); // Guard ODataQueryOptionParser parser = new ODataQueryOptionParser(model, sampleClassEntityType, entitySet, new Dictionary <string, string> { { "$orderby", "Property1 desc, Property2 asc" } }); OrderByClause orderbyNode = parser.ParseOrderBy(); // Act ICollection <OrderByNode> nodes = OrderByNode.CreateCollection(orderbyNode); // Assert Assert.False(nodes.OfType <OrderByItNode>().Any()); IEnumerable <OrderByPropertyNode> propertyNodes = nodes.OfType <OrderByPropertyNode>(); Assert.Equal(2, propertyNodes.Count()); Assert.Equal("Property1", propertyNodes.First().Property.Name); Assert.Equal(OrderByDirection.Descending, propertyNodes.First().Direction); Assert.Equal("Property1", propertyNodes.First().PropertyPath); Assert.Equal("Property2", propertyNodes.Last().Property.Name); Assert.Equal(OrderByDirection.Ascending, nodes.Last().Direction); Assert.Equal("Property2", propertyNodes.Last().PropertyPath); }
public void SingletonCanConfigureOptionalBinding_For_NavigationPropertiesInDerivedType() { // Arrange ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>(); builder.Singleton <Vehicle>("MyVehicle") .HasOptionalBinding((Car m) => m.Manufacturer, "manufacturers"); // Act IEdmModel model = builder.GetEdmModel(); // Assert var myVehicle = model.EntityContainer.FindSingleton("MyVehicle"); Assert.NotNull(myVehicle); var car = model.AssertHasEntityType(typeof(Car)); var carManufacturerProperty = car.AssertHasNavigationProperty(model, "Manufacturer", typeof(CarManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne); var carManufacturerPropertyTarget = myVehicle.FindNavigationTarget(carManufacturerProperty); Assert.NotNull(carManufacturerPropertyTarget); Assert.Equal("manufacturers", carManufacturerPropertyTarget.Name); }