public void Constructor_throws_when_referenced_key_not_on_referenced_entity()
        {
            var model = new Model();

            var principalEntityType = model.AddEntityType("R");
            var dependentEntityType = model.AddEntityType("D");
            var fk = dependentEntityType.AddProperty("Fk", typeof(int), shadowProperty: true);

            var principalKey = dependentEntityType.SetPrimaryKey(fk);

            Assert.Throws<ArgumentException>(() =>
                new ForeignKey(new[] { fk }, principalKey, principalEntityType));
        }
        public void Constructor_throws_when_referenced_key_not_on_referenced_entity()
        {
            var model = new Model();

            var principalEntityType = model.AddEntityType("R");
            var dependentEntityType = model.AddEntityType("D");
            var fk = dependentEntityType.AddProperty("Fk", typeof(int));

            var principalKey = dependentEntityType.SetPrimaryKey(fk);

            Assert.Equal(
                CoreStrings.ForeignKeyReferencedEntityKeyMismatch("{'Fk'}", "R"),
                Assert.Throws<ArgumentException>(() => new ForeignKey(new[] { fk }, principalKey, dependentEntityType, principalEntityType)).Message);
        }
        public virtual void Detects_shadow_entities()
        {
            var model = new Model();
            model.AddEntityType("A");

            VerifyError(CoreStrings.ShadowEntity("A"), model);
        }
        public virtual void Detects_a_null_primary_key()
        {
            var model = new Model();
            model.AddEntityType(typeof(A));

            VerifyError(CoreStrings.EntityRequiresKey(typeof(A).FullName), model);
        }
        public virtual void Passes_on_escapable_foreign_key_cycles_not_starting_at_hub()
        {
            var model = new Model();
            var entityA = model.AddEntityType(typeof(A));
            SetPrimaryKey(entityA);
            var keyA1 = CreateKey(entityA);
            var keyA2 = CreateKey(entityA, startingPropertyIndex: 1, propertyCount: 2);
            var entityB = model.AddEntityType(typeof(B));
            SetPrimaryKey(entityB);
            var keyB1 = CreateKey(entityB);
            var keyB2 = CreateKey(entityB, startingPropertyIndex: 0, propertyCount: 2);

            CreateForeignKey(keyA1, keyB1);
            CreateForeignKey(keyB1, keyA1);
            CreateForeignKey(keyB2, keyA2);

            Validate(model);
        }
        public virtual void Detects_shadow_keys()
        {
            var model = new Model();
            var entityType = model.AddEntityType(typeof(A));
            SetPrimaryKey(entityType);
            var keyProperty = entityType.AddProperty("Key", typeof(int));
            entityType.AddKey(keyProperty);

            VerifyWarning(CoreStrings.ShadowKey("{'Key'}", typeof(A).FullName, "{'Key'}"), model);
        }
        private static Model CreateModel(bool generateValues = true)
        {
            var model = new Model();

            var entityType = model.AddEntityType("Led");
            entityType.AddProperty("Zeppelin", typeof(Guid));
            entityType.AddProperty("Stairway", typeof(Guid)).RequiresValueGenerator = generateValues;

            return model;
        }
        private static Model CreateModel(bool generateValues = true)
        {
            var model = new Model();

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

            entityType.AddProperty("Zeppelin", typeof(Guid));
            entityType.AddProperty("Stairway", typeof(Guid)).RequiresValueGenerator = generateValues;

            return(model);
        }
Esempio n. 9
0
        public virtual void Passes_on_escapable_foreign_key_cycles_not_starting_at_hub()
        {
            var model   = new Model();
            var entityA = model.AddEntityType(typeof(A));

            SetPrimaryKey(entityA);
            var keyA1   = CreateKey(entityA);
            var keyA2   = CreateKey(entityA, startingPropertyIndex: 1, propertyCount: 2);
            var entityB = model.AddEntityType(typeof(B));

            SetPrimaryKey(entityB);
            var keyB1 = CreateKey(entityB);
            var keyB2 = CreateKey(entityB, startingPropertyIndex: 0, propertyCount: 2);

            CreateForeignKey(keyA1, keyB1);
            CreateForeignKey(keyB1, keyA1);
            CreateForeignKey(keyB2, keyA2);

            Validate(model);
        }
        public virtual void Detects_bool_with_default_expression()
        {
            var model      = new Model();
            var entityType = model.AddEntityType(typeof(E));

            SetPrimaryKey(entityType);
            entityType.AddProperty("ImBool", typeof(bool)).Relational().DefaultValueSql = "TRUE";
            entityType.AddProperty("ImNot", typeof(bool?)).Relational().DefaultValueSql = "TRUE";

            VerifyWarning(RelationalStrings.LogBoolWithDefaultWarning.GenerateMessage("ImBool", "E"), model);
        }
        public virtual void Detects_self_referencing_properties()
        {
            var model   = new Model();
            var entityA = model.AddEntityType(typeof(A));

            SetPrimaryKey(entityA);
            var keyA = CreateKey(entityA);

            CreateForeignKey(keyA, keyA);

            VerifyError(CoreStrings.CircularDependency("'A' {'P0'} -> 'A' {'P0'}"), model);
        }
        public virtual void Passes_on_shadow_key_created_explicitly()
        {
            var model      = new Model();
            var entityType = model.AddEntityType(typeof(A));

            SetPrimaryKey(entityType);
            var keyProperty = entityType.AddProperty("Key", typeof(int));

            entityType.AddKey(keyProperty);

            Validate(model);
        }
