public NonPrimitiveTypeRoundtripAtomTests()
{
this.model = new EdmModel();
EdmComplexType personalInfo = new EdmComplexType(MyNameSpace, "PersonalInfo");
personalInfo.AddStructuralProperty("Age", EdmPrimitiveTypeKind.Int16);
personalInfo.AddStructuralProperty("Email", EdmPrimitiveTypeKind.String);
personalInfo.AddStructuralProperty("Tel", EdmPrimitiveTypeKind.String);
personalInfo.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Guid);
EdmComplexType subjectInfo = new EdmComplexType(MyNameSpace, "Subject");
subjectInfo.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
subjectInfo.AddStructuralProperty("Score", EdmPrimitiveTypeKind.Int16);
EdmCollectionTypeReference subjectsCollection = new EdmCollectionTypeReference(new EdmCollectionType(new EdmComplexTypeReference(subjectInfo, isNullable:true)));
EdmEntityType studentInfo = new EdmEntityType(MyNameSpace, "Student");
studentInfo.AddStructuralProperty("Info", new EdmComplexTypeReference(personalInfo, isNullable: false));
studentInfo.AddProperty(new EdmStructuralProperty(studentInfo, "Subjects", subjectsCollection));
EdmCollectionTypeReference hobbiesCollection = new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(isNullable: false)));
studentInfo.AddProperty(new EdmStructuralProperty(studentInfo, "Hobbies", hobbiesCollection));
model.AddElement(studentInfo);
model.AddElement(personalInfo);
model.AddElement(subjectInfo);
}
public void ComplexValueTest()
{
EdmModel model = new EdmModel();
var emptyComplexType = new EdmComplexType(DefaultNamespaceName, "EmptyComplexType");
model.AddElement(emptyComplexType);
var complexTypeWithStringProperty = new EdmComplexType(DefaultNamespaceName, "ComplexTypeWithStringProperty");
complexTypeWithStringProperty.AddStructuralProperty("stringProperty", EdmCoreModel.Instance.GetString(isNullable: true));
complexTypeWithStringProperty.AddStructuralProperty("numberProperty", EdmCoreModel.Instance.GetInt32(isNullable: false));
model.AddElement(complexTypeWithStringProperty);
model.Fixup();
IEnumerable<PayloadReaderTestDescriptor> testDescriptors = new[]
{
// Empty element is a valid complex value
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.ComplexValue("TestModel.EmptyComplexType")
.XmlValueRepresentation(new XNode[0])
.WithTypeAnnotation(emptyComplexType),
PayloadEdmModel = model
},
};
testDescriptors = testDescriptors.Concat(
PropertiesElementAtomValues.CreatePropertiesElementPaddingPayloads<ComplexInstance>(
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.ComplexValue("TestModel.ComplexTypeWithStringProperty")
.WithTypeAnnotation(complexTypeWithStringProperty),
PayloadEdmModel = model
},
(complexInstance, xmlValue) => complexInstance.XmlValueRepresentation(xmlValue)));
testDescriptors = testDescriptors.Select(td => td.InProperty());
testDescriptors = testDescriptors.Concat(new []
{
// Top-level property without expected type and no type name - this is read as primitive string!
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.Property(null, PayloadBuilder.PrimitiveValue(string.Empty))
.XmlRepresentation("<m:value/>"),
PayloadEdmModel = model,
},
});
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.ReaderTestConfigurationProvider.AtomFormatConfigurations,
(testDescriptor, testConfiguration) =>
{
testDescriptor.RunTest(testConfiguration);
});
}
public void Initialize()
{
this.model = new EdmModel();
EdmComplexType personalInfo = new EdmComplexType(MyNameSpace, "PersonalInfo");
personalInfo.AddStructuralProperty("Age", EdmPrimitiveTypeKind.Int16);
personalInfo.AddStructuralProperty("Email", EdmPrimitiveTypeKind.String);
personalInfo.AddStructuralProperty("Tel", EdmPrimitiveTypeKind.String);
personalInfo.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Guid);
EdmComplexType derivedPersonalInfo = new EdmComplexType(MyNameSpace, "DerivedPersonalInfo", personalInfo);
derivedPersonalInfo.AddStructuralProperty("Hobby", EdmPrimitiveTypeKind.String);
EdmComplexType derivedDerivedPersonalInfo = new EdmComplexType(MyNameSpace, "DerivedDerivedPersonalInfo", derivedPersonalInfo);
derivedDerivedPersonalInfo.AddStructuralProperty("Education", EdmPrimitiveTypeKind.String);
EdmComplexType subjectInfo = new EdmComplexType(MyNameSpace, "Subject");
subjectInfo.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
subjectInfo.AddStructuralProperty("Score", EdmPrimitiveTypeKind.Int16);
EdmComplexType derivedSubjectInfo = new EdmComplexType(MyNameSpace, "DerivedSubject", subjectInfo);
derivedSubjectInfo.AddStructuralProperty("Teacher", EdmPrimitiveTypeKind.String);
EdmComplexType derivedDerivedSubjectInfo = new EdmComplexType(MyNameSpace, "DerivedDerivedSubject", derivedSubjectInfo);
derivedDerivedSubjectInfo.AddStructuralProperty("Classroom", EdmPrimitiveTypeKind.String);
EdmCollectionTypeReference subjectsCollection = new EdmCollectionTypeReference(new EdmCollectionType(new EdmComplexTypeReference(subjectInfo, isNullable: true)));
studentInfo = new EdmEntityType(MyNameSpace, "Student");
studentInfo.AddStructuralProperty("Info", new EdmComplexTypeReference(personalInfo, isNullable: false));
studentInfo.AddProperty(new EdmStructuralProperty(studentInfo, "Subjects", subjectsCollection));
// enum with flags
var enumFlagsType = new EdmEnumType(MyNameSpace, "ColorFlags", isFlags: true);
enumFlagsType.AddMember("Red", new EdmIntegerConstant(1));
enumFlagsType.AddMember("Green", new EdmIntegerConstant(2));
enumFlagsType.AddMember("Blue", new EdmIntegerConstant(4));
studentInfo.AddStructuralProperty("ClothesColors", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEnumTypeReference(enumFlagsType, true))));
EdmCollectionTypeReference hobbiesCollection = new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(isNullable: false)));
studentInfo.AddProperty(new EdmStructuralProperty(studentInfo, "Hobbies", hobbiesCollection));
model.AddElement(enumFlagsType);
model.AddElement(studentInfo);
model.AddElement(personalInfo);
model.AddElement(derivedPersonalInfo);
model.AddElement(derivedDerivedPersonalInfo);
model.AddElement(subjectInfo);
model.AddElement(derivedSubjectInfo);
model.AddElement(derivedDerivedSubjectInfo);
IEdmEntityContainer defaultContainer = new EdmEntityContainer("NS", "DefaultContainer");
model.AddElement(defaultContainer);
this.studentSet = new EdmEntitySet(defaultContainer, "MySet", this.studentInfo);
}
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 orderType = new EdmEntityType("Default", "Order");
orderType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32);
orderType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
orderType.AddStructuralProperty("Shipment", EdmPrimitiveTypeKind.String);
model.AddElement(orderType);
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 navigations
customerType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Name = "Orders", Target = orderType, TargetMultiplicity = EdmMultiplicity.Many });
orderType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Name = "Customer", Target = customerType, 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);
orderSet.AddNavigationTarget(orderType.NavigationProperties().Single(np => np.Name == "Customer"), customerSet);
NavigationSourceLinkBuilderAnnotation linkAnnotation = new MockNavigationSourceLinkBuilderAnnotation();
model.SetNavigationSourceLinkBuilder(customerSet, linkAnnotation);
model.SetNavigationSourceLinkBuilder(orderSet, linkAnnotation);
model.AddElement(container);
return model;
}
public void Initialize()
{
var addressEdmType = new EdmComplexType("Default", "Address");
addressEdmType.AddStructuralProperty("ZipCode", EdmPrimitiveTypeKind.String);
this.edmAddressComplexTypeRef = new EdmComplexTypeReference(addressEdmType, true);
}
private static void ReferentialConstraintDemo()
{
Console.WriteLine("ReferentialConstraintDemo");
EdmModel model = new EdmModel();
var customer = new EdmEntityType("ns", "Customer");
model.AddElement(customer);
var customerId = customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false);
customer.AddKeys(customerId);
var address = new EdmComplexType("ns", "Address");
model.AddElement(address);
var code = address.AddStructuralProperty("gid", EdmPrimitiveTypeKind.Guid);
customer.AddStructuralProperty("addr", new EdmComplexTypeReference(address, true));
var order = new EdmEntityType("ns", "Order");
model.AddElement(order);
var oId = order.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false);
order.AddKeys(oId);
var orderCustomerId = order.AddStructuralProperty("CustomerId", EdmPrimitiveTypeKind.Int32, false);
var nav = new EdmNavigationPropertyInfo()
{
Name = "NavCustomer",
Target = customer,
TargetMultiplicity = EdmMultiplicity.One,
DependentProperties = new[] { orderCustomerId },
PrincipalProperties = new[] { customerId }
};
order.AddUnidirectionalNavigation(nav);
ShowModel(model);
}
public static IEdmModel MultipleSchemasWithDifferentNamespacesEdm()
{
var namespaces = new string[]
{
"FindMethodsTestModelBuilder.MultipleSchemasWithDifferentNamespaces.first",
"FindMethodsTestModelBuilder.MultipleSchemasWithDifferentNamespaces.second"
};
var model = new EdmModel();
foreach (var namespaceName in namespaces)
{
var entityType1 = new EdmEntityType(namespaceName, "validEntityType1");
entityType1.AddKeys(entityType1.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
var entityType2 = new EdmEntityType(namespaceName, "VALIDeNTITYtYPE2");
entityType2.AddKeys(entityType2.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
var entityType3 = new EdmEntityType(namespaceName, "VALIDeNTITYtYPE3");
entityType3.AddKeys(entityType3.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
entityType1.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {Name = "Mumble", Target = entityType2, TargetMultiplicity = EdmMultiplicity.Many});
var complexType = new EdmComplexType(namespaceName, "ValidNameComplexType1");
complexType.AddStructuralProperty("aPropertyOne", new EdmComplexTypeReference(complexType, false));
model.AddElements(new IEdmSchemaElement[] { entityType1, entityType2, entityType3, complexType });
var function1 = new EdmFunction(namespaceName, "ValidFunction1", EdmCoreModel.Instance.GetSingle(false));
var function2 = new EdmFunction(namespaceName, "ValidFunction1", EdmCoreModel.Instance.GetSingle(false));
function2.AddParameter("param1", new EdmEntityTypeReference(entityType1, false));
var function3 = new EdmFunction(namespaceName, "ValidFunction1", EdmCoreModel.Instance.GetSingle(false));
function3.AddParameter("param1", EdmCoreModel.Instance.GetSingle(false));
model.AddElements(new IEdmSchemaElement[] {function1, function2, function3});
}
return model;
}
static ODataAtomPropertyAndValueDeserializerTests()
{
EdmModel = new EdmModel();
ComplexType = new EdmComplexType("TestNamespace", "TestComplexType");
StringProperty = ComplexType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
EdmModel.AddElement(ComplexType);
}
private IEdmType GetTmpType(IEdmOperation operation)
{
EdmComplexType type = new EdmComplexType(operation.Namespace, operation.Name + AvroConstants.ParameterTypeSuffix);
foreach (var parameter in operation.Parameters.Skip(operation.IsBound ? 1 : 0))
{
type.AddStructuralProperty(parameter.Name, parameter.Type);
}
return type;
}
public void XElementAnnotationTestXElementWithWithoutNamespaceCsdl()
{
EdmModel model = new EdmModel();
EdmComplexType complexType = new EdmComplexType("DefaultNamespace", "ComplexType");
complexType.AddStructuralProperty("Data", EdmCoreModel.Instance.GetString(true));
model.AddElement(complexType);
XElement annotationElement = new XElement("EmptyAnnotation");
var annotation = new EdmStringConstant(EdmCoreModel.Instance.GetString(false), annotationElement.ToString());
VerifyThrowsException(typeof(InvalidOperationException), () => annotation.SetIsSerializedAsElement(model, true));
}
static ODataAvroWriterTests()
{
var type = new EdmEntityType("NS", "SimpleEntry");
type.AddStructuralProperty("TBoolean", EdmPrimitiveTypeKind.Boolean, true);
type.AddStructuralProperty("TInt32", EdmPrimitiveTypeKind.Int32, true);
type.AddStructuralProperty("TCollection", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt64(false))));
var cpx = new EdmComplexType("NS", "SimpleComplex");
cpx.AddStructuralProperty("TBinary", EdmPrimitiveTypeKind.Binary, true);
cpx.AddStructuralProperty("TString", EdmPrimitiveTypeKind.String, true);
type.AddStructuralProperty("TComplex", new EdmComplexTypeReference(cpx, true));
TestEntityType = type;
binary0 = new byte[] { 4, 7 };
complexValue0 = new ODataComplexValue()
{
Properties = new[]
{
new ODataProperty {Name = "TBinary", Value = binary0 ,},
new ODataProperty {Name = "TString", Value = "iamstr",},
},
TypeName = "NS.SimpleComplex"
};
longCollection0 = new[] {7L, 9L};
var collectionValue0 = new ODataCollectionValue { Items = longCollection0 };
entry0 = new ODataEntry
{
Properties = new[]
{
new ODataProperty {Name = "TBoolean", Value = true,},
new ODataProperty {Name = "TInt32", Value = 32,},
new ODataProperty {Name = "TComplex", Value = complexValue0,},
new ODataProperty {Name = "TCollection", Value = collectionValue0 },
},
TypeName = "NS.SimpleEntry"
};
}
public static EdmModel AnnotationWithoutChildrenModel()
{
EdmModel model = new EdmModel();
EdmComplexType complexType = new EdmComplexType("DefaultNamespace", "ComplexType");
complexType.AddStructuralProperty("Data", EdmCoreModel.Instance.GetString(true));
model.AddElement(complexType);
XElement annotationElement = new XElement("{http://foo}Annotation");
var annotation = new EdmStringConstant(EdmCoreModel.Instance.GetString(false), annotationElement.ToString());
annotation.SetIsSerializedAsElement(model, true);
model.SetAnnotationValue(complexType, "http://foo", "Annotation", annotation);
return model;
}
public JsonLightTypeResolverTests()
{
this.serverModel = new EdmModel();
var serverEntityType = new EdmEntityType("Server.Name.Space", "EntityType");
serverEntityType.AddKeys(serverEntityType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
var parentType = new EdmEntityType("Server.Name.Space", "Parent");
this.serverModel.AddElement(serverEntityType);
this.serverModel.AddElement(parentType);
var serverComplexType = new EdmComplexType("Server.Name.Space", "ComplexType");
serverComplexType.AddStructuralProperty("Number", EdmPrimitiveTypeKind.Int32);
this.serverModel.AddElement(serverComplexType);
var entityContainer = new EdmEntityContainer("Fake", "Container");
this.serverModel.AddElement(entityContainer);
entityContainer.AddEntitySet("Entities", serverEntityType);
entityContainer.AddEntitySet("Parents", parentType);
parentType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "Navigation", Target = serverEntityType, TargetMultiplicity = EdmMultiplicity.Many });
}
public void HeterogeneousCollectionReaderTest()
{
EdmModel model = new EdmModel();
var cityType = new EdmComplexType("TestModel", "CityType");
cityType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(true));
model.AddElement(cityType);
var addressType = new EdmComplexType("TestModel", "AddressType");
addressType.AddStructuralProperty("Street", EdmCoreModel.Instance.GetString(true));
model.AddElement(addressType);
var testContainer = new EdmEntityContainer("TestModel", "TestContainer");
model.AddElement(testContainer);
EdmFunction citiesFunction = new EdmFunction("TestModel", "Cities", EdmCoreModel.GetCollection(cityType.ToTypeReference()));
model.AddElement(citiesFunction);
EdmOperationImport citiesFunctionImport = testContainer.AddFunctionImport("Cities", citiesFunction);
model.Fixup();
// Add some hand-crafted payloads
IEnumerable<PayloadReaderTestDescriptor> testDescriptors = new PayloadReaderTestDescriptor[]
{
// expected type without type names in the payload and heterogeneous items
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = new ComplexInstanceCollection(
PayloadBuilder.ComplexValue().Property("Name", PayloadBuilder.PrimitiveValue("Vienna")),
PayloadBuilder.ComplexValue().Property("Street", PayloadBuilder.PrimitiveValue("Am Euro Platz")))
.ExpectedFunctionImport(citiesFunctionImport)
.CollectionName(null),
PayloadEdmModel = model,
ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_PropertyDoesNotExistOnType", "Street", "TestModel.CityType"),
},
};
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.ReaderTestConfigurationProvider.ExplicitFormatConfigurations,
(testDescriptor, testConfiguration) =>
{
testDescriptor.RunTest(testConfiguration);
});
}
public static EdmModel NestedXElementWithNoValueModel()
{
EdmModel model = new EdmModel();
EdmComplexType simpleType = new EdmComplexType("DefaultNamespace", "SimpleType");
EdmStructuralProperty simpleTypeId = simpleType.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(true));
model.AddElement(simpleType);
XElement annotationElement =
new XElement("{http://foo}Annotation",
new XElement("{http://foo}Child",
new XElement("{http://foo}GrandChild",
new XElement("{http://foo}GreatGrandChild",
new XElement("{http://foo}GreateGreatGrandChild")
)
)
)
);
var annotation = new EdmStringConstant(EdmCoreModel.Instance.GetString(false), annotationElement.ToString());
annotation.SetIsSerializedAsElement(model, true);
model.SetAnnotationValue(simpleTypeId, "http://foo", "Annotation", annotation);
return model;
}
public void TryGetPropertyValue_Without_TrySetPropertyValue_ReturnsDefault()
{
string propertyName = "Property";
EdmComplexType edmType = new EdmComplexType("NS", "Complex");
edmType.AddStructuralProperty(propertyName, EdmPrimitiveTypeKind.Int32, isNullable: false);
var edmObject = new TestEdmStructuredObject(edmType);
object result;
edmObject.TryGetPropertyValue(propertyName, out result);
Assert.Equal(0, result);
}
public void TryGetPropertyValue_After_TrySetPropertyValue()
{
string propertyName = "Property";
EdmComplexType edmType = new EdmComplexType("NS", "Complex");
edmType.AddStructuralProperty(propertyName, EdmPrimitiveTypeKind.Int32);
var edmObject = new TestEdmStructuredObject(edmType);
object propertyValue = new object();
object result;
edmObject.TrySetPropertyValue(propertyName, propertyValue);
edmObject.TryGetPropertyValue(propertyName, out result);
Assert.Same(propertyValue, result);
}
public void TrySetPropertyValue_IfPropertyExists_UpdatesGetChangedPropertyNames()
{
EdmComplexType edmType = new EdmComplexType("NS", "Complex");
edmType.AddStructuralProperty("Property", EdmPrimitiveTypeKind.Int32);
var edmObject = new TestEdmStructuredObject(edmType);
edmObject.TrySetPropertyValue("Property", 42);
Assert.Contains("Property", edmObject.GetChangedPropertyNames());
}
private static IEdmComplexTypeReference GetComplexTypeReference(
EdmProperty efProperty,
EdmModel model,
IDictionary<MetadataItem, IEdmElement> elementMap)
{
var efComplexType = efProperty.ComplexType;
EdmComplexType complexType;
IEdmElement element;
if (elementMap.TryGetValue(efComplexType, out element))
{
complexType = (EdmComplexType)element;
}
else
{
complexType = new EdmComplexType(efComplexType.NamespaceName, efComplexType.Name);
elementMap.Add(efComplexType, complexType);
model.AddElement(complexType);
foreach (var property in efComplexType.Properties)
{
var propertyTypeRef = GetTypeReference(property, model, elementMap);
if (propertyTypeRef != null)
{
complexType.AddStructuralProperty(property.Name, propertyTypeRef);
}
}
}
return new EdmComplexTypeReference(complexType, efProperty.Nullable);
}
public void ParameterReaderShouldReadCollectionOfDerivedComplexValue()
{
var complexType = this.referencedModel.ComplexType("address").Property("StreetName", EdmPrimitiveTypeKind.String);
var derivedComplexType = new EdmComplexType("TestModel", "derivedAddress", complexType, false);
derivedComplexType.AddStructuralProperty("StreetNumber", EdmPrimitiveTypeKind.Int32, false);
this.referencedModel.AddElement(derivedComplexType);
this.action.AddParameter("addresses", EdmCoreModel.GetCollection(new EdmComplexTypeReference(complexType, false)));
string payload = "{\"addresses\" : [{ \"StreetName\": \"Bla\", \"StreetNumber\" : 61, \"@odata.type\":\"TestModel.derivedAddress\" }, { \"StreetName\": \"Bla2\" }]}";
var result = this.RunParameterReaderTest(payload);
result.Collections.Should().OnlyContain(keyValuePair => keyValuePair.Key.Equals("addresses"));
var collectioItems = result.Collections.Single().Value.Items;
collectioItems.Should().HaveCount(2);
collectioItems.Should().OnlyContain(item => item is ODataComplexValue);
}
public void ParameterReaderShouldReadSingleDerivedComplexValue()
{
var complexType = this.referencedModel.ComplexType("address").Property("StreetName", EdmPrimitiveTypeKind.String);
var derivedComplexType = new EdmComplexType("TestModel", "derivedAddress", complexType, false);
derivedComplexType.AddStructuralProperty("StreetNumber", EdmPrimitiveTypeKind.Int32, false);
this.referencedModel.AddElement(derivedComplexType);
this.action.AddParameter("address", new EdmComplexTypeReference(complexType, false));
string payload = "{\"address\" : { \"StreetName\": \"Bla\", \"StreetNumber\" : 61, \"@odata.type\":\"TestModel.derivedAddress\" } }";
var result = this.RunParameterReaderTest(payload);
result.Values.Should().OnlyContain(keyValuePair => keyValuePair.Key.Equals("address"));
var complexValue = result.Values.Single().Value;
complexValue.Should().BeOfType<ODataComplexValue>();
}
public void StreamPropertiesNegativeTests()
{
EdmModel model=new EdmModel();
EdmComplexType edmComplexType = new EdmComplexType("TestModel", "MyComplexType");
edmComplexType.AddStructuralProperty("Stream1", EdmCoreModel.Instance.GetStream(false));
model.AddElement(edmComplexType);
EdmEntityType edmEntityType = new EdmEntityType("TestModel", "EntityTypeForStreams");
edmEntityType.AddStructuralProperty("Complex", new EdmComplexTypeReference(edmComplexType, false));
edmEntityType.AddStructuralProperty("Collection", EdmCoreModel.GetCollection(new EdmComplexTypeReference(edmComplexType, false)));
edmEntityType.AddStructuralProperty("Int32Collection", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetInt32(false)));
edmEntityType.AddStructuralProperty("NamedStreamCollection", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetStream(false)));
model.AddElement(edmEntityType);
var edmEntityContainer = new EdmEntityContainer("TestModel", "DefaultContainer");
model.AddElement(edmEntityContainer);
var entitySet = edmEntityContainer.AddEntitySet("EntitySetForStreams", edmEntityType);
var testCases = new[] {
// Note that negative test cases to validate the content of an ODataStreamReferenceValue are in WriteInputValidationTests.cs.
// TODO: We need to add these test cases for writing top level properties and metadata as well.
new { // named stream properties are not allowed on complex types
NamedStreamProperty = new ODataProperty()
{
Name = "Complex",
Value = new ODataComplexValue()
{
TypeName = "TestModel.MyComplexType",
Properties = new[]
{
new ODataProperty()
{
Name = "Stream1",
Value = new ODataStreamReferenceValue()
{
EditLink = new Uri("someUri", UriKind.RelativeOrAbsolute)
}
}
}
}
},
ExpectedExceptionWithoutModel = ODataExpectedExceptions.ODataException("ODataWriter_StreamPropertiesMustBePropertiesOfODataEntry"),
ExpectedExceptionWithModel = ODataExpectedExceptions.ODataException("ODataWriter_StreamPropertiesMustBePropertiesOfODataEntry"),
},
new { // named stream properties are not allowed on complex collection types
NamedStreamProperty = new ODataProperty()
{
Name = "Collection",
Value = new ODataCollectionValue()
{
TypeName = EntityModelUtils.GetCollectionTypeName("TestModel.MyComplexType"),
Items = new[]
{
new ODataComplexValue()
{
TypeName = "TestModel.MyComplexType",
Properties = new[]
{
new ODataProperty()
{
Name = "Stream1",
Value = new ODataStreamReferenceValue()
{
EditLink = new Uri("someUri", UriKind.RelativeOrAbsolute)
}
}
}
}
}
}
},
ExpectedExceptionWithoutModel = ODataExpectedExceptions.ODataException("ODataWriter_StreamPropertiesMustBePropertiesOfODataEntry"),
ExpectedExceptionWithModel = ODataExpectedExceptions.ODataException("ODataWriter_StreamPropertiesMustBePropertiesOfODataEntry"),
},
// TODO: Add the following case for the top-level collection writer as well.
new { // named stream collection properties are not allowed.
NamedStreamProperty = new ODataProperty()
{
Name = "Int32Collection",
Value = new ODataCollectionValue()
{
TypeName = EntityModelUtils.GetCollectionTypeName("Edm.Int32"),
Items = new[]
{
new ODataStreamReferenceValue()
{
EditLink = new Uri("someUri", UriKind.RelativeOrAbsolute)
}
}
}
},
ExpectedExceptionWithoutModel = ODataExpectedExceptions.ODataException("ValidationUtils_StreamReferenceValuesNotSupportedInCollections"),
ExpectedExceptionWithModel = ODataExpectedExceptions.ODataException("ValidationUtils_StreamReferenceValuesNotSupportedInCollections"),
},
new { // named stream collection properties are not allowed - with valid type.
NamedStreamProperty = new ODataProperty()
{
Name = "NamedStreamCollection",
Value = new ODataCollectionValue()
{
TypeName = EntityModelUtils.GetCollectionTypeName("Edm.Stream"),
Items = new[]
{
new ODataStreamReferenceValue()
{
EditLink = new Uri("someUri", UriKind.RelativeOrAbsolute)
}
}
}
},
ExpectedExceptionWithoutModel = ODataExpectedExceptions.ODataException("ValidationUtils_StreamReferenceValuesNotSupportedInCollections"),
ExpectedExceptionWithModel = ODataExpectedExceptions.ODataException("EdmLibraryExtensions_CollectionItemCanBeOnlyPrimitiveEnumComplex"),
},
};
var testDescriptors = testCases.SelectMany(testCase =>
{
ODataEntry entry = new ODataEntry()
{
TypeName = "TestModel.EntityTypeForStreams",
Properties = new ODataProperty[] { testCase.NamedStreamProperty },
SerializationInfo = new ODataFeedAndEntrySerializationInfo()
{
NavigationSourceEntityTypeName = "TestModel.EntityTypeForStreams",
ExpectedTypeName = "TestModel.EntityTypeForStreams",
NavigationSourceName = "MySet"
}
};
return new []
{
new PayloadWriterTestDescriptor<ODataItem>(
this.Settings,
entry,
testConfiguration => new WriterTestExpectedResults(this.Settings.ExpectedResultSettings) { ExpectedException2 = testCase.ExpectedExceptionWithoutModel })
{
Model = null,
},
new PayloadWriterTestDescriptor<ODataItem>(
this.Settings,
entry,
testConfiguration => new WriterTestExpectedResults(this.Settings.ExpectedResultSettings) { ExpectedException2 = testCase.ExpectedExceptionWithModel })
{
Model = model,
PayloadEdmElementContainer = entitySet,
PayloadEdmElementType = edmEntityType,
},
};
});
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.WriterTestConfigurationProvider.ExplicitFormatConfigurations,
(testDescriptor, testConfiguration) =>
{
testConfiguration = testConfiguration.Clone();
testConfiguration.MessageWriterSettings.SetServiceDocumentUri(ServiceDocumentUri);
if (testDescriptor.Model == null && testConfiguration.Format == ODataFormat.Json)
{
return;
}
TestWriterUtils.WriteAndVerifyODataPayload(testDescriptor, testConfiguration, this.Assert, this.Logger);
});
}
public static IEnumerable<XElement> SimpleAllPrimitiveTypes(EdmVersion edmVersion, bool explictNullable, bool isNullable)
{
var namespaceName = "ModelBuilder.SimpleAllPrimitiveTypes";
var model = new EdmModel();
var entityType = new EdmEntityType(namespaceName, "validEntityType1");
entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false));
model.AddElement(entityType);
var complexType = new EdmComplexType(namespaceName, "V1alidcomplexType");
model.AddElement(complexType);
int i = 0;
bool typesAreNullable = !explictNullable && isNullable;
foreach (var primitiveType in AllPrimitiveEdmTypes(edmVersion, typesAreNullable))
{
entityType.AddStructuralProperty("Property" + i++, primitiveType);
complexType.AddStructuralProperty("Property" + i++, primitiveType);
}
var stringBuilder = new StringBuilder();
var xmlWriter = XmlWriter.Create(stringBuilder);
IEnumerable<EdmError> errors;
if (!model.TryWriteCsdl((s) => xmlWriter, out errors) || errors.Any())
{
ExceptionUtilities.Assert(false, "Failed to write CSDL: " + string.Join(",", errors.Select(e => e.ErrorMessage)));
}
xmlWriter.Close();
var csdlElements = new[] { XElement.Parse(stringBuilder.ToString()) };
if (explictNullable)
{
ModelBuilderHelpers.SetNullableAttributes(csdlElements, isNullable);
}
return csdlElements;
}
public static IEdmModel TaupoDefaultModelEdm()
{
var model = new EdmModel();
#region TaupoDefault Model code
var phoneType = new EdmComplexType("NS1", "Phone");
phoneType.AddStructuralProperty("PhoneNumber", EdmCoreModel.Instance.GetString(isUnbounded: false, maxLength: 16, isUnicode: false, isNullable: false));
phoneType.AddStructuralProperty("Extension", EdmCoreModel.Instance.GetString(isUnbounded: false, maxLength: 16, isUnicode: false, isNullable: true));
model.AddElement(phoneType);
var phoneTypeReference = new EdmComplexTypeReference(phoneType, false);
var contactDetailsType = new EdmComplexType("NS1", "ContactDetails");
contactDetailsType.AddStructuralProperty("Email", EdmCoreModel.Instance.GetString(isUnbounded: false, maxLength: 32, isUnicode: false, isNullable: false));
contactDetailsType.AddStructuralProperty("HomePhone", phoneTypeReference);
contactDetailsType.AddStructuralProperty("WorkPhone", phoneTypeReference);
contactDetailsType.AddStructuralProperty("MobilePhone", phoneTypeReference);
model.AddElement(contactDetailsType);
var contactDetailsTypeReference = new EdmComplexTypeReference(contactDetailsType, false);
var concurrencyInfoType = new EdmComplexType("NS1", "ConcurrencyInfo");
concurrencyInfoType.AddStructuralProperty("Token", EdmCoreModel.Instance.GetString(isUnbounded: false, maxLength: 20, isUnicode: false, isNullable: false), string.Empty, EdmConcurrencyMode.Fixed);
concurrencyInfoType.AddStructuralProperty("QueriedDateTimeOffset", EdmCoreModel.Instance.GetDateTimeOffset(true));
model.AddElement(concurrencyInfoType);
var concurrencyInfoTypeReference = new EdmComplexTypeReference(concurrencyInfoType, false);
var auditInfoType = new EdmComplexType("NS1", "AuditInfo");
auditInfoType.AddStructuralProperty("ModifiedDate", EdmPrimitiveTypeKind.DateTimeOffset);
auditInfoType.AddStructuralProperty("ModifiedBy", EdmCoreModel.Instance.GetString(isUnbounded: false, maxLength: 50, isUnicode: false, isNullable: false));
auditInfoType.AddStructuralProperty("Concurrency", new EdmComplexTypeReference(concurrencyInfoType, false));
model.AddElement(auditInfoType);
var auditInfoTypeReference = new EdmComplexTypeReference(auditInfoType, false);
var dimensionsType = new EdmComplexType("NS1", "Dimensions");
dimensionsType.AddStructuralProperty("Width", EdmCoreModel.Instance.GetDecimal(10, 3, false));
dimensionsType.AddStructuralProperty("Height", EdmCoreModel.Instance.GetDecimal(10, 3, false));
dimensionsType.AddStructuralProperty("Depth", EdmCoreModel.Instance.GetDecimal(10, 3, false));
model.AddElement(dimensionsType);
var dimensionsTypeReference = new EdmComplexTypeReference(dimensionsType, false);
var suspiciousActivityType = new EdmEntityType("NS1", "SuspiciousActivity");
suspiciousActivityType.AddKeys(suspiciousActivityType.AddStructuralProperty("SuspiciousActivityId", EdmPrimitiveTypeKind.Int32, false));
suspiciousActivityType.AddStructuralProperty("Activity", EdmPrimitiveTypeKind.String);
model.AddElement(suspiciousActivityType);
var messageType = new EdmEntityType("NS1", "Message");
var fromUsername = messageType.AddStructuralProperty("FromUsername", EdmCoreModel.Instance.GetString(isUnbounded: false, isNullable: false, maxLength: 50, isUnicode: false));
messageType.AddKeys(messageType.AddStructuralProperty("MessageId", EdmPrimitiveTypeKind.Int32, false), fromUsername);
var toUsername = messageType.AddStructuralProperty("ToUsername", EdmCoreModel.Instance.GetString(isUnbounded: false, isNullable: false, maxLength: 50, isUnicode: false));
messageType.AddStructuralProperty("Sent", EdmPrimitiveTypeKind.DateTimeOffset);
messageType.AddStructuralProperty("Subject", EdmPrimitiveTypeKind.String);
messageType.AddStructuralProperty("Body", EdmCoreModel.Instance.GetString(true));
messageType.AddStructuralProperty("IsRead", EdmCoreModel.Instance.GetBoolean(false));
model.AddElement(messageType);
var loginType = new EdmEntityType("NS1", "Login");
loginType.AddKeys(loginType.AddStructuralProperty("Username", EdmCoreModel.Instance.GetString(isUnbounded: false, isNullable: false, maxLength: 50, isUnicode: false)));
var loginCustomerIdProperty = loginType.AddStructuralProperty("CustomerId", EdmPrimitiveTypeKind.Int32, false);
model.AddElement(loginType);
var loginSentMessages = new EdmNavigationPropertyInfo { Name = "SentMessages", Target = messageType, TargetMultiplicity = EdmMultiplicity.Many };
var messageSender = new EdmNavigationPropertyInfo { Name = "Sender", Target = loginType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { fromUsername }, PrincipalProperties = loginType.Key() };
loginType.AddBidirectionalNavigation(loginSentMessages, messageSender);
var loginReceivedMessages = new EdmNavigationPropertyInfo { Name = "ReceivedMessages", Target = messageType, TargetMultiplicity = EdmMultiplicity.Many };
var messageRecipient = new EdmNavigationPropertyInfo { Name = "Recipient", Target = loginType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { fromUsername }, PrincipalProperties = loginType.Key() };
loginType.AddBidirectionalNavigation(loginReceivedMessages, messageRecipient);
var loginSuspiciousActivity = new EdmNavigationPropertyInfo { Name = "SuspiciousActivity", Target = suspiciousActivityType, TargetMultiplicity = EdmMultiplicity.Many };
loginType.AddUnidirectionalNavigation(loginSuspiciousActivity);
var lastLoginType = new EdmEntityType("NS1", "LastLogin");
var userNameProperty = lastLoginType.AddStructuralProperty("Username", EdmCoreModel.Instance.GetString(isUnbounded: false, isNullable: false, maxLength: 50, isUnicode: false));
lastLoginType.AddKeys(userNameProperty);
lastLoginType.AddStructuralProperty("LoggedIn", EdmPrimitiveTypeKind.DateTimeOffset);
lastLoginType.AddStructuralProperty("LoggedOut", EdmCoreModel.Instance.GetDateTimeOffset(true));
model.AddElement(lastLoginType);
var loginLastLogin = new EdmNavigationPropertyInfo { Name = "LastLogin", Target = lastLoginType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne };
var lastLoginLogin = new EdmNavigationPropertyInfo { Name = "Login", Target = loginType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { userNameProperty }, PrincipalProperties = loginType.Key() };
lastLoginType.AddBidirectionalNavigation(lastLoginLogin, loginLastLogin);
var orderType = new EdmEntityType("NS1", "Order");
orderType.AddKeys(orderType.AddStructuralProperty("OrderId", EdmPrimitiveTypeKind.Int32, false));
var orderCustomerId = orderType.AddStructuralProperty("CustomerId", EdmCoreModel.Instance.GetInt32(true));
orderType.AddStructuralProperty("Concurrency", concurrencyInfoTypeReference);
model.AddElement(orderType);
var loginOrders = new EdmNavigationPropertyInfo { Name = "Orders", Target = orderType, TargetMultiplicity = EdmMultiplicity.Many };
var orderLogin = new EdmNavigationPropertyInfo { Name = "Login", Target = loginType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne };
orderType.AddBidirectionalNavigation(orderLogin, loginOrders);
var customerInfoType = new EdmEntityType("NS1", "CustomerInfo");
customerInfoType.AddKeys(customerInfoType.AddStructuralProperty("CustomerInfoId", EdmPrimitiveTypeKind.Int32, false));
customerInfoType.AddStructuralProperty("Information", EdmPrimitiveTypeKind.String);
model.AddElement(customerInfoType);
var customerType = new EdmEntityType("NS1", "Customer");
var customerIdProperty = customerType.AddStructuralProperty("CustomerId", EdmPrimitiveTypeKind.Int32, false);
customerType.AddKeys(customerIdProperty);
customerType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(isUnbounded: false, maxLength: 100, isUnicode: false, isNullable: false));
customerType.AddStructuralProperty("ContactInfo", contactDetailsTypeReference);
model.AddElement(customerType);
var customerOrders = new EdmNavigationPropertyInfo { Name = "Orders", Target = orderType, TargetMultiplicity = EdmMultiplicity.Many, };
var orderCustomer = new EdmNavigationPropertyInfo { Name = "Customer", Target = customerType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne, DependentProperties = new[] { orderCustomerId }, PrincipalProperties = customerType.Key() };
customerType.AddBidirectionalNavigation(customerOrders, orderCustomer);
var customerLogins = new EdmNavigationPropertyInfo { Name = "Logins", Target = loginType, TargetMultiplicity = EdmMultiplicity.Many, };
var loginCustomer = new EdmNavigationPropertyInfo { Name = "Customer", Target = customerType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { loginCustomerIdProperty }, PrincipalProperties = customerType.Key() };
customerType.AddBidirectionalNavigation(customerLogins, loginCustomer);
var customerHusband = new EdmNavigationPropertyInfo { Name = "Husband", Target = customerType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne };
var customerWife = new EdmNavigationPropertyInfo { Name = "Wife", Target = customerType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne };
customerType.AddBidirectionalNavigation(customerHusband, customerWife);
var customerInfo = new EdmNavigationPropertyInfo { Name = "CustomerInfo", Target = customerInfoType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne };
customerType.AddUnidirectionalNavigation(customerInfo);
var productType = new EdmEntityType("NS1", "Product");
productType.AddKeys(productType.AddStructuralProperty("ProductId", EdmPrimitiveTypeKind.Int32, false));
productType.AddStructuralProperty("Description", EdmCoreModel.Instance.GetString(isUnbounded: false, isNullable: true, maxLength: 1000, isUnicode: false));
productType.AddStructuralProperty("Dimensions", dimensionsTypeReference);
productType.AddStructuralProperty("BaseConcurrency", EdmCoreModel.Instance.GetString(false), string.Empty, EdmConcurrencyMode.Fixed);
productType.AddStructuralProperty("ComplexConcurrency", concurrencyInfoTypeReference);
productType.AddStructuralProperty("NestedComplexConcurrency", auditInfoTypeReference);
model.AddElement(productType);
var barCodeType = new EdmEntityType("NS1", "Barcode");
barCodeType.AddKeys(barCodeType.AddStructuralProperty("Code", EdmCoreModel.Instance.GetBinary(isUnbounded: false, isNullable: false, maxLength: 50)));
var barCodeProductIdProperty = barCodeType.AddStructuralProperty("ProductId", EdmPrimitiveTypeKind.Int32, false);
barCodeType.AddStructuralProperty("Text", EdmPrimitiveTypeKind.String);
model.AddElement(barCodeType);
var productBarCodes = new EdmNavigationPropertyInfo { Name = "Barcodes", Target = barCodeType, TargetMultiplicity = EdmMultiplicity.Many };
var barCodeProduct = new EdmNavigationPropertyInfo { Name = "Product", Target = productType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { barCodeProductIdProperty }, PrincipalProperties = productType.Key() };
barCodeType.AddBidirectionalNavigation(barCodeProduct, productBarCodes);
var incorrectScanType = new EdmEntityType("NS1", "IncorrectScan");
incorrectScanType.AddKeys(incorrectScanType.AddStructuralProperty("IncorrectScanId", EdmPrimitiveTypeKind.Int32, false));
var expectedCodeProperty = incorrectScanType.AddStructuralProperty("ExpectedCode", EdmCoreModel.Instance.GetBinary(isUnbounded: false, isNullable: false, maxLength: 50));
var actualCodeProperty = incorrectScanType.AddStructuralProperty("ActualCode", EdmCoreModel.Instance.GetBinary(isUnbounded: false, isNullable: true, maxLength: 50));
incorrectScanType.AddStructuralProperty("ScanDate", EdmPrimitiveTypeKind.DateTimeOffset);
incorrectScanType.AddStructuralProperty("Details", EdmPrimitiveTypeKind.String);
model.AddElement(incorrectScanType);
var barCodeIncorrectScan = new EdmNavigationPropertyInfo { Name = "BadScans", Target = incorrectScanType, TargetMultiplicity = EdmMultiplicity.Many };
var incorrectScanExpectedBarCode = new EdmNavigationPropertyInfo { Name = "ExpectedBarcode", Target = barCodeType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { expectedCodeProperty }, PrincipalProperties = barCodeType.Key() };
incorrectScanType.AddBidirectionalNavigation(incorrectScanExpectedBarCode, barCodeIncorrectScan);
var actualBarcode = new EdmNavigationPropertyInfo { Name = "ActualBarcode", Target = barCodeType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne, DependentProperties = new[] { actualCodeProperty }, PrincipalProperties = barCodeType.Key() };
incorrectScanType.AddUnidirectionalNavigation(actualBarcode);
var barCodeDetailType = new EdmEntityType("NS1", "BarcodeDetail");
var codeProperty = barCodeDetailType.AddStructuralProperty("Code", EdmCoreModel.Instance.GetBinary(isUnbounded: false, isNullable: false, maxLength: 50));
barCodeDetailType.AddKeys(codeProperty);
barCodeDetailType.AddStructuralProperty("RegisteredTo", EdmPrimitiveTypeKind.String);
model.AddElement(barCodeDetailType);
var barCodeDetail = new EdmNavigationPropertyInfo { Name = "Detail", Target = barCodeDetailType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = barCodeType.Key(), PrincipalProperties = barCodeDetailType.Key() };
barCodeType.AddUnidirectionalNavigation(barCodeDetail);
var resolutionType = new EdmEntityType("NS1", "Resolution");
resolutionType.AddKeys(resolutionType.AddStructuralProperty("ResolutionId", EdmPrimitiveTypeKind.Int32, false));
resolutionType.AddStructuralProperty("Details", EdmPrimitiveTypeKind.String);
model.AddElement(resolutionType);
var complaintType = new EdmEntityType("NS1", "Complaint");
complaintType.AddKeys(complaintType.AddStructuralProperty("ComplaintId", EdmPrimitiveTypeKind.Int32, false));
var complaintCustomerId = complaintType.AddStructuralProperty("CustomerId", EdmCoreModel.Instance.GetInt32(true));
complaintType.AddStructuralProperty("Logged", EdmPrimitiveTypeKind.DateTimeOffset);
complaintType.AddStructuralProperty("Details", EdmPrimitiveTypeKind.String);
model.AddElement(complaintType);
var complaintCustomer = new EdmNavigationPropertyInfo { Name = "Customer", Target = customerType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne, DependentProperties = new[] { complaintCustomerId }, PrincipalProperties = customerType.Key() };
complaintType.AddUnidirectionalNavigation(complaintCustomer);
var complaintResolution = new EdmNavigationPropertyInfo { Name = "Resolution", Target = resolutionType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne };
var resolutionComplaint = new EdmNavigationPropertyInfo { Name = "Complaint", Target = complaintType, TargetMultiplicity = EdmMultiplicity.One };
complaintType.AddBidirectionalNavigation(complaintResolution, resolutionComplaint);
var smartCardType = new EdmEntityType("NS1", "SmartCard");
var smartCardUsername = smartCardType.AddStructuralProperty("Username", EdmCoreModel.Instance.GetString(isUnbounded: false, isNullable: false, maxLength: 50, isUnicode: false));
smartCardType.AddKeys(smartCardUsername);
smartCardType.AddStructuralProperty("CardSerial", EdmPrimitiveTypeKind.String);
smartCardType.AddStructuralProperty("Issued", EdmPrimitiveTypeKind.DateTimeOffset);
model.AddElement(smartCardType);
var smartCardLogin = new EdmNavigationPropertyInfo { Name = "Login", Target = loginType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { smartCardUsername }, PrincipalProperties = loginType.Key() };
smartCardType.AddUnidirectionalNavigation(smartCardLogin);
var smartCardLastLogin = new EdmNavigationPropertyInfo { Name = "LastLogin", Target = lastLoginType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne };
smartCardType.AddUnidirectionalNavigation(smartCardLastLogin);
var rsaTokenType = new EdmEntityType("NS1", "RSAToken");
rsaTokenType.AddKeys(rsaTokenType.AddStructuralProperty("Serial", EdmCoreModel.Instance.GetString(isUnbounded: false, isNullable: false, maxLength: 20, isUnicode: false)));
rsaTokenType.AddStructuralProperty("Issued", EdmPrimitiveTypeKind.DateTimeOffset);
model.AddElement(rsaTokenType);
var rsaTokenLogin = new EdmNavigationPropertyInfo { Name = "Login", Target = loginType, TargetMultiplicity = EdmMultiplicity.One };
rsaTokenType.AddUnidirectionalNavigation(rsaTokenLogin);
var passwordResetType = new EdmEntityType("NS1", "PasswordReset");
passwordResetType.AddKeys(passwordResetType.AddStructuralProperty("ResetNo", EdmPrimitiveTypeKind.Int32, false));
var passwordResetUsername = passwordResetType.AddStructuralProperty("Username", EdmCoreModel.Instance.GetString(isUnbounded: false, isNullable: false, maxLength: 50, isUnicode: false));
passwordResetType.AddStructuralProperty("TempPassword", EdmPrimitiveTypeKind.String);
passwordResetType.AddStructuralProperty("EmailedTo", EdmPrimitiveTypeKind.String);
model.AddElement(passwordResetType);
var passwordResetLogin = new EdmNavigationPropertyInfo { Name = "Login", Target = loginType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { passwordResetUsername }, PrincipalProperties = loginType.Key() };
passwordResetType.AddUnidirectionalNavigation(passwordResetLogin);
var pageViewType = new EdmEntityType("NS1", "PageView");
pageViewType.AddKeys(pageViewType.AddStructuralProperty("PageViewId", EdmPrimitiveTypeKind.Int32, false));
var pageViewUsername = pageViewType.AddStructuralProperty("Username", EdmCoreModel.Instance.GetString(isUnbounded: false, isNullable: false, maxLength: 50, isUnicode: false));
pageViewType.AddStructuralProperty("Viewed", EdmPrimitiveTypeKind.DateTimeOffset);
pageViewType.AddStructuralProperty("PageUrl", EdmCoreModel.Instance.GetString(isUnbounded: false, isNullable: false, maxLength: 500, isUnicode: false));
model.AddElement(pageViewType);
var pageViewLogin = new EdmNavigationPropertyInfo { Name = "Login", Target = loginType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { pageViewUsername }, PrincipalProperties = loginType.Key() };
pageViewType.AddUnidirectionalNavigation(pageViewLogin);
var productPageViewType = new EdmEntityType("NS1", "ProductPageView", pageViewType);
var productPageViewProductId = productPageViewType.AddStructuralProperty("ProductId", EdmPrimitiveTypeKind.Int32, false);
model.AddElement(productPageViewType);
var productPageViewProduct = new EdmNavigationPropertyInfo { Name = "Product", Target = productType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { productPageViewProductId }, PrincipalProperties = productType.Key() };
productPageViewType.AddUnidirectionalNavigation(productPageViewProduct);
var supplierType = new EdmEntityType("NS1", "Supplier");
supplierType.AddKeys(supplierType.AddStructuralProperty("SupplierId", EdmPrimitiveTypeKind.Int32, false));
supplierType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
model.AddElement(supplierType);
var supplierProducts = new EdmNavigationPropertyInfo { Name = "Products", Target = productType, TargetMultiplicity = EdmMultiplicity.Many };
var productSuppliers = new EdmNavigationPropertyInfo { Name = "Suppliers", Target = supplierType, TargetMultiplicity = EdmMultiplicity.Many };
supplierType.AddBidirectionalNavigation(supplierProducts, productSuppliers);
var supplierLogoType = new EdmEntityType("NS1", "SupplierLogo");
var supplierLogoSupplierId = supplierLogoType.AddStructuralProperty("SupplierId", EdmPrimitiveTypeKind.Int32, false);
supplierLogoType.AddKeys(supplierLogoSupplierId);
supplierLogoType.AddStructuralProperty("Logo", EdmCoreModel.Instance.GetBinary(isNullable: false, isUnbounded: false, maxLength: 500));
model.AddElement(supplierLogoType);
var supplierSupplierLogo = new EdmNavigationPropertyInfo { Name = "Logo", Target = supplierLogoType, TargetMultiplicity = EdmMultiplicity.One, PrincipalProperties = new[] { supplierLogoSupplierId }, DependentProperties = supplierType.Key() };
supplierType.AddUnidirectionalNavigation(supplierSupplierLogo);
var supplierInfoType = new EdmEntityType("NS1", "SupplierInfo");
supplierInfoType.AddKeys(supplierInfoType.AddStructuralProperty("SupplierInfoId", EdmPrimitiveTypeKind.Int32, false));
supplierInfoType.AddStructuralProperty("Information", EdmPrimitiveTypeKind.String);
model.AddElement(supplierInfoType);
var supplierInfoSupplier = new EdmNavigationPropertyInfo { Name = "Supplier", Target = supplierType, TargetMultiplicity = EdmMultiplicity.One, OnDelete = EdmOnDeleteAction.Cascade };
supplierInfoType.AddUnidirectionalNavigation(supplierInfoSupplier);
var orderNoteType = new EdmEntityType("NS1", "OrderNote");
orderNoteType.AddKeys(orderNoteType.AddStructuralProperty("NoteId", EdmPrimitiveTypeKind.Int32, false));
orderNoteType.AddStructuralProperty("Note", EdmPrimitiveTypeKind.String);
model.AddElement(orderNoteType);
var orderNoteOrder = new EdmNavigationPropertyInfo { Name = "Order", Target = orderType, TargetMultiplicity = EdmMultiplicity.One };
var orderOrderNotes = new EdmNavigationPropertyInfo { Name = "Notes", Target = orderNoteType, TargetMultiplicity = EdmMultiplicity.Many, OnDelete = EdmOnDeleteAction.Cascade };
orderNoteType.AddBidirectionalNavigation(orderNoteOrder, orderOrderNotes);
var orderQualityCheckType = new EdmEntityType("NS1", "OrderQualityCheck");
var orderQualityCheckOrderId = orderQualityCheckType.AddStructuralProperty("OrderId", EdmPrimitiveTypeKind.Int32, false);
orderQualityCheckType.AddKeys(orderQualityCheckOrderId);
orderQualityCheckType.AddStructuralProperty("CheckedBy", EdmPrimitiveTypeKind.String);
orderQualityCheckType.AddStructuralProperty("CheckedDateTime", EdmPrimitiveTypeKind.DateTimeOffset);
model.AddElement(orderQualityCheckType);
var orderQualityCheckOrder = new EdmNavigationPropertyInfo { Name = "Order", Target = orderType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { orderQualityCheckOrderId }, PrincipalProperties = orderType.Key() };
orderQualityCheckType.AddUnidirectionalNavigation(orderQualityCheckOrder);
var orderLineType = new EdmEntityType("NS1", "OrderLine");
var orderLineOrderId = orderLineType.AddStructuralProperty("OrderId", EdmPrimitiveTypeKind.Int32, false);
var orderLineProductId = orderLineType.AddStructuralProperty("ProductId", EdmPrimitiveTypeKind.Int32, false);
orderLineType.AddKeys(orderLineOrderId, orderLineProductId);
orderLineType.AddStructuralProperty("Quantity", EdmPrimitiveTypeKind.Int32);
orderLineType.AddStructuralProperty("ConcurrencyToken", EdmCoreModel.Instance.GetString(false), string.Empty, EdmConcurrencyMode.Fixed);
model.AddElement(orderLineType);
var orderLineOrder = new EdmNavigationPropertyInfo { Name = "Order", Target = orderType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { orderLineOrderId }, PrincipalProperties = orderType.Key() };
var orderOrderLine = new EdmNavigationPropertyInfo { Name = "OrderLines", Target = orderLineType, TargetMultiplicity = EdmMultiplicity.Many };
orderLineType.AddBidirectionalNavigation(orderLineOrder, orderOrderLine);
var orderLineProduct = new EdmNavigationPropertyInfo { Name = "Product", Target = productType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { orderLineProductId }, PrincipalProperties = productType.Key() };
orderLineType.AddUnidirectionalNavigation(orderLineProduct);
var backOrderLineType = new EdmEntityType("NS1", "BackOrderLine", orderLineType);
backOrderLineType.AddStructuralProperty("ETA", EdmPrimitiveTypeKind.DateTimeOffset);
model.AddElement(backOrderLineType);
var backOrderLineSupplier = new EdmNavigationPropertyInfo { Name = "Supplier", Target = supplierType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne };
var supplierBackOrderLines = new EdmNavigationPropertyInfo { Name = "BackOrderLines", Target = backOrderLineType, TargetMultiplicity = EdmMultiplicity.Many };
backOrderLineType.AddBidirectionalNavigation(backOrderLineSupplier, supplierBackOrderLines);
var backOrderLine2Type = new EdmEntityType("NS1", "BackOrderLine2", backOrderLineType);
model.AddElement(backOrderLine2Type);
var discontinuedProductType = new EdmEntityType("NS1", "DiscontinuedProduct", productType);
discontinuedProductType.AddStructuralProperty("Discontinued", EdmPrimitiveTypeKind.DateTimeOffset);
var replacementProductId = discontinuedProductType.AddStructuralProperty("ReplacementProductId", EdmCoreModel.Instance.GetInt32(true));
model.AddElement(discontinuedProductType);
var discontinuedProductReplacement = new EdmNavigationPropertyInfo { Name = "ReplacedBy", Target = productType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne, DependentProperties = new[] { replacementProductId }, PrincipalProperties = productType.Key() };
var productReplaces = new EdmNavigationPropertyInfo { Name = "Replaces", Target = discontinuedProductType, TargetMultiplicity = EdmMultiplicity.Many, };
discontinuedProductType.AddBidirectionalNavigation(discontinuedProductReplacement, productReplaces);
var productDetailType = new EdmEntityType("NS1", "ProductDetail");
var productDetailProductId = productDetailType.AddStructuralProperty("ProductId", EdmPrimitiveTypeKind.Int32, false);
productDetailType.AddKeys(productDetailProductId);
productDetailType.AddStructuralProperty("Details", EdmPrimitiveTypeKind.String);
model.AddElement(productDetailType);
var productDetailProduct = new EdmNavigationPropertyInfo { Name = "Product", Target = productType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { productDetailProductId }, PrincipalProperties = productType.Key() };
var productProductDetail = new EdmNavigationPropertyInfo { Name = "Detail", Target = productDetailType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne };
productDetailType.AddBidirectionalNavigation(productDetailProduct, productProductDetail);
var productReviewType = new EdmEntityType("NS1", "ProductReview");
var productReviewProductId = productReviewType.AddStructuralProperty("ProductId", EdmPrimitiveTypeKind.Int32, false);
productReviewType.AddKeys(productReviewProductId, productReviewType.AddStructuralProperty("ReviewId", EdmPrimitiveTypeKind.Int32, false));
productReviewType.AddStructuralProperty("Review", EdmPrimitiveTypeKind.String);
model.AddElement(productReviewType);
var productReviewProduct = new EdmNavigationPropertyInfo { Name = "Product", Target = productType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { productReviewProductId }, PrincipalProperties = productType.Key() };
var productProductReviews = new EdmNavigationPropertyInfo { Name = "Reviews", Target = productReviewType, TargetMultiplicity = EdmMultiplicity.Many };
productReviewType.AddBidirectionalNavigation(productReviewProduct, productProductReviews);
var productPhotoType = new EdmEntityType("NS1", "ProductPhoto");
var productPhotoProductId = productPhotoType.AddStructuralProperty("ProductId", EdmPrimitiveTypeKind.Int32, false);
productPhotoType.AddKeys(productPhotoProductId, productPhotoType.AddStructuralProperty("PhotoId", EdmPrimitiveTypeKind.Int32, false));
productPhotoType.AddStructuralProperty("Photo", EdmPrimitiveTypeKind.Binary);
model.AddElement(productPhotoType);
var productProductPhotos = new EdmNavigationPropertyInfo { Name = "Photos", Target = productPhotoType, TargetMultiplicity = EdmMultiplicity.Many };
var productPhotoProduct = new EdmNavigationPropertyInfo { Name = "Product", Target = productType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { productPhotoProductId }, PrincipalProperties = productType.Key() };
productType.AddBidirectionalNavigation(productProductPhotos, productPhotoProduct);
var productWebFeatureType = new EdmEntityType("NS1", "ProductWebFeature");
productWebFeatureType.AddKeys(productWebFeatureType.AddStructuralProperty("FeatureId", EdmPrimitiveTypeKind.Int32, false));
var productWebFeatureProductId = productWebFeatureType.AddStructuralProperty("ProductId", EdmCoreModel.Instance.GetInt32(true));
var productWebFeaturePhotoId = productWebFeatureType.AddStructuralProperty("PhotoId", EdmCoreModel.Instance.GetInt32(true));
var productWebFeatureReviewId = productWebFeatureType.AddStructuralProperty("ReviewId", EdmCoreModel.Instance.GetInt32(true));
productWebFeatureType.AddStructuralProperty("Heading", EdmPrimitiveTypeKind.String);
model.AddElement(productWebFeatureType);
var productReviewWebFeatures = new EdmNavigationPropertyInfo { Name = "Features", Target = productWebFeatureType, TargetMultiplicity = EdmMultiplicity.Many };
var productWebFeatureReview = new EdmNavigationPropertyInfo { Name = "Review", Target = productReviewType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne, DependentProperties = new[] { productWebFeatureReviewId, productWebFeatureProductId }, PrincipalProperties = productReviewType.Key() };
productWebFeatureType.AddBidirectionalNavigation(productWebFeatureReview, productReviewWebFeatures);
var productPhotoWebFeatures = new EdmNavigationPropertyInfo { Name = "Features", Target = productWebFeatureType, TargetMultiplicity = EdmMultiplicity.Many };
var productWebFeaturePhoto = new EdmNavigationPropertyInfo { Name = "Photo", Target = productPhotoType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne, DependentProperties = new[] { productWebFeaturePhotoId, productWebFeatureProductId }, PrincipalProperties = productPhotoType.Key() };
productWebFeatureType.AddBidirectionalNavigation(productWebFeaturePhoto, productPhotoWebFeatures);
var computerType = new EdmEntityType("NS1", "Computer");
computerType.AddKeys(computerType.AddStructuralProperty("ComputerId", EdmPrimitiveTypeKind.Int32, false));
computerType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
model.AddElement(computerType);
var computerDetailType = new EdmEntityType("NS1", "ComputerDetail");
computerDetailType.AddKeys(computerDetailType.AddStructuralProperty("ComputerDetailId", EdmPrimitiveTypeKind.Int32, false));
computerDetailType.AddStructuralProperty("Model", EdmPrimitiveTypeKind.String);
computerDetailType.AddStructuralProperty("Serial", EdmPrimitiveTypeKind.String);
computerDetailType.AddStructuralProperty("Specifications", EdmPrimitiveTypeKind.String);
computerDetailType.AddStructuralProperty("PurchaseDate", EdmPrimitiveTypeKind.DateTimeOffset);
computerDetailType.AddStructuralProperty("Dimensions", dimensionsTypeReference);
model.AddElement(computerDetailType);
var computerDetailComputer = new EdmNavigationPropertyInfo { Name = "Computer", Target = computerType, TargetMultiplicity = EdmMultiplicity.One };
var computerComputerDetail = new EdmNavigationPropertyInfo { Name = "ComputerDetail", Target = computerDetailType, TargetMultiplicity = EdmMultiplicity.One };
computerType.AddBidirectionalNavigation(computerComputerDetail, computerDetailComputer);
var driverType = new EdmEntityType("NS1", "Driver");
driverType.AddKeys(driverType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(isUnbounded: false, maxLength: 100, isNullable: false, isUnicode: false)));
driverType.AddStructuralProperty("BirthDate", EdmPrimitiveTypeKind.DateTimeOffset);
model.AddElement(driverType);
var licenseType = new EdmEntityType("NS1", "License");
var licenseDriverName = licenseType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(isUnbounded: false, maxLength: 100, isNullable: false, isUnicode: false));
licenseType.AddKeys(licenseDriverName);
licenseType.AddStructuralProperty("LicenseNumber", EdmPrimitiveTypeKind.String);
licenseType.AddStructuralProperty("LicenseClass", EdmPrimitiveTypeKind.String);
licenseType.AddStructuralProperty("Restrictions", EdmPrimitiveTypeKind.String);
licenseType.AddStructuralProperty("ExpirationDate", EdmPrimitiveTypeKind.DateTimeOffset);
model.AddElement(licenseType);
var driverLicense = new EdmNavigationPropertyInfo { Name = "License", Target = licenseType, TargetMultiplicity = EdmMultiplicity.One, };
var licenseDriver = new EdmNavigationPropertyInfo { Name = "Driver", Target = driverType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { licenseDriverName }, PrincipalProperties = driverType.Key() };
licenseType.AddBidirectionalNavigation(licenseDriver, driverLicense);
#endregion
model.AddDefaultContainerFixup("NS1");
return model;
}
public static IEdmModel ModelWithEnumEdm(params IEdmEnumType[] enumTypes)
{
var model = new EdmModel();
var complexType = new EdmComplexType("NS1", "Complex");
model.AddElement(complexType);
var entityType = new EdmEntityType("NS1", "Person");
model.AddElement(entityType);
var container = new EdmEntityContainer("NS1", "MyContainer");
model.AddElement(container);
int counter = 0;
foreach (var enumType in enumTypes)
{
var enumTypeReference = new EdmEnumTypeReference(enumType, false);
model.AddElement(enumType);
complexType.AddStructuralProperty("EnumProperty" + counter, enumTypeReference);
entityType.AddKeys(entityType.AddStructuralProperty("EnumProperty" + counter, enumTypeReference));
var function = new EdmFunction("NS1", "Function" + counter, enumTypeReference);
model.AddElement(function);
container.AddFunctionImport(function);
function.AddParameter("Param" + counter, enumTypeReference);
counter++;
}
return model;
}
public static IEdmModel ModelWithAllConceptsEdm()
{
var stringType = EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.String);
var model = new EdmModel();
var addressType = new EdmComplexType("NS1", "Address");
addressType.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
addressType.AddStructuralProperty("City", new EdmStringTypeReference(stringType, /*isNullable*/false, /*isUnbounded*/false, /*maxLength*/30, /*isUnicode*/true));
model.AddElement(addressType);
var zipCodeType = new EdmComplexType("NS1", "ZipCode");
zipCodeType.AddStructuralProperty("Main", new EdmStringTypeReference(stringType, /*isNullable*/false, /*isUnbounded*/false, /*maxLength*/5, /*isUnicode*/false));
zipCodeType.AddStructuralProperty("Extended", new EdmStringTypeReference(stringType, /*isNullable*/true, /*isUnbounded*/false, /*maxLength*/5, /*isUnicode*/false));
model.AddElement(zipCodeType);
addressType.AddStructuralProperty("Zip", new EdmComplexTypeReference(zipCodeType, false));
var foreignAddressType = new EdmComplexType("NS1", "ForeignAddress", addressType, false);
foreignAddressType.AddStructuralProperty("State", EdmPrimitiveTypeKind.String);
model.AddElement(foreignAddressType);
var personType = new EdmEntityType("NS1", "Person", null, true, false);
personType.AddKeys(personType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false));
model.AddElement(personType);
var customerType = new EdmEntityType("NS1", "Customer", personType);
customerType.AddStructuralProperty("IsVIP", EdmPrimitiveTypeKind.Boolean);
customerType.AddProperty(new EdmStructuralProperty(customerType, "LastUpdated", EdmCoreModel.Instance.GetDateTimeOffset(false), null, EdmConcurrencyMode.Fixed));
customerType.AddStructuralProperty("BillingAddress", new EdmComplexTypeReference(addressType, false));
customerType.AddStructuralProperty("ShippingAddress", new EdmComplexTypeReference(addressType, false));
model.AddElement(customerType);
var orderType = new EdmEntityType("NS1", "Order");
orderType.AddKeys(orderType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false));
var customerIdProperty = orderType.AddStructuralProperty("CustomerId", EdmPrimitiveTypeKind.Int32, false);
model.AddElement(orderType);
var navProp1 = new EdmNavigationPropertyInfo { Name = "ToOrders", Target = orderType, TargetMultiplicity = EdmMultiplicity.Many, };
var navProp2 = new EdmNavigationPropertyInfo { Name = "ToCustomer", Target = customerType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { customerIdProperty }, PrincipalProperties = customerType.Key() };
customerType.AddBidirectionalNavigation(navProp1, navProp2);
var container = new EdmEntityContainer("NS1", "MyContainer");
container.AddEntitySet("PersonSet", personType);
container.AddEntitySet("OrderSet", orderType);
model.AddElement(container);
var function = new EdmFunction("NS1", "Function1", EdmCoreModel.Instance.GetInt64(true));
function.AddParameter("Param1", EdmCoreModel.Instance.GetInt32(true));
container.AddFunctionImport(function);
model.AddElement(function);
return model;
}
public static IEdmModel MultipleNamespacesEdm()
{
var model = new EdmModel();
var personType = new EdmEntityType("NS1", "Person");
personType.AddKeys(personType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
model.AddElement(personType);
var complexType1 = new EdmComplexType("NS3", "ComplexLevel1");
model.AddElement(complexType1);
var complexType2 = new EdmComplexType("NS2", "ComplexLevel2");
model.AddElement(complexType2);
var complexType3 = new EdmComplexType("NS2", "ComplexLevel3");
model.AddElement(complexType3);
complexType3.AddStructuralProperty("IntProperty", EdmPrimitiveTypeKind.Int32);
complexType2.AddStructuralProperty("ComplexProperty", new EdmComplexTypeReference(complexType3, false));
complexType1.AddStructuralProperty("ComplexProperty", new EdmComplexTypeReference(complexType2, false));
personType.AddStructuralProperty("ComplexProperty", new EdmComplexTypeReference(complexType1, false));
var customerType = new EdmEntityType("NS3", "Customer", personType);
model.AddElement(customerType);
var orderType = new EdmEntityType("NS2", "Order");
orderType.AddKeys(orderType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
model.AddElement(orderType);
var customerIdProperty = orderType.AddStructuralProperty("CustomerId", EdmPrimitiveTypeKind.Int32);
var navProp1 = new EdmNavigationPropertyInfo { Name = "ToOrders", Target = orderType, TargetMultiplicity = EdmMultiplicity.Many, };
var navProp2 = new EdmNavigationPropertyInfo { Name = "ToCustomer", Target = customerType, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { customerIdProperty }, PrincipalProperties = customerType.Key() };
customerType.AddBidirectionalNavigation(navProp1, navProp2);
return model;
}
public void TryGetPropertyType_ReturnsTrue_IfPropertyExists()
{
EdmComplexType edmType = new EdmComplexType("NS", "Complex");
edmType.AddStructuralProperty("Property", EdmPrimitiveTypeKind.Int32);
var edmObject = new TestEdmStructuredObject(edmType);
Type propertyType;
bool result = edmObject.TryGetPropertyType("Property", out propertyType);
Assert.True(result);
}
public void CreateODataComplexValue_Understands_IEdmComplexTypeObject()
{
// Arrange
EdmComplexType complexEdmType = new EdmComplexType("NS", "ComplexType");
complexEdmType.AddStructuralProperty("Property", EdmPrimitiveTypeKind.Int32);
IEdmComplexTypeReference edmTypeReference = new EdmComplexTypeReference(complexEdmType, isNullable: false);
ODataSerializerContext context = new ODataSerializerContext();
TypedEdmComplexObject edmObject = new TypedEdmComplexObject(new { Property = 42 }, edmTypeReference, context.Model);
ODataComplexTypeSerializer serializer = new ODataComplexTypeSerializer(new DefaultODataSerializerProvider());
// Act
ODataComplexValue result = serializer.CreateODataComplexValue(edmObject, edmTypeReference, context);
// Assert
Assert.Equal("Property", result.Properties.Single().Name);
Assert.Equal(42, result.Properties.Single().Value);
}
public static IEdmModel OneComplexWithNestedComplexEdm()
{
var model = new EdmModel();
var entityType = new EdmEntityType("NS1", "Person");
entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
model.AddElement(entityType);
var complexType1 = new EdmComplexType("NS1", "ComplexLevel1");
model.AddElement(complexType1);
var complexType2 = new EdmComplexType("NS1", "ComplexLevel2");
model.AddElement(complexType2);
var complexType3 = new EdmComplexType("NS1", "ComplexLevel3");
model.AddElement(complexType3);
complexType3.AddStructuralProperty("IntProperty", EdmPrimitiveTypeKind.Int32);
complexType2.AddStructuralProperty("ComplexProperty", new EdmComplexTypeReference(complexType3, false));
complexType1.AddStructuralProperty("ComplexProperty", new EdmComplexTypeReference(complexType2, false));
entityType.AddStructuralProperty("ComplexProperty", new EdmComplexTypeReference(complexType1, false));
return model;
}
