public void Get_generation_property_returns_generation_property_from_foreign_key_tree()
{
var model = new Model();
var leftType = new EntityType("Left", model);
var leftId = leftType.AddProperty("Id", typeof(int), true);
var leftKey = leftType.AddKey(leftId);
var rightType = new EntityType("Right", model);
var rightId1 = rightType.AddProperty("Id1", typeof(int), true);
var rightId2 = rightType.AddProperty("Id2", typeof(int), true);
var rightKey = rightType.AddKey(new[] { rightId1, rightId2 });
var middleType = new EntityType("Middle", model);
var middleProperty1 = middleType.AddProperty("FK1", typeof(int), true);
var middleProperty2 = middleType.AddProperty("FK2", typeof(int), true);
var middleKey1 = middleType.AddKey(middleProperty1);
var middleFK1 = middleType.AddForeignKey(middleProperty1, leftKey);
var middleFK2 = middleType.AddForeignKey(new[] { middleProperty2, middleProperty1 }, rightKey);
var endType = new EntityType("End", model);
var endProperty = endType.AddProperty("FK", typeof(int), true);
var endFK = endType.AddForeignKey(endProperty, middleKey1);
rightId2.GenerateValueOnAdd = true;
Assert.Equal(rightId2, endProperty.GetGenerationProperty());
}
public void Every_eventId_has_a_logger_method_and_logs_when_level_enabled()
{
var propertyInfo = typeof(DateTime).GetTypeInfo().GetDeclaredProperty(nameof(DateTime.Now));
var entityType = new Model(new ConventionSet()).AddEntityType(typeof(object), ConfigurationSource.Convention);
var property = entityType.AddProperty("A", typeof(int), ConfigurationSource.Convention, ConfigurationSource.Convention);
var otherEntityType = new EntityType(typeof(object), entityType.Model, ConfigurationSource.Convention);
var otherProperty = otherEntityType.AddProperty(
"A", typeof(int), ConfigurationSource.Convention, ConfigurationSource.Convention);
var otherKey = otherEntityType.AddKey(otherProperty, ConfigurationSource.Convention);
var foreignKey = new ForeignKey(new[] { property }, otherKey, entityType, otherEntityType, ConfigurationSource.Convention);
var navigation = new Navigation("N", propertyInfo, null, foreignKey);
entityType.Model.FinalizeModel();
var options = new DbContextOptionsBuilder()
.UseInternalServiceProvider(InMemoryFixture.DefaultServiceProvider)
.UseInMemoryDatabase("D").Options;
var fakeFactories = new Dictionary <Type, Func <object> >
{
{ typeof(Type), () => typeof(object) },
{ typeof(DbContext), () => new DbContext(options) },
{ typeof(DbContextOptions), () => options },
{ typeof(string), () => "Fake" },
{ typeof(ExpressionPrinter), () => new ExpressionPrinter() },
{ typeof(Expression), () => Expression.Constant("A") },
{ typeof(IEntityType), () => entityType },
{ typeof(IConventionEntityType), () => entityType },
{ typeof(IKey), () => new Key(new[] { property }, ConfigurationSource.Convention) },
{ typeof(IPropertyBase), () => property },
{ typeof(IServiceProvider), () => new FakeServiceProvider() },
{ typeof(ICollection <IServiceProvider>), () => new List <IServiceProvider>() },
{ typeof(IReadOnlyList <IPropertyBase>), () => new[] { property } },
{
typeof(IEnumerable <Tuple <MemberInfo, Type> >),
() => new[] { new Tuple <MemberInfo, Type>(propertyInfo, typeof(object)) }
},
{ typeof(MemberInfo), () => propertyInfo },
{ typeof(IReadOnlyList <Exception>), () => new[] { new Exception() } },
{ typeof(IProperty), () => property },
{ typeof(INavigation), () => navigation },
{ typeof(IForeignKey), () => foreignKey },
{ typeof(InternalEntityEntry), () => new FakeInternalEntityEntry(entityType) },
{ typeof(ISet <object>), () => new HashSet <object>() },
{
typeof(IList <IDictionary <string, string> >),
() => new List <IDictionary <string, string> > {
new Dictionary <string, string> {
{ "A", "B" }
}
}
},
{ typeof(IDictionary <string, string>), () => new Dictionary <string, string>() }
};
TestEventLogging(
typeof(CoreEventId),
typeof(CoreLoggerExtensions),
typeof(TestLoggingDefinitions),
fakeFactories);
}
public void Get_generation_property_returns_generation_property_from_foreign_key_graph_with_cycle()
{
var model = new Model();
var leafType = new EntityType("leaf", model);
var leafId1 = leafType.AddProperty("Id1", typeof(int), true);
var leafId2 = leafType.AddProperty("Id2", typeof(int), true);
var leafKey = leafType.AddKey(new[] { leafId1, leafId2 });
var firstType = new EntityType("First", model);
var firstId = firstType.AddProperty("Id", typeof(int), true);
var firstKey = firstType.AddKey(firstId);
var secondType = new EntityType("Second", model);
var secondId1 = secondType.AddProperty("Id1", typeof(int), true);
var secondId2 = secondType.AddProperty("Id2", typeof(int), true);
var secondKey = secondType.AddKey(secondId1);
var firstForeignKey = firstType.AddForeignKey(firstId, secondKey);
var secondForeignKey1 = secondType.AddForeignKey(secondId1, firstKey);
var secondForeignKey2 = secondType.AddForeignKey(new[] { secondId1, secondId2 }, leafKey);
leafId1.GenerateValueOnAdd = true;
Assert.Equal(leafId1, secondId1.GetGenerationProperty());
}
public void Get_generation_property_returns_generation_property_from_foreign_key_tree()
{
var model = new Model();
var leftType = new EntityType("Left", model);
var leftId = leftType.AddProperty("Id", typeof(int), true);
var leftKey = leftType.AddKey(leftId);
var rightType = new EntityType("Right", model);
var rightId1 = rightType.AddProperty("Id1", typeof(int), true);
var rightId2 = rightType.AddProperty("Id2", typeof(int), true);
var rightKey = rightType.AddKey(new[] { rightId1, rightId2 });
var middleType = new EntityType("Middle", model);
var middleProperty1 = middleType.AddProperty("FK1", typeof(int), true);
var middleProperty2 = middleType.AddProperty("FK2", typeof(int), true);
var middleKey1 = middleType.AddKey(middleProperty1);
var middleFK1 = middleType.AddForeignKey(middleProperty1, leftKey, leftType);
var middleFK2 = middleType.AddForeignKey(new[] { middleProperty2, middleProperty1 }, rightKey, rightType);
var endType = new EntityType("End", model);
var endProperty = endType.AddProperty("FK", typeof(int), true);
var endFK = endType.AddForeignKey(endProperty, middleKey1, middleType);
rightId2.RequiresValueGenerator = true;
Assert.Equal(rightId2, endProperty.GetGenerationProperty());
}
private static void CloneKeys(IEntityType sourceEntityType, EntityType targetEntityType)
{
foreach (var key in sourceEntityType.GetDeclaredKeys())
{
var clonedKey = targetEntityType.AddKey(
key.Properties.Select(p => targetEntityType.FindProperty(p.Name)).ToList());
if (key.IsPrimaryKey())
{
targetEntityType.SetPrimaryKey(clonedKey.Properties);
}
key.GetAnnotations().ForEach(annotation => clonedKey[annotation.Name] = annotation.Value);
}
}
private Key CreateKey(EntityType entityType, int startingPropertyIndex = -1, int propertyCount = 1)
{
if (startingPropertyIndex == -1)
{
startingPropertyIndex = entityType.PropertyCount;
}
var keyProperties = new Property[propertyCount];
for (int i = 0; i < propertyCount; i++)
{
keyProperties[i] = entityType.GetOrAddProperty("P" + (startingPropertyIndex + i), typeof(int?));
keyProperties[i].GenerateValueOnAdd = true;
}
return(entityType.AddKey(keyProperties));
}
protected Key CreateKey(EntityType entityType, int startingPropertyIndex = -1, int propertyCount = 1)
{
if (startingPropertyIndex == -1)
{
startingPropertyIndex = entityType.PropertyCount() - 1;
}
var keyProperties = new Property[propertyCount];
for (var i = 0; i < propertyCount; i++)
{
var property = entityType.GetOrAddProperty("P" + (startingPropertyIndex + i), typeof(int?));
keyProperties[i] = property;
keyProperties[i].IsNullable = false;
}
return(entityType.AddKey(keyProperties));
}
private void CreateNavigationProperties(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder, String tableName)
{
foreach (String propertyName in MetadataProvider.GetNavigationProperties(tableName))
{
DynamicDependentPropertyInfo dependentInfo = MetadataProvider.GetDependentProperties(tableName, propertyName);
EntityType dependentEntityType = CreateEntityType(modelBuilder, MetadataProvider.GetTableName(dependentInfo.DependentEntityName));
EntityType principalEntityType = CreateEntityType(modelBuilder, MetadataProvider.GetTableName(dependentInfo.PrincipalEntityName));
var dependentProperties = new List <Property>();
foreach (String dependentPropertyName in dependentInfo.DependentPropertyNames)
{
dependentProperties.Add((Property)dependentEntityType.GetProperty(dependentPropertyName));
}
ForeignKey fkey = dependentEntityType.FindForeignKey(dependentProperties, principalEntityType.FindPrimaryKey(), principalEntityType);
if (fkey == null)
{
var principalProperties = new List <Property>();
foreach (String principalPropertyName in dependentInfo.PrincipalPropertyNames)
{
principalProperties.Add((Property)principalEntityType.GetProperty(principalPropertyName));
}
Key pkey = principalEntityType.FindKey(principalProperties);
if (pkey == null)
{
pkey = principalEntityType.AddKey(principalProperties);
}
fkey = dependentEntityType.AddForeignKey(dependentProperties, pkey, principalEntityType);
}
DynamicTypeDefinition dynamicTypeDefinition = TypeDefinitionManager.GetDynamicTypeDefinition(tableName);
if (dependentInfo.IsCollection)
{
Navigation navigation = fkey.HasPrincipalToDependent(propertyName);
navigation.SetField(dynamicTypeDefinition.GetCollectionFiledName(propertyName));
}
else
{
Navigation navigation = fkey.HasDependentToPrincipal(propertyName);
navigation.SetField(dynamicTypeDefinition.GetSingleFiledName(propertyName));
}
}
}
private Key CreateKey(EntityType entityType, int startingPropertyIndex = -1, int propertyCount = 1)
{
if (startingPropertyIndex == -1)
{
startingPropertyIndex = entityType.PropertyCount - 1;
}
var keyProperties = new Property[propertyCount];
for (var i = 0; i < propertyCount; i++)
{
var property = entityType.GetOrAddProperty("P" + (startingPropertyIndex + i));
property.ClrType = typeof(int?);
property.IsShadowProperty = false;
keyProperties[i] = property;
keyProperties[i].RequiresValueGenerator = true;
}
return(entityType.AddKey(keyProperties));
}
public void Get_generation_property_returns_generation_property_from_foreign_key_chain()
{
var model = new Model();
var firstType = new EntityType("First", model);
var firstProperty = firstType.AddProperty("ID", typeof(int), true);
var firstKey = firstType.AddKey(firstProperty);
var secondType = new EntityType("Second", model);
var secondProperty = secondType.AddProperty("ID", typeof(int), true);
var secondKey = secondType.AddKey(secondProperty);
var secondForeignKey = secondType.AddForeignKey(secondProperty, firstKey);
var thirdType = new EntityType("Third", model);
var thirdProperty = thirdType.AddProperty("ID", typeof(int), true);
var thirdForeignKey = thirdType.AddForeignKey(thirdProperty, secondKey);
firstProperty.GenerateValueOnAdd = true;
Assert.Equal(firstProperty, thirdProperty.GetGenerationProperty());
}
public void Get_generation_property_returns_generation_property_from_foreign_key_chain()
{
var model = new Model();
var firstType = new EntityType("First", model);
var firstProperty = firstType.AddProperty("ID", typeof(int), true);
var firstKey = firstType.AddKey(firstProperty);
var secondType = new EntityType("Second", model);
var secondProperty = secondType.AddProperty("ID", typeof(int), true);
var secondKey = secondType.AddKey(secondProperty);
var secondForeignKey = secondType.AddForeignKey(secondProperty, firstKey, firstType);
var thirdType = new EntityType("Third", model);
var thirdProperty = thirdType.AddProperty("ID", typeof(int), true);
var thirdForeignKey = thirdType.AddForeignKey(thirdProperty, secondKey, secondType);
firstProperty.RequiresValueGenerator = true;
Assert.Equal(firstProperty, thirdProperty.GetGenerationProperty());
}
public void Every_eventId_has_a_logger_method_and_logs_when_level_enabled()
{
var propertyInfo = typeof(DateTime).GetTypeInfo().GetDeclaredProperty(nameof(DateTime.Now));
var entityType = new EntityType(typeof(object), new Model(new ConventionSet()), ConfigurationSource.Convention);
var property = new Property("A", typeof(int), propertyInfo, null, entityType, ConfigurationSource.Convention, ConfigurationSource.Convention);
var otherEntityType = new EntityType(typeof(object), entityType.Model, ConfigurationSource.Convention);
var otherProperty = otherEntityType.AddProperty("A", typeof(int), ConfigurationSource.Convention);
var otherKey = otherEntityType.AddKey(otherProperty, ConfigurationSource.Convention);
var foreignKey = new ForeignKey(new[] { property }, otherKey, entityType, otherEntityType, ConfigurationSource.Convention);
var navigation = new Navigation("N", propertyInfo, null, foreignKey);
var queryModel = new QueryModel(new MainFromClause("A", typeof(object), Expression.Constant("A")), new SelectClause(Expression.Constant("A")));
var includeResultOperator = new IncludeResultOperator(new[] { "Foo" }, Expression.Constant("A"));
var options = new DbContextOptionsBuilder().UseInMemoryDatabase("D").Options;
var fakeFactories = new Dictionary <Type, Func <object> >
{
{ typeof(Type), () => typeof(object) },
{ typeof(DbContext), () => new DbContext(options) },
{ typeof(DbContextOptions), () => options },
{ typeof(QueryModel), () => queryModel },
{ typeof(string), () => "Fake" },
{ typeof(IExpressionPrinter), () => new ExpressionPrinter() },
{ typeof(Expression), () => Expression.Constant("A") },
{ typeof(IEntityType), () => entityType },
{ typeof(IKey), () => new Key(new[] { property }, ConfigurationSource.Convention) },
{ typeof(IPropertyBase), () => property },
{ typeof(IServiceProvider), () => new FakeServiceProvider() },
{ typeof(ICollection <IServiceProvider>), () => new List <IServiceProvider>() },
{ typeof(IReadOnlyList <IPropertyBase>), () => new[] { property } },
{ typeof(IEnumerable <Tuple <MemberInfo, Type> >), () => new[] { new Tuple <MemberInfo, Type>(propertyInfo, typeof(object)) } },
{ typeof(MemberInfo), () => propertyInfo },
{ typeof(IncludeResultOperator), () => includeResultOperator },
{ typeof(IReadOnlyList <Exception>), () => new[] { new Exception() } },
{ typeof(IProperty), () => property },
{ typeof(INavigation), () => navigation },
{ typeof(IForeignKey), () => foreignKey }
};
TestEventLogging(typeof(CoreEventId), typeof(CoreLoggerExtensions), fakeFactories);
}
public void Every_eventId_has_a_logger_method_and_logs_when_level_enabled()
{
var propertyInfo = typeof(DateTime).GetTypeInfo().GetDeclaredProperty(nameof(DateTime.Now));
var entityType = new Model().AddEntityType(typeof(object), ConfigurationSource.Convention);
var property = entityType.AddProperty("A", typeof(int), ConfigurationSource.Convention, ConfigurationSource.Convention);
var otherEntityType = new EntityType(typeof(object), entityType.Model, ConfigurationSource.Convention);
var otherProperty = otherEntityType.AddProperty(
"A", typeof(int), ConfigurationSource.Convention, ConfigurationSource.Convention);
var otherKey = otherEntityType.AddKey(otherProperty, ConfigurationSource.Convention);
var foreignKey = new ForeignKey(new[] { property }, otherKey, entityType, otherEntityType, ConfigurationSource.Convention);
var navigation = new Navigation("N", propertyInfo, null, foreignKey);
var skipNavigation = new SkipNavigation(
"SN", propertyInfo, null, entityType, otherEntityType, true, false, ConfigurationSource.Convention);
var navigationBase = new FakeNavigationBase("FNB", ConfigurationSource.Convention, entityType);
entityType.Model.FinalizeModel();
var options = new DbContextOptionsBuilder()
.UseInternalServiceProvider(InMemoryFixture.DefaultServiceProvider)
.UseInMemoryDatabase("D").Options;
var fakeFactories = new Dictionary <Type, Func <object> >
{
{ typeof(Type), () => typeof(object) },
public void Adding_a_key_throws_if_same_as_primary()
{
var entityType = new EntityType(typeof(Customer), new Model());
var idProperty = entityType.GetOrAddProperty(Customer.IdProperty);
var nameProperty = entityType.GetOrAddProperty(Customer.NameProperty);
entityType.GetOrSetPrimaryKey(new[] { idProperty, nameProperty });
Assert.Equal(
Strings.DuplicateKey("{'" + Customer.IdProperty.Name + "', '" + Customer.NameProperty.Name + "'}", typeof(Customer).FullName),
Assert.Throws<InvalidOperationException>(() => entityType.AddKey(new[] { idProperty, nameProperty })).Message);
}
private Key CreateKey(EntityType entityType, int startingPropertyIndex = -1, int propertyCount = 1)
{
if (startingPropertyIndex == -1)
{
startingPropertyIndex = entityType.PropertyCount;
}
var keyProperties = new Property[propertyCount];
for (int i = 0; i < propertyCount; i++)
{
keyProperties[i] = entityType.GetOrAddProperty("P" + (startingPropertyIndex + i), typeof(int?));
keyProperties[i].GenerateValueOnAdd = true;
}
return entityType.AddKey(keyProperties);
}
public void Adding_a_key_throws_if_properties_from_different_type()
{
var entityType1 = new EntityType(typeof(Customer), new Model());
var entityType2 = new EntityType(typeof(Order), new Model());
var idProperty = entityType2.GetOrAddProperty(Customer.IdProperty);
Assert.Equal(
Strings.KeyPropertiesWrongEntity("{'" + Customer.IdProperty.Name + "'}", typeof(Customer).FullName),
Assert.Throws<ArgumentException>(() => entityType1.AddKey(idProperty)).Message);
}
public void Every_eventId_has_a_logger_method_and_logs_when_level_enabled()
{
var constantExpression = Expression.Constant("A");
var model = new Model();
var entityType = new EntityType(typeof(object), model, ConfigurationSource.Convention);
var property = entityType.AddProperty("A", typeof(int), ConfigurationSource.Convention, ConfigurationSource.Convention);
var key = entityType.AddKey(property, ConfigurationSource.Convention);
var foreignKey = new ForeignKey(new List <Property> {
property
}, key, entityType, entityType, ConfigurationSource.Convention);
var index = new Index(new List <Property> {
property
}, "IndexName", entityType, ConfigurationSource.Convention);
var contextServices = RelationalTestHelpers.Instance.CreateContextServices(model.FinalizeModel());
var fakeFactories = new Dictionary <Type, Func <object> >
{
{ typeof(string), () => "Fake" },
{ typeof(IList <string>), () => new List <string> {
"Fake1", "Fake2"
} },
{
typeof(IEnumerable <IUpdateEntry>), () => new List <IUpdateEntry>
{
new InternalClrEntityEntry(
contextServices.GetRequiredService <IStateManager>(),
entityType,
new object())
}
},
{ typeof(IRelationalConnection), () => new FakeRelationalConnection() },
{ typeof(LoggingDefinitions), () => new TestRelationalLoggingDefinitions() },
{ typeof(DbCommand), () => new FakeDbCommand() },
{ typeof(DbTransaction), () => new FakeDbTransaction() },
{ typeof(DbDataReader), () => new FakeDbDataReader() },
{ typeof(Transaction), () => new CommittableTransaction() },
{ typeof(IMigrator), () => new FakeMigrator() },
{ typeof(Migration), () => new FakeMigration() },
{ typeof(IMigrationsAssembly), () => new FakeMigrationsAssembly() },
{ typeof(MethodCallExpression), () => Expression.Call(constantExpression, typeof(object).GetMethod("ToString")) },
{ typeof(Expression), () => constantExpression },
{ typeof(IEntityType), () => entityType },
{ typeof(IProperty), () => property },
{ typeof(IKey), () => key },
{ typeof(IForeignKey), () => foreignKey },
{ typeof(IIndex), () => index },
{ typeof(TypeInfo), () => typeof(object).GetTypeInfo() },
{ typeof(Type), () => typeof(object) },
{ typeof(ValueConverter), () => new BoolToZeroOneConverter <int>() },
{ typeof(DbContext), () => new FakeDbContext() },
{ typeof(SqlExpression), () => new FakeSqlExpression() }
};
TestEventLogging(
typeof(RelationalEventId),
typeof(RelationalLoggerExtensions),
new[]
{
typeof(IRelationalConnectionDiagnosticsLogger),
typeof(IRelationalCommandDiagnosticsLogger)
},
new TestRelationalLoggingDefinitions(),
fakeFactories,
services => FakeRelationalOptionsExtension.AddEntityFrameworkRelationalDatabase(services),
new Dictionary <string, IList <string> >
{
{
nameof(RelationalEventId.CommandExecuting),
new List <string>
{
nameof(IRelationalCommandDiagnosticsLogger.CommandReaderExecuting),
nameof(IRelationalCommandDiagnosticsLogger.CommandScalarExecuting),
nameof(IRelationalCommandDiagnosticsLogger.CommandNonQueryExecuting),
nameof(IRelationalCommandDiagnosticsLogger.CommandReaderExecutingAsync),
nameof(IRelationalCommandDiagnosticsLogger.CommandScalarExecutingAsync),
nameof(IRelationalCommandDiagnosticsLogger.CommandNonQueryExecutingAsync)
}
},
{
nameof(RelationalEventId.CommandExecuted),
new List <string>
{
nameof(IRelationalCommandDiagnosticsLogger.CommandReaderExecutedAsync),
nameof(IRelationalCommandDiagnosticsLogger.CommandScalarExecutedAsync),
nameof(IRelationalCommandDiagnosticsLogger.CommandNonQueryExecutedAsync),
nameof(IRelationalCommandDiagnosticsLogger.CommandReaderExecuted),
nameof(IRelationalCommandDiagnosticsLogger.CommandScalarExecuted),
nameof(IRelationalCommandDiagnosticsLogger.CommandNonQueryExecuted)
}
}
});
}
public void Get_generation_property_returns_generation_property_from_foreign_key_graph_with_cycle()
{
var model = new Model();
var leafType = new EntityType("leaf", model);
var leafId1 = leafType.AddProperty("Id1", typeof(int), true);
var leafId2 = leafType.AddProperty("Id2", typeof(int), true);
var leafKey = leafType.AddKey(new[] { leafId1, leafId2 });
var firstType = new EntityType("First", model);
var firstId = firstType.AddProperty("Id", typeof(int), true);
var firstKey = firstType.AddKey(firstId);
var secondType = new EntityType("Second", model);
var secondId1 = secondType.AddProperty("Id1", typeof(int), true);
var secondId2 = secondType.AddProperty("Id2", typeof(int), true);
var secondKey = secondType.AddKey(secondId1);
var firstForeignKey = firstType.AddForeignKey(firstId, secondKey, secondType);
var secondForeignKey1 = secondType.AddForeignKey(secondId1, firstKey, firstType);
var secondForeignKey2 = secondType.AddForeignKey(new[] { secondId1, secondId2 }, leafKey, leafType);
leafId1.RequiresValueGenerator = true;
Assert.Equal(leafId1, secondId1.GetGenerationProperty());
}
private Key CreateKey(EntityType entityType, int startingPropertyIndex = -1, int propertyCount = 1)
{
if (startingPropertyIndex == -1)
{
startingPropertyIndex = entityType.PropertyCount - 1;
}
var keyProperties = new Property[propertyCount];
for (var i = 0; i < propertyCount; i++)
{
var property = entityType.GetOrAddProperty("P" + (startingPropertyIndex + i));
property.ClrType = typeof(int?);
property.IsShadowProperty = false;
keyProperties[i] = property;
keyProperties[i].RequiresValueGenerator = true;
}
return entityType.AddKey(keyProperties);
}
public void Can_add_and_get_a_key()
{
var entityType = new EntityType(typeof(Customer), new Model());
var idProperty = entityType.GetOrAddProperty(Customer.IdProperty);
var nameProperty = entityType.GetOrAddProperty(Customer.NameProperty);
var key1 = entityType.AddKey(new[] { idProperty, nameProperty });
Assert.NotNull(key1);
Assert.Same(key1, entityType.GetOrAddKey(new[] { idProperty, nameProperty }));
Assert.Same(key1, entityType.Keys.Single());
var key2 = entityType.GetOrAddKey(idProperty);
Assert.NotNull(key2);
Assert.Same(key2, entityType.GetKey(idProperty));
Assert.Equal(2, entityType.Keys.Count());
Assert.Contains(key1, entityType.Keys);
Assert.Contains(key2, entityType.Keys);
}