Example #1
0
        public void HasConstraint_ThrowsArgumentNull_ForNullDependentPropertyInfo()
        {
            // Arrange
            NavigationPropertyConfiguration navigationProperty =
                new NavigationPropertyConfiguration(new MockPropertyInfo(), EdmMultiplicity.ZeroOrOne,
                                                    new EntityTypeConfiguration());

            // Act & Assert
            ExceptionAssert.ThrowsArgumentNull(
                () => navigationProperty.HasConstraint(dependentPropertyInfo: null,
                                                       principalPropertyInfo: new MockPropertyInfo()),
                "dependentPropertyInfo");
        }
        public void GetTargetEntitySet_Returns_Null_IfNoMatchingTargetEntitySet()
        {
            // Arrange
            ODataModelBuilder               builder            = new ODataModelBuilder();
            EntityTypeConfiguration         motorcycle         = builder.AddEntity(typeof(Motorcycle));
            NavigationPropertyConfiguration navigationProperty = motorcycle.AddNavigationProperty(typeof(Motorcycle).GetProperty("Manufacturer"), EdmMultiplicity.ZeroOrOne);

            // Act
            EntitySetConfiguration targetEntitySet = AssociationSetDiscoveryConvention.GetTargetEntitySet(navigationProperty, builder);

            // Assert
            Assert.Null(targetEntitySet);
        }
Example #3
0
        public void CascadeOnDelete_ModifiesOnDelete_WithParameter()
        {
            // Arrange
            NavigationPropertyConfiguration navigationProperty =
                new NavigationPropertyConfiguration(new MockPropertyInfo(), EdmMultiplicity.ZeroOrOne,
                                                    new EntityTypeConfiguration());

            // Act
            navigationProperty.CascadeOnDelete(cascade: false);

            // Assert
            Assert.Equal(EdmOnDeleteAction.None, navigationProperty.OnDeleteAction);
        }
Example #4
0
        private static IEdmModel CreateModel()
        {
            ODataModelBuilder builder = new 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);

            return(builder.GetEdmModel());
        }
        private static void GetModel(out IEdmModel model, out IEdmEntityTypeReference reference)
        {
            ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataConventionModelBuilder>();
            EntityTypeConfiguration <TestEntity> entity = builder.EntityType <TestEntity>();

            entity.Namespace = "Test";
            entity.Name      = "Entity";
            NavigationPropertyConfiguration property = entity.HasOptional(p => p.Property);

            property.Name = "Alias";
            model         = builder.GetEdmModel();
            reference     = new EdmEntityTypeReference((IEdmEntityType)model.FindType("Test.Entity"), false);
        }
        public void HasManyPath_AddBindindPath_Derived(bool contained)
        {
            // Assert
            ODataModelBuilder builder = new ODataModelBuilder();
            var customerType          = builder.EntityType <BindingCustomer>();
            var navigationSource      = builder.EntitySet <BindingCustomer>("Customers");

            StructuralTypeConfiguration addressType = builder.StructuralTypes.FirstOrDefault(c => c.Name == "BindingAddress");

            Assert.Null(addressType);              // Guard
            Assert.Empty(customerType.Properties); // Guard

            // Act
            var binding    = new BindingPathConfiguration <BindingCustomer>(builder, customerType, navigationSource.Configuration);
            var newBinding = binding.HasManyPath((BindingVipCustomer v) => v.VipAddresses, contained);

            // Assert
            addressType = builder.StructuralTypes.FirstOrDefault(c => c.Name == "BindingAddress");
            Assert.NotNull(addressType);
            Assert.Empty(customerType.Properties);

            StructuralTypeConfiguration vipCustomerType = builder.StructuralTypes.FirstOrDefault(c => c.Name == "BindingVipCustomer");

            Assert.NotNull(vipCustomerType);
            var vipAddressesProperty = Assert.Single(vipCustomerType.Properties);

            Assert.Equal("VipAddresses", vipAddressesProperty.Name);

            if (contained)
            {
                Assert.Equal(EdmTypeKind.Entity, addressType.Kind);
                Assert.Equal(PropertyKind.Navigation, vipAddressesProperty.Kind);
                NavigationPropertyConfiguration navigationProperty = Assert.IsType <NavigationPropertyConfiguration>(vipAddressesProperty);
                Assert.Equal(EdmMultiplicity.Many, navigationProperty.Multiplicity);
                Assert.True(navigationProperty.ContainsTarget);
            }
            else
            {
                Assert.Equal(EdmTypeKind.Complex, addressType.Kind);
                Assert.Equal(PropertyKind.Collection, vipAddressesProperty.Kind);
                CollectionPropertyConfiguration collection = Assert.IsType <CollectionPropertyConfiguration>(vipAddressesProperty);
                Assert.Equal(typeof(BindingAddress), collection.ElementType);
            }

            // different bindings
            Assert.NotSame(binding, newBinding);
            Assert.Equal("", binding.BindingPath);

            Assert.IsType <BindingPathConfiguration <BindingAddress> >(newBinding);
            Assert.Equal("Microsoft.AspNet.OData.Test.Formatter.BindingVipCustomer/VipAddresses", newBinding.BindingPath);
        }
        internal NavigationPropertyConfiguration Navigation(PropertyInfo propertyInfo)
        {
            DebugCheck.NotNull(propertyInfo);

            NavigationPropertyConfiguration navigationPropertyConfiguration;

            if (!_navigationPropertyConfigurations.TryGetValue(propertyInfo, out navigationPropertyConfiguration))
            {
                _navigationPropertyConfigurations.Add(
                    propertyInfo, navigationPropertyConfiguration = new NavigationPropertyConfiguration(propertyInfo));
            }

            return(navigationPropertyConfiguration);
        }
        public void Cloning_a_navigation_property_configuration_clones_its_function_mapping_configuration()
        {
            var navProp       = new MockPropertyInfo(typeof(AType1), "P1");
            var configuration = new NavigationPropertyConfiguration(navProp);

            var functionsConfiguration = new ModificationStoredProceduresConfiguration();

            configuration.ModificationStoredProceduresConfiguration = functionsConfiguration;

            var clone = configuration.Clone();

            Assert.NotSame(configuration.ModificationStoredProceduresConfiguration, clone.ModificationStoredProceduresConfiguration);
            Assert.True(configuration.ModificationStoredProceduresConfiguration.IsCompatibleWith(clone.ModificationStoredProceduresConfiguration));
        }
