public void Configure_should_configure_modification_functions()
        {
            var model = new EdmModel(DataSpace.CSpace);

            var entityType = model.AddEntityType("E");
            entityType.GetMetadataProperties().SetClrType(typeof(object));

            model.AddEntitySet("ESet", entityType);

            var modificationFunctionsConfigurationMock = new Mock<ModificationStoredProceduresConfiguration>();

            var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));
            entityTypeConfiguration.MapToStoredProcedures(modificationFunctionsConfigurationMock.Object, true);

            entityType.SetConfiguration(entityTypeConfiguration);

            var databaseMapping
                = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderInfo, ProviderRegistry.Sql2008_ProviderManifest).Generate(model);

            entityTypeConfiguration.Configure(entityType, databaseMapping, ProviderRegistry.Sql2008_ProviderManifest);

            modificationFunctionsConfigurationMock
                .Verify(
                    m => m.Configure(
                        It.IsAny<EntityTypeModificationFunctionMapping>(), It.IsAny<DbProviderManifest>()),
                    Times.Once());
        }
        public void Configure_should_configure_modification_functions()
        {
            var model = new EdmModel(DataSpace.CSpace);

            var entityType = model.AddEntityType("E");

            entityType.GetMetadataProperties().SetClrType(typeof(object));

            model.AddEntitySet("ESet", entityType);

            var modificationFunctionsConfigurationMock = new Mock <ModificationStoredProceduresConfiguration>();

            var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));

            entityTypeConfiguration.MapToStoredProcedures(modificationFunctionsConfigurationMock.Object, true);

            entityType.SetConfiguration(entityTypeConfiguration);

            var databaseMapping
                = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderInfo, ProviderRegistry.Sql2008_ProviderManifest).Generate(model);

            entityTypeConfiguration.Configure(entityType, databaseMapping, ProviderRegistry.Sql2008_ProviderManifest);

            modificationFunctionsConfigurationMock
            .Verify(
                m => m.Configure(
                    It.IsAny <EntityTypeModificationFunctionMapping>(), It.IsAny <DbProviderManifest>()),
                Times.Once());
        }
Ejemplo n.º 3
0
        public void MapToStoredProcedures_should_call_method_on_internal_configuration()
        {
            var mockEntityTypeConfiguration = new Mock<EntityTypeConfiguration>(typeof(Fixture));
            var entityConfiguration = new EntityTypeConfiguration<Fixture>(mockEntityTypeConfiguration.Object);

            entityConfiguration.MapToStoredProcedures();

            mockEntityTypeConfiguration.Verify(e => e.MapToStoredProcedures());
        }
        public void Can_pass_function_mapping_configuration_to_map_to_functions()
        {
            var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));

            Assert.Null(entityTypeConfiguration.ModificationStoredProceduresConfiguration);

            entityTypeConfiguration.MapToStoredProcedures(new ModificationStoredProceduresConfiguration(), true);

            Assert.NotNull(entityTypeConfiguration.ModificationStoredProceduresConfiguration);
        }
        public void MapToStoredProcedures_should_create_empty_function_mapping_configuration()
        {
            var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));

            Assert.Null(entityTypeConfiguration.ModificationStoredProceduresConfiguration);

            entityTypeConfiguration.MapToStoredProcedures();

            Assert.NotNull(entityTypeConfiguration.ModificationStoredProceduresConfiguration);
        }
        public void Can_pass_function_mapping_configuration_to_map_to_functions()
        {
            var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));

            Assert.Null(entityTypeConfiguration.ModificationStoredProceduresConfiguration);

            entityTypeConfiguration.MapToStoredProcedures(new ModificationStoredProceduresConfiguration(), true);

            Assert.NotNull(entityTypeConfiguration.ModificationStoredProceduresConfiguration);
        }
        public void MapToStoredProcedures_should_create_empty_function_mapping_configuration()
        {
            var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));

            Assert.Null(entityTypeConfiguration.ModificationStoredProceduresConfiguration);

            entityTypeConfiguration.MapToStoredProcedures();

            Assert.NotNull(entityTypeConfiguration.ModificationStoredProceduresConfiguration);
        }
Ejemplo n.º 8
0
        public void Can_pass_function_mapping_configuration_to_map_to_functions()
        {
            var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));

            Assert.False(entityTypeConfiguration.IsMappedToFunctions);

            entityTypeConfiguration.MapToStoredProcedures(new ModificationFunctionsConfiguration());

            Assert.True(entityTypeConfiguration.IsMappedToFunctions);
        }
Ejemplo n.º 9
0
        public void MapToStoredProcedures_should_create_empty_function_mapping_configuration()
        {
            var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));

            Assert.False(entityTypeConfiguration.IsMappedToFunctions);

            entityTypeConfiguration.MapToStoredProcedures();

            Assert.True(entityTypeConfiguration.IsMappedToFunctions);
        }
        public void Can_pass_function_mapping_configuration_to_map_to_functions()
        {
            var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));

            Assert.False(entityTypeConfiguration.IsMappedToFunctions);

            entityTypeConfiguration.MapToStoredProcedures(new ModificationFunctionsConfiguration());

            Assert.True(entityTypeConfiguration.IsMappedToFunctions);
        }
        public void MapToStoredProcedures_should_create_empty_function_mapping_configuration()
        {
            var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));

            Assert.False(entityTypeConfiguration.IsMappedToFunctions);

            entityTypeConfiguration.MapToStoredProcedures();

            Assert.True(entityTypeConfiguration.IsMappedToFunctions);
        }