Esempio n. 13
0
        private ForeignKey CreateOneToManySameBaseFK()
        {
            var model = new Model();

            var baseEntityType = model.AddEntityType(typeof(NavigationBase));
            var pk             = baseEntityType.GetOrSetPrimaryKey(baseEntityType.GetOrAddProperty("Id", typeof(int)));

            var principalEntityType = model.AddEntityType(typeof(OneToManyPrincipal));

            principalEntityType.BaseType = baseEntityType;

            var dependentEntityType = model.AddEntityType(typeof(OneToManyDependent));

            dependentEntityType.BaseType = baseEntityType;
            var fkProp = dependentEntityType.GetOrAddProperty("Fk", typeof(int), shadowProperty: true);
            var fk     = dependentEntityType.AddForeignKey(new[] { fkProp }, pk, principalEntityType);

            principalEntityType.AddNavigation("OneToManyDependents", fk, pointsToPrincipal: false);
            dependentEntityType.AddNavigation("OneToManyPrincipal", fk, pointsToPrincipal: true);
            return(fk);
        }
        public virtual void Detects_shadow_keys_by_convention()
        {
            var model      = new Model();
            var entityType = model.AddEntityType(typeof(A));

            SetPrimaryKey(entityType);
            var keyProperty = entityType.AddProperty("Key", typeof(int), configurationSource: ConfigurationSource.Convention);

            entityType.AddKey(keyProperty);

            VerifyWarning(CoreStrings.ShadowKey("{'Key'}", typeof(A).Name, "{'Key'}"), model);
        }
Esempio n. 15
0
        public virtual void Passes_for_changed_only_entities_with_snapshot_or_changed_only_tracking(ChangeTrackingStrategy changeTrackingStrategy)
        {
            var model      = new Model();
            var entityType = model.AddEntityType(typeof(ChangedOnlyEntity));
            var id         = entityType.AddProperty("Id");

            entityType.SetPrimaryKey(id);

            model.ChangeTrackingStrategy = changeTrackingStrategy;

            Validate(model);
        }
Esempio n. 16
0
        public virtual void Passes_for_non_notifying_entities_with_snapshot_tracking()
        {
            var model      = new Model();
            var entityType = model.AddEntityType(typeof(NonNotifyingEntity));
            var id         = entityType.AddProperty("Id");

            entityType.SetPrimaryKey(id);

            model.ChangeTrackingStrategy = ChangeTrackingStrategy.Snapshot;

            Validate(model);
        }
Esempio n. 17
0
        public virtual void Passes_for_fully_notifying_entities(ChangeTrackingStrategy changeTrackingStrategy)
        {
            var model      = new Model();
            var entityType = model.AddEntityType(typeof(FullNotificationEntity));
            var id         = entityType.AddProperty("Id");

            entityType.SetPrimaryKey(id);

            model.ChangeTrackingStrategy = changeTrackingStrategy;

            Validate(model);
        }
Esempio n. 18
0
        public virtual void Detects_shadow_keys()
        {
            var model      = new Model();
            var entityType = model.AddEntityType(typeof(A));

            SetPrimaryKey(entityType);
            var keyProperty = entityType.AddProperty("Key", typeof(int));

            entityType.AddKey(keyProperty);

            VerifyWarning(CoreStrings.ShadowKey("{'Key'}", typeof(A).FullName, "{'Key'}"), model);
        }
Esempio n. 19
0
        private static IMutableModel CreateModel(bool generateValues = true)
        {
            IMutableModel model = new Model();

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

            entityType.AddProperty("Zeppelin", typeof(Guid));
            entityType.AddProperty("Stairway", typeof(Guid))
            .ValueGenerated = generateValues ? ValueGenerated.OnAdd : ValueGenerated.Never;

            return(model);
        }
Esempio n. 20
0
        public virtual void Passes_on_shadow_key_created_explicitly()
        {
            var model      = new Model();
            var entityType = model.AddEntityType(typeof(A));

            SetPrimaryKey(entityType);
            var keyProperty = entityType.AddProperty("Key", typeof(int));

            entityType.AddKey(keyProperty);

            VerifyWarning(CoreStrings.LogShadowPropertyCreated.GenerateMessage("Key", "A"), model, LogLevel.Debug);
        }
