C# EntitySet.ChangeEntityContainerWithoutCollectionFixup方法代码示例

        public void Configure_association_set_should_call_configure_function_configurations()
        {
            var modificationFunctionsConfiguration = new ModificationFunctionsConfiguration();

            var mockModificationFunctionConfiguration = new Mock<ModificationFunctionConfiguration>();

            modificationFunctionsConfiguration.Insert(mockModificationFunctionConfiguration.Object);
            modificationFunctionsConfiguration.Delete(mockModificationFunctionConfiguration.Object);

            var entitySet = new EntitySet();
            entitySet.ChangeEntityContainerWithoutCollectionFixup(new EntityContainer("C", DataSpace.CSpace));

            var storageModificationFunctionMapping
                = new StorageModificationFunctionMapping(
                    entitySet,
                    new EntityType("E", "N", DataSpace.CSpace),
                    new EdmFunction("F", "N", DataSpace.SSpace),
                    new StorageModificationFunctionParameterBinding[0],
                    null,
                    null);

            modificationFunctionsConfiguration.Configure(
                new StorageAssociationSetModificationFunctionMapping(
                    new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)),
                    storageModificationFunctionMapping,
                    storageModificationFunctionMapping));

            mockModificationFunctionConfiguration
                .Verify(m => m.Configure(storageModificationFunctionMapping), Times.Exactly(2));
        }

        public void PrimaryParameterBindings_should_omit_original_value_parameters_when_update()
        {
            var entitySet = new EntitySet();
            entitySet.ChangeEntityContainerWithoutCollectionFixup(new EntityContainer("C", DataSpace.CSpace));

            var storageModificationFunctionMapping
                = new StorageModificationFunctionMapping(
                    entitySet,
                    new EntityType("E", "N", DataSpace.CSpace),
                    new EdmFunction("F", "N", DataSpace.SSpace),
                    new[]
                        {
                            new StorageModificationFunctionParameterBinding(
                                new FunctionParameter(),
                                new StorageModificationFunctionMemberPath(
                                new EdmMember[]
                                    {
                                        new EdmProperty("M")
                                    },
                                null),
                                false)
                        },
                    null,
                    null);

            var storageEntityTypeModificationFunctionMapping
                = new StorageEntityTypeModificationFunctionMapping(
                    new EntityType("E", "N", DataSpace.CSpace),
                    storageModificationFunctionMapping,
                    storageModificationFunctionMapping,
                    storageModificationFunctionMapping);

            Assert.Equal(2, storageEntityTypeModificationFunctionMapping.PrimaryParameterBindings.Count());
        }

            public void Executes_in_a_transaction_using_ExecutionStrategy()
            {
                var shaperMock = MockHelper.CreateShaperMock<object>();
                shaperMock.Setup(m => m.GetEnumerator()).Returns(
                    () => new DbEnumeratorShim<object>(((IEnumerable<object>)new[] { new object() }).GetEnumerator()));

                var objectResultMock = new Mock<ObjectResult<object>>(shaperMock.Object, null, null)
                    {
                        CallBase = true
                    };

                var entityType = new EntityType(
                    "FakeEntityType", "FakeNamespace", DataSpace.CSpace, new[] { "key" }, new EdmMember[] { new EdmProperty("key") });
                var entitySet = new EntitySet("FakeSet", "FakeSchema", "FakeTable", null, entityType);

                var entityContainer = new EntityContainer("FakeContainer", DataSpace.CSpace);
                entityContainer.AddEntitySetBase(entitySet);

                entitySet.ChangeEntityContainerWithoutCollectionFixup(entityContainer);
                entitySet.SetReadOnly();

                var model = new EdmModel(DataSpace.CSpace);
                var omicMock = new Mock<DefaultObjectMappingItemCollection>(new EdmItemCollection(model), new ObjectItemCollection())
                    {
                        CallBase = true
                    };
                var objectTypeMapping = new ObjectTypeMapping(entityType, entityType);
                objectTypeMapping.AddMemberMap(
                    new ObjectPropertyMapping((EdmProperty)entityType.Members.First(), (EdmProperty)entityType.Members.First()));
                omicMock.Setup(m => m.GetMap(It.IsAny<GlobalItem>())).Returns(objectTypeMapping);

                var metadataWorkspaceMock = new Mock<MetadataWorkspace>
                    {
                        CallBase = true
                    };
                metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.OSpace)).Returns(true);
                metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Returns(true);
                metadataWorkspaceMock.Setup(m => m.GetEntityContainer(It.IsAny<string>(), It.IsAny<DataSpace>()))
                                     .Returns(entityContainer);
                metadataWorkspaceMock.Setup(m => m.TryGetEntityContainer(It.IsAny<string>(), It.IsAny<DataSpace>(), out entityContainer))
                                     .Returns(true);
                var storeItemCollection = new StoreItemCollection(
                    GenericProviderFactory<DbProviderFactory>.Instance, new SqlProviderManifest("2008"), "System.Data.FakeSqlClient", "2008");
                metadataWorkspaceMock.Setup(m => m.GetItemCollection(DataSpace.SSpace)).Returns(storeItemCollection);
