public static IEdmModel InterfaceCriticalPropertyValueMustNotBeNullUsingEntitySetNullNavigationModel()
{
var model = new EdmModel();
var entity = new EdmEntityType("NS", "Entity");
var entityId = entity.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
entity.AddKeys(entityId);
model.AddElement(entity);
var entityContainer = new EdmEntityContainer("NS", "Container");
model.AddElement(entityContainer);
var goodSet = new EdmEntitySet(entityContainer, "GoodSet", entity);
entityContainer.AddElement(goodSet);
var badSet = new CustomEntitySet(entityContainer, "BadSet", entity);
badSet.AddNavigationTarget(null, goodSet);
entityContainer.AddElement(badSet);
return(model);
}
static InstanceAnnotationWriterIntegrationTests()
{
Model = new EdmModel();
EntityType = new EdmEntityType("TestNamespace", "TestEntityType");
Model.AddElement(EntityType);
var keyProperty = new EdmStructuralProperty(EntityType, "ID", EdmCoreModel.Instance.GetInt32(false));
EntityType.AddKeys(new IEdmStructuralProperty[] { keyProperty });
EntityType.AddProperty(keyProperty);
var resourceNavigationProperty = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "ResourceNavigationProperty", Target = EntityType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne
});
var resourceSetNavigationProperty = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "ResourceSetNavigationProperty", Target = EntityType, TargetMultiplicity = EdmMultiplicity.Many
});
ComplexType = new EdmComplexType("TestNamespace", "Address");
Model.AddElement(ComplexType);
var defaultContainer = new EdmEntityContainer("TestNamespace", "DefaultContainer");
Model.AddElement(defaultContainer);
EntitySet = new EdmEntitySet(defaultContainer, "TestEntitySet", EntityType);
EntitySet.AddNavigationTarget(resourceNavigationProperty, EntitySet);
EntitySet.AddNavigationTarget(resourceSetNavigationProperty, EntitySet);
defaultContainer.AddElement(EntitySet);
Singleton = new EdmSingleton(defaultContainer, "TestSingleton", EntityType);
Singleton.AddNavigationTarget(resourceNavigationProperty, EntitySet);
Singleton.AddNavigationTarget(resourceSetNavigationProperty, EntitySet);
defaultContainer.AddElement(Singleton);
}
public void CreateOperationIdWithSHA5ForOverloadEdmFunctionImport(bool enableOperationId)
{
// Arrange
EdmModel model = new EdmModel();
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
model.AddElement(customer);
EdmFunction function1 = new EdmFunction("NS", "MyFunction1", EdmCoreModel.Instance.GetString(false), false, null, false);
function1.AddParameter("entity", new EdmEntityTypeReference(customer, false));
function1.AddParameter("param", EdmCoreModel.Instance.GetString(false));
model.AddElement(function1);
EdmFunction function2 = new EdmFunction("NS", "MyFunction1", EdmCoreModel.Instance.GetString(false), false, null, false);
function2.AddParameter("entity", new EdmEntityTypeReference(customer, false));
function2.AddParameter("param", EdmCoreModel.Instance.GetString(false));
function2.AddParameter("otherParam", EdmCoreModel.Instance.GetString(false));
model.AddElement(function2);
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
EdmFunctionImport functionImport1 = new EdmFunctionImport(container, "MyFunction", function1);
EdmFunctionImport functionImport2 = new EdmFunctionImport(container, "MyFunction", function2);
container.AddElement(functionImport1);
container.AddElement(functionImport2);
model.AddElement(container);
OpenApiConvertSettings settings = new OpenApiConvertSettings
{
EnableOperationId = enableOperationId,
AddSingleQuotesForStringParameters = true,
};
ODataContext context = new ODataContext(model, settings);
ODataPath path = new ODataPath(new ODataOperationImportSegment(functionImport1));
// Act
var operation = _operationHandler.CreateOperation(context, path);
// Assert
Assert.NotNull(operation);
if (enableOperationId)
{
Assert.Equal("FunctionImport.MyFunction-cc1c", operation.OperationId);
}
else
{
Assert.Null(operation.OperationId);
}
}
private static IEdmModel GetGraphModel()
{
/*
* contact and directoyObject have the same common base type as "entity" as below.
* entity
* / \
* directoryObject outlookItem
* / \
* group contact
*/
var model = new EdmModel();
var entity = new EdmEntityType("microsoft.graph", "entity", null, true, false);
entity.AddKeys(entity.AddStructuralProperty("id", EdmCoreModel.Instance.GetString(false)));
model.AddElement(entity);
var directoryObject = new EdmEntityType("microsoft.graph", "directoryObject", entity, false, true);
model.AddElement(directoryObject);
var outlookItem = new EdmEntityType("microsoft.graph", "outlookItem", entity, true, false);
model.AddElement(outlookItem);
var group = new EdmEntityType("microsoft.graph", "group", directoryObject, false, true);
var navigation = group.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "members",
TargetMultiplicity = EdmMultiplicity.Many,
Target = directoryObject
});
model.AddElement(group);
var contact = new EdmEntityType("microsoft.graph", "contact", outlookItem, false, true);
contact.AddStructuralProperty("displayName", EdmPrimitiveTypeKind.String);
model.AddElement(contact);
var entityContainer = new EdmEntityContainer("microsoft.graph", "default");
var directoryObjects = new EdmEntitySet(entityContainer, "directoryObjects", directoryObject);
var groups = new EdmEntitySet(entityContainer, "groups", group);
entityContainer.AddElement(directoryObjects);
entityContainer.AddElement(groups);
model.AddElement(entityContainer);
groups.AddNavigationTarget(navigation, directoryObjects);
return(model);
}
private static EdmModel BuildEdmModel()
{
EdmModel model = new EdmModel();
EdmEntityContainer defaultContainer = new EdmEntityContainer(DefaultNamespace, "DefaultContainer");
model.AddElement(defaultContainer);
//Define entity type
var companyType = new EdmEntityType(DefaultNamespace, "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, "Revenue",
EdmCoreModel.Instance.GetInt32(true)));
model.AddElement(companyType);
//Define singleton
EdmSingleton company = new EdmSingleton(defaultContainer, "Company", companyType);
defaultContainer.AddElement(company);
return(model);
}
public void Initialize()
{
EdmModel edmModel = new EdmModel();
EdmEntityType edmEntityType = new EdmEntityType("TestNamespace", "EntityType", baseType: null, isAbstract: false, isOpen: true);
edmModel.AddElement(edmEntityType);
EdmComplexType ComplexType = new EdmComplexType("TestNamespace", "TestComplexType");
ComplexType.AddProperty(new EdmStructuralProperty(ComplexType, "StringProperty", EdmCoreModel.Instance.GetString(false)));
edmModel.AddElement(ComplexType);
EdmComplexType derivedComplexType = new EdmComplexType("TestNamespace", "TestDerivedComplexType", ComplexType, true);
derivedComplexType.AddProperty(new EdmStructuralProperty(derivedComplexType, "DerivedStringProperty", EdmCoreModel.Instance.GetString(false)));
edmModel.AddElement(derivedComplexType);
var defaultContainer = new EdmEntityContainer("TestNamespace", "DefaultContainer_sub");
edmModel.AddElement(defaultContainer);
this.entitySet = new EdmEntitySet(defaultContainer, "TestEntitySet", edmEntityType);
defaultContainer.AddElement(this.entitySet);
this.model = TestUtils.WrapReferencedModelsToMainModel("TestNamespace", "DefaultContainer", edmModel);
this.entityType = edmEntityType;
this.complexType = ComplexType;
}
private static void AddProcedures(this EdmEntityContainer container, IEnumerable <ProcedureConfiguration> configurations, Dictionary <string, IEdmStructuredType> edmTypeMap, Dictionary <string, EdmEntitySet> edmEntitySetMap)
{
foreach (ProcedureConfiguration procedure in configurations)
{
switch (procedure.Kind)
{
case ProcedureKind.Action:
ActionConfiguration action = procedure as ActionConfiguration;
IEdmTypeReference returnReference = GetEdmTypeReference(edmTypeMap, action.ReturnType, nullable: true);
IEdmExpression expression = GetEdmEntitySetExpression(edmEntitySetMap, action);
EdmFunctionImport functionImport = new EdmFunctionImport(container, action.Name, returnReference, expression, action.IsSideEffecting, action.IsComposable, action.IsBindable);
foreach (ParameterConfiguration parameter in action.Parameters)
{
// TODO: http://aspnetwebstack.codeplex.com/workitem/417
IEdmTypeReference parameterTypeReference = GetEdmTypeReference(edmTypeMap, parameter.TypeConfiguration, nullable: true);
EdmFunctionParameter functionParameter = new EdmFunctionParameter(functionImport, parameter.Name, parameterTypeReference, EdmFunctionParameterMode.In);
functionImport.AddParameter(functionParameter);
}
container.AddElement(functionImport);
break;
case ProcedureKind.Function:
Contract.Assert(false, "Functions are not supported.");
break;
case ProcedureKind.ServiceOperation:
Contract.Assert(false, "ServiceOperations are not supported.");
break;
}
}
}
public void VerifyAnnotationComputedConcurrency()
{
var model = new EdmModel();
var entity = new EdmEntityType("NS1", "Product");
var entityId = entity.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(false));
entity.AddKeys(entityId);
EdmStructuralProperty name1 = entity.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty timeVer = entity.AddStructuralProperty("UpdatedTime", EdmCoreModel.Instance.GetDate(false));
model.AddElement(entity);
SetComputedAnnotation(model, entityId); // semantic meaning is V3's 'Identity' for Key profperty
SetComputedAnnotation(model, timeVer); // semantic meaning is V3's 'Computed' for non-key profperty
var entityContainer = new EdmEntityContainer("NS1", "Container");
model.AddElement(entityContainer);
EdmEntitySet set1 = new EdmEntitySet(entityContainer, "Products", entity);
model.SetOptimisticConcurrencyAnnotation(set1, new IEdmStructuralProperty[] { entityId, timeVer });
entityContainer.AddElement(set1);
string csdlStr = GetEdmx(model, EdmxTarget.OData);
Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><edmx:Edmx Version=""4.0"" xmlns:edmx=""http://docs.oasis-open.org/odata/ns/edmx""><edmx:DataServices><Schema Namespace=""NS1"" xmlns=""http://docs.oasis-open.org/odata/ns/edm""><EntityType Name=""Product""><Key><PropertyRef Name=""Id"" /></Key><Property Name=""Id"" Type=""Edm.Int32"" Nullable=""false""><Annotation Term=""Org.OData.Core.V1.Computed"" Bool=""true"" /></Property><Property Name=""Name"" Type=""Edm.String"" Nullable=""false"" /><Property Name=""UpdatedTime"" Type=""Edm.Date"" Nullable=""false""><Annotation Term=""Org.OData.Core.V1.Computed"" Bool=""true"" /></Property></EntityType><EntityContainer Name=""Container""><EntitySet Name=""Products"" EntityType=""NS1.Product""><Annotation Term=""Org.OData.Core.V1.OptimisticConcurrency""><Collection><PropertyPath>Id</PropertyPath><PropertyPath>UpdatedTime</PropertyPath></Collection></Annotation></EntitySet></EntityContainer></Schema></edmx:DataServices></edmx:Edmx>", csdlStr);
}
public static IEdmModel InterfaceCriticalPropertyValueMustNotBeNullUsingEntitySetNullNavigationSetModel()
{
var model = new EdmModel();
var entity = new EdmEntityType("NS", "Entity");
var entityId = entity.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
entity.AddKeys(entityId);
var nav = entity.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Nav", Target = entity, TargetMultiplicity = EdmMultiplicity.One
});
model.AddElement(entity);
var entityContainer = new EdmEntityContainer("NS", "Container");
model.AddElement(entityContainer);
var badSet = new CustomEntitySet(entityContainer, "BadSet", entity);
badSet.AddNavigationTarget(nav, null);
entityContainer.AddElement(badSet);
return(model);
}
public ODataSingletonDeserializerTest()
{
EdmModel model = new EdmModel();
var employeeType = new EdmEntityType("NS", "Employee");
employeeType.AddStructuralProperty("EmployeeId", EdmPrimitiveTypeKind.Int32);
employeeType.AddStructuralProperty("EmployeeName", EdmPrimitiveTypeKind.String);
model.AddElement(employeeType);
EdmEntityContainer defaultContainer = new EdmEntityContainer("NS", "Default");
model.AddElement(defaultContainer);
_singleton = new EdmSingleton(defaultContainer, "CEO", employeeType);
defaultContainer.AddElement(_singleton);
model.SetAnnotationValue <ClrTypeAnnotation>(employeeType, new ClrTypeAnnotation(typeof(EmployeeModel)));
_edmModel = model;
_readContext = new ODataDeserializerContext
{
Path = new ODataPath(new SingletonSegment(_singleton)),
Model = _edmModel,
ResourceType = typeof(EmployeeModel)
};
_deserializerProvider = ODataDeserializerProviderFactory.Create();
}
public OpenApiRequestBodyGeneratorTest()
{
EdmModel model = new EdmModel();
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
model.AddElement(container);
EdmEntityType customer = new EdmEntityType("NS", "Customer", null, false, false, true);
customer.AddKeys(customer.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
var boolType = EdmCoreModel.Instance.GetBoolean(false);
var actionEntitySetPath = new EdmPathExpression("Param1/Nav");
var edmAction = new EdmAction("NS", "Checkout", boolType, true, actionEntitySetPath);
edmAction.AddParameter(new EdmOperationParameter(edmAction, "bindingParameter", new EdmEntityTypeReference(customer, true)));
edmAction.AddParameter("param", EdmCoreModel.Instance.GetString(true));
model.AddElement(edmAction);
var actionImportEntitySetPath = new EdmPathExpression("Param1/Nav2");
var edmActionImport = new EdmActionImport(container, "CheckoutImport", edmAction, actionImportEntitySetPath);
container.AddElement(edmActionImport);
_model = model;
_entityType = customer;
_action = edmAction;
_actionImport = edmActionImport;
}
public void CanWriteEdmEntitySetWithEdmEntityTypeButValidationFailed()
{
string expected =
"<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
"<edmx:Edmx Version=\"4.0\" xmlns:edmx=\"http://docs.oasis-open.org/odata/ns/edmx\">" +
"<edmx:DataServices>" +
"<Schema Namespace=\"NS\" xmlns=\"http://docs.oasis-open.org/odata/ns/edm\">" +
"<EntityContainer Name=\"Default\">" +
"<EntitySet Name=\"Customers\" EntityType=\"Edm.EntityType\" />" +
"</EntityContainer>" +
"</Schema>" +
"</edmx:DataServices>" +
"</edmx:Edmx>";
EdmModel model = new EdmModel();
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
EdmEntitySet entitySet = new EdmEntitySet(container, "Customers", EdmCoreModel.Instance.GetEntityType());
container.AddElement(entitySet);
model.AddElement(container);
IEnumerable <EdmError> errors;
Assert.False(model.Validate(out errors));
Assert.Equal(2, errors.Count());
string csdlStr = GetCsdl(model, CsdlTarget.OData);
Assert.Equal(expected, csdlStr);
}
public static EdmModel ComplexNamespaceOverlappingModel()
{
EdmModel model = new EdmModel();
EdmEntityContainer container = new EdmEntityContainer("Default", "Container");
EdmAction simpleOperationAction = new EdmAction("Default", "SimpleFunction", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(simpleOperationAction);
EdmActionImport simpleOperation = new EdmActionImport(container, "SimpleFunction", simpleOperationAction);
container.AddElement(simpleOperation);
model.AddElement(container);
XElement annotationElement =
new XElement("{http://foo}Annotation",
new XElement("{http://foo}Child",
new XElement("{http://foo1}GrandChild",
new XElement("{http://foo}GreatGrandChild",
"1"
)
)
),
new XElement("{http://foo1}Child",
new XElement("{http://foo}GrandChild",
"1"
)
)
);
var annotation = new EdmStringConstant(EdmCoreModel.Instance.GetString(false), annotationElement.ToString());
annotation.SetIsSerializedAsElement(model, true);
model.SetAnnotationValue(simpleOperation, "http://foo", "Annotation", annotation);
return(model);
}
private EdmModel CreateModel()
{
var model = new EdmModel();
var customer = new EdmEntityType("NS1", "Customer");
var customerId = new EdmStructuralProperty(customer, "CustomerID", EdmCoreModel.Instance.GetString(false));
customer.AddProperty(customerId);
customer.AddKeys(customerId);
model.AddElement(customer);
var title = new EdmTerm("NS1", "Title", EdmCoreModel.Instance.GetString(true));
model.AddElement(title);
var person = new EdmEntityType("NS1", "Person");
var Id = person.AddStructuralProperty("ID", EdmCoreModel.Instance.GetString(false));
person.AddKeys(Id);
model.AddElement(person);
var container = new EdmEntityContainer("NS1", "Container");
container.AddElement(new EdmEntitySet(container, "Customers", customer));
model.AddElement(container);
IEnumerable <EdmError> errors;
Assert.IsTrue(model.Validate(out errors), "validate");
return(model);
}
static ODataResourceTypeContextTests()
{
Model = new EdmModel();
EntitySetElementType = new EdmEntityType("ns", "Customer");
ExpectedEntityType = new EdmEntityType("ns", "VipCustomer", EntitySetElementType);
ActualEntityType = new EdmEntityType("ns", "DerivedVipCustomer", ExpectedEntityType);
ComplexType = new EdmComplexType("ns", "Address");
EdmEntityContainer defaultContainer = new EdmEntityContainer("ns", "DefaultContainer");
Model.AddElement(defaultContainer);
EntitySet = new EdmEntitySet(defaultContainer, "Customers", EntitySetElementType);
Model.AddElement(EntitySetElementType);
Model.AddElement(ExpectedEntityType);
Model.AddElement(ActualEntityType);
defaultContainer.AddElement(EntitySet);
SerializationInfo = new ODataResourceSerializationInfo {
NavigationSourceName = "MyCustomers", NavigationSourceEntityTypeName = "ns.MyCustomer", ExpectedTypeName = "ns.MyVipCustomer"
};
SerializationInfoWithEdmUnknowEntitySet = new ODataResourceSerializationInfo()
{
NavigationSourceName = null, NavigationSourceEntityTypeName = "ns.MyCustomer", ExpectedTypeName = "ns.MyVipCustomer", NavigationSourceKind = EdmNavigationSourceKind.UnknownEntitySet
};
TypeContextWithoutModel = ODataResourceTypeContext.Create(SerializationInfo, navigationSource: null, navigationSourceEntityType: null, expectedResourceType: null, throwIfMissingTypeInfo: true);
TypeContextWithModel = ODataResourceTypeContext.Create(/*serializationInfo*/ null, EntitySet, EntitySetElementType, ExpectedEntityType, throwIfMissingTypeInfo: true);
TypeContextWithEdmUnknowEntitySet = ODataResourceTypeContext.Create(SerializationInfoWithEdmUnknowEntitySet, navigationSource: null, navigationSourceEntityType: null, expectedResourceType: null, throwIfMissingTypeInfo: true);
BaseTypeContextThatThrows = ODataResourceTypeContext.Create(serializationInfo: null, navigationSource: null, navigationSourceEntityType: null, expectedResourceType: null, throwIfMissingTypeInfo: true);
BaseTypeContextThatWillNotThrow = ODataResourceTypeContext.Create(serializationInfo: null, navigationSource: null, navigationSourceEntityType: null, expectedResourceType: null, throwIfMissingTypeInfo: false);
}
static ODataFeedAndEntryTypeContextTests()
{
Model = new EdmModel();
EntitySetElementType = new EdmEntityType("ns", "Customer");
ExpectedEntityType = new EdmEntityType("ns", "VipCustomer", EntitySetElementType);
ActualEntityType = new EdmEntityType("ns", "DerivedVipCustomer", ExpectedEntityType);
EdmEntityContainer defaultContainer = new EdmEntityContainer("ns", "DefaultContainer");
Model.AddElement(defaultContainer);
Model.AddVocabularyAnnotation(new EdmAnnotation(defaultContainer, UrlConventionsConstants.ConventionTerm, UrlConventionsConstants.KeyAsSegmentAnnotationValue));
EntitySet = new EdmEntitySet(defaultContainer, "Customers", EntitySetElementType);
Model.AddElement(EntitySetElementType);
Model.AddElement(ExpectedEntityType);
Model.AddElement(ActualEntityType);
defaultContainer.AddElement(EntitySet);
SerializationInfo = new ODataFeedAndEntrySerializationInfo {
NavigationSourceName = "MyCustomers", NavigationSourceEntityTypeName = "ns.MyCustomer", ExpectedTypeName = "ns.MyVipCustomer"
};
TypeContextWithoutModel = ODataFeedAndEntryTypeContext.Create(SerializationInfo, navigationSource: null, navigationSourceEntityType: null, expectedEntityType: null, model: Model, throwIfMissingTypeInfo: true);
TypeContextWithModel = ODataFeedAndEntryTypeContext.Create(/*serializationInfo*/ null, EntitySet, EntitySetElementType, ExpectedEntityType, Model, throwIfMissingTypeInfo: true);
BaseTypeContextThatThrows = ODataFeedAndEntryTypeContext.Create(serializationInfo: null, navigationSource: null, navigationSourceEntityType: null, expectedEntityType: null, model: Model, throwIfMissingTypeInfo: true);
BaseTypeContextThatWillNotThrow = ODataFeedAndEntryTypeContext.Create(serializationInfo: null, navigationSource: null, navigationSourceEntityType: null, expectedEntityType: null, model: Model, throwIfMissingTypeInfo: false);
}
public void BuildSelectExpandNode_Works_IfOnlyNavigationPropertyDefinedOnType()
{
// Assert
EdmModel model = new EdmModel();
EdmEntityType entity = new EdmEntityType("NS", "Entity");
entity.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "Nav",
Target = entity,
TargetMultiplicity = EdmMultiplicity.One
});
model.AddElement(entity);
EdmEntityContainer container = new EdmEntityContainer("NS", "Container");
EdmSingleton singleton = container.AddSingleton("Single", entity);
container.AddElement(singleton);
model.AddElement(container);
// Act
SelectExpandClause selectExpandClause = new ODataQueryOptionParser(model, entity, singleton,
new Dictionary <string, string>
{
{ "$select", "Nav" }
}).ParseSelectAndExpand();
SelectExpandNode selectExpandNode = new SelectExpandNode(selectExpandClause, entity, model);
// Assert
Assert.Null(selectExpandNode.SelectedStructuralProperties);
Assert.Null(selectExpandNode.SelectedComplexTypeProperties);
Assert.NotNull(selectExpandNode.SelectedNavigationProperties);
Assert.Single(selectExpandNode.SelectedNavigationProperties);
}
static ODataEntityReferenceLinksTests()
{
EdmModel tmpModel = new EdmModel();
EdmComplexType complexType = new EdmComplexType("TestNamespace", "TestComplexType");
complexType.AddProperty(new EdmStructuralProperty(complexType, "StringProperty", EdmCoreModel.Instance.GetString(false)));
tmpModel.AddElement(complexType);
EntityType = new EdmEntityType("TestNamespace", "TestEntityType");
tmpModel.AddElement(EntityType);
var keyProperty = new EdmStructuralProperty(EntityType, "ID", EdmCoreModel.Instance.GetInt32(false));
EntityType.AddKeys(new IEdmStructuralProperty[] { keyProperty });
EntityType.AddProperty(keyProperty);
var defaultContainer = new EdmEntityContainer("TestNamespace", "DefaultContainer_sub");
tmpModel.AddElement(defaultContainer);
EntitySet = new EdmEntitySet(defaultContainer, "Customers", EntityType);
defaultContainer.AddElement(EntitySet);
EdmModel = TestUtils.WrapReferencedModelsToMainModel("TestNamespace", "DefaultContainer", tmpModel);
MessageReaderSettingsReadAndValidateCustomInstanceAnnotations = new ODataMessageReaderSettings {
ShouldIncludeAnnotation = ODataUtils.CreateAnnotationFilter("*")
};
}
private static IEdmModel CreateODataServiceModel(string ns)
{
EdmModel model = new EdmModel();
var defaultContainer = new EdmEntityContainer(ns, "DefaultContainer");
model.AddElement(defaultContainer);
var personType = new EdmEntityType(ns, "Person");
var personIdProperty = new EdmStructuralProperty(personType, "PersonId", EdmCoreModel.Instance.GetInt64(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, "UserName", EdmCoreModel.Instance.GetString(true)));
personType.AddProperty(new EdmStructuralProperty(personType, "DbLocation", EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.GeographyPolygon, true)));
personType.AddProperty(new EdmStructuralProperty(personType, "DbLineString", EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.GeographyMultiPoint, true)));
model.AddElement(personType);
var personSet = new EdmEntitySet(defaultContainer, "People", personType);
defaultContainer.AddElement(personSet);
model.SetAnnotationValue(personType, new ClrTypeAnnotation(typeof(Person)));
return(model);
}
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 && EdmLibHelpers.IsNullable(procedure.ReturnType.ClrType));
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));
}
AddProcedureParameters(operation, procedure, edmTypeMap);
if (procedure.IsBindable)
{
AddProcedureLinkBuilder(model, operation, procedure);
ValidateProcedureEntitySetPath(model, operationImport, procedure);
}
else
{
container.AddElement(operationImport);
}
model.AddElement(operation);
}
}
private static EdmModel CreateCustomerProductsModel()
{
var model = new EdmModel();
var container = new EdmEntityContainer("defaultNamespace", "DefaultContainer");
model.AddElement(container);
var productType = new EdmEntityType("defaultNamespace", "Product");
model.AddElement(productType);
var customerType = new EdmEntityType("defaultNamespace", "Customer");
customerType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Products", Target = productType, TargetMultiplicity = EdmMultiplicity.Many
});
productType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Customers", Target = customerType, TargetMultiplicity = EdmMultiplicity.Many
});
model.AddElement(customerType);
var productSet = new EdmEntitySet(
container,
"Products",
productType);
container.AddElement(productSet);
var customerSet = new EdmEntitySet(
container,
"Customers",
customerType);
var productsNavProp = customerType.NavigationProperties().Single(np => np.Name == "Products");
customerSet.AddNavigationTarget(productsNavProp, productSet);
container.AddElement(customerSet);
return(model);
}
private static IEdmModel GetDerivedModel()
{
var model = new EdmModel();
var entityType = new EdmEntityType("NS", "EntityType");
var id = entityType.AddStructuralProperty("ID", EdmCoreModel.Instance.GetString(false));
entityType.AddKeys(id);
var derivedEntityType = new EdmEntityType("NS", "DerivedEntityType", entityType);
var navEntityType = new EdmEntityType("NS", "NavEntityType");
var navEntityId = navEntityType.AddStructuralProperty("ID", EdmCoreModel.Instance.GetString(false));
navEntityType.AddKeys(navEntityId);
var nav = derivedEntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Nav",
Target = navEntityType,
TargetMultiplicity = EdmMultiplicity.Many,
});
model.AddElement(entityType);
model.AddElement(derivedEntityType);
model.AddElement(navEntityType);
var entityContainer = new EdmEntityContainer("NS", "Container");
model.AddElement(entityContainer);
var entitySet = new EdmEntitySet(entityContainer, "EntitySet", entityType);
var navEntitySet = new EdmEntitySet(entityContainer, "NavEntitySet", navEntityType);
entitySet.AddNavigationTarget(nav, navEntitySet);
entityContainer.AddElement(entitySet);
entityContainer.AddElement(navEntitySet);
return(model);
}
public static IEdmModel InterfaceCriticalPropertyValueMustNotBeNullUsingEntitySetElementTypeModel()
{
var model = new EdmModel();
var entityContainer = new EdmEntityContainer("NS", "Container");
model.AddElement(entityContainer);
var badSet = new CustomEntitySet(entityContainer, "Set", null);
entityContainer.AddElement(badSet);
return(model);
}
static InstanceAnnotationsReaderIntegrationTests()
{
EdmModel modelTmp = new EdmModel();
EntityType = new EdmEntityType("TestNamespace", "TestEntityType");
modelTmp.AddElement(EntityType);
var keyProperty = new EdmStructuralProperty(EntityType, "ID", EdmCoreModel.Instance.GetInt32(false));
EntityType.AddKeys(new IEdmStructuralProperty[] { keyProperty });
EntityType.AddProperty(keyProperty);
var resourceNavigationProperty = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "ResourceNavigationProperty", Target = EntityType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne
});
var resourceSetNavigationProperty = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "ResourceSetNavigationProperty", Target = EntityType, TargetMultiplicity = EdmMultiplicity.Many
});
var defaultContainer = new EdmEntityContainer("TestNamespace", "DefaultContainer_sub");
modelTmp.AddElement(defaultContainer);
EntitySet = new EdmEntitySet(defaultContainer, "TestEntitySet", EntityType);
EntitySet.AddNavigationTarget(resourceNavigationProperty, EntitySet);
EntitySet.AddNavigationTarget(resourceSetNavigationProperty, EntitySet);
defaultContainer.AddElement(EntitySet);
Singleton = new EdmSingleton(defaultContainer, "TestSingleton", EntityType);
Singleton.AddNavigationTarget(resourceNavigationProperty, EntitySet);
Singleton.AddNavigationTarget(resourceSetNavigationProperty, EntitySet);
defaultContainer.AddElement(Singleton);
ComplexType = new EdmComplexType("TestNamespace", "TestComplexType");
ComplexType.AddProperty(new EdmStructuralProperty(ComplexType, "StringProperty", EdmCoreModel.Instance.GetString(false)));
modelTmp.AddElement(ComplexType);
Model = TestUtils.WrapReferencedModelsToMainModel("TestNamespace", "DefaultContainer", modelTmp);
}
public void HandCraftEdmType()
{
foreach (var mimeType in this.testMimeTypes)
{
EdmModel edmModel = new EdmModel();
EdmEntityType edmEntityType = new EdmEntityType(NameSpace, "Person");
edmModel.AddElement(edmEntityType);
var keyProperty = new EdmStructuralProperty(edmEntityType, "PersonId", EdmCoreModel.Instance.GetInt32(false));
edmEntityType.AddKeys(new IEdmStructuralProperty[] { keyProperty });
edmEntityType.AddProperty(keyProperty);
var property = new EdmStructuralProperty(edmEntityType, "Name", EdmCoreModel.Instance.GetString(true));
edmEntityType.AddKeys(new IEdmStructuralProperty[] { property });
edmEntityType.AddProperty(property);
var defaultContainer = new EdmEntityContainer(NameSpace, "DefaultContainer");
edmModel.AddElement(defaultContainer);
EdmEntitySet entitySet = new EdmEntitySet(defaultContainer, "Person", edmEntityType);
defaultContainer.AddElement(entitySet);
var settings = new ODataMessageWriterSettings();
settings.ODataUri = new ODataUri()
{
ServiceRoot = this.ServiceUri
};
var responseMessageWithoutModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithoutModel.SetHeader("Content-Type", mimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithoutModel, settings))
{
var odataWriter = messageWriter.CreateODataEntryWriter(entitySet, edmEntityType);
var entry = this.CreatePersonEntryWithoutSerializationInfo();
string expectedError = null;
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
expectedError = "ODataFeedAndEntryTypeContext_MetadataOrSerializationInfoMissing";
}
AssertThrows <ODataException>(
() =>
{
odataWriter.WriteStart(entry);
odataWriter.WriteEnd();
},
expectedError);
}
}
}
static AsyncRoundtripJsonLightTests()
{
userModel = new EdmModel();
testType = new EdmEntityType("NS", "Test");
testType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
testType.AddStructuralProperty("Dummy", EdmPrimitiveTypeKind.String);
userModel.AddElement(testType);
defaultContainer = new EdmEntityContainer("NS", "DefaultContainer");
userModel.AddElement(defaultContainer);
singleton = new EdmSingleton(defaultContainer, "MySingleton", testType);
defaultContainer.AddElement(singleton);
}
public void AmbiguousEntitySetTest()
{
EdmEntityContainer container = new EdmEntityContainer("NS1", "Baz");
IEdmEntitySet set1 = new StubEdmEntitySet("Foo", container);
IEdmEntitySet set2 = new StubEdmEntitySet("Foo", container);
IEdmEntitySet set3 = new StubEdmEntitySet("Foo", container);
container.AddElement(set1);
Assert.AreNotEqual(set3, container.FindEntitySet("Foo"), "Checking the object equality.");
Assert.AreEqual(set3.Name, container.FindEntitySet("Foo").Name, "Checking the object equality.");
container.AddElement(set2);
container.AddElement(set3);
IEdmEntitySet ambiguous = container.FindEntitySet("Foo");
Assert.IsTrue(ambiguous.IsBad(), "Ambiguous binding is bad");
Assert.AreEqual(EdmContainerElementKind.EntitySet, ambiguous.ContainerElementKind, "Correct container element kind");
Assert.AreEqual("NS1.Baz", ambiguous.Container.FullName(), "Correct container name");
Assert.AreEqual("Foo", ambiguous.Name, "Correct Name");
Assert.IsTrue(ambiguous.EntityType().IsBad(), "Association is bad.");
}
private void InitializeEdmModel()
{
this.userModel = new EdmModel();
testType = new EdmEntityType("NS", "Test");
testType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
this.userModel.AddElement(testType);
var defaultContainer = new EdmEntityContainer("NS", "DefaultContainer");
this.userModel.AddElement(defaultContainer);
this.singleton = new EdmSingleton(defaultContainer, "MySingleton", this.testType);
defaultContainer.AddElement(this.singleton);
}
static ODataAsynchronousReaderTests()
{
userModel = new EdmModel();
testType = new EdmEntityType("NS", "Test");
testType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
userModel.AddElement(testType);
var defaultContainer = new EdmEntityContainer("NS", "DefaultContainer");
userModel.AddElement(defaultContainer);
singleton = new EdmSingleton(defaultContainer, "MySingleton", testType);
defaultContainer.AddElement(singleton);
}
private void MediaEntrySetSetting()
{
EdmModel tmpModel = new EdmModel();
this.webType = new EdmEntityType("NS", "Web", null, /*isAbstract*/ false, /*isOpen*/ false, /*hasStream*/ true);
tmpModel.AddElement(this.webType);
this.defaultContainer = new EdmEntityContainer("NS", "DefaultContainer_sub");
tmpModel.AddElement(defaultContainer);
this.singleton = new EdmSingleton(defaultContainer, "MySingleton", this.webType);
defaultContainer.AddElement(this.singleton);
this.userModel = TestUtils.WrapReferencedModelsToMainModel("NS", "DefaultContainer", tmpModel);
this.referencedModel = tmpModel;
}
