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);
}
private static void BuildCustomers(IEdmModel model)
{
IEdmEntityType customerType = model.SchemaElements.OfType<IEdmEntityType>().First(e => e.Name == "Customer");
IEdmEntityObject[] untypedCustomers = new IEdmEntityObject[6];
for (int i = 1; i <= 5; i++)
{
dynamic untypedCustomer = new EdmEntityObject(customerType);
untypedCustomer.ID = i;
untypedCustomer.Name = string.Format("Name {0}", i);
untypedCustomer.SSN = "SSN-" + i + "-" + (100 + i);
untypedCustomers[i-1] = untypedCustomer;
}
// create a special customer for "PATCH"
dynamic customer = new EdmEntityObject(customerType);
customer.ID = 6;
customer.Name = "Name 6";
customer.SSN = "SSN-6-T-006";
untypedCustomers[5] = customer;
IEdmCollectionTypeReference entityCollectionType =
new EdmCollectionTypeReference(
new EdmCollectionType(
new EdmEntityTypeReference(customerType, isNullable: false)));
Customers = new EdmEntityObjectCollection(entityCollectionType, untypedCustomers.ToList());
}
public void Init()
{
EdmModel model = new EdmModel();
EdmComplexType complex1 = new EdmComplexType("ns", "complex1");
complex1.AddProperty(new EdmStructuralProperty(complex1, "p1", EdmCoreModel.Instance.GetInt32(isNullable: false)));
model.AddElement(complex1);
EdmComplexType complex2 = new EdmComplexType("ns", "complex2");
complex2.AddProperty(new EdmStructuralProperty(complex2, "p1", EdmCoreModel.Instance.GetInt32(isNullable: false)));
model.AddElement(complex2);
EdmComplexTypeReference complex2Reference = new EdmComplexTypeReference(complex2, isNullable: false);
EdmCollectionType primitiveCollectionType = new EdmCollectionType(EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false));
EdmCollectionType complexCollectionType = new EdmCollectionType(complex2Reference);
EdmCollectionTypeReference primitiveCollectionTypeReference = new EdmCollectionTypeReference(primitiveCollectionType);
EdmCollectionTypeReference complexCollectionTypeReference = new EdmCollectionTypeReference(complexCollectionType);
model.AddElement(new EdmTerm("custom", "int", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false)));
model.AddElement(new EdmTerm("custom", "string", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, isNullable: false)));
model.AddElement(new EdmTerm("custom", "double", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Double, isNullable: false)));
model.AddElement(new EdmTerm("custom", "bool", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: true)));
model.AddElement(new EdmTerm("custom", "decimal", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Decimal, isNullable: false)));
model.AddElement(new EdmTerm("custom", "timespan", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Duration, isNullable: false)));
model.AddElement(new EdmTerm("custom", "guid", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Guid, isNullable: false)));
model.AddElement(new EdmTerm("custom", "complex", complex2Reference));
model.AddElement(new EdmTerm("custom", "primitiveCollection", primitiveCollectionTypeReference));
model.AddElement(new EdmTerm("custom", "complexCollection", complexCollectionTypeReference));
this.stream = new MemoryStream();
this.settings = new ODataMessageWriterSettings { Version = ODataVersion.V4, ShouldIncludeAnnotation = ODataUtils.CreateAnnotationFilter("*") };
this.settings.SetServiceDocumentUri(ServiceDocumentUri);
this.serializer = new ODataAtomPropertyAndValueSerializer(this.CreateAtomOutputContext(model, this.stream));
}
public void NonPrimitiveIsXXXMethods()
{
IEdmEntityType entityDef = new EdmEntityType("MyNamespace", "MyEntity");
IEdmEntityTypeReference entityRef = new EdmEntityTypeReference(entityDef, false);
Assert.IsTrue(entityRef.IsEntity(), "Entity is Entity");
IEdmPrimitiveTypeReference bad = entityRef.AsPrimitive();
Assert.IsTrue(bad.Definition.IsBad(), "bad TypeReference is bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, bad.Definition.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.IsTrue(bad.Definition.IsBad(), "Bad definition is bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, bad.Definition.Errors().First().ErrorCode, "Definition is bad from conversion");
IEdmPrimitiveType intDef = EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int32);
IEdmPrimitiveTypeReference intRef = new EdmPrimitiveTypeReference(intDef, false);
IEdmCollectionTypeReference intCollection = new EdmCollectionTypeReference(new EdmCollectionType(intRef));
Assert.IsTrue(intCollection.IsCollection(), "Collection is collection");
IEdmComplexType complexDef = new EdmComplexType("MyNamespace", "MyComplex");
IEdmComplexTypeReference complexRef = new EdmComplexTypeReference(complexDef, false);
Assert.IsTrue(complexRef.IsComplex(), "Complex is Complex");
Assert.IsTrue(entityRef.IsStructured(), "Entity is Structured");
Assert.IsTrue(complexRef.IsStructured(), "Complex is stuctured");
Assert.IsFalse(intCollection.IsStructured(), "Collection is not structured");
}
public void CollectionType_IsDeltaFeed_ReturnsFalseForNonDeltaCollectionType()
{
IEdmEntityType _entityType = new EdmEntityType("NS", "Entity");
EdmCollectionType _edmType = new EdmCollectionType(new EdmEntityTypeReference(_entityType, isNullable: true));
IEdmCollectionTypeReference _edmTypeReference = new EdmCollectionTypeReference(_edmType);
Assert.False(_edmTypeReference.Definition.IsDeltaFeed());
}
public void GetEdmType_Returns_EdmTypeInitializedByCtor()
{
IEdmTypeReference elementType = new EdmEntityTypeReference(new EdmEntityType("NS", "Entity"), isNullable: false);
IEdmCollectionTypeReference collectionType = new EdmCollectionTypeReference(new EdmCollectionType(elementType));
var edmObject = new EdmEntityObjectCollection(collectionType);
Assert.Same(collectionType, edmObject.GetEdmType());
}
public void Ctor_ThrowsArgument_UnexpectedElementType()
{
IEdmTypeReference elementType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: true);
IEdmCollectionTypeReference collectionType = new EdmCollectionTypeReference(new EdmCollectionType(elementType));
Assert.ThrowsArgument(() => new EdmEntityObjectCollection(collectionType), "edmType",
"The element type '[Edm.Int32 Nullable=True]' of the given collection type '[Collection([Edm.Int32 Nullable=True]) Nullable=True]' " +
"is not of the type 'IEdmEntityType'.");
}
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 void GetEdmType_Returns_EdmTypeInitializedByCtor()
{
// Arrange
IEdmTypeReference elementType = new EdmEnumTypeReference(new EdmEnumType("NS", "Enum"), isNullable: false);
IEdmCollectionTypeReference collectionType = new EdmCollectionTypeReference(new EdmCollectionType(elementType));
// Act
var edmObject = new EdmEnumObjectCollection(collectionType);
// Assert
Assert.Same(collectionType, edmObject.GetEdmType());
}
public ODataAtomAnnotationReaderTests()
{
this.model = new EdmModel();
this.model.AddElement(new EdmComplexType("foo", "complex"));
EdmComplexType complexType = new EdmComplexType("ns", "complex");
this.model.AddElement(complexType);
EdmComplexTypeReference complexTypeReference = new EdmComplexTypeReference(complexType, isNullable: false);
EdmCollectionType primitiveCollectionType = new EdmCollectionType(EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Guid, isNullable: false));
EdmCollectionType complexCollectionType = new EdmCollectionType(complexTypeReference);
EdmCollectionTypeReference primitiveCollectionTypeReference = new EdmCollectionTypeReference(primitiveCollectionType);
EdmCollectionTypeReference complexCollectionTypeReference = new EdmCollectionTypeReference(complexCollectionType);
this.model.AddElement(new EdmTerm("custom", "primitive", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Double, isNullable: false)));
this.model.AddElement(new EdmTerm("custom", "complex", complexTypeReference));
this.model.AddElement(new EdmTerm("custom", "primitiveCollection", primitiveCollectionTypeReference));
this.model.AddElement(new EdmTerm("custom", "complexCollection", complexCollectionTypeReference));
this.shouldIncludeAnnotation = (annotationName) => true;
}
private static IEdmActionImport AddUnboundAction(EdmEntityContainer container, string name, IEdmEntityType bindingType, bool isCollection)
{
var action = new EdmAction(
container.Namespace, name, returnType: null, isBound: true, entitySetPathExpression: null);
IEdmTypeReference bindingParamterType = new EdmEntityTypeReference(bindingType, isNullable: false);
if (isCollection)
{
bindingParamterType = new EdmCollectionTypeReference(new EdmCollectionType(bindingParamterType));
}
action.AddParameter("bindingParameter", bindingParamterType);
var actionImport = container.AddActionImport(action);
return actionImport;
}
static FullPayloadValidateTests()
{
EntityType = new EdmEntityType("Namespace", "EntityType", null, false, false, false);
EntityType.AddKeys(EntityType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
EntityType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(isNullable: true), null, EdmConcurrencyMode.Fixed);
DerivedType = new EdmEntityType("Namespace", "DerivedType", EntityType, false, true);
var expandedCollectionNavProp = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Target = EntityType,
TargetMultiplicity = EdmMultiplicity.Many,
Name = "ExpandedCollectionNavProp"
});
var expandedNavProp = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Target = EntityType,
TargetMultiplicity = EdmMultiplicity.One,
Name = "ExpandedNavProp"
});
EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Target = EntityType,
TargetMultiplicity = EdmMultiplicity.Many,
Name = "ContainedCollectionNavProp",
ContainsTarget = true
});
EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Target = EntityType,
TargetMultiplicity = EdmMultiplicity.One,
Name = "ContainedNavProp",
ContainsTarget = true
});
var container = new EdmEntityContainer("Namespace", "Container");
EntitySet = container.AddEntitySet("EntitySet", EntityType);
EntitySet.AddNavigationTarget(expandedNavProp, EntitySet);
EntitySet.AddNavigationTarget(expandedCollectionNavProp, EntitySet);
Model = new EdmModel();
Model.AddElement(EntityType);
Model.AddElement(DerivedType);
Model.AddElement(container);
ModelWithFunction = new EdmModel();
ModelWithFunction.AddElement(EntityType);
ModelWithFunction.AddElement(DerivedType);
ModelWithFunction.AddElement(container);
EdmEntityTypeReference entityTypeReference = new EdmEntityTypeReference(EntityType, false);
EdmCollectionTypeReference typeReference = new EdmCollectionTypeReference(new EdmCollectionType(entityTypeReference));
EdmFunction function = new EdmFunction("Namespace", "Function", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
function.AddParameter("bindingParameter", typeReference);
ModelWithFunction.AddElement(function);
EdmAction action = new EdmAction("Namespace", "Action", EdmCoreModel.Instance.GetBoolean(true), true, null);
action.AddParameter("bindingParameter", typeReference);
ModelWithFunction.AddElement(action);
}
IEdmTypeReference BuildTableValueType(string name, EdmModel model)
{
EdmEntityContainer container = model.EntityContainer as EdmEntityContainer;
string spRtvTypeName = string.Format("{0}_RtvCollectionType", name);
EdmComplexType t = null;
t = new EdmComplexType("ns", spRtvTypeName);
using (DbAccess db = new DbAccess(this.ConnectionString))
{
db.ExecuteReader(this.TableValuedResultSetCommand, (reader) =>
{
var et = Utility.DBType2EdmType(reader["DATA_TYPE"].ToString());
if (et.HasValue)
{
string col = reader["COLUMN_NAME"].ToString();
t.AddStructuralProperty(col, et.Value, true);
}
}, (par) => { par.AddWithValue("@Name", name); });
}
var etr = new EdmComplexTypeReference(t, true);
var t1 = new EdmCollectionTypeReference(new EdmCollectionType(etr));
model.AddElement((t1.Definition as EdmCollectionType).ElementType.Definition as IEdmSchemaElement);
return t1;
}
public void Term_Definition_Collection()
{
this.SetupModels();
var definitionModel = new EdmModel();
var collectionOfInt16 = new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt16(false /*isNullable*/)));
var valueTermInt16 = new EdmTerm("NS2", "CollectionOfInt16", collectionOfInt16);
definitionModel.AddElement(valueTermInt16);
var collectionOfPerson = new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(this.baseModel.FindEntityType("NS1.Person"), true)));
var valueTermPerson = new EdmTerm("NS2", "CollectionOfPerson", collectionOfPerson);
definitionModel.AddElement(valueTermPerson);
string expectedCsdl =
@"<Schema Namespace=""NS2"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<Term Name=""CollectionOfInt16"" Type=""Collection(Edm.Int16)"" Nullable=""false"" />
<Term Name=""CollectionOfPerson"" Type=""Collection(NS1.Person)"" />
</Schema>";
this.SerializeAndVerifyAgainst(definitionModel, expectedCsdl);
}
private static object ConvertCollectionValue(ODataCollectionValue collection,
ref IEdmTypeReference propertyType, ODataDeserializerProvider deserializerProvider,
ODataDeserializerContext readContext)
{
IEdmCollectionTypeReference collectionType;
if (propertyType == null)
{
// dynamic collection property
Contract.Assert(!String.IsNullOrEmpty(collection.TypeName),
"ODataLib should have verified that dynamic collection value has a type name " +
"since we provided metadata.");
string elementTypeName = GetCollectionElementTypeName(collection.TypeName, isNested: false);
IEdmModel model = readContext.Model;
IEdmSchemaType elementType = model.FindType(elementTypeName);
Contract.Assert(elementType != null);
collectionType =
new EdmCollectionTypeReference(
new EdmCollectionType(elementType.ToEdmTypeReference(isNullable: false)));
propertyType = collectionType;
}
else
{
collectionType = propertyType as IEdmCollectionTypeReference;
Contract.Assert(collectionType != null, "The type for collection must be a IEdmCollectionType.");
}
ODataEdmTypeDeserializer deserializer = deserializerProvider.GetEdmTypeDeserializer(collectionType);
return deserializer.ReadInline(collection, collectionType, readContext);
}
private static void BuildPeople(IEdmModel model)
{
IEdmEntityType personType = model.SchemaElements.OfType<IEdmEntityType>().First(e => e.Name == "Person");
IEdmEntityObject[] untypedPeople = new IEdmEntityObject[5];
for (int i = 0; i < 5; i++)
{
dynamic untypedPerson = new EdmEntityObject(personType);
untypedPerson.ID = i;
untypedPerson.Country = new[] { "Great Britain", "China", "United States", "Russia", "Japan" }[i];
untypedPerson.Passport = new[] { "1001", "2010", "9999", "3199992", "00001"}[i];
untypedPeople[i] = untypedPerson;
}
IEdmCollectionTypeReference entityCollectionType =
new EdmCollectionTypeReference(
new EdmCollectionType(
new EdmEntityTypeReference(personType, isNullable: false)));
People = new EdmEntityObjectCollection(entityCollectionType, untypedPeople.ToList());
}
public IHttpActionResult Get()
{
IEdmEntityObject[] untypedCustomers = new EdmEntityObject[20];
for (int i = 0; i < 20; i++)
{
dynamic untypedCustomer = new EdmEntityObject(CustomerType);
untypedCustomer.Id = i;
untypedCustomer.Name = string.Format("Name {0}", i);
untypedCustomer.Orders = CreateOrders(i);
untypedCustomer.Addresses = CreateAddresses(i);
untypedCustomer.FavoriteNumbers = Enumerable.Range(0, i).ToArray();
untypedCustomers[i] = untypedCustomer;
}
IEdmCollectionTypeReference entityCollectionType =
new EdmCollectionTypeReference(
new EdmCollectionType(
new EdmEntityTypeReference(CustomerType, isNullable: false)));
return Ok(new EdmEntityObjectCollection(entityCollectionType, untypedCustomers.ToList()));
}
public void GetPropertyInitializationValueShouldReturnConstructorWithDataServiceCollectionConstructorParameters()
{
EdmEntityType entityType = new EdmEntityType("Namespace", "elementName");
IEdmTypeReference elementTypeReference = new EdmTypeReferenceForTest(entityType, false);
IEdmCollectionType collectionType = new EdmCollectionType(elementTypeReference);
IEdmCollectionTypeReference collectionTypeReference = new EdmCollectionTypeReference(collectionType);
EdmPropertyForTest property = new EdmPropertyForTest(new EdmStructruedTypeForTest(), "propertyName", collectionTypeReference);
ODataT4CodeGenerator.Utils.GetPropertyInitializationValue(property, true, template, context).Should().Be("new global::Microsoft.OData.Client.DataServiceCollection<global::NamespacePrefix.elementName>(null, global::Microsoft.OData.Client.TrackingMode.None)");
}
public void ApplyNavigationProperty_Calls_ReadInlineOnFeed()
{
// Arrange
IEdmCollectionTypeReference productsType = new EdmCollectionTypeReference(new EdmCollectionType(_productEdmType));
Mock<ODataEdmTypeDeserializer> productsDeserializer = new Mock<ODataEdmTypeDeserializer>(ODataPayloadKind.Feed);
Mock<ODataDeserializerProvider> deserializerProvider = new Mock<ODataDeserializerProvider>();
var deserializer = new ODataEntityDeserializer(deserializerProvider.Object);
ODataNavigationLinkWithItems navigationLink = new ODataNavigationLinkWithItems(new ODataNavigationLink { Name = "Products" });
navigationLink.NestedItems.Add(new ODataFeedWithEntries(new ODataFeed()));
Supplier supplier = new Supplier();
IEnumerable products = new[] { new Product { ID = 42 } };
deserializerProvider.Setup(d => d.GetEdmTypeDeserializer(It.IsAny<IEdmTypeReference>())).Returns(productsDeserializer.Object);
productsDeserializer
.Setup(d => d.ReadInline(navigationLink.NestedItems[0], _supplierEdmType.FindNavigationProperty("Products").Type, _readContext))
.Returns(products).Verifiable();
// Act
deserializer.ApplyNavigationProperty(supplier, navigationLink, _supplierEdmType, _readContext);
// Assert
productsDeserializer.Verify();
Assert.Equal(1, supplier.Products.Count());
Assert.Equal(42, supplier.Products.First().ID);
}
public void CreateODataFeed_SetsNextPageLink_WhenWritingTruncatedCollection_ForExpandedProperties()
{
// Arrange
CustomersModelWithInheritance model = new CustomersModelWithInheritance();
IEdmCollectionTypeReference customersType = new EdmCollectionTypeReference(new EdmCollectionType(model.Customer.AsReference()));
ODataFeedSerializer serializer = new ODataFeedSerializer(new DefaultODataSerializerProvider());
SelectExpandClause selectExpandClause = new SelectExpandClause(new SelectItem[0], allSelected: true);
IEdmNavigationProperty ordersProperty = model.Customer.NavigationProperties().First();
EntityInstanceContext entity = new EntityInstanceContext
{
SerializerContext = new ODataSerializerContext { NavigationSource = model.Customers, Model = model.Model }
};
ODataSerializerContext nestedContext = new ODataSerializerContext(entity, selectExpandClause, ordersProperty);
TruncatedCollection<Order> orders = new TruncatedCollection<Order>(new[] { new Order(), new Order() }, pageSize: 1);
Mock<NavigationSourceLinkBuilderAnnotation> linkBuilder = new Mock<NavigationSourceLinkBuilderAnnotation>();
linkBuilder.Setup(l => l.BuildNavigationLink(entity, ordersProperty, ODataMetadataLevel.Default)).Returns(new Uri("http://navigation-link/"));
model.Model.SetNavigationSourceLinkBuilder(model.Customers, linkBuilder.Object);
model.Model.SetNavigationSourceLinkBuilder(model.Orders, new NavigationSourceLinkBuilderAnnotation());
// Act
ODataFeed feed = serializer.CreateODataFeed(orders, _customersType, nestedContext);
// Assert
Assert.Equal("http://navigation-link/?$skip=1", feed.NextPageLink.AbsoluteUri);
}
private static IEdmModel GetModelWithFunctions()
{
CustomersModelWithInheritance model = new CustomersModelWithInheritance();
var container = model.Container;
IEdmTypeReference boolType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmTypeReference customerType = model.Customer.AsReference();
IEdmTypeReference addressType = new EdmComplexTypeReference(model.Address, isNullable: false);
IEdmTypeReference customersType = new EdmCollectionTypeReference(new EdmCollectionType(customerType));
AddFunction(model, "unBoundWithoutParams");
var unBoundWithOneParam = AddFunction(model, "unBoundWithOneParam");
unBoundWithOneParam.AddParameter("Param", boolType);
var unBoundWithMultipleParams = AddFunction(model, "unBoundWithMultipleParams");
unBoundWithMultipleParams.AddParameter("Param1", boolType);
unBoundWithMultipleParams.AddParameter("Param2", boolType);
unBoundWithMultipleParams.AddParameter("Param3", boolType);
AddFunction(model, "BoundToEntityNoParams", bindingParameterType: customerType);
var boundToEntity = AddFunction(model, "BoundToEntity", bindingParameterType: customerType);
boundToEntity.AddParameter("Param", boolType);
AddFunction(model, "BoundToEntityReturnsEntityNoParams",
returnType: customerType, entitySet: model.Customers, bindingParameterType: customerType);
AddFunction(model, "BoundToEntityReturnsEntityCollectionNoParams",
returnType: customersType, entitySet: model.Customers, bindingParameterType: customerType);
AddFunction(model, "BoundToEntityCollection", bindingParameterType: customersType);
AddFunction(model, "BoundToEntityCollectionReturnsComplex", bindingParameterType: customersType, returnType: addressType);
return model.Model;
}
public void NonPrimitiveAsXXXMethods()
{
IEdmPrimitiveType intDef = EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int32);
IEdmPrimitiveTypeReference intRef = new EdmPrimitiveTypeReference(intDef, false);
IEdmEntityType entityDef = new EdmEntityType("MyNamespace", "MyEntity");
IEdmEntityTypeReference entityRef = new EdmEntityTypeReference(entityDef, false);
IEdmComplexType complexDef = new EdmComplexType("MyNamespace", "MyComplex");
IEdmComplexTypeReference complexRef = new EdmComplexTypeReference(complexDef, false);
IEdmCollectionType collectionDef = new EdmCollectionType(intRef);
IEdmCollectionTypeReference collectionRef = new EdmCollectionTypeReference(collectionDef);
IEdmCollectionTypeReference badCollectionRef = entityRef.AsCollection();
IEdmEntityTypeReference badEntityRef = collectionRef.AsEntity();
IEdmComplexTypeReference badComplexRef = entityRef.AsComplex();
IEdmEntityReferenceTypeReference badEntityRefRef= entityRef.AsEntityReference();
Assert.IsTrue(badCollectionRef.IsBad(), "Bad Collection is bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badCollectionRef.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.AreEqual("[Collection([UnknownType Nullable=True]) Nullable=True]", badCollectionRef.ToString(), "Correct tostring");
Assert.IsTrue(badComplexRef.IsBad(), "Bad Complex is Bad");
Assert.IsTrue(badComplexRef.Definition.IsBad(), "Bad Complex definition is Bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badComplexRef.Definition.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.AreEqual("TypeSemanticsCouldNotConvertTypeReference:[MyNamespace.MyEntity Nullable=False]", badComplexRef.ToString(), "Correct tostring");
Assert.IsTrue(badEntityRef.IsBad(), "Bad Entity is bad");
Assert.IsTrue(badEntityRef.Definition.IsBad(), "Bad Entity Definition is bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badEntityRef.Definition.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.AreEqual("TypeSemanticsCouldNotConvertTypeReference:[Collection(Edm.Int32) Nullable=False]", badEntityRef.ToString(), "Correct tostring");
Assert.IsTrue(badEntityRefRef.IsBad(), "Bad Entity Reference is Bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badEntityRefRef.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.AreEqual("[EntityReference(.) Nullable=False]", badEntityRefRef.ToString(), "Correct tostring");
Assert.IsFalse(entityRef.AsEntity().IsBad(), "Entity converted to Entity is good");
Assert.IsFalse(complexRef.AsComplex().IsBad(), "Complex converted to complex is good");
Assert.IsFalse(collectionRef.AsCollection().IsBad(), "Collection converted to collection is good");
Assert.IsTrue(entityRef.AsStructured().IsEntity(), "Entity as structured is entity");
Assert.IsFalse(entityRef.AsStructured().IsBad(), "Entity as structured is good");
Assert.IsTrue(complexRef.AsStructured().IsComplex(), "Complex as structured is complex");
Assert.IsFalse(complexRef.AsStructured().IsBad(), "Complex as structured is good");
Assert.IsFalse(collectionRef.AsStructured().IsCollection(), "Collection as structured is not collection");
Assert.IsTrue(collectionRef.AsStructured().IsBad(), "Collection as structured is bad");
Assert.IsTrue(collectionRef.AsStructured().Definition.IsBad(), "Collection as structured definition is bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, collectionRef.AsStructured().Definition.Errors().First().ErrorCode, "Reference is bad from conversion");
}
private static IEdmAction AddBindableAction(EdmModel model, string name, IEdmEntityType bindingType, bool isCollection)
{
IEdmEntityContainer container = model.EntityContainer;
var action = new EdmAction(
container.Namespace, name, returnType: null, isBound: true, entitySetPathExpression: null);
IEdmTypeReference bindingParamterType = new EdmEntityTypeReference(bindingType, isNullable: false);
if (isCollection)
{
bindingParamterType = new EdmCollectionTypeReference(new EdmCollectionType(bindingParamterType));
}
action.AddParameter("bindingParameter", bindingParamterType);
model.AddElement(action);
return action;
}
private static void BuildOrderss(IEdmModel model)
{
IEdmEntityType orderType = model.SchemaElements.OfType<IEdmEntityType>().First(e => e.Name == "Order");
Guid[] guids =
{
new Guid("196B3584-EF3D-41FD-90B4-76D59F9B929C"),
new Guid("6CED5600-28BA-40EE-A2DF-E80AFADBE6C7"),
new Guid("75036B94-C836-4946-8CC8-054CF54060EC"),
new Guid("B3FF5460-6E77-4678-B959-DCC1C4937FA7"),
new Guid("ED773C85-4E3C-4FC4-A3E9-9F1DA0A626DA")
};
IEdmEntityObject[] untypedOrders = new IEdmEntityObject[5];
for (int i = 0; i < 5; i++)
{
dynamic untypedOrder = new EdmEntityObject(orderType);
untypedOrder.OrderId = i;
untypedOrder.Name = string.Format("Order-{0}", i);
untypedOrder.Token = guids[i];
untypedOrder.Amount = 10 + i;
untypedOrders[i] = untypedOrder;
}
IEdmCollectionTypeReference entityCollectionType =
new EdmCollectionTypeReference(
new EdmCollectionType(
new EdmEntityTypeReference(orderType, isNullable: false)));
Orders = new EdmEntityObjectCollection(entityCollectionType, untypedOrders.ToList());
}
public void CanParse_BoundFunction_AtEntityCollection()
{
// Arrange
var model = new CustomersModelWithInheritance();
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmExpression entitySet = new EdmEntitySetReferenceExpression(model.Customers);
var function = new EdmFunction(
model.Container.Namespace,
"Count",
returnType,
isBound: true,
entitySetPathExpression: null,
isComposable: true);
IEdmTypeReference bindingParameterType = new EdmCollectionTypeReference(
new EdmCollectionType(new EdmEntityTypeReference(model.Customer, isNullable: false)));
function.AddParameter("customers", bindingParameterType);
model.Model.AddElement(function);
// Act
ODataPath path = _parser.Parse(model.Model, "Customers/NS.Count");
// Assert
Assert.NotNull(path);
Assert.Equal(2, path.Segments.Count);
var functionSegment = Assert.IsType<BoundFunctionPathSegment>(path.Segments.Last());
Assert.Same(function, functionSegment.Function);
Assert.Empty(functionSegment.Values);
}
public void ValidateEntitySetPathTypeCastColNavPropertyTypeCastNavPropertyReturnsNoErrors()
{
ValidationRulesTests.OperationOperationEntitySetPathMustBeValidValidTestModel testModelContainer = new ValidationRulesTests.OperationOperationEntitySetPathMustBeValidValidTestModel();
var returnType = new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(testModelContainer.T3, false)));
EdmFunction function = new EdmFunction("ns", "GetStuff", returnType, true /*isBound*/, new EdmPathExpression("bindingEntity/Bunk.T1/ColP101"), false);
function.AddParameter("bindingEntity", new EdmEntityTypeReference(testModelContainer.T2, false));
ValidateNoError(testModelContainer.Model, function);
}
public void WriteObjectInline_Can_WriteCollectionOfIEdmObjects()
{
// Arrange
IEdmTypeReference edmType = new EdmEntityTypeReference(new EdmEntityType("NS", "Name"), isNullable: false);
IEdmCollectionTypeReference feedType = new EdmCollectionTypeReference(new EdmCollectionType(edmType));
Mock<IEdmObject> edmObject = new Mock<IEdmObject>();
edmObject.Setup(e => e.GetEdmType()).Returns(edmType);
var mockWriter = new Mock<ODataWriter>();
Mock<ODataEdmTypeSerializer> customSerializer = new Mock<ODataEdmTypeSerializer>(ODataPayloadKind.Entry);
customSerializer.Setup(s => s.WriteObjectInline(edmObject.Object, edmType, mockWriter.Object, _writeContext)).Verifiable();
Mock<ODataSerializerProvider> serializerProvider = new Mock<ODataSerializerProvider>();
serializerProvider.Setup(s => s.GetEdmTypeSerializer(edmType)).Returns(customSerializer.Object);
ODataFeedSerializer serializer = new ODataFeedSerializer(serializerProvider.Object);
// Act
serializer.WriteObjectInline(new[] { edmObject.Object }, feedType, mockWriter.Object, _writeContext);
// Assert
customSerializer.Verify();
}
private static IEdmModel GetUnTypedEdmModel()
{
EdmModel model = new EdmModel();
// Enum type "Color"
EdmEnumType colorEnum = new EdmEnumType("NS", "Color");
colorEnum.AddMember(new EdmEnumMember(colorEnum, "Red", new EdmIntegerConstant(0)));
colorEnum.AddMember(new EdmEnumMember(colorEnum, "Blue", new EdmIntegerConstant(1)));
colorEnum.AddMember(new EdmEnumMember(colorEnum, "Green", new EdmIntegerConstant(2)));
model.AddElement(colorEnum);
// complex type "Address"
EdmComplexType address = new EdmComplexType("NS", "Address");
address.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
address.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
model.AddElement(address);
// derived complex type "SubAddress"
EdmComplexType subAddress = new EdmComplexType("NS", "SubAddress", address);
subAddress.AddStructuralProperty("Code", EdmPrimitiveTypeKind.Double);
model.AddElement(subAddress);
// entity type "Customer"
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
customer.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
customer.AddStructuralProperty("Location", new EdmComplexTypeReference(address, isNullable: true));
model.AddElement(customer);
// derived entity type special customer
EdmEntityType specialCustomer = new EdmEntityType("NS", "SpecialCustomer", customer);
specialCustomer.AddStructuralProperty("Title", EdmPrimitiveTypeKind.Guid);
model.AddElement(specialCustomer);
// entity sets
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
model.AddElement(container);
container.AddEntitySet("FCustomers", customer);
EdmComplexTypeReference complexType = new EdmComplexTypeReference(address, isNullable: false);
EdmCollectionTypeReference complexCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(complexType));
EdmEnumTypeReference enumType = new EdmEnumTypeReference(colorEnum, isNullable: false);
EdmCollectionTypeReference enumCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(enumType));
EdmEntityTypeReference entityType = new EdmEntityTypeReference(customer, isNullable: false);
EdmCollectionTypeReference entityCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(entityType));
IEdmTypeReference intType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: true);
EdmCollectionTypeReference primitiveCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(intType));
// bound functions
BoundFunction(model, "IntCollectionFunction", "intValues", primitiveCollectionType, entityType);
BoundFunction(model, "ComplexFunction", "address", complexType, entityType);
BoundFunction(model, "ComplexCollectionFunction", "addresses", complexCollectionType, entityType);
BoundFunction(model, "EnumFunction", "color", enumType, entityType);
BoundFunction(model, "EnumCollectionFunction", "colors", enumCollectionType, entityType);
BoundFunction(model, "EntityFunction", "customer", entityType, entityType);
BoundFunction(model, "CollectionEntityFunction", "customers", entityCollectionType, entityType);
// unbound functions
UnboundFunction(container, "UnboundIntCollectionFunction", "intValues", primitiveCollectionType);
UnboundFunction(container, "UnboundComplexFunction", "address", complexType);
UnboundFunction(container, "UnboundComplexCollectionFunction", "addresses", complexCollectionType);
UnboundFunction(container, "UnboundEnumFunction", "color", enumType);
UnboundFunction(container, "UnboundEnumCollectionFunction", "colors", enumCollectionType);
UnboundFunction(container, "UnboundEntityFunction", "customer", entityType);
UnboundFunction(container, "UnboundCollectionEntityFunction", "customers", entityCollectionType);
model.SetAnnotationValue<BindableProcedureFinder>(model, new BindableProcedureFinder(model));
return model;
}
public void GetDefaultValue_NonNullableEntityCollection()
{
IEdmTypeReference elementType = new EdmEntityTypeReference(new EdmEntityType("NS", "Entity"), isNullable: true);
IEdmCollectionTypeReference entityCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(elementType));
var result = EdmStructuredObject.GetDefaultValue(entityCollectionType);
var entityCollectionObject = Assert.IsType<EdmEntityObjectCollection>(result);
Assert.Equal(entityCollectionType, entityCollectionObject.GetEdmType(), new EdmTypeReferenceEqualityComparer());
}
private static void BuildCompanies(IEdmModel model)
{
IEdmEntityType companyType = model.SchemaElements.OfType<IEdmEntityType>().First(e => e.Name == "Company");
IList<IEdmComplexObject> addresses = BuildAddrsses(model);
IEdmEntityObject[] untypedCompanies = new IEdmEntityObject[5];
for (int i = 0; i < 5; i++)
{
dynamic untypedCompany = new EdmEntityObject(companyType);
untypedCompany.ID = i;
untypedCompany.Location = addresses[i];
untypedCompanies[i] = untypedCompany;
}
IEdmCollectionTypeReference entityCollectionType =
new EdmCollectionTypeReference(
new EdmCollectionType(
new EdmEntityTypeReference(companyType, isNullable: false)));
Companies = new EdmEntityObjectCollection(entityCollectionType, untypedCompanies.ToList());
}