示例#1
0
        public void Creates_mixed_entry_when_entity_CLR_entity_type_and_shadow_properties()
        {
            var entityType = new EntityType(typeof(RedHook));

            entityType.GetOrAddProperty("Long", typeof(int));
            entityType.GetOrAddProperty("Hammer", typeof(string), shadowProperty: true);

            var servicesMock = new Mock <ContextServices>();

            servicesMock.Setup(m => m.ClrPropertyGetterSource).Returns(new ClrPropertyGetterSource());
            var configurationMock = new Mock <DbContextConfiguration>();

            configurationMock.Setup(m => m.Services).Returns(servicesMock.Object);

            var entity = new RedHook();
            var entry  = new StateEntryFactory(
                configurationMock.Object,
                new EntityMaterializerSource(new MemberMapper(new FieldMatcher()))).Create(entityType, entity);

            Assert.IsType <MixedStateEntry>(entry);

            Assert.Same(configurationMock.Object, entry.Configuration);
            Assert.Same(entityType, entry.EntityType);
            Assert.Same(entity, entry.Entity);
        }
        public void Creates_mixed_entry_when_entity_CLR_entity_type_and_shadow_properties()
        {
            var model = new Model();
            var entityType = model.AddEntityType(typeof(RedHook));
            entityType.GetOrAddProperty("Long", typeof(int));
            entityType.GetOrAddProperty("Hammer", typeof(string), shadowProperty: true);

            var contextServices = TestHelpers.Instance.CreateContextServices(model);
            var stateManager = contextServices.GetRequiredService<IStateManager>();
            var factory = contextServices.GetRequiredService<IInternalEntityEntryFactory>();

            var entity = new RedHook();
            var entry = factory.Create(stateManager, entityType, entity);

            Assert.IsType<InternalMixedEntityEntry>(entry);

            Assert.Same(stateManager, entry.StateManager);
            Assert.Same(entityType, entry.EntityType);
            Assert.Same(entity, entry.Entity);
        }
示例#3
0
        public void Creates_mixed_entry_when_entity_CLR_entity_type_and_shadow_properties()
        {
            var model      = new Model();
            var entityType = model.AddEntityType(typeof(RedHook));

            entityType.AddProperty("Long", typeof(int));
            entityType.AddProperty("Spanner", typeof(string));

            var contextServices = InMemoryTestHelpers.Instance.CreateContextServices(model);
            var stateManager    = contextServices.GetRequiredService <IStateManager>();
            var factory         = contextServices.GetRequiredService <IInternalEntityEntryFactory>();

            var entity = new RedHook();
            var entry  = factory.Create(stateManager, entityType, entity);

            Assert.IsType <InternalMixedEntityEntry>(entry);

            Assert.Same(stateManager, entry.StateManager);
            Assert.Same(entityType, entry.EntityType);
            Assert.Same(entity, entry.Entity);
        }
        public void Creates_mixed_entry_when_entity_CLR_entity_type_and_shadow_properties()
        {
            var modelBuilder      = InMemoryTestHelpers.Instance.CreateConventionBuilder();
            var entityTypeBuilder = modelBuilder.Entity <RedHook>();

            entityTypeBuilder.Property <int>("Id");
            entityTypeBuilder.Property <int>("Long");
            entityTypeBuilder.Property <string>("Spanner");

            var model = modelBuilder.FinalizeModel();

            var contextServices = InMemoryTestHelpers.Instance.CreateContextServices(model);
            var stateManager    = contextServices.GetRequiredService <IStateManager>();

            var entity = new RedHook();
            var entry  = new InternalEntityEntry(stateManager, (IEntityType)entityTypeBuilder.Metadata, entity);

            Assert.Same(stateManager, entry.StateManager);
            Assert.Same(entityTypeBuilder.Metadata, entry.EntityType);
            Assert.Same(entity, entry.Entity);
        }
        public void Creates_mixed_entry_when_entity_CLR_entity_type_and_shadow_properties()
        {
            var model      = new Model();
            var entityType = model.AddEntityType(typeof(RedHook));

            entityType.GetOrAddProperty("Long", typeof(int));
            entityType.GetOrAddProperty("Hammer", typeof(string), shadowProperty: true);

            var contextServices = TestHelpers.CreateContextServices(model);
            var stateManager    = contextServices.GetRequiredService <StateManager>();
            var factory         = contextServices.GetRequiredService <StateEntryFactory>();

            var entity = new RedHook();
            var entry  = factory.Create(stateManager, entityType, entity);

            Assert.IsType <MixedStateEntry>(entry);

            Assert.Same(stateManager, entry.StateManager);
            Assert.Same(entityType, entry.EntityType);
            Assert.Same(entity, entry.Entity);
        }