Esempio n. 21
0
        private static IModel CreateModel()
        {
            var model      = new Model();
            var entityType = model.AddEntityType(typeof(Entity));
            var property   = entityType.GetOrAddProperty("Id", typeof(int));

            entityType.Relational().Table  = "MyTable";
            entityType.Relational().Schema = "dbo";
            entityType.GetOrSetPrimaryKey(property);
            entityType.GetPrimaryKey().Relational().Name = "MyPK";

            return(model);
        }
Esempio n. 22
0
        public void Can_add_and_remove_entity()
        {
            var model      = new Model();
            var entityType = new EntityType(typeof(Customer));

            model.AddEntityType(entityType);

            Assert.NotNull(model.TryGetEntityType(typeof(Customer)));

            model.RemoveEntityType(entityType);

            Assert.Null(model.TryGetEntityType(typeof(Customer)));
        }
Esempio n. 23
0
        public static Model Model()
        {
            var model = new Model();

            var entityType = model.AddEntityType(typeof(QueryTestType));

            foreach (var property in typeof(QueryTestType).GetProperties())
            {
                entityType.GetOrAddProperty(property);
            }

            return(model);
        }
Esempio n. 24
0
        private ForeignKey CreateOneToManySameBaseFK()
        {
            var model = new Model();

            var baseEntityType = model.AddEntityType(typeof(NavigationBase));
            var property1      = baseEntityType.AddProperty(NavigationBase.IdProperty);
            var pk             = baseEntityType.GetOrSetPrimaryKey(property1);

            var principalEntityType = model.AddEntityType(typeof(OneToManyPrincipal));

            principalEntityType.HasBaseType(baseEntityType);

            var dependentEntityType = model.AddEntityType(typeof(OneToManyDependent));

            dependentEntityType.HasBaseType(baseEntityType);
            var fkProp = dependentEntityType.AddProperty("Fk", typeof(int));
            var fk     = dependentEntityType.AddForeignKey(new[] { fkProp }, pk, principalEntityType);

            fk.HasPrincipalToDependent("OneToManyDependents");
            fk.HasDependentToPrincipal("OneToManyPrincipal");
            return(fk);
        }
Esempio n. 25
0
        private static Navigation CreateCollectionNavigation <TEntity>(
            string fieldName, string navigationName = Collection)
        {
            var model      = new Model();
            var entityType = model.AddEntityType(typeof(TEntity));
            var property   = entityType.AddProperty("Id", typeof(int));
            var key        = entityType.SetPrimaryKey(property);
            var foreignKey = entityType.AddForeignKey(property, key, entityType);
            var navigation = foreignKey.HasPrincipalToDependent(typeof(TEntity).GetProperty(navigationName));

            navigation.SetField(fieldName);
            return(navigation);
        }
Esempio n. 26
0
        public void Context_will_use_explicit_model_if_set_in_config()
        {
            IMutableModel model = new Model();

            model.AddEntityType(typeof(TheGu));

            using var context = new EarlyLearningCenter(
                      InMemoryTestHelpers.Instance.CreateServiceProvider(),
                      new DbContextOptionsBuilder().UseModel(model.FinalizeModel()).Options);
            Assert.Equal(
                new[] { typeof(TheGu).FullName },
                context.Model.GetEntityTypes().Select(e => e.Name).ToArray());
        }
Esempio n. 27
0
        private static Model BuildModel()
        {
            var model = new Model();

            var entityType = new EntityType(typeof(Banana));

            entityType.AddProperty("Id", typeof(int), shadowProperty: false, concurrencyToken: true);
            entityType.AddProperty("Name", typeof(string));
            entityType.AddProperty("State", typeof(string), shadowProperty: false, concurrencyToken: true);
            model.AddEntityType(entityType);

            return(model);
        }
Esempio n. 28
0
        private static IModel CreateModelWithForeignKeys()
        {
            var model = new Model();

            var houseType = new EntityType("Ho!use[]");
            var houseId   = houseType.GetOrAddProperty("Id", typeof(int), shadowProperty: true);

            houseType.GetOrSetPrimaryKey(houseId);
            model.AddEntityType(houseType);

            var customerType       = new EntityType(typeof(Customer));
            var customerId         = customerType.GetOrAddProperty("Id", typeof(int));
            var customerFkProperty = customerType.GetOrAddProperty("HouseId", typeof(int));

            customerFkProperty.SetColumnName(@"House[""Id]Column");
            customerType.SetSchema("dbo");
            customerType.SetTableName(@"Cus[""om.er]s");
            customerType.GetOrSetPrimaryKey(customerId);
            customerType.GetPrimaryKey().SetKeyName(@"My[""PK]");
            customerType.GetPrimaryKey().Annotations.Add(new Annotation(@"My""PK""Annotat!on", @"""Foo"""));
            var customerFk = customerType.GetOrAddForeignKey(houseType.GetPrimaryKey(), customerFkProperty);

            customerFk.SetKeyName(@"My_[""FK]");
            customerFk.Annotations.Add(new Annotation(@"My""FK""Annotation", @"""Bar"""));
            model.AddEntityType(customerType);

            var orderType = new EntityType(typeof(Order));
            var orderId   = orderType.GetOrAddProperty(@"OrderId", typeof(int));
            var orderFK   = orderType.GetOrAddProperty(@"CustomerId", typeof(int));

            orderType.SetSchema("dbo");
            orderType.GetOrSetPrimaryKey(orderId);
            orderType.SetTableName(@"Ord[""e.r]s");
            orderType.GetOrAddForeignKey(customerType.GetPrimaryKey(), orderFK);
            orderType.Annotations.Add(new Annotation("Random annotation", "42"));
            model.AddEntityType(orderType);

            return(model);
        }
