public void Create_throws_if_name_is_null_or_empty() { var stringTypeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var metadataProperty = new MetadataProperty("MetadataProperty", stringTypeUsage, "Value"); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws<ArgumentException>( () => EnumMember.Create(null, (sbyte)5, new [] { metadataProperty })) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws<ArgumentException>( () => EnumMember.Create(String.Empty, (sbyte)5, null)) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws<ArgumentException>( () => EnumMember.Create(null, (byte)5, null)) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws<ArgumentException>( () => EnumMember.Create(String.Empty, (byte)5, new[] { metadataProperty })) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws<ArgumentException>( () => EnumMember.Create(null, (short)5, null)) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws<ArgumentException>( () => EnumMember.Create(String.Empty, (short)5, null)) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws<ArgumentException>( () => EnumMember.Create(null, (int)5, null)) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws<ArgumentException>( () => EnumMember.Create(String.Empty, (int)5, new[] { metadataProperty })) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws<ArgumentException>( () => EnumMember.Create(null, (long)5, null)) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws<ArgumentException>( () => EnumMember.Create(String.Empty, (long)5, null)) .Message); }
/// <summary> /// Adds or updates an annotation with the specified name and value. /// </summary> /// <remarks> /// If an annotation with the given name already exists then the value of that annotation /// is updated to the given value. If the given value is null then the annotation will be /// removed. /// </remarks> /// <param name="name">The name of the annotation property.</param> /// <param name="value">The value of the annotation property.</param> public void AddAnnotation(string name, object value) { Check.NotEmpty(name, nameof(name)); MetadataProperty metadataProperty = this.Annotations.FirstOrDefault <MetadataProperty>((Func <MetadataProperty, bool>)(a => a.Name == name)); if (metadataProperty != null) { if (value == null) { this.RemoveAnnotation(name); } else { metadataProperty.Value = value; } } else { if (value == null) { return; } this.GetMetadataProperties().Add(MetadataProperty.CreateAnnotation(name, value)); } }
public void Create_throws_if_name_is_null_or_empty() { var stringTypeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var metadataProperty = new MetadataProperty("MetadataProperty", stringTypeUsage, "Value"); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws <ArgumentException>( () => EnumMember.Create(null, (sbyte)5, new [] { metadataProperty })) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws <ArgumentException>( () => EnumMember.Create(String.Empty, (sbyte)5, null)) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws <ArgumentException>( () => EnumMember.Create(null, (byte)5, null)) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws <ArgumentException>( () => EnumMember.Create(String.Empty, (byte)5, new[] { metadataProperty })) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws <ArgumentException>( () => EnumMember.Create(null, (short)5, null)) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws <ArgumentException>( () => EnumMember.Create(String.Empty, (short)5, null)) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws <ArgumentException>( () => EnumMember.Create(null, (int)5, null)) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws <ArgumentException>( () => EnumMember.Create(String.Empty, (int)5, new[] { metadataProperty })) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws <ArgumentException>( () => EnumMember.Create(null, (long)5, null)) .Message); Assert.Equal( Strings.ArgumentIsNullOrWhitespace("name"), Assert.Throws <ArgumentException>( () => EnumMember.Create(String.Empty, (long)5, null)) .Message); }
public void Create_throws_argument_exception_when_called_with_invalid_arguments() { var entityType = new EntityType("Source", "Namespace", DataSpace.CSpace); var refType = new RefType(entityType); var metadataProperty = new MetadataProperty( "MetadataProperty", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), "value"); Assert.Throws<ArgumentException>( () => AssociationEndMember.Create( null, refType, RelationshipMultiplicity.Many, OperationAction.Cascade, new[] { metadataProperty })); Assert.Throws<ArgumentException>( () => AssociationEndMember.Create( String.Empty, refType, RelationshipMultiplicity.Many, OperationAction.Cascade, new[] { metadataProperty })); Assert.Throws<ArgumentNullException>( () => AssociationEndMember.Create( "AssociationEndMember", null, RelationshipMultiplicity.Many, OperationAction.Cascade, new[] { metadataProperty })); }
public void Create_throws_argument_exception_when_called_with_invalid_arguments() { var entityType = new EntityType("Source", "Namespace", DataSpace.CSpace); var refType = new RefType(entityType); var metadataProperty = new MetadataProperty( "MetadataProperty", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), "value"); Assert.Throws <ArgumentException>( () => AssociationEndMember.Create( null, refType, RelationshipMultiplicity.Many, OperationAction.Cascade, new[] { metadataProperty })); Assert.Throws <ArgumentException>( () => AssociationEndMember.Create( String.Empty, refType, RelationshipMultiplicity.Many, OperationAction.Cascade, new[] { metadataProperty })); Assert.Throws <ArgumentNullException>( () => AssociationEndMember.Create( "AssociationEndMember", null, RelationshipMultiplicity.Many, OperationAction.Cascade, new[] { metadataProperty })); }
public void Create_throws_argument_exception_when_called_with_null_or_empty_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 associationType = AssociationType.Create( "AssociationType", "Namespace", true, DataSpace.CSpace, sourceEnd, targetEnd, constraint, Enumerable.Empty <MetadataProperty>()); var sourceSet = new EntitySet("SourceSet", "Schema", "Table", "Query", source); var targetSet = new EntitySet("TargetSet", "Schema", "Table", "Query", target); var metadataProperty = new MetadataProperty( "MetadataProperty", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), "value"); // name is null Assert.Throws <ArgumentException>( () => AssociationSet.Create( null, associationType, sourceSet, targetSet, new [] { metadataProperty })); // name is empty Assert.Throws <ArgumentException>( () => AssociationSet.Create( String.Empty, associationType, sourceSet, targetSet, new[] { metadataProperty })); // type is null Assert.Throws <ArgumentNullException>( () => AssociationSet.Create( "AssociationSet", null, sourceSet, targetSet, new[] { metadataProperty })); }
/// <summary> /// The factory method for constructing the MetadataProperty object. /// </summary> /// <param name="name">The name of the metadata property.</param> /// <param name="typeUsage">The type usage of the metadata property.</param> /// <param name="value">The value of the metadata property.</param> /// <exception cref="System.NullReferenceException"> /// Thrown <paramref name="typeUsage" /> is <c>null</c>. /// </exception> /// <notes>The newly created MetadataProperty will be read only.</notes> public static MetadataProperty Create(string name, TypeUsage typeUsage, object value) { Check.NotNull(typeUsage, "typeUsage"); var metadataProperty = new MetadataProperty(name, typeUsage, value); metadataProperty.SetReadOnly(); return(metadataProperty); }
public void Can_get_and_set_value_property() { var metadataProperty = new MetadataProperty { Value = "Foo" }; Assert.Equal("Foo", metadataProperty.Value); }
public void Create_sets_properties_and_seals_MetadataProperty() { var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var metadataProperty = MetadataProperty.Create("property", typeUsage, "value"); Assert.Equal("property", metadataProperty.Name); Assert.Same(typeUsage, metadataProperty.TypeUsage); Assert.Equal("value", metadataProperty.Value); Assert.True(metadataProperty.IsReadOnly); }
public void CreateAnnotation_creates_correct_metdata_property() { var value = new object(); var annotation = MetadataProperty.CreateAnnotation("name", value); Assert.Equal("name", annotation.Name); Assert.Equal(value, annotation.Value); Assert.Null(annotation.TypeUsage); Assert.Equal(PropertyKind.Extended, annotation.PropertyKind); Assert.True(annotation.IsAnnotation); }
/// <summary> /// The factory method for constructing the MetadataProperty object. /// </summary> /// <param name="name">The name of the metadata property.</param> /// <param name="typeUsage">The type usage of the metadata property.</param> /// <param name="value">The value of the metadata property.</param> /// <returns>The MetadataProperty object.</returns> /// <exception cref="T:System.NullReferenceException"> /// Thrown <paramref name="typeUsage" /> is <c>null</c>. /// </exception> /// <remarks>The newly created MetadataProperty will be read only.</remarks> public static MetadataProperty Create( string name, TypeUsage typeUsage, object value) { Check.NotEmpty(name, nameof(name)); Check.NotNull <TypeUsage>(typeUsage, nameof(typeUsage)); MetadataProperty metadataProperty = new MetadataProperty(name, typeUsage, value); metadataProperty.SetReadOnly(); return(metadataProperty); }
private static void EdmSerializationVisitor_writes_expected_xml <T>( Func <T> constructor, bool invalid, Action <EdmSerializationVisitor, T> visitAction, string expectedFormat) where T : MetadataItem { var errors = new List <EdmSchemaError>() { new EdmSchemaError("Message1.", 1, EdmSchemaErrorSeverity.Error), new EdmSchemaError("Message2.", 2, EdmSchemaErrorSeverity.Warning) }; var typeUsage1 = TypeUsage.CreateDefaultTypeUsage( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Boolean)); var property1 = MetadataProperty.Create( MetadataItemHelper.SchemaInvalidMetadataPropertyName, typeUsage1, invalid); var typeUsage2 = TypeUsage.CreateDefaultTypeUsage( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String).GetCollectionType()); var property2 = MetadataProperty.Create( MetadataItemHelper.SchemaErrorsMetadataPropertyName, typeUsage2, errors); var item = constructor(); item.AddMetadataProperties(new List <MetadataProperty>() { property1, property2 }); var builder = new StringBuilder(); var settings = new XmlWriterSettings { ConformanceLevel = ConformanceLevel.Fragment }; using (var writer = XmlWriter.Create(builder, settings)) { visitAction(new EdmSerializationVisitor(writer, 3.0), item); } var errorsString = String.Concat( Strings.MetadataItemErrorsFoundDuringGeneration, errors[0].ToString(), errors[1].ToString()); var expectedXml = String.Format( CultureInfo.InvariantCulture, expectedFormat, errorsString); AssertEqual(expectedXml, builder.ToString()); }
public void Contains_is_implemented() { var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var metadataItem = new EntityType("E", "N", DataSpace.CSpace); var annotation = MetadataProperty.CreateAnnotation("AN", "AV"); metadataItem.MetadataProperties.Source.Add(MetadataProperty.Create("PN", typeUsage, "PV")); Assert.False(metadataItem.Annotations.Contains(annotation)); metadataItem.Annotations.Add(annotation); Assert.True(metadataItem.Annotations.Contains(annotation)); }
public void Can_set_and_get_annotation_value() { var value1 = new object(); var value2 = new object(); var annotation = MetadataProperty.CreateAnnotation("name", value1); Assert.Equal("name", annotation.Name); Assert.Same(value1, annotation.Value); annotation.Value = value2; Assert.Equal("name", annotation.Name); Assert.Same(value2, annotation.Value); }
public void Add_is_implemented() { var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var metadataItem = new EntityType("E", "N", DataSpace.CSpace); metadataItem.MetadataProperties.Source.Add(MetadataProperty.Create("PN", typeUsage, "PV")); var count = metadataItem.MetadataProperties.Count; var annotation = MetadataProperty.CreateAnnotation("AN", "AV"); metadataItem.Annotations.Add(annotation); Assert.Same(annotation, metadataItem.MetadataProperties.ElementAt(count)); Assert.Same(annotation, metadataItem.Annotations.Single()); }
public void Count_is_implemented() { var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var metadataItem = new EntityType("E", "N", DataSpace.CSpace); metadataItem.MetadataProperties.Source.Add(MetadataProperty.Create("PN", typeUsage, "PV")); var count = metadataItem.MetadataProperties.Count; Assert.Equal(0, metadataItem.Annotations.Count); metadataItem.Annotations.Add(MetadataProperty.CreateAnnotation("AN", "AV")); Assert.Equal(count + 1, metadataItem.MetadataProperties.Count); Assert.Equal(1, metadataItem.Annotations.Count); }
public void SetMetadataProperties_sets_metadata_properties() { var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var property = EdmProperty.Create("foo", typeUsage); property.SetMetadataProperties( new List <MetadataProperty> { MetadataProperty.Create( "foo", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), "bar") }); Assert.NotNull(property.MetadataProperties.SingleOrDefault(p => p.Name == "foo" && (string)p.Value == "bar")); }
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 associationType = AssociationType.Create( "AssociationType", "Namespace", true, DataSpace.CSpace, sourceEnd, targetEnd, constraint, Enumerable.Empty <MetadataProperty>()); var sourceSet = new EntitySet("SourceSet", "Schema", "Table", "Query", source); var targetSet = new EntitySet("TargetSet", "Schema", "Table", "Query", target); var metadataProperty = new MetadataProperty( "MetadataProperty", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), "value"); var associationSet = AssociationSet.Create( "AssociationSet", associationType, sourceSet, targetSet, new[] { metadataProperty }); Assert.Equal("AssociationSet", associationSet.Name); Assert.Same(associationType, associationSet.ElementType); Assert.Same(sourceSet, associationSet.SourceSet); Assert.Same(targetSet, associationSet.TargetSet); Assert.Same(source, associationSet.SourceEnd.GetEntityType()); Assert.Same(target, associationSet.TargetEnd.GetEntityType()); Assert.Same(metadataProperty, associationSet.MetadataProperties.SingleOrDefault(p => p.Name == "MetadataProperty")); Assert.True(associationSet.IsReadOnly); }
public void CopyTo_is_implemented() { var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var metadataItem = new EntityType("E", "N", DataSpace.CSpace); var annotation1 = MetadataProperty.CreateAnnotation("AN1", "AV1"); var annotation2 = MetadataProperty.CreateAnnotation("AN2", "AV2"); metadataItem.MetadataProperties.Source.Add(MetadataProperty.Create("PN", typeUsage, "PV")); metadataItem.Annotations.Add(annotation1); metadataItem.Annotations.Add(annotation2); var annotations = new MetadataProperty[2]; metadataItem.Annotations.CopyTo(annotations, 0); Assert.Same(annotation1, annotations[0]); Assert.Same(annotation2, annotations[1]); }
public void WriteExtendedProperties_does_not_write_annotations_that_do_not_have_a_name_containing_a_colon() { var property = MetadataProperty.CreateAnnotation("Foo", "true"); var mockEntityType = new Mock <EntityType>("E", "ns", DataSpace.CSpace); mockEntityType.Setup(m => m.MetadataProperties).Returns( new ReadOnlyMetadataCollection <MetadataProperty>(new List <MetadataProperty>() { property })); var fixture = new Fixture(2.0); fixture.UnderlyingWriter.WriteStartElement(XmlConstants.EntityType); fixture.Writer.WriteExtendedProperties(mockEntityType.Object); Assert.Equal(@"<EntityType", fixture.ToString()); }
public void WriteExtendedProperties_does_not_write_store_generated_annotations() { var annotation = MetadataProperty.CreateAnnotation(XmlConstants.StoreGeneratedPatternAnnotation, "Identity"); var mockProperty = new Mock <MetadataProperty>(); mockProperty.Setup(m => m.MetadataProperties).Returns( new ReadOnlyMetadataCollection <MetadataProperty>(new List <MetadataProperty>() { annotation })); var fixture = new Fixture(2.0); fixture.UnderlyingWriter.WriteStartElement(XmlConstants.Property); fixture.Writer.WriteExtendedProperties(mockProperty.Object); Assert.Equal(@"<Property", fixture.ToString()); }
public void GetEnumerator_is_implemented() { var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var metadataItem = new EntityType("E", "N", DataSpace.CSpace); var annotation1 = MetadataProperty.CreateAnnotation("AN1", "AV1"); var annotation2 = MetadataProperty.CreateAnnotation("AN2", "AV2"); metadataItem.MetadataProperties.Source.Add(MetadataProperty.Create("PN", typeUsage, "PV")); metadataItem.Annotations.Add(annotation1); metadataItem.Annotations.Add(annotation2); var enumerator = metadataItem.Annotations.GetEnumerator(); Assert.True(enumerator.MoveNext()); Assert.Same(annotation1, enumerator.Current); Assert.True(enumerator.MoveNext()); Assert.Same(annotation2, enumerator.Current); Assert.False(enumerator.MoveNext()); }
public void WriteExtendedProperties_writes_annotations_using_ToString_if_serializer_not_available() { var property = MetadataProperty.CreateAnnotation(XmlConstants.UseClrTypesAnnotationWithPrefix, "true"); var mockEntityType = new Mock <EntityType>("E", "ns", DataSpace.CSpace); mockEntityType.Setup(m => m.MetadataProperties).Returns( new ReadOnlyMetadataCollection <MetadataProperty>(new List <MetadataProperty>() { property })); var fixture = new Fixture(2.0); fixture.UnderlyingWriter.WriteStartElement(XmlConstants.EntityType); fixture.Writer.WriteExtendedProperties(mockEntityType.Object); Assert.Equal(@"<EntityType p1:UseClrTypes=""true""", fixture.ToString()); }
public void WriteExtendedProperties_writes_annotations_on_properties() { var annotation = MetadataProperty.CreateAnnotation(XmlConstants.CustomAnnotationPrefix + "Foo", "Goo"); var mockProperty = new Mock <MetadataProperty>(); mockProperty.Setup(m => m.MetadataProperties).Returns( new ReadOnlyMetadataCollection <MetadataProperty>(new List <MetadataProperty>() { annotation })); var fixture = new Fixture(2.0); fixture.UnderlyingWriter.WriteStartElement(XmlConstants.Property); fixture.Writer.WriteExtendedProperties(mockProperty.Object); Assert.Equal(@"<Property p1:Foo=""Goo""", fixture.ToString()); }
public void WriteExtendedProperties_writes_annotations_using_serializer_to_serialize_if_available() { var property = MetadataProperty.CreateAnnotation(XmlConstants.ClrTypeAnnotationWithPrefix, typeof(Random)); var mockEntityType = new Mock <EntityType>("E", "ns", DataSpace.CSpace); mockEntityType.Setup(m => m.MetadataProperties).Returns( new ReadOnlyMetadataCollection <MetadataProperty>(new List <MetadataProperty>() { property })); var fixture = new Fixture(2.0); fixture.UnderlyingWriter.WriteStartElement(XmlConstants.EntityType); fixture.Writer.WriteExtendedProperties(mockEntityType.Object); Assert.Equal( @"<EntityType p1:ClrType=""System.Random, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089""", fixture.ToString()); }
public void WriteEnumTypeElementHeader_writes_annotations() { var property = MetadataProperty.CreateAnnotation(XmlConstants.ClrTypeAnnotationWithPrefix, typeof(Random)); var mockEnumType = new Mock <EnumType>(); mockEnumType.Setup(m => m.Name).Returns("E"); mockEnumType.Setup(m => m.MetadataProperties).Returns( new ReadOnlyMetadataCollection <MetadataProperty>(new List <MetadataProperty>() { property })); var fixture = new Fixture(2.0); fixture.Writer.WriteEnumTypeElementHeader(mockEnumType.Object); Assert.Equal( @"<EnumType Name=""E"" IsFlags=""false"" p1:ClrType=""System.Random, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"" UnderlyingType=""Int32""", fixture.ToString()); }
public void Validation_error_not_reported_for_types_marked_as_invalid() { var invalidAttribute = MetadataProperty.Create( "EdmSchemaInvalid", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), true); var model = new EdmModel(DataSpace.SSpace); model.AddItem( EntityType.Create("E", "N", DataSpace.SSpace, new string[0], new EdmMember[0], new[] { invalidAttribute })); using (var writer = XmlWriter.Create(new StringBuilder())) { var ssdlSerializer = new SsdlSerializer(); ssdlSerializer.OnError += (_, e) => { throw new Exception("Should not be invoked."); }; Assert.True(ssdlSerializer.Serialize(model, "N", "invName", "42", writer)); } }
public void Remove_is_implemented() { var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var metadataItem = new EntityType("E", "N", DataSpace.CSpace); var annotation = MetadataProperty.CreateAnnotation("AN", "AV"); metadataItem.MetadataProperties.Source.Add(MetadataProperty.Create("PN", typeUsage, "PV")); metadataItem.Annotations.Add(annotation); var count = metadataItem.MetadataProperties.Count; Assert.Equal(1, metadataItem.Annotations.Count); metadataItem.Annotations.Remove(annotation); Assert.Equal(count - 1, metadataItem.MetadataProperties.Count); Assert.Equal(0, metadataItem.Annotations.Count); foreach (var p in metadataItem.MetadataProperties) { Assert.False(p.IsAnnotation); } }
public void WriteComplexTypeElementHeader_writes_annotations() { var property = MetadataProperty.CreateAnnotation(XmlConstants.ClrTypeAnnotation, typeof(Random)); var mockComplexType = new Mock <ComplexType>("C", "ns", DataSpace.CSpace); mockComplexType.Setup(m => m.Name).Returns("C"); mockComplexType.Setup(m => m.MetadataProperties).Returns( new ReadOnlyMetadataCollection <MetadataProperty>(new List <MetadataProperty>() { property })); var fixture = new Fixture(2.0); fixture.Writer.WriteComplexTypeElementHeader(mockComplexType.Object); Assert.Equal( @"<ComplexType Name=""C"" p1:ClrType=""System.Random, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089""", fixture.ToString()); }
public void Can_create_enumeration_member() { var stringTypeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var metadataProperty = new MetadataProperty("MetadataProperty", stringTypeUsage, "Value"); var member = EnumMember.Create("MemberName", (sbyte)5, new[] { metadataProperty }); Assert.Equal("MemberName", member.Name); Assert.Equal(5, (sbyte)member.Value); Assert.Same(metadataProperty, member.MetadataProperties.Last()); Assert.True(member.IsReadOnly); member = EnumMember.Create("MemberName", (byte)5, new[] { metadataProperty }); Assert.Equal("MemberName", member.Name); Assert.Equal(5, (byte)member.Value); Assert.Same(metadataProperty, member.MetadataProperties.Last()); Assert.True(member.IsReadOnly); member = EnumMember.Create("MemberName", (short)5, new[] { metadataProperty }); Assert.Equal("MemberName", member.Name); Assert.Equal(5, (short)member.Value); Assert.Same(metadataProperty, member.MetadataProperties.Last()); Assert.True(member.IsReadOnly); member = EnumMember.Create("MemberName", (int)5, new[] { metadataProperty }); Assert.Equal("MemberName", member.Name); Assert.Equal(5, (int)member.Value); Assert.Same(metadataProperty, member.MetadataProperties.Last()); Assert.True(member.IsReadOnly); member = EnumMember.Create("MemberName", (long)5, new[] { metadataProperty }); Assert.Equal("MemberName", member.Name); Assert.Equal(5, (long)member.Value); Assert.Same(metadataProperty, member.MetadataProperties.Last()); Assert.True(member.IsReadOnly); }
/// <summary> /// Adds or updates an annotation with the specified name and value. /// </summary> /// <remarks> /// If an annotation with the given name already exists then the value of that annotation /// is updated to the given value. If the given value is null then the annotation will be /// removed. /// </remarks> /// <param name="name">The name of the annotation property.</param> /// <param name="value">The value of the annotation property.</param> public void AddAnnotation(string name, object value) { Check.NotEmpty(name, "name"); var existingAnnotation = Annotations.FirstOrDefault(a => a.Name == name); if (existingAnnotation != null) { if (value == null) { RemoveAnnotation(name); } else { existingAnnotation.Value = value; } } else if (value != null) { GetMetadataProperties().Add(MetadataProperty.CreateAnnotation(name, value)); } }
public void Can_create_enumeration_type() { var stringTypeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var metadataProperty = MetadataProperty.Create("MetadataProperty", stringTypeUsage, "Value"); var underlyingType = PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32); var members = new[] { EnumMember.Create("M1", 1, null), EnumMember.Create("M2", 2, null) }; var enumType = EnumType.Create("EnumName", "N", underlyingType, true, members, new[] { metadataProperty }); Assert.Equal("EnumName", enumType.Name); Assert.Equal("N", enumType.NamespaceName); Assert.True(enumType.IsFlags); Assert.Equal(DataSpace.CSpace, enumType.DataSpace); Assert.Equal(members, enumType.Members); Assert.Same(metadataProperty, enumType.MetadataProperties.Last()); Assert.True(enumType.IsReadOnly); }
public void Create_sets_properties_and_seals_the_instance() { var entityType = new EntityType("Source", "Namespace", DataSpace.CSpace); var refType = new RefType(entityType); var metadataProperty = new MetadataProperty( "MetadataProperty", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), "value"); var associationEnd = AssociationEndMember.Create( "AssociationEndMember", refType, RelationshipMultiplicity.Many, OperationAction.Cascade, new[] { metadataProperty }); Assert.Equal("AssociationEndMember", associationEnd.Name); Assert.Same(entityType, associationEnd.GetEntityType()); Assert.Equal(RelationshipMultiplicity.Many, associationEnd.RelationshipMultiplicity); Assert.Equal(OperationAction.Cascade, associationEnd.DeleteBehavior); Assert.Same(metadataProperty, associationEnd.MetadataProperties.SingleOrDefault(p => p.Name == "MetadataProperty")); Assert.True(associationEnd.IsReadOnly); }
public void Create_throws_argument_exception_when_called_with_null_or_empty_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 associationType = AssociationType.Create( "AssociationType", "Namespace", true, DataSpace.CSpace, sourceEnd, targetEnd, constraint, Enumerable.Empty<MetadataProperty>()); var sourceSet = new EntitySet("SourceSet", "Schema", "Table", "Query", source); var targetSet = new EntitySet("TargetSet", "Schema", "Table", "Query", target); var metadataProperty = new MetadataProperty( "MetadataProperty", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), "value"); // name is null Assert.Throws<ArgumentException>( () => AssociationSet.Create( null, associationType, sourceSet, targetSet, new [] { metadataProperty })); // name is empty Assert.Throws<ArgumentException>( () => AssociationSet.Create( String.Empty, associationType, sourceSet, targetSet, new[] { metadataProperty })); // type is null Assert.Throws<ArgumentNullException>( () => AssociationSet.Create( "AssociationSet", null, sourceSet, targetSet, new[] { metadataProperty })); }
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 associationType = AssociationType.Create( "AssociationType", "Namespace", true, DataSpace.CSpace, sourceEnd, targetEnd, constraint, Enumerable.Empty<MetadataProperty>()); var sourceSet = new EntitySet("SourceSet", "Schema", "Table", "Query", source); var targetSet = new EntitySet("TargetSet", "Schema", "Table", "Query", target); var metadataProperty = new MetadataProperty( "MetadataProperty", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), "value"); var associationSet = AssociationSet.Create( "AssociationSet", associationType, sourceSet, targetSet, new[] { metadataProperty }); Assert.Equal("AssociationSet", associationSet.Name); Assert.Same(associationType, associationSet.ElementType); Assert.Same(sourceSet, associationSet.SourceSet); Assert.Same(targetSet, associationSet.TargetSet); Assert.Same(source, associationSet.SourceEnd.GetEntityType()); Assert.Same(target, associationSet.TargetEnd.GetEntityType()); Assert.Same(metadataProperty, associationSet.MetadataProperties.SingleOrDefault(p => p.Name == "MetadataProperty")); Assert.True(associationSet.IsReadOnly); }
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); }
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 })); }
/// <summary> /// The factory method for constructing the MetadataProperty object. /// </summary> /// <param name="name">The name of the metadata property.</param> /// <param name="typeUsage">The type usage of the metadata property.</param> /// <param name="value">The value of the metadata property.</param> /// <returns>The MetadataProperty object.</returns> /// <exception cref="System.NullReferenceException"> /// Thrown <paramref name="typeUsage" /> is <c>null</c>. /// </exception> /// <remarks>The newly created MetadataProperty will be read only.</remarks> public static MetadataProperty Create(string name, TypeUsage typeUsage, object value) { Check.NotEmpty(name, "name"); Check.NotNull(typeUsage, "typeUsage"); var metadataProperty = new MetadataProperty(name, typeUsage, value); metadataProperty.SetReadOnly(); return metadataProperty; }
internal static MetadataProperty CreateMetadataPropertyFromOtherNamespaceXmlArtifact( string xmlNamespaceUri, string artifactName, object value) { MetadataProperty property; property = new MetadataProperty( xmlNamespaceUri + ":" + artifactName, TypeUsage.Create(EdmProviderManifest.Instance.GetPrimitiveType(PrimitiveTypeKind.String)), value); return property; }