Example #9
0
        public void Apply_should_ignore_when_end_kind_is_collection()
        {
            var propertyInfo = typeof(RequiredAttributeEntity).GetDeclaredProperty("Navigations");
            var associationConfiguration
                = new NavigationPropertyConfiguration(propertyInfo)
                {
                RelationshipMultiplicity = RelationshipMultiplicity.Many
                };

            new RequiredNavigationPropertyAttributeConvention()
            .ApplyPropertyConfiguration(propertyInfo, () => associationConfiguration, new ModelConfiguration());

            Assert.Equal(RelationshipMultiplicity.Many, associationConfiguration.RelationshipMultiplicity);
        }
        public void GetTargetNavigationSource_Returns_TargetEntitySet()
        {
            // Arrange
            ODataModelBuilder               builder            = new ODataModelBuilder();
            EntityTypeConfiguration         motorcycle         = builder.AddEntityType(typeof(Motorcycle));
            EntityTypeConfiguration         manufacturer       = builder.AddEntityType(typeof(MotorcycleManufacturer));
            NavigationPropertyConfiguration navigationProperty = motorcycle.AddNavigationProperty(typeof(Motorcycle).GetProperty("Manufacturer"), EdmMultiplicity.ZeroOrOne);
            EntitySetConfiguration          manufacturers      = builder.AddEntitySet("manufacturers", manufacturer);

            // Act
            NavigationSourceConfiguration targetNavigationSource = AssociationSetDiscoveryConvention.GetTargetNavigationSource(navigationProperty, builder);

            // Assert
            Assert.Same(manufacturers, targetNavigationSource);
        }
        public void GetTargetNavigationSource_Returns_TargetSingleton()
        {
            // Arrange
            ODataModelBuilder               builder            = new ODataModelBuilder();
            EntityTypeConfiguration         companyType        = builder.AddEntityType(typeof(Company));
            EntityTypeConfiguration         employeeType       = builder.AddEntityType(typeof(Employee));
            NavigationPropertyConfiguration navigationProperty = companyType.AddNavigationProperty(typeof(Company).GetProperty("CEO"), EdmMultiplicity.One);
            SingletonConfiguration          gazes = builder.AddSingleton("Gazes", employeeType);

            // Act
            NavigationSourceConfiguration targetNavigationSource = AssociationSetDiscoveryConvention.GetTargetNavigationSource(navigationProperty, builder);

            // Assert
            Assert.Same(gazes, targetNavigationSource);
        }
