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);
}
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 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 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 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 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 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 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);
}
