public CsdlSemanticsEntitySetTests() { var referentialConstraints = new List<CsdlReferentialConstraint>(); var csdlNavigation = new CsdlNavigationProperty("Navigation", null, null, null, false, null, referentialConstraints, null, null); this.csdlEntityType = new CsdlEntityType("EntityType", null, false, false, false, null, Enumerable.Empty<CsdlProperty>(), new[] { csdlNavigation }, null, null); var goodBinding = new CsdlNavigationPropertyBinding("Navigation", "EntitySet", null, new CsdlLocation(1, 1)); this.csdlEntitySet = new CsdlEntitySet("EntitySet", "FQ.NS.EntityType", new[] { goodBinding }, null, null); this.csdlContainer = new CsdlEntityContainer("Container", null, new[] { this.csdlEntitySet }, Enumerable.Empty<CsdlSingleton>(), Enumerable.Empty<CsdlOperationImport>(), null, null); var derivedCsdlNavigation = new CsdlNavigationProperty("DerivedNavigation", null, null, null, false, null, referentialConstraints, null, null); var derivedCsdlEntityType = new CsdlEntityType("DerivedEntityType", "FQ.NS.EntityType", false, false, false, null, Enumerable.Empty<CsdlProperty>(), new[] { derivedCsdlNavigation }, null, null); var unrelatedCsdlEntityType = new CsdlEntityType("UnrelatedEntityType", null, false, false, false, null, Enumerable.Empty<CsdlProperty>(), Enumerable.Empty<CsdlNavigationProperty>(), null, null); var csdlSchema = new CsdlSchema("FQ.NS", null, null, new[] { this.csdlEntityType, derivedCsdlEntityType, unrelatedCsdlEntityType }, Enumerable.Empty<CsdlEnumType>(), Enumerable.Empty<CsdlOperation>(),Enumerable.Empty<CsdlTerm>(),Enumerable.Empty<CsdlEntityContainer>(),Enumerable.Empty<CsdlAnnotations>(), Enumerable.Empty<CsdlTypeDefinition>(), null, null); var csdlModel = new CsdlModel(); csdlModel.AddSchema(csdlSchema); var semanticModel = new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty<IEdmModel>()); this.semanticSchema = new CsdlSemanticsSchema(semanticModel, csdlSchema); this.semanticContainer = new CsdlSemanticsEntityContainer(this.semanticSchema, this.csdlContainer); this.semanticEntityType = semanticModel.FindType("FQ.NS.EntityType") as CsdlSemanticsEntityTypeDefinition; this.semanticEntityType.Should().NotBeNull(); this.navigationProperty = this.semanticEntityType.FindProperty("Navigation") as CsdlSemanticsNavigationProperty; this.navigationProperty.Should().NotBeNull(); }
public CsdlSemanticsNavigationPropertyTests() { var constraints = new[] { new CsdlReferentialConstraint("FK", "ID", null, null) }; this.collectionProperty = new CsdlNavigationProperty("Collection", "Collection(FQ.NS.EntityType)", null, "Reference", false, null, constraints, null, null); this.referenceProperty = new CsdlNavigationProperty("Reference", "FQ.NS.EntityType", false, null, false, null, Enumerable.Empty<CsdlReferentialConstraint>(), null, null); var navigationWithoutPartner = new CsdlNavigationProperty("WithoutPartner", "FQ.NS.EntityType", false, null, false, null, Enumerable.Empty<CsdlReferentialConstraint>(), null, null); var idProperty = new CsdlProperty("ID", new CsdlNamedTypeReference("Edm.Int32", false, null), false, null, null, null); var fkProperty = new CsdlProperty("FK", new CsdlNamedTypeReference("Edm.Int32", false, null), false, null, null, null); this.csdlEntityType = new CsdlEntityType("EntityType", null, false, false, false, new CsdlKey(new[] { new CsdlPropertyReference("ID", null) }, null), new[] { idProperty, fkProperty }, new[] { collectionProperty, referenceProperty, navigationWithoutPartner }, null, null); var csdlSchema = new CsdlSchema("FQ.NS", null, null, new[] { this.csdlEntityType }, Enumerable.Empty<CsdlEnumType>(), Enumerable.Empty<CsdlOperation>(),Enumerable.Empty<CsdlTerm>(),Enumerable.Empty<CsdlEntityContainer>(),Enumerable.Empty<CsdlAnnotations>(), Enumerable.Empty<CsdlTypeDefinition>(), null, null); var csdlModel = new CsdlModel(); csdlModel.AddSchema(csdlSchema); var semanticModel = new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty<IEdmModel>()); this.semanticEntityType = semanticModel.FindType("FQ.NS.EntityType") as CsdlSemanticsEntityTypeDefinition; this.semanticEntityType.Should().NotBeNull(); this.semanticCollectionNavigation = this.semanticEntityType.FindProperty("Collection") as CsdlSemanticsNavigationProperty; this.semanticReferenceNavigation = this.semanticEntityType.FindProperty("Reference") as CsdlSemanticsNavigationProperty; this.semanticNavigationWithoutPartner = this.semanticEntityType.FindProperty("WithoutPartner") as CsdlSemanticsNavigationProperty; this.semanticCollectionNavigation.Should().NotBeNull(); this.semanticReferenceNavigation.Should().NotBeNull(); this.semanticNavigationWithoutPartner.Should().NotBeNull(); }
public void EnsureFunctionImportFunctionPropertyIsUnresolvedFunction() { var functionImport = new CsdlFunctionImport("GetStuff", "FQ.NS.GetStuff", null /*entitySet*/, true /*includeInServiceDocument*/, null /*documentation*/, testLocation); var csdlEntityContainer = CsdlBuilder.EntityContainer("Container", operationImports: new CsdlOperationImport[] {functionImport}); var schema = CsdlBuilder.Schema("FQ.NS", csdlEntityContainers: new CsdlEntityContainer[] { csdlEntityContainer }); var csdlModel = new CsdlModel(); csdlModel.AddSchema(schema); var semanticSchema = new CsdlSemanticsSchema(new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty<IEdmModel>()), schema); CsdlSemanticsEntityContainer container = new CsdlSemanticsEntityContainer(semanticSchema, csdlEntityContainer); var imports = container.OperationImports().ToList(); imports.Should().HaveCount(1); var csdlFunctionImport = (IEdmFunctionImport)imports[0]; csdlFunctionImport.Name.Should().Be("GetStuff"); csdlFunctionImport.Operation.GetType().Should().Be(typeof(UnresolvedFunction)); var errors = csdlFunctionImport.Operation.As<BadElement>().Errors.ToList(); errors.Should().HaveCount(1); errors.First().ErrorMessage.Should().Be(Strings.Bad_UnresolvedOperation("FQ.NS.GetStuff")); csdlFunctionImport.Container.Name.Should().Be("Container"); csdlFunctionImport.Location().Should().Be(testLocation); csdlFunctionImport.ContainerElementKind.Should().Be(EdmContainerElementKind.FunctionImport); csdlFunctionImport.EntitySet.Should().BeNull(); csdlFunctionImport.IncludeInServiceDocument.Should().BeTrue(); csdlFunctionImport.Function.IsComposable.Should().BeFalse(); }
/// <summary> /// Constructor /// </summary> /// <param name="astModel">The raw CsdlModel.</param> /// <param name="annotationsManager">The IEdmDirectValueAnnotationsManager.</param> /// <param name="referencedModels">The IEdmModels to be referenced. if any element or namespce is not supposed to be include, you should have removed it before passing to this constructor.</param> public CsdlSemanticsModel(CsdlModel astModel, IEdmDirectValueAnnotationsManager annotationsManager, IEnumerable<IEdmModel> referencedModels) : base(referencedModels, annotationsManager) { this.astModel = astModel; this.SetEdmReferences(astModel.CurrentModelReferences); foreach (CsdlSchema schema in this.astModel.Schemata) { this.AddSchema(schema); } }
public CsdlSemanticsOperationTests() { this.csdlEntityType = new CsdlEntityType("EntityType", null, false, false, false, null, Enumerable.Empty<CsdlProperty>(), Enumerable.Empty<CsdlNavigationProperty>(), null, null); var csdlSchema = CsdlBuilder.Schema("FQ.NS", csdlStructuredTypes: new[] { this.csdlEntityType }); var csdlModel = new CsdlModel(); csdlModel.AddSchema(csdlSchema); var semanticModel = new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty<IEdmModel>()); this.semanticSchema = new CsdlSemanticsSchema(semanticModel, csdlSchema); this.testLocation = new CsdlLocation(1, 3); }
public static bool TryParse(IEnumerable<XmlReader> csdlReaders, out CsdlModel entityModel, out IEnumerable<EdmError> errors) { EdmUtil.CheckArgumentNull(csdlReaders, "csdlReaders"); CsdlParser parser = new CsdlParser(); int readerCount = 0; foreach (var inputReader in csdlReaders) { if (inputReader != null) { try { parser.AddReader(inputReader); } catch (XmlException e) { entityModel = null; errors = new EdmError[] { new EdmError(new CsdlLocation(e.LineNumber, e.LinePosition), EdmErrorCode.XmlError, e.Message) }; return false; } } else { entityModel = null; errors = new EdmError[] { new EdmError(null, EdmErrorCode.NullXmlReader, Edm.Strings.CsdlParser_NullXmlReader) }; return false; } readerCount++; } if (readerCount == 0) { entityModel = null; errors = new EdmError[] { new EdmError(null, EdmErrorCode.NoReadersProvided, Edm.Strings.CsdlParser_NoReadersProvided) }; return false; } bool success = parser.GetResult(out entityModel, out errors); if (!success) { entityModel = null; } return success; }
public void EnsureActionImportActionPropertyIsUnresolvedAction() { var actionImport = new CsdlActionImport("Action", "FQ.NS.Action", null /*entitySet*/, null /*documentation*/, testLocation); var csdlEntityContainer = CsdlBuilder.EntityContainer("Container", operationImports: new CsdlOperationImport[] { actionImport }); var schema = CsdlBuilder.Schema("FQ.NS", csdlEntityContainers: new CsdlEntityContainer[] { csdlEntityContainer }); var csdlModel = new CsdlModel(); csdlModel.AddSchema(schema); var semanticSchema = new CsdlSemanticsSchema(new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty<IEdmModel>()), schema); CsdlSemanticsEntityContainer container = new CsdlSemanticsEntityContainer(semanticSchema, csdlEntityContainer); var imports = container.OperationImports().ToList(); imports.Should().HaveCount(1); imports[0].Name.Should().Be("Action"); imports[0].Operation.GetType().Should().Be(typeof(UnresolvedAction)); var errors = imports[0].Operation.As<BadElement>().Errors.ToList(); errors.Should().HaveCount(1); errors.First().ErrorMessage.Should().Be(Strings.Bad_UnresolvedOperation("FQ.NS.Action")); imports[0].Container.Name.Should().Be("Container"); imports[0].Location().Should().Be(testLocation); imports[0].ContainerElementKind.Should().Be(EdmContainerElementKind.ActionImport); imports[0].EntitySet.Should().BeNull(); }
/// <summary> /// Constroctur /// </summary> /// <param name="mainCsdlModel">The main raw CsdlModel.</param> /// <param name="annotationsManager">The IEdmDirectValueAnnotationsManager.</param> /// <param name="referencedCsdlModels">The referenced raw CsdlModels.</param> public CsdlSemanticsModel(CsdlModel mainCsdlModel, IEdmDirectValueAnnotationsManager annotationsManager, IEnumerable<CsdlModel> referencedCsdlModels) : base(Enumerable.Empty<IEdmModel>(), annotationsManager) { this.astModel = mainCsdlModel; this.SetEdmReferences(astModel.CurrentModelReferences); // 1. build semantics for referenced models foreach (var tmp in referencedCsdlModels) { this.AddReferencedModel(new CsdlSemanticsModel(tmp, this.DirectValueAnnotationsManager, this)); } // 2. build semantics for current model foreach (var include in mainCsdlModel.CurrentModelReferences.SelectMany(s => s.Includes)) { this.SetNamespaceAlias(include.Namespace, include.Alias); } foreach (CsdlSchema schema in this.astModel.Schemata) { this.AddSchema(schema); } }
public void TryGetEntitySetWithBoundCsdlSemanticOperationParameterShouldReturnTrueAndHaveNoErrors() { var csdlEntityType = new CsdlEntityType("EntityType", null, false, false, false, null, Enumerable.Empty<CsdlProperty>(), Enumerable.Empty<CsdlNavigationProperty>(), null, null); var csdlSchema = CsdlBuilder.Schema("FQ.NS", csdlStructuredTypes: new[] { csdlEntityType }); var csdlModel = new CsdlModel(); csdlModel.AddSchema(csdlSchema); var semanticModel = new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty<IEdmModel>()); var semanticSchema = new CsdlSemanticsSchema(semanticModel, csdlSchema); var testLocation = new CsdlLocation(1, 3); var action = new CsdlAction( "Checkout", new CsdlOperationParameter[] { new CsdlOperationParameter("entity", new CsdlNamedTypeReference("FQ.NS.EntityType", false, testLocation), null, testLocation) }, new CsdlNamedTypeReference("Edm.String", false, testLocation), true /*isBound*/, "entity", null /*documentation*/, testLocation); var semanticAction = new CsdlSemanticsAction(semanticSchema, action); IEdmOperationParameter edmParameter; IEnumerable<IEdmNavigationProperty> navigationProperties; IEdmEntityType entityType; IEnumerable<EdmError> errors; semanticAction.TryGetRelativeEntitySetPath(semanticSchema.Model, out edmParameter, out navigationProperties, out entityType, out errors).Should().BeTrue(); edmParameter.Name.Should().Be("entity"); navigationProperties.Should().BeEmpty(); entityType.FullName().Should().Be("FQ.NS.EntityType"); errors.Should().BeEmpty(); }
/// <summary> /// Parse Edm xml doc into CsdlModel, error messages are stored in this.errors. /// </summary> /// <param name="edmxVersion">The edmxVersion out.</param> /// <param name="csdlModel">The CsdlModel out.</param> /// <returns>True if succeeded.</returns> private bool TryParseEdmxFileToCsdlModel(out Version edmxVersion, out CsdlModel csdlModel) { edmxVersion = null; csdlModel = null; try { // Advance to root element if (this.reader.NodeType != XmlNodeType.Element) { while (this.reader.Read() && this.reader.NodeType != XmlNodeType.Element) { } } // There must be a root element for all current artifacts if (this.reader.EOF) { this.RaiseEmptyFile(); return false; } if (this.reader.LocalName != CsdlConstants.Element_Edmx || !CsdlConstants.SupportedEdmxNamespaces.TryGetValue(this.reader.NamespaceURI, out edmxVersion)) { this.RaiseError(EdmErrorCode.UnexpectedXmlElement, Edm.Strings.XmlParser_UnexpectedRootElement(this.reader.Name, CsdlConstants.Element_Edmx)); return false; } this.ParseEdmxElement(edmxVersion); IEnumerable<EdmError> err; if (!this.csdlParser.GetResult(out csdlModel, out err)) { this.errors.AddRange(err); if (this.HasIntolerableError()) { return false; } } } catch (XmlException e) { this.errors.Add(new EdmError(new CsdlLocation(this.source, e.LineNumber, e.LinePosition), EdmErrorCode.XmlError, e.Message)); return false; } csdlModel.AddCurrentModelReferences(this.edmReferences); return true; }
private static CsdlSemanticsSchema CreateCsdlSemanticsSchema(CsdlEntityContainer csdlEntityContainer, params CsdlOperation[] operations) { var csdlEntityType = new CsdlEntityType("EntityType", null, false, false, false, null, new Collection<CsdlProperty>(), new BindingList<CsdlNavigationProperty>(), null, null); var schema = CsdlBuilder.Schema("FQ.NS", csdlOperations: operations, csdlEntityContainers: new CsdlEntityContainer[] { csdlEntityContainer }, csdlStructuredTypes: new CsdlStructuredType[] { csdlEntityType }); var csdlModel = new CsdlModel(); csdlModel.AddSchema(schema); var semanticSchema = new CsdlSemanticsSchema(new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty<IEdmModel>()), schema); return semanticSchema; }
public bool GetResult(out CsdlModel model, out IEnumerable<EdmError> errors) { model = this.result; errors = this.errorsList; return this.success; }
/// <summary> /// Constructor for creating a referenced model, is private and only called by the above constructor. /// </summary> /// <param name="referencedCsdlModel">The referenced raw CsdlModel.</param> /// <param name="annotationsManager">The IEdmDirectValueAnnotationsManager.</param> /// <param name="mainCsdlSemanticsModel">The CsdlSemanticsModel that will reference this new CsdlSemanticsModel. </param> private CsdlSemanticsModel(CsdlModel referencedCsdlModel, IEdmDirectValueAnnotationsManager annotationsManager, CsdlSemanticsModel mainCsdlSemanticsModel) : base(Enumerable.Empty<IEdmModel>(), annotationsManager) { this.mainEdmModel = mainCsdlSemanticsModel; Debug.Assert(referencedCsdlModel.ParentModelReferences.Any(), "referencedCsdlModel.ParentModelReferences.Any()"); this.astModel = referencedCsdlModel; this.SetEdmReferences(referencedCsdlModel.CurrentModelReferences); foreach (var tmp in referencedCsdlModel.ParentModelReferences.SelectMany(s => s.Includes)) { string includeNs = tmp.Namespace; if (!referencedCsdlModel.Schemata.Any(s => s.Namespace == includeNs)) { // edmx:include must be an existing namespace // TODO: REF throw exception: should include a namespace that exists in referenced model. } } foreach (var tmp in referencedCsdlModel.CurrentModelReferences.SelectMany(s => s.Includes)) { // in any referenced model, alias may point to a further referenced model, now make alias available: this.SetNamespaceAlias(tmp.Namespace, tmp.Alias); } foreach (var schema in referencedCsdlModel.Schemata) { string schemaNamespace = schema.Namespace; IEdmInclude edmInclude = referencedCsdlModel.ParentModelReferences.SelectMany(s => s.Includes).FirstOrDefault(s => s.Namespace == schemaNamespace); if (edmInclude != null) { this.AddSchema(schema, false /*addAnnotations*/); } // TODO: REF add annotations } }