public void Apply_should_not_add_index_when_one_present()
{
var associationType
= new AssociationType("A", "N", false, DataSpace.SSpace)
{
Constraint
= new ReferentialConstraint(
new AssociationEndMember("F", new EntityType("P", "N", DataSpace.SSpace)),
new AssociationEndMember("T", new EntityType("D", "N", DataSpace.SSpace)),
new EdmProperty[] { },
new[] { new EdmProperty("A"), new EdmProperty("B") })
};
(new ForeignKeyIndexConvention()).Apply(associationType, null);
var consolidatedIndexes
= ConsolidatedIndex.BuildIndexes(
associationType.Name,
associationType.Constraint.ToProperties.Select(p => Tuple.Create(p.Name, p)));
Assert.Equal(1, consolidatedIndexes.Count());
(new ForeignKeyIndexConvention()).Apply(associationType, null);
consolidatedIndexes
= ConsolidatedIndex.BuildIndexes(
associationType.Name,
associationType.Constraint.ToProperties.Select(p => Tuple.Create(p.Name, p)));
Assert.Equal(1, consolidatedIndexes.Count());
}
public static void Create_sets_properties_and_seals_the_instance()
{
var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var associationType = new AssociationType("AssociationType", "Namespace", true, DataSpace.CSpace);
var source = new EntityType("Source", "Namespace", DataSpace.CSpace);
var target = new EntityType("Target", "Namespace", DataSpace.CSpace);
var sourceEnd = new AssociationEndMember("SourceEnd", source);
var targetEnd = new AssociationEndMember("TargetEnd", target);
var navigationProperty =
NavigationProperty.Create(
"NavigationProperty",
typeUsage,
associationType,
sourceEnd,
targetEnd,
new[]
{
new MetadataProperty(
"TestProperty",
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
"value"),
});
Assert.Equal("NavigationProperty", navigationProperty.Name);
Assert.Same(typeUsage, navigationProperty.TypeUsage);
Assert.Same(associationType, navigationProperty.RelationshipType);
Assert.Same(sourceEnd, navigationProperty.FromEndMember);
Assert.Same(targetEnd, navigationProperty.ToEndMember);
Assert.True(navigationProperty.IsReadOnly);
var metadataProperty = navigationProperty.MetadataProperties.SingleOrDefault(p => p.Name == "TestProperty");
Assert.NotNull(metadataProperty);
Assert.Equal("value", metadataProperty.Value);
}
public void Apply_should_discover_for_self_reference()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
associationType.SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace));
associationType.TargetEnd = new AssociationEndMember("T", associationType.SourceEnd.GetEntityType());
associationType.SourceEnd.RelationshipMultiplicity = RelationshipMultiplicity.ZeroOrOne;
associationType.TargetEnd.RelationshipMultiplicity = RelationshipMultiplicity.Many;
var pkProperty = EdmProperty.Primitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
associationType.SourceEnd.GetEntityType().AddKeyMember(pkProperty);
var fkProperty = EdmProperty.Primitive("NavId", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
associationType.TargetEnd.GetEntityType().AddMember(fkProperty);
associationType.TargetEnd.GetEntityType().AddNavigationProperty("Nav", associationType).ToEndMember = associationType.SourceEnd;
associationType.TargetEnd.GetEntityType().AddNavigationProperty("Foos", associationType);
// Foo.Id == Foo.NavId
((IEdmConvention<AssociationType>)new NavigationPropertyNameForeignKeyDiscoveryConvention())
.Apply(associationType, new EdmModel(DataSpace.CSpace));
Assert.NotNull(associationType.Constraint);
Assert.Same(associationType.TargetEnd, associationType.Constraint.ToRole);
Assert.Equal("NavId", associationType.Constraint.ToProperties.Single().Name);
}
public void Apply_is_noop_when_existing_constraint()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
associationType.SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace));
associationType.TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace));
var property = EdmProperty.Primitive("Fk", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var associationConstraint
= new ReferentialConstraint(
associationType.SourceEnd,
associationType.TargetEnd,
new[] { property },
new[] { property });
associationType.Constraint = associationConstraint;
var navigationProperty = new NavigationProperty("N", TypeUsage.Create(new EntityType("E", "N", DataSpace.CSpace)))
{
RelationshipType = associationType
};
((IEdmConvention<NavigationProperty>)new ForeignKeyNavigationPropertyAttributeConvention())
.Apply(navigationProperty, new EdmModel(DataSpace.CSpace));
Assert.Same(associationConstraint, navigationProperty.Association.Constraint);
}
public void Can_get_and_set_ends_via_wrapper_properties()
{
var associationType
= new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)
{
SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace)),
TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace))
};
var associationSet = new AssociationSet("A", associationType);
Assert.Null(associationSet.SourceSet);
Assert.Null(associationSet.TargetSet);
var sourceEntitySet = new EntitySet();
associationSet.SourceSet = sourceEntitySet;
var targetEntitySet = new EntitySet();
associationSet.TargetSet = targetEntitySet;
Assert.Same(sourceEntitySet, associationSet.SourceSet);
Assert.Same(targetEntitySet, associationSet.TargetSet);
}
private static void GenerateForeignKeyAssociationType(
AssociationType associationType, DbDatabaseMapping databaseMapping)
{
DebugCheck.NotNull(associationType);
DebugCheck.NotNull(databaseMapping);
Debug.Assert(associationType.Constraint != null);
var dependentEnd = associationType.Constraint.DependentEnd;
var principalEnd = associationType.GetOtherEnd(dependentEnd);
var principalEntityTypeMapping = GetEntityTypeMappingInHierarchy(databaseMapping, principalEnd.GetEntityType());
var dependentEntityTypeMapping = GetEntityTypeMappingInHierarchy(databaseMapping, dependentEnd.GetEntityType());
var foreignKeyConstraint
= new ForeignKeyBuilder(databaseMapping.Database, associationType.Name)
{
PrincipalTable =
principalEntityTypeMapping.MappingFragments.Single().Table,
DeleteAction = principalEnd.DeleteBehavior != OperationAction.None
? principalEnd.DeleteBehavior
: OperationAction.None
};
dependentEntityTypeMapping
.MappingFragments
.Single()
.Table
.AddForeignKey(foreignKeyConstraint);
foreignKeyConstraint.DependentColumns = associationType.Constraint.ToProperties.Select(
dependentProperty => dependentEntityTypeMapping.GetPropertyMapping(dependentProperty).ColumnProperty);
foreignKeyConstraint.SetAssociationType(associationType);
}
public void Configure_should_configure_inverse()
{
var inverseMockPropertyInfo = new MockPropertyInfo();
var navigationPropertyConfiguration = new NavigationPropertyConfiguration(new MockPropertyInfo())
{
InverseNavigationProperty = inverseMockPropertyInfo
};
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
associationType.SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace));
associationType.TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace));
var inverseAssociationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
inverseAssociationType.SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace));
inverseAssociationType.TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace));
var model = new EdmModel(DataSpace.CSpace);
model.AddAssociationType(inverseAssociationType);
var inverseNavigationProperty
= model.AddEntityType("T")
.AddNavigationProperty("N", inverseAssociationType);
inverseNavigationProperty.SetClrPropertyInfo(inverseMockPropertyInfo);
navigationPropertyConfiguration.Configure(
new NavigationProperty("N", TypeUsage.Create(associationType.TargetEnd.GetEntityType()))
{
RelationshipType = associationType
}, model, new EntityTypeConfiguration(typeof(object)));
Assert.Same(associationType, inverseNavigationProperty.Association);
Assert.Same(associationType.SourceEnd, inverseNavigationProperty.ResultEnd);
Assert.Same(associationType.TargetEnd, inverseNavigationProperty.FromEndMember);
Assert.Equal(0, model.AssociationTypes.Count());
}
/// <inheritdoc/>
protected override bool MatchDependentKeyProperty(
AssociationType associationType,
AssociationEndMember dependentAssociationEnd,
EdmProperty dependentProperty,
EntityType principalEntityType,
EdmProperty principalKeyProperty)
{
Check.NotNull(associationType, "associationType");
Check.NotNull(dependentAssociationEnd, "dependentAssociationEnd");
Check.NotNull(dependentProperty, "dependentProperty");
Check.NotNull(principalEntityType, "principalEntityType");
Check.NotNull(principalKeyProperty, "principalKeyProperty");
var otherEnd = associationType.GetOtherEnd(dependentAssociationEnd);
var navigationProperty
= dependentAssociationEnd.GetEntityType().NavigationProperties
.SingleOrDefault(n => n.ResultEnd == otherEnd);
if (navigationProperty == null)
{
return false;
}
return string.Equals(
dependentProperty.Name, navigationProperty.Name + principalKeyProperty.Name,
StringComparison.OrdinalIgnoreCase);
}
// <summary>
// Add the rel property induced by the specified relationship, (if the target
// end has a multiplicity of one)
// We only keep track of rel-properties that are "interesting"
// </summary>
// <param name="associationType"> the association relationship </param>
// <param name="fromEnd"> source end of the relationship traversal </param>
// <param name="toEnd"> target end of the traversal </param>
private void AddRelProperty(
AssociationType associationType,
AssociationEndMember fromEnd, AssociationEndMember toEnd)
{
if (toEnd.RelationshipMultiplicity
== RelationshipMultiplicity.Many)
{
return;
}
var prop = new RelProperty(associationType, fromEnd, toEnd);
if (_interestingRelProperties == null
||
!_interestingRelProperties.Contains(prop))
{
return;
}
var entityType = ((RefType)fromEnd.TypeUsage.EdmType).ElementType;
List<RelProperty> propList;
if (!_relPropertyMap.TryGetValue(entityType, out propList))
{
propList = new List<RelProperty>();
_relPropertyMap[entityType] = propList;
}
propList.Add(prop);
}
public void HasCascadeDeletePath_should_return_true_for_transitive_cascade()
{
var model = new EdmModel(DataSpace.CSpace);
var entityTypeA = model.AddEntityType("A");
var entityTypeB = model.AddEntityType("B");
var entityTypeC = model.AddEntityType("B");
var associationTypeA
= new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)
{
SourceEnd = new AssociationEndMember("S", entityTypeA),
TargetEnd = new AssociationEndMember("T", entityTypeB)
};
associationTypeA.SourceEnd.DeleteBehavior = OperationAction.Cascade;
model.AddAssociationType(associationTypeA);
var associationTypeB
= new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)
{
SourceEnd = new AssociationEndMember("S", entityTypeB),
TargetEnd = new AssociationEndMember("T", entityTypeC)
};
associationTypeB.SourceEnd.DeleteBehavior = OperationAction.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 Can_get_and_set_constraint_via_wrapper_property()
{
var associationType
= new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)
{
SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace)),
TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace))
};
Assert.Null(associationType.Constraint);
Assert.False(associationType.IsForeignKey);
var property
= EdmProperty.CreatePrimitive("Fk", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var referentialConstraint
= new ReferentialConstraint(
associationType.SourceEnd,
associationType.TargetEnd,
new[] { property },
new[] { property });
associationType.Constraint = referentialConstraint;
Assert.Same(referentialConstraint, associationType.Constraint);
Assert.True(associationType.IsForeignKey);
}
public void Apply_should_set_principal_end_kind_to_required_when_all_properties_not_nullable()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
associationType.SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace));
associationType.TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace));
associationType.SourceEnd.RelationshipMultiplicity = RelationshipMultiplicity.ZeroOrOne;
var property1 = EdmProperty.CreatePrimitive("P1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var property2 = EdmProperty.CreatePrimitive("P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var associationConstraint
= new ReferentialConstraint(
associationType.SourceEnd,
associationType.TargetEnd,
new[]
{
property1,
property2
},
new[]
{
property1,
property2
});
associationConstraint.ToProperties.Each(p => p.Nullable = false);
associationType.Constraint = associationConstraint;
(new ForeignKeyAssociationMultiplicityConvention())
.Apply(associationType, new DbModel(new EdmModel(DataSpace.CSpace), null));
Assert.True(associationType.SourceEnd.IsRequired());
}
public static void SetAssociationType(
this ForeignKeyBuilder fk, AssociationType associationType)
{
DebugCheck.NotNull(fk);
DebugCheck.NotNull(associationType);
fk.Annotations.SetAnnotation(AssociationType, associationType);
}
public static void SetAssociationType(
this ForeignKeyBuilder fk, AssociationType associationType)
{
DebugCheck.NotNull(fk);
DebugCheck.NotNull(associationType);
fk.GetMetadataProperties().SetAnnotation(AssociationType, associationType);
}
public void Can_get_and_set_configuration_facet()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
associationType.SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace));
associationType.TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace));
associationType.SetConfiguration(42);
Assert.Equal(42, associationType.GetConfiguration());
}
public void Initialize_should_create_association_ends()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
associationType.SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace));
associationType.TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace));
Assert.NotNull(associationType.SourceEnd);
Assert.NotNull(associationType.TargetEnd);
}
public void GetOtherEnd_should_return_correct_end()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
associationType.SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace));
associationType.TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace));
Assert.Same(associationType.SourceEnd, associationType.GetOtherEnd(associationType.TargetEnd));
Assert.Same(associationType.TargetEnd, associationType.GetOtherEnd(associationType.SourceEnd));
}
internal override void Configure(
AssociationType associationType, AssociationEndMember dependentEnd,
EntityTypeConfiguration entityTypeConfiguration)
{
DebugCheck.NotNull(associationType);
DebugCheck.NotNull(dependentEnd);
DebugCheck.NotNull(entityTypeConfiguration);
associationType.MarkIndependent();
}
public void IsManyToMany_should_be_true_when_source_many_and_target_many()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
associationType.SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace));
associationType.TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace));
associationType.SourceEnd.RelationshipMultiplicity = RelationshipMultiplicity.Many;
associationType.TargetEnd.RelationshipMultiplicity = RelationshipMultiplicity.Many;
Assert.True(associationType.IsManyToMany());
}
public void Can_mark_association_as_independent()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
Assert.False(associationType.IsIndependent());
associationType.MarkIndependent();
Assert.True(associationType.IsIndependent());
}
public void Can_get_association_set_mapping()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
var associationSetMapping
= new AssociationSetMapping(
new AssociationSet("AS", associationType),
new EntityContainerMapping(new EntityContainer("C", DataSpace.CSpace)));
var associationTypeMapping = new AssociationTypeMapping(associationSetMapping);
Assert.Same(associationSetMapping, associationTypeMapping.AssociationSetMapping);
}
public void Cannot_create_with_null_argument()
{
var associationType = new AssociationType("AT", "N", false, DataSpace.CSpace);
var associationSet = new AssociationSet("AS", associationType);
Assert.Equal(
"members",
Assert.Throws<ArgumentNullException>(
() => new ModificationFunctionMemberPath(
null, associationSet)).ParamName);
}
public void IsOfType_collection_empty()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
var setMapping
= new StorageEntitySetMapping(
new EntitySet(),
new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace)));
Assert.Empty(new StorageAssociationTypeMapping(associationType, setMapping).IsOfTypes);
}
public void Apply_should_not_discover_when_independent_constraint()
{
var associationType = new AssociationType();
associationType.SourceEnd = new AssociationEndMember("S", new EntityType());
associationType.TargetEnd = new AssociationEndMember("T", new EntityType());
associationType.MarkIndependent();
((IEdmConvention<AssociationType>)new TypeNameForeignKeyDiscoveryConvention())
.Apply(associationType, new EdmModel().Initialize());
Assert.Null(associationType.Constraint);
}
private static void FixNavigationProperties(
EdmModel model, AssociationType unifiedAssociation, AssociationType redundantAssociation)
{
foreach (var navigationProperty
in model.GetEntityTypes()
.SelectMany(e => e.NavigationProperties)
.Where(np => np.Association == redundantAssociation))
{
navigationProperty.RelationshipType = unifiedAssociation;
navigationProperty.ToEndMember = unifiedAssociation.SourceEnd;
}
}
public void Apply_should_not_add_action_when_self_reference()
{
var associationType = new AssociationType();
associationType.SourceEnd = new AssociationEndMember("S", new EntityType());
associationType.TargetEnd = new AssociationEndMember("T", associationType.SourceEnd.GetEntityType());
((IEdmConvention<AssociationType>)new OneToManyCascadeDeleteConvention())
.Apply(associationType, new EdmModel().Initialize());
Assert.Equal(OperationAction.None, associationType.SourceEnd.DeleteBehavior);
Assert.Equal(OperationAction.None, associationType.TargetEnd.DeleteBehavior);
}
public void Apply_should_not_add_action_when_self_reference()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
associationType.SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace));
associationType.TargetEnd = new AssociationEndMember("T", associationType.SourceEnd.GetEntityType());
((IEdmConvention<AssociationType>)new OneToManyCascadeDeleteConvention())
.Apply(associationType, new EdmModel(DataSpace.CSpace));
Assert.Equal(OperationAction.None, associationType.SourceEnd.DeleteBehavior);
Assert.Equal(OperationAction.None, associationType.TargetEnd.DeleteBehavior);
}
public void Apply_should_not_discover_when_independent_constraint()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
associationType.SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace));
associationType.TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace));
associationType.MarkIndependent();
(new TypeNameForeignKeyDiscoveryConvention())
.Apply(associationType, new DbModel(new EdmModel(DataSpace.CSpace), null));
Assert.Null(associationType.Constraint);
}
public void Association_type_returned_in_type_collection()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
var setMapping
= new StorageEntitySetMapping(
new EntitySet(),
new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace)));
Assert.Same(
associationType,
new StorageAssociationTypeMapping(associationType, setMapping).Types.Single());
}
public void Can_get_association_type()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
var setMapping
= new StorageEntitySetMapping(
new EntitySet(),
new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace)));
Assert.Same(
associationType,
new StorageAssociationTypeMapping(associationType, setMapping).AssociationType);
}
private void ResolveAssociationEnd(
AssociationType associationType,
string roleName,
Type clrType,
RelationshipMultiplicity multiplicity)
{
EntityType entityType;
if (!this.TryGetRelationshipEndEntityType(clrType, out entityType))
{
this.SessionData.EdmItemErrors.Add(new EdmItemError(Strings.RoleTypeInEdmRelationshipAttributeIsInvalidType((object)associationType.Name, (object)roleName, (object)clrType)));
}
else
{
associationType.AddKeyMember((EdmMember) new AssociationEndMember(roleName, entityType.GetReferenceType(), multiplicity));
}
}
public void Can_get_and_set_ends_via_wrapper_properties()
{
var associationType = new AssociationType();
Assert.Null(associationType.SourceEnd);
Assert.Null(associationType.TargetEnd);
var sourceEnd = new AssociationEndMember("S", new EntityType());
associationType.SourceEnd = sourceEnd;
var targetEnd = new AssociationEndMember("T", new EntityType());
associationType.TargetEnd = targetEnd;
Assert.Same(sourceEnd, associationType.SourceEnd);
Assert.Same(targetEnd, associationType.TargetEnd);
}
public void Can_get_and_set_ends_via_wrapper_properties()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
Assert.Null(associationType.SourceEnd);
Assert.Null(associationType.TargetEnd);
var sourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace));
associationType.SourceEnd = sourceEnd;
var targetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace));
associationType.TargetEnd = targetEnd;
Assert.Same(sourceEnd, associationType.SourceEnd);
Assert.Same(targetEnd, associationType.TargetEnd);
}
[Fact] // Codeplex 1735
public void EdmAssociationType_ValidateReferentialConstraint_validates_composite_key_properties_in_correct_order()
{
var principal = new EntityType(
"Principal", "N", DataSpace.CSpace,
new[] { "IdInt", "IdString" },
new EdmMember[]
{
new EdmProperty("IdInt", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))),
new EdmProperty("IdString", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)))
});
var dependent = new EntityType(
"Dependent", "N", DataSpace.CSpace,
new[] { "Id" },
new EdmMember[]
{
new EdmProperty("Id", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))),
new EdmProperty("IdString", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String))),
new EdmProperty("IdInt", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)))
});
var associationType = new AssociationType("AT", "N", true, DataSpace.CSpace);
var fromRole = new AssociationEndMember("Principal", new RefType(principal), RelationshipMultiplicity.ZeroOrOne);
var toRole = new AssociationEndMember("Dependent", new RefType(dependent), RelationshipMultiplicity.Many);
associationType.Constraint = new ReferentialConstraint(
fromRole, toRole,
new[] { principal.Properties["IdString"], principal.Properties["IdInt"] },
new[] { dependent.Properties["IdString"], dependent.Properties["IdInt"] });
var validationContext
= new EdmModelValidationContext(new EdmModel(DataSpace.CSpace), true);
DataModelErrorEventArgs errorEventArgs = null;
validationContext.OnError += (_, e) => errorEventArgs = e;
EdmModelSemanticValidationRules
.EdmAssociationType_ValidateReferentialConstraint
.Evaluate(validationContext, associationType);
Assert.Null(errorEventArgs);
}
private DataModelErrorEventArgs ValidateAssociationTypeWithNonFkeyReference(DataSpace dataSpace)
{
var model = new EdmModel(dataSpace, 1.0);
var intType =
dataSpace == DataSpace.CSpace
? PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)
: FakeSqlProviderServices.Instance.GetProviderManifest("2008").GetStoreTypes().Single(t => t.Name == "int");
var principal =
new EntityType("P", "ns", dataSpace, new [] { "Id" }, new[] { EdmProperty.CreatePrimitive("Id", intType) });
var dependent =
new EntityType("P", "ns", dataSpace, new [] { "Id" },
new[] { EdmProperty.CreatePrimitive("Id", intType), EdmProperty.CreatePrimitive("NonKeyProperty", intType) });
foreach (var property in principal.Properties.Concat(dependent.Properties))
{
property.Nullable = false;
}
var associationType =
new AssociationType("AT", "ns", false, dataSpace)
{
Constraint = new ReferentialConstraint(
new AssociationEndMember("P", principal.GetReferenceType(), RelationshipMultiplicity.One),
new AssociationEndMember("C", dependent.GetReferenceType(), RelationshipMultiplicity.Many),
principal.KeyProperties,
dependent.Properties.Where(p => p.Name == "NonKeyProperty"))
};
model.AddAssociationType(associationType);
var validationContext = new EdmModelValidationContext(model, true);
DataModelErrorEventArgs errorEventArgs = null;
validationContext.OnError += (_, e) => errorEventArgs = e;
EdmModelSemanticValidationRules
.EdmAssociationType_ValidateReferentialConstraint
.Evaluate(validationContext, model.AssociationTypes.Single());
return(errorEventArgs);
}
protected internal override void VisitEdmAssociationType(AssociationType item)
{
var builder = new StringBuilder();
AppendSchemaErrors(builder, item);
if (MetadataItemHelper.IsInvalid(item))
{
AppendMetadataItem(builder, item, (v, i) => v.InternalVisitEdmAssociationType(i));
WriteComment(builder.ToString());
}
else
{
WriteComment(builder.ToString());
InternalVisitEdmAssociationType(item);
}
}
private static AssociationType CreateCSpaceAssociationType(int index)
{
var sourceProperty = new EdmProperty("SourceProperty");
var targetProperty = new EdmProperty("TargetProperty");
var sourceEntityType = EntityType.Create(
"SourceEntityType" + index,
"Namespace",
DataSpace.CSpace,
new [] { "SourceProperty" },
new[] { sourceProperty },
Enumerable.Empty <MetadataProperty>());
var targetEntityType = EntityType.Create(
"TargetEntityType" + index,
"Namespace",
DataSpace.CSpace,
new[] { "TargetProperty" },
new[] { targetProperty },
Enumerable.Empty <MetadataProperty>());
var sourceEnd = new AssociationEndMember("SourceEnd" + index, sourceEntityType);
var targetEnd = new AssociationEndMember("TargetEnd" + index, targetEntityType);
var constraint =
new ReferentialConstraint(
sourceEnd,
targetEnd,
new[] { sourceProperty },
new[] { targetProperty });
var associationType =
AssociationType.Create(
"AssociationType" + index,
"Namespace",
true,
DataSpace.CSpace,
sourceEnd,
targetEnd,
constraint,
Enumerable.Empty <MetadataProperty>());
return(associationType);
}
internal AssociationType GetOSpaceAssociationType(
AssociationType cSpaceAssociationType,
Func <AssociationType> initializer)
{
AssociationType[] associationTypes = this.GetOSpaceAssociationTypes();
int index = cSpaceAssociationType.Index;
Thread.MemoryBarrier();
AssociationType associationType = associationTypes[index];
if (associationType == null)
{
associationType = initializer();
associationType.Index = index;
associationTypes[index] = associationType;
Thread.MemoryBarrier();
}
return(associationType);
}
private static NavigationProperty ConvertToNavigationProperty(
EntityType declaringEntityType,
System.Data.Entity.Core.SchemaObjectModel.NavigationProperty somNavigationProperty,
DbProviderManifest providerManifest,
Converter.ConversionCache convertedItemCache,
Dictionary <SchemaElement, GlobalItem> newGlobalItems)
{
EntityType endMemberType = (EntityType)Converter.LoadSchemaElement(somNavigationProperty.Type, providerManifest, convertedItemCache, newGlobalItems);
AssociationType associationType = (AssociationType)Converter.LoadSchemaElement((System.Data.Entity.Core.SchemaObjectModel.SchemaType)somNavigationProperty.Relationship, providerManifest, convertedItemCache, newGlobalItems);
IRelationshipEnd end = (IRelationshipEnd)null;
somNavigationProperty.Relationship.TryGetEnd(somNavigationProperty.ToEnd.Name, out end);
RelationshipMultiplicity?multiplicity1 = end.Multiplicity;
EdmType edmType = (multiplicity1.GetValueOrDefault() != RelationshipMultiplicity.Many ? 0 : (multiplicity1.HasValue ? 1 : 0)) == 0 ? (EdmType)endMemberType : (EdmType)endMemberType.GetCollectionType();
RelationshipMultiplicity?multiplicity2 = end.Multiplicity;
TypeUsage typeUsage;
if ((multiplicity2.GetValueOrDefault() != RelationshipMultiplicity.One ? 0 : (multiplicity2.HasValue ? 1 : 0)) != 0)
{
typeUsage = TypeUsage.Create(edmType, new FacetValues()
{
Nullable = (FacetValueContainer <bool?>) new bool?(false)
});
}
else
{
typeUsage = TypeUsage.Create(edmType);
}
Converter.InitializeAssociationEndMember(associationType, somNavigationProperty.ToEnd, endMemberType);
Converter.InitializeAssociationEndMember(associationType, somNavigationProperty.FromEnd, declaringEntityType);
NavigationProperty navigationProperty = new NavigationProperty(somNavigationProperty.Name, typeUsage);
navigationProperty.RelationshipType = (RelationshipType)associationType;
navigationProperty.ToEndMember = (RelationshipEndMember)associationType.Members[somNavigationProperty.ToEnd.Name];
navigationProperty.FromEndMember = (RelationshipEndMember)associationType.Members[somNavigationProperty.FromEnd.Name];
if (somNavigationProperty.Documentation != null)
{
navigationProperty.Documentation = Converter.ConvertToDocumentation(somNavigationProperty.Documentation);
}
Converter.AddOtherContent((SchemaElement)somNavigationProperty, (MetadataItem)navigationProperty);
return(navigationProperty);
}
internal static AssociationEndMember GetEndThatShouldBeMappedToKey(
AssociationType associationType)
{
if (associationType.AssociationEndMembers.Any <AssociationEndMember>((Func <AssociationEndMember, bool>)(it => it.RelationshipMultiplicity.Equals((object)RelationshipMultiplicity.One))))
{
return(associationType.AssociationEndMembers.SingleOrDefault <AssociationEndMember>((Func <AssociationEndMember, bool>)(it =>
{
if (!it.RelationshipMultiplicity.Equals((object)RelationshipMultiplicity.Many))
{
return it.RelationshipMultiplicity.Equals((object)RelationshipMultiplicity.ZeroOrOne);
}
return true;
})));
}
if (associationType.AssociationEndMembers.Any <AssociationEndMember>((Func <AssociationEndMember, bool>)(it => it.RelationshipMultiplicity.Equals((object)RelationshipMultiplicity.ZeroOrOne))))
{
return(associationType.AssociationEndMembers.SingleOrDefault <AssociationEndMember>((Func <AssociationEndMember, bool>)(it => it.RelationshipMultiplicity.Equals((object)RelationshipMultiplicity.Many))));
}
return((AssociationEndMember)null);
}
public void Can_add_association_set_to_container()
{
var entityContainer = new EntityContainer("Container", DataSpace.CSpace);
var associationType
= new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)
{
SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace)),
TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace))
};
var associationSet = new AssociationSet("A", associationType);
Assert.Equal(0, entityContainer.EntitySets.Count);
Assert.Null(associationSet.EntityContainer);
entityContainer.AddEntitySetBase(associationSet);
Assert.Equal(1, entityContainer.AssociationSets.Count);
Assert.Same(associationSet, entityContainer.AssociationSets.Single());
Assert.Same(entityContainer, associationSet.EntityContainer);
}
public IEnumerable <EdmProperty> GetDependentProperties()
{
AssociationType relationshipType = (AssociationType)this.RelationshipType;
if (relationshipType.ReferentialConstraints.Count > 0)
{
ReferentialConstraint referentialConstraint = relationshipType.ReferentialConstraints[0];
if (referentialConstraint.ToRole.EdmEquals((MetadataItem)this.FromEndMember))
{
ReadOnlyMetadataCollection <EdmMember> keyMembers = referentialConstraint.FromRole.GetEntityType().KeyMembers;
List <EdmProperty> edmPropertyList = new List <EdmProperty>(keyMembers.Count);
for (int index = 0; index < keyMembers.Count; ++index)
{
edmPropertyList.Add(referentialConstraint.ToProperties[referentialConstraint.FromProperties.IndexOf((EdmProperty)keyMembers[index])]);
}
return((IEnumerable <EdmProperty>) new ReadOnlyCollection <EdmProperty>((IList <EdmProperty>)edmPropertyList));
}
}
return(Enumerable.Empty <EdmProperty>());
}
public virtual void CreateRelationships(EdmItemCollection edmItemCollection)
{
foreach (var cspaceAssociation in edmItemCollection.GetItems <AssociationType>())
{
Debug.Assert(cspaceAssociation.RelationshipEndMembers.Count == 2, "Relationships are assumed to have exactly two ends");
if (CspaceToOspace.ContainsKey(cspaceAssociation))
{
// don't try to load relationships that we already know about
continue;
}
var ospaceEndTypes = new EdmType[2];
if (CspaceToOspace.TryGetValue(
GetRelationshipEndType(cspaceAssociation.RelationshipEndMembers[0]), out ospaceEndTypes[0]) &&
CspaceToOspace.TryGetValue(
GetRelationshipEndType(cspaceAssociation.RelationshipEndMembers[1]), out ospaceEndTypes[1]))
{
Debug.Assert(ospaceEndTypes[0] is StructuralType);
Debug.Assert(ospaceEndTypes[1] is StructuralType);
// if we can find both ends of the relationship, then create it
var ospaceAssociation = new AssociationType(
cspaceAssociation.Name, cspaceAssociation.NamespaceName, cspaceAssociation.IsForeignKey, DataSpace.OSpace);
for (var i = 0; i < cspaceAssociation.RelationshipEndMembers.Count; i++)
{
var ospaceEndType = (EntityType)ospaceEndTypes[i];
var cspaceEnd = cspaceAssociation.RelationshipEndMembers[i];
ospaceAssociation.AddKeyMember(
new AssociationEndMember(cspaceEnd.Name, ospaceEndType.GetReferenceType(), cspaceEnd.RelationshipMultiplicity));
}
AddToTypesInAssembly(ospaceAssociation);
LoadedTypes.Add(ospaceAssociation.FullName, ospaceAssociation);
CspaceToOspace.Add(cspaceAssociation, ospaceAssociation);
}
}
}
internal AssociationSet FindCSpaceAssociationSet(
AssociationType associationType,
string endName,
string entitySetName,
string entityContainerName,
out EntitySet endEntitySet)
{
object associationTypeToSets = this.GetCSpaceAssociationTypeToSetsMap()[associationType.Index];
if (associationTypeToSets == null)
{
endEntitySet = (EntitySet)null;
return((AssociationSet)null);
}
AssociationSet associationSet1 = associationTypeToSets as AssociationSet;
if (associationSet1 != null)
{
EntitySet entitySet = associationSet1.AssociationSetEnds[endName].EntitySet;
if (entitySet.Name == entitySetName && entitySet.EntityContainer.Name == entityContainerName)
{
endEntitySet = entitySet;
return(associationSet1);
}
endEntitySet = (EntitySet)null;
return((AssociationSet)null);
}
foreach (AssociationSet associationSet2 in (AssociationSet[])associationTypeToSets)
{
EntitySet entitySet = associationSet2.AssociationSetEnds[endName].EntitySet;
if (entitySet.Name == entitySetName && entitySet.EntityContainer.Name == entityContainerName)
{
endEntitySet = entitySet;
return(associationSet2);
}
}
endEntitySet = (EntitySet)null;
return((AssociationSet)null);
}
public static void Adding_a_NavigationProperty_to_an_EntityType_can_be_forced_when_read_only()
{
var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var associationType = new AssociationType("AssociationType", "Namespace", true, DataSpace.CSpace);
var source = new EntityType("Source", "Namespace", DataSpace.CSpace);
var target = new EntityType("Target", "Namespace", DataSpace.CSpace);
var sourceEnd = new AssociationEndMember("SourceEnd", source);
var targetEnd = new AssociationEndMember("TargetEnd", target);
var navigationProperty =
NavigationProperty.Create(
"NavigationProperty",
typeUsage,
associationType,
sourceEnd,
targetEnd,
null);
source.SetReadOnly();
Assert.True(source.IsReadOnly);
Assert.Equal(
Resources.Strings.OperationOnReadOnlyItem,
Assert.Throws <InvalidOperationException>(
() => source.AddMember(navigationProperty)).Message);
Assert.Equal(0, source.Members.Count);
source.AddNavigationProperty(navigationProperty);
Assert.True(source.IsReadOnly);
Assert.Equal(1, source.Members.Count);
Assert.Same(navigationProperty, source.Members[0]);
Assert.Equal(
Resources.Strings.OperationOnReadOnlyItem,
Assert.Throws <InvalidOperationException>(
() => source.AddMember(navigationProperty)).Message);
}
public void Can_get_association_ends_from_association_set()
{
var sourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace));
var targetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace));
var associationType
= new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
associationType.AddKeyMember(targetEnd);
associationType.AddKeyMember(sourceEnd);
var associationSet = new AssociationSet("A", associationType);
Assert.Null(associationSet.SourceEnd);
Assert.Null(associationSet.TargetEnd);
associationSet.AddAssociationSetEnd(new AssociationSetEnd(new EntitySet(), associationSet, sourceEnd));
associationSet.AddAssociationSetEnd(new AssociationSetEnd(new EntitySet(), associationSet, targetEnd));
Assert.Same(sourceEnd, associationSet.SourceEnd);
Assert.Same(targetEnd, associationSet.TargetEnd);
}
/// <summary>
/// Creates a read-only AssociationType instance from the specified parameters.
/// </summary>
/// <param name="name">The name of the association type.</param>
/// <param name="namespaceName">The namespace of the association type.</param>
/// <param name="foreignKey">Flag that indicates a foreign key (FK) relationship.</param>
/// <param name="dataSpace">The data space for the association type.</param>
/// <param name="sourceEnd">The source association end member.</param>
/// <param name="targetEnd">The target association end member.</param>
/// <param name="constraint">A referential constraint.</param>
/// <param name="metadataProperties">Metadata properties to be associated with the instance.</param>
/// <returns>The newly created AssociationType instance.</returns>
/// <exception cref="System.ArgumentException">The specified name is null or empty.</exception>
/// <exception cref="System.ArgumentException">The specified namespace is null or empty.</exception>
public static AssociationType Create(
string name,
string namespaceName,
bool foreignKey,
DataSpace dataSpace,
AssociationEndMember sourceEnd,
AssociationEndMember targetEnd,
ReferentialConstraint constraint,
IEnumerable <MetadataProperty> metadataProperties)
{
Check.NotEmpty(name, "name");
Check.NotEmpty(namespaceName, "namespaceName");
var instance = new AssociationType(name, namespaceName, foreignKey, dataSpace);
if (sourceEnd != null)
{
instance.SourceEnd = sourceEnd;
}
if (targetEnd != null)
{
instance.TargetEnd = targetEnd;
}
if (constraint != null)
{
instance.AddReferentialConstraint(constraint);
}
if (metadataProperties != null)
{
instance.AddMetadataProperties(metadataProperties);
}
instance.SetReadOnly();
return(instance);
}
internal AssociationType GetOSpaceAssociationType(
AssociationType cSpaceAssociationType, Func <AssociationType> initializer)
{
Debug.Assert(cSpaceAssociationType.DataSpace == DataSpace.CSpace);
var oSpaceAssociationTypes = GetOSpaceAssociationTypes();
var index = cSpaceAssociationType.Index;
Thread.MemoryBarrier();
var oSpaceAssociationType = oSpaceAssociationTypes[index];
if (oSpaceAssociationType == null)
{
oSpaceAssociationType = initializer();
Debug.Assert(oSpaceAssociationType.DataSpace == DataSpace.OSpace);
oSpaceAssociationType.Index = index;
oSpaceAssociationTypes[index] = oSpaceAssociationType;
Thread.MemoryBarrier();
}
return(oSpaceAssociationType);
}
public void Create_sets_properties_and_seals_the_instance()
{
var source = new EntityType("Source", "Namespace", DataSpace.CSpace);
var target = new EntityType("Target", "Namespace", DataSpace.CSpace);
var sourceEnd = new AssociationEndMember("SourceEnd", source);
var targetEnd = new AssociationEndMember("TargetEnd", target);
var constraint =
new ReferentialConstraint(
sourceEnd,
targetEnd,
new[] { new EdmProperty("SourceProperty") },
new[] { new EdmProperty("TargetProperty") });
var metadataProperty =
new MetadataProperty(
"MetadataProperty",
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
"value");
var associationType =
AssociationType.Create(
"AssociationType",
"Namespace",
true,
DataSpace.CSpace,
sourceEnd,
targetEnd,
constraint,
new[] { metadataProperty });
Assert.Equal("Namespace.AssociationType", associationType.FullName);
Assert.Equal(true, associationType.IsForeignKey);
Assert.Equal(DataSpace.CSpace, associationType.DataSpace);
Assert.Same(sourceEnd, associationType.SourceEnd);
Assert.Same(targetEnd, associationType.TargetEnd);
Assert.Same(constraint, associationType.Constraint);
Assert.Same(metadataProperty, associationType.MetadataProperties.SingleOrDefault(p => p.Name == "MetadataProperty"));
Assert.True(associationType.IsReadOnly);
}
internal AssociationSet FindCSpaceAssociationSet(AssociationType associationType, string endName, EntitySet endEntitySet)
{
DebugCheck.NotNull(associationType);
DebugCheck.NotEmpty(endName);
DebugCheck.NotNull(endEntitySet);
Debug.Assert(associationType.DataSpace == DataSpace.CSpace);
var array = GetCSpaceAssociationTypeToSetsMap();
var index = associationType.Index;
var objectAtIndex = array[index];
if (objectAtIndex == null)
{
return(null);
}
var associationSet = objectAtIndex as AssociationSet;
if (associationSet != null)
{
return(associationSet.AssociationSetEnds[endName].EntitySet == endEntitySet ? associationSet : null);
}
var items = (AssociationSet[])objectAtIndex;
for (var i = 0; i < items.Length; i++)
{
associationSet = items[i];
if (associationSet.AssociationSetEnds[endName].EntitySet == endEntitySet)
{
return(associationSet);
}
}
return(null);
}
/// <summary>
/// Creates a read-only AssociationSet instance from the specified parameters.
/// </summary>
/// <param name="name">The name of the association set.</param>
/// <param name="type">The association type of the elements in the association set.</param>
/// <param name="sourceSet">The entity set for the source association set end.</param>
/// <param name="targetSet">The entity set for the target association set end.</param>
/// <param name="metadataProperties">Metadata properties to be associated with the instance.</param>
/// <returns>The newly created AssociationSet instance.</returns>
/// <exception cref="System.ArgumentException">The specified name is null or empty.</exception>
/// <exception cref="System.ArgumentNullException">The specified association type is null.</exception>
/// <exception cref="System.ArgumentException">
/// The entity type of one of the ends of the specified
/// association type does not match the entity type of the corresponding entity set end.
/// </exception>
public static AssociationSet Create(
string name,
AssociationType type,
EntitySet sourceSet,
EntitySet targetSet,
IEnumerable <MetadataProperty> metadataProperties)
{
Check.NotEmpty(name, "name");
Check.NotNull(type, "type");
if (!CheckEntitySetAgainstEndMember(sourceSet, type.SourceEnd) ||
!CheckEntitySetAgainstEndMember(targetSet, type.TargetEnd))
{
throw new ArgumentException(Strings.AssociationSet_EndEntityTypeMismatch);
}
var instance = new AssociationSet(name, type);
if (sourceSet != null)
{
instance.SourceSet = sourceSet;
}
if (targetSet != null)
{
instance.TargetSet = targetSet;
}
if (metadataProperties != null)
{
instance.AddMetadataProperties(metadataProperties.ToList());
}
instance.SetReadOnly();
return(instance);
}
public static void Create_sets_properties_and_seals_the_instance()
{
var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var associationType = new AssociationType("AssociationType", "Namespace", true, DataSpace.CSpace);
var source = new EntityType("Source", "Namespace", DataSpace.CSpace);
var target = new EntityType("Target", "Namespace", DataSpace.CSpace);
var sourceEnd = new AssociationEndMember("SourceEnd", source);
var targetEnd = new AssociationEndMember("TargetEnd", target);
var navigationProperty =
NavigationProperty.Create(
"NavigationProperty",
typeUsage,
associationType,
sourceEnd,
targetEnd,
new[]
{
new MetadataProperty(
"TestProperty",
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
"value"),
});
Assert.Equal("NavigationProperty", navigationProperty.Name);
Assert.Same(typeUsage, navigationProperty.TypeUsage);
Assert.Same(associationType, navigationProperty.RelationshipType);
Assert.Same(sourceEnd, navigationProperty.FromEndMember);
Assert.Same(targetEnd, navigationProperty.ToEndMember);
Assert.True(navigationProperty.IsReadOnly);
var metadataProperty = navigationProperty.MetadataProperties.SingleOrDefault(p => p.Name == "TestProperty");
Assert.NotNull(metadataProperty);
Assert.Equal("value", metadataProperty.Value);
}
public static void Create_sets_properties_and_seals_the_instance()
{
var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var associationType = new AssociationType("AssociationType", "Namespace", true, DataSpace.CSpace);
var source = new EntityType("Source", "Namespace", DataSpace.CSpace);
var target = new EntityType("Target", "Namespace", DataSpace.CSpace);
var sourceEnd = new AssociationEndMember("SourceEnd", source);
var targetEnd = new AssociationEndMember("TargetEnd", target);
var navigationProperty =
NavigationProperty.Create(
"NavigationProperty",
typeUsage,
associationType,
sourceEnd,
targetEnd);
Assert.Equal("NavigationProperty", navigationProperty.Name);
Assert.Same(typeUsage, navigationProperty.TypeUsage);
Assert.Same(associationType, navigationProperty.RelationshipType);
Assert.Same(sourceEnd, navigationProperty.FromEndMember);
Assert.Same(targetEnd, navigationProperty.ToEndMember);
Assert.True(navigationProperty.IsReadOnly);
}
public void Create_throws_argument_exception_when_called_with_invalid_arguments()
{
var source = new EntityType("Source", "Namespace", DataSpace.CSpace);
var target = new EntityType("Target", "Namespace", DataSpace.CSpace);
var sourceEnd = new AssociationEndMember("SourceEnd", source);
var targetEnd = new AssociationEndMember("TargetEnd", target);
var constraint =
new ReferentialConstraint(
sourceEnd,
targetEnd,
new[] { new EdmProperty("SourceProperty") },
new[] { new EdmProperty("TargetProperty") });
var metadataProperty =
new MetadataProperty(
"MetadataProperty",
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
"value");
Assert.Throws <ArgumentException>(
() => AssociationType.Create(
null,
"Namespace",
true,
DataSpace.CSpace,
sourceEnd,
targetEnd,
constraint,
new[] { metadataProperty }));
Assert.Throws <ArgumentException>(
() => AssociationType.Create(
String.Empty,
"Namespace",
true,
DataSpace.CSpace,
sourceEnd,
targetEnd,
constraint,
new[] { metadataProperty }));
Assert.Throws <ArgumentException>(
() => AssociationType.Create(
"AssociationType",
null,
true,
DataSpace.CSpace,
sourceEnd,
targetEnd,
constraint,
new[] { metadataProperty }));
Assert.Throws <ArgumentException>(
() => AssociationType.Create(
"AssociationType",
String.Empty,
true,
DataSpace.CSpace,
sourceEnd,
targetEnd,
constraint,
new[] { metadataProperty }));
}
public void Create_checks_each_EntitySet_parameter_against_corresponding_AssociationEndMember()
{
var source = new EntityType("Source", "Namespace", DataSpace.CSpace);
var target = new EntityType("Target", "Namespace", DataSpace.CSpace);
var other = new EntityType("Other", "Namespace", DataSpace.CSpace);
var sourceSet = new EntitySet("SourceSet", "Schema", "Table", "Query", source);
var targetSet = new EntitySet("TargetSet", "Schema", "Table", "Query", target);
var otherSet = new EntitySet("OtherSet", "Schema", "Table", "Query", other);
var sourceEnd = new AssociationEndMember("SourceEnd", source);
var targetEnd = new AssociationEndMember("TargetEnd", target);
var associationTypeWithNonNullEndMembers =
AssociationType.Create(
"AssociationType",
"Namespace",
true,
DataSpace.CSpace,
sourceEnd,
targetEnd,
null,
null);
var associationTypeWithNullEndMembers =
AssociationType.Create(
"AssociationType",
"Namespace",
true,
DataSpace.CSpace,
null, // sourceEnd
null, // targetEnd
null,
null);
Assert.NotNull(
AssociationSet.Create(
"AssociationSet",
associationTypeWithNonNullEndMembers,
sourceSet,
targetSet,
null));
Assert.NotNull(
AssociationSet.Create(
"AssociationSet",
associationTypeWithNullEndMembers,
null, // sourceSet
null, // targetSet
null));
Assert.Equal(
Resources.Strings.AssociationSet_EndEntityTypeMismatch,
Assert.Throws <ArgumentException>(
() => AssociationSet.Create(
"AssociationSet",
associationTypeWithNonNullEndMembers,
otherSet,
targetSet,
null)).Message);
Assert.Equal(
Resources.Strings.AssociationSet_EndEntityTypeMismatch,
Assert.Throws <ArgumentException>(
() => AssociationSet.Create(
"AssociationSet",
associationTypeWithNonNullEndMembers,
sourceSet,
otherSet,
null)).Message);
Assert.Equal(
Resources.Strings.AssociationSet_EndEntityTypeMismatch,
Assert.Throws <ArgumentException>(
() => AssociationSet.Create(
"AssociationSet",
associationTypeWithNonNullEndMembers,
null, // sourceSet
targetSet,
null)).Message);
Assert.Equal(
Resources.Strings.AssociationSet_EndEntityTypeMismatch,
Assert.Throws <ArgumentException>(
() => AssociationSet.Create(
"AssociationSet",
associationTypeWithNonNullEndMembers,
sourceSet,
null, // targetSet
null)).Message);
Assert.Equal(
Resources.Strings.AssociationSet_EndEntityTypeMismatch,
Assert.Throws <ArgumentException>(
() => AssociationSet.Create(
"AssociationSet",
associationTypeWithNullEndMembers,
null, // sourceSet
targetSet,
null)).Message);
Assert.Equal(
Resources.Strings.AssociationSet_EndEntityTypeMismatch,
Assert.Throws <ArgumentException>(
() => AssociationSet.Create(
"AssociationSet",
associationTypeWithNullEndMembers,
sourceSet,
null, // targetSet
null)).Message);
}
internal AssociationType GetCSpaceAssociationType(AssociationType osAssociationType)
{
Debug.Assert(osAssociationType.Index >= 0);
return(_csAssociationTypes[osAssociationType.Index]);
}
/// <summary>
/// Removes an association type from the model.
/// </summary>
/// <param name="item">The AssociationType instance to be removed.</param>
public void RemoveItem(AssociationType item)
{
Check.NotNull(item, "item");
_associationTypes.Remove(item);
}
// <summary>
// Initializes a new instance of AssocationSet with the given name and the association type
// </summary>
// <param name="name"> The name of the Assocation set </param>
// <param name="associationType"> The association type of the entities that this associationship set type contains </param>
internal AssociationSet(string name, AssociationType associationType)
: base(name, null, null, null, associationType)
{
}
private void InternalVisitEdmAssociationType(AssociationType item)
{
this._schemaWriter.WriteAssociationTypeElementHeader(item);
base.VisitEdmAssociationType(item);
this._schemaWriter.WriteEndElement();
}
internal void WriteAssociationTypeElementHeader(AssociationType associationType)
{
this._xmlWriter.WriteStartElement("Association");
this._xmlWriter.WriteAttributeString("Name", associationType.Name);
}