#pragma warning disable 618
                metadataWorkspaceMock.Object.RegisterItemCollection(omicMock.Object);
#pragma warning restore 618

                var objectStateManagerMock = new Mock<ObjectStateManager>(metadataWorkspaceMock.Object)
                    {
                        CallBase = true
                    };
                var entityKey = new EntityKey(entitySet, "keyValue");
                var entityEntry = objectStateManagerMock.Object.AddKeyEntry(entityKey, entitySet);

                var objectContextMock = Mock.Get(
                    CreateObjectContext(
                        metadataWorkspaceMock: metadataWorkspaceMock,
                        objectStateManagerMock: objectStateManagerMock));

                var entityWrapperMock = new Mock<IEntityWrapper>();
                entityWrapperMock.Setup(m => m.EntityKey).Returns(entityKey);
                var entityWrapperFactoryMock = new Mock<EntityWrapperFactory>();
                entityWrapperFactoryMock.Setup(
                    m => m.WrapEntityUsingStateManagerGettingEntry(
                        It.IsAny<object>(), It.IsAny<ObjectStateManager>(), out entityEntry))
                                        .Returns(entityWrapperMock.Object);
                objectContextMock.Setup(m => m.EntityWrapperFactory).Returns(entityWrapperFactoryMock.Object);

                var executionPlanMock = new Mock<ObjectQueryExecutionPlan>(
                    MockBehavior.Loose, null, null, null, MergeOption.NoTracking, false, null, null);
                executionPlanMock.Setup(
                    m => m.Execute<object>(It.IsAny<ObjectContext>(), It.IsAny<ObjectParameterCollection>()))
                                 .Returns(objectResultMock.Object);
                objectContextMock.Setup(
                    m => m.PrepareRefreshQuery(It.IsAny<RefreshMode>(), It.IsAny<EntitySet>(), It.IsAny<List<EntityKey>>(), It.IsAny<int>()))
                                 .Returns(new Tuple<ObjectQueryExecutionPlan, int>(executionPlanMock.Object, 1));

                // Verify that ExecuteInTransaction calls ObjectQueryExecutionPlan.Execute
                objectContextMock.Setup(
                    m =>
                    m.ExecuteInTransaction(It.IsAny<Func<ObjectResult<object>>>(), It.IsAny<IDbExecutionStrategy>(), It.IsAny<bool>(), It.IsAny<bool>()))
                                 .Returns<Func<ObjectResult<object>>, IDbExecutionStrategy, bool, bool>(
                                     (f, t, s, r) =>
                                         {
                                             executionPlanMock.Verify(
                                                 m =>
                                                 m.Execute<object>(It.IsAny<ObjectContext>(), It.IsAny<ObjectParameterCollection>()),
                                                 Times.Never());
                                             var result = f();
                                             executionPlanMock.Verify(
                                                 m =>
                                                 m.Execute<object>(It.IsAny<ObjectContext>(), It.IsAny<ObjectParameterCollection>()),
                                                 Times.Once());
                                             return result;
                                         });

                // Verify that ExecutionStrategy.Execute calls ExecuteInTransaction
                var executionStrategyMock = new Mock<IDbExecutionStrategy>();
                executionStrategyMock.Setup(m => m.Execute(It.IsAny<Func<ObjectResult<object>>>()))