示例#6
0
        public void Creates_CLR_only_entry_when_entity_has_no_shadow_properties()
        {
            var model      = new Model();
            var entityType = model.AddEntityType(typeof(RedHook));

            entityType.AddProperty("Long", typeof(int), shadow: false);
            entityType.AddProperty("Hammer", typeof(string), shadow: false);

            var contextServices = TestHelpers.Instance.CreateContextServices(model);
            var stateManager    = contextServices.GetRequiredService <IStateManager>();
            var factory         = contextServices.GetRequiredService <IInternalEntityEntryFactory>();

            var entity = new RedHook();
            var entry  = factory.Create(stateManager, entityType, entity);

            Assert.IsType <InternalClrEntityEntry>(entry);

            Assert.Same(stateManager, entry.StateManager);
            Assert.Same(entityType, entry.EntityType);
            Assert.Same(entity, entry.Entity);
        }
        public void Creates_mixed_entry_when_entity_CLR_entity_type_and_shadow_properties()
        {
            var entityType = new EntityType(typeof(RedHook));
            entityType.AddProperty("Long", typeof(int));
            entityType.AddProperty("Hammer", typeof(string), shadowProperty: true, concurrencyToken: false);

            var servicesMock = new Mock<ContextServices>();
            servicesMock.Setup(m => m.ClrPropertyGetterSource).Returns(new ClrPropertyGetterSource());
            var configurationMock = new Mock<DbContextConfiguration>();
            configurationMock.Setup(m => m.Services).Returns(servicesMock.Object);

            var entity = new RedHook();
            var entry = new StateEntryFactory(
                configurationMock.Object,
                new EntityMaterializerSource(new MemberMapper(new FieldMatcher()))).Create(entityType, entity);

            Assert.IsType<MixedStateEntry>(entry);

            Assert.Same(configurationMock.Object, entry.Configuration);
            Assert.Same(entityType, entry.EntityType);
            Assert.Same(entity, entry.Entity);
        }
        public void Creates_CLR_only_entry_when_entity_has_no_shadow_properties()
        {
            var model = new Model();
            var entityType = model.AddEntityType(typeof(RedHook));
            var property = entityType.AddProperty("Long", typeof(int));
            property.IsShadowProperty = false;
            var property1 = entityType.AddProperty("Hammer", typeof(string));
            property1.IsShadowProperty = false;

            var contextServices = TestHelpers.Instance.CreateContextServices(model);
            var stateManager = contextServices.GetRequiredService<IStateManager>();
            var factory = contextServices.GetRequiredService<IInternalEntityEntryFactory>();

            var entity = new RedHook();
            var entry = factory.Create(stateManager, entityType, entity);

            Assert.IsType<InternalClrEntityEntry>(entry);

            Assert.Same(stateManager, entry.StateManager);
            Assert.Same(entityType, entry.EntityType);
            Assert.Same(entity, entry.Entity);
        }
        public void Creates_CLR_only_entry_when_entity_has_no_shadow_properties()
        {
            var modelBuilder      = InMemoryTestHelpers.Instance.CreateConventionBuilder();
            var entityTypeBuilder = modelBuilder.Entity <RedHook>();

            entityTypeBuilder.Property <int>("Id");
            entityTypeBuilder.Property <int>("Long");
            entityTypeBuilder.Property <string>("Hammer");

            var model = modelBuilder.FinalizeModel();

            var contextServices = InMemoryTestHelpers.Instance.CreateContextServices(model);
            var stateManager    = contextServices.GetRequiredService <IStateManager>();
            var factory         = contextServices.GetRequiredService <IInternalEntityEntryFactory>();

            var entity = new RedHook();
            var entry  = factory.Create(stateManager, (IEntityType)entityTypeBuilder.Metadata, entity);

            Assert.IsType <InternalClrEntityEntry>(entry);

            Assert.Same(stateManager, entry.StateManager);
            Assert.Same(entityTypeBuilder.Metadata, entry.EntityType);
            Assert.Same(entity, entry.Entity);
        }