Esempio n. 29
0
        private static Model BuildModel()
        {
            var model = new Model();

            var entityType = model.AddEntityType(typeof(Banana));
            var property1  = entityType.GetOrAddProperty("P1", typeof(int));
            var property2  = entityType.GetOrAddProperty("P2", typeof(int?));

            entityType.GetOrSetPrimaryKey(property1);
            entityType.GetOrAddForeignKey(property2, entityType.GetPrimaryKey());

            return(model);
        }
        public void Save_changes_returns_requested_document_count()
        {
            var queryCompilationContextFactory = Mock.Of <IQueryCompilationContextFactory>();
            var mockMongoDbConnection          = new Mock <IMongoDbConnection>();
            var mockStateManager                = new Mock <IStateManager>();
            var mockMongoCollection             = new Mock <IMongoCollection <SimpleRecord> >();
            var mockValueGenerationManager      = new Mock <IValueGenerationManager>();
            var mockInternalEntityEntryNotifier = new Mock <IInternalEntityEntryNotifier>();

            mockStateManager.SetupGet(stateManager => stateManager.ValueGeneration)
            .Returns(() => mockValueGenerationManager.Object);
            mockStateManager.SetupGet(stateManager => stateManager.Notify)
            .Returns(() => mockInternalEntityEntryNotifier.Object);
            mockMongoDbConnection.Setup(mockedMongoDbConnection => mockedMongoDbConnection.GetCollection <SimpleRecord>())
            .Returns(() => mockMongoCollection.Object);
            mockMongoCollection.Setup(mongoCollection => mongoCollection.BulkWrite(
                                          It.IsAny <IEnumerable <WriteModel <SimpleRecord> > >(),
                                          It.IsAny <BulkWriteOptions>(),
                                          It.IsAny <CancellationToken>()))
            .Returns((IEnumerable <WriteModel <SimpleRecord> > list, BulkWriteOptions options, CancellationToken token)
                     => new BulkWriteResult <SimpleRecord> .Acknowledged(
                         list.Count(),
                         matchedCount: 0,
                         deletedCount: list.OfType <DeleteOneModel <SimpleRecord> >().Count(),
                         insertedCount: list.OfType <InsertOneModel <SimpleRecord> >().Count(),
                         modifiedCount: list.OfType <ReplaceOneModel <SimpleRecord> >().Count(),
                         processedRequests: list,
                         upserts: new List <BulkWriteUpsert>()));
            var databaseDepedencies = new DatabaseDependencies(queryCompilationContextFactory);
            var mongoDbDatabase     = new MongoDbDatabase(databaseDepedencies, mockMongoDbConnection.Object);

            var        model      = new Model(new CoreConventionSetBuilder().CreateConventionSet());
            EntityType entityType = model.AddEntityType(typeof(SimpleRecord));

            entityType.Builder
            .GetOrCreateProperties(typeof(SimpleRecord).GetTypeInfo().GetProperties(), ConfigurationSource.Convention);
            entityType.Builder
            .MongoDb(ConfigurationSource.Convention)
            .FromCollection(collectionName: "simpleRecords");

            IReadOnlyList <InternalEntityEntry> entityEntries = new[] { EntityState.Added, EntityState.Deleted, EntityState.Modified }
            .Select(entityState =>
            {
                var entityEntry = new InternalClrEntityEntry(mockStateManager.Object, entityType, new SimpleRecord());
                entityEntry.SetEntityState(entityState, acceptChanges: true);
                return(entityEntry);
            })
            .ToList();

            Assert.Equal(entityEntries.Count, mongoDbDatabase.SaveChanges(entityEntries));
        }