//.........这里部分代码省略.........

        public void Configure_should_throw_when_rows_affected_parameter_not_found()
        {
            var modificationFunctionConfiguration = new ModificationFunctionConfiguration();

            modificationFunctionConfiguration.RowsAffectedParameter("boom");

            var entitySet = new EntitySet();
            entitySet.ChangeEntityContainerWithoutCollectionFixup(new EntityContainer("C", DataSpace.CSpace));

            Assert.Equal(
                Strings.NoRowsAffectedParameter("F"),
                Assert.Throws<InvalidOperationException>(
                    () => modificationFunctionConfiguration.Configure(
                        new StorageModificationFunctionMapping(
                              entitySet,
                              new EntityType("E", "N", DataSpace.CSpace),
                              new EdmFunction("F", "N", DataSpace.SSpace),
                              new StorageModificationFunctionParameterBinding[0],
                              null,
                              null))).Message);
        }

        public void Can_configure_result_bindings()
        {
            var modificationFunctionConfiguration = new ModificationFunctionConfiguration();

            var mockPropertyInfo = new MockPropertyInfo();

            modificationFunctionConfiguration
                .Result(new PropertyPath(mockPropertyInfo), "Foo");

            var entitySet = new EntitySet();
            entitySet.ChangeEntityContainerWithoutCollectionFixup(new EntityContainer("C", DataSpace.CSpace));

            var property = new EdmProperty("P1");
            property.SetClrPropertyInfo(mockPropertyInfo);

            var resultBinding = new StorageModificationFunctionResultBinding("Bar", property);

            modificationFunctionConfiguration.Configure(
                new StorageModificationFunctionMapping(
                    entitySet,
                    new EntityType("E", "N", DataSpace.CSpace),
                    new EdmFunction("F", "N", DataSpace.SSpace),
                    new[]
                        {
                            new StorageModificationFunctionParameterBinding(
                                new FunctionParameter(
                                "P",
                                TypeUsage.Create(
                                    PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
                                ParameterMode.In),
                                new StorageModificationFunctionMemberPath(new[] { property }, null), false)
                        },
                    null,
                    new[] { resultBinding }));

            Assert.Equal("Foo", resultBinding.ColumnName);
        }

        public void Can_retrieve_properties_and_set_read_only()
        {
            var entitySet = new EntitySet();
            entitySet.ChangeEntityContainerWithoutCollectionFixup(new EntityContainer("C", DataSpace.CSpace));

            var deleteModificationFunctionMapping
                = new ModificationFunctionMapping(
                    entitySet,
                    new EntityType("E", "N", DataSpace.CSpace),
                    new EdmFunction("F", "N", DataSpace.SSpace),
                    new[]
                        {
                            new ModificationFunctionParameterBinding(
                                new FunctionParameter(),
                                new ModificationFunctionMemberPath(
                                new EdmMember[]
                                    {
                                        new EdmProperty("M")
                                    },
                                null),
                                false)
                        },
                    null,
                    null);

            var insertModificationFunctionMapping
                = new ModificationFunctionMapping(
                    entitySet,
                    new EntityType("E", "N", DataSpace.CSpace),
                    new EdmFunction("F", "N", DataSpace.SSpace),
                    new[]
                        {
                            new ModificationFunctionParameterBinding(
                                new FunctionParameter(),
                                new ModificationFunctionMemberPath(
                                new EdmMember[]
                                    {
                                        new EdmProperty("M")
                                    },
                                null),
                                false)
                        },
                    null,
                    null);

            var updateModificationFunctionMapping
                = new ModificationFunctionMapping(
                    entitySet,
                    new EntityType("E", "N", DataSpace.CSpace),
                    new EdmFunction("F", "N", DataSpace.SSpace),
                    new[]
                        {
                            new ModificationFunctionParameterBinding(
                                new FunctionParameter(),
                                new ModificationFunctionMemberPath(
                                new EdmMember[]
                                    {
                                        new EdmProperty("M")
                                    },
                                null),
                                false)
                        },
                    null,
                    null);

            var entityType = new EntityType("E", "N", DataSpace.CSpace);
            var entityTypeModificationFunctionMapping
                = new EntityTypeModificationFunctionMapping(
                    entityType,
                    deleteModificationFunctionMapping,
                    insertModificationFunctionMapping,
                    updateModificationFunctionMapping);

            Assert.Same(entityTypeModificationFunctionMapping.EntityType, entityType);
            Assert.Same(entityTypeModificationFunctionMapping.DeleteFunctionMapping, deleteModificationFunctionMapping);
            Assert.Same(entityTypeModificationFunctionMapping.InsertFunctionMapping, insertModificationFunctionMapping);
            Assert.Same(entityTypeModificationFunctionMapping.UpdateFunctionMapping, updateModificationFunctionMapping);

            Assert.False(entityTypeModificationFunctionMapping.IsReadOnly);
            Assert.False(deleteModificationFunctionMapping.IsReadOnly);
            Assert.False(insertModificationFunctionMapping.IsReadOnly);
            Assert.False(updateModificationFunctionMapping.IsReadOnly);

            entityTypeModificationFunctionMapping.SetReadOnly();

            Assert.True(entityTypeModificationFunctionMapping.IsReadOnly);
            Assert.True(deleteModificationFunctionMapping.IsReadOnly);
            Assert.True(insertModificationFunctionMapping.IsReadOnly);
            Assert.True(updateModificationFunctionMapping.IsReadOnly);
        }