Ejemplo n.º 12
0
        public void MapToStoredProcedures_when_config_action_should_call_method_on_internal_configuration()
        {
            var mockEntityTypeConfiguration = new Mock<EntityTypeConfiguration>(typeof(Fixture));
            var entityConfiguration = new EntityTypeConfiguration<Fixture>(mockEntityTypeConfiguration.Object);

            ModificationFunctionsConfiguration<Fixture> configuration = null;

            entityConfiguration.MapToStoredProcedures(c => { configuration = c; });
            
            mockEntityTypeConfiguration.Verify(e => e.MapToStoredProcedures(configuration.Configuration, true));
        }
        public void Generate_should_not_generate_modification_function_mappings_when_entity_abstract()
        {
            var model = new EdmModel(DataSpace.CSpace);
            var entityType = model.AddEntityType("E");
            entityType.Abstract = true;
            entityType.GetMetadataProperties().SetClrType(typeof(string));
            
            var derivedType = model.AddEntityType("D");
            derivedType.BaseType = entityType;
            derivedType.GetMetadataProperties().SetClrType(typeof(object));

            model.AddEntitySet("ESet", entityType);

            var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));
            entityTypeConfiguration.MapToStoredProcedures();
            entityType.SetConfiguration(entityTypeConfiguration);

            var databaseMapping = CreateDatabaseMappingGenerator().Generate(model);

            Assert.Equal(0, databaseMapping.Database.Functions.Count());
        }
        public void Can_generate_function_mappings_for_many_to_many_association_set_mapping()
        {
            var databaseMapping
                = new DbDatabaseMapping()
                    .Initialize(new EdmModel(DataSpace.CSpace), new EdmModel(DataSpace.SSpace));

            var entityType1 = databaseMapping.Model.AddEntityType("E1");
            entityType1.Annotations.SetClrType(typeof(string));
            databaseMapping.Model.AddEntitySet("E1Set", entityType1);

            var entityType2 = databaseMapping.Model.AddEntityType("E2");
            entityType2.Annotations.SetClrType(typeof(string));
            databaseMapping.Model.AddEntitySet("E2Set", entityType2);

            var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));
            entityTypeConfiguration.MapToStoredProcedures();
            entityType1.SetConfiguration(entityTypeConfiguration);
            entityType2.SetConfiguration(entityTypeConfiguration);

            var associationSet
                = databaseMapping.Model.AddAssociationSet(
                    "M2MSet",
                    databaseMapping.Model.AddAssociationType(
                        "M2M",
                        entityType1,
                        RelationshipMultiplicity.Many,
                        entityType2,
                        RelationshipMultiplicity.Many));

            var entitySet = new EntitySet("ES", "S", null, null, new EntityType("E", "N", DataSpace.CSpace));

            var associationEndMember1 = new AssociationEndMember("Source", new EntityType("E", "N", DataSpace.CSpace));
            associationSet.AddAssociationSetEnd(new AssociationSetEnd(entitySet, associationSet, associationEndMember1));

            var associationEndMember2 = new AssociationEndMember("Target", new EntityType("E", "N", DataSpace.CSpace));
            associationSet.AddAssociationSetEnd(new AssociationSetEnd(entitySet, associationSet, associationEndMember2));

            var associationSetMapping
                = new StorageAssociationSetMapping(
                    associationSet,
                    entitySet)
                      {
                          SourceEndMapping
                              = new StorageEndPropertyMapping()
                                    {
                                        EndMember = associationEndMember1
                                    },
                          TargetEndMapping
                              = new StorageEndPropertyMapping()
                                    {
                                        EndMember = associationEndMember2
                                    }
                      };

            associationSetMapping.SourceEndMapping
                                 .AddProperty(new StorageScalarPropertyMapping(new EdmProperty("PK"), new EdmProperty("FooId")));

            associationSetMapping.TargetEndMapping
                                 .AddProperty(new StorageScalarPropertyMapping(new EdmProperty("PK"), new EdmProperty("BarId")));

            var functionMappingGenerator
                = new ModificationFunctionMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest);

            functionMappingGenerator.Generate(associationSetMapping, databaseMapping);

            var modificationFunctionMapping
                = associationSetMapping.ModificationFunctionMapping;

            Assert.NotNull(modificationFunctionMapping);

            var functionMapping = modificationFunctionMapping.InsertFunctionMapping;

            Assert.NotNull(functionMapping);
            Assert.Equal(2, functionMapping.ParameterBindings.Count);
            Assert.Null(functionMapping.ResultBindings);

            var function = functionMapping.Function;

            Assert.NotNull(function);
            Assert.Equal("M2M_Insert", function.Name);
            Assert.Equal(2, function.Parameters.Count);

            functionMapping = modificationFunctionMapping.DeleteFunctionMapping;

            Assert.NotNull(functionMapping);
            Assert.Equal(2, functionMapping.ParameterBindings.Count);
            Assert.Null(functionMapping.ResultBindings);

            function = modificationFunctionMapping.DeleteFunctionMapping.Function;

            Assert.NotNull(function);
            Assert.Equal("M2M_Delete", function.Name);
            Assert.Equal(2, function.Parameters.Count);
        }
        public void Generate_should_not_generate_modification_function_mappings_when_entity_abstract()
        {
            var model = new EdmModel(DataSpace.CSpace);
            var entityType = model.AddEntityType("E");
            entityType.Abstract = true;
            entityType.Annotations.SetClrType(typeof(string));
            model.AddEntitySet("ESet", entityType);

            var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));
            entityTypeConfiguration.MapToStoredProcedures();
            entityType.SetConfiguration(entityTypeConfiguration);

            var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);

            Assert.Equal(0, databaseMapping.Database.Functions.Count());
        }