Esempio n. 31
0
        protected virtual Model BuildModel()
        {
            var model = new Model();

            var entityType1 = new EntityType(typeof(SomeEntity));

            model.AddEntityType(entityType1);
            var key1 = entityType1.AddProperty("Id", typeof(int));

            key1.ValueGenerationOnSave = ValueGenerationOnSave.WhenInserting;
            key1.ValueGenerationOnAdd  = ValueGenerationOnAdd.Client;
            entityType1.SetKey(key1);
            entityType1.AddProperty("Name", typeof(string), shadowProperty: false, concurrencyToken: true);

            var entityType2 = new EntityType(typeof(SomeDependentEntity));

            model.AddEntityType(entityType2);
            var key2 = entityType2.AddProperty("Id", typeof(int));

            entityType2.SetKey(key2);
            var fk = entityType2.AddProperty("SomeEntityId", typeof(int));

            entityType2.AddForeignKey(entityType1.GetKey(), new[] { fk });

            var entityType3 = new EntityType(typeof(FullNotificationEntity));

            model.AddEntityType(entityType3);
            entityType3.SetKey(entityType3.AddProperty("Id", typeof(int)));
            entityType3.AddProperty("Name", typeof(string), shadowProperty: false, concurrencyToken: true);

            var entityType4 = new EntityType(typeof(ChangedOnlyEntity));

            model.AddEntityType(entityType4);
            entityType4.SetKey(entityType4.AddProperty("Id", typeof(int)));
            entityType4.AddProperty("Name", typeof(string), shadowProperty: false, concurrencyToken: true);

            return(model);
        }
Esempio n. 32
0
        private static IModel CreateModel()
        {
            var model      = new Model();
            var entityType = new EntityType(typeof(Entity));
            var property   = entityType.GetOrAddProperty("Id", typeof(int));

            entityType.SetTableName("MyTable");
            entityType.SetSchema("dbo");
            entityType.GetOrSetPrimaryKey(property);
            entityType.GetPrimaryKey().SetKeyName("MyPK");
            model.AddEntityType(entityType);

            return(model);
        }
        private static Model CreateModel(bool generateValues = true)
        {
            var model = new Model();

            var entityType = model.AddEntityType("Led");
            var property1  = entityType.GetOrAddProperty("Zeppelin", typeof(Guid), shadowProperty: true);

            property1.GenerateValueOnAdd = generateValues;
            var property2 = entityType.GetOrAddProperty("Stairway", typeof(Guid), shadowProperty: true);

            property2.GenerateValueOnAdd = generateValues;

            return(model);
        }
Esempio n. 34
0
    public void Can_ignore_existing_entity_type_using_entity_type_name()
    {
        var model        = new Model();
        var entityType   = model.AddEntityType(typeof(Customer).FullName, owned: false, ConfigurationSource.Explicit);
        var modelBuilder = CreateModelBuilder(model);

        Assert.Same(entityType, modelBuilder.Entity(typeof(Customer).FullName, ConfigurationSource.Convention).Metadata);
        Assert.Null(modelBuilder.Ignore(typeof(Customer).FullName, ConfigurationSource.DataAnnotation));
        Assert.NotNull(model.FindEntityType(typeof(Customer).FullName));

        Assert.NotNull(modelBuilder.Ignore(typeof(Customer).FullName, ConfigurationSource.Explicit));

        Assert.Null(model.FindEntityType(typeof(Customer).FullName));
    }
        public virtual void Passes_on_shadow_primary_key_created_by_convention_in_dependent_type()
        {
            var model       = new Model();
            var entityType  = model.AddEntityType(typeof(A));
            var keyProperty = entityType.AddProperty("Key", typeof(int), configurationSource: ConfigurationSource.Convention);

            entityType.SetPrimaryKey(keyProperty);

            Validate(model);

            Assert.Equal(1, Log.Count);
            Assert.Equal(LogLevel.Debug, Log[0].Level);
            Assert.Equal(CoreStrings.LogShadowPropertyCreated.GenerateMessage("Key", "A"), Log[0].Message);
        }
Esempio n. 36
0
        public virtual void Detects_changed_only_notifying_entities(ChangeTrackingStrategy changeTrackingStrategy)
        {
            var model      = new Model();
            var entityType = model.AddEntityType(typeof(ChangedOnlyEntity));
            var id         = entityType.AddProperty("Id");

            entityType.SetPrimaryKey(id);

            model.ChangeTrackingStrategy = changeTrackingStrategy;

            VerifyError(
                CoreStrings.ChangeTrackingInterfaceMissing("ChangedOnlyEntity", changeTrackingStrategy, "INotifyPropertyChanging"),
                model);
        }
