public virtual void Does_not_throw_when_non_candidate_property_is_not_added()
        {
            var modelBuilder = CreateConventionlessInternalModelBuilder();

            modelBuilder.Entity(typeof(NonCandidatePropertyEntity), ConfigurationSource.Convention);

            CreatePropertyMappingValidator()(modelBuilder.Metadata);
        }
        public virtual void Does_not_throw_when_primitive_type_property_is_added()
        {
            var modelBuilder      = CreateConventionlessInternalModelBuilder();
            var entityTypeBuilder = modelBuilder.Entity(typeof(PrimitivePropertyEntity), ConfigurationSource.Convention);

            entityTypeBuilder.Property(typeof(int), "Property", ConfigurationSource.Convention);

            CreatePropertyMappingValidator()(modelBuilder.Metadata);
        }
        public virtual void Does_not_throw_when_navigation_target_entity_is_ignored()
        {
            var modelBuilder = CreateConventionlessInternalModelBuilder();

            modelBuilder.Entity(typeof(NavigationEntity), ConfigurationSource.Convention);
            modelBuilder.Ignore(typeof(PrimitivePropertyEntity), ConfigurationSource.Convention);

            CreatePropertyMappingValidator()(modelBuilder.Metadata);
        }
        public virtual void Does_not_throw_when_primitive_type_property_is_ignored()
        {
            var modelBuilder      = CreateConventionlessModelBuilder().GetInfrastructure();
            var entityTypeBuilder = modelBuilder.Entity(typeof(PrimitivePropertyEntity), ConfigurationSource.Convention);

            entityTypeBuilder.Ignore("Property", ConfigurationSource.DataAnnotation);

            CreatePropertyMappingValidator()(modelBuilder.Metadata);
        }
        public virtual void Does_not_throw_when_navigation_is_ignored()
        {
            var modelBuilder      = CreateConventionlessInternalModelBuilder();
            var entityTypeBuilder = modelBuilder.Entity(typeof(NavigationEntity), ConfigurationSource.Convention);

            entityTypeBuilder.Ignore("Navigation", ConfigurationSource.DataAnnotation);

            CreatePropertyMappingValidator()(modelBuilder.Metadata);
        }
        public virtual void Does_not_throw_when_added_shadow_property_by_convention_is_not_of_primitive_type()
        {
            var modelBuilder      = CreateConventionlessInternalModelBuilder();
            var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveAsPropertyEntity), ConfigurationSource.Convention);

            entityTypeBuilder.Property(typeof(NavigationAsProperty), "ShadowProperty", ConfigurationSource.Convention);
            entityTypeBuilder.Ignore(nameof(NonPrimitiveAsPropertyEntity.Property), ConfigurationSource.Explicit);

            CreatePropertyMappingValidator()(modelBuilder.Metadata);
        }
        public virtual void Throws_when_nonprimitive_value_type_property_is_not_added_or_ignored()
        {
            var modelBuilder = CreateConventionlessInternalModelBuilder();

            modelBuilder.Entity(typeof(NonPrimitiveValueTypePropertyEntity), ConfigurationSource.Convention);

            Assert.Equal(
                CoreStrings.PropertyNotAdded(
                    typeof(NonPrimitiveValueTypePropertyEntity).ShortDisplayName(), "Property", typeof(CancellationToken).Name),
                Assert.Throws <InvalidOperationException>(() => CreatePropertyMappingValidator()(modelBuilder.Metadata)).Message);
        }
        public virtual void Does_not_throw_when_navigation_is_added()
        {
            var modelBuilder                = CreateConventionlessInternalModelBuilder();
            var entityTypeBuilder           = modelBuilder.Entity(typeof(NavigationEntity), ConfigurationSource.Convention);
            var referencedEntityTypeBuilder = modelBuilder.Entity(typeof(PrimitivePropertyEntity), ConfigurationSource.Convention);

            referencedEntityTypeBuilder.Ignore("Property", ConfigurationSource.DataAnnotation);
            entityTypeBuilder.HasRelationship(referencedEntityTypeBuilder.Metadata, "Navigation", null, ConfigurationSource.Convention);

            CreatePropertyMappingValidator()(modelBuilder.Metadata);
        }
        public virtual void Throws_when_primitive_type_property_is_not_added_or_ignored()
        {
            var modelBuilder = CreateConventionlessModelBuilder().GetInfrastructure();

            modelBuilder.Entity(typeof(PrimitivePropertyEntity), ConfigurationSource.Convention);

            Assert.Equal(
                CoreStrings.PropertyNotAdded(
                    typeof(PrimitivePropertyEntity).ShortDisplayName(), "Property", typeof(int).DisplayName()),
                Assert.Throws <InvalidOperationException>(() => CreatePropertyMappingValidator()(modelBuilder.Metadata)).Message);
        }
        public virtual void Throws_when_navigation_is_not_added_or_ignored()
        {
            var modelBuilder = CreateConventionlessInternalModelBuilder();

            modelBuilder.Entity(typeof(NavigationEntity), ConfigurationSource.Convention);
            modelBuilder.Entity(typeof(PrimitivePropertyEntity), ConfigurationSource.Convention);

            Assert.Equal(
                CoreStrings.NavigationNotAdded(
                    typeof(NavigationEntity).ShortDisplayName(), "Navigation", typeof(PrimitivePropertyEntity).Name),
                Assert.Throws <InvalidOperationException>(() => CreatePropertyMappingValidator()(modelBuilder.Metadata)).Message);
        }
        public virtual void Throws_when_keyless_type_property_is_not_added_or_ignored()
        {
            var modelBuilder = CreateConventionlessInternalModelBuilder();

            modelBuilder.Entity(typeof(NonPrimitiveReferenceTypePropertyEntity), ConfigurationSource.Convention);

            Assert.Equal(
                CoreStrings.PropertyNotAdded(
                    typeof(NonPrimitiveReferenceTypePropertyEntity).ShortDisplayName(),
                    nameof(NonPrimitiveReferenceTypePropertyEntity.Property),
                    typeof(ICollection <Uri>).ShortDisplayName()),
                Assert.Throws <InvalidOperationException>(() => CreatePropertyMappingValidator()(modelBuilder.Metadata)).Message);
        }
