public Task<IEdmModel> GetModelAsync(ModelContext context, CancellationToken cancellationToken)
{
var model = new EdmModel();
var dummyType = new EdmEntityType("NS", "Dummy");
model.AddElement(dummyType);
var container = new EdmEntityContainer("NS", "DefaultContainer");
container.AddEntitySet("Test", dummyType);
model.AddElement(container);
return Task.FromResult((IEdmModel) model);
}
public WriterTypeNameEndToEndTests()
{
var model = new EdmModel();
var type = new EdmEntityType("TestModel", "TestEntity", /* baseType */ null, /* isAbstract */ false, /* isOpen */ true);
var keyProperty = type.AddStructuralProperty("DeclaredInt16", EdmPrimitiveTypeKind.Int16);
type.AddKeys(new[] { keyProperty });
// Note: DerivedPrimitive is declared as a Geography, but its value below will be set to GeographyPoint, which is derived from Geography.
type.AddStructuralProperty("DerivedPrimitive", EdmPrimitiveTypeKind.Geography);
var container = new EdmEntityContainer("TestModel", "Container");
var set = container.AddEntitySet("Set", type);
model.AddElement(type);
model.AddElement(container);
var writerStream = new MemoryStream();
this.settings = new ODataMessageWriterSettings();
this.settings.SetServiceDocumentUri(ServiceDocumentUri);
// Make the message writer and entry writer lazy so that individual tests can tweak the settings before the message writer is created.
this.messageWriter = new Lazy <ODataMessageWriter>(() =>
new ODataMessageWriter(
(IODataResponseMessage) new InMemoryMessage {
Stream = writerStream
},
this.settings,
model));
var entryWriter = new Lazy <ODataWriter>(() => this.messageWriter.Value.CreateODataEntryWriter(set, type));
var valueWithAnnotation = new ODataPrimitiveValue(45);
valueWithAnnotation.SetAnnotation(new SerializationTypeNameAnnotation {
TypeName = "TypeNameFromSTNA"
});
var propertiesToWrite = new List <ODataProperty>
{
new ODataProperty
{
Name = "DeclaredInt16", Value = (Int16)42
},
new ODataProperty
{
Name = "UndeclaredDecimal", Value = (Decimal)4.5
},
new ODataProperty
{
// Note: value is more derived than the declared type.
Name = "DerivedPrimitive", Value = Microsoft.Spatial.GeographyPoint.Create(42, 45)
},
new ODataProperty()
{
Name = "PropertyWithSTNA", Value = valueWithAnnotation
}
};
this.writerOutput = new Lazy <string>(() =>
{
entryWriter.Value.WriteStart(new ODataEntry {
Properties = propertiesToWrite
});
entryWriter.Value.WriteEnd();
entryWriter.Value.Flush();
writerStream.Seek(0, SeekOrigin.Begin);
return(new StreamReader(writerStream).ReadToEnd());
});
}
private static IEdmModel GetEdmModel()
{
EdmModel model = new EdmModel();
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmTypeReference stringType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, isNullable: false);
IEdmTypeReference intType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false);
// Entity
EdmEntityType entity = new EdmEntityType("NS", "Entity", null, true, false);
model.AddElement(entity);
// Customer
EdmEntityType customer = new EdmEntityType("NS", "Customer", entity);
customer.AddKeys(customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
model.AddElement(customer);
// VipCustomer
EdmEntityType vipCustomer = new EdmEntityType("NS", "VipCustomer", customer);
model.AddElement(vipCustomer);
// functions bound to single
EdmFunction isBaseUpgraded = new EdmFunction("NS", "IsBaseUpgraded", returnType, true, entitySetPathExpression: null, isComposable: false);
isBaseUpgraded.AddParameter("entity", new EdmEntityTypeReference(entity, false));
model.AddElement(isBaseUpgraded);
EdmFunction isUpgraded = new EdmFunction("NS", "IsUpgraded", returnType, true, entitySetPathExpression: null, isComposable: false);
isUpgraded.AddParameter("entity", new EdmEntityTypeReference(customer, false));
model.AddElement(isUpgraded);
EdmFunction isVipUpgraded = new EdmFunction("NS", "IsVipUpgraded", returnType, true, entitySetPathExpression: null, isComposable: false);
isVipUpgraded.AddParameter("entity", new EdmEntityTypeReference(vipCustomer, false));
isVipUpgraded.AddParameter("param", stringType);
model.AddElement(isVipUpgraded);
// functions bound to collection
EdmFunction isBaseAllUpgraded = new EdmFunction("NS", "IsBaseAllUpgraded", returnType, true, entitySetPathExpression: null, isComposable: false);
isBaseAllUpgraded.AddParameter("entityset", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(entity, false))));
isBaseAllUpgraded.AddParameter("param", intType);
model.AddElement(isBaseAllUpgraded);
EdmFunction isAllUpgraded = new EdmFunction("NS", "IsAllCustomersUpgraded", returnType, true, entitySetPathExpression: null, isComposable: false);
isAllUpgraded.AddParameter("entityset", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(customer, false))));
isAllUpgraded.AddParameter("param", intType);
model.AddElement(isAllUpgraded);
EdmFunction isVipAllUpgraded = new EdmFunction("NS", "IsVipAllUpgraded", returnType, true, entitySetPathExpression: null, isComposable: false);
isVipAllUpgraded.AddParameter("entityset", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(vipCustomer, false))));
isVipAllUpgraded.AddParameter("param", intType);
model.AddElement(isVipAllUpgraded);
// overloads
EdmFunction upgradeAll1 = new EdmFunction("NS", "UpgradedAll", returnType, true, entitySetPathExpression: null, isComposable: false);
upgradeAll1.AddParameter("entityset", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(customer, false))));
upgradeAll1.AddParameter("age", intType);
upgradeAll1.AddParameter("name", stringType);
model.AddElement(upgradeAll1);
EdmFunction upgradeAll2 = new EdmFunction("NS", "UpgradedAll", returnType, true, entitySetPathExpression: null, isComposable: false);
upgradeAll2.AddParameter("entityset", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(customer, false))));
upgradeAll2.AddParameter("age", intType);
upgradeAll2.AddParameter("name", stringType);
upgradeAll2.AddParameter("gender", stringType);
model.AddElement(upgradeAll2);
EdmFunction upgradeAll3 = new EdmFunction("NS", "UpgradedAll", returnType, true, entitySetPathExpression: null, isComposable: false);
upgradeAll3.AddParameter("entityset", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(vipCustomer, false))));
upgradeAll3.AddParameter("age", intType);
upgradeAll3.AddParameter("name", stringType);
model.AddElement(upgradeAll3);
// function with optional parameters
EdmFunction getSalaray = new EdmFunction("NS", "GetWholeSalary", intType, isBound: true, entitySetPathExpression: null, isComposable: false);
getSalaray.AddParameter("entityset", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(customer, false))));
getSalaray.AddParameter("minSalary", intType);
getSalaray.AddOptionalParameter("maxSalary", intType);
getSalaray.AddOptionalParameter("aveSalary", intType, "129");
model.AddElement(getSalaray);
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
container.AddEntitySet("Customers", customer);
container.AddSingleton("Me", customer);
model.AddElement(container);
return(model);
}
public CustomersModelWithInheritance()
{
EdmModel model = new EdmModel();
// Enum type simpleEnum
EdmEnumType simpleEnum = new EdmEnumType("NS", "SimpleEnum");
simpleEnum.AddMember(new EdmEnumMember(simpleEnum, "First", new EdmEnumMemberValue(0)));
simpleEnum.AddMember(new EdmEnumMember(simpleEnum, "Second", new EdmEnumMemberValue(1)));
simpleEnum.AddMember(new EdmEnumMember(simpleEnum, "Third", new EdmEnumMemberValue(2)));
model.AddElement(simpleEnum);
// complex type address
EdmComplexType address = new EdmComplexType("NS", "Address");
address.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
address.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
address.AddStructuralProperty("State", EdmPrimitiveTypeKind.String);
address.AddStructuralProperty("ZipCode", EdmPrimitiveTypeKind.String);
address.AddStructuralProperty("Country", EdmPrimitiveTypeKind.String);
model.AddElement(address);
// open complex type "Account"
EdmComplexType account = new EdmComplexType("NS", "Account", null, false, true);
account.AddStructuralProperty("Bank", EdmPrimitiveTypeKind.String);
account.AddStructuralProperty("CardNum", EdmPrimitiveTypeKind.Int64);
account.AddStructuralProperty("BankAddress", new EdmComplexTypeReference(address, isNullable: true));
model.AddElement(account);
EdmComplexType specialAccount = new EdmComplexType("NS", "SpecialAccount", account, false, true);
specialAccount.AddStructuralProperty("SpecialCard", EdmPrimitiveTypeKind.String);
model.AddElement(specialAccount);
// entity type customer
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
IEdmProperty customerName = customer.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
customer.AddStructuralProperty("SimpleEnum", simpleEnum.ToEdmTypeReference(isNullable: false));
customer.AddStructuralProperty("Address", new EdmComplexTypeReference(address, isNullable: true));
customer.AddStructuralProperty("Account", new EdmComplexTypeReference(account, isNullable: true));
IEdmTypeReference primitiveTypeReference = EdmCoreModel.Instance.GetPrimitive(
EdmPrimitiveTypeKind.String,
isNullable: true);
var city = customer.AddStructuralProperty(
"City",
primitiveTypeReference,
defaultValue: null);
model.AddElement(customer);
// derived entity type special customer
EdmEntityType specialCustomer = new EdmEntityType("NS", "SpecialCustomer", customer);
specialCustomer.AddStructuralProperty("SpecialCustomerProperty", EdmPrimitiveTypeKind.Guid);
specialCustomer.AddStructuralProperty("SpecialAddress", new EdmComplexTypeReference(address, isNullable: true));
model.AddElement(specialCustomer);
// entity type order (open entity type)
EdmEntityType order = new EdmEntityType("NS", "Order", null, false, true);
// EdmEntityType order = new EdmEntityType("NS", "Order");
order.AddKeys(order.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
order.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
order.AddStructuralProperty("Amount", EdmPrimitiveTypeKind.Int32);
model.AddElement(order);
// derived entity type special order
EdmEntityType specialOrder = new EdmEntityType("NS", "SpecialOrder", order, false, true);
specialOrder.AddStructuralProperty("SpecialOrderProperty", EdmPrimitiveTypeKind.Guid);
model.AddElement(specialOrder);
// test entity
EdmEntityType testEntity = new EdmEntityType("System.Web.OData.Query.Expressions", "TestEntity");
testEntity.AddStructuralProperty("SampleProperty", EdmPrimitiveTypeKind.Binary);
model.AddElement(testEntity);
// containment
// my order
EdmEntityType myOrder = new EdmEntityType("NS", "MyOrder");
myOrder.AddKeys(myOrder.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
myOrder.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
model.AddElement(myOrder);
// order line
EdmEntityType orderLine = new EdmEntityType("NS", "OrderLine");
orderLine.AddKeys(orderLine.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
orderLine.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
model.AddElement(orderLine);
EdmNavigationProperty orderLinesNavProp = myOrder.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "OrderLines",
TargetMultiplicity = EdmMultiplicity.Many,
Target = orderLine,
ContainsTarget = true,
});
EdmNavigationProperty nonContainedOrderLinesNavProp = myOrder.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "NonContainedOrderLines",
TargetMultiplicity = EdmMultiplicity.Many,
Target = orderLine,
ContainsTarget = false,
});
EdmAction tag = new EdmAction("NS", "tag", returnType: null, isBound: true, entitySetPathExpression: null);
tag.AddParameter("entity", new EdmEntityTypeReference(orderLine, false));
model.AddElement(tag);
// entity sets
EdmEntityContainer container = new EdmEntityContainer("NS", "ModelWithInheritance");
model.AddElement(container);
EdmEntitySet customers = container.AddEntitySet("Customers", customer);
EdmEntitySet orders = container.AddEntitySet("Orders", order);
EdmEntitySet myOrders = container.AddEntitySet("MyOrders", myOrder);
// singletons
EdmSingleton vipCustomer = container.AddSingleton("VipCustomer", customer);
EdmSingleton mary = container.AddSingleton("Mary", customer);
EdmSingleton rootOrder = container.AddSingleton("RootOrder", order);
// annotations
model.SetOptimisticConcurrencyAnnotation(customers, new[] { city });
// containment
IEdmContainedEntitySet orderLines = (IEdmContainedEntitySet)myOrders.FindNavigationTarget(orderLinesNavProp);
// no-containment
IEdmNavigationSource nonContainedOrderLines = myOrders.FindNavigationTarget(nonContainedOrderLinesNavProp);
// actions
EdmAction upgrade = new EdmAction("NS", "upgrade", returnType: null, isBound: true, entitySetPathExpression: null);
upgrade.AddParameter("entity", new EdmEntityTypeReference(customer, false));
model.AddElement(upgrade);
EdmAction specialUpgrade =
new EdmAction("NS", "specialUpgrade", returnType: null, isBound: true, entitySetPathExpression: null);
specialUpgrade.AddParameter("entity", new EdmEntityTypeReference(specialCustomer, false));
model.AddElement(specialUpgrade);
// actions bound to collection
EdmAction upgradeAll = new EdmAction("NS", "UpgradeAll", returnType: null, isBound: true, entitySetPathExpression: null);
upgradeAll.AddParameter("entityset",
new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(customer, false))));
model.AddElement(upgradeAll);
EdmAction upgradeSpecialAll = new EdmAction("NS", "UpgradeSpecialAll", returnType: null, isBound: true, entitySetPathExpression: null);
upgradeSpecialAll.AddParameter("entityset",
new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(specialCustomer, false))));
model.AddElement(upgradeSpecialAll);
// functions
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmTypeReference stringType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, isNullable: false);
IEdmTypeReference intType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false);
EdmFunction IsUpgraded = new EdmFunction(
"NS",
"IsUpgraded",
returnType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
IsUpgraded.AddParameter("entity", new EdmEntityTypeReference(customer, false));
model.AddElement(IsUpgraded);
EdmFunction orderByCityAndAmount = new EdmFunction(
"NS",
"OrderByCityAndAmount",
stringType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
orderByCityAndAmount.AddParameter("entity", new EdmEntityTypeReference(customer, false));
orderByCityAndAmount.AddParameter("city", stringType);
orderByCityAndAmount.AddParameter("amount", intType);
model.AddElement(orderByCityAndAmount);
EdmFunction getOrders = new EdmFunction(
"NS",
"GetOrders",
EdmCoreModel.GetCollection(order.ToEdmTypeReference(false)),
isBound: true,
entitySetPathExpression: null,
isComposable: true);
getOrders.AddParameter("entity", new EdmEntityTypeReference(customer, false));
getOrders.AddParameter("parameter", intType);
model.AddElement(getOrders);
EdmFunction IsSpecialUpgraded = new EdmFunction(
"NS",
"IsSpecialUpgraded",
returnType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
IsSpecialUpgraded.AddParameter("entity", new EdmEntityTypeReference(specialCustomer, false));
model.AddElement(IsSpecialUpgraded);
EdmFunction getSalary = new EdmFunction(
"NS",
"GetSalary",
stringType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
getSalary.AddParameter("entity", new EdmEntityTypeReference(customer, false));
model.AddElement(getSalary);
getSalary = new EdmFunction(
"NS",
"GetSalary",
stringType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
getSalary.AddParameter("entity", new EdmEntityTypeReference(specialCustomer, false));
model.AddElement(getSalary);
EdmFunction IsAnyUpgraded = new EdmFunction(
"NS",
"IsAnyUpgraded",
returnType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
EdmCollectionType edmCollectionType = new EdmCollectionType(new EdmEntityTypeReference(customer, false));
IsAnyUpgraded.AddParameter("entityset", new EdmCollectionTypeReference(edmCollectionType));
model.AddElement(IsAnyUpgraded);
EdmFunction isCustomerUpgradedWithParam = new EdmFunction(
"NS",
"IsUpgradedWithParam",
returnType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
isCustomerUpgradedWithParam.AddParameter("entity", new EdmEntityTypeReference(customer, false));
isCustomerUpgradedWithParam.AddParameter("city", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, isNullable: false));
model.AddElement(isCustomerUpgradedWithParam);
EdmFunction isCustomerLocal = new EdmFunction(
"NS",
"IsLocal",
returnType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
isCustomerLocal.AddParameter("entity", new EdmEntityTypeReference(customer, false));
model.AddElement(isCustomerLocal);
EdmFunction entityFunction = new EdmFunction(
"NS",
"GetCustomer",
returnType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
entityFunction.AddParameter("entity", new EdmEntityTypeReference(customer, false));
entityFunction.AddParameter("customer", new EdmEntityTypeReference(customer, false));
model.AddElement(entityFunction);
EdmFunction getOrder = new EdmFunction(
"NS",
"GetOrder",
order.ToEdmTypeReference(false),
isBound: true,
entitySetPathExpression: null,
isComposable: true); // Composable
getOrder.AddParameter("entity", new EdmEntityTypeReference(customer, false));
getOrder.AddParameter("orderId", intType);
model.AddElement(getOrder);
// functions bound to collection
EdmFunction isAllUpgraded = new EdmFunction("NS", "IsAllUpgraded", returnType, isBound: true,
entitySetPathExpression: null, isComposable: false);
isAllUpgraded.AddParameter("entityset",
new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(customer, false))));
isAllUpgraded.AddParameter("param", intType);
model.AddElement(isAllUpgraded);
EdmFunction isSpecialAllUpgraded = new EdmFunction("NS", "IsSpecialAllUpgraded", returnType, isBound: true,
entitySetPathExpression: null, isComposable: false);
isSpecialAllUpgraded.AddParameter("entityset",
new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(specialCustomer, false))));
isSpecialAllUpgraded.AddParameter("param", intType);
model.AddElement(isSpecialAllUpgraded);
// navigation properties
EdmNavigationProperty ordersNavProp = customer.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "Orders",
TargetMultiplicity = EdmMultiplicity.Many,
Target = order
});
mary.AddNavigationTarget(ordersNavProp, orders);
vipCustomer.AddNavigationTarget(ordersNavProp, orders);
customers.AddNavigationTarget(ordersNavProp, orders);
orders.AddNavigationTarget(
order.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "Customer",
TargetMultiplicity = EdmMultiplicity.ZeroOrOne,
Target = customer
}),
customers);
// navigation properties on derived types.
EdmNavigationProperty specialOrdersNavProp = specialCustomer.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "SpecialOrders",
TargetMultiplicity = EdmMultiplicity.Many,
Target = order
});
vipCustomer.AddNavigationTarget(specialOrdersNavProp, orders);
customers.AddNavigationTarget(specialOrdersNavProp, orders);
orders.AddNavigationTarget(
specialOrder.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "SpecialCustomer",
TargetMultiplicity = EdmMultiplicity.ZeroOrOne,
Target = customer
}),
customers);
model.SetAnnotationValue <BindableOperationFinder>(model, new BindableOperationFinder(model));
// set properties
Model = model;
Container = container;
Customer = customer;
Order = order;
Address = address;
Account = account;
SpecialCustomer = specialCustomer;
SpecialOrder = specialOrder;
Orders = orders;
Customers = customers;
VipCustomer = vipCustomer;
Mary = mary;
RootOrder = rootOrder;
OrderLine = orderLine;
OrderLines = orderLines;
NonContainedOrderLines = nonContainedOrderLines;
UpgradeCustomer = upgrade;
UpgradeSpecialCustomer = specialUpgrade;
CustomerName = customerName;
IsCustomerUpgraded = isCustomerUpgradedWithParam;
IsSpecialCustomerUpgraded = IsSpecialUpgraded;
Tag = tag;
}
private static IEdmModel GetTypelessEdmModel()
{
EdmModel model = new EdmModel();
// Enum type "Color"
EdmEnumType colorEnum = new EdmEnumType("NS", "Color");
colorEnum.AddMember(new EdmEnumMember(colorEnum, "Red", new EdmEnumMemberValue(0)));
colorEnum.AddMember(new EdmEnumMember(colorEnum, "Blue", new EdmEnumMemberValue(1)));
colorEnum.AddMember(new EdmEnumMember(colorEnum, "Green", new EdmEnumMemberValue(2)));
model.AddElement(colorEnum);
// complex type "Address"
EdmComplexType address = new EdmComplexType("NS", "Address");
address.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
address.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
model.AddElement(address);
// derived complex type "SubAddress"
EdmComplexType subAddress = new EdmComplexType("NS", "SubAddress", address);
subAddress.AddStructuralProperty("Code", EdmPrimitiveTypeKind.Double);
model.AddElement(subAddress);
// entity type "Customer"
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
customer.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
customer.AddStructuralProperty("Location", new EdmComplexTypeReference(address, isNullable: true));
model.AddElement(customer);
// derived entity type special customer
EdmEntityType specialCustomer = new EdmEntityType("NS", "SpecialCustomer", customer);
specialCustomer.AddStructuralProperty("Title", EdmPrimitiveTypeKind.Guid);
model.AddElement(specialCustomer);
// entity sets
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
model.AddElement(container);
container.AddEntitySet("FCustomers", customer);
EdmComplexTypeReference complexType = new EdmComplexTypeReference(address, isNullable: true);
EdmCollectionTypeReference complexCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(complexType));
EdmEnumTypeReference enumType = new EdmEnumTypeReference(colorEnum, isNullable: false);
EdmCollectionTypeReference enumCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(enumType));
EdmEntityTypeReference entityType = new EdmEntityTypeReference(customer, isNullable: false);
EdmCollectionTypeReference entityCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(entityType));
IEdmTypeReference intType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: true);
EdmCollectionTypeReference primitiveCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(intType));
// bound functions
BoundFunction(model, "IntCollectionFunction", "intValues", primitiveCollectionType, entityType);
BoundFunction(model, "ComplexFunction", "address", complexType, entityType);
BoundFunction(model, "ComplexCollectionFunction", "addresses", complexCollectionType, entityType);
BoundFunction(model, "EnumFunction", "color", enumType, entityType);
BoundFunction(model, "EnumCollectionFunction", "colors", enumCollectionType, entityType);
BoundFunction(model, "EntityFunction", "customer", entityType, entityType);
BoundFunction(model, "CollectionEntityFunction", "customers", entityCollectionType, entityType);
// unbound functions
UnboundFunction(container, "UnboundIntCollectionFunction", "intValues", primitiveCollectionType);
UnboundFunction(container, "UnboundComplexFunction", "address", complexType);
UnboundFunction(container, "UnboundComplexCollectionFunction", "addresses", complexCollectionType);
UnboundFunction(container, "UnboundEnumFunction", "color", enumType);
UnboundFunction(container, "UnboundEnumCollectionFunction", "colors", enumCollectionType);
UnboundFunction(container, "UnboundEntityFunction", "customer", entityType);
UnboundFunction(container, "UnboundCollectionEntityFunction", "customers", entityCollectionType);
// bound to collection
BoundToCollectionFunction(model, "BoundToCollectionFunction", "p", intType, entityType);
model.SetAnnotationValue <BindableOperationFinder>(model, new BindableOperationFinder(model));
return(model);
}
public void ParseCompositeKeyReference(TestODataUrlKeyDelimiter testODataUrlKeyDelimiter, string fullUrl)
{
var model = new EdmModel();
var customer = new EdmEntityType("Test", "Customer", null, false, true);
var customerId = customer.AddStructuralProperty("id", EdmPrimitiveTypeKind.String, false);
customer.AddKeys(customerId);
model.AddElement(customer);
var order = new EdmEntityType("Test", "Order", null, false, true);
var orderCustomerId = order.AddStructuralProperty("customerId", EdmPrimitiveTypeKind.String, true);
var orderOrderId = order.AddStructuralProperty("orderId", EdmPrimitiveTypeKind.String, true);
order.AddKeys(orderCustomerId, orderOrderId);
model.AddElement(order);
var customerOrders = customer.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
ContainsTarget = true,
Name = "orders",
Target = order,
TargetMultiplicity = EdmMultiplicity.Many,
DependentProperties = new[] { customerId },
PrincipalProperties = new[] { orderCustomerId }
});
var detail = new EdmEntityType("Test", "Detail");
var detailCustomerId = detail.AddStructuralProperty("customerId", EdmPrimitiveTypeKind.String);
var detailOrderId = detail.AddStructuralProperty("orderId", EdmPrimitiveTypeKind.String);
detail.AddKeys(detailCustomerId, detailOrderId,
detail.AddStructuralProperty("id", EdmPrimitiveTypeKind.Int32, false));
model.AddElement(detail);
var detailedOrder = new EdmEntityType("Test", "DetailedOrder", order);
var detailedOrderDetails = detailedOrder.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
ContainsTarget = true,
Target = detail,
TargetMultiplicity = EdmMultiplicity.Many,
Name = "details",
DependentProperties = new[] { orderOrderId, orderCustomerId },
PrincipalProperties = new[] { detailOrderId, detailCustomerId }
});
model.AddElement(detailedOrder);
var container = new EdmEntityContainer("Test", "Container");
var customers = container.AddEntitySet("customers", customer);
model.AddElement(container);
var parser = new ODataUriParser(model, new Uri("http://host"), new Uri(fullUrl));
switch (testODataUrlKeyDelimiter)
{
case TestODataUrlKeyDelimiter.Parentheses:
parser.UrlKeyDelimiter = ODataUrlKeyDelimiter.Parentheses;
break;
case TestODataUrlKeyDelimiter.Slash:
parser.UrlKeyDelimiter = ODataUrlKeyDelimiter.Slash;
break;
default:
Assert.True(false, "Unreachable code path");
break;
}
var path = parser.ParsePath().ToList();
path[0].ShouldBeEntitySetSegment(customers);
path[1].ShouldBeKeySegment(new KeyValuePair <string, object>("id", "customerId"));
path[2].ShouldBeNavigationPropertySegment(customerOrders);
path[3].ShouldBeKeySegment(new KeyValuePair <string, object>("customerId", "customerId"),
new KeyValuePair <string, object>("orderId", "orderId"));
if (path.Count > 4)
{
// For tests with a type cast and a second-level navigation property.
path[4].ShouldBeTypeSegment(detailedOrder);
path[5].ShouldBeNavigationPropertySegment(detailedOrderDetails);
path[6].ShouldBeKeySegment(new KeyValuePair <string, object>("customerId", "customerId"),
new KeyValuePair <string, object>("orderId", "orderId"),
new KeyValuePair <string, object>("id", 1));
}
}
public static IEdmModel GetEdmModel()
{
if (_edmModel != null)
{
return(_edmModel);
}
EdmModel model = new EdmModel();
// entity type 'Customer' with single alternate keys
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
customer.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
var ssn = customer.AddStructuralProperty("SSN", EdmPrimitiveTypeKind.String);
model.AddAlternateKeyAnnotation(customer, new Dictionary <string, IEdmProperty>
{
{ "SSN", ssn }
});
model.AddElement(customer);
// entity type 'Order' with multiple alternate keys
EdmEntityType order = new EdmEntityType("NS", "Order");
order.AddKeys(order.AddStructuralProperty("OrderId", EdmPrimitiveTypeKind.Int32));
var orderName = order.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
var orderToken = order.AddStructuralProperty("Token", EdmPrimitiveTypeKind.Guid);
order.AddStructuralProperty("Amount", EdmPrimitiveTypeKind.Int32);
model.AddAlternateKeyAnnotation(order, new Dictionary <string, IEdmProperty>
{
{ "Name", orderName }
});
model.AddAlternateKeyAnnotation(order, new Dictionary <string, IEdmProperty>
{
{ "Token", orderToken }
});
model.AddElement(order);
// entity type 'Person' with composed alternate keys
EdmEntityType person = new EdmEntityType("NS", "Person");
person.AddKeys(person.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
var countryRegion = person.AddStructuralProperty("Country_Region", EdmPrimitiveTypeKind.String);
var passport = person.AddStructuralProperty("Passport", EdmPrimitiveTypeKind.String);
model.AddAlternateKeyAnnotation(person, new Dictionary <string, IEdmProperty>
{
{ "Country_Region", countryRegion },
{ "Passport", passport }
});
model.AddElement(person);
// complex type address
EdmComplexType address = new EdmComplexType("NS", "Address");
var street = address.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
var city = address.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
model.AddElement(address);
// entity type 'Company' with complex type alternate keys
EdmEntityType company = new EdmEntityType("NS", "Company");
company.AddKeys(company.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
company.AddStructuralProperty("Location", new EdmComplexTypeReference(address, isNullable: true));
model.AddAlternateKeyAnnotation(company, new Dictionary <string, IEdmProperty>
{
{ "City", city },
{ "Street", street }
});
model.AddElement(company);
// entity sets
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
model.AddElement(container);
container.AddEntitySet("Customers", customer);
container.AddEntitySet("Orders", order);
container.AddEntitySet("People", person);
container.AddEntitySet("Companies", company);
return(_edmModel = model);
}
public void Initialize()
{
// Initialize open EntityType: EntityType.
EdmModel edmModel = new EdmModel();
myInt32 = new EdmTypeDefinition("TestNamespace", "MyInt32", EdmPrimitiveTypeKind.Int32);
EdmTypeDefinitionReference myInt32Reference = new EdmTypeDefinitionReference(myInt32, true);
edmModel.AddElement(myInt32);
myString = new EdmTypeDefinition("TestNamespace", "MyString", EdmPrimitiveTypeKind.String);
EdmTypeDefinitionReference myStringReference = new EdmTypeDefinitionReference(myString, true);
edmModel.AddElement(myString);
EdmEntityType edmEntityType = new EdmEntityType("TestNamespace", "EntityType", baseType: null, isAbstract: false, isOpen: true);
edmEntityType.AddStructuralProperty("DeclaredProperty", EdmPrimitiveTypeKind.Guid);
edmEntityType.AddStructuralProperty("DeclaredGeometryProperty", EdmPrimitiveTypeKind.Geometry);
edmEntityType.AddStructuralProperty("DeclaredSingleProperty", EdmPrimitiveTypeKind.Single);
edmEntityType.AddStructuralProperty("DeclaredDoubleProperty", EdmPrimitiveTypeKind.Double);
edmEntityType.AddStructuralProperty("MyInt32Property", myInt32Reference);
edmEntityType.AddStructuralProperty("MyStringProperty", myStringReference);
edmEntityType.AddStructuralProperty("TimeOfDayProperty", EdmPrimitiveTypeKind.TimeOfDay);
edmEntityType.AddStructuralProperty("DateProperty", EdmPrimitiveTypeKind.Date);
edmModel.AddElement(edmEntityType);
this.model = TestUtils.WrapReferencedModelsToMainModel(edmModel);
this.entityType = edmEntityType;
this.declaredProperty = new ODataProperty {
Name = "DeclaredProperty", Value = Guid.Empty
};
this.undeclaredProperty = new ODataProperty {
Name = "UndeclaredProperty", Value = DateTimeOffset.MinValue
};
this.declaredGeometryProperty = new ODataProperty {
Name = "DeclaredGeometryProperty", Value = GeometryPoint.Create(0.0, 0.0)
};
this.declaredPropertyTimeOfDay = new ODataProperty {
Name = "TimeOfDayProperty", Value = new TimeOfDay(1, 30, 5, 123)
};
this.declaredPropertyDate = new ODataProperty {
Name = "DateProperty", Value = new Date(2014, 9, 17)
};
// Initialize derived ComplexType: Address and HomeAddress
this.addressType = new EdmComplexType("TestNamespace", "Address", baseType: null, isAbstract: false, isOpen: false);
this.addressType.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
this.derivedAddressType = new EdmComplexType("TestNamespace", "HomeAddress", baseType: this.addressType, isAbstract: false, isOpen: false);
this.derivedAddressType.AddStructuralProperty("FamilyName", EdmPrimitiveTypeKind.String);
// Initialize open ComplexType: OpenAddress.
this.openAddressType = new EdmComplexType("TestNamespace", "OpenAddress", baseType: null, isAbstract: false, isOpen: true);
this.openAddressType.AddStructuralProperty("CountryRegion", EdmPrimitiveTypeKind.String);
edmModel.AddElement(this.addressType);
edmModel.AddElement(this.derivedAddressType);
edmModel.AddElement(this.openAddressType);
this.declaredPropertyAddress = new ODataProperty()
{
Name = "AddressProperty", Value = new ODataComplexValue {
TypeName = "TestNamespace.Address", Properties = new ODataProperty[] { new ODataProperty {
Name = "City", Value = "Shanghai"
} }
}
};
this.declaredPropertyHomeAddress = new ODataProperty()
{
Name = "HomeAddressProperty", Value = new ODataComplexValue {
TypeName = "TestNamespace.HomeAddress", Properties = new ODataProperty[] { new ODataProperty {
Name = "FamilyName", Value = "Green"
}, new ODataProperty {
Name = "City", Value = "Shanghai"
} }
}
};
this.declaredPropertyAddressWithInstanceAnnotation = new ODataProperty()
{
Name = "AddressProperty",
Value = new ODataComplexValue
{
TypeName = "TestNamespace.Address",
Properties = new ODataProperty[]
{
new ODataProperty {
Name = "City", Value = "Shanghai"
}
},
InstanceAnnotations = new Collection <ODataInstanceAnnotation>
{
new ODataInstanceAnnotation("Is.ReadOnly", new ODataPrimitiveValue(true))
}
}
};
this.declaredPropertyHomeAddressWithInstanceAnnotations = new ODataProperty()
{
Name = "HomeAddressProperty",
Value = new ODataComplexValue
{
TypeName = "TestNamespace.HomeAddress",
Properties = new ODataProperty[]
{
new ODataProperty
{
Name = "FamilyName",
Value = "Green",
InstanceAnnotations = new Collection <ODataInstanceAnnotation>
{
new ODataInstanceAnnotation("FamilyName.annotation", new ODataPrimitiveValue(true))
}
},
new ODataProperty
{
Name = "City",
Value = "Shanghai",
InstanceAnnotations = new Collection <ODataInstanceAnnotation>
{
new ODataInstanceAnnotation("City.annotation1", new ODataPrimitiveValue(true)),
new ODataInstanceAnnotation("City.annotation2", new ODataPrimitiveValue(123))
}
}
},
InstanceAnnotations = new Collection <ODataInstanceAnnotation>
{
new ODataInstanceAnnotation("Is.AutoComputable", new ODataPrimitiveValue(true)),
new ODataInstanceAnnotation("Is.ReadOnly", new ODataPrimitiveValue(false))
}
}
};
this.declaredPropertyCountryRegion = new ODataProperty()
{
Name = "CountryRegion", Value = "China"
};
this.declaredPropertyCountryRegionWithInstanceAnnotation = new ODataProperty()
{
Name = "CountryRegion",
Value = "China",
InstanceAnnotations = new Collection <ODataInstanceAnnotation>
{
new ODataInstanceAnnotation("Is.ReadOnly", new ODataPrimitiveValue(true))
}
};
this.undeclaredPropertyCity = new ODataProperty()
{
Name = "City", Value = "Shanghai"
};
this.declaredPropertyMyInt32 = new ODataProperty()
{
Name = "MyInt32Property", Value = 12345
};
this.declaredPropertyMyInt32WithInstanceAnnotations = new ODataProperty()
{
Name = "MyInt32Property",
Value = 12345,
InstanceAnnotations = new Collection <ODataInstanceAnnotation>
{
new ODataInstanceAnnotation("Is.AutoComputable", new ODataPrimitiveValue(true)),
new ODataInstanceAnnotation("Is.ReadOnly", new ODataPrimitiveValue(false))
}
};
this.declaredPropertyMyString = new ODataProperty()
{
Name = "MyStringProperty", Value = "abcde"
};
}
public void WriterShouldNotIncludeTypeNameForCollectionOfDerivedType()
{
// JSON Light: writer doesn't include type name for collection of derived type
// If I have a collection property declared in metadata as Collection(Edm.Geography),
// and at serialization type, it's clearly a Collection(Edm.GeographyPoint),
// we won't write the type name for that property by default (i.e., minimal metadata mode).
var model = new EdmModel();
var entityType = new EdmEntityType("Var1", "Type");
entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
entityType.AddProperty(new EdmStructuralProperty(entityType, "Geographies", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.Geography, false)))));
model.AddElement(entityType);
var writerSettings = new ODataMessageWriterSettings();
writerSettings.SetContentType(ODataFormat.Json);
writerSettings.DisableMessageStreamDisposal = true;
var message = new InMemoryMessage {
Stream = new MemoryStream()
};
using (ODataMessageWriter odataMessageWriter = new ODataMessageWriter((IODataRequestMessage)message, writerSettings, model))
{
ODataWriter odataWriter = odataMessageWriter.CreateODataEntryWriter();
odataWriter.WriteStart(
new ODataEntry
{
TypeName = "Var1.Type",
Properties = new[]
{
new ODataProperty()
{
Name = "Id",
Value = 1
},
new ODataProperty()
{
Name = "Geographies",
Value = new ODataCollectionValue
{
Items = new[]
{
GeographyPoint.Create(0, 0),
GeographyPoint.Create(1, 1),
GeographyPoint.Create(2, 2)
}
}
},
}
});
odataWriter.WriteEnd();
odataWriter.Flush();
}
message.Stream.Position = 0;
var output = new StreamReader(message.Stream).ReadToEnd();
Assert.IsFalse(output.Contains("Collection(Edm.GeographyPoint)"), @"output.Contains(""Collection(Edm.GeographyPoint)"" == false");
}
public static IEdmModel CreateServiceEdmModel(string ns)
{
EdmModel model = new EdmModel();
var defaultContainer = new EdmEntityContainer(ns, "PerfInMemoryContainer");
model.AddElement(defaultContainer);
var personType = new EdmEntityType(ns, "Person");
var personIdProperty = new EdmStructuralProperty(personType, "PersonID", EdmCoreModel.Instance.GetInt32(false));
personType.AddProperty(personIdProperty);
personType.AddKeys(new IEdmStructuralProperty[] { 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, "MiddleName", EdmCoreModel.Instance.GetString(true)));
personType.AddProperty(new EdmStructuralProperty(personType, "Age", EdmCoreModel.Instance.GetInt32(false)));
model.AddElement(personType);
var simplePersonSet = new EdmEntitySet(defaultContainer, "SimplePeopleSet", personType);
defaultContainer.AddElement(simplePersonSet);
var largetPersonSet = new EdmEntitySet(defaultContainer, "LargePeopleSet", personType);
defaultContainer.AddElement(largetPersonSet);
var addressType = new EdmComplexType(ns, "Address");
addressType.AddProperty(new EdmStructuralProperty(addressType, "Street", EdmCoreModel.Instance.GetString(false)));
addressType.AddProperty(new EdmStructuralProperty(addressType, "City", EdmCoreModel.Instance.GetString(false)));
addressType.AddProperty(new EdmStructuralProperty(addressType, "PostalCode", EdmCoreModel.Instance.GetString(false)));
model.AddElement(addressType);
var companyType = new EdmEntityType(ns, "Company");
var companyId = new EdmStructuralProperty(companyType, "CompanyID", EdmCoreModel.Instance.GetInt32(false));
companyType.AddProperty(companyId);
companyType.AddKeys(companyId);
companyType.AddProperty(new EdmStructuralProperty(companyType, "Name", EdmCoreModel.Instance.GetString(true)));
companyType.AddProperty(new EdmStructuralProperty(companyType, "Address", new EdmComplexTypeReference(addressType, true)));
companyType.AddProperty(new EdmStructuralProperty(companyType, "Revenue", EdmCoreModel.Instance.GetInt32(false)));
model.AddElement(companyType);
var companySet = new EdmEntitySet(defaultContainer, "CompanySet", companyType);
defaultContainer.AddElement(companySet);
var companyEmployeeNavigation = companyType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Employees",
Target = personType,
TargetMultiplicity = EdmMultiplicity.Many
});
companySet.AddNavigationTarget(companyEmployeeNavigation, largetPersonSet);
// ResetDataSource
var resetDataSourceAction = new EdmAction(ns, "ResetDataSource", null, false, null);
model.AddElement(resetDataSourceAction);
defaultContainer.AddActionImport(resetDataSourceAction);
return(model);
}
private IEdmModel GetModel()
{
if (_model != null)
{
return(_model);
}
var model = new EdmModel();
// EntityContainer: Service
var container = new EdmEntityContainer("ns", "Service");
model.AddElement(container);
// EntityType: Address
var address = new EdmEntityType("ns", "Address");
var addressId = address.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
address.AddKeys(addressId);
model.AddElement(address);
// EntitySet: Addresses
var addresses = container.AddEntitySet("Addresses", address);
// EntityType: PaymentInstrument
var paymentInstrument = new EdmEntityType("ns", "PaymentInstrument");
var paymentInstrumentId = paymentInstrument.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
paymentInstrument.AddKeys(paymentInstrumentId);
var billingAddresses = paymentInstrument.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "BillingAddresses",
Target = address,
TargetMultiplicity = EdmMultiplicity.Many
});
paymentInstrument.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "ContainedBillingAddresses",
Target = address,
TargetMultiplicity = EdmMultiplicity.Many,
ContainsTarget = true
});
model.AddElement(paymentInstrument);
// EntityType: Account
var account = new EdmEntityType("ns", "Account");
var accountId = account.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
account.AddKeys(accountId);
var myPaymentInstruments = account.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "MyPaymentInstruments",
Target = paymentInstrument,
TargetMultiplicity = EdmMultiplicity.Many,
ContainsTarget = true
});
model.AddElement(account);
// EntitySet: Accounts
var accounts = container.AddEntitySet("Accounts", account);
var paymentInstruments = accounts.FindNavigationTarget(myPaymentInstruments) as EdmNavigationSource;
Assert.NotNull(paymentInstruments);
paymentInstruments.AddNavigationTarget(billingAddresses, addresses);
// EntityType: Person
var person = new EdmEntityType("ns", "Person");
var personId = person.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
person.AddKeys(personId);
var myAccounts = person.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "MyAccounts",
Target = account,
TargetMultiplicity = EdmMultiplicity.Many
});
var myPermanentAccount = person.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "MyPermanentAccount",
Target = account,
TargetMultiplicity = EdmMultiplicity.One
});
var myLatestAccount = person.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "MyLatestAccount",
Target = account,
TargetMultiplicity = EdmMultiplicity.One
});
person.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "MyAddresses",
Target = address,
TargetMultiplicity = EdmMultiplicity.Many,
ContainsTarget = true
});
model.AddElement(person);
// EntityType: Benefit
var benefit = new EdmEntityType("ns", "Benefit");
var benefitId = benefit.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
benefit.AddKeys(benefitId);
model.AddElement(benefit);
// EntityType: SpecialPerson
var specialPerson = new EdmEntityType("ns", "SpecialPerson", person);
specialPerson.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "Benefits",
Target = benefit,
TargetMultiplicity = EdmMultiplicity.Many,
ContainsTarget = true
});
model.AddElement(specialPerson);
// EntityType: VIP
var vip = new EdmEntityType("ns", "VIP", specialPerson);
vip.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "MyBenefits",
Target = benefit,
TargetMultiplicity = EdmMultiplicity.Many,
ContainsTarget = true
});
model.AddElement(vip);
// EntitySet: People
var people = container.AddEntitySet("People", person);
people.AddNavigationTarget(myAccounts, accounts);
people.AddNavigationTarget(myLatestAccount, accounts);
// EntityType: Club
var club = new EdmEntityType("ns", "Club");
var clubId = club.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
club.AddKeys(clubId);
var members = club.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "Members",
Target = person,
TargetMultiplicity = EdmMultiplicity.Many,
ContainsTarget = true
});
// EntityType: SeniorClub
var seniorClub = new EdmEntityType("ns", "SeniorClub", club);
model.AddElement(seniorClub);
// EntitySet: Clubs
var clubs = container.AddEntitySet("Clubs", club);
var membersInClub = clubs.FindNavigationTarget(members) as EdmNavigationSource;
membersInClub.AddNavigationTarget(myAccounts, accounts);
// Singleton: PermanentAccount
var permanentAccount = container.AddSingleton("PermanentAccount", account);
people.AddNavigationTarget(myPermanentAccount, permanentAccount);
_model = model;
return(_model);
}
/// <summary>
/// Creates several PayloadTestDescriptors containing Batch Requests
/// </summary>
/// <param name="requestManager">Used for building the requests</param>
/// <param name="model">The model to use for adding additional types.</param>
/// <param name="withTypeNames">Whether or not to use full type names.</param>
/// <returns>PayloadTestDescriptors</returns>
public static IEnumerable <PayloadTestDescriptor> CreateBatchRequestTestDescriptors(
IODataRequestManager requestManager,
EdmModel model,
bool withTypeNames = false)
{
ExceptionUtilities.CheckArgumentNotNull(requestManager, "requestManager");
EdmEntityType personType = null;
EdmComplexType carType = null;
EdmEntitySet personsEntitySet = null;
EdmEntityContainer container = model.EntityContainer as EdmEntityContainer;
if (model != null)
{
//TODO: Clone EdmModel
//model = model.Clone();
if (container == null)
{
container = new EdmEntityContainer("TestModel", "DefaultContainer");
model.AddElement(container);
}
personType = model.FindDeclaredType("TestModel.TFPerson") as EdmEntityType;
carType = model.FindDeclaredType("TestModel.TFCar") as EdmComplexType;
// Create the metadata types for the entity instance used in the entity set
if (carType == null)
{
carType = new EdmComplexType("TestModel", "TFCar");
model.AddElement(carType);
carType.AddStructuralProperty("Make", EdmPrimitiveTypeKind.String, true);
carType.AddStructuralProperty("Color", EdmPrimitiveTypeKind.String, true);
}
if (personType == null)
{
personType = new EdmEntityType("TestModel", "TFPerson");
model.AddElement(personType);
personType.AddKeys(personType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
personType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String, true);
personType.AddStructuralProperty("Car", carType.ToTypeReference());
container.AddEntitySet("Customers", personType);
}
personsEntitySet = container.AddEntitySet("People", personType);
}
ComplexInstance carInstance = PayloadBuilder.ComplexValue(withTypeNames ? "TestModel.TFCar" : null)
.Property("Make", PayloadBuilder.PrimitiveValue("Ford"))
.Property("Color", PayloadBuilder.PrimitiveValue("Blue"));
ComplexProperty carProperty = (ComplexProperty)PayloadBuilder.Property("Car", carInstance)
.WithTypeAnnotation(personType);
EntityInstance personInstance = PayloadBuilder.Entity(withTypeNames ? "TestModel.TFPerson" : null)
.Property("Id", PayloadBuilder.PrimitiveValue(1))
.Property("Name", PayloadBuilder.PrimitiveValue("John Doe"))
.Property("Car", carInstance)
.WithTypeAnnotation(personType);
var carPropertyPayload = new PayloadTestDescriptor()
{
PayloadElement = carProperty,
PayloadEdmModel = model
};
var emptyPayload = new PayloadTestDescriptor()
{
PayloadEdmModel = CreateEmptyEdmModel()
};
var personPayload = new PayloadTestDescriptor()
{
PayloadElement = personInstance,
PayloadEdmModel = model
};
var root = ODataUriBuilder.Root(new Uri("http://www.odata.org/service.svc"));
var entityset = ODataUriBuilder.EntitySet(personsEntitySet);
// Get operations
var queryOperation1 = emptyPayload.InRequestOperation(HttpVerb.Get, new ODataUri(new ODataUriSegment[] { root }), requestManager);
var queryOperation2 = emptyPayload.InRequestOperation(HttpVerb.Get, new ODataUri(new ODataUriSegment[] { root }), requestManager);
// Post operation containing a complex property
var postOperation = carPropertyPayload.InRequestOperation(HttpVerb.Post, new ODataUri(new ODataUriSegment[] { root, entityset }), requestManager, MimeTypes.ApplicationJsonLight);
// Delete operation with no payload
var deleteOperation = emptyPayload.InRequestOperation(HttpVerb.Delete, new ODataUri(new ODataUriSegment[] { root, entityset }), requestManager);
// Put operation where the payload is an EntityInstance
var putOperation = personPayload.InRequestOperation(HttpVerb.Put, new ODataUri(new ODataUriSegment[] { root, entityset }), requestManager);
// A changeset containing a delete with no payload and a put
var twoOperationsChangeset = BatchUtils.GetRequestChangeset(new IMimePart[] { postOperation, deleteOperation }, requestManager);
// A changeset containing a delete with no payload
var oneOperationChangeset = BatchUtils.GetRequestChangeset(new IMimePart[] { deleteOperation }, requestManager);
// A changeset containing a put, post and delete
var threeOperationsChangeset = BatchUtils.GetRequestChangeset(new IMimePart[] { putOperation, postOperation, deleteOperation }, requestManager);
// A changeset containing no operations
var emptyChangeset = BatchUtils.GetRequestChangeset(new IMimePart[] { }, requestManager);
// Empty Batch
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload()
.AddAnnotation(new BatchBoundaryAnnotation("bb_emptybatch")),
PayloadEdmModel = emptyPayload.PayloadEdmModel,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
// Single Operation
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(queryOperation1)
.AddAnnotation(new BatchBoundaryAnnotation("bb_singleoperation")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
// Multiple Operations
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(queryOperation1, queryOperation2)
.AddAnnotation(new BatchBoundaryAnnotation("bb_multipleoperations")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
// Single Changeset
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(twoOperationsChangeset)
.AddAnnotation(new BatchBoundaryAnnotation("bb_singlechangeset")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
// Multiple Changesets (different content types)
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(twoOperationsChangeset, oneOperationChangeset, emptyChangeset)
.AddAnnotation(new BatchBoundaryAnnotation("bb_multiplechangesets")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
// Operations and changesets
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(twoOperationsChangeset, queryOperation1, oneOperationChangeset)
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_1")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(queryOperation1, oneOperationChangeset, queryOperation2)
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_2")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(queryOperation1, queryOperation2, twoOperationsChangeset, oneOperationChangeset)
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_3")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(queryOperation1, threeOperationsChangeset, queryOperation2, twoOperationsChangeset, queryOperation1, oneOperationChangeset)
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_4")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(queryOperation1, emptyChangeset, queryOperation1, threeOperationsChangeset, queryOperation2, oneOperationChangeset)
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_5")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
}
/// <summary>
/// Creates several PayloadTestDescriptors containing Batch Responses
/// </summary>
/// <param name="requestManager">Used for building the requests/responses.</param>
/// <param name="model">The model to use for adding additional types.</param>
/// <param name="withTypeNames">Whether or not to use full type names.</param>
/// <returns>PayloadTestDescriptors</returns>
public static IEnumerable <PayloadTestDescriptor> CreateBatchResponseTestDescriptors(
IODataRequestManager requestManager,
EdmModel model,
bool withTypeNames = false)
{
EdmEntityType personType = null;
EdmComplexType carType = null;
if (model != null)
{
//TODO: CLONE for EdmModel
//model = model.Clone();
personType = model.FindDeclaredType("TestModel.TFPerson") as EdmEntityType;
carType = model.FindDeclaredType("TestModel.TFCar") as EdmComplexType;
// Create the metadata types for the entity instance used in the entity set
if (carType == null)
{
carType = new EdmComplexType("TestModel", "TFCar");
model.AddElement(carType);
carType.AddStructuralProperty("Make", EdmPrimitiveTypeKind.String, true);
carType.AddStructuralProperty("Color", EdmPrimitiveTypeKind.String, true);
}
if (personType == null)
{
personType = new EdmEntityType("TestModel", "TFPerson");
model.AddElement(personType);
personType.AddKeys(personType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
personType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String, true);
personType.AddStructuralProperty("Car", carType.ToTypeReference());
EdmEntityContainer container = (EdmEntityContainer)model.EntityContainer;
if (container == null)
{
container = new EdmEntityContainer("TestModel", "DefaultContainer");
model.AddElement(container);
container.AddEntitySet("Customers", personType);
container.AddEntitySet("TFPerson", personType);
}
}
}
ComplexInstance carInstance = PayloadBuilder.ComplexValue(withTypeNames ? "TestModel.TFCar" : null)
.Property("Make", PayloadBuilder.PrimitiveValue("Ford"))
.Property("Color", PayloadBuilder.PrimitiveValue("Blue"));
ComplexProperty carProperty = (ComplexProperty)PayloadBuilder.Property("Car", carInstance)
.WithTypeAnnotation(carType);
EntityInstance personInstance = PayloadBuilder.Entity(withTypeNames ? "TestModel.TFPerson" : null)
.Property("Id", PayloadBuilder.PrimitiveValue(1))
.Property("Name", PayloadBuilder.PrimitiveValue("John Doe"))
.Property("Car", carInstance)
.WithTypeAnnotation(personType);
ODataErrorPayload errorInstance = PayloadBuilder.Error("ErrorCode")
.Message("ErrorValue")
.InnerError(
PayloadBuilder.InnerError().Message("InnerErrorMessage").StackTrace("InnerErrorStackTrace").TypeName("InnerErrorTypeName"));
var carPropertyPayload = new PayloadTestDescriptor()
{
PayloadElement = carProperty,
PayloadEdmModel = model
};
var emptyPayload = new PayloadTestDescriptor()
{
PayloadEdmModel = CreateEmptyEdmModel()
};
var personPayload = new PayloadTestDescriptor()
{
// This payload will be serialised to JSON so we need the annotation to mark it as a response.
PayloadElement = personInstance.AddAnnotation(new PayloadFormatVersionAnnotation()
{
Response = true, ResponseWrapper = true
}),
PayloadEdmModel = model
};
var errorPayload = new PayloadTestDescriptor()
{
PayloadElement = errorInstance,
PayloadEdmModel = model,
};
// response operation with a status code of 5 containing a complex instance
var carPropertyPayloadOperation = carPropertyPayload.InResponseOperation(5, requestManager);
// response operation with no payload and a status code of 200
var emptyPayloadOperation = emptyPayload.InResponseOperation(200, requestManager);
// response operation with a status code of 418 containing an entity instance
var personPayloadOperation = personPayload.InResponseOperation(418, requestManager, MimeTypes.ApplicationJsonLight);
// response operation with a status code of 404 containing an error instance
var errorPayloadOperation = errorPayload.InResponseOperation(404, requestManager);
// changeset with multiple operations
var twoOperationsChangeset = BatchUtils.GetResponseChangeset(new IMimePart[] { carPropertyPayloadOperation, emptyPayloadOperation }, requestManager);
// changesets with a single operation
var oneOperationChangeset = BatchUtils.GetResponseChangeset(new IMimePart[] { personPayloadOperation }, requestManager);
var oneErrorChangeset = BatchUtils.GetResponseChangeset(new IMimePart[] { errorPayloadOperation }, requestManager);
// empty changeset
var emptyChangeset = BatchUtils.GetResponseChangeset(new IMimePart[] { }, requestManager);
// Empty Batch
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(new IMimePart[] { })
.AddAnnotation(new BatchBoundaryAnnotation("bb_emptybatch")),
PayloadEdmModel = emptyPayload.PayloadEdmModel,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
// Single Operation
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(new IMimePart[] { carPropertyPayloadOperation })
.AddAnnotation(new BatchBoundaryAnnotation("bb_singleoperation")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
// Multiple Operations
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(new IMimePart[] { carPropertyPayloadOperation, emptyPayloadOperation, errorPayloadOperation, personPayloadOperation })
.AddAnnotation(new BatchBoundaryAnnotation("bb_multipleoperations")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
// Single Changeset
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(new IMimePart[] { twoOperationsChangeset })
.AddAnnotation(new BatchBoundaryAnnotation("bb_singlechangeset")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
// Multiple Changesets
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(new IMimePart[] { twoOperationsChangeset, oneOperationChangeset })
.AddAnnotation(new BatchBoundaryAnnotation("bb_multiplechangesets")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
// Operations and changesets
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(new IMimePart[] { twoOperationsChangeset, carPropertyPayloadOperation, oneOperationChangeset })
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_1")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(new IMimePart[] { carPropertyPayloadOperation, oneOperationChangeset, emptyPayloadOperation })
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_2")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(new IMimePart[] { errorPayloadOperation, carPropertyPayloadOperation, emptyPayloadOperation, twoOperationsChangeset, oneOperationChangeset })
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_3")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(
new IMimePart[] { oneErrorChangeset, carPropertyPayloadOperation, emptyChangeset, emptyPayloadOperation, twoOperationsChangeset, personPayloadOperation, oneOperationChangeset, errorPayloadOperation })
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_4")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
}
private void BuildOperations(EdmModel model, string modelNamespace)
{
foreach (OperationMethodInfo operationMethodInfo in this.operationInfos)
{
// With this method, if return type is nullable type,it will get underlying type
var returnType = TypeHelper.GetUnderlyingTypeOrSelf(operationMethodInfo.Method.ReturnType);
var returnTypeReference = returnType.GetReturnTypeReference(model);
bool isBound = operationMethodInfo.IsBound;
var bindingParameter = operationMethodInfo.Method.GetParameters().FirstOrDefault();
if (bindingParameter == null && isBound)
{
// Ignore the method which is marked as bounded but no parameters
continue;
}
string namespaceName = GetNamespaceName(operationMethodInfo, modelNamespace);
EdmOperation operation = null;
EdmPathExpression path = null;
if (isBound)
{
// Unbound actions or functions should not have EntitySetPath attribute
path = BuildBoundOperationReturnTypePathExpression(returnTypeReference, bindingParameter);
}
if (operationMethodInfo.HasSideEffects)
{
operation = new EdmAction(
namespaceName,
operationMethodInfo.Name,
returnTypeReference,
isBound,
path);
}
else
{
operation = new EdmFunction(
namespaceName,
operationMethodInfo.Name,
returnTypeReference,
isBound,
path,
operationMethodInfo.IsComposable);
}
BuildOperationParameters(operation, operationMethodInfo.Method, model);
model.AddElement(operation);
if (!isBound)
{
// entitySetReferenceExpression refer to an entity set containing entities returned
// by this function/action import.
var entitySetExpression = BuildEntitySetExpression(
model, operationMethodInfo.EntitySet, returnTypeReference);
var entityContainer = model.EnsureEntityContainer(this.targetType);
if (operationMethodInfo.HasSideEffects)
{
entityContainer.AddActionImport(operation.Name, (EdmAction)operation, entitySetExpression);
}
else
{
entityContainer.AddFunctionImport(
operation.Name, (EdmFunction)operation, entitySetExpression);
}
}
}
}
public EdmModel BuildEdmModel()
{
Dictionary <Type, EntityTypeInfo> entityTypeInfos = BuildEntityTypes();
foreach (EntityTypeInfo typeInfo in entityTypeInfos.Values)
{
typeInfo.BuildProperties(entityTypeInfos, _enumTypes, _complexTypes);
}
foreach (EntityTypeInfo typeInfo in entityTypeInfos.Values)
{
foreach (FKeyInfo fkeyInfo in typeInfo.NavigationClrProperties)
{
fkeyInfo.EdmNavigationProperty = CreateNavigationProperty(fkeyInfo);
}
}
var edmModel = new EdmModel();
var container = new EdmEntityContainer("Default", "Container");
edmModel.AddElements(_enumTypes.Values);
foreach (KeyValuePair <Type, EdmEnumType> enumType in _enumTypes)
{
edmModel.SetClrType(enumType.Value, enumType.Key);
}
edmModel.AddElements(_complexTypes.Values);
foreach (KeyValuePair <Type, EdmComplexType> complexType in _complexTypes)
{
edmModel.SetClrType(complexType.Value, complexType.Key);
}
var entitySets = new Dictionary <IEdmEntityType, EdmEntitySet>(entityTypeInfos.Count);
foreach (EntityTypeInfo typeInfo in entityTypeInfos.Values)
{
edmModel.AddElement(typeInfo.EdmType);
edmModel.SetClrType(typeInfo.EdmType, typeInfo.ClrType);
foreach (KeyValuePair <String, Type> pair in _entitySets)
{
if (pair.Value == typeInfo.ClrType)
{
entitySets.Add(typeInfo.EdmType, container.AddEntitySet(pair.Key, typeInfo.EdmType));
break;
}
}
}
var manyToManyBuilder = new ManyToManyBuilder(edmModel, _metadataProvider, entityTypeInfos);
foreach (EntityTypeInfo typeInfo in entityTypeInfos.Values)
{
foreach (FKeyInfo fkeyInfo in typeInfo.NavigationClrProperties)
{
EdmEntitySet principal = entitySets[fkeyInfo.PrincipalInfo.EdmType];
EdmEntitySet dependent = entitySets[fkeyInfo.DependentInfo.EdmType];
if (fkeyInfo.DependentNavigationProperty == null)
{
principal.AddNavigationTarget(fkeyInfo.EdmNavigationProperty, dependent);
}
else
{
dependent.AddNavigationTarget(fkeyInfo.EdmNavigationProperty, principal);
if (fkeyInfo.EdmNavigationProperty.Partner != null)
{
principal.AddNavigationTarget(fkeyInfo.EdmNavigationProperty.Partner, dependent);
}
}
}
manyToManyBuilder.Build(typeInfo);
}
foreach (OeOperationConfiguration operationConfiguration in _operationConfigurations)
{
if (operationConfiguration.IsEdmFunction)
{
EdmFunction edmFunction = BuildFunction(operationConfiguration, entityTypeInfos);
if (edmFunction != null)
{
edmModel.AddElement(edmFunction);
container.AddFunctionImport(operationConfiguration.Name, edmFunction);
edmModel.SetIsDbFunction(edmFunction, operationConfiguration.IsDbFunction);
}
}
else
{
EdmAction edmAction = BuildAction(operationConfiguration, entityTypeInfos);
if (edmAction != null)
{
edmModel.AddElement(edmAction);
container.AddActionImport(operationConfiguration.Name, edmAction);
edmModel.SetIsDbFunction(edmAction, operationConfiguration.IsDbFunction);
}
}
}
edmModel.AddElement(container);
return(edmModel);
}
public void NoMetadataTest()
{
EdmModel model = new EdmModel();
var container = new EdmEntityContainer("TestModel", "DefaultContainer");
model.AddElement(container);
var testDescriptors = new[]
{
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.EntitySet(),
SkipTestConfiguration = tc => !tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightInputContext_ModelRequiredForReading"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.EntitySet(),
SkipTestConfiguration = tc => tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightDeserializer_ContextLinkNotFoundAsFirstProperty"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.EntitySet(),
PayloadEdmModel = model,
SkipTestConfiguration = tc => !tc.IsRequest,
//ExpectedException = ODataExpectedExceptions.ODataException("ReaderValidationUtils_ResourceWithoutType"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.Entity(),
SkipTestConfiguration = tc => !tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightInputContext_ModelRequiredForReading"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.Entity(),
SkipTestConfiguration = tc => tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightDeserializer_ContextLinkNotFoundAsFirstProperty"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.Entity(),
PayloadEdmModel = model,
SkipTestConfiguration = tc => !tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ReaderValidationUtils_ResourceWithoutType"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.PrimitiveProperty("propertyName", 42),
SkipTestConfiguration = tc => !tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightInputContext_ModelRequiredForReading"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.Property("propertyName", PayloadBuilder.ComplexValue()),
SkipTestConfiguration = tc => !tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightInputContext_ModelRequiredForReading"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.Property("propertyName", PayloadBuilder.PrimitiveMultiValue()),
SkipTestConfiguration = tc => !tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightInputContext_ModelRequiredForReading"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.PrimitiveCollection(),
SkipTestConfiguration = tc => !tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightInputContext_ModelRequiredForReading"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.PrimitiveCollection(),
SkipTestConfiguration = tc => tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightDeserializer_ContextLinkNotFoundAsFirstProperty"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.PrimitiveCollection(),
//PayloadModel = model,
PayloadEdmModel = model,
SkipTestConfiguration = tc => !tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightInputContext_ItemTypeRequiredForCollectionReaderInRequests"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.ComplexCollection(),
SkipTestConfiguration = tc => !tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightInputContext_ModelRequiredForReading"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.ComplexCollection(),
SkipTestConfiguration = tc => tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightDeserializer_ContextLinkNotFoundAsFirstProperty"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.ComplexCollection(),
PayloadEdmModel = model,
SkipTestConfiguration = tc => !tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightInputContext_ItemTypeRequiredForCollectionReaderInRequests"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.ServiceDocument().Workspace(PayloadBuilder.Workspace()),
SkipTestConfiguration = tc => tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightDeserializer_ContextLinkNotFoundAsFirstProperty"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.DeferredLink("http://odata.org/deferred"),
SkipTestConfiguration = tc => !tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightInputContext_ModelRequiredForReading"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.DeferredLink("http://odata.org/deferred"),
SkipTestConfiguration = tc => tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightDeserializer_ContextLinkNotFoundAsFirstProperty"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.LinkCollection(),
SkipTestConfiguration = tc => tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightDeserializer_ContextLinkNotFoundAsFirstProperty"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.ComplexValue(),
SkipTestConfiguration = tc => !tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightInputContext_ModelRequiredForReading"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.ComplexValue(),
PayloadEdmModel = model,
SkipTestConfiguration = tc => !tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ArgumentNullException("ODataJsonLightInputContext_OperationCannotBeNullForCreateParameterReader", "operation")
},
};
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.ReaderTestConfigurationProvider.JsonLightFormatConfigurations,
(testDescriptor, testConfiguration) =>
{
// These descriptors are already tailored specifically for Json Light and
// do not require normalization.
testDescriptor.TestDescriptorNormalizers.Clear();
testDescriptor.RunTest(testConfiguration);
});
}
private static void AddOperations(this EdmModel model, IEnumerable <OperationConfiguration> configurations, EdmEntityContainer container,
Dictionary <Type, IEdmType> edmTypeMap, IDictionary <string, EdmNavigationSource> edmNavigationSourceMap)
{
Contract.Assert(model != null, "Model can't be null");
ValidateActionOverload(configurations.OfType <ActionConfiguration>());
foreach (OperationConfiguration operationConfiguration in configurations)
{
IEdmTypeReference returnReference = GetEdmTypeReference(edmTypeMap,
operationConfiguration.ReturnType,
operationConfiguration.ReturnType != null && operationConfiguration.ReturnNullable);
IEdmExpression expression = GetEdmEntitySetExpression(edmNavigationSourceMap, operationConfiguration);
IEdmPathExpression pathExpression = operationConfiguration.EntitySetPath != null
? new EdmPathExpression(operationConfiguration.EntitySetPath)
: null;
EdmOperationImport operationImport;
switch (operationConfiguration.Kind)
{
case OperationKind.Action:
operationImport = CreateActionImport(operationConfiguration, container, returnReference, expression, pathExpression);
break;
case OperationKind.Function:
operationImport = CreateFunctionImport((FunctionConfiguration)operationConfiguration, container, returnReference, expression, pathExpression);
break;
default:
Contract.Assert(false, "Unsupported OperationKind");
return;
}
EdmOperation operation = (EdmOperation)operationImport.Operation;
if (operationConfiguration.IsBindable && operationConfiguration.Title != null && operationConfiguration.Title != operationConfiguration.Name)
{
model.SetOperationTitleAnnotation(operation, new OperationTitleAnnotation(operationConfiguration.Title));
}
if (operationConfiguration.IsBindable &&
operationConfiguration.NavigationSource != null &&
edmNavigationSourceMap.ContainsKey(operationConfiguration.NavigationSource.Name))
{
model.SetAnnotationValue(operation, new ReturnedEntitySetAnnotation(operationConfiguration.NavigationSource.Name));
}
AddOperationParameters(operation, operationConfiguration, edmTypeMap);
if (operationConfiguration.IsBindable)
{
AddOperationLinkBuilder(model, operation, operationConfiguration);
ValidateOperationEntitySetPath(model, operationImport, operationConfiguration);
}
else
{
container.AddElement(operationImport);
}
model.AddElement(operation);
model.SetVocabularyConfigurationAnnotations(operation, operationConfiguration);
}
}
private static void AddProcedures(this EdmModel model, IEnumerable <ProcedureConfiguration> configurations, EdmEntityContainer container,
Dictionary <Type, IEdmType> edmTypeMap, IDictionary <string, EdmNavigationSource> edmNavigationSourceMap)
{
Contract.Assert(model != null, "Model can't be null");
ValidateActionOverload(configurations.OfType <ActionConfiguration>());
foreach (ProcedureConfiguration procedure in configurations)
{
IEdmTypeReference returnReference = GetEdmTypeReference(edmTypeMap,
procedure.ReturnType,
procedure.ReturnType != null && procedure.OptionalReturn);
IEdmExpression expression = GetEdmEntitySetExpression(edmNavigationSourceMap, procedure);
IEdmPathExpression pathExpression = procedure.EntitySetPath != null
? new EdmPathExpression(procedure.EntitySetPath)
: null;
EdmOperationImport operationImport;
switch (procedure.Kind)
{
case ProcedureKind.Action:
operationImport = CreateActionImport(procedure, container, returnReference, expression, pathExpression);
break;
case ProcedureKind.Function:
operationImport = CreateFunctionImport((FunctionConfiguration)procedure, container, returnReference, expression, pathExpression);
break;
case ProcedureKind.ServiceOperation:
Contract.Assert(false, "ServiceOperations are not supported.");
goto default;
default:
Contract.Assert(false, "Unsupported ProcedureKind");
return;
}
EdmOperation operation = (EdmOperation)operationImport.Operation;
if (procedure.IsBindable && procedure.Title != null & procedure.Title != procedure.Name)
{
model.SetOperationTitleAnnotation(operation, new OperationTitleAnnotation(procedure.Title));
}
if (procedure.IsBindable &&
procedure.NavigationSource != null &&
edmNavigationSourceMap.ContainsKey(procedure.NavigationSource.Name))
{
model.SetAnnotationValue(operation, new ReturnedEntitySetAnnotation(procedure.NavigationSource.Name));
}
AddProcedureParameters(operation, procedure, edmTypeMap);
if (procedure.IsBindable)
{
AddProcedureLinkBuilder(model, operation, procedure);
ValidateProcedureEntitySetPath(model, operationImport, procedure);
}
else
{
container.AddElement(operationImport);
}
model.AddElement(operation);
}
}
private static IEdmModel GetEdmModel()
{
EdmModel model = new EdmModel();
// Order
EdmEntityType order = new EdmEntityType("NS", "Order", null, false, true);
order.AddKeys(order.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
// Customer
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
customer.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
model.AddElement(customer);
// VipCustomer
EdmEntityType vipCustomer = new EdmEntityType("NS", "VipCustomer", customer);
model.AddElement(vipCustomer);
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
EdmEntitySet orders = container.AddEntitySet("Orders", order);
EdmEntitySet customers = container.AddEntitySet("Customers", customer);
EdmSingleton me = container.AddSingleton("Me", customer);
model.AddElement(container);
EdmNavigationProperty ordersNavProp = customer.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "Orders",
TargetMultiplicity = EdmMultiplicity.Many,
Target = order
});
customers.AddNavigationTarget(ordersNavProp, orders);
me.AddNavigationTarget(ordersNavProp, orders);
EdmNavigationProperty orderNavProp = customer.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "Order",
TargetMultiplicity = EdmMultiplicity.One,
Target = order
});
customers.AddNavigationTarget(orderNavProp, orders);
me.AddNavigationTarget(orderNavProp, orders);
EdmNavigationProperty subOrdersNavProp = customer.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "SubOrders",
TargetMultiplicity = EdmMultiplicity.Many,
Target = order
});
customers.AddNavigationTarget(subOrdersNavProp, orders, new EdmPathExpression("NS.VipCustomer/SubOrders"));
me.AddNavigationTarget(subOrdersNavProp, orders, new EdmPathExpression("NS.VipCustomer/SubOrders"));
EdmNavigationProperty subOrderNavProp = customer.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "SubOrder",
TargetMultiplicity = EdmMultiplicity.Many,
Target = order
});
customers.AddNavigationTarget(subOrderNavProp, orders, new EdmPathExpression("NS.VipCustomer/SubOrder"));
me.AddNavigationTarget(subOrderNavProp, orders, new EdmPathExpression("NS.VipCustomer/SubOrder"));
return(model);
}
/// <summary>
/// Get EdmModel
/// </summary>
/// <returns><see cref="IEdmModel"/></returns>
public virtual IEdmModel GetEdmModel()
{
var serviceContext = Dependencies.GetServiceContext();
var website = Dependencies.GetWebsite();
var model = new EdmModel();
var container = new EdmEntityContainer(NamespaceName, ContainerName);
model.AddElement(container);
model.SetIsDefaultEntityContainer(container, true);
var entitylists = GetEntityLists(website);
if (!entitylists.Any())
{
return(model);
}
var entityReferenceType = new EdmComplexType(NamespaceName, "EntityReference");
entityReferenceType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Guid);
entityReferenceType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
var picklistType = new EdmComplexType(NamespaceName, "OptionSet");
picklistType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
picklistType.AddStructuralProperty("Value", EdmPrimitiveTypeKind.Int32);
model.AddElement(entityReferenceType);
model.AddElement(picklistType);
var entitySetNames = new List <string>();
foreach (var entitylist in entitylists)
{
var entityListId = entitylist.GetAttributeValue <Guid>("adx_entitylistid");
var entityListEntityName = entitylist.GetAttributeValue <string>("adx_entityname");
var entityListEntityTypeName = entitylist.GetAttributeValue <string>("adx_odata_entitytypename");
var entityListEntitySetName = entitylist.GetAttributeValue <string>("adx_odata_entitysetname");
var entityTypeName = string.IsNullOrWhiteSpace(entityListEntityTypeName) ? entityListEntityName : entityListEntityTypeName;
var entitySetName = string.IsNullOrWhiteSpace(entityListEntitySetName) ? entityListEntityName : entityListEntitySetName;
var entityPermissionsEnabled = entitylist.GetAttributeValue <bool>("adx_entitypermissionsenabled");
if (entitySetNames.Contains(entitySetName))
{
ADXTrace.Instance.TraceError(TraceCategory.Application, string.Format(string.Format("An Entity Set has already been defined with the name '{0}'. Entity Set could not added to the model. You must not have multiple Entity List records with OData enabled and the same Entity Name specified, otherwise specifiy a unique Entity Set Name and Entity Type Name in the Entity List's OData Settings in CRM.", entitySetName)));
continue;
}
entitySetNames.Add(entitySetName);
var entityType = new EdmEntityType(NamespaceName, entityTypeName);
var viewIdString = entitylist.GetAttributeValue <string>("adx_odata_view");
if (string.IsNullOrWhiteSpace(viewIdString))
{
continue;
}
Guid viewId;
Guid.TryParse(viewIdString, out viewId);
var savedQuery = GetSavedQuery(viewId);
var view = new SavedQueryView(serviceContext, savedQuery, LanguageCode);
var columns = view.Columns;
var key = entityType.AddStructuralProperty(view.PrimaryKeyLogicalName, EdmPrimitiveTypeKind.Guid);
entityType.AddKeys(key);
foreach (var column in columns)
{
var attributeMetadata = column.Metadata;
var propertyName = column.LogicalName;
if (propertyName.Contains('.'))
{
propertyName = string.Format("{0}-{1}", column.Metadata.EntityLogicalName, column.Metadata.LogicalName);
}
var edmPrimitiveTypeKind = MetadataHelpers.GetEdmPrimitiveTypeKindFromAttributeMetadata(attributeMetadata);
if (edmPrimitiveTypeKind != null)
{
entityType.AddStructuralProperty(propertyName, edmPrimitiveTypeKind.GetValueOrDefault(EdmPrimitiveTypeKind.None));
}
else
{
switch (attributeMetadata.AttributeType)
{
case AttributeTypeCode.Customer:
case AttributeTypeCode.Lookup:
case AttributeTypeCode.Owner:
entityType.AddStructuralProperty(propertyName, new EdmComplexTypeReference(entityReferenceType, true));
break;
case AttributeTypeCode.Picklist:
case AttributeTypeCode.State:
case AttributeTypeCode.Status:
entityType.AddStructuralProperty(propertyName, new EdmComplexTypeReference(picklistType, true));
break;
}
}
}
entityType.AddProperty(new EdmStructuralProperty(entityType, "list-id", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, true), entityListId.ToString(), EdmConcurrencyMode.None));
entityType.AddProperty(new EdmStructuralProperty(entityType, "view-id", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, true), viewId.ToString(), EdmConcurrencyMode.None));
entityType.AddProperty(new EdmStructuralProperty(entityType, "entity-permissions-enabled", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, true), entityPermissionsEnabled.ToString(), EdmConcurrencyMode.None));
model.AddElement(entityType);
container.AddEntitySet(entitySetName, entityType);
}
return(model);
}
public void AssociationLinkOnNavigationLinkTest()
{
EdmModel model = new EdmModel();
var container = new EdmEntityContainer("TestModel", "Default");
model.AddElement(container);
var edmEntityTypeOrderType = new EdmEntityType("TestModel", "OrderType");
model.AddElement(edmEntityTypeOrderType);
var edmEntityTypeCustomerType = new EdmEntityType("TestModel", "CustomerType");
var edmNavigationPropertyAssociationLinkOne = edmEntityTypeCustomerType.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo {
Name = "NavProp1", Target = edmEntityTypeOrderType, TargetMultiplicity = EdmMultiplicity.One
});
var edmNavigationPropertyAssociationLinkTwo = edmEntityTypeCustomerType.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo {
Name = "NavProp2", Target = edmEntityTypeOrderType, TargetMultiplicity = EdmMultiplicity.Many
});
model.AddElement(edmEntityTypeCustomerType);
var customerSet = container.AddEntitySet("Customers", edmEntityTypeCustomerType);
var orderSet = container.AddEntitySet("Orders", edmEntityTypeOrderType);
customerSet.AddNavigationTarget(edmNavigationPropertyAssociationLinkOne, orderSet);
customerSet.AddNavigationTarget(edmNavigationPropertyAssociationLinkTwo, orderSet);
var testCases = new[]
{
// Both nav link URL and association link URL
new {
NavigationLink = new ODataNavigationLink()
{
Name = "NavProp1", IsCollection = false, Url = new Uri("http://odata.org/navlink"), AssociationLinkUrl = new Uri("http://odata.org/assoclink")
},
PropertyName = "NavProp1",
Atom = BuildXmlNavigationLink("NavProp1", "application/atom+xml;type=entry", "http://odata.org/navlink"),
JsonLight =
"\"" + JsonLightUtils.GetPropertyAnnotationName("NavProp1", JsonLightConstants.ODataNavigationLinkUrlAnnotationName) + "\":\"http://odata.org/navlink\"," +
"\"" + JsonLightUtils.GetPropertyAnnotationName("NavProp1", JsonLightConstants.ODataAssociationLinkUrlAnnotationName) + "\":\"http://odata.org/assoclink\""
},
// Just nav link URL
new {
NavigationLink = new ODataNavigationLink()
{
Name = "NavProp1", IsCollection = false, Url = new Uri("http://odata.org/navlink"), AssociationLinkUrl = null
},
PropertyName = "NavProp1",
Atom = BuildXmlNavigationLink("NavProp1", "application/atom+xml;type=entry", "http://odata.org/navlink"),
JsonLight = "\"" + JsonLightUtils.GetPropertyAnnotationName("NavProp1", JsonLightConstants.ODataNavigationLinkUrlAnnotationName) + "\":\"http://odata.org/navlink\""
},
// Just association link URL
new {
NavigationLink = new ODataNavigationLink()
{
Name = "NavProp1", IsCollection = false, Url = null, AssociationLinkUrl = new Uri("http://odata.org/assoclink")
},
PropertyName = "NavProp1",
Atom = (string)null,
JsonLight = "\"" + JsonLightUtils.GetPropertyAnnotationName("NavProp1", JsonLightConstants.ODataAssociationLinkUrlAnnotationName) + "\":\"http://odata.org/assoclink\""
},
// Navigation link with both URLs null
new {
NavigationLink = new ODataNavigationLink()
{
Name = "NavProp1", IsCollection = false, Url = null, AssociationLinkUrl = null
},
PropertyName = "NavProp1",
Atom = (string)null,
JsonLight = string.Empty
}
};
IEnumerable <PayloadWriterTestDescriptor <ODataItem> > testDescriptors = testCases.Select(testCase =>
{
ODataEntry entry = ObjectModelUtils.CreateDefaultEntry();
entry.TypeName = "TestModel.CustomerType";
return(new PayloadWriterTestDescriptor <ODataItem>(
this.Settings,
new ODataItem[] { entry, testCase.NavigationLink, null },
(testConfiguration) =>
{
if (testConfiguration.Format == ODataFormat.Atom)
{
return new AtomWriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
Xml = "<Links>" + testCase.Atom + "</Links>",
FragmentExtractor = (result) =>
{
var links = result.Elements(TestAtomConstants.AtomXNamespace + TestAtomConstants.AtomLinkElementName)
.Where(l => l.Attribute(TestAtomConstants.AtomLinkRelationAttributeName).Value.StartsWith(
TestAtomConstants.ODataNavigationPropertiesAssociationLinkRelationPrefix) ||
l.Attribute(TestAtomConstants.AtomLinkRelationAttributeName).Value.StartsWith(
TestAtomConstants.ODataNavigationPropertiesRelatedLinkRelationPrefix));
result = new XElement("Ref", links);
if (result.FirstNode == null)
{
result.Add("");
}
return result;
},
ExpectedException2 = testCase.Atom == null ? ODataExpectedExceptions.ODataException("WriterValidationUtils_NavigationLinkMustSpecifyUrl", testCase.PropertyName) : null
};
}
else if (testConfiguration.Format == ODataFormat.Json)
{
return new JsonWriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
Json = string.Join(
"$(NL)",
"{",
testCase.JsonLight,
"}"),
FragmentExtractor = (result) =>
{
var links = result.Object().GetPropertyAnnotations(testCase.PropertyName).ToList();
var jsonResult = new JsonObject();
links.ForEach(l =>
{
// NOTE we remove all annoatations here and in particular the text annotations to be able to easily compare
// against the expected results. This however means that we do not distinguish between the indented and non-indented case here.
l.RemoveAllAnnotations(true);
jsonResult.Add(l);
});
return jsonResult;
}
};
}
else
{
this.Settings.Assert.Fail("Unknown format '{0}'.", testConfiguration.Format);
return null;
}
})
{
Model = model,
PayloadEdmElementContainer = customerSet
});
});
// With and without model
testDescriptors = testDescriptors.SelectMany(td =>
new[]
{
td,
new PayloadWriterTestDescriptor <ODataItem>(td)
{
Model = null,
PayloadEdmElementContainer = null
}
});
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors.PayloadCases(WriterPayloads.EntryPayloads),
this.WriterTestConfigurationProvider.ExplicitFormatConfigurationsWithIndent.Where(testConfiguration => !testConfiguration.IsRequest),
(testDescriptor, testConfiguration) =>
{
testConfiguration = testConfiguration.Clone();
testConfiguration.MessageWriterSettings.SetServiceDocumentUri(ServiceDocumentUri);
if (testDescriptor.Model == null && testConfiguration.Format == ODataFormat.Json)
{
return;
}
if (testDescriptor.IsGeneratedPayload && testDescriptor.Model != null)
{
return;
}
TestWriterUtils.WriteAndVerifyODataPayload(testDescriptor, testConfiguration, this.Assert, this.Logger);
});
}
public ODataJsonLightReaderEnumIntegrationTests()
{
EdmModel tmpModel = new EdmModel();
// enum without flags
var enumType = new EdmEnumType("NS", "Color");
var red = new EdmEnumMember(enumType, "Red", new EdmIntegerConstant(1));
enumType.AddMember(red);
enumType.AddMember("Green", new EdmIntegerConstant(2));
enumType.AddMember("Blue", new EdmIntegerConstant(3));
tmpModel.AddElement(enumType);
// enum with flags
var enumFlagsType = new EdmEnumType("NS", "ColorFlags", isFlags: true);
enumFlagsType.AddMember("Red", new EdmIntegerConstant(1));
enumFlagsType.AddMember("Green", new EdmIntegerConstant(2));
enumFlagsType.AddMember("Blue", new EdmIntegerConstant(4));
tmpModel.AddElement(enumFlagsType);
this.entityType = new EdmEntityType("NS", "MyEntityType", isAbstract: false, isOpen: true, baseType: null);
EdmStructuralProperty floatId = new EdmStructuralProperty(this.entityType, "FloatId", EdmCoreModel.Instance.GetSingle(false));
this.entityType.AddKeys(floatId);
this.entityType.AddProperty(floatId);
var enumTypeReference = new EdmEnumTypeReference(enumType, true);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "Color", enumTypeReference));
var enumFlagsTypeReference = new EdmEnumTypeReference(enumFlagsType, false);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "ColorFlags", enumFlagsTypeReference));
// enum in complex type
EdmComplexType myComplexType = new EdmComplexType("NS", "MyComplexType");
myComplexType.AddProperty(new EdmStructuralProperty(myComplexType, "MyColorFlags", enumFlagsTypeReference));
myComplexType.AddProperty(new EdmStructuralProperty(myComplexType, "Height", EdmCoreModel.Instance.GetDouble(false)));
tmpModel.AddElement(myComplexType);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "MyComplexType", new EdmComplexTypeReference(myComplexType, true)));
// enum in derived complex type
EdmComplexType myDerivedComplexType = new EdmComplexType("NS", "MyDerivedComplexType", myComplexType, false);
myDerivedComplexType.AddProperty(new EdmStructuralProperty(myDerivedComplexType, "MyDerivedColorFlags", new EdmEnumTypeReference(enumFlagsType, false)));
tmpModel.AddElement(myDerivedComplexType);
// enum in collection type
EdmCollectionType myCollectionType = new EdmCollectionType(enumFlagsTypeReference);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "MyCollectionType", new EdmCollectionTypeReference(myCollectionType)));
tmpModel.AddElement(this.entityType);
var defaultContainer = new EdmEntityContainer("NS", "DefaultContainer_sub");
this.entitySet = new EdmEntitySet(defaultContainer, "MySet", this.entityType);
defaultContainer.AddEntitySet(this.entitySet.Name, this.entityType);
tmpModel.AddElement(defaultContainer);
this.userModel = TestUtils.WrapReferencedModelsToMainModel("NS", "DefaultContainer", tmpModel);
}
public void AssociationLinkMetadataValidationTest()
{
EdmModel model = new EdmModel();
var container = new EdmEntityContainer("TestModel", "Default");
model.AddElement(container);
var edmEntityTypeOrderType = new EdmEntityType("TestModel", "OrderType");
model.AddElement(edmEntityTypeOrderType);
var edmEntityTypeCustomerType = new EdmEntityType("TestModel", "CustomerType");
edmEntityTypeCustomerType.AddKeys(new EdmStructuralProperty(edmEntityTypeCustomerType, "ID", EdmCoreModel.Instance.GetInt32(false)));
edmEntityTypeCustomerType.AddStructuralProperty("PrimitiveProperty", EdmCoreModel.Instance.GetString(true));
var edmNavigationPropertyAssociationLinkOne = edmEntityTypeCustomerType.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo {
Name = "Orders", Target = edmEntityTypeOrderType, TargetMultiplicity = EdmMultiplicity.Many
});
var edmNavigationPropertyAssociationLinkTwo = edmEntityTypeCustomerType.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo {
Name = "BestFriend", Target = edmEntityTypeCustomerType, TargetMultiplicity = EdmMultiplicity.One
});
model.AddElement(edmEntityTypeCustomerType);
var edmEntityTypeOpenCustomerType = new EdmEntityType("TestModel", "OpenCustomerType", edmEntityTypeCustomerType, isAbstract: false, isOpen: true);
model.AddElement(edmEntityTypeOpenCustomerType);
var customerSet = container.AddEntitySet("Customers", edmEntityTypeCustomerType);
var orderSet = container.AddEntitySet("Orders", edmEntityTypeOrderType);
customerSet.AddNavigationTarget(edmNavigationPropertyAssociationLinkOne, orderSet);
customerSet.AddNavigationTarget(edmNavigationPropertyAssociationLinkTwo, customerSet);
Uri associationLinkUrl = new Uri("http://odata.org/associationlink");
var testCases = new[]
{
// Valid collection
new
{
TypeName = "TestModel.CustomerType",
NavigationLink = ObjectModelUtils.CreateDefaultCollectionLink("Orders"),
ExpectedException = (ExpectedException)null,
},
// Valid singleton
new
{
TypeName = "TestModel.CustomerType",
NavigationLink = ObjectModelUtils.CreateDefaultSingletonLink("BestFriend"),
ExpectedException = (ExpectedException)null,
},
// Undeclared on closed type
new
{
TypeName = "TestModel.CustomerType",
NavigationLink = ObjectModelUtils.CreateDefaultCollectionLink("NonExistant"),
ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_PropertyDoesNotExistOnType", "NonExistant", "TestModel.CustomerType"),
},
// Undeclared on open type
new
{
TypeName = "TestModel.OpenCustomerType",
NavigationLink = ObjectModelUtils.CreateDefaultCollectionLink("NonExistant"),
ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_OpenNavigationProperty", "NonExistant", "TestModel.OpenCustomerType"),
},
// Declared but of wrong kind
new
{
TypeName = "TestModel.CustomerType",
NavigationLink = ObjectModelUtils.CreateDefaultSingletonLink("PrimitiveProperty"),
ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_NavigationPropertyExpected", "PrimitiveProperty", "TestModel.CustomerType", "Structural"),
},
};
var testDescriptors = testCases.Select(testCase =>
{
ODataEntry entry = ObjectModelUtils.CreateDefaultEntry();
entry.TypeName = testCase.TypeName;
ODataNavigationLink navigationLink = testCase.NavigationLink;
navigationLink.AssociationLinkUrl = associationLinkUrl;
return(new PayloadWriterTestDescriptor <ODataItem>(
this.Settings,
new ODataItem[] { entry, navigationLink },
tc => tc.Format == ODataFormat.Atom ?
(WriterTestExpectedResults) new AtomWriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
ExpectedException2 = testCase.ExpectedException
} :
(WriterTestExpectedResults) new JsonWriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
ExpectedException2 = testCase.ExpectedException
})
{
Model = model,
PayloadEdmElementContainer = customerSet
});
});
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.WriterTestConfigurationProvider.AtomFormatConfigurations
.Where(testConfiguration => !testConfiguration.IsRequest),
(testDescriptor, testConfiguration) =>
{
testConfiguration = testConfiguration.Clone();
testConfiguration.MessageWriterSettings.SetServiceDocumentUri(ServiceDocumentUri);
TestWriterUtils.WriteAndVerifyODataPayload(testDescriptor, testConfiguration, this.Assert, this.Logger);
});
}
public EdmModel BuildEdmModel()
{
foreach (EntityTypeInfo typeInfo in _entityTypes.Values)
{
typeInfo.BuildProperties(_entityTypes, _enumTypes, _complexTypes);
}
foreach (EntityTypeInfo typeInfo in _entityTypes.Values)
{
foreach (FKeyInfo fkeyInfo in typeInfo.NavigationClrProperties)
{
fkeyInfo.EdmNavigationProperty = CreateNavigationProperty(fkeyInfo);
}
}
var edmModel = new EdmModel();
var container = new EdmEntityContainer("Default", "Container");
edmModel.AddElements(_enumTypes.Values);
foreach (KeyValuePair <Type, EdmEnumType> enumType in _enumTypes)
{
edmModel.SetAnnotationValue(enumType.Value, new OeClrTypeAnnotation(enumType.Key));
}
edmModel.AddElements(_complexTypes.Values);
foreach (KeyValuePair <Type, EdmComplexType> complexType in _complexTypes)
{
edmModel.SetAnnotationValue(complexType.Value, new OeClrTypeAnnotation(complexType.Key));
}
var entitySets = new Dictionary <IEdmEntityType, EdmEntitySet>(_entityTypes.Count);
foreach (EntityTypeInfo typeInfo in _entityTypes.Values)
{
edmModel.AddElement(typeInfo.EdmType);
edmModel.SetAnnotationValue(typeInfo.EdmType, new OeClrTypeAnnotation(typeInfo.ClrType));
entitySets.Add(typeInfo.EdmType, container.AddEntitySet(typeInfo.EntitySetName, typeInfo.EdmType));
}
foreach (EntityTypeInfo typeInfo in _entityTypes.Values)
{
foreach (FKeyInfo fkeyInfo in typeInfo.NavigationClrProperties)
{
EdmEntitySet principal = entitySets[fkeyInfo.PrincipalInfo.EdmType];
EdmEntitySet dependent = entitySets[fkeyInfo.DependentInfo.EdmType];
dependent.AddNavigationTarget(fkeyInfo.EdmNavigationProperty, principal);
if (fkeyInfo.EdmNavigationProperty.Partner != null)
{
principal.AddNavigationTarget(fkeyInfo.EdmNavigationProperty.Partner, dependent);
}
}
}
foreach (OeOperationConfiguration operationConfiguration in _operationConfigurations)
{
if (operationConfiguration.IsFunction)
{
EdmFunction edmFunction = BuildFunction(operationConfiguration);
if (edmFunction != null)
{
container.AddFunctionImport(edmFunction);
}
}
else
{
EdmAction edmAction = BuildAction(operationConfiguration);
if (edmAction != null)
{
container.AddActionImport(edmAction);
}
}
}
edmModel.AddElement(container);
return(edmModel);
}
public void AssociationLinkTest()
{
string associationLinkName1 = "AssociationLinkOne";
string linkUrl1 = "http://odata.org/associationlink";
Uri linkUrlUri1 = new Uri(linkUrl1);
string associationLinkName2 = "AssociationLinkTwo";
string linkUrl2 = "http://odata.org/associationlink2";
Uri linkUrlUri2 = new Uri(linkUrl2);
EdmModel model = new EdmModel();
var edmEntityTypeOrderType = new EdmEntityType("TestModel", "OrderType");
model.AddElement(edmEntityTypeOrderType);
var edmEntityTypeCustomerType = new EdmEntityType("TestModel", "CustomerType");
var edmNavigationPropertyAssociationLinkOne = edmEntityTypeCustomerType.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo {
Name = associationLinkName1, Target = edmEntityTypeOrderType, TargetMultiplicity = EdmMultiplicity.One
});
var edmNavigationPropertyAssociationLinkTwo = edmEntityTypeCustomerType.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo {
Name = associationLinkName2, Target = edmEntityTypeOrderType, TargetMultiplicity = EdmMultiplicity.Many
});
model.AddElement(edmEntityTypeCustomerType);
var container = new EdmEntityContainer("TestModel", "Default");
model.AddElement(container);
var customerSet = container.AddEntitySet("Customers", edmEntityTypeCustomerType);
var orderSet = container.AddEntitySet("Orders", edmEntityTypeOrderType);
customerSet.AddNavigationTarget(edmNavigationPropertyAssociationLinkOne, orderSet);
customerSet.AddNavigationTarget(edmNavigationPropertyAssociationLinkTwo, orderSet);
var testCases = new[]
{
new {
NavigationLink = ObjectModelUtils.CreateDefaultNavigationLink(associationLinkName1, linkUrlUri1),
Atom = BuildXmlAssociationLink(associationLinkName1, "application/xml", linkUrl1),
JsonLight = (string)null,
},
new {
NavigationLink = ObjectModelUtils.CreateDefaultNavigationLink(associationLinkName2, linkUrlUri2),
Atom = BuildXmlAssociationLink(associationLinkName2, "application/xml", linkUrl2),
JsonLight = (string)null
},
};
var testCasesWithMultipleLinks = testCases.Variations()
.Select(tcs =>
new
{
NavigationLinks = tcs.Select(tc => tc.NavigationLink),
Atom = string.Concat(tcs.Select(tc => tc.Atom)),
JsonLight = string.Join(",", tcs.Where(tc => tc.JsonLight != null).Select(tc => tc.JsonLight))
});
var testDescriptors = testCasesWithMultipleLinks.Select(testCase =>
{
ODataEntry entry = ObjectModelUtils.CreateDefaultEntry();
entry.TypeName = "TestModel.CustomerType";
List <ODataItem> items = new ODataItem[] { entry }.ToList();
foreach (var navLink in testCase.NavigationLinks)
{
items.Add(navLink);
items.Add(null);
}
return(new PayloadWriterTestDescriptor <ODataItem>(
this.Settings,
items,
(testConfiguration) =>
{
var firstAssocLink = testCase.NavigationLinks == null ? null : testCase.NavigationLinks.FirstOrDefault();
if (testConfiguration.Format == ODataFormat.Atom)
{
return new AtomWriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
Xml = "<AssociationLinks>" + testCase.Atom + "</AssociationLinks>",
FragmentExtractor = (result) =>
{
var links = result.Elements(TestAtomConstants.AtomXNamespace + TestAtomConstants.AtomLinkElementName)
.Where(l => l.Attribute(TestAtomConstants.AtomLinkRelationAttributeName).Value.StartsWith(
TestAtomConstants.ODataNavigationPropertiesAssociationLinkRelationPrefix));
result = new XElement("AssociationLinks", links);
if (result.FirstNode == null)
{
result.Add("");
}
return result;
},
ExpectedException2 = testConfiguration.IsRequest && firstAssocLink != null
? ODataExpectedExceptions.ODataException("ODataWriterCore_DeferredLinkInRequest")
: null
};
}
else if (testConfiguration.Format == ODataFormat.Json)
{
return new JsonWriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
Json = string.Join(
"$(NL)",
"{",
testCase.JsonLight,
"}"),
FragmentExtractor = (result) =>
{
var associationLinks = result.Object().GetAnnotationsWithName("@" + JsonLightConstants.ODataAssociationLinkUrlAnnotationName).ToList();
var jsonResult = new JsonObject();
associationLinks.ForEach(l =>
{
// NOTE we remove all annoatations here and in particular the text annotations to be able to easily compare
// against the expected results. This however means that we do not distinguish between the indented and non-indented case here.
l.RemoveAllAnnotations(true);
jsonResult.Add(l);
});
return jsonResult;
},
};
}
else
{
this.Settings.Assert.Fail("Unknown format '{0}'.", testConfiguration.Format);
return null;
}
})
{
Model = model,
PayloadEdmElementContainer = customerSet
});
});
// With and without model
testDescriptors = testDescriptors.SelectMany(td =>
new[]
{
td,
new PayloadWriterTestDescriptor <ODataItem>(td)
{
Model = null,
PayloadEdmElementContainer = null
}
});
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors.PayloadCases(WriterPayloads.EntryPayloads),
this.WriterTestConfigurationProvider.ExplicitFormatConfigurationsWithIndent,
(testDescriptor, testConfiguration) =>
{
testConfiguration = testConfiguration.Clone();
testConfiguration.MessageWriterSettings.SetServiceDocumentUri(ServiceDocumentUri);
if (testDescriptor.Model == null && testConfiguration.Format == ODataFormat.Json)
{
return;
}
if (testDescriptor.IsGeneratedPayload && testDescriptor.Model != null)
{
return;
}
TestWriterUtils.WriteAndVerifyODataPayload(testDescriptor, testConfiguration, this.Assert, this.Logger);
});
}
public static IEdmModel SimpleCustomerOrderModel()
{
var model = new EdmModel();
var customerType = new EdmEntityType("Default", "Customer");
customerType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32);
customerType.AddStructuralProperty("FirstName", EdmPrimitiveTypeKind.String);
customerType.AddStructuralProperty("LastName", EdmPrimitiveTypeKind.String);
IEdmTypeReference primitiveTypeReference = EdmCoreModel.Instance.GetPrimitive(
EdmPrimitiveTypeKind.String,
isNullable: true);
customerType.AddStructuralProperty(
"City",
primitiveTypeReference,
defaultValue: null,
concurrencyMode: EdmConcurrencyMode.Fixed);
model.AddElement(customerType);
var specialCustomerType = new EdmEntityType("Default", "SpecialCustomer", customerType);
model.AddElement(specialCustomerType);
var orderType = new EdmEntityType("Default", "Order");
orderType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32);
orderType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
orderType.AddStructuralProperty("Shipment", EdmPrimitiveTypeKind.String);
model.AddElement(orderType);
var specialOrderType = new EdmEntityType("Default", "SpecialOrder", orderType);
model.AddElement(specialOrderType);
var addressType = new EdmComplexType("Default", "Address");
addressType.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
addressType.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
addressType.AddStructuralProperty("State", EdmPrimitiveTypeKind.String);
addressType.AddStructuralProperty("Country", EdmPrimitiveTypeKind.String);
addressType.AddStructuralProperty("ZipCode", EdmPrimitiveTypeKind.String);
model.AddElement(addressType);
// add a derived complex type "UsAddress"
var usAddressType = new EdmComplexType("Default", "UsAddress", addressType);
usAddressType.AddStructuralProperty("UsProp", EdmPrimitiveTypeKind.String);
model.AddElement(usAddressType);
// add a derived complex type "CnAddress"
var cnAddressType = new EdmComplexType("Default", "CnAddress", addressType);
cnAddressType.AddStructuralProperty("CnProp", EdmPrimitiveTypeKind.Guid);
model.AddElement(cnAddressType);
// Add navigations
customerType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Orders", Target = orderType, TargetMultiplicity = EdmMultiplicity.Many
});
orderType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Customer", Target = customerType, TargetMultiplicity = EdmMultiplicity.One
});
specialCustomerType.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "SpecialOrders",
Target = specialOrderType,
TargetMultiplicity = EdmMultiplicity.Many
});
orderType.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "SpecialCustomer",
Target = specialCustomerType,
TargetMultiplicity = EdmMultiplicity.One
});
// Add Entity set
var container = new EdmEntityContainer("Default", "Container");
var customerSet = container.AddEntitySet("Customers", customerType);
var orderSet = container.AddEntitySet("Orders", orderType);
customerSet.AddNavigationTarget(customerType.NavigationProperties().Single(np => np.Name == "Orders"), orderSet);
customerSet.AddNavigationTarget(
specialCustomerType.NavigationProperties().Single(np => np.Name == "SpecialOrders"),
orderSet);
orderSet.AddNavigationTarget(orderType.NavigationProperties().Single(np => np.Name == "Customer"), customerSet);
orderSet.AddNavigationTarget(
specialOrderType.NavigationProperties().Single(np => np.Name == "SpecialCustomer"),
customerSet);
NavigationSourceLinkBuilderAnnotation linkAnnotation = new MockNavigationSourceLinkBuilderAnnotation();
model.SetNavigationSourceLinkBuilder(customerSet, linkAnnotation);
model.SetNavigationSourceLinkBuilder(orderSet, linkAnnotation);
model.AddElement(container);
return(model);
}
private static IEdmModel CreateEdmModel()
{
var model = new EdmModel();
var coreDescription = CoreVocabularyModel.DescriptionTerm;
var enumType = new EdmEnumType("DefaultNs", "Color");
var blue = enumType.AddMember("Blue", new EdmEnumMemberValue(0));
enumType.AddMember("White", new EdmEnumMemberValue(1));
model.AddElement(enumType);
var annotation = new EdmVocabularyAnnotation(enumType, coreDescription, new EdmStringConstant("Enum type 'Color' description."));
model.AddVocabularyAnnotation(annotation);
var person = new EdmEntityType("DefaultNs", "Person");
var entityId = person.AddStructuralProperty("UserName", EdmCoreModel.Instance.GetString(false));
person.AddKeys(entityId);
var city = new EdmEntityType("DefaultNs", "City");
var cityId = city.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false));
city.AddKeys(cityId);
var countryOrRegion = new EdmEntityType("DefaultNs", "CountryOrRegion");
var countryId = countryOrRegion.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false));
countryOrRegion.AddKeys(countryId);
var complex = new EdmComplexType("DefaultNs", "Address");
complex.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(false));
var navP = complex.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo()
{
Name = "City",
Target = city,
TargetMultiplicity = EdmMultiplicity.One,
});
var derivedComplex = new EdmComplexType("DefaultNs", "WorkAddress", complex);
var navP2 = derivedComplex.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo()
{
Name = "CountryOrRegion",
Target = countryOrRegion,
TargetMultiplicity = EdmMultiplicity.One,
});
person.AddStructuralProperty("HomeAddress", new EdmComplexTypeReference(complex, false));
person.AddStructuralProperty("WorkAddress", new EdmComplexTypeReference(complex, false));
person.AddStructuralProperty("Addresses",
new EdmCollectionTypeReference(new EdmCollectionType(new EdmComplexTypeReference(complex, false))));
model.AddElement(person);
model.AddElement(city);
model.AddElement(countryOrRegion);
model.AddElement(complex);
model.AddElement(derivedComplex);
var entityContainer = new EdmEntityContainer("DefaultNs", "Container");
model.AddElement(entityContainer);
EdmSingleton me = new EdmSingleton(entityContainer, "Me", person);
EdmEntitySet people = new EdmEntitySet(entityContainer, "People", person);
EdmEntitySet cities = new EdmEntitySet(entityContainer, "City", city);
EdmEntitySet countriesOrRegions = new EdmEntitySet(entityContainer, "CountryOrRegion", countryOrRegion);
people.AddNavigationTarget(navP, cities, new EdmPathExpression("HomeAddress/City"));
people.AddNavigationTarget(navP, cities, new EdmPathExpression("Addresses/City"));
people.AddNavigationTarget(navP2, countriesOrRegions,
new EdmPathExpression("WorkAddress/DefaultNs.WorkAddress/CountryOrRegion"));
entityContainer.AddElement(people);
entityContainer.AddElement(cities);
entityContainer.AddElement(countriesOrRegions);
entityContainer.AddElement(me);
annotation = new EdmVocabularyAnnotation(people, coreDescription, new EdmStringConstant("People's description."));
model.AddVocabularyAnnotation(annotation);
var coreLongDescription = CoreVocabularyModel.LongDescriptionTerm;
annotation = new EdmVocabularyAnnotation(people, coreLongDescription, new EdmStringConstant("People's Long description."));
model.AddVocabularyAnnotation(annotation);
return(model);
}
public static IEdmModel GetEdmModel1()
{
EdmModel model = new EdmModel();
// Complex Type
EdmComplexType address = new EdmComplexType("WebApiDocNS", "Address");
address.AddStructuralProperty("Country", EdmPrimitiveTypeKind.String);
address.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
model.AddElement(address);
EdmComplexType subAddress = new EdmComplexType("WebApiDocNS", "SubAddress", address);
subAddress.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
model.AddElement(subAddress);
// Enum type
EdmEnumType color = new EdmEnumType("WebApiDocNS", "Color");
color.AddMember(new EdmEnumMember(color, "Red", new EdmEnumMemberValue(0)));
color.AddMember(new EdmEnumMember(color, "Blue", new EdmEnumMemberValue(1)));
color.AddMember(new EdmEnumMember(color, "Green", new EdmEnumMemberValue(2)));
model.AddElement(color);
// Entity type
EdmEntityType customer = new EdmEntityType("WebApiDocNS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("CustomerId", EdmPrimitiveTypeKind.Int32));
customer.AddStructuralProperty("Location", new EdmComplexTypeReference(address, isNullable: true));
model.AddElement(customer);
EdmEntityType vipCustomer = new EdmEntityType("WebApiDocNS", "VipCustomer", customer);
vipCustomer.AddStructuralProperty("FavoriteColor", new EdmEnumTypeReference(color, isNullable: false));
model.AddElement(vipCustomer);
EdmEntityType order = new EdmEntityType("WebApiDocNS", "Order");
order.AddKeys(order.AddStructuralProperty("OrderId", EdmPrimitiveTypeKind.Int32));
order.AddStructuralProperty("Token", EdmPrimitiveTypeKind.Guid);
model.AddElement(order);
EdmEntityContainer container = new EdmEntityContainer("WebApiDocNS", "Container");
EdmEntitySet customers = container.AddEntitySet("Customers", customer);
EdmEntitySet orders = container.AddEntitySet("Orders", order);
model.AddElement(container);
// EdmSingleton mary = container.AddSingleton("Mary", customer);
// navigation properties
EdmNavigationProperty ordersNavProp = customer.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "Orders",
TargetMultiplicity = EdmMultiplicity.Many,
Target = order
});
customers.AddNavigationTarget(ordersNavProp, orders);
// function
IEdmTypeReference stringType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, isNullable: false);
IEdmTypeReference intType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false);
EdmFunction getFirstName = new EdmFunction("WebApiDocNS", "GetFirstName", stringType, isBound: true, entitySetPathExpression: null, isComposable: false);
getFirstName.AddParameter("entity", new EdmEntityTypeReference(customer, false));
model.AddElement(getFirstName);
EdmFunction getNumber = new EdmFunction("WebApiDocNS", "GetOrderCount", intType, isBound: false, entitySetPathExpression: null, isComposable: false);
model.AddElement(getNumber);
container.AddFunctionImport("GetOrderCount", getNumber);
// action
EdmAction calculate = new EdmAction("WebApiDocNS", "CalculateOrderPrice", returnType: null, isBound: true, entitySetPathExpression: null);
calculate.AddParameter("entity", new EdmEntityTypeReference(customer, false));
model.AddElement(calculate);
EdmAction change = new EdmAction("WebApiDocNS", "ChangeCustomerById", returnType: null, isBound: false, entitySetPathExpression: null);
change.AddParameter("Id", intType);
model.AddElement(change);
container.AddActionImport("ChangeCustomerById", change);
return(model);
}
private static IEdmModel CreateMultipleInheritanceEdmModel()
{
var model = new EdmModel();
// enum type
var colorEnumType = new EdmEnumType("NS", "Color");
colorEnumType.AddMember("Blue", new EdmEnumMemberValue(0));
colorEnumType.AddMember("While", new EdmEnumMemberValue(1));
colorEnumType.AddMember("Red", new EdmEnumMemberValue(2));
colorEnumType.AddMember("Yellow", new EdmEnumMemberValue(3));
model.AddElement(colorEnumType);
var oceanEnumType = new EdmEnumType("NS", "Ocean");
oceanEnumType.AddMember("Atlantic", new EdmEnumMemberValue(0));
oceanEnumType.AddMember("Pacific", new EdmEnumMemberValue(1));
oceanEnumType.AddMember("India", new EdmEnumMemberValue(2));
oceanEnumType.AddMember("Arctic", new EdmEnumMemberValue(3));
model.AddElement(oceanEnumType);
var continentEnumType = new EdmEnumType("NS", "Continent");
continentEnumType.AddMember("Asia", new EdmEnumMemberValue(0));
continentEnumType.AddMember("Europe", new EdmEnumMemberValue(1));
continentEnumType.AddMember("Antarctica", new EdmEnumMemberValue(2));
model.AddElement(continentEnumType);
// top level entity type
var zoo = new EdmEntityType("NS", "Zoo");
var zooId = zoo.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(false));
zoo.AddKeys(zooId);
model.AddElement(zoo);
// abstract entity type "Creature"
var creature = new EdmEntityType("NS", "Creature", null, true, true);
creature.AddKeys(creature.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(false)));
model.AddElement(creature);
var animal = new EdmEntityType("NS", "Animal", creature, true, true);
animal.AddStructuralProperty("Age", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(animal);
var human = new EdmEntityType("NS", "Human", animal, false, true);
human.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false));
model.AddElement(human);
var horse = new EdmEntityType("NS", "Horse", animal, false, true);
horse.AddStructuralProperty("Height", EdmCoreModel.Instance.GetDecimal(false));
model.AddElement(horse);
EdmNavigationPropertyInfo navInfo = new EdmNavigationPropertyInfo
{
Name = "Creatures",
Target = creature,
TargetMultiplicity = EdmMultiplicity.Many,
};
zoo.AddUnidirectionalNavigation(navInfo);
// complex type
var plant = new EdmComplexType("NS", "Plant", null, true, true);
plant.AddStructuralProperty("Color", new EdmEnumTypeReference(colorEnumType, isNullable: false));
model.AddElement(plant);
// ocean plant
var oceanPlant = new EdmComplexType("NS", "OceanPlant", plant, true, true);
oceanPlant.AddStructuralProperty("Ocean", new EdmEnumTypeReference(oceanEnumType, isNullable: false));
model.AddElement(oceanPlant);
var kelp = new EdmComplexType("NS", "Kelp", oceanPlant, false, true);
kelp.AddStructuralProperty("Length", EdmCoreModel.Instance.GetDouble(false));
model.AddElement(kelp);
// land plant
var landPlant = new EdmComplexType("NS", "LandPlant", plant, true, true);
landPlant.AddStructuralProperty("Continent", new EdmEnumTypeReference(continentEnumType, isNullable: false));
landPlant.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false));
model.AddElement(landPlant);
var tree = new EdmComplexType("NS", "Tree", landPlant, false, true);
tree.AddStructuralProperty("Price", EdmCoreModel.Instance.GetDecimal(false));
model.AddElement(tree);
var flower = new EdmComplexType("NS", "Flower", landPlant, false, true);
flower.AddStructuralProperty("Height", EdmCoreModel.Instance.GetDouble(false));
model.AddElement(flower);
// address
var address = new EdmComplexType("NS", "Address");
address.AddStructuralProperty("Street", EdmCoreModel.Instance.GetString(true));
address.AddStructuralProperty("City", EdmCoreModel.Instance.GetString(true));
model.AddElement(address);
var coreDescription = CoreVocabularyModel.DescriptionTerm;
var annotation = new EdmVocabularyAnnotation(address, coreDescription, new EdmStringConstant("Complex type 'Address' description."));
model.AddVocabularyAnnotation(annotation);
annotation = new EdmVocabularyAnnotation(tree, coreDescription, new EdmStringConstant("Complex type 'Tree' description."));
model.AddVocabularyAnnotation(annotation);
annotation = new EdmVocabularyAnnotation(zoo, coreDescription, new EdmStringConstant("Entity type 'Zoo' description."));
model.AddVocabularyAnnotation(annotation);
annotation = new EdmVocabularyAnnotation(human, coreDescription, new EdmStringConstant("Entity type 'Human' description."));
model.AddVocabularyAnnotation(annotation);
return(model);
}
public void CollectionValueTest()
{
EdmModel model = new EdmModel();
var complexType = new EdmComplexType("TestModel", "ComplexType").Property("Name", EdmPrimitiveTypeKind.String, true);
model.AddElement(complexType);
var owningType = new EdmEntityType("TestModel", "OwningType");
owningType.AddKeys(owningType.AddStructuralProperty("ID", EdmCoreModel.Instance.GetInt32(false)));
owningType.AddStructuralProperty("PrimitiveCollection", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetInt32(false)));
model.AddElement(owningType);
model.Fixup();
var primitiveMultiValue = PayloadBuilder.PrimitiveMultiValue("Collection(Edm.Int32)").Item(42).Item(43);
IEnumerable <PayloadReaderTestDescriptor> testDescriptors = new[]
{
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "null collection in request - should fail.",
PayloadEdmModel = model,
PayloadElement = PayloadBuilder.Property("PrimitiveCollection",
PayloadBuilder.PrimitiveMultiValue("Collection(Edm.Int32)"))
.JsonRepresentation("{\"value\":null }")
.ExpectedProperty(owningType, "PrimitiveCollection"),
SkipTestConfiguration = tc => !tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ReaderValidationUtils_NullNamedValueForNonNullableType", "value", "Collection(Edm.Int32)")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "null collection in response - should fail.",
PayloadEdmModel = model,
PayloadElement = PayloadBuilder.Property("PrimitiveCollection",
PayloadBuilder.PrimitiveMultiValue("Collection(Edm.Int32)"))
.JsonRepresentation(
"{" +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\"," +
"\"value\":null" +
"}")
.ExpectedProperty(owningType, "PrimitiveCollection"),
SkipTestConfiguration = tc => tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ReaderValidationUtils_NullNamedValueForNonNullableType", "value", "Collection(Edm.Int32)")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Primitive value for collection - should fail.",
PayloadEdmModel = model,
PayloadElement = PayloadBuilder.Property("PrimitiveCollection",
PayloadBuilder.PrimitiveMultiValue("Collection(Edm.Int32)")
.JsonRepresentation("42"))
.ExpectedProperty(owningType, "PrimitiveCollection"),
ExpectedException = ODataExpectedExceptions.ODataException("JsonReaderExtensions_UnexpectedNodeDetected", "StartArray", "PrimitiveValue")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Object value for collection - should fail.",
PayloadEdmModel = model,
PayloadElement = PayloadBuilder.Property("PrimitiveCollection",
PayloadBuilder.PrimitiveMultiValue("Collection(Edm.Int32)")
.JsonRepresentation("{}"))
.ExpectedProperty(owningType, "PrimitiveCollection"),
ExpectedException = ODataExpectedExceptions.ODataException("JsonReaderExtensions_UnexpectedNodeDetectedWithPropertyName", "StartArray", "StartObject", "value")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Simple primitive collection.",
PayloadEdmModel = model,
PayloadElement = PayloadBuilder.Property("PrimitiveCollection",
primitiveMultiValue
.JsonRepresentation("[42,43]")
.AddAnnotation(new SerializationTypeNameTestAnnotation()
{
TypeName = null
}))
.ExpectedProperty(owningType, "PrimitiveCollection"),
ExpectedResultPayloadElement = tc => tc.IsRequest
? PayloadBuilder.Property(string.Empty, primitiveMultiValue)
: PayloadBuilder.Property("PrimitiveCollection", primitiveMultiValue)
},
};
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.ReaderTestConfigurationProvider.JsonLightFormatConfigurations,
(testDescriptor, testConfiguration) =>
{
// These descriptors are already tailored specifically for Json Light and
// do not require normalization.
testDescriptor.TestDescriptorNormalizers.Clear();
testDescriptor.RunTest(testConfiguration);
});
}
public void ComplexValueTest()
{
var injectedProperties = new[]
{
new
{
InjectedJSON = string.Empty,
ExpectedException = (ExpectedException)null
},
new
{
InjectedJSON = "\"@custom.annotation\": null",
ExpectedException = (ExpectedException)null
},
new
{
InjectedJSON = "\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataAnnotationNamespacePrefix + "unknown\": { }",
ExpectedException = (ExpectedException)null
},
new
{
InjectedJSON = "\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\": { }",
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightPropertyAndValueDeserializer_UnexpectedAnnotationProperties", JsonLightConstants.ODataContextAnnotationName)
},
new
{
InjectedJSON = "\"@custom.annotation\": null, \"@custom.annotation\": 42",
ExpectedException = (ExpectedException)null
},
};
var payloads = new[]
{
new
{
Json = "{0}",
ExpectedValue = PayloadBuilder.Entity("TestModel.ComplexType").IsComplex(true)
},
new
{
Json = "{0}{1} \"Name\": \"Value\"",
ExpectedValue = PayloadBuilder.Entity("TestModel.ComplexType")
.PrimitiveProperty("Name", "Value").IsComplex(true)
},
new
{
Json = "\"Name\": \"Value\"{1}{0}",
ExpectedValue = PayloadBuilder.Entity("TestModel.ComplexType")
.PrimitiveProperty("Name", "Value").IsComplex(true)
},
new
{
Json = "\"Name\":\"Value\",{0}{1}\"City\":\"Redmond\"",
ExpectedValue = PayloadBuilder.Entity("TestModel.ComplexType")
.PrimitiveProperty("Name", "Value")
.PrimitiveProperty("City", "Redmond")
.IsComplex(true)
},
};
EdmModel model = new EdmModel();
var addressType = new EdmComplexType("TestModel", "Address");
addressType.AddStructuralProperty("Street", EdmCoreModel.Instance.GetString(isNullable: false));
var complexType = new EdmComplexType("TestModel", "ComplexType");
complexType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(isNullable: false));
complexType.AddStructuralProperty("City", EdmCoreModel.Instance.GetString(isNullable: false));
complexType.AddStructuralProperty("Address", new EdmComplexTypeReference(addressType, isNullable: false));
complexType.AddStructuralProperty("Location", EdmPrimitiveTypeKind.GeographyPoint);
var owningType = new EdmEntityType("TestModel", "OwningType");
owningType.AddKeys(owningType.AddStructuralProperty("ID", EdmCoreModel.Instance.GetInt32(isNullable: false)));
owningType.AddStructuralProperty("TopLevelProperty", new EdmComplexTypeReference(complexType, isNullable: true));
model.AddElement(owningType);
model.AddElement(addressType);
model.AddElement(complexType);
var container = new EdmEntityContainer("TestModel", "DefaultContainer");
container.AddEntitySet("OwningType", owningType);
model.AddElement(container);
IEnumerable <PayloadReaderTestDescriptor> testDescriptors = payloads.SelectMany(payload => injectedProperties.Select(injectedProperty =>
{
var json = string.Format(payload.Json, injectedProperty.InjectedJSON, string.IsNullOrEmpty(injectedProperty.InjectedJSON) ? string.Empty : ",");
json = string.Format("{{{0}{1}{2}}}",
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#TestModel.ComplexType\"",
string.IsNullOrEmpty(json) ? string.Empty : ",", json);
return(new PayloadReaderTestDescriptor(this.Settings)
{
PayloadKind = ODataPayloadKind.Resource,
PayloadElement = payload.ExpectedValue.DeepCopy()
.JsonRepresentation(json)
// JSON Light payloads don't store complex type names since the type can be inferred from the context URI and or API.
.SetAnnotation(new SerializationTypeNameTestAnnotation()
{
TypeName = null
})
.ExpectedEntityType(complexType),
PayloadEdmModel = model,
ExpectedException = injectedProperty.ExpectedException,
ExpectedResultPayloadElement = tc => tc.IsRequest
? payload.ExpectedValue
.SetAnnotation(new SerializationTypeNameTestAnnotation()
{
TypeName = null
}).IsComplex(true)
: payload.ExpectedValue
.SetAnnotation(new SerializationTypeNameTestAnnotation()
{
TypeName = null
}).IsComplex(true)
});
}));
var explicitPayloadsForPrimitiveAndArray = new[]
{
new
{
Description = "Primitive value as complex - should fail.",
Json = "42",
ExpectedPayload = PayloadBuilder.Entity("TestModel.ComplexType"),
ExpectedException = ODataExpectedExceptions.ODataException("JsonReaderExtensions_UnexpectedNodeDetected", "StartObject", "PrimitiveValue")
},
new
{
Description = "Array value as complex - should fail.",
Json = "[]",
ExpectedPayload = PayloadBuilder.Entity("TestModel.ComplexType"),
ExpectedException = ODataExpectedExceptions.ODataException("JsonReaderExtensions_UnexpectedNodeDetected", "StartObject", "StartArray")
},
};
testDescriptors = testDescriptors.Concat(explicitPayloadsForPrimitiveAndArray.Select(payload =>
{
return(new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = payload.ExpectedPayload.DeepCopy()
.JsonRepresentation(payload.Json)
// JSON Light payloads don't store complex type names since the type can be inferred from the context URI and or API.
.SetAnnotation(new SerializationTypeNameTestAnnotation()
{
TypeName = null
})
.ExpectedEntityType(complexType),
PayloadEdmModel = model,
ExpectedException = payload.ExpectedException,
DebugDescription = payload.Description,
ExpectedResultPayloadElement = tc => payload.ExpectedPayload.DeepCopy()
.SetAnnotation(new SerializationTypeNameTestAnnotation()
{
TypeName = null
})
});
}));
var explicitPayloads = new[]
{
new
{
Description = "Type annotation preceded by custom annotation - should fail",
Json = "\"@custom.annotation\": null," +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataTypeAnnotationName + "\": \"TestModel.ComplexType\"," +
"\"Name\": \"Value\"",
ExpectedPayload = PayloadBuilder.Entity("TestModel.ComplexType"),
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightResourceDeserializer_ResourceTypeAnnotationNotFirst")
},
new
{
Description = "Custom property annotation - should be ignored.",
Json = "\"" + JsonLightUtils.GetPropertyAnnotationName("Name", "custom.annotation") + "\": null," +
"\"Name\": \"Value\"",
ExpectedPayload = PayloadBuilder.Entity("TestModel.ComplexType")
.PrimitiveProperty("Name", "Value").IsComplex(true),
ExpectedException = (ExpectedException)null
},
new
{
Description = "Duplicate custom property annotation - should not fail.",
Json = "\"" + JsonLightUtils.GetPropertyAnnotationName("Name", "custom.annotation") + "\": null," +
"\"" + JsonLightUtils.GetPropertyAnnotationName("Name", "custom.annotation") + "\": 42," +
"\"Name\": \"Value\"",
ExpectedPayload = PayloadBuilder.Entity("TestModel.ComplexType")
.PrimitiveProperty("Name", "Value").IsComplex(true),
ExpectedException = (ExpectedException)null
},
new
{
Description = "Unrecognized odata property annotation - should fail.",
Json = "\"" + JsonLightUtils.GetPropertyAnnotationName("Name", JsonLightConstants.ODataAnnotationNamespacePrefix + "unknown") + "\": null," +
"\"Name\": \"Value\"",
ExpectedPayload = PayloadBuilder.Entity("TestModel.ComplexType").PrimitiveProperty("Name", "Value").IsComplex(true),
ExpectedException = (ExpectedException)null
},
new
{
Description = "Custom property annotation after the property - should fail.",
Json = "\"Name\": \"Value\"," +
"\"" + JsonLightUtils.GetPropertyAnnotationName("Name", "custom.annotation") + "\": null",
ExpectedPayload = PayloadBuilder.Entity("TestModel.ComplexType").IsComplex(true),
ExpectedException = ODataExpectedExceptions.ODataException("PropertyAnnotationAfterTheProperty", "custom.annotation", "Name")
},
new
{
Description = "OData property annotation.",
Json = "\"" + JsonLightUtils.GetPropertyAnnotationName("Name", JsonLightConstants.ODataTypeAnnotationName) + "\": \"Edm.String\"," +
"\"Name\": \"Value\"",
ExpectedPayload = PayloadBuilder.Entity("TestModel.ComplexType")
.PrimitiveProperty("Name", "Value").IsComplex(true),
ExpectedException = (ExpectedException)null
},
new
{
Description = "Duplicate odata property annotation.",
Json = "\"" + JsonLightUtils.GetPropertyAnnotationName("Name", JsonLightConstants.ODataTypeAnnotationName) + "\": \"Edm.Int32\"," +
"\"" + JsonLightUtils.GetPropertyAnnotationName("Name", JsonLightConstants.ODataTypeAnnotationName) + "\": \"Edm.String\"," +
"\"Name\": \"Value\"",
ExpectedPayload = PayloadBuilder.Entity("TestModel.ComplexType").IsComplex(true),
ExpectedException = ODataExpectedExceptions.ODataException("DuplicateAnnotationForPropertyNotAllowed", JsonLightConstants.ODataTypeAnnotationName, "Name")
},
new
{
Description = "Property with object value and type name annotation - should fail.",
Json = "\"" + JsonLightUtils.GetPropertyAnnotationName("Address", JsonLightConstants.ODataTypeAnnotationName) + "\":\"TestModel.Address\"," +
"\"Address\":{}",
ExpectedPayload = PayloadBuilder.Entity("TestModel.ComplexType").IsComplex(true),
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightPropertyAndValueDeserializer_ComplexValueWithPropertyTypeAnnotation", JsonLightConstants.ODataTypeAnnotationName)
},
new
{
Description = "String property with type annotation after the property - should fail.",
Json = "\"Name\":\"value\"," +
"\"" + JsonLightUtils.GetPropertyAnnotationName("Name", JsonLightConstants.ODataTypeAnnotationName) + "\":\"Edm.String\"",
ExpectedPayload = PayloadBuilder.Entity("TestModel.ComplexType").IsComplex(true),
ExpectedException = ODataExpectedExceptions.ODataException("PropertyAnnotationAfterTheProperty", JsonLightConstants.ODataTypeAnnotationName, "Name")
},
new
{
Description = "String property with null type annotation - should fail.",
Json = "\"" + JsonLightUtils.GetPropertyAnnotationName("Name", JsonLightConstants.ODataTypeAnnotationName) + "\":null," +
"\"Name\":\"value\"",
ExpectedPayload = PayloadBuilder.Entity("TestModel.ComplexType").IsComplex(true),
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightPropertyAndValueDeserializer_InvalidTypeName", string.Empty)
},
new
{
Description = "null property with unknown type annotation - should fail.",
Json = "\"" + JsonLightUtils.GetPropertyAnnotationName("Name", JsonLightConstants.ODataTypeAnnotationName) + "\":\"Unknown\"," +
"\"Name\":null",
ExpectedPayload = PayloadBuilder.Entity("TestModel.ComplexType").IsComplex(true),
ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_IncorrectTypeKind", "Unknown", "Primitive", "Complex"),
},
new
{
Description = "Spatial property with odata.type annotation inside the GeoJson object - should fail.",
Json = "\"Location\":" + SpatialUtils.GetSpatialStringValue(ODataFormat.Json, GeographyFactory.Point(33.1, -110.0).Build(), "Edm.GeographyPoint"),
ExpectedPayload = PayloadBuilder.Entity("TestModel.ComplexType").IsComplex(true),
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightPropertyAndValueDeserializer_ODataTypeAnnotationInPrimitiveValue", JsonLightConstants.ODataTypeAnnotationName),
},
new
{
Description = "Spatial property with odata.type annotation inside and outside the GeoJson object - should fail.",
Json = "\"" + JsonLightUtils.GetPropertyAnnotationName("Location", JsonLightConstants.ODataTypeAnnotationName) + "\":\"Edm.GeographyPoint\"," +
"\"Location\":" + SpatialUtils.GetSpatialStringValue(ODataFormat.Json, GeographyFactory.Point(33.1, -110.0).Build(), "Edm.GeographyPoint"),
ExpectedPayload = PayloadBuilder.Entity("TestModel.ComplexType").IsComplex(true),
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightPropertyAndValueDeserializer_ODataTypeAnnotationInPrimitiveValue", JsonLightConstants.ODataTypeAnnotationName),
},
};
testDescriptors = testDescriptors.Concat(explicitPayloads.Select(payload =>
{
var json = string.Format("{{{0}{1}{2}}}",
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#TestModel.ComplexType\"",
string.IsNullOrEmpty(payload.Json) ? string.Empty : ",", payload.Json);
return(new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = payload.ExpectedPayload.DeepCopy()
.JsonRepresentation(json)
// JSON Light payloads don't store complex type names since the type can be inferred from the context URI and or API.
.SetAnnotation(new SerializationTypeNameTestAnnotation()
{
TypeName = null
})
.ExpectedEntityType(complexType),
PayloadEdmModel = model,
ExpectedException = payload.ExpectedException,
DebugDescription = payload.Description,
ExpectedResultPayloadElement = tc => payload.ExpectedPayload.DeepCopy()
.SetAnnotation(new SerializationTypeNameTestAnnotation()
{
TypeName = null
})
});
}));
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.ReaderTestConfigurationProvider.JsonLightFormatConfigurations,
(testDescriptor, testConfiguration) =>
{
// These descriptors are already tailored specifically for Json Light and
// do not require normalization.
testDescriptor.TestDescriptorNormalizers.Clear();
testDescriptor.RunTest(testConfiguration);
});
}
public Task<IEdmModel> GetModelAsync(ModelContext context, CancellationToken cancellationToken)
{
var model = new EdmModel();
var entityType = new EdmEntityType(
"TestNamespace", "TestName");
var entityContainer = new EdmEntityContainer(
"TestNamespace", "Entities");
entityContainer.AddEntitySet("TestEntitySet", entityType);
model.AddElement(entityType);
model.AddElement(entityContainer);
return Task.FromResult<IEdmModel>(model);
}
private static IEdmModel BuildModel()
{
EdmModel model = new EdmModel();
var movieType = new EdmEntityType("TestModel", "Movie");
EdmStructuralProperty idProperty = new EdmStructuralProperty(movieType, "Id", EdmCoreModel.Instance.GetInt32(false));
movieType.AddProperty(idProperty);
movieType.AddKeys(idProperty);
movieType.AddProperty(new EdmStructuralProperty(movieType, "Name", EdmCoreModel.Instance.GetString(true)));
model.AddElement(movieType);
var tvMovieType = new EdmEntityType("TestModel", "TVMovie", movieType);
tvMovieType.AddProperty(new EdmStructuralProperty(tvMovieType, "Channel", EdmCoreModel.Instance.GetString(false)));
model.AddElement(tvMovieType);
EdmEntityContainer defaultContainer = new EdmEntityContainer("TestModel", "Default");
defaultContainer.AddEntitySet("Movies", movieType);
model.AddElement(defaultContainer);
EdmAction simpleAction = new EdmAction("TestModel", "SimpleAction", null /*returnType*/, false /*isBound*/, null /*entitySetPath*/);
model.AddElement(simpleAction);
defaultContainer.AddActionImport(simpleAction);
EdmAction checkoutAction1 = new EdmAction("TestModel", "Checkout", EdmCoreModel.Instance.GetInt32(false), false /*isBound*/, null /*entitySetPath*/);
checkoutAction1.AddParameter("movie", movieType.ToTypeReference());
checkoutAction1.AddParameter("duration", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(checkoutAction1);
EdmAction rateAction1 = new EdmAction("TestModel", "Rate", null /*returnType*/, true /*isBound*/, null /*entitySetPath*/);
rateAction1.AddParameter("movie", movieType.ToTypeReference());
rateAction1.AddParameter("rating", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(rateAction1);
EdmAction changeChannelAction1 = new EdmAction("TestModel", "ChangeChannel", null /*returnType*/, true /*isBound*/, null /*entitySetPath*/);
changeChannelAction1.AddParameter("movie", tvMovieType.ToTypeReference());
changeChannelAction1.AddParameter("channel", EdmCoreModel.Instance.GetString(false));
model.AddElement(changeChannelAction1);
EdmAction checkoutAction = new EdmAction("TestModel", "Checkout", EdmCoreModel.Instance.GetInt32(false) /*returnType*/, false /*isBound*/, null /*entitySetPath*/);
checkoutAction.AddParameter("movie", movieType.ToTypeReference());
checkoutAction.AddParameter("duration", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(checkoutAction);
var movieCollectionTypeReference = (new EdmCollectionType(movieType.ToTypeReference(nullable: false))).ToTypeReference(nullable: false);
EdmAction checkoutMultiple1Action = new EdmAction("TestModel", "CheckoutMultiple", EdmCoreModel.Instance.GetInt32(false), false /*isBound*/, null /*entitySetPath*/);
checkoutMultiple1Action.AddParameter("movies", movieCollectionTypeReference);
checkoutMultiple1Action.AddParameter("duration", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(checkoutMultiple1Action);
EdmAction rateMultiple1Action = new EdmAction("TestModel", "RateMultiple", null /*returnType*/, true /*isBound*/, null /*entitySetPath*/);
rateMultiple1Action.AddParameter("movies", movieCollectionTypeReference);
rateMultiple1Action.AddParameter("rating", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(rateMultiple1Action);
EdmAction checkoutMultiple2Action = new EdmAction("TestModel", "CheckoutMultiple", EdmCoreModel.Instance.GetInt32(false) /*returnType*/, false /*isBound*/, null /*entitySetPath*/);
checkoutMultiple2Action.AddParameter("movies", movieCollectionTypeReference);
checkoutMultiple2Action.AddParameter("duration", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(checkoutMultiple2Action);
EdmAction rateMultiple2Action = new EdmAction("TestModel", "RateMultiple", null /*returnType*/, true /*isBound*/, null /*entitySetPath*/);
rateMultiple2Action.AddParameter("movies", movieCollectionTypeReference);
rateMultiple2Action.AddParameter("rating", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(rateMultiple2Action);
return(model);
}
