public void NonBoundCsdlSemanticsOperationPropertiesShouldBeCorrect()
{
var function = new CsdlFunction("Checkout", Enumerable.Empty <CsdlOperationParameter>(), new CsdlNamedTypeReference("Edm.String", false, testLocation), false /*isBound*/, null /*entitySetPath*/, true /*isComposable*/, null /*documentation*/, testLocation);
var semanticFunction = new CsdlSemanticsFunction(this.semanticSchema, function);
semanticFunction.IsBound.Should().BeFalse();
semanticFunction.Location().Should().Be(testLocation);
semanticFunction.Name.Should().Be("Checkout");
semanticFunction.Namespace.Should().Be("FQ.NS");
semanticFunction.ReturnType.Definition.Should().Be(EdmCoreModel.Instance.GetString(true).Definition);
semanticFunction.EntitySetPath.Should().BeNull();
semanticFunction.SchemaElementKind.Should().Be(EdmSchemaElementKind.Function);
semanticFunction.IsComposable.Should().BeTrue();
}
private IEnumerable <IEdmOperation> ComputeOperations()
{
List <IEdmOperation> operations = new List <IEdmOperation>();
foreach (CsdlOperation operation in this.schema.Operations)
{
if (operation is CsdlAction)
{
operations.Add(new CsdlSemanticsAction(this, (CsdlAction)operation));
}
else
{
CsdlFunction function = operation as CsdlFunction;
Debug.Assert(function != null, "function != null");
operations.Add(new CsdlSemanticsFunction(this, function));
}
}
return(operations);
}
public void NonBoundCsdlSemanticsOperationPropertiesShouldBeCorrect()
{
var function = new CsdlFunction(
"Checkout",
Enumerable.Empty <CsdlOperationParameter>(),
new CsdlOperationReturn(new CsdlNamedTypeReference("Edm.String", false, testLocation), testLocation),
false /*isBound*/,
null /*entitySetPath*/,
true /*isComposable*/,
testLocation);
var semanticFunction = new CsdlSemanticsFunction(this.semanticSchema, function);
Assert.False(semanticFunction.IsBound);
Assert.Equal(testLocation, semanticFunction.Location());
Assert.Equal("Checkout", semanticFunction.Name);
Assert.Equal("FQ.NS", semanticFunction.Namespace);
Assert.Equal("Edm.String", semanticFunction.ReturnType.Definition.FullTypeName());
Assert.Null(semanticFunction.EntitySetPath);
Assert.Equal(EdmSchemaElementKind.Function, semanticFunction.SchemaElementKind);
Assert.True(semanticFunction.IsComposable);
}
public CsdlSemanticsFunction(CsdlSemanticsSchema context, CsdlFunction function)
: base(context, function)
{
this.function = function;
}
public void ParseCsdlOperationWithActionAndFunctionWorksAsExpected()
{
string json = @"""Approval"": [
{
""$Kind"": ""Action"",
""$IsBound"": true,
""$Parameter"": [
{
""$Name"": ""binding"",
""$Type"": ""self.Order"",
""$Nullable"": true
}
]
},
{
""$Kind"": ""Function"",
""$Parameter"": [
{
""$Name"": ""Rating"",
""$Type"": ""Edm.Decimal"",
""$Precision"": 4,
""$Scale"": 1
}
],
""$ReturnType"": {
""$Type"": ""self.Product""
}
}
]";
IList <CsdlOperation> operations = ParseCsdlSchemaElement(json, SchemaJsonParser.TryParseCsdlOperationOverload);
Assert.NotNull(operations);
Assert.Equal(2, operations.Count);
// #1 CsdlAction
CsdlAction action = Assert.IsType <CsdlAction>(operations.First());
Assert.Equal("Approval", action.Name);
Assert.True(action.IsBound);
Assert.Null(action.EntitySetPath);
CsdlOperationParameter parameter = Assert.Single(action.Parameters);
Assert.Equal("binding", parameter.Name);
Assert.False(parameter.IsOptional);
Assert.Null(parameter.DefaultValue);
CsdlNamedTypeReference namedType = Assert.IsType <CsdlNamedTypeReference>(parameter.Type);
Assert.True(namedType.IsNullable);
Assert.Equal("self.Order", namedType.FullName);
Assert.Null(action.Return);
// #2 CsdlFunction
CsdlFunction function = Assert.IsType <CsdlFunction>(operations.Last());
Assert.Equal("Approval", function.Name);
Assert.False(function.IsBound);
Assert.Null(function.EntitySetPath);
parameter = Assert.Single(function.Parameters);
Assert.Equal("Rating", parameter.Name);
Assert.False(parameter.IsOptional);
Assert.Null(parameter.DefaultValue);
CsdlDecimalTypeReference decimalType = Assert.IsType <CsdlDecimalTypeReference>(parameter.Type);
Assert.False(decimalType.IsNullable);
Assert.Equal(4, decimalType.Precision.Value);
Assert.Equal(1, decimalType.Scale.Value);
Assert.NotNull(function.Return);
namedType = Assert.IsType <CsdlNamedTypeReference>(function.Return.ReturnType);
Assert.False(namedType.IsNullable);
Assert.Equal("self.Product", namedType.FullName);
}
public void ParseCsdlOperationForFunctionWithMembersWorksAsExpected()
{
string json = @"""CreatedEntities"": [
{
""$Kind"": ""Function"",
""$Parameter"": [
{
""$Name"": ""before"",
""$Type"": ""Edm.DateTimeOffset"",
""$Nullable"": true,
""$Precision"": 10
},
{
""$Name"": ""after"",
""$Type"": ""Edm.DateTimeOffset"",
""$Precision"": 9
}
],
""$ReturnType"": {
""$Collection"": true,
""$Type"": ""Edm.EntityType"",
""$Nullable"": true
},
""$IsComposable"": true
}
]";
IList <CsdlOperation> operations = ParseCsdlSchemaElement(json, SchemaJsonParser.TryParseCsdlOperationOverload);
Assert.NotNull(operations);
CsdlOperation operation = Assert.Single(operations);
CsdlFunction function = Assert.IsType <CsdlFunction>(operation);
Assert.Equal("CreatedEntities", function.Name);
Assert.False(function.IsBound);
Assert.True(function.IsComposable);
Assert.Null(function.EntitySetPath);
// Parameter
Assert.Equal(2, function.Parameters.Count());
CsdlOperationParameter parameter = function.Parameters.First(c => c.Name == "before");
Assert.False(parameter.IsOptional);
Assert.Null(parameter.DefaultValue);
CsdlTemporalTypeReference temporalType = Assert.IsType <CsdlTemporalTypeReference>(parameter.Type);
Assert.Equal(EdmPrimitiveTypeKind.DateTimeOffset, temporalType.Kind);
Assert.True(temporalType.IsNullable);
Assert.Equal(10, temporalType.Precision.Value);
parameter = function.Parameters.First(c => c.Name == "after");
Assert.False(parameter.IsOptional);
Assert.Null(parameter.DefaultValue);
temporalType = Assert.IsType <CsdlTemporalTypeReference>(parameter.Type);
Assert.Equal(EdmPrimitiveTypeKind.DateTimeOffset, temporalType.Kind);
Assert.False(temporalType.IsNullable);
Assert.Equal(9, temporalType.Precision.Value);
// ReturnType
Assert.NotNull(function.Return);
CsdlExpressionTypeReference expTypeRef = Assert.IsType <CsdlExpressionTypeReference>(operation.Return.ReturnType);
Assert.True(expTypeRef.IsNullable);
CsdlNamedTypeReference namedType = Assert.IsType <CsdlNamedTypeReference>(Assert.IsType <CsdlCollectionType>(expTypeRef.TypeExpression).ElementType);
Assert.True(namedType.IsNullable); // derived from collection
Assert.Equal("Edm.EntityType", namedType.FullName);
}