Example #12
0
        public void NonContained_ModifiesContainsTargetToFalse()
        {
            // Arrange
            NavigationPropertyConfiguration navigationProperty =
                new NavigationPropertyConfiguration(
                    new MockPropertyInfo(),
                    EdmMultiplicity.ZeroOrOne,
                    new EntityTypeConfiguration());

            // Act
            navigationProperty.Contained().NonContained();

            // Assert
            Assert.False(navigationProperty.ContainsTarget);
        }
        // Get the default target entity set for this navigation property.
        internal static IEntitySetConfiguration GetTargetEntitySet(NavigationPropertyConfiguration navigationProperty, ODataModelBuilder model)
        {
            IEntityTypeConfiguration targetEntityType =
                model
                .StructuralTypes
                .OfType<IEntityTypeConfiguration>()
                .Where(e => e.ClrType == navigationProperty.RelatedClrType).SingleOrDefault();

            if (targetEntityType == null)
            {
                throw Error.InvalidOperation(SRResources.TargetEntityTypeMissing, navigationProperty.Name, navigationProperty.PropertyInfo.ReflectedType.FullName);
            }

            return GetDefaultEntitySet(targetEntityType, model);
        }
        // Get the default target entity set for this navigation property.
        internal static EntitySetConfiguration GetTargetEntitySet(NavigationPropertyConfiguration navigationProperty, ODataModelBuilder model)
        {
            EntityTypeConfiguration targetEntityType =
                model
                .StructuralTypes
                .OfType <EntityTypeConfiguration>()
                .Where(e => e.ClrType == navigationProperty.RelatedClrType).SingleOrDefault();

            if (targetEntityType == null)
            {
                throw Error.InvalidOperation(SRResources.TargetEntityTypeMissing, navigationProperty.Name, navigationProperty.PropertyInfo.ReflectedType.FullName);
            }

            return(GetDefaultEntitySet(targetEntityType, model));
        }
        public void Cloning_a_navigation_property_configuration_clones_its_association_mapping_configuration()
        {
            var navProp       = new MockPropertyInfo(typeof(AType1), "P1");
            var configuration = new NavigationPropertyConfiguration(navProp);

            var mappingConfiguration = new ForeignKeyAssociationMappingConfiguration();

            mappingConfiguration.MapKey("C1");
            configuration.AssociationMappingConfiguration = mappingConfiguration;

            var clone = configuration.Clone();

            Assert.NotSame(configuration.AssociationMappingConfiguration, clone.AssociationMappingConfiguration);
            Assert.Equal(configuration.AssociationMappingConfiguration, clone.AssociationMappingConfiguration);
        }
