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 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 HasCascadeDeletePath_should_return_true_for_transitive_cascade()
{
var model = new EdmModel().Initialize();
var entityTypeA = model.AddEntityType("A");
var entityTypeB = model.AddEntityType("B");
var entityTypeC = model.AddEntityType("B");
var associationTypeA = new EdmAssociationType().Initialize();
associationTypeA.SourceEnd.EntityType = entityTypeA;
associationTypeA.TargetEnd.EntityType = entityTypeB;
associationTypeA.SourceEnd.DeleteAction = EdmOperationAction.Cascade;
model.AddAssociationType(associationTypeA);
var associationTypeB = new EdmAssociationType().Initialize();
associationTypeB.SourceEnd.EntityType = entityTypeB;
associationTypeB.TargetEnd.EntityType = entityTypeC;
associationTypeB.SourceEnd.DeleteAction = EdmOperationAction.Cascade;
model.AddAssociationType(associationTypeB);
Assert.True(model.HasCascadeDeletePath(entityTypeA, entityTypeB));
Assert.True(model.HasCascadeDeletePath(entityTypeB, entityTypeC));
Assert.True(model.HasCascadeDeletePath(entityTypeA, entityTypeC));
Assert.False(model.HasCascadeDeletePath(entityTypeB, entityTypeA));
Assert.False(model.HasCascadeDeletePath(entityTypeC, entityTypeB));
Assert.False(model.HasCascadeDeletePath(entityTypeC, entityTypeA));
}
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 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 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 Apply_should_match_key_that_is_an_fk_used_in_table_splitting()
{
var model = new EdmModel().Initialize();
var entityType = new EdmEntityType();
var property = new EdmProperty().AsPrimitive();
property.PropertyType.EdmType = EdmPrimitiveType.Int64;
entityType.DeclaredKeyProperties.Add(property);
var targetConfig = new EntityTypeConfiguration(typeof(object));
targetConfig.ToTable("SharedTable");
entityType.SetConfiguration(targetConfig);
var sourceEntityType = new EdmEntityType();
var sourceConfig = new EntityTypeConfiguration(typeof(object));
sourceConfig.ToTable("SharedTable");
sourceEntityType.SetConfiguration(sourceConfig);
var associationType
= model.AddAssociationType(
"A", sourceEntityType, EdmAssociationEndKind.Required,
entityType, EdmAssociationEndKind.Required);
associationType.Constraint = new EdmAssociationConstraint();
associationType.Constraint.DependentProperties.Add(property);
((IEdmConvention<EdmEntityType>)new StoreGeneratedIdentityKeyConvention())
.Apply(entityType, model);
Assert.Equal(
DbStoreGeneratedPattern.Identity,
entityType.DeclaredKeyProperties.Single().GetStoreGeneratedPattern());
}
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 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 RemoveAssociationType_should_remove_type_and_set()
{
var model = new EdmModel().Initialize();
var associationType = model.AddAssociationType(
"A",
new EdmEntityType(), EdmAssociationEndKind.Optional,
new EdmEntityType(), EdmAssociationEndKind.Many);
model.AddAssociationSet("FooSet", associationType);
model.RemoveAssociationType(associationType);
Assert.Equal(0, model.GetAssociationTypes().Count());
Assert.Equal(0, model.Containers.First().AssociationSets.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 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);
}
