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 MapComplexType_should_not_map_invalid_structural_type()
{
var model = new EdmModel().Initialize();
var typeMapper = new TypeMapper(new MappingContext(new ModelConfiguration(), new ConventionsConfiguration(), model));
Assert.Null(typeMapper.MapComplexType(typeof(string)));
}
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 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 Can_get_and_set_provider_info_annotation()
{
var model = new EdmModel();
var providerInfo = ProviderRegistry.Sql2008_ProviderInfo;
model.SetProviderInfo(providerInfo);
Assert.Same(providerInfo, model.GetProviderInfo());
}
public void Apply_should_ignore_current_entity_set()
{
var model = new EdmModel().Initialize();
var entitySet = model.AddEntitySet("Cats", new EdmEntityType());
((IEdmConvention<EdmEntitySet>)new PluralizingEntitySetNameConvention())
.Apply(entitySet, model);
Assert.Equal("Cats", entitySet.Name);
}
public void ApplyModel_should_run_model_conventions()
{
var model = new EdmModel().Initialize();
var mockConvention = new Mock<IEdmConvention>();
var conventionsConfiguration = new ConventionsConfiguration(new[] { mockConvention.Object });
conventionsConfiguration.ApplyModel(model);
mockConvention.Verify(c => c.Apply(model), Times.AtMostOnce());
}
public void Generate_should_initialize_mapping_model()
{
var model = new EdmModel().Initialize();
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
Assert.NotNull(databaseMapping);
Assert.NotNull(databaseMapping.Database);
Assert.Same(model.Containers.Single(), databaseMapping.EntityContainerMappings.Single().EntityContainer);
}
private static DbDatabaseMapping InitializeDatabaseMapping(EdmModel model)
{
//Contract.Requires(model != null);
var databaseMapping = new DbDatabaseMapping().Initialize(
model, new DbDatabaseMetadata().Initialize(model.Version));
databaseMapping.EntityContainerMappings.Single().EntityContainer = model.Containers.Single();
return databaseMapping;
}
private static void FixNavigationProperties(
EdmModel model, EdmAssociationType unifiedAssociation, EdmAssociationType redundantAssociation)
{
foreach (var navigationProperty
in model.GetEntityTypes()
.SelectMany(e => e.NavigationProperties)
.Where(np => np.Association == redundantAssociation))
{
navigationProperty.Association = unifiedAssociation;
navigationProperty.ResultEnd = unifiedAssociation.SourceEnd;
}
}
public DbDatabaseMapping Generate(EdmModel model)
{
//Contract.Requires(model != null);
var databaseMapping = InitializeDatabaseMapping(model);
GenerateEntityTypes(model, databaseMapping);
GenerateDiscriminators(databaseMapping);
GenerateAssociationTypes(model, databaseMapping);
return databaseMapping;
}
public void MapComplexType_should_not_map_ignored_type()
{
var model = new EdmModel().Initialize();
var mockModelConfiguration = new Mock<ModelConfiguration>();
var typeMapper = new TypeMapper(new MappingContext(mockModelConfiguration.Object, new ConventionsConfiguration(), model));
var mockType = new MockType("Foo");
mockModelConfiguration.Setup(m => m.IsIgnoredType(mockType)).Returns(true);
var complexType = typeMapper.MapComplexType(mockType);
Assert.Null(complexType);
}
public void HasCascadeDeletePath_should_return_true_for_self_ref_cascade()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("A");
var associationType = new EdmAssociationType().Initialize();
associationType.SourceEnd.EntityType
= associationType.TargetEnd.EntityType
= entityType;
associationType.SourceEnd.DeleteAction = EdmOperationAction.Cascade;
model.AddAssociationType(associationType);
Assert.True(model.HasCascadeDeletePath(entityType, entityType));
}
public void Map_should_not_detect_arrays_as_collection_associations()
{
var modelConfiguration = new ModelConfiguration();
var model = new EdmModel().Initialize();
var entityType = new EdmEntityType();
var mappingContext = new MappingContext(modelConfiguration, new ConventionsConfiguration(), model);
new NavigationPropertyMapper(new TypeMapper(mappingContext))
.Map(new MockPropertyInfo(typeof(NavigationPropertyMapperTests[]), "Nav"), entityType,
() => new EntityTypeConfiguration(typeof(object)));
Assert.Equal(0, model.Namespaces.Single().AssociationTypes.Count);
}
public void Apply_is_noop_when_unknown_dependent()
{
var model = new EdmModel().Initialize();
var associationType = new EdmAssociationType().Initialize();
var navigationProperty = new EdmNavigationProperty { Association = associationType };
var foreignKeyAnnotation = new ForeignKeyAttribute("AId");
navigationProperty.Annotations.SetClrAttributes(new[] { foreignKeyAnnotation });
((IEdmConvention<EdmNavigationProperty>)new ForeignKeyNavigationPropertyAttributeConvention())
.Apply(navigationProperty, model);
Assert.Null(associationType.Constraint);
}
public void Configure_should_configure_entity_set_name()
{
var model = new EdmModel().Initialize();
var entityType = new EdmEntityType { Name = "E" };
var entitySet = model.AddEntitySet("ESet", entityType);
var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object)) { EntitySetName = "MySet" };
entityTypeConfiguration.Configure(entityType, model);
Assert.Equal("MySet", entitySet.Name);
Assert.Same(entityTypeConfiguration, entitySet.GetConfiguration());
}
private void GenerateEntityTypes(EdmModel model, DbDatabaseMapping databaseMapping)
{
//Contract.Requires(model != null);
//Contract.Requires(databaseMapping != null);
foreach (var entityType in model.GetEntityTypes())
{
if (!entityType.IsAbstract)
{
new EntityTypeMappingGenerator(_providerManifest).
Generate(entityType, databaseMapping);
}
}
}
public void MapEntityType_should_not_bring_in_base_class_by_default()
{
var model = new EdmModel().Initialize();
var typeMapper = new TypeMapper(new MappingContext(new ModelConfiguration(), new ConventionsConfiguration(), model));
var mockType = new MockType("Bar").BaseType(new MockType("Foo"));
var entityType = typeMapper.MapEntityType(mockType);
Assert.NotNull(entityType);
Assert.Null(entityType.BaseType);
Assert.Equal(1, model.Namespaces.Single().EntityTypes.Count);
Assert.Equal(1, model.Containers.Single().EntitySets.Count);
Assert.Equal("Bar", model.GetEntitySet(entityType).Name);
}
public MappingContext(
ModelConfiguration modelConfiguration,
ConventionsConfiguration conventionsConfiguration,
EdmModel model)
{
//Contract.Requires(modelConfiguration != null);
//Contract.Requires(conventionsConfiguration != null);
//Contract.Requires(model != null);
_modelConfiguration = modelConfiguration;
_conventionsConfiguration = conventionsConfiguration;
_model = model;
_attributeProvider = new AttributeProvider();
}
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());
}
void IEdmConvention.Apply(EdmModel model)
{
var associationPairs
= (from a1 in model.GetAssociationTypes()
from a2 in model.GetAssociationTypes()
where a1 != a2
where a1.SourceEnd.EntityType == a2.TargetEnd.EntityType
&& a1.TargetEnd.EntityType == a2.SourceEnd.EntityType
let a1Configuration = a1.GetConfiguration() as NavigationPropertyConfiguration
let a2Configuration = a2.GetConfiguration() as NavigationPropertyConfiguration
where (((a1Configuration == null)
|| ((a1Configuration.InverseEndKind == null)
&& (a1Configuration.InverseNavigationProperty == null)))
&& ((a2Configuration == null)
|| ((a2Configuration.InverseEndKind == null)
&& (a2Configuration.InverseNavigationProperty == null))))
select new
{
a1,
a2
})
.Distinct((a, b) => a.a1 == b.a2 && a.a2 == b.a1)
.GroupBy(
(a, b) => a.a1.SourceEnd.EntityType == b.a2.TargetEnd.EntityType
&& a.a1.TargetEnd.EntityType == b.a2.SourceEnd.EntityType)
.Where(g => g.Count() == 1)
.Select(g => g.Single());
foreach (var pair in associationPairs)
{
var unifiedAssociation = pair.a2.GetConfiguration() != null ? pair.a2 : pair.a1;
var redundantAssociation = unifiedAssociation == pair.a1 ? pair.a2 : pair.a1;
unifiedAssociation.SourceEnd.EndKind = redundantAssociation.TargetEnd.EndKind;
if (redundantAssociation.Constraint != null)
{
unifiedAssociation.Constraint = redundantAssociation.Constraint;
unifiedAssociation.Constraint.DependentEnd =
unifiedAssociation.Constraint.DependentEnd.EntityType == unifiedAssociation.SourceEnd.EntityType
? unifiedAssociation.SourceEnd
: unifiedAssociation.TargetEnd;
}
FixNavigationProperties(model, unifiedAssociation, redundantAssociation);
model.RemoveAssociationType(redundantAssociation);
}
}
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 MapEntityType_should_bring_in_derived_types_from_the_same_assembly()
{
var model = new EdmModel().Initialize();
var typeMapper = new TypeMapper(new MappingContext(new ModelConfiguration(), new ConventionsConfiguration(), model));
var mockType1 = new MockType("Foo");
var mockType2 = new MockType("Bar").BaseType(mockType1);
new MockAssembly(mockType1, mockType2);
typeMapper.MapEntityType(mockType1);
Assert.Equal(2, model.Namespaces.Single().EntityTypes.Count);
Assert.Equal(1, model.Containers.Single().EntitySets.Count);
}
public void Apply_should_uniquify_names_multiple()
{
var model = new EdmModel().Initialize();
model.AddEntitySet("Cats1", new EdmEntityType());
var entitySet1 = model.AddEntitySet("Cat", new EdmEntityType());
var entitySet2 = model.AddEntitySet("Cat", new EdmEntityType());
((IEdmConvention<EdmEntitySet>)new PluralizingEntitySetNameConvention())
.Apply(entitySet1, model);
((IEdmConvention<EdmEntitySet>)new PluralizingEntitySetNameConvention())
.Apply(entitySet2, model);
Assert.Equal("Cats", entitySet1.Name);
Assert.Equal("Cats2", entitySet2.Name);
}
public void Map_should_detect_collection_associations_and_set_correct_end_kinds()
{
var modelConfiguration = new ModelConfiguration();
var model = new EdmModel().Initialize();
var entityType = new EdmEntityType();
var mappingContext = new MappingContext(modelConfiguration, new ConventionsConfiguration(), model);
new NavigationPropertyMapper(new TypeMapper(mappingContext))
.Map(new MockPropertyInfo(typeof(List<NavigationPropertyMapperTests>), "Nav"), entityType,
() => new EntityTypeConfiguration(typeof(object)));
Assert.Equal(1, model.Namespaces.Single().AssociationTypes.Count);
var associationType = model.Namespaces.Single().AssociationTypes.Single();
Assert.Equal(EdmAssociationEndKind.Optional, associationType.SourceEnd.EndKind);
Assert.Equal(EdmAssociationEndKind.Many, associationType.TargetEnd.EndKind);
}
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));
}
internal static DbDatabaseMapping Initialize(
this DbDatabaseMapping databaseMapping, EdmModel model, DbDatabaseMetadata database)
{
//Contract.Requires(databaseMapping != null);
//Contract.Requires(databaseMapping != null);
//Contract.Requires(database != null);
databaseMapping.Model = model;
databaseMapping.Database = database;
var entityContainerMapping
= new DbEntityContainerMapping
{
EntityContainer = model.Containers.Single()
};
databaseMapping.EntityContainerMappings.Add(entityContainerMapping);
return databaseMapping;
}
public void Map_should_create_association_sets_for_associations()
{
var modelConfiguration = new ModelConfiguration();
var model = new EdmModel().Initialize();
var entityType = new EdmEntityType { Name = "Source" };
var mappingContext = new MappingContext(modelConfiguration, new ConventionsConfiguration(), model);
new NavigationPropertyMapper(new TypeMapper(mappingContext))
.Map(new MockPropertyInfo(new MockType("Target"), "Nav"), entityType,
() => new EntityTypeConfiguration(typeof(object)));
Assert.Equal(1, model.Containers.Single().AssociationSets.Count);
var associationSet = model.Containers.Single().AssociationSets.Single();
Assert.NotNull(associationSet);
Assert.NotNull(associationSet.ElementType);
Assert.Equal("Source_Nav", associationSet.Name);
}
public void Apply_should_not_match_key_that_is_also_an_fk()
{
var model = new EdmModel().Initialize();
var entityType = new EdmEntityType();
var property = new EdmProperty().AsPrimitive();
property.PropertyType.EdmType = EdmPrimitiveType.Int64;
entityType.DeclaredKeyProperties.Add(property);
var associationType
= model.AddAssociationType(
"A", new EdmEntityType(), EdmAssociationEndKind.Optional,
entityType, EdmAssociationEndKind.Many);
associationType.Constraint = new EdmAssociationConstraint();
associationType.Constraint.DependentProperties.Add(property);
((IEdmConvention<EdmEntityType>)new StoreGeneratedIdentityKeyConvention())
.Apply(entityType, model);
Assert.Null(entityType.DeclaredKeyProperties.Single().GetStoreGeneratedPattern());
}
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));
}
