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