public void Circular_inheritance_should_throw()
{
var model = new Model();
// A
// / \
// B C
// \
// D
var a = model.AddEntityType(typeof(A).Name);
var b = model.AddEntityType(typeof(B).Name);
var c = model.AddEntityType(typeof(C).Name);
var d = model.AddEntityType(typeof(D).Name);
b.HasBaseType(a);
c.HasBaseType(a);
d.HasBaseType(c);
Assert.Equal(
CoreStrings.CircularInheritance(a, a),
Assert.Throws<InvalidOperationException>(() => { a.HasBaseType(a); }).Message);
Assert.Equal(
CoreStrings.CircularInheritance(a, b),
Assert.Throws<InvalidOperationException>(() => { a.HasBaseType(b); }).Message);
Assert.Equal(
CoreStrings.CircularInheritance(a, d),
Assert.Throws<InvalidOperationException>(() => { a.HasBaseType(d); }).Message);
}
public virtual void Does_not_detect_duplicate_table_names_for_inherited_entities()
{
var model = new Model();
var entityA = model.AddEntityType(typeof(A));
SetPrimaryKey(entityA);
var entityC = model.AddEntityType(typeof(C));
SetBaseType(entityC, entityA);
Validate(model);
}
public virtual void Detects_duplicate_table_names()
{
var model = new Model();
var entityA = model.AddEntityType(typeof(A));
SetPrimaryKey(entityA);
var entityB = model.AddEntityType(typeof(B));
SetPrimaryKey(entityB);
entityA.Relational().TableName = "Table";
entityB.Relational().TableName = "Table";
VerifyError(RelationalStrings.DuplicateTableName("Table", null, entityB.DisplayName()), model);
}
public virtual void Does_not_detect_duplicate_table_names_in_different_schema()
{
var model = new Model();
var entityA = model.AddEntityType(typeof(A));
SetPrimaryKey(entityA);
var entityB = model.AddEntityType(typeof(B));
SetPrimaryKey(entityB);
entityA.Relational().TableName = "Table";
entityA.Relational().Schema = "SchemaA";
entityB.Relational().TableName = "Table";
entityB.Relational().Schema = "SchemaB";
Validate(model);
}
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<InvalidOperationException>(() => dependentEntityType.AddForeignKey(new[] { fk }, principalKey, principalEntityType)).Message);
}
private ForeignKey CreateForeignKey()
{
var model = new Model();
var entityType = model.AddEntityType(typeof(E));
var idProperty = entityType.AddProperty("id", typeof(int));
var key = entityType.SetPrimaryKey(idProperty);
var fkProperty = entityType.AddProperty("p", typeof(int));
return entityType.AddForeignKey(fkProperty, key, entityType);
}
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 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);
}
public virtual void Detects_navigations_to_query_types()
{
var model = new Model();
var entityType = model.AddEntityType(typeof(B));
var idProperty = entityType.AddProperty("id", typeof(int));
var key = entityType.SetPrimaryKey(idProperty);
var queryType = model.AddQueryType(typeof(A));
var fkProperty = queryType.AddProperty("p", typeof(int));
var fk = queryType.AddForeignKey(fkProperty, key, entityType);
Assert.Equal(CoreStrings.NavigationToQueryType(nameof(B.ManyAs), nameof(A)),
Assert.Throws <InvalidOperationException>(() => fk.HasPrincipalToDependent(nameof(B.ManyAs))).Message);
}
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(NavigationBase.OneToManyDependentsProperty);
fk.HasDependentToPrincipal(NavigationBase.OneToManyPrincipalProperty);
return(fk);
}
public void Marking_a_property_ValueGenerated_throws_if_part_of_a_key_and_inherited_foreign_key()
{
var model = new Model();
var baseType = model.AddEntityType(typeof(BaseType));
var idProperty = baseType.GetOrAddProperty(nameof(Customer.Id), typeof(int));
var idProperty2 = baseType.GetOrAddProperty("id2", typeof(int));
var key = baseType.GetOrAddKey(new[] { idProperty, idProperty2 });
IMutableEntityType entityType = model.AddEntityType(typeof(Customer));
entityType.BaseType = baseType;
var fkProperty = entityType.AddProperty("fk", typeof(int));
entityType.AddForeignKey(new[] { fkProperty, idProperty }, key, entityType);
Assert.Equal(
CoreStrings.ForeignKeyPropertyInKey(
nameof(Customer.Id),
typeof(Customer).Name,
"{'" + nameof(Customer.Id) + "'" + ", 'id2'}",
typeof(BaseType).Name),
Assert.Throws <InvalidOperationException>(() => idProperty.ValueGenerated = ValueGenerated.OnAdd).Message);
}
public void Can_ignore_existing_entity_type_using_entity_type_name()
{
var model = new Model();
var entityType = model.AddEntityType(typeof(Customer).FullName, 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 void Delegate_accessor_always_creates_collections_that_use_reference_equality_comparer()
{
IMutableModel model = new Model();
var entityType = model.AddEntityType(typeof(MyEntity));
var otherType = model.AddEntityType(typeof(MyEntityWithCustomComparer));
var foreignKey = otherType.AddForeignKey(
otherType.AddProperty("MyEntityId", typeof(int)),
entityType.SetPrimaryKey(entityType.AddProperty("Id", typeof(int))),
entityType);
var navigation = foreignKey.HasPrincipalToDependent(
typeof(MyEntity).GetProperty(
nameof(MyEntity.AsICollectionWithCustomComparer),
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance));
new BackingFieldConvention(new TestLogger <DbLoggerCategory.Model, TestLoggingDefinitions>())
.Apply(((ForeignKey)foreignKey).Builder, (Navigation)navigation);
var accessor = new ClrCollectionAccessorFactory().Create(navigation);
var entity = new MyEntity(initialize: false);
var value = new MyEntityWithCustomComparer
{
Id = 1
};
Assert.False(accessor.Contains(entity, value));
accessor.Add(entity, value);
value.Id = 42;
accessor.Add(entity, value);
Assert.Equal(1, entity.AsICollectionWithCustomComparer.Count);
}
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));
compositeKeyProperty2.IsNullable = false;
someCompositeEntityType.GetOrSetPrimaryKey(new[] { compositeKeyProperty1, compositeKeyProperty2 });
var entityType1 = model.AddEntityType(typeof(SomeEntity).FullName);
entityType1.HasBaseType(someSimpleEntityType);
var property3 = entityType1.AddProperty("Name", typeof(string));
property3.IsConcurrencyToken = true;
var entityType2 = model.AddEntityType(typeof(SomeDependentEntity).FullName);
entityType2.HasBaseType(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;
entityType3.ChangeTrackingStrategy = ChangeTrackingStrategy.ChangingAndChangedNotifications;
var entityType4 = model.AddEntityType(typeof(ChangedOnlyEntity));
entityType4.GetOrSetPrimaryKey(entityType4.AddProperty("Id", typeof(int)));
var property8 = entityType4.AddProperty("Name", typeof(string));
property8.IsConcurrencyToken = true;
entityType4.ChangeTrackingStrategy = ChangeTrackingStrategy.ChangedNotifications;
var entityType5 = model.AddEntityType(typeof(SomeMoreDependentEntity).FullName);
entityType5.HasBaseType(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_only_override_existing_Shadow_value_explicitly()
{
var model = new Model();
var metadata = model.AddEntityType(typeof(Customer)).AddProperty(Customer.NameProperty.Name);
Assert.Null(metadata.GetIsShadowPropertyConfigurationSource());
metadata.IsShadowProperty = false;
var builder = CreateInternalPropertyBuilder(metadata);
Assert.Equal(ConfigurationSource.Explicit, metadata.GetIsShadowPropertyConfigurationSource());
Assert.True(builder.IsShadow(false, ConfigurationSource.DataAnnotation));
Assert.False(builder.IsShadow(true, ConfigurationSource.DataAnnotation));
Assert.False(builder.Metadata.IsShadowProperty);
Assert.True(builder.IsShadow(true, ConfigurationSource.Explicit));
Assert.True(builder.Metadata.IsShadowProperty);
}
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 Can_only_override_existing_ClrType_value_explicitly()
{
var model = new Model();
model.AddEntityType(typeof(Customer)).AddProperty(Customer.NameProperty.Name);
var modelBuilder = new InternalModelBuilder(model);
var entityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit);
var builder = entityBuilder.Property(Customer.NameProperty.Name, ConfigurationSource.Convention);
Assert.Null(builder.Metadata.GetClrTypeConfigurationSource());
builder.Metadata.ClrType = typeof(string);
Assert.Equal(ConfigurationSource.Explicit, builder.Metadata.GetClrTypeConfigurationSource());
Assert.True(builder.HasClrType(typeof(string), ConfigurationSource.DataAnnotation));
Assert.False(builder.HasClrType(typeof(int), ConfigurationSource.DataAnnotation));
Assert.Equal(typeof(string), builder.Metadata.ClrType);
Assert.True(builder.HasClrType(typeof(int), ConfigurationSource.Explicit));
Assert.Equal(typeof(int), builder.Metadata.ClrType);
}
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), shadow: false);
entityType.AddProperty("Hammer", typeof(string), shadow: 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);
}
public void Can_only_override_existing_ClrType_value_explicitly()
{
var model = new Model();
model.AddEntityType(typeof(Customer)).AddProperty(Customer.NameProperty.Name);
var modelBuilder = new InternalModelBuilder(model);
var entityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit);
var builder = entityBuilder.Property(Customer.NameProperty.Name, ConfigurationSource.Convention);
Assert.Null(builder.Metadata.GetClrTypeConfigurationSource());
builder.Metadata.ClrType = typeof(string);
Assert.Equal(ConfigurationSource.Explicit, builder.Metadata.GetClrTypeConfigurationSource());
Assert.True(builder.HasClrType(typeof(string), ConfigurationSource.DataAnnotation));
Assert.False(builder.HasClrType(typeof(int), ConfigurationSource.DataAnnotation));
Assert.Equal(typeof(string), builder.Metadata.ClrType);
Assert.True(builder.HasClrType(typeof(int), ConfigurationSource.Explicit));
Assert.Equal(typeof(int), builder.Metadata.ClrType);
}
public void Can_add_and_remove_entity_by_type()
{
var model = new Model();
Assert.Null(model.FindEntityType(typeof(Customer)));
Assert.Null(model.RemoveEntityType(typeof(Customer)));
var entityType = model.AddEntityType(typeof(Customer));
Assert.Equal(typeof(Customer), entityType.ClrType);
Assert.NotNull(model.FindEntityType(typeof(Customer)));
Assert.Same(model, entityType.Model);
Assert.NotNull(entityType.Builder);
Assert.Same(entityType, model.GetOrAddEntityType(typeof(Customer)));
Assert.Equal(new[] { entityType }, model.GetEntityTypes().ToArray());
Assert.Same(entityType, model.RemoveEntityType(entityType.ClrType));
Assert.Null(model.RemoveEntityType(entityType.ClrType));
Assert.Null(model.FindEntityType(typeof(Customer)));
Assert.Null(entityType.Builder);
}
public void Can_add_and_remove_entity_by_type()
{
var model = new Model();
Assert.Null(model.FindEntityType(typeof(Customer)));
Assert.Null(model.RemoveEntityType(typeof(Customer)));
var entityType = model.AddEntityType(typeof(Customer));
Assert.Equal(typeof(Customer), entityType.ClrType);
Assert.NotNull(model.FindEntityType(typeof(Customer)));
Assert.Same(model, entityType.Model);
Assert.NotNull(entityType.Builder);
Assert.Same(entityType, model.GetOrAddEntityType(typeof(Customer)));
Assert.Equal(new[] { entityType }, model.GetEntityTypes().ToArray());
Assert.Same(entityType, model.RemoveEntityType(entityType.ClrType));
Assert.Null(model.RemoveEntityType(entityType.ClrType));
Assert.Null(model.FindEntityType(typeof(Customer)));
Assert.Null(entityType.Builder);
}
public void Can_only_override_existing_Shadow_value_explicitly()
{
var model = new Model();
var metadata = model.AddEntityType(typeof(Customer)).AddProperty(Customer.NameProperty.Name);
Assert.Null(metadata.GetIsShadowPropertyConfigurationSource());
metadata.IsShadowProperty = false;
var builder = CreateInternalPropertyBuilder(metadata);
Assert.Equal(ConfigurationSource.Explicit, metadata.GetIsShadowPropertyConfigurationSource());
Assert.True(builder.IsShadow(false, ConfigurationSource.DataAnnotation));
Assert.False(builder.IsShadow(true, ConfigurationSource.DataAnnotation));
Assert.False(builder.Metadata.IsShadowProperty);
Assert.True(builder.IsShadow(true, ConfigurationSource.Explicit));
Assert.True(builder.Metadata.IsShadowProperty);
}
public void Setting_base_type_throws_when_grandchild_contain_duplicate_property()
{
var model = new Model();
var a = model.AddEntityType(typeof(A));
a.AddProperty(A.EProperty);
a.AddProperty(A.GProperty);
var c = model.AddEntityType(typeof(C));
var d = model.AddEntityType(typeof(D));
d.AddProperty(A.EProperty);
d.AddProperty(A.GProperty);
d.HasBaseType(c);
Assert.Equal(
CoreStrings.DuplicatePropertiesOnBase(typeof(C).FullName, typeof(A).FullName, "E, G"),
Assert.Throws<InvalidOperationException>(() => { c.HasBaseType(a); }).Message);
}
public void Index_on_base_type_should_be_inherited()
{
var model = new Model();
var orderType = model.AddEntityType(typeof(Order));
var indexProperty = orderType.GetOrAddProperty(Order.CustomerIdProperty);
var index = orderType.GetOrAddIndex(indexProperty);
var specialOrderType = model.AddEntityType(typeof(SpecialOrder));
var derivedIndexProperty = specialOrderType.GetOrAddProperty(Order.IdProperty);
specialOrderType.GetOrAddIndex(derivedIndexProperty);
Assert.Equal(new[] { new[] { Order.CustomerIdProperty.Name } },
orderType.GetIndexes().Select(fk => fk.Properties.Select(p => p.Name).ToArray()).ToArray());
Assert.Equal(new[] { new[] { Order.IdProperty.Name } },
specialOrderType.GetIndexes().Select(fk => fk.Properties.Select(p => p.Name).ToArray()).ToArray());
specialOrderType.HasBaseType(orderType);
Assert.Equal(new[] { new[] { Order.CustomerIdProperty.Name } },
orderType.GetIndexes().Select(fk => fk.Properties.Select(p => p.Name).ToArray()).ToArray());
Assert.Equal(new[] { new[] { Order.CustomerIdProperty.Name }, new[] { Order.IdProperty.Name } },
specialOrderType.GetIndexes().Select(fk => fk.Properties.Select(p => p.Name).ToArray()).ToArray());
Assert.Same(index, specialOrderType.GetOrAddIndex(indexProperty));
}
public void Can_remove_implicitly_created_join_entity_type()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
var manyToManyLeft = modelBuilder.Entity(typeof(ManyToManyLeft), ConfigurationSource.Convention);
var manyToManyRight = modelBuilder.Entity(typeof(ManyToManyRight), ConfigurationSource.Convention);
var manyToManyLeftPK = manyToManyLeft.PrimaryKey(new[] { nameof(ManyToManyLeft.Id) }, ConfigurationSource.Convention);
var manyToManyRightPK = manyToManyRight.PrimaryKey(new[] { nameof(ManyToManyRight.Id) }, ConfigurationSource.Convention);
var skipNavOnLeft = manyToManyLeft.HasSkipNavigation(
new MemberIdentity(typeof(ManyToManyLeft).GetProperty(nameof(ManyToManyLeft.Rights))),
manyToManyRight.Metadata,
ConfigurationSource.Convention);
var skipNavOnRight = manyToManyRight.HasSkipNavigation(
new MemberIdentity(typeof(ManyToManyRight).GetProperty(nameof(ManyToManyRight.Lefts))),
manyToManyLeft.Metadata,
ConfigurationSource.Convention);
skipNavOnLeft.HasInverse(skipNavOnRight.Metadata, ConfigurationSource.Convention);
var joinEntityTypeBuilder =
model.AddEntityType(
"JoinEntity",
typeof(Dictionary <string, object>),
owned: false,
ConfigurationSource.Convention).Builder;
var leftFK = joinEntityTypeBuilder
.HasRelationship(
manyToManyLeft.Metadata.Name,
new List <string> {
"ManyToManyLeft_Id"
},
manyToManyLeftPK.Metadata,
ConfigurationSource.Convention)
.IsUnique(false, ConfigurationSource.Convention)
.Metadata;
var rightFK = joinEntityTypeBuilder
.HasRelationship(
manyToManyRight.Metadata.Name,
new List <string> {
"ManyToManyRight_Id"
},
manyToManyRightPK.Metadata,
ConfigurationSource.Convention)
.IsUnique(false, ConfigurationSource.Convention)
.Metadata;
skipNavOnLeft.HasForeignKey(leftFK, ConfigurationSource.Convention);
skipNavOnRight.HasForeignKey(rightFK, ConfigurationSource.Convention);
joinEntityTypeBuilder.PrimaryKey(
leftFK.Properties.Concat(rightFK.Properties).ToList(),
ConfigurationSource.Convention);
var joinEntityType = joinEntityTypeBuilder.Metadata;
Assert.NotNull(joinEntityType);
Assert.NotNull(modelBuilder.RemoveImplicitJoinEntity(joinEntityType));
Assert.Empty(
model.GetEntityTypes()
.Where(e => e.IsImplicitlyCreatedJoinEntityType));
var leftSkipNav = manyToManyLeft.Metadata.FindDeclaredSkipNavigation(nameof(ManyToManyLeft.Rights));
var rightSkipNav = manyToManyRight.Metadata.FindDeclaredSkipNavigation(nameof(ManyToManyRight.Lefts));
Assert.NotNull(leftSkipNav);
Assert.NotNull(rightSkipNav);
}
public void Adding_keys_throws_when_there_is_a_parent_type()
{
var model = new Model();
var a = model.AddEntityType(typeof(A));
var b = model.AddEntityType(typeof(B));
b.HasBaseType(a);
Assert.Equal(
CoreStrings.DerivedEntityTypeKey(typeof(B).Name, typeof(A).Name),
Assert.Throws<InvalidOperationException>(() => b.SetPrimaryKey(b.AddProperty("G"))).Message);
Assert.Equal(
CoreStrings.DerivedEntityTypeKey(typeof(B).Name, typeof(A).Name),
Assert.Throws<InvalidOperationException>(() => b.AddKey(b.AddProperty("E"))).Message);
}
public void Adding_foreignKey_throws_when_grandchild_type_has_foreignKey_on_same_properties()
{
var model = new Model();
var customerType = model.AddEntityType(typeof(Customer));
var customerKey = customerType.GetOrAddKey(customerType.GetOrAddProperty(Customer.IdProperty));
var orderType = model.AddEntityType(typeof(Order));
var foreignKeyProperty = orderType.GetOrAddProperty(Order.CustomerIdProperty);
var specialOrderType = model.AddEntityType(typeof(SpecialOrder));
specialOrderType.HasBaseType(orderType);
var verySpecialOrderType = model.AddEntityType(typeof(VerySpecialOrder));
verySpecialOrderType.HasBaseType(specialOrderType);
verySpecialOrderType.AddForeignKey(foreignKeyProperty, customerKey, customerType);
Assert.Equal(
CoreStrings.DuplicateForeignKey(
Property.Format(new[] { foreignKeyProperty }),
typeof(Order).Name,
typeof(VerySpecialOrder).Name,
Property.Format(customerKey.Properties),
typeof(Customer).Name),
Assert.Throws<InvalidOperationException>(() =>
orderType.AddForeignKey(foreignKeyProperty, customerKey, customerType)).Message);
}
public void Setting_base_type_throws_when_grandchild_contain_duplicate_navigation()
{
var model = new Model();
var customerType = model.AddEntityType(typeof(Customer));
var customerKey = customerType.GetOrAddKey(customerType.GetOrAddProperty(Customer.IdProperty));
var orderType = model.AddEntityType(typeof(Order));
var foreignKeyProperty = orderType.GetOrAddProperty(Order.CustomerIdProperty);
var customerForeignKey = orderType.GetOrAddForeignKey(foreignKeyProperty, customerKey, customerType);
customerForeignKey.HasDependentToPrincipal("Customer");
var specialOrderType = model.AddEntityType(typeof(SpecialOrder));
specialOrderType.HasBaseType(orderType);
var specialCustomerType = model.AddEntityType(typeof(SpecialCustomer));
var verySpecialOrderType = model.AddEntityType(typeof(VerySpecialOrder));
var derivedForeignKeyProperty = verySpecialOrderType.GetOrAddProperty(Order.IdProperty);
var property = specialCustomerType.AddProperty("AltId", typeof(int));
var specialCustomerKey = specialCustomerType.GetOrAddKey(property);
var specialCustomerForeignKey = verySpecialOrderType.GetOrAddForeignKey(derivedForeignKeyProperty, specialCustomerKey, specialCustomerType);
specialCustomerForeignKey.HasDependentToPrincipal("Customer");
Assert.Equal(
CoreStrings.DuplicateNavigationsOnBase(typeof(VerySpecialOrder).FullName, typeof(SpecialOrder).FullName, "Customer"),
Assert.Throws<InvalidOperationException>(() => { verySpecialOrderType.HasBaseType(specialOrderType); }).Message);
}
public void FK_properties_are_marked_as_requiring_original_values()
{
var model = new Model();
var entityType = model.AddEntityType(typeof(FullNotificationEntity));
var key = entityType.GetOrSetPrimaryKey(entityType.AddProperty(FullNotificationEntity.IdProperty));
var fkProperty = entityType.AddProperty("Fk", typeof(int));
Assert.Equal(-1, fkProperty.GetOriginalValueIndex());
entityType.GetOrAddForeignKey(new[] { fkProperty }, key, entityType);
Assert.Equal(0, fkProperty.GetOriginalValueIndex());
}
public void Navigations_should_be_updated_when_base_type_changes()
{
var model = new Model();
var customerType = model.AddEntityType(typeof(Customer));
var customerKey = customerType.GetOrAddKey(customerType.GetOrAddProperty(Customer.IdProperty));
var orderType = model.AddEntityType(typeof(SpecialOrder));
var foreignKeyProperty = orderType.GetOrAddProperty(Order.CustomerIdProperty);
var customerForeignKey = orderType.GetOrAddForeignKey(foreignKeyProperty, customerKey, customerType);
customerForeignKey.HasPrincipalToDependent("Orders");
var specialCustomerType = model.AddEntityType(typeof(SpecialCustomer));
specialCustomerType.HasBaseType(customerType);
var derivedForeignKeyProperty = orderType.GetOrAddProperty(Order.IdProperty);
var specialCustomerForeignKey = orderType.GetOrAddForeignKey(derivedForeignKeyProperty, customerKey, specialCustomerType);
specialCustomerForeignKey.HasPrincipalToDependent("DerivedOrders");
specialCustomerType.HasBaseType(null);
Assert.Equal(new[] { "Orders" }, customerType.GetNavigations().Select(p => p.Name).ToArray());
Assert.Equal(new[] { "DerivedOrders" }, specialCustomerType.GetNavigations().Select(p => p.Name).ToArray());
}
public void Adding_navigation_throws_when_grandchild_type_has_navigation_with_same_name()
{
var model = new Model();
var customerType = model.AddEntityType(typeof(Customer));
var customerKey = customerType.GetOrAddKey(customerType.GetOrAddProperty(Customer.IdProperty));
var orderType = model.AddEntityType(typeof(SpecialOrder));
var foreignKeyProperty = orderType.GetOrAddProperty(Order.CustomerIdProperty);
var customerForeignKey = orderType.GetOrAddForeignKey(foreignKeyProperty, customerKey, customerType);
var specialCustomerType = model.AddEntityType(typeof(SpecialCustomer));
specialCustomerType.HasBaseType(customerType);
var verySpecialCustomerType = model.AddEntityType(typeof(VerySpecialCustomer));
verySpecialCustomerType.HasBaseType(specialCustomerType);
var derivedForeignKeyProperty = orderType.GetOrAddProperty(Order.IdProperty);
var specialCustomerForeignKey = orderType.GetOrAddForeignKey(derivedForeignKeyProperty, customerKey, verySpecialCustomerType);
specialCustomerForeignKey.HasPrincipalToDependent("Orders");
Assert.Equal(
CoreStrings.NavigationForWrongForeignKey("Orders", typeof(VerySpecialCustomer).Name, "{'CustomerId'}", "{'Id'}"),
Assert.Throws<InvalidOperationException>(() =>
customerForeignKey.HasPrincipalToDependent("Orders")).Message);
Assert.Equal("Orders", ((IEntityType)verySpecialCustomerType).GetNavigations().Single().Name);
}
public void Keys_on_base_type_should_be_inherited()
{
var model = new Model();
var a = model.AddEntityType(typeof(A));
var g = a.AddProperty(A.GProperty);
g.IsNullable = false;
var e = a.AddProperty(A.EProperty);
e.IsNullable = false;
var pk = a.SetPrimaryKey(g);
a.AddKey(e);
var b = model.AddEntityType(typeof(B));
b.AddProperty(B.FProperty);
Assert.Equal(new[] { new[] { "E" }, new[] { "G" } },
a.GetKeys().Select(fk => fk.Properties.Select(p => p.Name).ToArray()).ToArray());
Assert.Equal(new string[0][],
b.GetKeys().Select(fk => fk.Properties.Select(p => p.Name).ToArray()).ToArray());
Assert.Equal(new[] { "G", "E" }, a.GetProperties().Select(p => p.Name).ToArray());
Assert.Equal(new[] { "F" }, b.GetProperties().Select(p => p.Name).ToArray());
b.HasBaseType(a);
Assert.Equal(new[] { new[] { "E" }, new[] { "G" } },
a.GetKeys().Select(fk => fk.Properties.Select(p => p.Name).ToArray()).ToArray());
Assert.Equal(new[] { new[] { "E" }, new[] { "G" } },
b.GetKeys().Select(fk => fk.Properties.Select(p => p.Name).ToArray()).ToArray());
Assert.Equal(new[] { "G", "E" }, a.GetProperties().Select(p => p.Name).ToArray());
Assert.Equal(new[] { "G", "E", "F" }, b.GetProperties().Select(p => p.Name).ToArray());
Assert.Equal(new[] { 0, 1, 2 }, b.GetProperties().Select(p => p.GetIndex()));
Assert.Same(pk, b.FindPrimaryKey(new[] { b.FindProperty("G") }));
Assert.Same(b.FindKey(b.FindProperty("G")), a.FindKey(a.FindProperty("G")));
}
public void Navigations_on_base_type_should_be_inherited()
{
var model = new Model();
var customerType = model.AddEntityType(typeof(Customer));
var customerKey = customerType.GetOrAddKey(customerType.GetOrAddProperty(Customer.IdProperty));
var orderType = model.AddEntityType(typeof(SpecialOrder));
var foreignKeyProperty = orderType.GetOrAddProperty(Order.CustomerIdProperty);
var customerForeignKey = orderType.GetOrAddForeignKey(foreignKeyProperty, customerKey, customerType);
customerForeignKey.HasPrincipalToDependent("Orders");
var specialCustomerType = model.AddEntityType(typeof(SpecialCustomer));
Assert.Equal(new[] { "Orders" }, customerType.GetNavigations().Select(p => p.Name).ToArray());
Assert.Equal(new string[0], specialCustomerType.GetNavigations().Select(p => p.Name).ToArray());
specialCustomerType.HasBaseType(customerType);
Assert.Equal(new[] { "Orders" }, customerType.GetNavigations().Select(p => p.Name).ToArray());
Assert.Equal(new[] { "Orders" }, specialCustomerType.GetNavigations().Select(p => p.Name).ToArray());
var derivedForeignKeyProperty = orderType.GetOrAddProperty(Order.IdProperty);
var specialCustomerForeignKey = orderType.GetOrAddForeignKey(derivedForeignKeyProperty, customerKey, specialCustomerType);
specialCustomerForeignKey.HasPrincipalToDependent("DerivedOrders");
Assert.Equal(new[] { "Orders" }, customerType.GetNavigations().Select(p => p.Name).ToArray());
Assert.Equal(new[] { "Orders", "DerivedOrders" }, specialCustomerType.GetNavigations().Select(p => p.Name).ToArray());
Assert.Equal(new[] { "Orders", "DerivedOrders" }, ((IEntityType)specialCustomerType).GetNavigations().Select(p => p.Name).ToArray());
Assert.Same(customerType.FindNavigation("Orders"), specialCustomerType.FindNavigation("Orders"));
}
public void Setting_base_type_throws_when_child_contains_key()
{
var model = new Model();
var a = model.AddEntityType(typeof(A));
var b = model.AddEntityType(typeof(B));
var h = b.AddProperty(B.HProperty);
h.IsNullable = false;
var key = b.AddKey(h);
Assert.Equal(
CoreStrings.DerivedEntityCannotHaveKeys(typeof(B).FullName),
Assert.Throws<InvalidOperationException>(() => { b.HasBaseType(a); }).Message);
b.RemoveKey(key.Properties);
var f = b.AddProperty(B.FProperty);
f.IsNullable = false;
b.SetPrimaryKey(f);
Assert.Equal(
CoreStrings.DerivedEntityCannotHaveKeys(typeof(B).FullName),
Assert.Throws<InvalidOperationException>(() => { b.HasBaseType(a); }).Message);
}
public void Setting_base_type_throws_when_parent_contains_duplicate_property()
{
var model = new Model();
var a = model.AddEntityType(typeof(A));
a.AddProperty(A.GProperty);
var b = model.AddEntityType(typeof(B));
b.AddProperty(A.GProperty);
Assert.Equal(
CoreStrings.DuplicatePropertiesOnBase(typeof(B).FullName, typeof(A).FullName, "G"),
Assert.Throws<InvalidOperationException>(() => { b.HasBaseType(a); }).Message);
}
public void ForeignKeys_should_be_updated_when_base_type_changes()
{
var model = new Model();
var customerType = model.AddEntityType(typeof(SpecialCustomer));
var customerKey = customerType.GetOrAddKey(customerType.GetOrAddProperty(Customer.IdProperty));
var orderType = model.AddEntityType(typeof(Order));
var specialOrderType = model.AddEntityType(typeof(SpecialOrder));
specialOrderType.HasBaseType(orderType);
var derivedForeignKeyProperty = specialOrderType.GetOrAddProperty(Order.IdProperty);
specialOrderType.GetOrAddForeignKey(derivedForeignKeyProperty, customerKey, customerType);
var foreignKeyProperty = orderType.GetOrAddProperty(Order.CustomerIdProperty);
orderType.GetOrAddForeignKey(foreignKeyProperty, customerKey, customerType);
specialOrderType.HasBaseType(null);
Assert.Equal(new[] { new[] { Order.CustomerIdProperty.Name } },
orderType.GetForeignKeys().Select(fk => fk.Properties.Select(p => p.Name).ToArray()).ToArray());
Assert.Equal(new[] { new[] { Order.IdProperty.Name } },
specialOrderType.GetForeignKeys().Select(fk => fk.Properties.Select(p => p.Name).ToArray()).ToArray());
}
public void Adding_property_throws_when_grandchild_type_has_property_with_same_name()
{
var model = new Model();
var a = model.AddEntityType(typeof(A));
var c = model.AddEntityType(typeof(C));
c.HasBaseType(a);
var d = model.AddEntityType(typeof(D));
d.HasBaseType(c);
d.AddProperty(A.GProperty);
Assert.Equal(
CoreStrings.DuplicateProperty("G", typeof(A).Name, typeof(D).Name),
Assert.Throws<InvalidOperationException>(() => a.AddProperty(A.GProperty)).Message);
}
public void Setting_CLR_base_for_shadow_entity_type_should_throw()
{
var model = new Model();
var a = model.AddEntityType(typeof(A));
var b = model.AddEntityType(typeof(B).Name);
Assert.Equal(
CoreStrings.NonShadowBaseType(b, a),
Assert.Throws<InvalidOperationException>(() => { b.HasBaseType(a); }).Message);
}
public void Keys_added_to_base_type_should_be_inherited()
{
var model = new Model();
var a = model.AddEntityType(typeof(A));
a.AddProperty(A.GProperty).IsNullable = false;
a.AddProperty(A.EProperty).IsNullable = false;
var b = model.AddEntityType(typeof(B));
b.AddProperty(B.FProperty);
b.HasBaseType(a);
a.SetPrimaryKey(a.FindProperty("G"));
a.AddKey(a.FindProperty("E"));
Assert.Equal(new[] { new[] { "E" }, new[] { "G" } },
a.GetKeys().Select(fk => fk.Properties.Select(p => p.Name).ToArray()).ToArray());
Assert.Equal(new[] { new[] { "E" }, new[] { "G" } },
b.GetKeys().Select(fk => fk.Properties.Select(p => p.Name).ToArray()).ToArray());
Assert.Equal(new[] { "G", "E" }, a.GetProperties().Select(p => p.Name).ToArray());
Assert.Equal(new[] { "G", "E", "F" }, b.GetProperties().Select(p => p.Name).ToArray());
}
public void Keys_should_be_updated_when_base_type_changes()
{
var model = new Model();
var a = model.AddEntityType(typeof(A));
var g = a.AddProperty(A.GProperty);
g.IsNullable = false;
a.SetPrimaryKey(g);
var e = a.AddProperty(A.EProperty);
e.IsNullable = false;
a.AddKey(e);
var b = model.AddEntityType(typeof(B));
b.AddProperty(B.FProperty);
b.HasBaseType(a);
b.HasBaseType(null);
Assert.Equal(new[] { new[] { "E" }, new[] { "G" } },
a.GetKeys().Select(fk => fk.Properties.Select(p => p.Name).ToArray()).ToArray());
Assert.Equal(new string[0][],
b.GetKeys().Select(fk => fk.Properties.Select(p => p.Name).ToArray()).ToArray());
Assert.Equal(new[] { "G", "E" }, a.GetProperties().Select(p => p.Name).ToArray());
Assert.Equal(new[] { "F" }, b.GetProperties().Select(p => p.Name).ToArray());
}