Esempio n. 37
0
        public void Can_get_referencing_foreign_keys()
        {
            var model       = new Model();
            var entityType1 = new EntityType(typeof(Customer));
            var entityType2 = new EntityType(typeof(Order));
            var keyProperty = new Property("Id", typeof(int))
            {
                EntityType = entityType1
            };
            var fkProperty = new Property("CustomerId", typeof(int?))
            {
                EntityType = entityType2
            };
            var foreignKey = entityType2.GetOrAddForeignKey(new Key(new[] { keyProperty }), fkProperty);

            model.AddEntityType(entityType1);
            model.AddEntityType(entityType2);

            var referencingForeignKeys = model.GetReferencingForeignKeys(entityType1);

            Assert.Same(foreignKey, referencingForeignKeys.Single());
            Assert.Same(foreignKey, entityType1.GetReferencingForeignKeys().Single());
        }
        public void Creates_shadow_state_only_entry_when_entity_is_fully_shadow_state()
        {
            var model = new Model();
            var entityType = model.AddEntityType("RedHook");
            entityType.AddProperty("Long", typeof(int));
            entityType.AddProperty("Hammer", typeof(string));

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

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

            Assert.IsType<InternalShadowEntityEntry>(entry);

            Assert.Same(stateManager, entry.StateManager);
            Assert.Same(entityType, entry.EntityType);
            Assert.Null(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));
            var property1 = entityType.AddProperty("Long", typeof(int));
            property1.IsShadowProperty = false;
            entityType.AddProperty("Hammer", typeof(string));

            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);
        }
        protected override Model BuildModel()
        {
            var model = new Model();

            var someSimpleEntityType = model.AddEntityType(typeof(SomeSimpleEntityBase).FullName);
            var simpleKeyProperty = someSimpleEntityType.AddProperty("Id", typeof(int));
            simpleKeyProperty.RequiresValueGenerator = true;
            someSimpleEntityType.GetOrSetPrimaryKey(simpleKeyProperty);

            var someCompositeEntityType = model.AddEntityType(typeof(SomeCompositeEntityBase).FullName);
            var compositeKeyProperty1 = someCompositeEntityType.AddProperty("Id1", typeof(int));
            var compositeKeyProperty2 = someCompositeEntityType.AddProperty("Id2", typeof(string));
            someCompositeEntityType.GetOrSetPrimaryKey(new[] { compositeKeyProperty1, compositeKeyProperty2 });

            var entityType1 = model.AddEntityType(typeof(SomeEntity).FullName);
            entityType1.BaseType = someSimpleEntityType;
            var property3 = entityType1.AddProperty("Name", typeof(string));
            property3.IsConcurrencyToken = true;

            var entityType2 = model.AddEntityType(typeof(SomeDependentEntity).FullName);
            entityType2.BaseType = someCompositeEntityType;
            var fk = entityType2.AddProperty("SomeEntityId", typeof(int));
            entityType2.GetOrAddForeignKey(new[] { fk }, entityType1.FindPrimaryKey(), entityType1);
            var justAProperty = entityType2.AddProperty("JustAProperty", typeof(int));
            justAProperty.RequiresValueGenerator = true;

            var entityType3 = model.AddEntityType(typeof(FullNotificationEntity));
            entityType3.GetOrSetPrimaryKey(entityType3.AddProperty("Id", typeof(int)));
            var property6 = entityType3.AddProperty("Name", typeof(string));
            property6.IsConcurrencyToken = true;

            var entityType4 = model.AddEntityType(typeof(ChangedOnlyEntity));
            entityType4.GetOrSetPrimaryKey(entityType4.AddProperty("Id", typeof(int)));
            var property8 = entityType4.AddProperty("Name", typeof(string));
            property8.IsConcurrencyToken = true;

            var entityType5 = model.AddEntityType(typeof(SomeMoreDependentEntity).FullName);
            entityType5.BaseType = someSimpleEntityType;
            var fk5a = entityType5.AddProperty("Fk1", typeof(int));
            var fk5b = entityType5.AddProperty("Fk2", typeof(string));
            entityType5.GetOrAddForeignKey(new[] { fk5a, fk5b }, entityType2.FindPrimaryKey(), entityType2);

            return model;
        }
        public void Can_ignore_existing_entity_type_using_entity_type_name()
        {
            var model = new Model();
            var entityType = model.AddEntityType(typeof(Customer).FullName);
            var modelBuilder = CreateModelBuilder(model);

            Assert.Same(entityType, modelBuilder.Entity(typeof(Customer).FullName, ConfigurationSource.Convention).Metadata);
            Assert.False(modelBuilder.Ignore(typeof(Customer).FullName, ConfigurationSource.DataAnnotation));
            Assert.NotNull(model.FindEntityType(typeof(Customer).FullName));

            Assert.NotNull(modelBuilder.Ignore(typeof(Customer).FullName, ConfigurationSource.Explicit));

            Assert.Null(model.FindEntityType(typeof(Customer).FullName));
        }
        public void Can_ignore_existing_entity_type_using_entity_type_name_explicitly()
        {
            var model = new Model();
            var entityType = model.AddEntityType(typeof(Customer).FullName);
            var modelBuilder = CreateModelBuilder(model);

            Assert.Same(entityType, modelBuilder.Entity(typeof(Customer).FullName, ConfigurationSource.Convention).Metadata);
            Assert.False(modelBuilder.Ignore(typeof(Customer).FullName, ConfigurationSource.DataAnnotation));
            Assert.NotNull(model.FindEntityType(typeof(Customer).FullName));

            Assert.True(modelBuilder.Ignore(typeof(Customer).FullName, ConfigurationSource.Explicit));
            Assert.Null(model.FindEntityType(typeof(Customer).FullName));

            Assert.Equal(Strings.EntityIgnoredExplicitly(typeof(Customer).FullName),
                Assert.Throws<InvalidOperationException>(() =>
                    modelBuilder.Entity(typeof(Customer).FullName, ConfigurationSource.Explicit)).Message);
        }
        private static Model BuildModel()
        {
            var model = new Model();

            var entityType = model.AddEntityType(typeof(Banana));
            var pkProperty = entityType.AddProperty("Id", typeof(int));
            pkProperty.IsShadowProperty = false;
            var fkProperty = entityType.AddProperty("Fk", typeof(int));
            fkProperty.IsShadowProperty = false;

            entityType.GetOrSetPrimaryKey(pkProperty);
            var fk = entityType.GetOrAddForeignKey(fkProperty, entityType.FindPrimaryKey(), entityType);

            entityType.AddProperty("Name", typeof(string)).IsShadowProperty = false;

            fk.HasPrincipalToDependent("LesserBananas");
            fk.HasDependentToPrincipal("TopBanana");

            return model;
        }
        private static Model BuildModel()
        {
            var model = new Model();

            var entityType = model.AddEntityType(typeof(Banana));
            var property1 = entityType.AddProperty("P1", typeof(int));
            property1.IsShadowProperty = false;
            var property2 = entityType.AddProperty("P2", typeof(string));
            property2.IsShadowProperty = false;
            var property3 = entityType.AddProperty("P3", typeof(Random));
            property3.IsShadowProperty = false;
            var property4 = entityType.AddProperty("P4", typeof(int));
            property4.IsShadowProperty = false;
            var property5 = entityType.AddProperty("P5", typeof(string));
            property5.IsShadowProperty = false;
            var property6 = entityType.AddProperty("P6", typeof(Random));
            property6.IsShadowProperty = false;

            entityType.GetOrSetPrimaryKey(new[] { property1, property2, property3 });
            entityType.GetOrAddForeignKey(new[] { property4, property5, property6 }, entityType.FindPrimaryKey(), entityType);

            return model;
        }
        public virtual void Pases_on_diamond_path_to_root_principal_property()
        {
            var model = new Model();
            var entityA = model.AddEntityType(typeof(A));
            SetPrimaryKey(entityA);
            var keyA1 = CreateKey(entityA);
            var keyA2 = CreateKey(entityA, startingPropertyIndex: 0, propertyCount: 2);
            var keyA3 = CreateKey(entityA);
            var keyA4 = CreateKey(entityA, startingPropertyIndex: 2, propertyCount: 2);
            var entityB = model.AddEntityType(typeof(B));
            SetPrimaryKey(entityB);
            var keyB1 = CreateKey(entityB);
            var keyB2 = CreateKey(entityB, startingPropertyIndex: 1, propertyCount: 2);

            CreateForeignKey(keyA1, keyB1);
            CreateForeignKey(keyA2, keyB2);

            CreateForeignKey(keyB1, keyA3);
            CreateForeignKey(keyB2, keyA4);

            Validate(model);
        }