Example #16
0
        public void HasConstraint_Throws_MultiplicityMany()
        {
            // Arrange
            Mock<EntityTypeConfiguration> entityType = new Mock<EntityTypeConfiguration>();
            entityType.Setup(c => c.ClrType).Returns(typeof(NavigationPropertyConfigurationTest));
            NavigationPropertyConfiguration navigationProperty = new NavigationPropertyConfiguration(
                new MockPropertyInfo(typeof(List<NavigationPropertyConfigurationTest>), "Navigation"),
                EdmMultiplicity.Many, entityType.Object);

            // Act & Assert
            ExceptionAssert.Throws<NotSupportedException>(
                () => navigationProperty.HasConstraint(new MockPropertyInfo(), new MockPropertyInfo()),
                String.Format(SRResources.ReferentialConstraintOnManyNavigationPropertyNotSupported,
                "Navigation", typeof(NavigationPropertyConfigurationTest).FullName));
        }
        public void GetTargetNavigationSource_Throws_IfTargetEntityTypeIsMissing()
        {
            // Arrange
            PropertyInfo propertyInfo = this.GetType().GetProperty(nameof(SamplePropertyName));

            Mock <EntityTypeConfiguration>  entityTypeConfiguration = new Mock <EntityTypeConfiguration>();
            NavigationPropertyConfiguration config = new NavigationPropertyConfiguration(propertyInfo, EdmMultiplicity.ZeroOrOne, entityTypeConfiguration.Object);

            Mock <ODataModelBuilder> modelBuilder = new Mock <ODataModelBuilder>();

            // Act & Assert
            ExceptionAssert.Throws <InvalidOperationException>(
                () => AssociationSetDiscoveryConvention.GetTargetNavigationSource(config, modelBuilder.Object),
                "Could not find the target entity type for the navigation property 'SamplePropertyName' on entity type 'Microsoft.AspNet.OData.Test.Builder.Conventions.AssociationSetDiscoveryConventionTest'.");
        }
        private static IEdmModel CreateModelForFullMetadata(bool sameLinksForIdAndEdit, bool sameLinksForEditAndRead)
        {
            ODataModelBuilder builder = new ODataModelBuilder();

            EntitySetConfiguration <MainEntity> mainSet = builder.EntitySet <MainEntity>("MainEntity");

            Func <EntityInstanceContext <MainEntity>, string> idLinkFactory = (e) =>
                                                                              CreateAbsoluteLink("/MainEntity/id/" + e.EntityInstance.Id.ToString());

            mainSet.HasIdLink(idLinkFactory, followsConventions: true);

            Func <EntityInstanceContext <MainEntity>, string> editLinkFactory;

            if (!sameLinksForIdAndEdit)
            {
                editLinkFactory = (e) => CreateAbsoluteLink("/MainEntity/edit/" + e.EntityInstance.Id.ToString());
                mainSet.HasEditLink(editLinkFactory, followsConventions: false);
            }

            Func <EntityInstanceContext <MainEntity>, string> readLinkFactory;

            if (!sameLinksForEditAndRead)
            {
                readLinkFactory = (e) => CreateAbsoluteLink("/MainEntity/read/" + e.EntityInstance.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/" + ((MainEntity)(c.EntityInstance)).Id),
                                                                                                            followsConventions: true);
            main.TransientAction("DoSometimes").ReturnsCollectionFromEntitySet <MainEntity>(
                "MainEntity").HasActionLink((c) =>
                                            CreateAbsoluteUri("/MainEntity/DoSometimes/" + ((MainEntity)(c.EntityInstance)).Id),
                                            followsConventions: false);

            mainSet.HasNavigationPropertyLink(mainToRelated, (c, p) => new Uri("/MainEntity/RelatedEntity/" +
                                                                               c.EntityInstance.Id, UriKind.Relative), followsConventions: true);

            EntitySetConfiguration <RelatedEntity> related = builder.EntitySet <RelatedEntity>("RelatedEntity");

            return(builder.GetEdmModel());
        }
Example #19
0
        public void Configure_should_set_configuration_annotations()
        {
            var navigationPropertyConfiguration = new NavigationPropertyConfiguration(new MockPropertyInfo());
            var navigationProperty = new NavigationProperty("N", TypeUsage.Create(new EntityType()))
            {
                RelationshipType = new AssociationType()
            };

            navigationProperty.Association.SourceEnd = new AssociationEndMember("S", new EntityType());
            navigationProperty.Association.TargetEnd = new AssociationEndMember("T", new EntityType());

            navigationPropertyConfiguration.Configure(navigationProperty, new EdmModel(), new EntityTypeConfiguration(typeof(object)));

            Assert.NotNull(navigationProperty.GetConfiguration());
            Assert.NotNull(navigationProperty.Association.GetConfiguration());
        }
        public void Apply_DoesnotModifiy_ExplicitlyAddedAction()
        {
            // Arrange
            ODataConventionModelBuilder builder          = new ODataConventionModelBuilder();
            PropertyInfo                    propertyInfo = typeof(TestOrder).GetProperty("Customer");
            EntityTypeConfiguration         entity       = builder.AddEntityType(typeof(TestOrder));
            NavigationPropertyConfiguration navProperty  = entity.AddNavigationProperty(propertyInfo, EdmMultiplicity.One);

            navProperty.OnDeleteAction = EdmOnDeleteAction.None;

            // Act
            new ActionOnDeleteAttributeConvention().Apply(navProperty, entity, builder);

            // Assert
            Assert.Equal(EdmOnDeleteAction.None, navProperty.OnDeleteAction);
        }
        private static void ApplyNavigation(NavigationPropertyConfiguration navProperty, EntityTypeConfiguration entityType,
                                            ForeignKeyAttribute foreignKeyAttribute)
        {
            Contract.Assert(navProperty != null);
            Contract.Assert(entityType != null);
            Contract.Assert(foreignKeyAttribute != null);

            if (navProperty.AddedExplicitly || navProperty.Multiplicity == EdmMultiplicity.Many)
            {
                return;
            }

            EntityTypeConfiguration principalEntity = entityType.ModelBuilder.StructuralTypes
                                                      .OfType <EntityTypeConfiguration>().FirstOrDefault(e => e.ClrType == navProperty.RelatedClrType);

            if (principalEntity == null)
            {
                return;
            }

            // if a navigation property has multiple foreign keys, use comma to separate the list of foreign key names.
            IEnumerable <string> dependentPropertyNames = foreignKeyAttribute.Name.Split(',').Select(p => p.Trim());

            foreach (string dependentPropertyName in dependentPropertyNames)
            {
                if (String.IsNullOrWhiteSpace(dependentPropertyName))
                {
                    continue;
                }

                PrimitivePropertyConfiguration dependent =
                    entityType.Properties.OfType <PrimitivePropertyConfiguration>()
                    .SingleOrDefault(p => p.Name.Equals(dependentPropertyName, StringComparison.Ordinal));

                if (dependent != null)
                {
                    Type dependentType = Nullable.GetUnderlyingType(dependent.PropertyInfo.PropertyType) ?? dependent.PropertyInfo.PropertyType;
                    PrimitivePropertyConfiguration principal = principalEntity.Keys.FirstOrDefault(
                        k => k.PropertyInfo.PropertyType == dependentType && navProperty.PrincipalProperties.All(p => p != k.PropertyInfo));

                    if (principal != null)
                    {
                        navProperty.HasConstraint(dependent.PropertyInfo, principal.PropertyInfo);
                    }
                }
            }
        }
Example #22
0
        internal override void ApplyPropertyConfiguration(
            PropertyInfo propertyInfo,
            Func <PropertyConfiguration> propertyConfiguration,
            System.Data.Entity.ModelConfiguration.Configuration.ModelConfiguration modelConfiguration)
        {
            if (!propertyInfo.IsValidEdmNavigationProperty() || propertyInfo.PropertyType.IsCollection() || !this._attributeProvider.GetAttributes(propertyInfo).OfType <RequiredAttribute>().Any <RequiredAttribute>())
            {
                return;
            }
            NavigationPropertyConfiguration propertyConfiguration1 = (NavigationPropertyConfiguration)propertyConfiguration();

            if (propertyConfiguration1.RelationshipMultiplicity.HasValue)
            {
                return;
            }
            propertyConfiguration1.RelationshipMultiplicity = new RelationshipMultiplicity?(RelationshipMultiplicity.One);
        }
        public void Cloning_a_navigation_property_configuration_clones_its_constraint_information()
        {
            var navProp       = new MockPropertyInfo(typeof(AType1), "P1");
            var configuration = new NavigationPropertyConfiguration(navProp);

            configuration.Constraint =
                new ForeignKeyConstraintConfiguration(
                    new List <PropertyInfo>
            {
                new MockPropertyInfo(typeof(int), "P2")
            });

            var clone = configuration.Clone();

            Assert.NotSame(configuration.Constraint, clone.Constraint);
            Assert.Equal(configuration.Constraint, clone.Constraint);
        }
        public void GetTargetEntitySet_Returns_BaseTypeEntitySet_IfNoMatchingEntitysetForCurrentType()
        {
            // Arrange
            ODataModelBuilder        builder                = new ODataModelBuilder();
            IEntityTypeConfiguration motorcycle             = builder.AddEntity(typeof(Motorcycle));
            IEntityTypeConfiguration manufacturer           = builder.AddEntity(typeof(Manufacturer));
            IEntityTypeConfiguration motorcycleManufacturer = builder.AddEntity(typeof(MotorcycleManufacturer)).DerivesFrom(manufacturer);

            NavigationPropertyConfiguration navigationProperty = motorcycle.AddNavigationProperty(typeof(Motorcycle).GetProperty("Manufacturer"), EdmMultiplicity.ZeroOrOne);
            IEntitySetConfiguration         manufacturers      = builder.AddEntitySet("manufacturers", manufacturer);

            // Act
            IEntitySetConfiguration targetEntitySet = AssociationSetDiscoveryConvention.GetTargetEntitySet(navigationProperty, builder);

            // Assert
            Assert.Equal(manufacturers, targetEntitySet);
        }
Example #25
0
        public override void Apply(PropertyConfiguration edmProperty, StructuralTypeConfiguration structuralTypeConfiguration, Attribute attribute)
        {
            if (structuralTypeConfiguration == null)
            {
                throw Error.ArgumentNull("structuralTypeConfiguration");
            }

            if (edmProperty == null)
            {
                throw Error.ArgumentNull("edmProperty");
            }

            bool isTypeDataContract        = structuralTypeConfiguration.ClrType.GetCustomAttributes(typeof(DataContractAttribute), inherit: true).Any();
            DataMemberAttribute dataMember = attribute as DataMemberAttribute;

            if (isTypeDataContract && dataMember != null && !edmProperty.AddedExplicitly)
            {
                // set the name alias
                if (structuralTypeConfiguration.ModelBuilder != null &&
                    structuralTypeConfiguration.ModelBuilder.ModelAliasingEnabled &&
                    !String.IsNullOrWhiteSpace(dataMember.Name))
                {
                    edmProperty.Name = dataMember.Name;
                }

                StructuralPropertyConfiguration structuralProperty = edmProperty as StructuralPropertyConfiguration;
                if (structuralProperty != null)
                {
                    structuralProperty.OptionalProperty = !dataMember.IsRequired;
                }

                NavigationPropertyConfiguration navigationProperty = edmProperty as NavigationPropertyConfiguration;
                if (navigationProperty != null && navigationProperty.Multiplicity != EdmMultiplicity.Many)
                {
                    if (dataMember.IsRequired)
                    {
                        navigationProperty.Required();
                    }
                    else
                    {
                        navigationProperty.Optional();
                    }
                }
            }
        }
        public void Has_foreign_key_with_multiple_properties_should_create_constraint_with_dependent_keys()
        {
            var navigationPropertyConfiguration = new NavigationPropertyConfiguration(new MockPropertyInfo());

            new DependentNavigationPropertyConfiguration <D>(navigationPropertyConfiguration)
            .HasForeignKey(
                d => new
            {
                d.Fk1,
                d.Fk2
            });

            var foreignKeyConstraint = (ForeignKeyConstraintConfiguration)navigationPropertyConfiguration.Constraint;

            Assert.Equal(2, foreignKeyConstraint.ToProperties.Count());
            Assert.Equal("Fk1", foreignKeyConstraint.ToProperties.First().Name);
            Assert.Equal("Fk2", foreignKeyConstraint.ToProperties.ElementAt(1).Name);
        }
Example #27
0
        public void HasConstraint_Throws_ReferentialConstraintPropertyTypeNotValid()
        {
            // Arrange
            PropertyInfo principalPropertyInfo = typeof(Principal).GetProperty("MockPrincipal");
            PropertyInfo dependentPropertyInfo = typeof(Dependent).GetProperty("MockDependent");

            ODataModelBuilder builder = new ODataModelBuilder();
            builder.AddEntityType(typeof(Principal));
            EntityTypeConfiguration dependentEntity = builder.AddEntityType(typeof(Dependent));
            NavigationPropertyConfiguration navigationProperty =
                new NavigationPropertyConfiguration(typeof(Dependent).GetProperty("Principal"), EdmMultiplicity.One,
                    dependentEntity);

            // Act & Assert
            ExceptionAssert.Throws<InvalidOperationException>(
                () => navigationProperty.HasConstraint(dependentPropertyInfo, principalPropertyInfo),
                String.Format(SRResources.ReferentialConstraintPropertyTypeNotValid, "Microsoft.AspNet.OData.Test.Common.MockType"));
        }
Example #28
0
        public void HasConstraint_Throws_DependentAndPrincipalTypeNotMatch()
        {
            // Arrange
            PropertyInfo principalPropertyInfo = typeof(Principal).GetProperty("PrincipalKey2");
            PropertyInfo dependentPropertyInfo = typeof(Dependent).GetProperty("DependentKey1");

            ODataModelBuilder builder = new ODataModelBuilder();
            builder.AddEntityType(typeof(Principal));
            EntityTypeConfiguration dependentEntity = builder.AddEntityType(typeof(Dependent));
            NavigationPropertyConfiguration navigationProperty =
                new NavigationPropertyConfiguration(typeof(Dependent).GetProperty("Principal"), EdmMultiplicity.One,
                    dependentEntity);

            // Act & Assert
            ExceptionAssert.Throws<InvalidOperationException>(
                () => navigationProperty.HasConstraint(dependentPropertyInfo, principalPropertyInfo),
                String.Format(SRResources.DependentAndPrincipalTypeNotMatch, "System.Int32", "System.String"));
        }
        private static IEdmModel CreateModel()
        {
            Mock <ODataModelBuilder> mock = new Mock <ODataModelBuilder>();

            mock.Setup(b => b.ValidateModel(It.IsAny <IEdmModel>())).Callback(() => { });
            mock.CallBase = true;
            ODataModelBuilder builder = mock.Object;
            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());
        }
        public void GetTargetEntitySet_Throws_IfTargetEntityTypeIsMissing()
        {
            // Arrange
            Mock<PropertyInfo> property = new Mock<PropertyInfo>();
            property.Setup(p => p.PropertyType).Returns(typeof(Vehicle));
            property.Setup(p => p.ReflectedType).Returns(typeof(AssociationSetDiscoveryConventionTest));
            property.Setup(p => p.Name).Returns("SamplePropertyName");

            Mock<EntityTypeConfiguration> entityTypeConfiguration = new Mock<EntityTypeConfiguration>();
            NavigationPropertyConfiguration config = new NavigationPropertyConfiguration(property.Object, EdmMultiplicity.ZeroOrOne, entityTypeConfiguration.Object);

            Mock<ODataModelBuilder> modelBuilder = new Mock<ODataModelBuilder>();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => AssociationSetDiscoveryConvention.GetTargetEntitySet(config, modelBuilder.Object),
                "Could not find the target entity type for the navigation property 'SamplePropertyName' on entity type 'System.Web.OData.Builder.Conventions.AssociationSetDiscoveryConventionTest'.");
        }