Beispiel #12
0
        public void Throws_when_added_property_is_not_mapped_to_store()
        {
            var modelBuilder      = new InternalModelBuilder(new Model());
            var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveAsPropertyEntity), ConfigurationSource.Convention);

            entityTypeBuilder.Property(typeof(Tuple <long>), "LongProperty", ConfigurationSource.Explicit);
            entityTypeBuilder.Ignore(nameof(NonPrimitiveAsPropertyEntity.Property), ConfigurationSource.Explicit);

            Assert.Equal(
                CoreStrings.PropertyNotMapped(
                    typeof(NonPrimitiveAsPropertyEntity).ShortDisplayName(), "LongProperty", typeof(Tuple <long>).ShortDisplayName()),
                Assert.Throws <InvalidOperationException>(() => CreatePropertyMappingValidator()(modelBuilder.Metadata)).Message);
        }
Beispiel #13
0
        public virtual void Throws_when_interface_type_property_is_not_added_or_ignored()
        {
            var modelBuilder = new InternalModelBuilder(new Model());

            modelBuilder.Entity(typeof(InterfaceNavigationEntity), ConfigurationSource.Convention);

            Assert.Equal(
                CoreStrings.InterfacePropertyNotAdded(
                    typeof(InterfaceNavigationEntity).ShortDisplayName(),
                    "Navigation",
                    typeof(IList <INavigationEntity>).ShortDisplayName()),
                Assert.Throws <InvalidOperationException>(() => CreatePropertyMappingValidator()(modelBuilder.Metadata)).Message);
        }
        public virtual void Throws_when_added_property_is_not_of_primitive_type()
        {
            var modelBuilder      = CreateConventionlessModelBuilder().GetInfrastructure();
            var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveAsPropertyEntity), ConfigurationSource.Convention);

            entityTypeBuilder.Property(typeof(NavigationAsProperty), nameof(NonPrimitiveAsPropertyEntity.Property), ConfigurationSource.Convention);

            Assert.Equal(
                CoreStrings.PropertyNotMapped(
                    typeof(NonPrimitiveAsPropertyEntity).ShortDisplayName(),
                    nameof(NonPrimitiveAsPropertyEntity.Property),
                    typeof(NavigationAsProperty).ShortDisplayName()),
                Assert.Throws <InvalidOperationException>(() => CreatePropertyMappingValidator()(modelBuilder.Metadata)).Message);
        }
        public void Throws_when_added_property_is_not_mapped_to_store_even_if_configured_to_use_column_type()
        {
            var modelBuilder      = CreateConventionlessInternalModelBuilder();
            var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveNonNavigationAsPropertyEntity), ConfigurationSource.Convention);

            entityTypeBuilder.Property(typeof(Tuple <long>), "LongProperty", ConfigurationSource.Explicit)
            .HasColumnType("some_int_mapping");

            Assert.Equal(
                CoreStrings.PropertyNotMapped(
                    typeof(NonPrimitiveNonNavigationAsPropertyEntity).ShortDisplayName(), "LongProperty",
                    typeof(Tuple <long>).ShortDisplayName()),
                Assert.Throws <InvalidOperationException>(() => CreatePropertyMappingValidator()(modelBuilder.Metadata)).Message);
        }