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