Example #31
0
        // Get the default target navigation source for this navigation property.
        internal static NavigationSourceConfiguration GetTargetNavigationSource(NavigationPropertyConfiguration navigationProperty,
                                                                                ODataModelBuilder model)
        {
            EntityTypeConfiguration targetEntityType =
                model
                .StructuralTypes
                .OfType <EntityTypeConfiguration>().SingleOrDefault(e => e.ClrType == navigationProperty.RelatedClrType);

            if (targetEntityType == null)
            {
                throw Error.InvalidOperation(SRResources.TargetEntityTypeMissing, navigationProperty.Name,
                                             TypeHelper.GetReflectedType(navigationProperty.PropertyInfo).FullName);
            }

            bool hasSingletonAttribute = navigationProperty.PropertyInfo.GetCustomAttributes <SingletonAttribute>().Any();

            return(GetDefaultNavigationSource(targetEntityType, model, hasSingletonAttribute));
        }
        public void AssociationSetDiscoveryConvention_AddsBindingForBaseAndDerivedNavigationProperties()
        {
            // Arrange
            ODataModelBuilder builder = new ODataModelBuilder();

            EntityTypeConfiguration vehicle = builder.AddEntityType(typeof(Vehicle));

            EntityTypeConfiguration         car = builder.AddEntityType(typeof(Car)).DerivesFrom(vehicle);
            NavigationPropertyConfiguration carNavigationProperty = car.AddNavigationProperty(typeof(Car).GetProperty("Manufacturer"), EdmMultiplicity.ZeroOrOne);

            EntityTypeConfiguration         motorcycle = builder.AddEntityType(typeof(Motorcycle)).DerivesFrom(vehicle);
            NavigationPropertyConfiguration motorcycleNavigationProperty = motorcycle.AddNavigationProperty(typeof(Motorcycle).GetProperty("Manufacturer"), EdmMultiplicity.ZeroOrOne);

            EntityTypeConfiguration manufacturer = builder.AddEntityType(typeof(Manufacturer));

            builder.AddEntityType(typeof(MotorcycleManufacturer)).DerivesFrom(manufacturer);
            builder.AddEntityType(typeof(CarManufacturer)).DerivesFrom(manufacturer);

            EntitySetConfiguration manufacturers = builder.AddEntitySet("manufacturers", manufacturer);

            Mock <EntitySetConfiguration> entitySet = new Mock <EntitySetConfiguration>(MockBehavior.Strict);

            entitySet.Setup(v => v.EntityType).Returns(vehicle);
            entitySet.Setup(
                v =>
                v.AddBinding(motorcycleNavigationProperty, manufacturers,
                             new List <MemberInfo> {
                typeof(Motorcycle), typeof(Motorcycle).GetProperty("Manufacturer")
            }))
            .Returns <NavigationPropertyConfiguration>(null);
            entitySet.Setup(
                v =>
                v.AddBinding(carNavigationProperty, manufacturers,
                             new List <MemberInfo> {
                typeof(Car), typeof(Car).GetProperty("Manufacturer")
            }))
            .Returns <NavigationPropertyConfiguration>(null);

            // Act
            _convention.Apply(entitySet.Object, builder);

            // Assert
            entitySet.VerifyAll();
        }
        // Get the default target navigation source for this navigation property.
        internal static NavigationSourceConfiguration GetTargetNavigationSource(NavigationPropertyConfiguration navigationProperty,
            ODataModelBuilder model)
        {
            EntityTypeConfiguration targetEntityType =
                model
                .StructuralTypes
                .OfType<EntityTypeConfiguration>()
                .Where(e => e.ClrType == navigationProperty.RelatedClrType).SingleOrDefault();

            if (targetEntityType == null)
            {
                throw Error.InvalidOperation(SRResources.TargetEntityTypeMissing, navigationProperty.Name,
                    navigationProperty.PropertyInfo.ReflectedType.FullName);
            }

            bool hasSingletonAttribute = navigationProperty.PropertyInfo.GetCustomAttributes<SingletonAttribute>().Any();

            return GetDefaultNavigationSource(targetEntityType, model, hasSingletonAttribute);
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="NavigationPropertyBindingConfiguration"/> class.
 /// </summary>
 /// <param name="navigationProperty">The navigation property for the binding.</param>
 /// <param name="navigationSource">The target navigation source of the binding.</param>
 public NavigationPropertyBindingConfiguration(NavigationPropertyConfiguration navigationProperty,
     INavigationSourceConfiguration navigationSource)
 {
     NavigationProperty = navigationProperty;
     TargetNavigationSource = navigationSource;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="NavigationPropertyBindingConfiguration"/> class.
 /// </summary>
 /// <param name="navigationProperty">The navigation property for the binding.</param>
 /// <param name="entitySet">The target entity set of the binding.</param>
 public NavigationPropertyBindingConfiguration(NavigationPropertyConfiguration navigationProperty,
     EntitySetConfiguration entitySet)
 {
     NavigationProperty = navigationProperty;
     EntitySet = entitySet;
 }
        public void Apply_AddsLinkBuilder_ForAllNavigationProperties()
        {
            // Arrange
            Mock<EntityTypeConfiguration> entity = new Mock<EntityTypeConfiguration>();
            NavigationPropertyConfiguration navigationProperty = new NavigationPropertyConfiguration(new MockPropertyInfo(typeof(Motorcycle), "Motorcycle"), EdmMultiplicity.One, entity.Object);
            entity.Setup(e => e.NavigationProperties).Returns(new[] { navigationProperty });

            var mockEntitySet = new Mock<EntitySetConfiguration>();
            mockEntitySet.Setup(e => e.EntityType).Returns(entity.Object);
            bool navigationLinkSetup = false;
            mockEntitySet
                .Setup(e => e.HasNavigationPropertyLink(navigationProperty, It.IsAny<NavigationLinkBuilder>()))
                .Callback((NavigationPropertyConfiguration property, NavigationLinkBuilder navBuilder) =>
                {
                    Assert.True(navBuilder.FollowsConventions);
                    navigationLinkSetup = true;
                });

            var mockModelBuilder = new Mock<ODataModelBuilder>();

            // Act
            new NavigationLinksGenerationConvention().Apply(mockEntitySet.Object, mockModelBuilder.Object);

            // Assert
            Assert.True(navigationLinkSetup);
        }
        public void Apply_AddsLinkBuilder_ForAllNavigationProperties()
        {
            // Arrange
            Mock<EntityTypeConfiguration> entity = new Mock<EntityTypeConfiguration>();
            NavigationPropertyConfiguration navigationProperty = new NavigationPropertyConfiguration(new MockPropertyInfo(typeof(Motorcycle), "Motorcycle"), EdmMultiplicity.One, entity.Object);
            entity.Setup(e => e.NavigationProperties).Returns(new[] { navigationProperty });

            var mockEntitySet = new Mock<EntitySetConfiguration>();
            mockEntitySet.Setup(e => e.EntityType).Returns(entity.Object);
            mockEntitySet
                .Setup(e => e.HasNavigationPropertyLink(navigationProperty, It.IsAny<Func<EntityInstanceContext, IEdmNavigationProperty, Uri>>()))
                .Verifiable();

            var mockModelBuilder = new Mock<ODataModelBuilder>();

            // Act
            new NavigationLinksGenerationConvention().Apply(mockEntitySet.Object, mockModelBuilder.Object);

            // Assert
            mockEntitySet.Verify();
        }