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 CsdlSemanticsPrimitiveTypeReference(CsdlSemanticsSchema schema, CsdlPrimitiveTypeReference reference)
: base(reference)
{
this.schema = schema;
this.Reference = reference;
this.definition = EdmCoreModel.Instance.GetPrimitiveType(this.Reference.Kind);
}
public CsdlSemanticsRecordExpression(CsdlRecordExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression)
{
this.declaredTypeCache = new Cache<CsdlSemanticsRecordExpression, IEdmStructuredTypeReference>();
this.propertiesCache = new Cache<CsdlSemanticsRecordExpression, IEnumerable<IEdmPropertyConstructor>>();
this.expression = expression;
this.bindingContext = bindingContext;
}
public CsdlSemanticsApplyExpression(CsdlApplyExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema)
: base(schema, expression)
{
this.expression = expression;
this.bindingContext = bindingContext;
this.schema = schema;
}
public CsdlSemanticsPropertyReferenceExpression(CsdlPropertyReferenceExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression)
{
this.baseCache = new Cache<CsdlSemanticsPropertyReferenceExpression, IEdmExpression>();
this.elementCache = new Cache<CsdlSemanticsPropertyReferenceExpression, IEdmProperty>();
this.expression = expression;
this.bindingContext = bindingContext;
}
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();
}
public CsdlSemanticsAssertTypeExpression(CsdlAssertTypeExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression)
{
this.operandCache = new Cache<CsdlSemanticsAssertTypeExpression, IEdmExpression>();
this.typeCache = new Cache<CsdlSemanticsAssertTypeExpression, IEdmTypeReference>();
this.expression = expression;
this.bindingContext = bindingContext;
}
public CsdlSemanticsCollectionExpression(CsdlCollectionExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression)
{
this.declaredTypeCache = new Cache<CsdlSemanticsCollectionExpression, IEdmTypeReference>();
this.elementsCache = new Cache<CsdlSemanticsCollectionExpression, IEnumerable<IEdmExpression>>();
this.expression = expression;
this.bindingContext = bindingContext;
}
public CsdlSemanticsApplyExpression(CsdlApplyExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression)
{
this.appliedFunctionCache = new Cache<CsdlSemanticsApplyExpression, IEdmExpression>();
this.argumentsCache = new Cache<CsdlSemanticsApplyExpression, IEnumerable<IEdmExpression>>();
this.expression = expression;
this.bindingContext = bindingContext;
this.schema = schema;
}
public CsdlSemanticsLabeledExpression(string name, CsdlExpressionBase element, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(element)
{
this.expressionCache = new Cache<CsdlSemanticsLabeledExpression, IEdmExpression>();
this.name = name;
this.sourceElement = element;
this.bindingContext = bindingContext;
this.schema = schema;
}
public CsdlSemanticsIfExpression(CsdlIfExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression)
{
this.testCache = new Cache<CsdlSemanticsIfExpression, IEdmExpression>();
this.ifTrueCache = new Cache<CsdlSemanticsIfExpression, IEdmExpression>();
this.ifFalseCache = new Cache<CsdlSemanticsIfExpression, IEdmExpression>();
this.expression = expression;
this.bindingContext = bindingContext;
}
protected CsdlSemanticsVocabularyAnnotation(CsdlSemanticsSchema schema, IEdmVocabularyAnnotatable targetContext, CsdlSemanticsAnnotations annotationsContext, CsdlAnnotation annotation, string qualifier)
: base(annotation)
{
this.schema = schema;
this.Annotation = annotation;
this.qualifier = qualifier ?? annotation.Qualifier;
this.targetContext = targetContext;
this.annotationsContext = annotationsContext;
}
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 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();
}
public CsdlSemanticsLabeledExpressionReferenceExpression(CsdlLabeledExpressionReferenceExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema)
: base(schema, expression)
{
this.expression = expression;
this.bindingContext = bindingContext;
}
protected CsdlSemanticsStructuredTypeDefinition(CsdlSemanticsSchema context, CsdlStructuredType type)
: base(type)
{
this.context = context;
}
public CsdlSemanticsFunction(CsdlSemanticsSchema context, CsdlFunction function)
: base(context, function)
{
this.function = function;
}
public CsdlSemanticsIsTypeExpression(CsdlIsTypeExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema)
: base(schema, expression)
{
this.expression = expression;
this.bindingContext = bindingContext;
}
public CsdlSemanticsOperation(CsdlSemanticsSchema context, CsdlOperation operation)
: base(operation)
{
this.Context = context;
this.operation = operation;
}
public CsdlSemanticsValueTerm(CsdlSemanticsSchema context, CsdlValueTerm valueTerm)
: base(valueTerm)
{
this.Context = context;
this.valueTerm = valueTerm;
}
public CsdlSemanticsComplexTypeDefinition(CsdlSemanticsSchema context, CsdlComplexType complex)
: base(context, complex)
{
this.complex = complex;
}
public CsdlSemanticsBooleanConstantExpression(CsdlConstantExpression expression, CsdlSemanticsSchema schema) : base(schema, expression)
{
this.valueCache = new Cache<CsdlSemanticsBooleanConstantExpression, bool>();
this.errorsCache = new Cache<CsdlSemanticsBooleanConstantExpression, IEnumerable<EdmError>>();
this.expression = expression;
}
public CsdlSemanticsCollectionTypeDefinition(CsdlSemanticsSchema schema, CsdlCollectionType collection) : base(collection)
{
this.elementTypeCache = new Cache<CsdlSemanticsCollectionTypeDefinition, IEdmTypeReference>();
this.collection = collection;
this.schema = schema;
}
public CsdlSemanticsEntityContainer(CsdlSemanticsSchema context, CsdlEntityContainer entityContainer) : base(entityContainer)
{
this.elementsCache = new Cache<CsdlSemanticsEntityContainer, IEnumerable<IEdmEntityContainerElement>>();
this.associationSetsCache = new Cache<CsdlSemanticsEntityContainer, IEnumerable<CsdlSemanticsAssociationSet>>();
this.associationSetMappingsCache = new Cache<CsdlSemanticsEntityContainer, Dictionary<IEdmAssociation, IEnumerable<CsdlSemanticsAssociationSet>>>();
this.entitySetDictionaryCache = new Cache<CsdlSemanticsEntityContainer, Dictionary<string, IEdmEntitySet>>();
this.functionImportsDictionaryCache = new Cache<CsdlSemanticsEntityContainer, Dictionary<string, object>>();
this.errorsCache = new Cache<CsdlSemanticsEntityContainer, IEnumerable<EdmError>>();
this.extendsCache = new Cache<CsdlSemanticsEntityContainer, IEdmEntityContainer>();
this.context = context;
this.entityContainer = entityContainer;
}
public CsdlSemanticsNamedTypeReference(CsdlSemanticsSchema schema, CsdlNamedTypeReference reference)
: base(reference)
{
this.schema = schema;
this.reference = reference;
}
/// <summary>
/// Initializes a new instance of the <see cref="CsdlSemanticsAction"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="action">The action.</param>
public CsdlSemanticsAction(CsdlSemanticsSchema context, CsdlAction action)
: base(context, action)
{
}
public CsdlSemanticsTimeOfDayConstantExpression(CsdlConstantExpression expression, CsdlSemanticsSchema schema)
: base(schema, expression)
{
this.expression = expression;
}
public CsdlSemanticsFunctionReferenceExpression(CsdlFunctionReferenceExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression)
{
this.referencedCache = new Cache<CsdlSemanticsFunctionReferenceExpression, IEdmFunction>();
this.expression = expression;
this.bindingContext = bindingContext;
}
protected CsdlSemanticsStructuredTypeDefinition(CsdlSemanticsSchema context, CsdlStructuredType type) : base(type)
{
this.declaredPropertiesCache = new Cache<CsdlSemanticsStructuredTypeDefinition, List<IEdmProperty>>();
this.propertiesDictionaryCache = new Cache<CsdlSemanticsStructuredTypeDefinition, IDictionary<string, IEdmProperty>>();
this.context = context;
}
public CsdlSemanticsStringTypeReference(CsdlSemanticsSchema schema, CsdlStringTypeReference reference)
: base(schema, reference)
{
}
