public void TestBooleanConstant()
{
var constant = new EdmBooleanConstant(true);
Assert.AreEqual(EdmValueKind.Boolean, constant.ValueKind, "Invalid value kind.");
this.ValidateEdmValueKindRoundTrip(EdmValueKind.Boolean, EdmCoreModel.Instance.GetBoolean(true), constant);
}
private static void SetCapabilitiesAnnotation(this EdmModel model, IEdmVocabularyAnnotatable target, IEdmValueTerm term, bool value)
{
var expression = new EdmBooleanConstant(value);
var annotation = new EdmAnnotation(target, term, expression);
annotation.SetSerializationLocation(model, target.ToSerializationLocation());
model.AddVocabularyAnnotation(annotation);
}
private static void SetComputedAnnotation(EdmModel model, IEdmProperty target)
{
// when 'target' is <Key> property, V4's 'Computed' also has the meaning of OData V3's 'Identity'.
var val = new EdmBooleanConstant(value: true);
var annotation = new EdmAnnotation(target, CoreVocabularyModel.ComputedTerm, val);
annotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline);
model.SetVocabularyAnnotation(annotation);
}
public static void SetComputedAnnotation(EdmModel model, IEdmProperty target)
{
EdmUtil.CheckArgumentNull(model, "model");
EdmUtil.CheckArgumentNull(target, "target");
IEdmBooleanConstantExpression val = new EdmBooleanConstant(true);
IEdmValueTerm term = CoreVocabularyModel.ComputedTerm;
Debug.Assert(term != null, "term!=null");
EdmAnnotation annotation = new EdmAnnotation(target, term, val);
annotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline);
model.SetVocabularyAnnotation(annotation);
}
public void BuildEdmExpression_Works_ForBooleanValue(string value, bool expected)
{
// Arrange
IEdmType edmType = EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Boolean);
// Act
IEdmExpression exp = IEdmTermExtensions.BuildEdmExpression(edmType, value);
// Assert
Assert.NotNull(exp);
EdmBooleanConstant constant = Assert.IsType <EdmBooleanConstant>(exp);
Assert.Equal(expected, constant.Value);
}
public async Task <IEdmModel> GetModelAsync(ModelContext context, CancellationToken cancellationToken)
{
var model = await InnerHandler.GetModelAsync(context, cancellationToken);
var trueConstant = new EdmBooleanConstant(true);
// Set computed annotation
var tripType = (EdmEntityType)model.SchemaElements.Single(e => e.Name == "Trip");
var trackGuidProperty = tripType.DeclaredProperties.Single(prop => prop.Name == "TrackGuid");
var timeStampValueProp = model.EntityContainer.FindEntitySet("Airlines").EntityType().FindProperty("TimeStampValue");
var computedTerm = new EdmTerm("Org.OData.Core.V1", "Computed", EdmPrimitiveTypeKind.Boolean);
var anno1 = new EdmVocabularyAnnotation(trackGuidProperty, computedTerm, trueConstant);
var anno2 = new EdmVocabularyAnnotation(timeStampValueProp, computedTerm, trueConstant);
((EdmModel)model).SetVocabularyAnnotation(anno1);
((EdmModel)model).SetVocabularyAnnotation(anno2);
var immutableTerm = new EdmTerm("Org.OData.Core.V1", "Immutable", EdmPrimitiveTypeKind.Boolean);
var orderType = (EdmEntityType)model.SchemaElements.Single(e => e.Name == "Order");
var orderProp1 = orderType.DeclaredProperties.Single(prop => prop.Name == "ComputedProperty");
var orderProp2 = orderType.DeclaredProperties.Single(prop => prop.Name == "ImmutableProperty");
var orderProp3 = orderType.DeclaredProperties.Single(prop => prop.Name == "ComputedOrderDetail");
var orderProp4 = orderType.DeclaredProperties.Single(prop => prop.Name == "ImmutableOrderDetail");
((EdmModel)model).SetVocabularyAnnotation(new EdmVocabularyAnnotation(orderProp1, computedTerm, trueConstant));
((EdmModel)model).SetVocabularyAnnotation(new EdmVocabularyAnnotation(orderProp2, immutableTerm, trueConstant));
((EdmModel)model).SetVocabularyAnnotation(new EdmVocabularyAnnotation(orderProp3, computedTerm, trueConstant));
((EdmModel)model).SetVocabularyAnnotation(new EdmVocabularyAnnotation(orderProp4, immutableTerm, trueConstant));
var orderDetailType = (EdmComplexType)model.SchemaElements.Single(e => e.Name == "OrderDetail");
var detailProp1 = orderDetailType.DeclaredProperties.Single(prop => prop.Name == "ComputedProperty");
var detailProp2 = orderDetailType.DeclaredProperties.Single(prop => prop.Name == "ImmutableProperty");
((EdmModel)model).SetVocabularyAnnotation(new EdmVocabularyAnnotation(detailProp1, computedTerm, trueConstant));
((EdmModel)model).SetVocabularyAnnotation(new EdmVocabularyAnnotation(detailProp2, immutableTerm, trueConstant));
var personType = (EdmEntityType)model.SchemaElements.Single(e => e.Name == "Person");
var type = personType.FindProperty("PersonId").Type;
var isNullableField = typeof(EdmTypeReference).GetField("isNullable", BindingFlags.Instance | BindingFlags.NonPublic);
if (isNullableField != null)
{
isNullableField.SetValue(type, false);
}
return(model);
}
public void GetDefaultValueExpression_Works_ForTermFromCoreVocabularyModel()
{
// Arrange
IEdmTerm term = CoreVocabularyModel.Instance.FindTerm("Org.OData.Core.V1.PositionalInsert");
Assert.NotNull(term);
Assert.NotNull(term.DefaultValue);
Assert.Equal("true", term.DefaultValue);
// Act
IEdmExpression exp = term.GetDefaultValueExpression();
EdmBooleanConstant constant = Assert.IsType <EdmBooleanConstant>(exp);
Assert.True(constant.Value);
}
public void CreatePathItemsReturnsForEscapeFunctionModel(bool enableEscaped, bool hasEscapedAnnotation, bool isComposable, string expected)
{
// Arrange
EdmModel model = new EdmModel();
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
model.AddElement(customer);
EdmFunction function = new EdmFunction("NS", "MyFunction", EdmCoreModel.Instance.GetString(false), true, null, isComposable);
function.AddParameter("entity", new EdmEntityTypeReference(customer, false));
function.AddParameter("param", EdmCoreModel.Instance.GetString(false));
model.AddElement(function);
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
EdmEntitySet customers = new EdmEntitySet(container, "Customers", customer);
container.AddElement(customers);
model.AddElement(container);
if (hasEscapedAnnotation)
{
IEdmBooleanConstantExpression booleanConstant = new EdmBooleanConstant(true);
IEdmTerm term = CommunityVocabularyModel.UrlEscapeFunctionTerm;
EdmVocabularyAnnotation annotation = new EdmVocabularyAnnotation(function, term, booleanConstant);
annotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline);
model.SetVocabularyAnnotation(annotation);
}
OpenApiConvertSettings settings = new OpenApiConvertSettings
{
EnableUriEscapeFunctionCall = enableEscaped,
AddSingleQuotesForStringParameters = true,
};
ODataContext context = new ODataContext(model, settings);
// Act
var pathItems = context.CreatePathItems();
// Assert
Assert.NotNull(pathItems);
Assert.Equal(4, pathItems.Count);
Assert.Contains("/Customers", pathItems.Keys);
Assert.Contains("/Customers/$count", pathItems.Keys);
Assert.Contains("/Customers({ID})", pathItems.Keys);
Assert.Contains(expected, pathItems.Keys);
}
private static IEdmModel GetEdmModel(EdmVocabularyAnnotationSerializationLocation location, bool supported)
{
EdmModel model = new EdmModel();
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
model.AddElement(container);
IEdmTerm term = model.FindTerm(CapabilitiesConstants.KeyAsSegmentSupported);
Assert.NotNull(term);
IEdmBooleanConstantExpression boolean = new EdmBooleanConstant(supported);
EdmVocabularyAnnotation annotation = new EdmVocabularyAnnotation(container, term, boolean);
annotation.SetSerializationLocation(model, location);
model.SetVocabularyAnnotation(annotation);
return(model);
}
public void EdmBooleanConstant()
{
var e = new EdmBooleanConstant(true);
Assert.AreEqual(EdmExpressionKind.BooleanConstant, e.ExpressionKind, "e.ExpressionKind");
Assert.IsNull(e.Type, "e.Type");
Assert.AreEqual(true, e.Value, "e.Value");
e = new EdmBooleanConstant(EdmCoreModel.Instance.GetBinary(true, null, true), false);
Assert.AreEqual(true, e.Type.IsNullable, "e.Type.IsNullable");
Assert.AreEqual(true, e.Type.AsBinary().IsUnbounded, "e.Type.AsBinary().isUnbounded");
Assert.AreEqual(false, e.Value, "e.Value");
e = new EdmBooleanConstant(null, true);
Assert.IsNull(e.Type, "e.Type");
Assert.IsFalse(e.IsBad(), "Expression not bad.");
Assert.AreEqual(0, e.Errors().Count(), "Expression has no errors");
}
public void GetDefaultValueExpression_Works_ForTermWithOrWithoutDefaultValue()
{
// Arrange
IEdmTypeReference typeRef = EdmCoreModel.Instance.GetBoolean(true);
EdmTerm term1 = new EdmTerm("NS", "MyTerm", typeRef);
EdmTerm term2 = new EdmTerm("NS", "MyTerm", typeRef, null, "true");
// Act & Assert
IEdmExpression exp1 = term1.GetDefaultValueExpression();
Assert.Null(exp1);
IEdmExpression exp2 = term2.GetDefaultValueExpression();
Assert.NotNull(exp2);
EdmBooleanConstant constant = Assert.IsType <EdmBooleanConstant>(exp2);
Assert.True(constant.Value);
}
