public void Can_mark_type_as_owned_type()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
var entityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit);
Assert.NotNull(modelBuilder.Entity(typeof(Details), ConfigurationSource.Convention));
Assert.False(model.IsOwned(typeof(Details)));
Assert.NotNull(entityBuilder.HasOwnership(typeof(Details), nameof(Customer.Details), ConfigurationSource.Convention));
Assert.NotNull(modelBuilder.Ignore(typeof(Details), ConfigurationSource.Convention));
Assert.Empty(model.GetEntityTypes(typeof(Details)));
Assert.Null(entityBuilder.HasOwnership(typeof(Details), nameof(Customer.Details), ConfigurationSource.Convention));
Assert.Null(modelBuilder.Owned(typeof(Details), ConfigurationSource.Convention));
Assert.NotNull(entityBuilder.HasOwnership(typeof(Details), nameof(Customer.Details), ConfigurationSource.DataAnnotation));
Assert.NotNull(modelBuilder.Owned(typeof(Details), ConfigurationSource.Convention));
Assert.NotNull(modelBuilder.Owned(typeof(Details), ConfigurationSource.DataAnnotation));
Assert.True(model.IsOwned(typeof(Details)));
Assert.NotNull(
modelBuilder.Entity(typeof(Product), ConfigurationSource.Explicit)
.HasOwnership(typeof(Details), nameof(Product.Details), ConfigurationSource.Convention));
Assert.Null(modelBuilder.Ignore(typeof(Details), ConfigurationSource.Convention));
Assert.Equal(2, model.GetEntityTypes(typeof(Details)).Count());
Assert.Equal(
CoreStrings.ClashingSharedType(typeof(Details).Name),
Assert.Throws <InvalidOperationException>(() => modelBuilder.Entity(typeof(Details), ConfigurationSource.Explicit)).Message);
Assert.Equal(
CoreStrings.ClashingOwnedEntityType(typeof(Details).Name),
Assert.Throws <InvalidOperationException>(()
=> modelBuilder.SharedTypeEntity(nameof(Details), typeof(Details), ConfigurationSource.Explicit)).Message);
Assert.NotNull(modelBuilder.Ignore(typeof(Details), ConfigurationSource.Explicit));
Assert.False(model.IsOwned(typeof(Details)));
Assert.NotNull(modelBuilder.SharedTypeEntity(nameof(Details), typeof(Details), ConfigurationSource.Explicit));
Assert.Empty(model.GetEntityTypes(typeof(Details)).Where(e => !e.HasSharedClrType));
Assert.Null(modelBuilder.Owned(typeof(Details), ConfigurationSource.Convention));
Assert.Equal(
CoreStrings.ClashingNonOwnedEntityType(typeof(Details).Name),
Assert.Throws <InvalidOperationException>(() => modelBuilder.Owned(typeof(Details), ConfigurationSource.Explicit)).Message);
}
public void Can_add_and_remove_entity_by_name()
{
var model = new Model();
Assert.Null(model.FindEntityType(typeof(Customer).FullName));
Assert.Null(model.RemoveEntityType(typeof(Customer).FullName));
var entityType = model.AddEntityType(typeof(Customer).FullName);
Assert.Null(entityType.ClrType);
Assert.Equal(typeof(Customer).FullName, entityType.Name);
Assert.NotNull(model.FindEntityType(typeof(Customer).FullName));
Assert.Same(model, entityType.Model);
Assert.NotNull(entityType.Builder);
Assert.Same(entityType, model.GetOrAddEntityType(typeof(Customer).FullName));
Assert.Equal(new[] { entityType }, model.GetEntityTypes().ToArray());
Assert.Same(entityType, model.RemoveEntityType(entityType.Name));
Assert.Null(model.RemoveEntityType(entityType.Name));
Assert.Null(model.FindEntityType(typeof(Customer).FullName));
Assert.Null(entityType.Builder);
}
public void Entities_are_ordered_by_name()
{
var model = new Model();
var entityType1 = model.AddEntityType(typeof(Order));
var entityType2 = model.AddEntityType(typeof(Customer));
Assert.True(new[] { entityType2, entityType1 }.SequenceEqual(model.GetEntityTypes()));
}
public void Can_add_weak_entity_types()
{
IMutableModel model = new Model();
var customerType = model.AddEntityType(typeof(Customer));
var idProperty = customerType.GetOrAddProperty(Customer.IdProperty);
var customerKey = customerType.AddKey(idProperty);
var dependentOrderType = model.AddEntityType(typeof(Order), nameof(Customer.Orders), customerType);
var fkProperty = dependentOrderType.AddProperty("ShadowId", typeof(int));
var orderKey = dependentOrderType.AddKey(fkProperty);
var fk = dependentOrderType.AddForeignKey(fkProperty, customerKey, customerType);
var index = dependentOrderType.AddIndex(fkProperty);
Assert.Same(fkProperty, dependentOrderType.GetProperties().Single());
Assert.Same(orderKey, dependentOrderType.GetKeys().Single());
Assert.Same(fk, dependentOrderType.GetForeignKeys().Single());
Assert.Same(index, dependentOrderType.GetIndexes().Single());
Assert.Equal(new[] { customerType, dependentOrderType }, model.GetEntityTypes());
Assert.True(model.HasEntityTypeWithDefiningNavigation(typeof(Order)));
Assert.True(model.HasEntityTypeWithDefiningNavigation(typeof(Order).DisplayName()));
Assert.Same(
dependentOrderType,
model.FindEntityType(typeof(Order).DisplayName(), nameof(Customer.Orders), customerType));
Assert.Same(
dependentOrderType,
model.FindEntityType(typeof(Order).DisplayName(), nameof(Customer.Orders), (IEntityType)customerType));
Assert.Equal(
CoreStrings.ClashingWeakEntityType(typeof(Order).DisplayName(fullName: false)),
Assert.Throws <InvalidOperationException>(() => model.AddEntityType(typeof(Order))).Message);
Assert.Equal(
CoreStrings.ClashingNonWeakEntityType(
nameof(Customer) + "." + nameof(Customer.Orders) + "#"
+ nameof(Order) + "." + nameof(Order.Customer) + "#" + nameof(Customer)),
Assert.Throws <InvalidOperationException>(
() => model.AddEntityType(typeof(Customer), nameof(Order.Customer), dependentOrderType)).Message);
Assert.Equal(
CoreStrings.ForeignKeySelfReferencingDependentEntityType(
nameof(Customer) + "." + nameof(Customer.Orders) + "#" + nameof(Order)),
Assert.Throws <InvalidOperationException>(
() => dependentOrderType.AddForeignKey(fkProperty, orderKey, dependentOrderType)).Message);
Assert.Equal(
CoreStrings.EntityTypeInUseByForeignKey(
nameof(Customer) + "." + nameof(Customer.Orders) + "#" + nameof(Order),
nameof(Customer), fk.Properties.Format()),
Assert.Throws <InvalidOperationException>(() => model.RemoveEntityType(dependentOrderType)).Message);
dependentOrderType.RemoveForeignKey(fk.Properties, fk.PrincipalKey, fk.PrincipalEntityType);
Assert.Same(
dependentOrderType, model.RemoveEntityType(
typeof(Order), nameof(Customer.Orders), customerType));
Assert.Null(((EntityType)dependentOrderType).Builder);
Assert.Null(model.RemoveEntityType(dependentOrderType));
}
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_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 Entities_are_ordered_by_name()
{
var model = new Model();
var entityType1 = model.AddEntityType(typeof(Order));
var entityType2 = model.AddEntityType(typeof(Customer));
Assert.True(new[] { entityType2, entityType1 }.SequenceEqual(model.GetEntityTypes()));
}
