private IEdmModel GetEdmModel()
{
EdmModel model = new EdmModel();
EdmEntityContainer container = new EdmEntityContainer("NS", "Name");
model.AddElement(container);
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmTypeReference parameterType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
container.AddFunctionImport(new EdmFunction("NS", "FunctionWithoutParams", returnType));
var functionWithOneParam = new EdmFunction("NS", "FunctionWithOneParam", returnType);
functionWithOneParam.AddParameter("Parameter", parameterType);
container.AddFunctionImport(functionWithOneParam);
var functionWithMultipleParams = new EdmFunction("NS", "FunctionWithMultipleParams", returnType);
functionWithMultipleParams.AddParameter("Parameter1", parameterType);
functionWithMultipleParams.AddParameter("Parameter2", parameterType);
functionWithMultipleParams.AddParameter("Parameter3", parameterType);
container.AddFunctionImport(functionWithMultipleParams);
container.AddFunctionImport(new EdmFunction("NS", "FunctionWithOverloads", returnType));
var functionWithOverloads2 = new EdmFunction("NS", "FunctionWithOverloads", returnType);
functionWithOverloads2.AddParameter("Parameter", parameterType);
container.AddFunctionImport(functionWithOverloads2);
var functionWithOverloads3 = new EdmFunction("NS", "FunctionWithOverloads", returnType);
functionWithOverloads3.AddParameter("Parameter1", parameterType);
functionWithOverloads3.AddParameter("Parameter2", parameterType);
functionWithOverloads3.AddParameter("Parameter3", parameterType);
container.AddFunctionImport(functionWithOverloads3);
return model;
}
public void DuplicateFunctionsUnBoundFunctionsWithSameNameWhereBindingTypeDifferentonNullabilityAndSameParametersShouldError()
{
var edmFunction = new EdmFunction("n.s", "GetStuff", EdmCoreModel.Instance.GetString(true), true /*isBound*/, null /*entitySetPath*/, false /*isComposable*/);
edmFunction.AddParameter("bindingParameter", EdmCoreModel.Instance.GetInt16(true));
edmFunction.AddParameter("differentName", EdmCoreModel.Instance.GetInt16(true));
var edmFunction2 = new EdmFunction("n.s", "GetStuff", EdmCoreModel.Instance.GetString(true), true /*isBound*/, null /*entitySetPath*/, false /*isComposable*/);
edmFunction2.AddParameter("bindingParameter", EdmCoreModel.Instance.GetInt16(true));
edmFunction2.AddParameter("otherParameter", EdmCoreModel.Instance.GetInt16(false));
EdmModel model = new EdmModel();
model.AddElement(edmFunction);
model.AddElement(edmFunction2);
ValidateError(model, EdmErrorCode.DuplicateFunctions, Strings.EdmModel_Validator_Semantic_ModelDuplicateBoundFunctionParameterTypes("n.s.GetStuff"));
}
public void DuplicateBoundFunctionOverloadsSameParameterNamesShouldError()
{
var edmFunction = new EdmFunction("n.s", "GetStuff", EdmCoreModel.Instance.GetString(true), true /*isBound*/, null /*entitySetPath*/, false /*isComposable*/);
edmFunction.AddParameter("bindingParameter", EdmCoreModel.Instance.GetInt32(true));
edmFunction.AddParameter("param1", EdmCoreModel.Instance.GetInt32(true));
var edmFunction2 = new EdmFunction("n.s", "GetStuff", EdmCoreModel.Instance.GetInt16(true), true /*isBound*/, null /*entitySetPath*/, false /*isComposable*/);
edmFunction2.AddParameter("bindingParameter", EdmCoreModel.Instance.GetInt32(true));
edmFunction2.AddParameter("param1", EdmCoreModel.Instance.GetInt16(true));
EdmModel model = new EdmModel();
model.AddElement(edmFunction);
model.AddElement(edmFunction2);
ValidateError(model, EdmErrorCode.DuplicateFunctions, Strings.EdmModel_Validator_Semantic_ModelDuplicateBoundFunctionParameterNames("n.s.GetStuff"));
}
public static IEdmModel MultipleSchemasWithDifferentNamespacesEdm()
{
var namespaces = new string[]
{
"FindMethodsTestModelBuilder.MultipleSchemasWithDifferentNamespaces.first",
"FindMethodsTestModelBuilder.MultipleSchemasWithDifferentNamespaces.second"
};
var model = new EdmModel();
foreach (var namespaceName in namespaces)
{
var entityType1 = new EdmEntityType(namespaceName, "validEntityType1");
entityType1.AddKeys(entityType1.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
var entityType2 = new EdmEntityType(namespaceName, "VALIDeNTITYtYPE2");
entityType2.AddKeys(entityType2.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
var entityType3 = new EdmEntityType(namespaceName, "VALIDeNTITYtYPE3");
entityType3.AddKeys(entityType3.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
entityType1.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {Name = "Mumble", Target = entityType2, TargetMultiplicity = EdmMultiplicity.Many});
var complexType = new EdmComplexType(namespaceName, "ValidNameComplexType1");
complexType.AddStructuralProperty("aPropertyOne", new EdmComplexTypeReference(complexType, false));
model.AddElements(new IEdmSchemaElement[] { entityType1, entityType2, entityType3, complexType });
var function1 = new EdmFunction(namespaceName, "ValidFunction1", EdmCoreModel.Instance.GetSingle(false));
var function2 = new EdmFunction(namespaceName, "ValidFunction1", EdmCoreModel.Instance.GetSingle(false));
function2.AddParameter("param1", new EdmEntityTypeReference(entityType1, false));
var function3 = new EdmFunction(namespaceName, "ValidFunction1", EdmCoreModel.Instance.GetSingle(false));
function3.AddParameter("param1", EdmCoreModel.Instance.GetSingle(false));
model.AddElements(new IEdmSchemaElement[] {function1, function2, function3});
}
return model;
}
public void FunctionImportShouldProduceCorrectFullyQualifiedNameAndNotHaveParameters()
{
var function = new EdmFunction("d.s", "testFunction", EdmCoreModel.Instance.GetString(true));
function.AddParameter("param1", EdmCoreModel.Instance.GetString(false));
var functionImport = new EdmFunctionImport(new EdmEntityContainer("d.s", "container"), "testFunction", function);
EdmUtil.FullyQualifiedName(functionImport).Should().Be("d.s.container/testFunction");
}
public void TryMatch_ReturnTrue_IfSameUnboundFunction()
{
// Arrange
IEdmModel model = new Mock<IEdmModel>().Object;
IEdmEntityType returnType = new Mock<IEdmEntityType>().Object;
EdmEntityContainer container = new EdmEntityContainer("NS", "Container");
EdmFunction func = new EdmFunction("NS", "Function", new EdmEntityTypeReference(returnType, isNullable: false));
func.AddParameter("Parameter1", EdmCoreModel.Instance.GetInt32(isNullable: false));
func.AddParameter("Parameter2", EdmCoreModel.Instance.GetInt32(isNullable: false));
EdmFunctionImport function = new EdmFunctionImport(container, "Function", func);
Dictionary<string, string> parameterValues = new Dictionary<string, string>
{
{ "Parameter1", "1" },
{ "Parameter2", "2" }
};
Dictionary<string, string> parameterMappings = new Dictionary<string, string>
{
{ "Parameter1", "{param1}" },
{ "Parameter2", "{param2}" }
};
UnboundFunctionPathSegment segment = new UnboundFunctionPathSegment(function, model, parameterValues);
UnboundFunctionPathSegmentTemplate template = new UnboundFunctionPathSegmentTemplate(
new UnboundFunctionPathSegment(function, model, parameterMappings));
// Act
Dictionary<string, object> values = new Dictionary<string,object>();
bool result = template.TryMatch(segment, values);
// Assert
Assert.True(result);
Assert.Equal(4, values.Count);
Assert.Equal("1", values["param1"]);
Assert.Equal("2", values["param2"]);
Assert.Equal(1, (values[ODataParameterValue.ParameterValuePrefix + "param1"] as ODataParameterValue).Value);
Assert.Equal(2, (values[ODataParameterValue.ParameterValuePrefix + "param2"] as ODataParameterValue).Value);
}
public void DuplicateFunctionOverloadsWithDifferentBindingTypesAndSameNameWithDifferentReturnTypesShouldNotError()
{
var edmFunction = new EdmFunction("n.s", "GetStuff", EdmCoreModel.Instance.GetString(true), true /*isBound*/, null /*entitySetPath*/, false /*isComposable*/);
edmFunction.AddParameter("bindingParameter", EdmCoreModel.Instance.GetInt16(true));
var edmFunction2 = new EdmFunction("n.s", "GetStuff", EdmCoreModel.Instance.GetInt16(true), true /*isBound*/, null /*entitySetPath*/, false /*isComposable*/);
edmFunction2.AddParameter("bindingParameter", EdmCoreModel.Instance.GetInt32(true));
EdmModel model = new EdmModel();
model.AddElement(edmFunction);
model.AddElement(edmFunction2);
ValidateNoError(model);
}
public void EdmFunctionConstructorShouldHaveSpecifiedConstructorValues()
{
var entitySetPath = new EdmPathExpression("Param1/Nav");
var edmFunction = new EdmFunction(defaultNamespaceName, checkout, this.boolType, true, entitySetPath, true /*IsComposable*/);
edmFunction.AddParameter(new EdmOperationParameter(edmFunction, "Param1", new EdmEntityTypeReference(personType, false)));
edmFunction.Namespace.Should().Be(defaultNamespaceName);
edmFunction.Name.Should().Be(checkout);
edmFunction.ReturnType.Should().Be(this.boolType);
edmFunction.EntitySetPath.Should().Be(entitySetPath);
edmFunction.IsBound.Should().BeTrue();
edmFunction.SchemaElementKind.Should().Be(EdmSchemaElementKind.Function);
edmFunction.IsComposable.Should().BeTrue();
}
private IEdmModel CreateTestModel()
{
EdmModel model = new EdmModel();
EdmEntityContainer defaultContainer = new EdmEntityContainer("TestModel", "Default");
model.AddElement(defaultContainer);
var productType = new EdmEntityType("TestModel", "Product");
EdmStructuralProperty idProperty = new EdmStructuralProperty(productType, "Id", EdmCoreModel.Instance.GetInt32(false));
productType.AddProperty(idProperty);
productType.AddKeys(idProperty);
productType.AddProperty(new EdmStructuralProperty(productType, "Name", EdmCoreModel.Instance.GetString(true)));
model.AddElement(productType);
var customerType = new EdmEntityType("TestModel", "Customer");
idProperty = new EdmStructuralProperty(customerType, "Id", EdmCoreModel.Instance.GetInt32(false));
customerType.AddProperty(idProperty);
customerType.AddKeys(idProperty);
customerType.AddProperty(new EdmStructuralProperty(customerType, "Name", EdmCoreModel.Instance.GetString(true)));
model.AddElement(productType);
defaultContainer.AddEntitySet("Products", productType);
defaultContainer.AddEntitySet("Customers", customerType);
defaultContainer.AddSingleton("SingleProduct", productType);
defaultContainer.AddSingleton("SingleCustomer", customerType);
EdmAction action = new EdmAction("TestModel", "SimpleAction", null/*returnType*/, false /*isBound*/, null /*entitySetPath*/);
model.AddElement(action);
defaultContainer.AddActionImport("SimpleActionImport", action);
EdmFunction function1 = new EdmFunction("TestModel", "SimpleFunction1", EdmCoreModel.Instance.GetInt32(false), false /*isbound*/, null, true);
function1.AddParameter("p1", EdmCoreModel.Instance.GetInt32(false));
defaultContainer.AddFunctionImport("SimpleFunctionImport1", function1);
EdmFunction function2 = new EdmFunction("TestModel", "SimpleFunction2", EdmCoreModel.Instance.GetInt32(false), false /*isbound*/, null, true);
function2.AddParameter("p1", EdmCoreModel.Instance.GetInt32(false));
defaultContainer.AddFunctionImport("SimpleFunctionImport2", function1, null, true /*IncludeInServiceDocument*/);
return model;
}
public void CanParse_FunctionParameters_CanResolveAliasedParameterValue()
{
// Arrange
var model = new CustomersModelWithInheritance();
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
var function = new EdmFunction(
model.Container.Namespace,
"FunctionAtRoot",
returnType,
isBound: false,
entitySetPathExpression: null,
isComposable: true);
function.AddParameter("IntParameter", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false));
model.Container.AddFunctionImport("FunctionAtRoot", function, entitySet: null);
// Act
ODataPath path = _parser.Parse(model.Model, "FunctionAtRoot(IntParameter=@p1)");
UnboundFunctionPathSegment functionSegment = (UnboundFunctionPathSegment)path.Segments.Last();
// Assert
UnresolvedParameterValue unresolvedParamValue = functionSegment.GetParameterValue("IntParameter") as UnresolvedParameterValue;
int intParameter = (int)unresolvedParamValue.Resolve(new Uri("http://services.odata.org/FunctionAtRoot(IntParameter=@p1)?@p1=1"));
Assert.Equal(1, intParameter);
}
private static EdmFunction AddFunction(CustomersModelWithInheritance model, string name,
IEdmTypeReference returnType = null, IEdmEntitySet entitySet = null, IEdmTypeReference bindingParameterType = null)
{
returnType = returnType ?? EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmExpression expression = entitySet == null ? null : new EdmEntitySetReferenceExpression(entitySet);
var function = new EdmFunction(
model.Container.Namespace,
name,
returnType,
isBound: bindingParameterType != null,
entitySetPathExpression: null,
isComposable: true);
if (bindingParameterType != null)
{
function.AddParameter("bindingParameter", bindingParameterType);
model.Model.AddElement(function);
}
else
{
model.Container.AddFunctionImport(name, function, expression);
}
return function;
}
public static IEdmModel ModelWithAllConceptsEdm()
{
var stringType = EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.String);
var model = new EdmModel();
var addressType = new EdmComplexType("NS1", "Address");
addressType.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
addressType.AddStructuralProperty("City", new EdmStringTypeReference(stringType, /*isNullable*/false, /*isUnbounded*/false, /*maxLength*/30, /*isUnicode*/true));
model.AddElement(addressType);
var zipCodeType = new EdmComplexType("NS1", "ZipCode");
zipCodeType.AddStructuralProperty("Main", new EdmStringTypeReference(stringType, /*isNullable*/false, /*isUnbounded*/false, /*maxLength*/5, /*isUnicode*/false));
zipCodeType.AddStructuralProperty("Extended", new EdmStringTypeReference(stringType, /*isNullable*/true, /*isUnbounded*/false, /*maxLength*/5, /*isUnicode*/false));
model.AddElement(zipCodeType);
addressType.AddStructuralProperty("Zip", new EdmComplexTypeReference(zipCodeType, false));
var foreignAddressType = new EdmComplexType("NS1", "ForeignAddress", addressType, false);
foreignAddressType.AddStructuralProperty("State", EdmPrimitiveTypeKind.String);
model.AddElement(foreignAddressType);
var personType = new EdmEntityType("NS1", "Person", null, true, false);
personType.AddKeys(personType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false));
model.AddElement(personType);
var customerType = new EdmEntityType("NS1", "Customer", personType);
customerType.AddStructuralProperty("IsVIP", EdmPrimitiveTypeKind.Boolean);
customerType.AddProperty(new EdmStructuralProperty(customerType, "LastUpdated", EdmCoreModel.Instance.GetDateTimeOffset(false), null, EdmConcurrencyMode.Fixed));
customerType.AddStructuralProperty("BillingAddress", new EdmComplexTypeReference(addressType, false));
customerType.AddStructuralProperty("ShippingAddress", new EdmComplexTypeReference(addressType, false));
model.AddElement(customerType);
var orderType = new EdmEntityType("NS1", "Order");
orderType.AddKeys(orderType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false));
var customerIdProperty = orderType.AddStructuralProperty("CustomerId", EdmPrimitiveTypeKind.Int32, false);
model.AddElement(orderType);
var navProp1 = new EdmNavigationPropertyInfo { Name = "ToOrders", Target = orderType, TargetMultiplicity = EdmMultiplicity.Many, };
var navProp2 = new EdmNavigationPropertyInfo { Name = "ToCustomer", Target = customerType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { customerIdProperty }, PrincipalProperties = customerType.Key() };
customerType.AddBidirectionalNavigation(navProp1, navProp2);
var container = new EdmEntityContainer("NS1", "MyContainer");
container.AddEntitySet("PersonSet", personType);
container.AddEntitySet("OrderSet", orderType);
model.AddElement(container);
var function = new EdmFunction("NS1", "Function1", EdmCoreModel.Instance.GetInt64(true));
function.AddParameter("Param1", EdmCoreModel.Instance.GetInt32(true));
container.AddFunctionImport(function);
model.AddElement(function);
return model;
}
public static IEdmModel EntityContainerWithOperationImportsEdm()
{
var model = new EdmModel();
var customerType = new EdmEntityType("NS1", "Customer");
customerType.AddKeys(customerType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
model.AddElement(customerType);
var container = new EdmEntityContainer("NS1", "MyContainer");
var customerSet = container.AddEntitySet("Customer", customerType);
var function = new EdmFunction("NS1", "GetCustomersExcluding", EdmCoreModel.GetCollection(new EdmEntityTypeReference(customerType, false)), false, null, false);
function.AddParameter("CustomerId", EdmCoreModel.Instance.GetInt32(true));
model.AddElement(function);
container.AddFunctionImport("GetCustomersExcluding", function, new EdmEntitySetReferenceExpression(customerSet));
model.AddElement(container);
return model;
}
public void CannotParseOverloadUnboundFunctionWithDifferentParamterType(string uri)
{
// Arrange
EdmModel model = new EdmModel();
EdmEntityContainer container = new EdmEntityContainer("NS", "Container");
model.AddElement(container);
var unboundFunction = new EdmFunction("NS", "OverloadUnboundFunction", EdmCoreModel.Instance.GetInt32(false));
unboundFunction.AddParameter("Parameter", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(unboundFunction);
unboundFunction = new EdmFunction("NS", "OverloadUnboundFunction", EdmCoreModel.Instance.GetInt32(false));
unboundFunction.AddParameter("Parameter", EdmCoreModel.Instance.GetString(false));
model.AddElement(unboundFunction);
// Act & Assert
Assert.Throws<ODataUnrecognizedPathException>(
() => _parser.Parse(model, _serviceRoot, _serviceRoot + uri),
"Resource not found for the segment 'OverloadUnboundFunction'.");
}
private object GetParameterValue(object value, Type type)
{
var model = new CustomersModelWithInheritance();
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
var function = new EdmFunction(
model.Container.Namespace,
"FunctionAtRoot",
returnType,
isBound: false,
entitySetPathExpression: null,
isComposable: true);
model.Model.SetAnnotationValue(model.Model.FindType("NS.SimpleEnum"), new ClrTypeAnnotation(typeof(SimpleEnum)));
function.AddParameter("Parameter", model.Model.GetEdmTypeReference(type));
model.Container.AddFunctionImport("FunctionAtRoot", function, entitySet: null);
ODataPath path = _parser.Parse(
model.Model,
_serviceRoot,
"FunctionAtRoot(Parameter=" + ODataUriUtils.ConvertToUriLiteral(value, ODataVersion.V4) + ")");
UnboundFunctionPathSegment functionSegment = (UnboundFunctionPathSegment)path.Segments.Last();
return functionSegment.GetParameterValue("Parameter");
}
void AddTableValueFunction(string name, EdmModel model, Dictionary<string, IEdmTypeReference> pars)
{
var container = model.EntityContainer as EdmEntityContainer;
var t = BuildTableValueType(name, model);
var func = new EdmFunction(container.Namespace, name, t, false, null, true);
foreach (var item in pars)
{
func.AddParameter(item.Key, item.Value);
}
container.AddFunctionImport(func.Name, func, null, true);
model.AddElement(func);
TVFList.Add(func.Name);
pars.Clear();
}
public void CanParse_FunctionParameters_CanResolveNestedAliasedParameterValues()
{
// Arrange
var model = new CustomersModelWithInheritance();
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
var function = new EdmFunction(
model.Container.Namespace,
"BoundFunction",
returnType,
isBound: true,
entitySetPathExpression: null,
isComposable: true);
model.Model.SetAnnotationValue(model.Model.FindType("NS.SimpleEnum"), new ClrTypeAnnotation(typeof(SimpleEnum)));
function.AddParameter("bindingParameter", model.Customer.ToEdmTypeReference(false));
function.AddParameter("IntParameter", model.Model.GetEdmTypeReference(typeof(int)));
function.AddParameter("NullableDoubleParameter", model.Model.GetEdmTypeReference(typeof(double?)));
function.AddParameter("StringParameter", model.Model.GetEdmTypeReference(typeof(string)));
function.AddParameter("GuidParameter", model.Model.GetEdmTypeReference(typeof(Guid)));
function.AddParameter("EnumParameter", model.Model.GetEdmTypeReference(typeof(SimpleEnum)));
model.Model.AddElement(function);
// Act
ODataPath path = _parser.Parse(model.Model, _serviceRoot, String.Format(
"Customers(1)/NS.BoundFunction(StringParameter=@p2,IntParameter=@p0,NullableDoubleParameter=@p1," +
"EnumParameter=@p4,GuidParameter=@p3)?@p2={2}&@p4={4}&@p1={1}&@p0={0}&@p999={3}&@p3=@p999",
ODataUriUtils.ConvertToUriLiteral(123, ODataVersion.V4),
ODataUriUtils.ConvertToUriLiteral(null, ODataVersion.V4),
ODataUriUtils.ConvertToUriLiteral("123", ODataVersion.V4),
ODataUriUtils.ConvertToUriLiteral(Guid.Empty, ODataVersion.V4),
ODataUriUtils.ConvertToUriLiteral(new ODataEnumValue("Third", "NS.SimpleEnum"), ODataVersion.V4)));
BoundFunctionPathSegment functionSegment = (BoundFunctionPathSegment)path.Segments.Last();
object intParameter = functionSegment.GetParameterValue("IntParameter");
object nullableDoubleParameter = functionSegment.GetParameterValue("NullableDoubleParameter");
object stringParameter = functionSegment.GetParameterValue("StringParameter");
object guidParameter = functionSegment.GetParameterValue("GuidParameter");
object enumParameter = functionSegment.GetParameterValue("EnumParameter");
// Assert
Assert.Equal(123, intParameter);
Assert.IsType<ODataNullValue>(nullableDoubleParameter);
Assert.Equal("123", stringParameter);
Assert.Equal(Guid.Empty, guidParameter);
Assert.IsType<ODataEnumValue>(enumParameter);
Assert.Equal("2", ((ODataEnumValue)enumParameter).Value);
Assert.Equal("NS.SimpleEnum", ((ODataEnumValue)enumParameter).TypeName);
}
public static IEdmModel CreateTripPinServiceModel(string ns)
{
EdmModel model = new EdmModel();
var defaultContainer = new EdmEntityContainer(ns, "DefaultContainer");
model.AddElement(defaultContainer);
var genderType = new EdmEnumType(ns, "PersonGender", isFlags: false);
genderType.AddMember("Male", new EdmIntegerConstant(0));
genderType.AddMember("Female", new EdmIntegerConstant(1));
genderType.AddMember("Unknown", new EdmIntegerConstant(2));
model.AddElement(genderType);
var cityType = new EdmComplexType(ns, "City");
cityType.AddProperty(new EdmStructuralProperty(cityType, "CountryRegion", EdmCoreModel.Instance.GetString(false)));
cityType.AddProperty(new EdmStructuralProperty(cityType, "Name", EdmCoreModel.Instance.GetString(false)));
cityType.AddProperty(new EdmStructuralProperty(cityType, "Region", EdmCoreModel.Instance.GetString(false)));
model.AddElement(cityType);
var locationType = new EdmComplexType(ns, "Location", null, false, true);
locationType.AddProperty(new EdmStructuralProperty(locationType, "Address", EdmCoreModel.Instance.GetString(false)));
locationType.AddProperty(new EdmStructuralProperty(locationType, "City", new EdmComplexTypeReference(cityType, false)));
model.AddElement(locationType);
var eventLocationType = new EdmComplexType(ns, "EventLocation", locationType, false, true);
eventLocationType.AddProperty(new EdmStructuralProperty(eventLocationType, "BuildingInfo", EdmCoreModel.Instance.GetString(true)));
model.AddElement(eventLocationType);
var airportLocationType = new EdmComplexType(ns, "AirportLocation", locationType, false, true);
airportLocationType.AddProperty(new EdmStructuralProperty(airportLocationType, "Loc", EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.GeographyPoint, false)));
model.AddElement(airportLocationType);
var photoType = new EdmEntityType(ns, "Photo", null, false, false, true);
var photoIdProperty = new EdmStructuralProperty(photoType, "Id", EdmCoreModel.Instance.GetInt64(false));
photoType.AddProperty(photoIdProperty);
photoType.AddKeys(photoIdProperty);
photoType.AddProperty(new EdmStructuralProperty(photoType, "Name", EdmCoreModel.Instance.GetString(true)));
model.AddElement(photoType);
var photoSet = new EdmEntitySet(defaultContainer, "Photos", photoType);
defaultContainer.AddElement(photoSet);
var personType = new EdmEntityType(ns, "Person", null, false, /* isOpen */ true);
var personIdProperty = new EdmStructuralProperty(personType, "UserName", EdmCoreModel.Instance.GetString(false));
personType.AddProperty(personIdProperty);
personType.AddKeys(personIdProperty);
personType.AddProperty(new EdmStructuralProperty(personType, "FirstName", EdmCoreModel.Instance.GetString(false)));
personType.AddProperty(new EdmStructuralProperty(personType, "LastName", EdmCoreModel.Instance.GetString(false)));
personType.AddProperty(new EdmStructuralProperty(personType, "Emails", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(true)))));
personType.AddProperty(new EdmStructuralProperty(personType, "AddressInfo", new EdmCollectionTypeReference(new EdmCollectionType(new EdmComplexTypeReference(locationType, true)))));
personType.AddProperty(new EdmStructuralProperty(personType, "Gender", new EdmEnumTypeReference(genderType, true)));
personType.AddProperty(new EdmStructuralProperty(personType, "Concurrency", EdmCoreModel.Instance.GetInt64(false)));
model.AddElement(personType);
var personSet = new EdmEntitySet(defaultContainer, "People", personType);
defaultContainer.AddElement(personSet);
var airlineType = new EdmEntityType(ns, "Airline");
var airlineCodeProp = new EdmStructuralProperty(airlineType, "AirlineCode", EdmCoreModel.Instance.GetString(false));
airlineType.AddKeys(airlineCodeProp);
airlineType.AddProperty(airlineCodeProp);
airlineType.AddProperty(new EdmStructuralProperty(airlineType, "Name", EdmCoreModel.Instance.GetString(false)));
model.AddElement(airlineType);
var airlineSet = new EdmEntitySet(defaultContainer, "Airlines", airlineType);
defaultContainer.AddElement(airlineSet);
var airportType = new EdmEntityType(ns, "Airport");
var airportIdType = new EdmStructuralProperty(airportType, "IcaoCode", EdmCoreModel.Instance.GetString(false));
airportType.AddProperty(airportIdType);
airportType.AddKeys(airportIdType);
airportType.AddProperty(new EdmStructuralProperty(airportType, "Name", EdmCoreModel.Instance.GetString(false)));
airportType.AddProperty(new EdmStructuralProperty(airportType, "IataCode", EdmCoreModel.Instance.GetString(false)));
airportType.AddProperty(new EdmStructuralProperty(airportType, "Location", new EdmComplexTypeReference(airportLocationType, false)));
model.AddElement(airportType);
var airportSet = new EdmEntitySet(defaultContainer, "Airports", airportType);
defaultContainer.AddElement(airportSet);
var planItemType = new EdmEntityType(ns, "PlanItem");
var planItemIdType = new EdmStructuralProperty(planItemType, "PlanItemId", EdmCoreModel.Instance.GetInt32(false));
planItemType.AddProperty(planItemIdType);
planItemType.AddKeys(planItemIdType);
planItemType.AddProperty(new EdmStructuralProperty(planItemType, "ConfirmationCode", EdmCoreModel.Instance.GetString(true)));
planItemType.AddProperty(new EdmStructuralProperty(planItemType, "StartsAt", EdmCoreModel.Instance.GetDateTimeOffset(true)));
planItemType.AddProperty(new EdmStructuralProperty(planItemType, "EndsAt", EdmCoreModel.Instance.GetDateTimeOffset(true)));
planItemType.AddProperty(new EdmStructuralProperty(planItemType, "Duration", EdmCoreModel.Instance.GetDuration(true)));
model.AddElement(planItemType);
var publicTransportationType = new EdmEntityType(ns, "PublicTransportation", planItemType);
publicTransportationType.AddProperty(new EdmStructuralProperty(publicTransportationType, "SeatNumber", EdmCoreModel.Instance.GetString(true)));
model.AddElement(publicTransportationType);
var flightType = new EdmEntityType(ns, "Flight", publicTransportationType);
var flightNumberType = new EdmStructuralProperty(flightType, "FlightNumber", EdmCoreModel.Instance.GetString(false));
flightType.AddProperty(flightNumberType);
model.AddElement(flightType);
var eventType = new EdmEntityType(ns, "Event", planItemType, false, true);
eventType.AddProperty(new EdmStructuralProperty(eventType, "Description", EdmCoreModel.Instance.GetString(true)));
eventType.AddProperty(new EdmStructuralProperty(eventType, "OccursAt", new EdmComplexTypeReference(eventLocationType, false)));
model.AddElement(eventType);
var tripType = new EdmEntityType(ns, "Trip");
var tripIdType = new EdmStructuralProperty(tripType, "TripId", EdmCoreModel.Instance.GetInt32(false));
tripType.AddProperty(tripIdType);
tripType.AddKeys(tripIdType);
tripType.AddProperty(new EdmStructuralProperty(tripType, "ShareId", EdmCoreModel.Instance.GetGuid(true)));
tripType.AddProperty(new EdmStructuralProperty(tripType, "Description", EdmCoreModel.Instance.GetString(true)));
tripType.AddProperty(new EdmStructuralProperty(tripType, "Name", EdmCoreModel.Instance.GetString(false)));
tripType.AddProperty(new EdmStructuralProperty(tripType, "Budget", EdmCoreModel.Instance.GetSingle(false)));
tripType.AddProperty(new EdmStructuralProperty(tripType, "StartsAt", EdmCoreModel.Instance.GetDateTimeOffset(false)));
tripType.AddProperty(new EdmStructuralProperty(tripType, "EndsAt", EdmCoreModel.Instance.GetDateTimeOffset(false)));
tripType.AddProperty(new EdmStructuralProperty(tripType, "Tags", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(false)))));
model.AddElement(tripType);
var friendsnNavigation = personType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Friends",
Target = personType,
TargetMultiplicity = EdmMultiplicity.Many
});
var personTripNavigation = personType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Trips",
Target = tripType,
TargetMultiplicity = EdmMultiplicity.Many,
ContainsTarget = true
});
var personPhotoNavigation = personType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Photo",
Target = photoType,
TargetMultiplicity = EdmMultiplicity.ZeroOrOne,
});
var tripPhotosNavigation = tripType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Photos",
Target = photoType,
TargetMultiplicity = EdmMultiplicity.Many,
});
var tripItemNavigation = tripType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "PlanItems",
Target = planItemType,
ContainsTarget = true,
TargetMultiplicity = EdmMultiplicity.Many
});
var flightFromAirportNavigation = flightType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "From",
Target = airportType,
TargetMultiplicity = EdmMultiplicity.One
});
var flightToAirportNavigation = flightType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "To",
Target = airportType,
TargetMultiplicity = EdmMultiplicity.One
});
var flightAirlineNavigation = flightType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Airline",
Target = airlineType,
TargetMultiplicity = EdmMultiplicity.One
});
var me = new EdmSingleton(defaultContainer, "Me", personType);
defaultContainer.AddElement(me);
personSet.AddNavigationTarget(friendsnNavigation, personSet);
me.AddNavigationTarget(friendsnNavigation, personSet);
personSet.AddNavigationTarget(flightAirlineNavigation, airlineSet);
me.AddNavigationTarget(flightAirlineNavigation, airlineSet);
personSet.AddNavigationTarget(flightFromAirportNavigation, airportSet);
me.AddNavigationTarget(flightFromAirportNavigation, airportSet);
personSet.AddNavigationTarget(flightToAirportNavigation, airportSet);
me.AddNavigationTarget(flightToAirportNavigation, airportSet);
personSet.AddNavigationTarget(personPhotoNavigation, photoSet);
me.AddNavigationTarget(personPhotoNavigation, photoSet);
personSet.AddNavigationTarget(tripPhotosNavigation, photoSet);
me.AddNavigationTarget(tripPhotosNavigation, photoSet);
var getFavoriteAirlineFunction = new EdmFunction(ns, "GetFavoriteAirline",
new EdmEntityTypeReference(airlineType, false), true,
new EdmPathExpression("person/Trips/PlanItems/Microsoft.OData.SampleService.Models.TripPin.Flight/Airline"), true);
getFavoriteAirlineFunction.AddParameter("person", new EdmEntityTypeReference(personType, false));
model.AddElement(getFavoriteAirlineFunction);
var getInvolvedPeopleFunction = new EdmFunction(ns, "GetInvolvedPeople",
new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(personType, false))), true, null, true);
getInvolvedPeopleFunction.AddParameter("trip", new EdmEntityTypeReference(tripType, false));
model.AddElement(getInvolvedPeopleFunction);
var getFriendsTripsFunction = new EdmFunction(ns, "GetFriendsTrips",
new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(tripType, false))),
true, new EdmPathExpression("person/Friends/Trips"), true);
getFriendsTripsFunction.AddParameter("person", new EdmEntityTypeReference(personType, false));
getFriendsTripsFunction.AddParameter("userName", EdmCoreModel.Instance.GetString(false));
model.AddElement(getFriendsTripsFunction);
var getNearestAirport = new EdmFunction(ns, "GetNearestAirport",
new EdmEntityTypeReference(airportType, false),
false, null, true);
getNearestAirport.AddParameter("lat", EdmCoreModel.Instance.GetDouble(false));
getNearestAirport.AddParameter("lon", EdmCoreModel.Instance.GetDouble(false));
model.AddElement(getNearestAirport);
var getNearestAirportFunctionImport = (IEdmFunctionImport)defaultContainer.AddFunctionImport("GetNearestAirport", getNearestAirport, new EdmEntitySetReferenceExpression(airportSet), true);
var resetDataSourceAction = new EdmAction(ns, "ResetDataSource", null, false, null);
model.AddElement(resetDataSourceAction);
defaultContainer.AddActionImport(resetDataSourceAction);
var shareTripAction = new EdmAction(ns, "ShareTrip", null, true, null);
shareTripAction.AddParameter("person", new EdmEntityTypeReference(personType, false));
shareTripAction.AddParameter("userName", EdmCoreModel.Instance.GetString(false));
shareTripAction.AddParameter("tripId", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(shareTripAction);
model.SetDescriptionAnnotation(defaultContainer, "TripPin service is a sample service for OData V4.");
model.SetOptimisticConcurrencyAnnotation(personSet, personType.StructuralProperties().Where(p => p.Name == "Concurrency"));
// TODO: currently singleton does not support ETag feature
// model.SetOptimisticConcurrencyAnnotation(me, personType.StructuralProperties().Where(p => p.Name == "Concurrency"));
model.SetResourcePathCoreAnnotation(personSet, "People");
model.SetResourcePathCoreAnnotation(me, "Me");
model.SetResourcePathCoreAnnotation(airlineSet, "Airlines");
model.SetResourcePathCoreAnnotation(airportSet, "Airports");
model.SetResourcePathCoreAnnotation(photoSet, "Photos");
model.SetResourcePathCoreAnnotation(getNearestAirportFunctionImport, "Microsoft.OData.SampleService.Models.TripPin.GetNearestAirport");
model.SetDereferenceableIDsCoreAnnotation(defaultContainer, true);
model.SetConventionalIDsCoreAnnotation(defaultContainer, true);
model.SetPermissionsCoreAnnotation(personType.FindProperty("UserName"), CorePermission.Read);
model.SetPermissionsCoreAnnotation(airlineType.FindProperty("AirlineCode"), CorePermission.Read);
model.SetPermissionsCoreAnnotation(airportType.FindProperty("IcaoCode"), CorePermission.Read);
model.SetPermissionsCoreAnnotation(planItemType.FindProperty("PlanItemId"), CorePermission.Read);
model.SetPermissionsCoreAnnotation(tripType.FindProperty("TripId"), CorePermission.Read);
model.SetPermissionsCoreAnnotation(photoType.FindProperty("Id"), CorePermission.Read);
model.SetImmutableCoreAnnotation(airportType.FindProperty("IataCode"), true);
model.SetComputedCoreAnnotation(personType.FindProperty("Concurrency"), true);
model.SetAcceptableMediaTypesCoreAnnotation(photoType, new[] { "image/jpeg" });
model.SetConformanceLevelCapabilitiesAnnotation(defaultContainer, CapabilitiesConformanceLevelType.Advanced);
model.SetSupportedFormatsCapabilitiesAnnotation(defaultContainer, new[] { "application/json;odata.metadata=full;IEEE754Compatible=false;odata.streaming=true", "application/json;odata.metadata=minimal;IEEE754Compatible=false;odata.streaming=true", "application/json;odata.metadata=none;IEEE754Compatible=false;odata.streaming=true" });
model.SetAsynchronousRequestsSupportedCapabilitiesAnnotation(defaultContainer, true);
model.SetBatchContinueOnErrorSupportedCapabilitiesAnnotation(defaultContainer, false);
model.SetNavigationRestrictionsCapabilitiesAnnotation(personSet, CapabilitiesNavigationType.None, new[] { new Tuple<IEdmNavigationProperty, CapabilitiesNavigationType>(friendsnNavigation, CapabilitiesNavigationType.Recursive) });
model.SetFilterFunctionsCapabilitiesAnnotation(defaultContainer, new[] { "contains", "endswith", "startswith", "length", "indexof", "substring", "tolower", "toupper", "trim", "concat", "year", "month", "day", "hour", "minute", "second", "round", "floor", "ceiling", "cast", "isof" });
model.SetSearchRestrictionsCapabilitiesAnnotation(personSet, true, CapabilitiesSearchExpressions.None);
model.SetSearchRestrictionsCapabilitiesAnnotation(airlineSet, true, CapabilitiesSearchExpressions.None);
model.SetSearchRestrictionsCapabilitiesAnnotation(airportSet, true, CapabilitiesSearchExpressions.None);
model.SetSearchRestrictionsCapabilitiesAnnotation(photoSet, true, CapabilitiesSearchExpressions.None);
model.SetInsertRestrictionsCapabilitiesAnnotation(personSet, true, new[] { personTripNavigation, friendsnNavigation });
model.SetInsertRestrictionsCapabilitiesAnnotation(airlineSet, true, null);
model.SetInsertRestrictionsCapabilitiesAnnotation(airportSet, false, null);
model.SetInsertRestrictionsCapabilitiesAnnotation(photoSet, true, null);
// TODO: model.SetUpdateRestrictionsCapabilitiesAnnotation();
model.SetDeleteRestrictionsCapabilitiesAnnotation(airportSet, false, null);
model.SetISOCurrencyMeasuresAnnotation(tripType.FindProperty("Budget"), "USD");
model.SetScaleMeasuresAnnotation(tripType.FindProperty("Budget"), 2);
return model;
}
public void ParseAsUnresolvePathSegment_OverloadBoundFunctionWithDifferentParamterType(string uri, string unresolvedValue)
{
// Arrange
EdmModel model = new EdmModel();
var entityType = new EdmEntityType("NS", "EntityTypeName");
entityType.AddKeys(entityType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
model.AddElement(entityType);
EdmEntityContainer container = new EdmEntityContainer("NS", "Container");
model.AddElement(container);
container.AddEntitySet("EntitySet", entityType);
var boundFunction = new EdmFunction("NS", "OverloadBoundFunction", EdmCoreModel.Instance.GetInt32(false));
boundFunction.AddParameter("bindingParameter", entityType.ToEdmTypeReference(false));
boundFunction.AddParameter("FunctionParameter", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(boundFunction);
boundFunction = new EdmFunction("NS", "OverloadBoundFunction", EdmCoreModel.Instance.GetInt32(false));
boundFunction.AddParameter("bindingParameter", entityType.ToEdmTypeReference(false));
boundFunction.AddParameter("FunctionParameter", EdmCoreModel.Instance.GetString(false));
model.AddElement(boundFunction);
// Act & Assert
UnresolvedPathSegment unresolvedPathSegment = Assert.IsType<UnresolvedPathSegment>(
_parser.Parse(model, _serviceRoot, _serviceRoot + uri).Segments.Last());
Assert.Equal(unresolvedValue, unresolvedPathSegment.SegmentValue);
}
public void NonBoundOperationShouldNotWriteIsBoundAttribute()
{
EdmFunction function = new EdmFunction("Default.Namespace", "Checkout", EdmCoreModel.Instance.GetString(true) /*returnType*/, false /*isBound*/, null /*entitySetPath*/, false /*isComposable*/);
function.AddParameter("param", EdmCoreModel.Instance.GetString(true));
this.TestWriteFunctionElementHeaderMethod(function, @"<Function Name=""Checkout""");
}
static FullPayloadValidateTests()
{
EntityType = new EdmEntityType("Namespace", "EntityType", null, false, false, false);
EntityType.AddKeys(EntityType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
EntityType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(isNullable: true), null, EdmConcurrencyMode.Fixed);
DerivedType = new EdmEntityType("Namespace", "DerivedType", EntityType, false, true);
var expandedCollectionNavProp = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Target = EntityType,
TargetMultiplicity = EdmMultiplicity.Many,
Name = "ExpandedCollectionNavProp"
});
var expandedNavProp = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Target = EntityType,
TargetMultiplicity = EdmMultiplicity.One,
Name = "ExpandedNavProp"
});
EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Target = EntityType,
TargetMultiplicity = EdmMultiplicity.Many,
Name = "ContainedCollectionNavProp",
ContainsTarget = true
});
EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Target = EntityType,
TargetMultiplicity = EdmMultiplicity.One,
Name = "ContainedNavProp",
ContainsTarget = true
});
var container = new EdmEntityContainer("Namespace", "Container");
EntitySet = container.AddEntitySet("EntitySet", EntityType);
EntitySet.AddNavigationTarget(expandedNavProp, EntitySet);
EntitySet.AddNavigationTarget(expandedCollectionNavProp, EntitySet);
Model = new EdmModel();
Model.AddElement(EntityType);
Model.AddElement(DerivedType);
Model.AddElement(container);
ModelWithFunction = new EdmModel();
ModelWithFunction.AddElement(EntityType);
ModelWithFunction.AddElement(DerivedType);
ModelWithFunction.AddElement(container);
EdmEntityTypeReference entityTypeReference = new EdmEntityTypeReference(EntityType, false);
EdmCollectionTypeReference typeReference = new EdmCollectionTypeReference(new EdmCollectionType(entityTypeReference));
EdmFunction function = new EdmFunction("Namespace", "Function", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
function.AddParameter("bindingParameter", typeReference);
ModelWithFunction.AddElement(function);
EdmAction action = new EdmAction("Namespace", "Action", EdmCoreModel.Instance.GetBoolean(true), true, null);
action.AddParameter("bindingParameter", typeReference);
ModelWithFunction.AddElement(action);
}
private static void BoundFunction(EdmModel model, string funcName, string paramName, IEdmTypeReference edmType, IEdmEntityTypeReference bindingType)
{
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
EdmFunction boundFunction = new EdmFunction("NS", funcName, returnType, isBound: true, entitySetPathExpression: null, isComposable: false);
boundFunction.AddParameter("entity", bindingType);
boundFunction.AddParameter(paramName, edmType);
model.AddElement(boundFunction);
}
public static IEdmModel FunctionWithAllEdm()
{
var model = new EdmModel();
var function = new EdmFunction("NS1", "FunctionWithAll", EdmCoreModel.Instance.GetInt32(true));
function.AddParameter("Param1", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(function);
return model;
}
private static void UnboundFunction(EdmEntityContainer container, string funcName, string paramName, IEdmTypeReference edmType)
{
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
var unboundFunction = new EdmFunction("NS", funcName, returnType, isBound: false, entitySetPathExpression: null, isComposable: true);
unboundFunction.AddParameter("key", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false));
unboundFunction.AddParameter(paramName, edmType);
container.AddFunctionImport(funcName, unboundFunction, entitySet: null);
}
public static IEdmModel ModelWithEnumEdm(params IEdmEnumType[] enumTypes)
{
var model = new EdmModel();
var complexType = new EdmComplexType("NS1", "Complex");
model.AddElement(complexType);
var entityType = new EdmEntityType("NS1", "Person");
model.AddElement(entityType);
var container = new EdmEntityContainer("NS1", "MyContainer");
model.AddElement(container);
int counter = 0;
foreach (var enumType in enumTypes)
{
var enumTypeReference = new EdmEnumTypeReference(enumType, false);
model.AddElement(enumType);
complexType.AddStructuralProperty("EnumProperty" + counter, enumTypeReference);
entityType.AddKeys(entityType.AddStructuralProperty("EnumProperty" + counter, enumTypeReference));
var function = new EdmFunction("NS1", "Function" + counter, enumTypeReference);
model.AddElement(function);
container.AddFunctionImport(function);
function.AddParameter("Param" + counter, enumTypeReference);
counter++;
}
return model;
}
private IEdmModel GetEdmModel()
{
EdmModel model = new EdmModel();
EdmEntityContainer container = new EdmEntityContainer("NS", "Name");
model.AddElement(container);
var entityType = new EdmEntityType("NS", "EntityTypeName");
model.AddElement(entityType);
container.AddEntitySet("EntitySet", entityType);
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmTypeReference parameterType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmTypeReference stringType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, isNullable: false);
// unbound function without parameter
container.AddFunctionImport(new EdmFunction("NS", "FunctionWithoutParams", returnType));
// unbound function with one parameter
var functionWithOneParam = new EdmFunction("NS", "FunctionWithOneParam", returnType);
functionWithOneParam.AddParameter("Parameter", parameterType);
container.AddFunctionImport(functionWithOneParam);
// unbound function with multiple parameters
var functionWithMultipleParams = new EdmFunction("NS", "FunctionWithMultipleParams", returnType);
functionWithMultipleParams.AddParameter("Parameter1", parameterType);
functionWithMultipleParams.AddParameter("Parameter2", parameterType);
functionWithMultipleParams.AddParameter("Parameter3", parameterType);
container.AddFunctionImport(functionWithMultipleParams);
// unbound overload function
container.AddFunctionImport(new EdmFunction("NS", "FunctionWithOverloads", returnType));
var functionWithOverloads2 = new EdmFunction("NS", "FunctionWithOverloads", returnType);
functionWithOverloads2.AddParameter("Parameter", parameterType);
container.AddFunctionImport(functionWithOverloads2);
var functionWithOverloads3 = new EdmFunction("NS", "FunctionWithOverloads", returnType);
functionWithOverloads3.AddParameter("Parameter1", parameterType);
functionWithOverloads3.AddParameter("Parameter2", parameterType);
functionWithOverloads3.AddParameter("Parameter3", parameterType);
container.AddFunctionImport(functionWithOverloads3);
// bound function with only binding parameter
IEdmTypeReference bindingParamterType = new EdmEntityTypeReference(entityType, isNullable: false);
var boundFunction = new EdmFunction("NS", "BoundFunctionWithoutParams", returnType, true, null, true);
boundFunction.AddParameter("bindingParameter", bindingParamterType);
model.AddElement(boundFunction);
// bound function with binding and one non-binding parameter
boundFunction = new EdmFunction("NS", "BoundFunctionWithOneParam", returnType, true, null, true);
boundFunction.AddParameter("bindingParameter", bindingParamterType);
boundFunction.AddParameter("Parameter", parameterType);
model.AddElement(boundFunction);
// bound function with binding and multiple non-binding parameters
boundFunction = new EdmFunction("NS", "BoundFunctionWithMultipleParams", returnType, true, null, true);
boundFunction.AddParameter("bindingParameter", bindingParamterType);
boundFunction.AddParameter("Parameter1", parameterType);
boundFunction.AddParameter("Parameter2", parameterType);
boundFunction.AddParameter("Parameter3", parameterType);
model.AddElement(boundFunction);
// bound overload function with only binding parameter
boundFunction = new EdmFunction("NS", "BoundFunctionOverload", returnType, true, null, true);
boundFunction.AddParameter("bindingParameter", bindingParamterType);
model.AddElement(boundFunction);
// bound overload function with binding and one non-binding parameter
boundFunction = new EdmFunction("NS", "BoundFunctionOverload", returnType, true, null, true);
boundFunction.AddParameter("bindingParameter", bindingParamterType);
boundFunction.AddParameter("Parameter", parameterType);
model.AddElement(boundFunction);
// bound overload function with binding and multiple non-binding parameters
boundFunction = new EdmFunction("NS", "BoundFunctionOverload", returnType, true, null, true);
boundFunction.AddParameter("bindingParameter", bindingParamterType);
boundFunction.AddParameter("Parameter1", parameterType);
boundFunction.AddParameter("Parameter2", parameterType);
boundFunction.AddParameter("Parameter3", parameterType);
model.AddElement(boundFunction);
// the following two bound functions have the same function name, same binding type and the same parameter name,
// but the non-binding parameter type is different.
boundFunction = new EdmFunction("NS", "BoundOverloadFailed", returnType, true, null, true);
boundFunction.AddParameter("bindingParameter", bindingParamterType);
boundFunction.AddParameter("FunctionParameter", parameterType);
model.AddElement(boundFunction);
boundFunction = new EdmFunction("NS", "BoundOverloadFailed", returnType, true, null, true);
boundFunction.AddParameter("bindingParameter", bindingParamterType);
boundFunction.AddParameter("FunctionParameter", stringType);
model.AddElement(boundFunction);
// the following two unbound functions have the same function name and the same parameter name,
// but the parameter type is different.
var function = new EdmFunction("NS", "UnboundOverloadFailed", returnType);
function.AddParameter("FunctionParameter", parameterType);
container.AddFunctionImport(function);
function = new EdmFunction("NS", "UnboundOverloadFailed", returnType);
function.AddParameter("FunctionParameter", stringType);
container.AddFunctionImport(function);
return model;
}
public void CanParse_BoundFunction_AtEntityCollection()
{
// Arrange
var model = new CustomersModelWithInheritance();
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmExpression entitySet = new EdmEntitySetReferenceExpression(model.Customers);
var function = new EdmFunction(
model.Container.Namespace,
"Count",
returnType,
isBound: true,
entitySetPathExpression: null,
isComposable: true);
IEdmTypeReference bindingParameterType = new EdmCollectionTypeReference(
new EdmCollectionType(new EdmEntityTypeReference(model.Customer, isNullable: false)));
function.AddParameter("customers", bindingParameterType);
model.Model.AddElement(function);
// Act
ODataPath path = _parser.Parse(model.Model, "Customers/NS.Count");
// Assert
Assert.NotNull(path);
Assert.Equal(2, path.Segments.Count);
var functionSegment = Assert.IsType<BoundFunctionPathSegment>(path.Segments.Last());
Assert.Same(function, functionSegment.Function);
Assert.Empty(functionSegment.Values);
}
public void GetTargetEntitySetForSingleton()
{
var model = new EdmModel();
var container = new EdmEntityContainer("Fake", "Container");
model.AddElement(container);
var edmEntityType = new EdmEntityType("Fake", "EntityType");
var singleton = container.AddSingleton("Singleton", edmEntityType);
var function = new EdmFunction("Fake", "FakeFunction", new EdmEntityTypeReference(edmEntityType, false), true, new EdmPathExpression("bindingparameter"), false);
function.AddParameter("bindingparameter", new EdmEntityTypeReference(edmEntityType, false));
var target = function.GetTargetEntitySet(singleton, model);
target.Should().BeNull();
}
public void GetParameterValue_Returns_FunctionParameterValue()
{
// Arrange
string parameterName = "Parameter";
EdmModel model = new EdmModel();
var entityType = new EdmEntityType("NS", "Customer");
model.AddElement(entityType);
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmTypeReference parameterType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false);
IEdmTypeReference bindingParamterType = new EdmEntityTypeReference(entityType, isNullable: false);
EdmFunction function = new EdmFunction("NS", "Function", returnType);
function.AddParameter("bindingParameter", bindingParamterType);
function.AddParameter(parameterName, parameterType);
model.AddElement(function);
IDictionary<string, string> parameterValues = new Dictionary<string, string>();
parameterValues.Add(parameterName, "101");
// Act
BoundFunctionPathSegment segment = new BoundFunctionPathSegment(function, model, parameterValues);
var result = segment.GetParameterValue(parameterName);
// Assert
Assert.Equal("System.Int32", result.GetType().FullName);
Assert.Equal("101", result.ToString());
}
void AddEdmFunction(string spName,
EdmModel model,
Dictionary<string, IEdmTypeReference> pars,
Dictionary<string, IEdmTypeReference> outPars)
{
IEdmTypeReference t = BuildSPReturnType(spName, model, outPars);
EdmEntityContainer container = model.EntityContainer as EdmEntityContainer;
var func = new EdmFunction(container.Namespace, spName, t, false, null, false);
foreach (var item in pars)
{
func.AddParameter(item.Key, item.Value);
}
container.AddFunctionImport(func.Name, func, null, true);
model.AddElement(func);
pars.Clear();
outPars.Clear();
}