public void GetClrTypes_should_return_ospace_types()
{
var model = new EdmModel().Initialize();
model.AddEntityType("A").SetClrType(typeof(object));
model.AddEntityType("B").SetClrType(typeof(string));
Assert.Equal(2, model.GetClrTypes().Count());
}
public void HasCascadeDeletePath_should_return_true_for_simple_cascade()
{
var model = new EdmModel().Initialize();
var entityTypeA = model.AddEntityType("A");
var entityTypeB = model.AddEntityType("B");
var associationType = new EdmAssociationType().Initialize();
associationType.SourceEnd.EntityType = entityTypeA;
associationType.TargetEnd.EntityType = entityTypeB;
associationType.SourceEnd.DeleteAction = EdmOperationAction.Cascade;
model.AddAssociationType(associationType);
Assert.True(model.HasCascadeDeletePath(entityTypeA, entityTypeB));
Assert.False(model.HasCascadeDeletePath(entityTypeB, entityTypeA));
}
public void Configure_should_configure_inverse()
{
var inverseMockPropertyInfo = new MockPropertyInfo();
var navigationPropertyConfiguration = new NavigationPropertyConfiguration(new MockPropertyInfo())
{
InverseNavigationProperty = inverseMockPropertyInfo
};
var associationType = new EdmAssociationType().Initialize();
var inverseAssociationType = new EdmAssociationType().Initialize();
var model = new EdmModel().Initialize();
model.AddAssociationType(inverseAssociationType);
var inverseNavigationProperty
= model.AddEntityType("T")
.AddNavigationProperty("N", inverseAssociationType);
inverseNavigationProperty.SetClrPropertyInfo(inverseMockPropertyInfo);
navigationPropertyConfiguration.Configure(
new EdmNavigationProperty
{
Association = associationType
}, model, new EntityTypeConfiguration(typeof(object)));
Assert.Same(associationType, inverseNavigationProperty.Association);
Assert.Same(associationType.SourceEnd, inverseNavigationProperty.ResultEnd);
Assert.Equal(0, model.GetAssociationTypes().Count());
}
public void Generate_should_correctly_map_string_primitive_property_facets()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("E");
entityType.SetClrType(typeof(object));
model.AddEntitySet("ESet", entityType);
var property = entityType.AddPrimitiveProperty("P");
property.PropertyType.EdmType = EdmPrimitiveType.String;
property.PropertyType.IsNullable = false;
property.PropertyType.PrimitiveTypeFacets.IsFixedLength = true;
property.PropertyType.PrimitiveTypeFacets.IsMaxLength = true;
property.PropertyType.PrimitiveTypeFacets.IsUnicode = true;
property.PropertyType.PrimitiveTypeFacets.MaxLength = 42;
property.PropertyType.PrimitiveTypeFacets.Precision = 23;
property.PropertyType.PrimitiveTypeFacets.Scale = 77;
property.SetStoreGeneratedPattern(DbStoreGeneratedPattern.Identity);
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var column = databaseMapping.GetEntityTypeMapping(entityType).TypeMappingFragments.Single().PropertyMappings.Single().Column;
Assert.False(column.IsNullable);
Assert.Null(column.Facets.IsFixedLength);
Assert.Equal(true, column.Facets.IsMaxLength);
Assert.Null(column.Facets.IsUnicode);
Assert.Equal(42, column.Facets.MaxLength);
Assert.Null(column.Facets.Precision);
Assert.Null(column.Facets.Scale);
Assert.Equal(DbStoreGeneratedPattern.Identity, column.StoreGeneratedPattern);
}
public void ApplyModel_should_run_targeted_model_conventions()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("E");
var mockConvention = new Mock<IEdmConvention<EdmEntityType>>();
var conventionsConfiguration = new ConventionsConfiguration(new IConvention[]
{
mockConvention.Object
});
conventionsConfiguration.ApplyModel(model);
mockConvention.Verify(c => c.Apply(entityType, model), Times.AtMostOnce());
}
private static DbDatabaseMapping CreateSimpleModel(double version)
{
var model = new EdmModel().Initialize(version);
var entityType = model.AddEntityType("E");
entityType.SetClrType(typeof(object));
model.AddEntitySet("ESet", entityType);
var property = entityType.AddPrimitiveProperty("Id");
property.PropertyType.EdmType = EdmPrimitiveType.Int32;
property.PropertyType.IsNullable = false;
entityType.DeclaredKeyProperties.Add(property);
return new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
}
public void Apply_generates_constraint_when_simple_fk()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("E");
var associationType = model.AddAssociationType("A",
entityType, EdmAssociationEndKind.Optional,
entityType, EdmAssociationEndKind.Many);
var navigationProperty = entityType.AddNavigationProperty("N", associationType);
var fkProperty = entityType.AddPrimitiveProperty("Fk");
var foreignKeyAnnotation = new ForeignKeyAttribute("Fk");
navigationProperty.Annotations.SetClrAttributes(new[] { foreignKeyAnnotation });
((IEdmConvention<EdmNavigationProperty>)new ForeignKeyNavigationPropertyAttributeConvention())
.Apply(navigationProperty, model);
Assert.NotNull(associationType.Constraint);
Assert.True(associationType.Constraint.DependentProperties.Contains(fkProperty));
}
public void Configure_should_configure_active_entities_and_complex_types()
{
var mockEntityType = new MockType();
var mockComplexType = new MockType();
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("E");
entityType.SetClrType(mockEntityType);
var complexType = model.AddComplexType("C");
complexType.SetClrType(mockComplexType);
var modelConfiguration = new ModelConfiguration();
var mockComplexTypeConfiguration = new Mock<ComplexTypeConfiguration>(mockComplexType.Object);
var mockEntityTypeConfiguration = new Mock<EntityTypeConfiguration>(mockEntityType.Object);
modelConfiguration.Add(mockComplexTypeConfiguration.Object);
modelConfiguration.Add(mockEntityTypeConfiguration.Object);
modelConfiguration.Configure(model);
mockComplexTypeConfiguration.Verify(c => c.Configure(complexType));
mockEntityTypeConfiguration.Verify(c => c.Configure(entityType, model));
}
public void Generate_can_map_a_simple_entity_type_and_set()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("E");
entityType.SetClrType(typeof(object));
entityType.AddPrimitiveProperty("P1").PropertyType.EdmType = EdmPrimitiveType.Int32;
entityType.AddPrimitiveProperty("P2").PropertyType.EdmType = EdmPrimitiveType.String;
var entitySet = model.AddEntitySet("ESet", entityType);
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entitySetMapping = databaseMapping.GetEntitySetMapping(entitySet);
Assert.NotNull(entitySetMapping);
Assert.Same(entitySet, entitySetMapping.EntitySet);
var entityTypeMapping = entitySetMapping.EntityTypeMappings.Single();
Assert.Same(entityType, entityTypeMapping.EntityType);
Assert.NotNull(entityTypeMapping.TypeMappingFragments.Single().Table);
Assert.Equal("E", entityTypeMapping.TypeMappingFragments.Single().Table.Name);
Assert.Equal(2, entityTypeMapping.TypeMappingFragments.Single().Table.Columns.Count);
Assert.Equal(typeof(object), entityTypeMapping.GetClrType());
}
public void Generate_should_map_entity_keys_to_primary_keys()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("E");
entityType.SetClrType(typeof(object));
var idProperty = entityType.AddPrimitiveProperty("Id");
idProperty.PropertyType.EdmType = EdmPrimitiveType.Int32;
entityType.DeclaredKeyProperties.Add(idProperty);
var entitySet = model.AddEntitySet("ESet", entityType);
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entitySetMapping = databaseMapping.GetEntitySetMapping(entitySet);
var entityTypeMapping = entitySetMapping.EntityTypeMappings.Single();
Assert.Equal(1, entityTypeMapping.TypeMappingFragments.Single().Table.KeyColumns.Count());
Assert.Equal("Id", entityTypeMapping.TypeMappingFragments.Single().Table.KeyColumns.Single().Name);
Assert.True(entityTypeMapping.TypeMappingFragments.Single().Table.KeyColumns.Single().IsPrimaryKeyColumn);
}
public void GetDerivedTypes_must_return_list_of_direct_descendants()
{
var model = new EdmModel().Initialize();
var entity1 = model.AddEntityType("E1");
var entity2 = model.AddEntityType("E2");
var entity3 = model.AddEntityType("E3");
var entity4 = model.AddEntityType("E4");
entity2.BaseType = entity1;
entity3.BaseType = entity1;
entity4.BaseType = entity2;
var derivedTypes = model.GetDerivedTypes(entity1).ToList();
Assert.Equal(2, derivedTypes.Count);
Assert.Same(entity2, derivedTypes[0]);
Assert.Same(entity3, derivedTypes[1]);
}
public void AddAssociationSet_should_create_and_add_to_default_container()
{
var model = new EdmModel().Initialize();
var sourceEntityType = model.AddEntityType("Source");
var targetEntityType = model.AddEntityType("Target");
var associationType = model.AddAssociationType(
"Foo",
sourceEntityType, EdmAssociationEndKind.Required,
targetEntityType, EdmAssociationEndKind.Many);
var associationSet = model.AddAssociationSet("FooSet", associationType);
Assert.NotNull(associationSet);
Assert.Equal("FooSet", associationSet.Name);
Assert.Same(associationType, associationSet.ElementType);
Assert.True(model.Containers.Single().AssociationSets.Contains(associationSet));
}
public void AddAssociationType_should_create_and_add_to_default_namespace()
{
var model = new EdmModel().Initialize();
var sourceEntityType = model.AddEntityType("Source");
var targetEntityType = model.AddEntityType("Target");
var associationType = model.AddAssociationType(
"Foo",
sourceEntityType, EdmAssociationEndKind.Required,
targetEntityType, EdmAssociationEndKind.Many);
Assert.NotNull(associationType);
Assert.Equal("Foo", associationType.Name);
Assert.Same(sourceEntityType, associationType.SourceEnd.EntityType);
Assert.Equal(EdmAssociationEndKind.Required, associationType.SourceEnd.EndKind);
Assert.Same(targetEntityType, associationType.TargetEnd.EntityType);
Assert.Equal(EdmAssociationEndKind.Many, associationType.TargetEnd.EndKind);
Assert.True(model.Namespaces.Single().AssociationTypes.Contains(associationType));
}
public void RemoveEntityType_should_remove_type_and_set()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("Foo");
model.AddEntitySet("FooSet", entityType);
model.RemoveEntityType(entityType);
Assert.Equal(0, model.GetEntityTypes().Count());
Assert.Equal(0, model.Containers.First().EntitySets.Count());
}
public void AddEntitySet_should_create_and_add_to_default_container()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("Foo");
var entitySet = model.AddEntitySet("FooSet", entityType);
Assert.NotNull(entitySet);
Assert.Equal("FooSet", entitySet.Name);
Assert.Same(entityType, entitySet.ElementType);
Assert.True(model.Containers.Single().EntitySets.Contains(entitySet));
}
public void Generate_can_map_type_hierarchies_using_Tph()
{
var model = new EdmModel().Initialize();
var rootEntityType = model.AddEntityType("E");
rootEntityType.SetClrType(typeof(object));
rootEntityType.AddPrimitiveProperty("P1").PropertyType.EdmType = EdmPrimitiveType.Int32;
rootEntityType.AddPrimitiveProperty("P2").PropertyType.EdmType = EdmPrimitiveType.String;
var entitySet = model.AddEntitySet("ESet", rootEntityType);
var entityType2 = model.AddEntityType("E2");
entityType2.AddPrimitiveProperty("P3").PropertyType.EdmType = EdmPrimitiveType.Decimal;
entityType2.SetClrType(typeof(string));
entityType2.BaseType = rootEntityType;
var entityType3 = model.AddEntityType("E3");
entityType3.SetClrType(typeof(int));
entityType3.AddPrimitiveProperty("P4").PropertyType.EdmType = EdmPrimitiveType.Int32;
entityType3.BaseType = entityType2;
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entitySetMapping = databaseMapping.GetEntitySetMapping(entitySet);
Assert.NotNull(entitySetMapping);
var entityTypeMappings = entitySetMapping.EntityTypeMappings;
Assert.Equal(3, entityTypeMappings.Count);
var entityType1Mapping = databaseMapping.GetEntityTypeMapping(rootEntityType);
var entityType2Mapping = databaseMapping.GetEntityTypeMapping(entityType2);
var entityType3Mapping = databaseMapping.GetEntityTypeMapping(entityType3);
Assert.Equal(2, entityType1Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal(3, entityType2Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal(4, entityType3Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
var table = entityType1Mapping.TypeMappingFragments.Single().Table;
Assert.Same(table, entityType2Mapping.TypeMappingFragments.Single().Table);
Assert.Same(table, entityType3Mapping.TypeMappingFragments.Single().Table);
Assert.Equal(5, table.Columns.Count);
Assert.Equal("P1", table.Columns[0].Name);
Assert.Equal("P2", table.Columns[1].Name);
Assert.Equal("P3", table.Columns[2].Name);
Assert.Equal("P4", table.Columns[3].Name);
Assert.Equal("Discriminator", table.Columns[4].Name);
}
public void Generate_can_map_foreign_key_association_type()
{
var model = new EdmModel().Initialize();
var principalEntityType = model.AddEntityType("P");
principalEntityType.SetClrType(typeof(object));
var dependentEntityType = model.AddEntityType("D");
dependentEntityType.SetClrType(typeof(string));
var dependentProperty1 = dependentEntityType.AddPrimitiveProperty("FK1");
dependentProperty1.PropertyType.EdmType = EdmPrimitiveType.Int32;
var dependentProperty2 = dependentEntityType.AddPrimitiveProperty("FK2");
dependentProperty2.PropertyType.EdmType = EdmPrimitiveType.String;
model.AddEntitySet("PSet", principalEntityType);
model.AddEntitySet("DSet", dependentEntityType);
var associationType
= model.AddAssociationType("P_D",
principalEntityType, EdmAssociationEndKind.Required,
dependentEntityType, EdmAssociationEndKind.Many);
associationType.Constraint
= new EdmAssociationConstraint
{
DependentEnd = associationType.TargetEnd,
DependentProperties = new[] { dependentProperty1, dependentProperty2 },
};
associationType.SourceEnd.DeleteAction = EdmOperationAction.Cascade;
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var dependentTable = databaseMapping.GetEntityTypeMapping(dependentEntityType).TypeMappingFragments.Single().Table;
var foreignKeyConstraint = dependentTable.ForeignKeyConstraints.Single();
Assert.Equal(2, dependentTable.Columns.Count());
Assert.Equal(2, foreignKeyConstraint.DependentColumns.Count);
Assert.Equal(DbOperationAction.Cascade, foreignKeyConstraint.DeleteAction);
Assert.Equal(associationType.Name, foreignKeyConstraint.Name);
var foreignKeyColumn = foreignKeyConstraint.DependentColumns.First();
Assert.False(foreignKeyColumn.IsNullable);
Assert.Equal("FK1", foreignKeyColumn.Name);
}
public void AddEntityType_should_create_and_add_to_default_namespace()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("Foo");
Assert.NotNull(entityType);
Assert.Equal("Foo", entityType.Name);
Assert.True(model.Namespaces.Single().EntityTypes.Contains(entityType));
}
public void Apply_throws_with_empty_foreign_key_properties()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("E");
var mockType = new MockType();
entityType.SetClrType(mockType);
var associationType = model.AddAssociationType("A",
entityType, EdmAssociationEndKind.Optional,
entityType, EdmAssociationEndKind.Many);
var navigationProperty = entityType.AddNavigationProperty("N", associationType);
var foreignKeyAnnotation = new ForeignKeyAttribute(",");
navigationProperty.Annotations.SetClrAttributes(new[] { foreignKeyAnnotation });
Assert.Equal(Strings.ForeignKeyAttributeConvention_EmptyKey("N", mockType.Object), Assert.Throws<InvalidOperationException>(() => ((IEdmConvention<EdmNavigationProperty>)new ForeignKeyNavigationPropertyAttributeConvention())
.Apply(navigationProperty, model)).Message);
}
public void GetAssociationSet_should_return_association_set()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("Foo");
model.AddEntitySet("FooSet", entityType);
var associationType = new EdmAssociationType().Initialize();
associationType.SourceEnd.EntityType = entityType;
associationType.TargetEnd.EntityType = entityType;
model.AddAssociationSet("FooSet", associationType);
var associationSet = model.GetAssociationSet(associationType);
Assert.NotNull(associationSet);
Assert.Same(associationType, associationSet.ElementType);
}
public void GetEntitySet_should_return_entity_set()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("Foo");
model.AddEntitySet("FooSet", entityType);
var entitySet = model.GetEntitySet(entityType);
Assert.NotNull(entitySet);
Assert.Same(entityType, entitySet.ElementType);
}
private static EdmModel CreateModelFixture(
out EdmEntityType declaringEntityType, out EdmEntityType complexEntityType)
{
var model = new EdmModel().Initialize();
declaringEntityType = model.AddEntityType("E");
complexEntityType = model.AddEntityType("C");
complexEntityType.AddPrimitiveProperty("P");
var associationType
= model.AddAssociationType(
"A",
declaringEntityType, EdmAssociationEndKind.Many,
complexEntityType, EdmAssociationEndKind.Optional);
declaringEntityType.AddNavigationProperty("E.C", associationType);
return model;
}
public void GetEntityType_should_return_correct_type()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("Foo");
var foundEntityType = model.GetEntityType("Foo");
Assert.NotNull(foundEntityType);
Assert.Same(entityType, foundEntityType);
}
public void GetStructuralType_should_return_entity_or_complex_type()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("E");
var complexType = model.AddComplexType("C");
Assert.Same(entityType, model.GetStructuralType("E"));
Assert.Same(complexType, model.GetStructuralType("C"));
}
public void Generate_maps_abstract_type_hierarchies_correctly()
{
var model = new EdmModel().Initialize();
var rootEntityType = model.AddEntityType("E");
rootEntityType.SetClrType(typeof(object));
rootEntityType.AddPrimitiveProperty("P1").PropertyType.EdmType = EdmPrimitiveType.Int32;
rootEntityType.DeclaredKeyProperties.Add(rootEntityType.Properties.First());
rootEntityType.AddPrimitiveProperty("P2").PropertyType.EdmType = EdmPrimitiveType.String;
model.AddEntitySet("ESet", rootEntityType);
var entityType2 = model.AddEntityType("E2");
entityType2.AddPrimitiveProperty("P3").PropertyType.EdmType = EdmPrimitiveType.Decimal;
entityType2.SetClrType(typeof(string));
entityType2.IsAbstract = true;
entityType2.BaseType = rootEntityType;
var entityType3 = model.AddEntityType("E3");
entityType3.SetClrType(typeof(int));
entityType3.AddPrimitiveProperty("P4").PropertyType.EdmType = EdmPrimitiveType.Int32;
entityType3.BaseType = entityType2;
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entityType1Mapping = databaseMapping.GetEntityTypeMapping(rootEntityType);
var entityType3Mapping = databaseMapping.GetEntityTypeMapping(entityType3);
Assert.Equal(2, entityType1Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal("P1", entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal("P2", entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.Equal(4, entityType3Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal("P1", entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal("P2", entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.Equal("P3", entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[2].Column.Name);
Assert.Equal("P4", entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[3].Column.Name);
var table = entityType1Mapping.TypeMappingFragments.Single().Table;
Assert.Equal(5, table.Columns.Count);
}
public void GetAssociationsBetween_should_return_matching_associations()
{
var model = new EdmModel().Initialize();
var entityTypeA = model.AddEntityType("Foo");
var entityTypeB = model.AddEntityType("Bar");
Assert.Equal(0, model.GetAssociationTypesBetween(entityTypeA, entityTypeB).Count());
model.AddAssociationType(
"Foo_Bar",
entityTypeA, EdmAssociationEndKind.Optional,
entityTypeB, EdmAssociationEndKind.Many);
model.AddAssociationType(
"Bar_Foo",
entityTypeB, EdmAssociationEndKind.Optional,
entityTypeA, EdmAssociationEndKind.Many);
Assert.Equal(2, model.GetAssociationTypesBetween(entityTypeA, entityTypeB).Count());
Assert.Equal(2, model.GetAssociationTypesBetween(entityTypeB, entityTypeA).Count());
Assert.Equal(0, model.GetAssociationTypesBetween(entityTypeA, entityTypeA).Count());
}
public void TypeHierarchyIterator_should_return_entity_types_in_depth_first_order()
{
var model = new EdmModel().Initialize();
var entityTypeRoot = model.AddEntityType("Root");
var derivedType1 = model.AddEntityType("DType1");
var derivedType2 = model.AddEntityType("DType2");
derivedType1.BaseType = entityTypeRoot;
derivedType2.BaseType = entityTypeRoot;
var derivedType1_1 = model.AddEntityType("DType1_1");
var derivedType1_2 = model.AddEntityType("DType1_2");
derivedType1_1.BaseType = derivedType1;
derivedType1_2.BaseType = derivedType1;
var typesVisited = new List<EdmEntityType>();
foreach (var derivedType in entityTypeRoot.TypeHierarchyIterator(model))
{
typesVisited.Add(derivedType);
}
var oracle = new List<EdmEntityType> { entityTypeRoot, derivedType1, derivedType1_1, derivedType1_2, derivedType2 };
Assert.Equal(true, oracle.SequenceEqual(typesVisited));
}
