public static XElement[] BinaryValueInHexidecimalFormat(EdmVersion edmVersion)
{
var csdl1 =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""Annotations"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<Annotations Target=""foo.Person"">
<Annotation Term=""bar.BinaryValue"" Binary=""0x1234"" />
</Annotations>
</Schema>";
var csdl2 =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""bar"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<Term Name=""BinaryValue"" Type=""Binary"" />
</Schema>";
var csdl3 =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""foo"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<EntityType Name=""Person"">
<Key>
<PropertyRef Name=""Name"" />
</Key>
<Property Name=""Name"" Type=""String"" Nullable=""false"" />
</EntityType>
</Schema>";
return(FixUpWithEdmVersion(new string[] { csdl1, csdl2, csdl3 }, edmVersion));
}
public static XElement[] BadRecordTermRenamedProperty(EdmVersion edmVersion)
{
var csdl1 =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""Vocab"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<ComplexType Name=""VocabComplex"">
<Property Name=""ID"" Type=""Edm.Int64"" />
<Property Name=""Prop1"" Type=""Edm.Int64"" />
<Property Name=""Prop2"" Type=""Edm.String"" />
</ComplexType>
<Term Name=""StructuredTerm"" Type=""Vocab.VocabComplex"" />
</Schema>";
var csdl2 =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""CSDL"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<ComplexType Name=""MyComplex"">
<Property Name=""ID"" Type=""Edm.Int32"" />
<Annotation Term=""Vocab.StructuredTerm"">
<Record>
<PropertyValue Property=""Prop1"">
<Int>256</Int>
</PropertyValue>
<PropertyValue Property=""PropBAD"">
<String>A road less traveled.</String>
</PropertyValue>
<PropertyValue Property=""ID"">
<Int>1</Int>
</PropertyValue>
</Record>
</Annotation>
</ComplexType>
</Schema>";
return(FixUpWithEdmVersion(new string[] { csdl1, csdl2 }, edmVersion));
}
public static XElement[] BadRecordTermMisTypedPropertyForUntypedTerm(EdmVersion edmVersion)
{
var csdl1 =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""Vocab"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<Term Name=""ComplexTerm"" Type=""CSDL.TermComplex""/>
</Schema>";
var csdl2 =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""CSDL"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<ComplexType Name=""TermComplex"">
<Property Name=""ID"" Type=""Edm.Int64"" />
<Property Name=""Prop1"" Type=""Edm.Int64"" />
<Property Name=""Prop2"" Type=""Edm.String"" />
</ComplexType>
<ComplexType Name=""MyComplex"">
<Property Name=""ID"" Type=""Edm.Int32"" />
<Annotation Term=""Vocab.ComplexTerm"">
<Record Type=""CSDL.TermComplex"">
<PropertyValue Property=""Prop1"">
<Int>256</Int>
</PropertyValue>
<PropertyValue Property=""Prop2"">
<Binary>DEADBEEFCAFE</Binary>
</PropertyValue>
<PropertyValue Property=""ID"">
<Int>1</Int>
</PropertyValue>
</Record>
</Annotation>
</ComplexType>
</Schema>";
return(FixUpWithEdmVersion(new string[] { csdl1, csdl2 }, edmVersion));
}
public static XElement[] InvalidEntitySetNameReference(EdmVersion edmVersion)
{
const string csdl =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""Bork"" Alias=""Self"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<EntityType Name=""Entity1"">
<Key>
<PropertyRef Name=""Id"" />
</Key>
<Property Name=""Id"" Type=""Int32"" Nullable=""false""/>
<Property Name=""OtherId"" Type=""Int32"" />
<NavigationProperty Name=""Navigation"" Type=""Bork.Entity2"" Nullable=""false"" Partner=""Navigation"" />
</EntityType>
<EntityType Name=""Entity2"">
<Key>
<PropertyRef Name=""Id"" />
</Key>
<Property Name=""Id"" Type=""Int32"" Nullable=""false""/>
<Property Name=""OtherId"" Type=""Int32"" Nullable=""false""/>
<NavigationProperty Name=""Navigation"" Type=""Collection(Bork.Entity1)"" Partner=""Navigation"" />
</EntityType>
<EntityContainer Name=""Container"">
<EntitySet Name=""Entity1_a"" EntityType=""Bork.Entity1"">
<NavigationPropertyBinding Path=""Navigation"" Target=""Entity2_b"" />
</EntitySet>
<EntitySet Name=""Entity2_a"" EntityType=""Bork.Entity2"">
<NavigationPropertyBinding Path=""Navigation"" Target=""Entity1_b"" />
</EntitySet>
</EntityContainer>
</Schema>";
return FixUpWithEdmVersion(csdl, edmVersion);
}
public static XElement[] BadCollectionTermItemOfIncorrectType(EdmVersion edmVersion)
{
var csdl1 =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""Vocab"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<Term Name=""CollectionTerm"" Type=""Collection(Edm.Int64)"" />
</Schema>
";
var csdl2 =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""CSDL"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<ComplexType Name=""MyComplex"">
<Property Name=""ID"" Type=""Edm.Int32"" />
<Annotation Term=""Vocab.CollectionTerm"">
<Collection>
<Int>1</Int>
<Int>2</Int>
<String>Not an Int</String>
</Collection>
</Annotation>
</ComplexType>
</Schema>";
return(FixUpWithEdmVersion(new string[] { csdl1, csdl2 }, edmVersion));
}
private void CsdlXElementComparer(IEnumerable<XElement> expectedCsdls, IEnumerable<XElement> actualCsdls, EdmVersion version)
{
var updatedExpectedCsdls = ModelBuilderHelpers.ReplaceCsdlNamespacesForEdmVersion(expectedCsdls.ToArray(), version);
var updatedActualCsdls = ModelBuilderHelpers.ReplaceCsdlNamespacesForEdmVersion(actualCsdls.ToArray(), version);
new ConstructiveApiCsdlXElementComparer().Compare(updatedExpectedCsdls.ToList(), updatedActualCsdls.ToList());
}
public static XElement[] CastNullableToNonNullableOnInlineAnnotationCsdl(EdmVersion edmVersion)
{
var csdl = @"
<Schema Namespace=""NS"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<Term Name=""FriendInfo"" Type=""Collection(NS.Friend)"">
<Annotation Term=""NS.FriendInfo"">
<Cast Type=""NS.Friend"">
<Collection>
<String>foo</String>
<String>bar</String>
</Collection>
</Cast>
</Annotation>
</Term>
<ComplexType Name=""Friend"">
<Property Name=""Name"" Type=""Edm.String"" />
<Property Name=""NickNames"" Type=""Collection(String)"" />
<Property Name=""Address"" Type=""NS.Address"" />
</ComplexType>
<ComplexType Name=""Address"">
<Property Name=""StreetNumber"" Type=""Edm.Int32"" />
<Property Name=""StreetName"" Type=""String"" />
</ComplexType>
</Schema>";
return(FixUpWithEdmVersion(new string[] { csdl }, edmVersion));
}
protected IEnumerable <string> GetSerializerResult(IEdmModel edmModel, EdmVersion edmVersion, out IEnumerable <EdmError> errors)
{
// TODO: figure out the best way for multiple schemas
List <StringBuilder> stringBuilders = new List <StringBuilder>();
List <XmlWriter> xmlWriters = new List <XmlWriter>();
edmModel.SetEdmVersion(this.toProductVersionlookup[edmVersion]);
edmModel.TryWriteCsdl(
s =>
{
stringBuilders.Add(new StringBuilder());
xmlWriters.Add(XmlWriter.Create(stringBuilders.Last()));
return(xmlWriters.Last());
}, out errors);
for (int i = 0; i < stringBuilders.Count; i++)
{
xmlWriters[i].Close();
}
List <string> strings = new List <string>();
foreach (var sb in stringBuilders)
{
strings.Add(sb.ToString());
}
return(strings);
}
public static IEnumerable <XElement> MultipleSchemasWithDerivedTypes(EdmVersion csdlVersion) // M4
{
var csdl = new[]
{
@"<Schema Namespace=""FindMethodsTestModelBuilder.MultipleSchemasWithUsings.first"" p1:UseStrongSpatialTypes=""false"" xmlns:p1=""http://schemas.microsoft.com/ado/2009/02/edm/annotation"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<EntityType Name=""validEntityType1"">
<Key>
<PropertyRef Name=""Id"" />
</Key>
<Property Name=""Id"" Type=""Int32"" Nullable=""false"" />
</EntityType>
<ComplexType Name=""V1alidcomplexType"">
<Property Name=""aPropertyOne"" Type=""Int32"" Nullable=""false"" />
</ComplexType>
</Schema>",
@"<Schema Namespace=""FindMethodsTestModelBuilder.MultipleSchemasWithUsings.second"" p1:UseStrongSpatialTypes=""false"" xmlns:p1=""http://schemas.microsoft.com/ado/2009/02/edm/annotation"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<EntityType Name=""VALIDeNTITYtYPE2"" BaseType=""FindMethodsTestModelBuilder.MultipleSchemasWithUsings.first.validEntityType1"" />
<ComplexType Name=""V1alidcomplexType"">
<Property Name=""aPropertyOne"" Type=""FindMethodsTestModelBuilder.MultipleSchemasWithUsings.first.V1alidcomplexType"" Nullable=""false"" />
</ComplexType>
<EntityContainer Name=""ValidEntityContainer1"" />
</Schema>",
@"<Schema Namespace=""FindMethodsTestModelBuilder.MultipleSchemasWithUsings.third"" p1:UseStrongSpatialTypes=""false"" xmlns:p1=""http://schemas.microsoft.com/ado/2009/02/edm/annotation"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<EntityType Name=""VALIDeNTITYtYPE1"" BaseType=""FindMethodsTestModelBuilder.MultipleSchemasWithUsings.second.VALIDeNTITYtYPE2"" />
<ComplexType Name=""V1alidcomplexType"">
<Property Name=""aPropertyOne"" Type=""FindMethodsTestModelBuilder.MultipleSchemasWithUsings.second.V1alidcomplexType"" Nullable=""false"" />
</ComplexType>
</Schema>",
};
return(csdl.Select(XElement.Parse));
}
private void RoundTripValidator(IEnumerable <XElement> csdls, EdmVersion version)
{
var model = this.GetParserResult(csdls);
var roundTripCsdls = this.GetSerializerResult(model).Select(n => XElement.Parse(n));
CsdlXElementComparer(csdls, roundTripCsdls, version);
}
public static XElement[] ComplexTypeTerm(EdmVersion edmVersion)
{
var csdl2 =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""CSDL"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<ComplexType Name=""TermComplex"">
<Property Name=""ID"" Type=""Edm.Int64"" />
<Property Name=""Prop1"" Type=""Edm.Int64"" />
<Property Name=""Prop2"" Type=""Edm.String"" />
</ComplexType>
<Term Name=""TermComplexTerm"" Type=""CSDL.TermComplex"" />
<ComplexType Name=""MyComplex"">
<Property Name=""ID"" Type=""Edm.Int32"" />
<Annotation Term=""CSDL.TermComplexTerm"">
<Record>
<PropertyValue Property=""Prop1"">
<Int>256</Int>
</PropertyValue>
<PropertyValue Property=""Prop2"">
<String>HappyHappy</String>
</PropertyValue>
<PropertyValue Property=""ID"">
<Int>1</Int>
</PropertyValue>
</Record>
</Annotation>
</ComplexType>
</Schema>";
return(FixUpWithEdmVersion(new string[] { csdl2 }, edmVersion));
}
public static XElement[] CastResultTrueEvaluationCsdl(EdmVersion edmVersion)
{
var csdl = @"
<Schema Namespace=""NS"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<EntityType Name=""Friend"">
<Key>
<PropertyRef Name=""Name"" />
</Key>
<Property Name=""Name"" Type=""Edm.String"" Nullable=""false"" />
<Property Name=""Address"" Type=""NS.Address"" />
</EntityType>
<ComplexType Name=""Address"">
<Property Name=""StreetNumber"" Type=""Edm.Int32"" />
<Property Name=""StreetName"" Type=""String"" />
</ComplexType>
<Term Name=""FriendTerm"" Type=""NS.Friend"" />
<Annotations Target=""NS.Friend"">
<Annotation Term=""NS.FriendTerm"">
<Record>
<PropertyValue Property=""Name"" String=""foo"" />
<PropertyValue Property=""Address"">
<Cast Type=""NS.Address"">
<Record>
<PropertyValue Property=""StreetNumber"" Int=""3"" />
<PropertyValue Property=""StreetName"" String=""에O詰 갂คำŚёæ"" />
</Record>
</Cast>
</PropertyValue>
</Record>
</Annotation>
</Annotations>
</Schema>";
return(FixUpWithEdmVersion(new string[] { csdl }, edmVersion));
}
/// <summary>
/// Serializes the <paramref name="schema"/> in the specified <paramref name="csdlVersion"/> and returns it.
/// </summary>
/// <param name="csdlVersion">The CSDL version to use for serializing the entity model schema.</param>
/// <param name="schema">The schema to serialize.</param>
/// <returns>The serialized <paramref name="schema"/>.</returns>
public IEnumerable<FileContents<XElement>> Serialize(EdmVersion csdlVersion, EntityModelSchema schema)
{
ExceptionUtilities.Assert(schema != null, "schema != null");
// TODO: Can we inherit from the default implemenation of the CSDL content generator instead of doing this in a separate step?
schema = this.ODataAnnotationConverter.ConvertToProductAnnotations(schema);
return this.BaseEntityModelSchemaSerializer.Generate(csdlVersion, schema);
}
/// <summary>
/// Serializes the <paramref name="schema"/> in the specified <paramref name="csdlVersion"/> and returns it.
/// </summary>
/// <param name="csdlVersion">The CSDL version to use for serializing the entity model schema.</param>
/// <param name="schema">The schema to serialize.</param>
/// <returns>The serialized <paramref name="schema"/>.</returns>
public IEnumerable <FileContents <XElement> > Serialize(EdmVersion csdlVersion, EntityModelSchema schema)
{
ExceptionUtilities.Assert(schema != null, "schema != null");
// TODO: Can we inherit from the default implemenation of the CSDL content generator instead of doing this in a separate step?
schema = this.ODataAnnotationConverter.ConvertToProductAnnotations(schema);
return(this.BaseEntityModelSchemaSerializer.Generate(csdlVersion, schema));
}
public void ParserInlineAnnotationNavigationPropertyCsdlSchemaCompliantTest()
{
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
this.BasicXsdValidationTestForParserInputCsdl(VocabularyTestModelBuilder.InlineAnnotationNavigationProperty(), edmVersion);
}
}
public void ValueTermXsdValidation()
{
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
this.BasicXsdValidationTestForSerializerOutputCsdl(this.GetParserResult(VocabularyTestModelBuilder.ValueTermOnlyCsdl()), edmVersion);
}
}
public void ParserModelWithEnumValueTerm()
{
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
Assert.IsFalse(this.GetXsdValidationResults(ValidationTestModelBuilder.ModelWithEnumValueTerm(), edmVersion).Any(), "EnumType should be able to have inline vocab. annotations");
}
}
public void SerializerOperationParameterShouldBeInboundCsdlSchemaCompliantTest()
{
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
this.BasicXsdValidationTestForSerializerOutputCsdl(ValidationTestModelBuilder.OperationParameterShouldBeInbound(), edmVersion);
}
}
public void ParserAnnotationQualifiersWithNonSimpleValueCsdlSchemaCompliantTest()
{
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
this.BasicXsdValidationTestForParserInputCsdl(VocabularyTestModelBuilder.AnnotationQualifiersWithNonSimpleValue(), edmVersion);
}
}
private IEnumerable <string> GetXsdValidationResults(XElement csdlElement, EdmVersion edmVersion)
{
var csdlEdmVersionUpdated = XElement.Parse(csdlElement.ToString().Replace(csdlElement.Name.NamespaceName, EdmLibCsdlContentGenerator.GetCsdlFullNamespace(edmVersion).NamespaceName));
var errorMessages = new List <string>();
InitializeEdmLibCsdlSchemas();
new XDocument(csdlEdmVersionUpdated).Validate(EdmLibXmlSchemas[edmVersion], (o, e) => { errorMessages.Add(e.Message); });
return(errorMessages);
}
public void ParserSimpleIdentifierTypeReferenceCsdlSchemaCompliantTest()
{
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.CollectionTypeTypeRefSimpleTypeCanHaveFacets(edmVersion), edmVersion);
}
}
public void ParserOpenTypeSupportCsdlSchemaCompliantTest()
{
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.OpenTypeSupportInV40(edmVersion), edmVersion);
this.BasicXsdValidationTestForParserInputCsdl(ODataTestModelBuilder.ODataTestModelWithOpenType, edmVersion);
}
}
public void ParserInlineAnnotationFunctionImportParameterCsdlSchemaCompliantTest()
{
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
this.BasicXsdValidationTestForParserInputCsdl(VocabularyTestModelBuilder.InlineAnnotationFunctionImportParameter(), edmVersion);
}
}
public void ParserSimpleIdentifierTypeReferenceCsdlSchemaCompliantTest()
{
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.ConcurrencyModeTypes(edmVersion), edmVersion);
this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.CollectionTypeTypeRefSimpleTypeCanHaveFacets(edmVersion), edmVersion);
}
}
public void SerializerModelWithRowTypePropertyOfTypeNoneCsdlSchemaCompliantTest()
{
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
this.BasicXsdValidationTestForSerializerOutputCsdl(ValidationTestModelBuilder.ModelWithInvalidOperationReturnType(), edmVersion);
this.BasicXsdValidationTestForSerializerOutputCsdl(ValidationTestModelBuilder.ModelWithInvalidOperationParameterType(), edmVersion);
}
}
public void SerializerModelWithInvalidFunctionImportReturnTypeCsdlSchemaCompliantTest()
{
Console.WriteLine(DateTime.Now.ToShortDateString());
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
this.BasicXsdValidationTestForSerializerOutputCsdl(ValidationTestModelBuilder.ModelWithInvalidFunctionReturnType(), edmVersion);
}
}
public void SerializerModelWithAssociationEndAsInaccessibleEntityTypeCsdlSchemaCompliantTest()
{
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
this.BasicXsdValidationTestForSerializerOutputCsdl(ValidationTestModelBuilder.ModelWithAssociationEndAsInaccessibleEntityType(), edmVersion);
this.BasicXsdValidationTestForSerializerOutputCsdl(ValidationTestModelBuilder.ModelWithInconsistentNavigationPropertyPartner(), edmVersion);
}
}
public static IEdmModel OperationsWith2ParametersSchemasEdm(EdmVersion edmVersion)
{
var model = new EdmModel();
foreach (var operation in OperationTestModelBuilder.EdmOperationsWith2Parameters(edmVersion))
{
model.AddElement(operation);
}
return model;
}
public static IEdmModel OperationsWithReturnTypeOfPrimitiveDataTypeSchemasEdm(EdmVersion edmVersion)
{
var model = new EdmModel();
foreach (var function in OperationTestModelBuilder.EdmFunctionsWithReturnTypePrimitiveDataType(edmVersion))
{
model.AddElement(function);
}
return model;
}
public void ParserImmediateAnnotationRoundTripCsdlSchemaCompliantTest()
{
var testCsdls = ODataTestModelBuilder.ImmediateAnnotationRoundTrip;
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
this.BasicXsdValidationTestForParserInputCsdl(testCsdls, edmVersion);
}
}
public void ParserOpenTypeSupportCsdlSchemaCompliantTest()
{
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.OpenTypeSupportInV40(edmVersion), edmVersion);
this.BasicXsdValidationTestForParserInputCsdl(ODataTestModelBuilder.ODataTestModelWithOpenType, edmVersion);
}
}
public void ParserAnnotationValueTermCsdlSchemaCompliantTest()
{
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
this.BasicXsdValidationTestForParserInputCsdl(VocabularyTestModelBuilder.OutOfLineAnnotationValueTerm(), edmVersion);
this.BasicXsdValidationTestForParserInputCsdl(VocabularyTestModelBuilder.InlineAnnotationValueTerm(), edmVersion);
}
}
public static IEnumerable<IEdmPrimitiveTypeReference> AllPrimitiveEdmTypes(EdmVersion edmVersion, bool isNullable)
{
IEnumerable<IEdmPrimitiveTypeReference> primitiveTypes = AllNonSpatialPrimitiveEdmTypes(isNullable);
if (edmVersion >= EdmVersion.V40)
{
primitiveTypes = primitiveTypes.Concat(AllSpatialEdmTypes(isNullable));
}
return primitiveTypes;
}
public static XNamespace GetCsdlFullNamespace(EdmVersion csdlVersion)
{
if (csdlVersion == EdmVersion.V40)
{
return(EdmConstants.EdmOasisNamespace);
}
else
{
throw new ArgumentOutOfRangeException("CSDL Schema Version is not supported: " + csdlVersion.ToString());
}
}
public void ParserInvalidDecimalTypePrecisionCsdlSchemaCompliantTest()
{
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.ValidDecimalTypePrecisionValue(edmVersion), edmVersion);
this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.ValidDateTimeOffsetTypePrecisionValue(edmVersion), edmVersion);
this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.ValidTimeTypePrecisionValue(edmVersion), edmVersion);
}
}
public static XNamespace GetCsdlFullNamespace(EdmVersion csdlVersion)
{
if (csdlVersion == EdmVersion.V40)
{
return EdmConstants.EdmOasisNamespace;
}
else
{
throw new ArgumentOutOfRangeException("CSDL Schema Version is not supported: " + csdlVersion.ToString());
}
}
public void ParserComplexTypeWithBaseTypeAbstractCsdlSchemaCompliantTest()
{
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
this.BasicXsdValidationTestForParserInputCsdl(ModelBuilder.ComplexTypeWithBaseType(edmVersion), edmVersion);
this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.ComplexTypeBaseTypeSupportInV11(edmVersion), edmVersion);
this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.EdmComplexTypeInvalidIsPolymorphic(edmVersion), edmVersion);
this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.ComplexTypeIsAbstractSupportInV40(edmVersion), edmVersion);
}
}
/// <summary>
/// Determines XML namespace to be used.
/// </summary>
/// <param name="csdlVersion">The CSDL version.</param>
/// <returns>
/// CSDL namespace based on specified csdl version.
/// </returns>
private XNamespace DetermineXmlNamespace(EdmVersion csdlVersion)
{
if (csdlVersion == EdmVersion.V40)
{
return(EdmConstants.CsdlOasisNamespace);
}
else
{
throw new TaupoNotSupportedException("CSDL Schema Version is not supported: " + csdlVersion.ToString());
}
}
// TODO: get it from CsdlContentGenerator (or some common place)
private XNamespace DetermineXmlNamespace(EdmVersion csdlVersion)
{
if (csdlVersion == EdmVersion.V40)
{
return(Microsoft.Test.OData.Utils.Metadata.EdmConstants.EdmOasisNamespace);
}
else
{
throw new NotSupportedException("CSDL Schema Version is not supported: " + csdlVersion.ToString());
}
}
public static IEdmModel OperationsWith2ParametersSchemasEdm(EdmVersion edmVersion)
{
var model = new EdmModel();
foreach (var operation in OperationTestModelBuilder.EdmOperationsWith2Parameters(edmVersion))
{
model.AddElement(operation);
}
return(model);
}
public static IEnumerable<XElement> ReplaceCsdlNamespacesForEdmVersion(XElement[] csdls, EdmVersion edmVersion)
{
var edmNamespace = EdmLibCsdlContentGenerator.GetCsdlFullNamespace(edmVersion);
for (int i = 0; i < csdls.Count(); ++i)
{
if (edmNamespace != csdls[i].Name.Namespace)
{
csdls[i] = XElement.Parse(csdls[i].ToString().Replace(csdls[i].Name.Namespace.NamespaceName, edmNamespace.NamespaceName));
}
}
return csdls;
}
public static EdmVersion GetEdmVersion(XNamespace edmNamespace)
{
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
if (GetCsdlFullNamespace(edmVersion) == edmNamespace)
{
return edmVersion;
}
}
throw new ArgumentOutOfRangeException("The namespace is not a EDM namespace " + edmNamespace.NamespaceName);
}
public static XElement[] SystemNamespace(EdmVersion edmVersion)
{
const string csdl =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""Edm"" Alias=""Self"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<EntityType Name=""Clod"">
<Key>
<PropertyRef Name=""Id"" />
</Key>
<Property Name=""Id"" Type=""Int32"" Nullable=""false""/>
<Property Name=""Bar"" Type=""Int32"" />
</EntityType>
</Schema>";
return FixUpWithEdmVersion(csdl, edmVersion);
}
private void GenerateContentsWithoutDefinition(EdmVersion edmVersion, IEdmModel definitionModel)
{
IEnumerable<EdmError> errors;
var contentsWithoutDefinition = this.GetSerializerResult(definitionModel, edmVersion, out errors).Select(XElement.Parse);
var stripTheseElements = new[] { "Term", "Annotations", "Annotation"};
foreach (var contents in contentsWithoutDefinition)
{
contents.Descendants().Where(e => stripTheseElements.Contains(e.Name.LocalName)).Remove();
string namespaceName = contents.Attribute("Namespace").Value;
this.namespaceToContents.Add(namespaceName, contents);
}
}
public static string ReplaceCsdlNamespaceForEdmVersion(string csdl, EdmVersion edmVersion)
{
var edmNamespace = EdmLibCsdlContentGenerator.GetCsdlFullNamespace(edmVersion);
var xmlReader = XmlReader.Create(new StringReader(csdl));
while (xmlReader.Read())
{
if (xmlReader.Name == "Schema")
{
break;
}
}
if (xmlReader.EOF)
{
throw new ArgumentException("{0} is not a well formed CSDL.");
}
return csdl.Replace(xmlReader.NamespaceURI, edmNamespace.NamespaceName);
}
public static XElement[] OkayPrimitiveTerm(EdmVersion edmVersion)
{
var csdl1 =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""Vocab"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<Term Name=""IntegerTerm"" Type=""Edm.Int64"" />
</Schema>
";
var csdl2 =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""CSDL"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<ComplexType Name=""MyComplex"">
<Property Name=""ID"" Type=""Edm.Int32"" />
<Annotation Term=""Vocab.IntegerTerm"" Int=""32"" />
</ComplexType>
</Schema>";
return FixUpWithEdmVersion(new string[] { csdl1, csdl2 }, edmVersion);
}
public IEnumerable<XElement> GenerateDefinitionCsdl(EdmVersion edmVersion, IEdmModel definitionModel)
{
this.namespaceToContents = new Dictionary<string, XElement>();
this.GenerateContentsWithoutDefinition(edmVersion, definitionModel);
XNamespace ns = this.namespaceToContents.First().Value.Name.Namespace;
foreach (var valueTerm in definitionModel.SchemaElements.OfType<IEdmValueTerm>())
{
XElement schema = this.FindOrCreateCorrespondingSchema(valueTerm.Namespace, ns);
schema.Add(new XElement(ns + "Term",
new XAttribute("Name", valueTerm.Name),
this.GenerateTypeAttributes(valueTerm.Type)));
}
return this.namespaceToContents.Values.Where(fc => fc.HasElements);
}
public XElement GenerateApplicationCsdl(EdmVersion edmVerion, IEdmModel applicationModel)
{
XNamespace ns = this.DetermineXmlNamespace(edmVerion);
var schema = new XElement(ns + "Schema", new XAttribute("Namespace", "Application.NS1"));
IEnumerable<IEdmVocabularyAnnotatable> possiblyAnnotated = applicationModel.SchemaElements.OfType<IEdmEntityType>().Cast<IEdmVocabularyAnnotatable>()
.Concat(applicationModel.SchemaElements.OfType<IEdmEntityContainer>().Cast<IEdmVocabularyAnnotatable>())
.Concat(applicationModel.SchemaElements.OfType<IEdmEntityContainer>().SelectMany(c => c.EntitySets()).Cast<IEdmVocabularyAnnotatable>());
foreach (var annotated in possiblyAnnotated.Where(e => e.VocabularyAnnotations(applicationModel).Any()))
{
var valueAnnotations = annotated.VocabularyAnnotations(applicationModel).OfType<IEdmValueAnnotation>();
schema.Add(new XElement(
ns + "Annotations",
new XAttribute("Target", this.GetTargetPathFor(annotated, applicationModel)),
this.GenerateValueAnnotations(ns, valueAnnotations)));
}
return schema;
}
public static XElement[] DuplicatePropertyName(EdmVersion edmVersion)
{
var csdl =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""CollectionAtomic"" Alias=""Self"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<ComplexType Name=""ComplexTypeA"">
<Property Name=""Id"" Type=""Int32""/>
<Property Name=""Collection"" Type=""Collection(Int32)""/>
<Property Name=""Collection"" Type=""Collection(Int32)""/>
</ComplexType>
<EntityType Name=""ComplexTypeE"">
<Key>
<PropertyRef Name=""Id"" />
</Key>
<Property Name=""Id"" Type=""Edm.Int32"" Nullable=""false"" />
<Property Name=""Collection"" Type=""Collection(Int32)""/>
<Property Name=""Collection"" Type=""Collection(Int32)""/>
</EntityType>
</Schema>";
return FixUpWithEdmVersion(csdl, edmVersion);
}
private void SerializeAndVerifyAgainst(IEdmModel model, IEnumerable<XElement> expectedCsdls, EdmVersion version)
{
IEnumerable<XElement> actualCsdls = this.GetSerializerResult(model).Select(s => XElement.Load(new StringReader(s)));
var updatedExpectedCsdls = ModelBuilderHelpers.ReplaceCsdlNamespacesForEdmVersion(expectedCsdls.ToArray(), version);
var updatedActualCsdls = ModelBuilderHelpers.ReplaceCsdlNamespacesForEdmVersion(actualCsdls.ToArray(), version);
this.CompareCsdls(updatedExpectedCsdls, updatedActualCsdls);
}
public void ParserInvalidDecimalTypePrecisionCsdlSchemaCompliantTest()
{
var edmVersions = new EdmVersion[] { EdmVersion.V40 };
foreach (var edmVersion in edmVersions)
{
this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.ValidDecimalTypePrecisionValue(edmVersion), edmVersion);
this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.ValidDateTimeOffsetTypePrecisionValue(edmVersion), edmVersion);
this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.ValidTimeTypePrecisionValue(edmVersion), edmVersion);
}
}
/// <summary>
/// Unwraps the <paramref name="envelope"/> Edmx envelope and returns the actual payload.
/// </summary>
/// <param name="envelope">The <see cref="XElement"/> reprsenting the Edmx envelope.</param>
/// <param name="edmVersion">The Edm Version for the edmx envelope.</param>
/// <returns>The payload that was wrapped by the Edmx envelope.</returns>
public static XElement UnwrapEdmxEnvelope(this XElement envelope, EdmVersion edmVersion)
{
ExceptionUtilities.CheckArgumentNotNull(envelope, "envelope");
Version edmxVersion = edmVersion.ToEdmxVersion();
XNamespace edmxNamespace = EdmxXNamespace(edmxVersion);
ExceptionUtilities.Assert(envelope.Name.Namespace == edmxNamespace && envelope.Name.LocalName == "Edmx", "Expected <edmx:Edmx> as the top-level element.");
XAttribute versionAttribute = envelope.Attribute(EdmxVersionAttributeName);
ExceptionUtilities.Assert(versionAttribute != null && versionAttribute.Value == edmxVersion.ToString(), "Edmx version attribute not valid.");
XElement dataServicesElement = envelope.Element(edmxNamespace + "DataServices");
ExceptionUtilities.Assert(dataServicesElement != null, "<DataServices> element not found.");
return dataServicesElement.Elements().Single();
}
/// <summary>
/// Wraps the specified <paramref name="payload"/> into and Edmx envelope.
/// </summary>
/// <param name="payload">The <see cref="XElement"/> payload to wrap.</param>
/// <param name="edmVersion">The Edm Version for the edmx envelope.</param>
/// <returns>
/// The Edmx wrapper that contains the <paramref name="payload"/>.
/// </returns>
public static XElement WrapInEdmxEnvelope(this XElement payload, EdmVersion edmVersion)
{
ExceptionUtilities.CheckArgumentNotNull(payload, "payload");
XAttribute metadataNamespaceAttr = null;
Version edmxVersion = edmVersion.ToEdmxVersion();
XNamespace edmxNamespace = EdmxXNamespace(edmxVersion);
return new XElement(edmxNamespace + "Edmx",
new XAttribute(XNamespace.Xmlns + "edmx", edmxNamespace),
new XAttribute(EdmxVersionAttributeName, edmxVersion.ToString()),
new XElement(edmxNamespace + "DataServices",
metadataNamespaceAttr,
payload));
}
public static IEnumerable<XElement> SimpleAllPrimitiveTypes(EdmVersion edmVersion, bool explictNullable, bool isNullable)
{
var namespaceName = "ModelBuilder.SimpleAllPrimitiveTypes";
var model = new EdmModel();
var entityType = new EdmEntityType(namespaceName, "validEntityType1");
entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false));
model.AddElement(entityType);
var complexType = new EdmComplexType(namespaceName, "V1alidcomplexType");
model.AddElement(complexType);
int i = 0;
bool typesAreNullable = !explictNullable && isNullable;
foreach (var primitiveType in AllPrimitiveEdmTypes(edmVersion, typesAreNullable))
{
entityType.AddStructuralProperty("Property" + i++, primitiveType);
complexType.AddStructuralProperty("Property" + i++, primitiveType);
}
var stringBuilder = new StringBuilder();
var xmlWriter = XmlWriter.Create(stringBuilder);
IEnumerable<EdmError> errors;
if (!model.TryWriteCsdl((s) => xmlWriter, out errors) || errors.Any())
{
ExceptionUtilities.Assert(false, "Failed to write CSDL: " + string.Join(",", errors.Select(e => e.ErrorMessage)));
}
xmlWriter.Close();
var csdlElements = new[] { XElement.Parse(stringBuilder.ToString()) };
if (explictNullable)
{
ModelBuilderHelpers.SetNullableAttributes(csdlElements, isNullable);
}
return csdlElements;
}
private IEnumerable<string> GetXsdValidationResults(XElement csdlElement, EdmVersion edmVersion)
{
var csdlEdmVersionUpdated = XElement.Parse(csdlElement.ToString().Replace(csdlElement.Name.NamespaceName, EdmLibCsdlContentGenerator.GetCsdlFullNamespace(edmVersion).NamespaceName));
var errorMessages = new List<string>();
InitializeEdmLibCsdlSchemas();
new XDocument(csdlEdmVersionUpdated).Validate(EdmLibXmlSchemas[edmVersion], (o, e) => { errorMessages.Add(e.Message); });
return errorMessages;
}
/// <summary>
/// Determines XML namespace to be used.
/// </summary>
/// <param name="csdlVersion">The CSDL version.</param>
/// <returns>
/// CSDL namespace based on specified csdl version.
/// </returns>
private XNamespace DetermineXmlNamespace(EdmVersion csdlVersion)
{
if (csdlVersion == EdmVersion.V40)
{
return EdmConstants.CsdlOasisNamespace;
}
else
{
throw new TaupoNotSupportedException("CSDL Schema Version is not supported: " + csdlVersion.ToString());
}
}
public static IEnumerable<XElement> ComplexTypeWithBaseType(EdmVersion edmVersion)
{
var csdls = new List<string>(3);
csdls.Add(@"
<Schema Namespace='FindMethodsTestModelBuilder.MultipleSchemasWithDerivedTypes.third' xmlns='$EdmNamespace$'>
<ComplexType Name='VALIDeCOMPLEXtYPE1' BaseType='a.ValidComplexType2' />
<ComplexType Name='V1alidcomplexType'>
<Property Name='aPropertyOne' Type='FindMethodsTestModelBuilder.MultipleSchemasWithUsings.second.V1alidcomplexType' Nullable='false' />
</ComplexType>
<EntityContainer Name='ValidEntityContainer2' />
</Schema> ");
csdls.Add(@"<Schema Namespace='FindMethodsTestModelBuilder.MultipleSchemasWithUsings.second' xmlns='$EdmNamespace$'>
<ComplexType Name='ValidComplexType2' BaseType='FindMethodsTestModelBuilder.MultipleSchemasWithUsings.first.validComplexType1' />
<ComplexType Name='V1alidcomplexType'>
<Property Name='aPropertyOne' Type='FindMethodsTestModelBuilder.MultipleSchemasWithUsings.first.V1alidcomplexType' Nullable='false' />
</ComplexType>
</Schema>");
csdls.Add(@"
<Schema Namespace='FindMethodsTestModelBuilder.MultipleSchemasWithDerivedTypes.first' xmlns='$EdmNamespace$'>
<ComplexType Name='validComplexType1'>
<Property Name='Id' Type='Int32' Nullable='false' />
</ComplexType>
<ComplexType Name='V1alidcomplexType' />
</Schema>");
var temp = csdls.Select(n => n.Replace("$EdmNamespace$", EdmLibCsdlContentGenerator.GetCsdlFullNamespace(edmVersion).NamespaceName));
return from t in temp
select XElement.Parse(t);
}
private IEnumerable<string> GetXsdValidationResults(IEnumerable<XElement> csdls, EdmVersion edmVersion)
{
var errorMessages = new List<string>();
foreach (var csdl in csdls)
{
errorMessages.AddRange(GetXsdValidationResults(csdl, edmVersion));
}
return errorMessages;
}
private void RoundTripValidator(IEnumerable<XElement> csdls, EdmVersion version)
{
var model = this.GetParserResult(csdls);
var roundTripCsdls = this.GetSerializerResult(model).Select(n => XElement.Parse(n));
CsdlXElementComparer(csdls, roundTripCsdls, version);
}
/// <summary>
/// Generates csdl contents, given a fully resolved <see cref="EntityModelSchema"/>
/// </summary>
/// <param name="csdlVersion">The CSDL version.</param>
/// <param name="model">Input model</param>
/// <returns>Generated file contents.</returns>
public IEnumerable<FileContents<XElement>> Generate(EdmVersion csdlVersion, EntityModelSchema model)
{
this.edmVersion = csdlVersion;
return base.Generate(this.DetermineXmlNamespace(csdlVersion), model);
}
