public void LocateTypes() { const string csdl = @"<?xml version=""1.0"" encoding=""utf-16""?> <Schema Namespace=""Grumble"" xmlns=""http://docs.oasis-open.org/odata/ns/edm""> <EntityType Name=""Person""> <Key> <PropertyRef Name=""Id"" /> </Key> <Property Name=""Id"" Type=""Int32"" Nullable=""false"" /> <Property Name=""Address"" Type=""String"" MaxLength=""100"" /> </EntityType> <ComplexType Name=""Smod""> <Property Name=""Id"" Type=""Edm.Int32"" /> <Property Name=""Collection"" Type=""Collection(Edm.Int32)"" /> <Property Name=""ref"" Type=""Ref(Grumble.Person)"" /> </ComplexType> </Schema>"; IEdmModel model; IEnumerable <EdmError> error; bool parsed = SchemaReader.TryParse(new XmlReader[] { XmlReader.Create(new StringReader(csdl)) }, out model, out error); Assert.IsTrue(parsed, "parsed"); IEdmComplexType complexType = (IEdmComplexType)model.FindType("Grumble.Smod"); IEdmTypeReference primitive = complexType.FindProperty("Id").Type; IEdmTypeReference collection = complexType.FindProperty("Collection").Type; IEdmTypeReference entityReference = complexType.FindProperty("ref").Type; AssertCorrectLocation((CsdlLocation)primitive.Location(), csdl, @"Property Name=""Id"" Type=""Edm.Int32"" "); AssertCorrectLocation((CsdlLocation)collection.Location(), csdl, @"Property Name=""Collection"" Type=""Collection(Edm.Int32)"" "); AssertCorrectLocation((CsdlLocation)entityReference.Location(), csdl, @"Property Name=""ref"" Type=""Ref(Grumble.Person)"" "); }
public void CsdlUnnamedTypeDefinitionToStringTest() { const string csdl = @"<?xml version=""1.0"" encoding=""utf-16""?> <Schema Namespace=""Namespace"" Alias=""Alias"" xmlns=""http://docs.oasis-open.org/odata/ns/edm""> <EntityType Name=""AstonishingEntity""> <Key> <PropertyRef Name=""Id"" /> </Key> <Property Name=""Id"" Type=""Int32"" Nullable=""false"" /> </EntityType> <Function Name=""Function1""><ReturnType Type=""Edm.Int32""/> <Parameter Name=""P1"" Type=""Collection(Edm.Int32)"" /> <Parameter Name=""P2"" Type=""Ref(Namespace.AstonishingEntity)"" /> </Function> </Schema>"; IEdmModel model; IEnumerable <EdmError> errors; bool parsed = SchemaReader.TryParse(new XmlReader[] { XmlReader.Create(new StringReader(csdl)) }, out model, out errors); Assert.IsTrue(parsed, "parsed"); Assert.IsTrue(errors.Count() == 0, "No errors"); IEdmOperation operation = (IEdmOperation)(model.FindOperations("Namespace.Function1")).First(); IEdmCollectionType collection = (IEdmCollectionType)operation.FindParameter("P1").Type.Definition; IEdmEntityReferenceType entityRef = (IEdmEntityReferenceType)operation.FindParameter("P2").Type.Definition; Assert.AreEqual("Collection([Edm.Int32 Nullable=True])", collection.ToString(), "To string correct"); Assert.AreEqual("EntityReference(Namespace.AstonishingEntity)", entityRef.ToString(), "To string correct"); }
static AlternateKeysVocabularyModel() { Assembly assembly = typeof(AlternateKeysVocabularyModel).GetAssembly(); // Resource name has leading namespace and folder in .NetStandard dll. string[] allResources = assembly.GetManifestResourceNames(); string alternateKeysVocabularies = allResources.Where(x => x.Contains("AlternateKeysVocabularies.xml")).FirstOrDefault(); Debug.Assert(alternateKeysVocabularies != null, "AlternateKeysVocabularies.xml: not found."); using (Stream stream = assembly.GetManifestResourceStream(alternateKeysVocabularies)) { IEnumerable<EdmError> errors; Debug.Assert(stream != null, "AlternateKeysVocabularies.xml: stream!=null"); SchemaReader.TryParse(new[] { XmlReader.Create(stream) }, out Instance, out errors); } AlternateKeysTerm = Instance.FindDeclaredTerm(AlternateKeysVocabularyConstants.AlternateKeys); Debug.Assert(AlternateKeysTerm != null, "Expected Alternate Key term"); AlternateKeyType = Instance.FindDeclaredType(AlternateKeysVocabularyConstants.AlternateKeyType) as IEdmComplexType; Debug.Assert(AlternateKeyType != null, "Expected Alternate Key type"); PropertyRefType = Instance.FindDeclaredType(AlternateKeysVocabularyConstants.PropertyRefType) as IEdmComplexType; Debug.Assert(PropertyRefType != null, "Expected Alternate Key property ref type"); }
private static IEdmModel GetEdmModel(string schema) { bool parsed = SchemaReader.TryParse(new XmlReader[] { XmlReader.Create(new StringReader(schema)) }, out IEdmModel parsedModel, out IEnumerable <EdmError> errors); Assert.True(parsed, $"Parse failure. {string.Join(Environment.NewLine, errors.Select(e => e.ToString()))}"); return(parsedModel); }
private void BasicXsdValidationTestForParserInputCsdl(IEnumerable <XElement> csdls, EdmVersion edmVersion) { IEdmModel edmModel; IEnumerable <EdmError> parserErrors; var csdlsEdmVersionUpdated = csdls.Select(n => XElement.Parse(n.ToString().Replace(n.Name.NamespaceName, EdmLibCsdlContentGenerator.GetCsdlFullNamespace(edmVersion).NamespaceName))); var isParsed = SchemaReader.TryParse(csdlsEdmVersionUpdated.Select(e => e.CreateReader()), out edmModel, out parserErrors); if (!isParsed) { // XSD verification is a sufficent condition, but not a necessary condition of EDMLib parser. Assert.IsTrue(this.GetXsdValidationResults(csdlsEdmVersionUpdated, edmVersion).Count() > 0, "It should be invalid for the CSDL {0} XSDs", edmVersion); } else { IEnumerable <EdmError> validationErrors; edmModel.Validate(toProductVersionlookup[edmVersion], out validationErrors); var xsdValidationErrors = new List <string>(); xsdValidationErrors.AddRange(this.GetXsdValidationResults(csdlsEdmVersionUpdated, edmVersion)); if (!validationErrors.Any() && xsdValidationErrors.Any()) { Assert.Fail("XSD validation must succeed when there is no semantic validation error."); } else if (validationErrors.Any() && !xsdValidationErrors.Any()) { foreach (var validationError in validationErrors) { Console.WriteLine("The test data has no XSD error, but it has a validation error : {0}", validationError.ErrorMessage); } } } }
public static new void InitializeService(DataServiceConfiguration config) { BaseService.InitializeService(config); config.AnnotationsBuilder = (model) => { var xmlReaders = new XmlReader[] { XmlReader.Create(new StringReader(@" <Schema xmlns=""http://docs.oasis-open.org/odata/ns/edm"" Namespace=""Microsoft.Test.OData.Services.ODataWriterService"" > <Annotations Target=""Microsoft.Test.OData.Services.AstoriaDefaultService.Customer""> <Annotation Term=""CustomInstanceAnnotations.Term1"" Bool=""true"" /> </Annotations> </Schema> ")) }; IEdmModel annotationsModel; IEnumerable <EdmError> errors; bool parsed = SchemaReader.TryParse(xmlReaders, model, out annotationsModel, out errors); if (!parsed) { throw new EdmParseException(errors); } return(new IEdmModel[] { annotationsModel }); }; }
private static IEdmModel GetEdmModel() { const string schema = @"<?xml version=""1.0"" encoding=""utf-16""?> <Schema Namespace=""NS"" xmlns=""http://docs.oasis-open.org/odata/ns/edm""> <EntityContainer Name=""Container""> <Annotation Term=""Org.OData.Authorization.V1.Authorizations""> <Collection> <Record Type=""Org.OData.Authorization.V1.OpenIDConnect""> <PropertyValue Property=""IssuerUrl"" String=""http://any"" /> <PropertyValue Property=""Name"" String=""OpenIDConnect Name"" /> <PropertyValue Property=""Description"" String=""OpenIDConnect Description"" /> </Record> <Record Type=""Org.OData.Authorization.V1.Http""> <PropertyValue Property=""BearerFormat"" String=""Http BearerFormat"" /> <PropertyValue Property=""Scheme"" String=""Http Scheme"" /> <PropertyValue Property=""Name"" String=""Http Name"" /> </Record> </Collection> </Annotation> </EntityContainer> </Schema>"; IEdmModel parsedModel; bool parsed = SchemaReader.TryParse(new XmlReader[] { XmlReader.Create(new StringReader(schema)) }, out parsedModel, out _); Assert.True(parsed); return(parsedModel); }
void VerifyResult(string[] inputText, string expectedResult, CsdlTarget target, Action <IEdmModel> visitModel) { IEdmModel model; IEnumerable <EdmError> errors; List <XmlReader> readers = new List <XmlReader>(); foreach (string s in inputText) { readers.Add(XmlReader.Create(new StringReader(s))); } bool parsed = SchemaReader.TryParse(readers, out model, out errors); Assert.IsTrue(parsed, "Model Parsed"); Assert.IsTrue(errors.Count() == 0, "No Errors"); if (visitModel != null) { visitModel(model); } StringWriter sw = new StringWriter(); XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; settings.Encoding = System.Text.Encoding.UTF8; XmlWriter xw = XmlWriter.Create(sw, settings); CsdlWriter.TryWriteCsdl(model, xw, target, out errors); xw.Flush(); xw.Close(); string outputText = sw.ToString(); Assert.AreEqual(expectedResult, outputText, "Expected Result = Output"); }
static CoreVocabularyModel() { IsInitializing = true; Assembly assembly = typeof(CoreVocabularyModel).GetAssembly(); // Resource name has leading namespace and folder in .NetStandard dll. string[] allResources = assembly.GetManifestResourceNames(); string coreVocabularies = allResources.Where(x => x.Contains("CoreVocabularies.xml")).FirstOrDefault(); Debug.Assert(coreVocabularies != null, "CoreVocabularies.xml: not found."); using (Stream stream = assembly.GetManifestResourceStream(coreVocabularies)) { IEnumerable <EdmError> errors; Debug.Assert(stream != null, "CoreVocabularies.xml: stream!=null"); SchemaReader.TryParse(new[] { XmlReader.Create(stream) }, out Instance, out errors); IsInitializing = false; } AcceptableMediaTypesTerm = Instance.FindDeclaredTerm(CoreVocabularyConstants.AcceptableMediaTypes); ComputedTerm = Instance.FindDeclaredTerm(CoreVocabularyConstants.Computed); ConcurrencyTerm = Instance.FindDeclaredTerm(CoreVocabularyConstants.OptimisticConcurrency); ConventionalIDsTerm = Instance.FindDeclaredTerm(CoreVocabularyConstants.ConventionalIDs); DereferenceableIDsTerm = Instance.FindDeclaredTerm(CoreVocabularyConstants.DereferenceableIDs); DescriptionTerm = Instance.FindDeclaredTerm(CoreVocabularyConstants.Description); ImmutableTerm = Instance.FindDeclaredTerm(CoreVocabularyConstants.Immutable); IsLanguageDependentTerm = Instance.FindDeclaredTerm(CoreVocabularyConstants.IsLanguageDependent); IsMediaTypeTerm = Instance.FindDeclaredTerm(CoreVocabularyConstants.IsMediaType); IsURLTerm = Instance.FindDeclaredTerm(CoreVocabularyConstants.IsURL); LongDescriptionTerm = Instance.FindDeclaredTerm(CoreVocabularyConstants.LongDescription); MediaTypeTerm = Instance.FindDeclaredTerm(CoreVocabularyConstants.MediaType); RequiresTypeTerm = Instance.FindDeclaredTerm(CoreVocabularyConstants.RequiresType); ResourcePathTerm = Instance.FindDeclaredTerm(CoreVocabularyConstants.ResourcePath); PermissionsTerm = Instance.FindDeclaredTerm(CoreVocabularyConstants.Permissions); }
public void ParserTestForDifferentUnderlyingXmlReaders() { var csdl = @"<Schema Namespace=""DefaultNamespace"" xmlns=""http://docs.oasis-open.org/odata/ns/edm""> <Action Name=""FunctionImportsWithReturnTypePrimitiveDataType""> <Parameter Name=""PrimitiveParameter1"" Type=""Edm.Binary"" /> <Parameter Name=""PrimitiveParameter2""><Foo /></Parameter> </Action> <EntityContainer Name=""MyContainer""> <ActionImport Name=""FunctionImportsWithReturnTypePrimitiveDataType"" Action=""DefaultNamespace.FunctionImportsWithReturnTypePrimitiveDataType"" /> </EntityContainer> </Schema>"; IEdmModel model; IEnumerable <EdmError> errors; var csdlElements = new XElement[] { XElement.Parse(csdl) }; bool parsed = SchemaReader.TryParse(new System.Xml.XmlReader[] { System.Xml.XmlReader.Create(new System.IO.StringReader(csdl)) }, out model, out errors); Assert.IsFalse(parsed, "parsed"); Assert.AreEqual(2, errors.Count(), "2 errors"); Assert.AreEqual(EdmErrorCode.UnexpectedXmlElement, errors.First().ErrorCode, "10: Unexpected Xml Element"); parsed = SchemaReader.TryParse(new System.Xml.XmlReader[] { csdlElements.First().CreateReader() }, out model, out errors); Assert.IsFalse(parsed, "parsed"); Assert.AreEqual(2, errors.Count(), "2 errors"); Assert.AreEqual(EdmErrorCode.UnexpectedXmlElement, errors.First().ErrorCode, "10: Unexpected Xml Element"); }
private IEdmModel DeSerializeCsdlsToModel(IEnumerable <XElement> csdls) { IEdmModel model; IEnumerable <EdmError> errors; var isParsed = SchemaReader.TryParse(csdls.Select(e => e.CreateReader()), out model, out errors); Assert.IsTrue(isParsed, "Error occurs while deserializing csdl to model"); return(model); }
public void VocabularySerializingAnnotationTermsWithNoNamespace() { IEdmModel edmModel; IEnumerable <EdmError> errors; var isParsed = SchemaReader.TryParse(VocabularyTestModelBuilder.AnnotationTermsWithNoNamespace().Select(e => e.CreateReader()), out edmModel, out errors); Assert.IsFalse(isParsed, "SchemaReader.TryParse failed"); Assert.IsFalse(errors.Count() == 0, "SchemaReader.TryParse returned errors"); }
private IEdmModel GetParserResult(IEnumerable <XElement> csdlElements) { IEdmModel edmModel; IEnumerable <EdmError> errors; bool success = SchemaReader.TryParse(csdlElements.Select(e => e.CreateReader()), out edmModel, out errors); ExceptionUtilities.Assert(success, "Parse failed -- are you using an invalid model?"); return(edmModel); }
private static IEdmModel GetEdmModel() { const string schema = @"<?xml version=""1.0"" encoding=""utf-16""?> <Schema Namespace=""NS"" xmlns=""http://docs.oasis-open.org/odata/ns/edm""> <EntityType Name=""Entity""> <Key> <PropertyRef Name=""Id"" /> </Key> <Property Name=""Id"" Type=""Edm.Int32"" Nullable=""false"" /> </EntityType> <EntityContainer Name=""Container""> <EntitySet Name=""Entities"" EntityType=""NS.Entity""> <Annotation Term=""Org.OData.Authorization.V1.Authorizations""> <Collection> <Record Type=""Org.OData.Authorization.V1.OpenIDConnect""> <PropertyValue Property=""IssuerUrl"" String=""http://any"" /> <PropertyValue Property=""Name"" String=""OpenIDConnect Name"" /> <PropertyValue Property=""Description"" String=""OpenIDConnect Description"" /> </Record> <Record Type=""Org.OData.Authorization.V1.Http""> <PropertyValue Property=""BearerFormat"" String=""Http BearerFormat"" /> <PropertyValue Property=""Scheme"" String=""Http Scheme"" /> <PropertyValue Property=""Name"" String=""Http Name"" /> <PropertyValue Property=""Description"" String=""Http Description"" /> </Record> </Collection> </Annotation> </EntitySet> <Singleton Name=""Me"" Type=""NS.Entity"" /> </EntityContainer> <Annotations Target=""NS.Container/Me""> <Annotation Term=""Org.OData.Authorization.V1.Authorizations""> <Collection> <Record Type=""Org.OData.Authorization.V1.OpenIDConnect""> <PropertyValue Property=""IssuerUrl"" String=""http://any"" /> <PropertyValue Property=""Name"" String=""OpenIDConnect Name"" /> <PropertyValue Property=""Description"" String=""OpenIDConnect Description"" /> </Record> <Record Type=""Org.OData.Authorization.V1.Http""> <PropertyValue Property=""BearerFormat"" String=""Http BearerFormat"" /> <PropertyValue Property=""Scheme"" String=""Http Scheme"" /> <PropertyValue Property=""Name"" String=""Http Name"" /> <PropertyValue Property=""Description"" String=""Http Description"" /> </Record> </Collection> </Annotation> </Annotations> </Schema>"; IEdmModel parsedModel; IEnumerable <EdmError> errors; bool parsed = SchemaReader.TryParse(new XmlReader[] { XmlReader.Create(new StringReader(schema)) }, out parsedModel, out errors); Assert.True(parsed); return(parsedModel); }
public void CheckMultiVersionCsdlsRoundtrip() { const string inputText = @"<?xml version=""1.0"" encoding=""utf-16""?> <Schema Namespace=""Real4"" xmlns=""http://docs.oasis-open.org/odata/ns/edm""> <ComplexType Name=""Complex4"" BaseType=""Real4.Complex1""> <Property Name=""Prop4"" Type=""Edm.Int32"" Nullable=""false"" /> </ComplexType> </Schema>"; XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; settings.Encoding = System.Text.Encoding.UTF8; List <StringWriter> outStrings = new List <StringWriter>(); List <XmlReader> readers = new List <XmlReader>(); List <XmlWriter> writers = new List <XmlWriter>(); foreach (string s in new string[] { inputText }) { readers.Add(XmlReader.Create(new StringReader(s))); } for (int i = 0; i < readers.Count; i++) { StringWriter sw = new StringWriter(); outStrings.Add(sw); writers.Add(XmlWriter.Create(sw, settings)); } IEdmModel model; IEnumerable <EdmError> errors; bool parsed = SchemaReader.TryParse(readers, out model, out errors); Assert.IsTrue(parsed, "Model Parsed"); Assert.IsTrue(errors.Count() == 0, "No errors"); Assert.AreEqual(EdmConstants.EdmVersion4, model.GetEdmVersion(), "Version check"); IEnumerator <XmlWriter> writerEnumerator = writers.GetEnumerator(); model.TryWriteSchema(s => { writerEnumerator.MoveNext(); return(writerEnumerator.Current); }, out errors); foreach (XmlWriter xw in writers) { xw.Flush(); xw.Close(); } IEnumerator <StringWriter> swEnumerator = outStrings.GetEnumerator(); foreach (string input in new string[] { inputText }) { swEnumerator.MoveNext(); Assert.IsTrue(swEnumerator.Current.ToString() == input, "Input = Output"); } }
private static IEdmModel LoadSchemaEdmModel(Assembly assembly, string vocabularyName, IEnumerable <IEdmModel> referenceModels) { using (Stream stream = assembly.GetManifestResourceStream(vocabularyName)) { IEdmModel model; IEnumerable <EdmError> errors; SchemaReader.TryParse(new[] { XmlReader.Create(stream) }, referenceModels, false, out model, out errors); return(model); } }
public void SerializerTestModelOperationDuplicateReturnType() { var csdls = ModelBuilder.FunctionDuplicateReturnType(); IEdmModel edmModel; IEnumerable <EdmError> errors; var isParsed = SchemaReader.TryParse(csdls.Select(e => e.CreateReader()), out edmModel, out errors); Assert.AreEqual(1, errors.Count(), "Expecting errors."); Assert.AreEqual(EdmErrorCode.UnexpectedXmlElement, errors.ElementAt(0).ErrorCode, "Invalid error code."); }
protected IEdmModel GetParserResult(IEnumerable <XElement> csdlElements, params IEdmModel[] referencedModels) { IEdmModel edmModel; IEnumerable <EdmError> errors; var isParsed = SchemaReader.TryParse(csdlElements.Select(e => e.CreateReader()), referencedModels, out edmModel, out errors); Assert.IsTrue(isParsed, "SchemaReader.TryParse failed"); Assert.IsTrue(!errors.Any(), "SchemaReader.TryParse returned errors"); return(edmModel); }
protected void VerifySemanticValidation(IEdmModel testModel, ValidationRuleSet ruleset, IEnumerable <EdmError> expectedErrors) { // Compare the actual errors of the test models to the expected errors. IEnumerable <EdmError> actualErrors = null; var validationResult = testModel.Validate(ruleset, out actualErrors); Assert.IsTrue(actualErrors.Any() ? !validationResult : validationResult, "The return value of the Validate method does not match the reported validation errors."); this.CompareErrors(actualErrors, expectedErrors); // Compare the round-tripped immutable model through the CSDL serialized from the original test model against the expected errors. Func <EdmVersion> GetEdmVersionFromRuleSet = () => { EdmVersion result = EdmVersion.Latest; foreach (var edmVersion in new EdmVersion[] { EdmVersion.V40 }) { var versionRuleSet = ValidationRuleSet.GetEdmModelRuleSet(toProductVersionlookup[edmVersion]); if (versionRuleSet.Count() == ruleset.Count() && !ruleset.Except(versionRuleSet).Any()) { result = edmVersion; break; } } return(result); }; IEnumerable <EdmError> serializationErrors; var serializedCsdls = this.GetSerializerResult(testModel, GetEdmVersionFromRuleSet(), out serializationErrors).Select(n => XElement.Parse(n)); if (!serializedCsdls.Any()) { Assert.AreNotEqual(0, serializationErrors.Count(), "Empty models should have associated errors"); return; } if (!actualErrors.Any()) { // if the original test model is valid, the round-tripped model should be well-formed and valid. IEnumerable <EdmError> parserErrors = null; IEdmModel roundtrippedModel = null; var isWellformed = SchemaReader.TryParse(serializedCsdls.Select(e => e.CreateReader()), out roundtrippedModel, out parserErrors); Assert.IsTrue(isWellformed && !parserErrors.Any(), "The model from valid CSDLs should be generated back to well-formed CSDLs."); IEnumerable <EdmError> validationErrors = null; var isValid = roundtrippedModel.Validate(out validationErrors); Assert.IsTrue(!validationErrors.Any() && isValid, "The model from valid CSDLs should be generated back to valid CSDLs."); } else { // if the originl test model is not valid, the serializer should still generate CSDLs that parser can handle, but the round trip-ability is not guarantted. IEnumerable <EdmError> parserErrors = null; IEdmModel roundtrippedModel = null; var isWellformed = SchemaReader.TryParse(serializedCsdls.Select(e => e.CreateReader()), out roundtrippedModel, out parserErrors); Assert.IsTrue(isWellformed, "The parser cannot handle the CSDL that the serializer generated:" + Environment.NewLine + String.Join(Environment.NewLine, parserErrors)); } }
static MeasuresHelpers() { using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ODataSamples.Services.Core.Vocabularies.MeasuresVocabularies.xml")) { IEnumerable <EdmError> errors; SchemaReader.TryParse(new[] { XmlReader.Create(stream) }, out Instance, out errors); } ISOCurrencyTerm = Instance.FindDeclaredTerm(MeasuresISOCurrency); ScaleTerm = Instance.FindDeclaredTerm(MeasuresScale); }
public void LocateEntityContainer() { const string csdl = @"<?xml version=""1.0"" encoding=""utf-16""?> <Schema Namespace=""Hot"" Alias=""Fuzz"" xmlns=""http://docs.oasis-open.org/odata/ns/edm""> <EntityType Name=""Person""> <Key> <PropertyRef Name=""Id"" /> </Key> <Property Name=""Id"" Type=""Int32"" Nullable=""false"" /> <Property Name=""Address"" Type=""String"" MaxLength=""100"" /> </EntityType> <EntityType Name=""Pet""> <Key> <PropertyRef Name=""PetId"" /> </Key> <Property Name=""Id"" Type=""Int32"" Nullable=""false"" /> <Property Name=""OwnerId"" Type=""Int32"" Nullable=""false"" /> </EntityType> <EntityContainer Name=""Wild""> <EntitySet Name=""People"" EntityType=""Hot.Person"" /> <EntitySet Name=""Pets"" EntityType=""Hot.Pet"" /> </EntityContainer> </Schema>"; IEdmModel model; IEnumerable <EdmError> errors; bool parsed = SchemaReader.TryParse(new XmlReader[] { XmlReader.Create(new StringReader(csdl)) }, out model, out errors); Assert.IsTrue(parsed, "parsed"); Assert.IsTrue(errors.Count() == 0, "No errors"); IEdmEntityType person = (IEdmEntityType)model.FindType("Hot.Person"); IEdmProperty personId = person.FindProperty("Id"); IEdmProperty personAddress = person.FindProperty("Address"); IEdmEntityType pet = (IEdmEntityType)model.FindType("Hot.Pet"); IEdmProperty petId = pet.FindProperty("Id"); IEdmProperty ownerId = pet.FindProperty("OwnerId"); IEdmEntityContainer wild = model.EntityContainer; IEdmEntitySet people = model.EntityContainer.FindEntitySet("People"); IEdmEntitySet pets = model.EntityContainer.FindEntitySet("Pets"); AssertCorrectLocation((CsdlLocation)person.Location(), csdl, @"EntityType Name=""Person"""); AssertCorrectLocation((CsdlLocation)personId.Location(), csdl, @"Property Name=""Id"" Type=""Int32"" Nullable=""false"""); AssertCorrectLocation((CsdlLocation)personAddress.Location(), csdl, @"Property Name=""Address"" Type=""String"" MaxLength=""100"" "); AssertCorrectLocation((CsdlLocation)pet.Location(), csdl, @"EntityType Name=""Pet"""); AssertCorrectLocation((CsdlLocation)petId.Location(), csdl, @"Property Name=""Id"" Type=""Int32"" Nullable=""false"" "); AssertCorrectLocation((CsdlLocation)ownerId.Location(), csdl, @"Property Name=""OwnerId"" Type=""Int32"" Nullable=""false"" "); AssertCorrectLocation((CsdlLocation)wild.Location(), csdl, @"EntityContainer Name=""Wild"""); AssertCorrectLocation((CsdlLocation)people.Location(), csdl, @"EntitySet Name=""People"" EntityType=""Hot.Person"" "); AssertCorrectLocation((CsdlLocation)pets.Location(), csdl, @"EntitySet Name=""Pets"" EntityType=""Hot.Pet"" "); }
public void AmbiguousOperationTest() { string csdl = @" <Schema Namespace=""DefaultNamespace"" xmlns=""http://docs.oasis-open.org/odata/ns/edm""> <Term Name=""Annotation"" Type=""Edm.Int32"" /> <EntityType Name=""Entity"" > <Key> <PropertyRef Name=""ID"" /> </Key> <Property Name=""ID"" Type=""Edm.Int32"" Nullable=""False"" /> </EntityType> <Function Name=""Function""> <Parameter Name=""Parameter"" Type=""Edm.String"" /> <Parameter Name=""Parameter2"" Type=""Ref(DefaultNamespace.Entity)"" /> <ReturnType Type=""Edm.Int32"" /> </Function> <Function Name=""Function""> <Parameter Name=""Parameter"" Type=""Edm.String"" /> <Parameter Name=""Parameter2"" Type=""Ref(DefaultNamespace.Entity)"" /> <ReturnType Type=""Edm.Int32"" /> </Function> <Function Name=""Function""> <Parameter Name=""Parameter"" Type=""Edm.String"" /> <Parameter Name=""Parameter2"" Type=""Ref(DefaultNamespace.Entity)"" /> <ReturnType Type=""Edm.Int32"" /> </Function> <Annotations Target=""DefaultNamespace.Function(Edm.String, Ref(DefaultNamespace.Entity))""> <Annotation Term=""AnnotationNamespace.Annotation""> <Int>42</Int> </Annotation> </Annotations> </Schema>"; IEdmModel model; IEnumerable <EdmError> errors; bool parsed = SchemaReader.TryParse(new XmlReader[] { XmlReader.Create(new StringReader(csdl)) }, out model, out errors); Assert.IsTrue(parsed, "parsed"); Assert.IsTrue(errors.Count() == 0, "No errors"); IEdmVocabularyAnnotation annotation = model.VocabularyAnnotations.First(); IEdmOperation firstOperation = model.FindOperations("DefaultNamespace.Function").First(); IEdmOperation ambiguousOperation = annotation.Target as IEdmOperation; Assert.IsNotNull(ambiguousOperation, "Function not null"); Assert.AreEqual(EdmSchemaElementKind.Function, ambiguousOperation.SchemaElementKind, "Correct schema element kind"); Assert.IsNull(ambiguousOperation.ReturnType, "Null return type"); Assert.AreEqual("DefaultNamespace", ambiguousOperation.Namespace, "Correct namespace"); Assert.AreEqual(firstOperation.Parameters.First(), ambiguousOperation.Parameters.First(), "Function gets parameters from first function"); Assert.AreEqual(firstOperation.FindParameter("Parameter"), ambiguousOperation.FindParameter("Parameter"), "Find parameter defers to first function"); }
/// <summary> /// Reads edm model from resource file /// </summary> /// <param name="modelName">The name of resource file containing the model</param> /// <returns>Edm model</returns> private static IEdmModel ReadModelFromResources(string modelName) { IEdmModel model; IEnumerable <EdmError> errors; var csdlStream = new MemoryStream(ReadTestResource(modelName)); bool parseResult = SchemaReader.TryParse(new[] { XmlReader.Create(csdlStream) }, out model, out errors); if (!parseResult) { throw new InvalidOperationException("Failed to load model : " + string.Join(Environment.NewLine, errors.Select(e => e.ErrorMessage))); } return(model); }
/// <summary> /// Loads a model from the resource. /// </summary> /// <param name="resourceAssembly">The assembly that stores the resource.</param> /// <param name="name">The name of the resource file to load.</param> /// <param name="references">The model references to add.</param> /// <returns>The loaded model.</returns> public static IEdmModel LoadModelFromResource(Assembly resourceAssembly, string name, params IEdmModel[] references) { Stream modelStream = resourceAssembly.GetManifestResourceStream(name); using (XmlReader reader = XmlReader.Create(modelStream)) { IEdmModel model; IEnumerable <EdmError> errors; if (!SchemaReader.TryParse(new XmlReader[] { reader }, references, out model, out errors)) { throw new AssertionFailedException("Model loading failed: " + string.Join("\r\n", errors.Select(e => e.ErrorLocation.ToString() + ": " + e.ErrorMessage))); } return(model); } }
public void CsdlNamedTypeDefinitionToStringTest() { const string csdl = @"<?xml version=""1.0"" encoding=""utf-16""?> <Schema Namespace=""AwesomeNamespace"" Alias=""Alias"" xmlns=""http://docs.oasis-open.org/odata/ns/edm""> <EntityType Name=""AstonishingEntity""> <Key> <PropertyRef Name=""Id"" /> </Key> <Property Name=""Id"" Type=""Int32"" Nullable=""false"" /> </EntityType> <EntityType Name=""AweInspiringEntity""> <Key> <PropertyRef Name=""Id"" /> </Key> <Property Name=""Id"" Type=""Int32"" Nullable=""false"" /> <Property Name=""AstonishingID"" Type=""Int32"" /> </EntityType> <ComplexType Name=""BreathtakingComplex""> <Property Name=""Par1"" Type=""Int32"" Nullable=""false"" /> <Property Name=""Par2"" Type=""Int32"" Nullable=""false"" /> </ComplexType> <EnumType Name=""FabulousEnum""> <Member Name=""m1"" /> <Member Name=""m2"" /> </EnumType> </Schema>"; IEdmModel model; IEnumerable <EdmError> errors; bool parsed = SchemaReader.TryParse(new XmlReader[] { XmlReader.Create(new StringReader(csdl)) }, out model, out errors); Assert.IsTrue(parsed, "parsed"); Assert.IsTrue(errors.Count() == 0, "No errors"); IEdmEntityType astonishing = (IEdmEntityType)model.FindType("AwesomeNamespace.AstonishingEntity"); IEdmEntityType aweInspiring = (IEdmEntityType)model.FindType("AwesomeNamespace.AweInspiringEntity"); IEdmComplexType breathTaking = (IEdmComplexType)model.FindType("AwesomeNamespace.BreathtakingComplex"); IEdmPrimitiveType primitive = (IEdmPrimitiveType)astonishing.FindProperty("Id").Type.Definition; IEdmEnumType fabulous = (IEdmEnumType)model.FindType("AwesomeNamespace.FabulousEnum"); Assert.AreEqual("AwesomeNamespace.AstonishingEntity", astonishing.ToString(), "To string correct"); Assert.AreEqual("AwesomeNamespace.AweInspiringEntity", aweInspiring.ToString(), "To string correct"); Assert.AreEqual("AwesomeNamespace.BreathtakingComplex", breathTaking.ToString(), "To string correct"); Assert.AreEqual("Edm.Int32", primitive.ToString(), "To string correct"); Assert.AreEqual("AwesomeNamespace.FabulousEnum", fabulous.ToString(), "To string correct"); }
/// <summary> /// Parse Validation Vocabulary Model from ValidationVocabularies.xml /// </summary> static ValidationVocabularyModel() { Assembly assembly = typeof(ValidationVocabularyModel).GetAssembly(); // Resource name has leading namespace and folder in .NetStandard dll. string[] allResources = assembly.GetManifestResourceNames(); string validationVocabularies = allResources.Where(x => x.Contains("ValidationVocabularies.xml")).FirstOrDefault(); Debug.Assert(validationVocabularies != null, "ValidationVocabularies.xml: not found."); using (Stream stream = assembly.GetManifestResourceStream(validationVocabularies)) { IEnumerable <EdmError> errors; Debug.Assert(stream != null, "ValidationVocabularies.xml: stream!=null"); SchemaReader.TryParse(new[] { XmlReader.Create(stream) }, out Instance, out errors); } }
private IEdmModel GetEdmModel(string annotation) { const string template = @"<?xml version=""1.0"" encoding=""utf-16""?> <Schema Namespace=""NS"" xmlns=""http://docs.oasis-open.org/odata/ns/edm""> <EntityContainer Name=""Container""> {0} </EntityContainer> <Term Name=""MyCustomParameter"" Type=""Org.OData.Capabilities.V1.CustomParameter"" /> </Schema> "; string schema = string.Format(template, annotation); IEdmModel model; bool result = SchemaReader.TryParse(new XmlReader[] { XmlReader.Create(new StringReader(schema)) }, out model, out _); Assert.True(result); return(model); }
/// <summary> /// Builds a model with annotations. /// </summary> /// <param name="annotationXml">The annotation element(s) as XML string.</param> /// <param name="references">The model references to add.</param> /// <returns>The loaded model.</returns> /// <remarks>The <paramref name="annotationXml"/> string must not include the wrapping schema element.</remarks> public static IEdmModel BuildAnnotationModel(string annotationXml, params IEdmModel[] references) { string annotationSchema = "<Schema Namespace='TestModelStandardAnnotations' xmlns='http://docs.oasis-open.org/odata/ns/edm'>" + annotationXml + "</Schema>"; using (XmlReader reader = XmlReader.Create(new StringReader(annotationSchema))) { IEdmModel model; IEnumerable <EdmError> errors; if (!SchemaReader.TryParse(new XmlReader[] { reader }, references, out model, out errors)) { throw new AssertionFailedException("Model loading failed: " + string.Join("\r\n", errors.Select(e => e.ErrorLocation.ToString() + ": " + e.ErrorMessage))); } return(model); } }
public void ParserTestForIncorrectCsdl20Namespace() { var csdls = ModelBuilder.SimpleConstructiveApiTestModel(); IEdmModel model; IEnumerable <EdmError> errors; foreach (var csdl in csdls) { bool parsed = SchemaReader.TryParse(new System.Xml.XmlReader[] { csdl.CreateReader() }, out model, out errors); Assert.IsTrue(parsed, "parsed"); // http://docs.oasis-open.org/odata/ns/edm is a namespace that OData uses. var csdlStringNewNamespace = csdl.ToString(); parsed = SchemaReader.TryParse(new System.Xml.XmlReader[] { System.Xml.XmlReader.Create(new System.IO.StringReader(csdlStringNewNamespace)) }, out model, out errors); Assert.IsTrue(parsed, "parsed"); csdlStringNewNamespace = csdl.ToString().Replace(csdl.GetDefaultNamespace().NamespaceName, "http://schemas.microsoft.com/ado/2007/09/edm"); parsed = SchemaReader.TryParse(new System.Xml.XmlReader[] { System.Xml.XmlReader.Create(new System.IO.StringReader(csdlStringNewNamespace)) }, out model, out errors); Assert.IsFalse(parsed, "The parser should not support other invalid namespaces than http://docs.oasis-open.org/odata/ns/edm."); } }
public void ValidateAnnotationAttributeMustNotCollide() { const string csdl = @"<?xml version=""1.0"" encoding=""utf-16""?> <Schema Namespace=""Hot"" Alias=""Fuzz"" xmlns:Bogus=""http://bogus.com/schema"" xmlns=""http://docs.oasis-open.org/odata/ns/edm""> <EntityType Name=""Person"" Bogus:PropertyAnnotationAttribute=""Just kidding"" Bogus:PropertyAnnotationAttribute=""Just kidding""> <Key> <PropertyRef Name=""Id"" /> </Key> <Bogus:EntityTypeAnnotation Stuff=""Whatever"" /> <Property Name=""Id"" Type=""Int32"" Nullable=""false""/> </EntityType> </Schema>"; IEdmModel model; IEnumerable <EdmError> errors; bool parsed = SchemaReader.TryParse(new XmlReader[] { XmlReader.Create(new StringReader(csdl)) }, out model, out errors); Assert.IsFalse(parsed, "Should fail to parse."); Assert.IsTrue(errors.Count() != 0, "Should report a failure"); }