Esempio n. 46
0
        private static Model BuildModel()
        {
            var model = new Model();

            var entityType = model.AddEntityType(typeof(Banana));

            var idProperty = entityType.AddProperty("Id", typeof(int));
            idProperty.IsShadowProperty = false;
            idProperty.IsConcurrencyToken = true;
            idProperty.RequiresValueGenerator = true;
            var key = entityType.GetOrSetPrimaryKey(idProperty);

            entityType.AddProperty("Name", typeof(string)).IsShadowProperty = false;
            var property2 = entityType.AddProperty("State", typeof(string));
            property2.IsShadowProperty = false;
            property2.IsConcurrencyToken = true;

            var fkProperty = entityType.AddProperty("Fk", typeof(int?));
            fkProperty.IsShadowProperty = false;
            fkProperty.IsConcurrencyToken = true;
            entityType.GetOrAddForeignKey(fkProperty, key, entityType);

            var entityType2 = model.AddEntityType(typeof(SomeDependentEntity));
            var key2A = entityType2.AddProperty("Id1", typeof(int));
            key2A.IsShadowProperty = false;
            var key2B = entityType2.AddProperty("Id2", typeof(string));
            key2B.IsShadowProperty = false;
            entityType2.GetOrSetPrimaryKey(new[] { key2A, key2B });
            var fk = entityType2.AddProperty("SomeEntityId", typeof(int));
            fk.IsShadowProperty = false;
            entityType2.GetOrAddForeignKey(new[] { fk }, key, entityType);
            var justAProperty = entityType2.AddProperty("JustAProperty", typeof(int));
            justAProperty.IsShadowProperty = false;
            justAProperty.RequiresValueGenerator = true;

            var entityType5 = model.AddEntityType(typeof(SomeMoreDependentEntity));
            var key5 = entityType5.AddProperty("Id", typeof(int));
            key5.IsShadowProperty = false;
            entityType5.GetOrSetPrimaryKey(key5);
            var fk5A = entityType5.AddProperty("Fk1", typeof(int));
            fk5A.IsShadowProperty = false;
            var fk5B = entityType5.AddProperty("Fk2", typeof(string));
            fk5B.IsShadowProperty = false;
            entityType5.GetOrAddForeignKey(new[] { fk5A, fk5B }, entityType2.FindPrimaryKey(), entityType2);

            return model;
        }
Esempio n. 47
0
        private ForeignKey CreateOneToManySameHierarchyFK()
        {
            var model = new Model();

            var baseEntityType = model.AddEntityType(typeof(NavigationBase));
            var property1 = baseEntityType.AddProperty(NavigationBase.IdProperty);
            var pk = baseEntityType.GetOrSetPrimaryKey(property1);

            var dependentEntityType = model.AddEntityType(typeof(OneToManyDependent));
            dependentEntityType.BaseType = baseEntityType;
            var fkProp = dependentEntityType.AddProperty("Fk", typeof(int));
            var fk = dependentEntityType.AddForeignKey(new[] { fkProp }, pk, baseEntityType);

            baseEntityType.AddNavigation("OneToManyDependents", fk, pointsToPrincipal: false);
            return fk;
        }
Esempio n. 48
0
        private ForeignKey CreateOneToManyFK()
        {
            var model = new Model();
            var principalEntityType = model.AddEntityType(typeof(OneToManyPrincipal));
            var property = principalEntityType.AddProperty(NavigationBase.IdProperty);
            var pk = principalEntityType.GetOrSetPrimaryKey(property);

            var dependentEntityType = model.AddEntityType(typeof(OneToManyDependent));
            var fkProp = dependentEntityType.AddProperty(NavigationBase.IdProperty);
            var fk = dependentEntityType.AddForeignKey(new[] { fkProp }, pk, principalEntityType);

            principalEntityType.AddNavigation("OneToManyDependents", fk, pointsToPrincipal: false);
            dependentEntityType.AddNavigation("OneToManyPrincipal", fk, pointsToPrincipal: true);
            return fk;
        }
Esempio n. 49
0
        public void Context_will_use_explicit_model_if_set_in_config()
        {
            var model = new Model();
            model.AddEntityType(typeof(TheGu));

            using (var context = new EarlyLearningCenter(
                TestHelpers.Instance.CreateServiceProvider(),
                new DbContextOptionsBuilder().UseModel(model).Options))
            {
                Assert.Equal(
                    new[] { typeof(TheGu).FullName },
                    context.Model.GetEntityTypes().Select(e => e.Name).ToArray());
            }
        }
        private ForeignKey CreateOneToManySameBaseFK()
        {
            var model = new Model();

            var baseEntityType = model.AddEntityType(typeof(NavigationBase));
            var pk = baseEntityType.GetOrSetPrimaryKey(baseEntityType.GetOrAddProperty("Id", typeof(int)));

            var principalEntityType = model.AddEntityType(typeof(OneToManyPrincipal));
            principalEntityType.BaseType = baseEntityType;

            var dependentEntityType = model.AddEntityType(typeof(OneToManyDependent));
            dependentEntityType.BaseType = baseEntityType;
            var fkProp = dependentEntityType.GetOrAddProperty("Fk", typeof(int), shadowProperty: true);
            var fk = dependentEntityType.AddForeignKey(new[] { fkProp }, pk, principalEntityType);

            principalEntityType.AddNavigation("OneToManyDependents", fk, pointsToPrincipal: false);
            dependentEntityType.AddNavigation("OneToManyPrincipal", fk, pointsToPrincipal: true);
            return fk;
        }
        public virtual void Passes_on_foreign_key_cycle_with_one_GenerateOnAdd()
        {
            var model = new Model();
            var entityA = model.AddEntityType(typeof(A));
            SetPrimaryKey(entityA);
            var keyA = CreateKey(entityA);
            var entityB = model.AddEntityType(typeof(B));
            SetPrimaryKey(entityB);
            var keyB = CreateKey(entityB);

            CreateForeignKey(keyA, keyB);
            CreateForeignKey(keyB, keyA);

            keyA.Properties[0].RequiresValueGenerator = true;

            Validate(model);
        }
        private static Model BuildModel()
        {
            var model = new Model();

            var entityType = model.AddEntityType(typeof(Banana));
            var property1 = entityType.AddProperty("P1", typeof(int));
            property1.IsShadowProperty = false;
            var property2 = entityType.AddProperty("P2", typeof(int?));
            property2.IsShadowProperty = false;

            entityType.GetOrSetPrimaryKey(property1);
            entityType.GetOrAddForeignKey(property2, entityType.FindPrimaryKey(), entityType);

            return model;
        }