public ODataComplexTypeSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_address = new Address()
{
Street = "One Microsoft Way",
City = "Redmond",
State = "Washington",
Country = "United States",
ZipCode = "98052"
};
_addressType = _model.FindDeclaredType("Default.Address") as IEdmComplexType;
_model.SetAnnotationValue(_addressType, new ClrTypeAnnotation(typeof(Address)));
_addressTypeRef = _addressType.ToEdmTypeReference(isNullable: false).AsComplex();
var cnAddressType = _model.FindDeclaredType("Default.CnAddress") as IEdmComplexType;
_model.SetAnnotationValue(cnAddressType, new ClrTypeAnnotation(typeof(CnAddress)));
var usAddressType = _model.FindDeclaredType("Default.UsAddress") as IEdmComplexType;
_model.SetAnnotationValue(usAddressType, new ClrTypeAnnotation(typeof(UsAddress)));
_locationType = _model.FindDeclaredType("Default.Location") as IEdmComplexType;
_model.SetAnnotationValue(_locationType, new ClrTypeAnnotation(typeof(Location)));
_locationTypeRef = _locationType.ToEdmTypeReference(isNullable: false).AsComplex();
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
_serializer = new ODataComplexTypeSerializer(serializerProvider);
TimeZoneInfoHelper.TimeZone = null;
}
public void CanSerializerSingleton()
{
// Arrange
const string expect = "{" +
"\"@odata.context\":\"http://localhost/odata/$metadata#Boss\"," +
"\"@odata.id\":\"http://localhost/odata/Boss\"," +
"\"@odata.editLink\":\"http://localhost/odata/Boss\"," +
"\"EmployeeId\":987,\"EmployeeName\":\"John Mountain\"}";
IEdmModel model = GetEdmModel();
IEdmSingleton singleton = model.EntityContainer.FindSingleton("Boss");
HttpRequestMessage request = GetRequest(model, singleton);
ODataSerializerContext readContext = new ODataSerializerContext()
{
Url = new UrlHelper(request),
Path = request.ODataProperties().Path,
Model = model,
NavigationSource = singleton
};
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
EmployeeModel boss = new EmployeeModel {EmployeeId = 987, EmployeeName = "John Mountain"};
MemoryStream bufferedStream = new MemoryStream();
// Act
ODataEntityTypeSerializer serializer = new ODataEntityTypeSerializer(serializerProvider);
serializer.WriteObject(boss, typeof(EmployeeModel), GetODataMessageWriter(model, bufferedStream), readContext);
// Assert
string result = Encoding.UTF8.GetString(bufferedStream.ToArray());
Assert.Equal(expect, result);
}
public ODataComplexTypeSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_address = new Address()
{
Street = "One Microsoft Way",
City = "Redmond",
State = "Washington",
Country = "United States",
ZipCode = "98052"
};
_addressType = _model.FindDeclaredType("Default.Address") as IEdmComplexType;
_model.SetAnnotationValue(_addressType, new ClrTypeAnnotation(typeof(Address)));
_addressTypeRef = _addressType.ToEdmTypeReference(isNullable: false).AsComplex();
var cnAddressType = _model.FindDeclaredType("Default.CnAddress") as IEdmComplexType;
_model.SetAnnotationValue(cnAddressType, new ClrTypeAnnotation(typeof(CnAddress)));
var usAddressType = _model.FindDeclaredType("Default.UsAddress") as IEdmComplexType;
_model.SetAnnotationValue(usAddressType, new ClrTypeAnnotation(typeof(UsAddress)));
_locationType = _model.FindDeclaredType("Default.Location") as IEdmComplexType;
_model.SetAnnotationValue(_locationType, new ClrTypeAnnotation(typeof(Location)));
_locationTypeRef = _locationType.ToEdmTypeReference(isNullable: false).AsComplex();
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
_serializer = new ODataComplexTypeSerializer(serializerProvider);
TimeZoneInfoHelper.TimeZone = null;
}
public void Property_Instance_IsCached()
{
DefaultODataSerializerProvider instance1 = DefaultODataSerializerProvider.Instance;
DefaultODataSerializerProvider instance2 = DefaultODataSerializerProvider.Instance;
Assert.Same(instance1, instance2);
}
public void GetEdmTypeSerializer_ThrowsArgumentNull_EdmType()
{
DefaultODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
Assert.ThrowsArgumentNull(
() => serializerProvider.GetEdmTypeSerializer(edmType: null),
"edmType");
}
public void Ctor_SetsProperty_SerializerProvider()
{
IEdmTypeReference edmType = new Mock<IEdmTypeReference>().Object;
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
var serializer = new Mock<ODataEdmTypeSerializer>(ODataPayloadKind.Unsupported, serializerProvider).Object;
Assert.Same(serializerProvider, serializer.SerializerProvider);
}
public void Ctor_SetsProperty_SerializerProvider()
{
IEdmTypeReference edmType = new Mock <IEdmTypeReference>().Object;
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
var serializer = new Mock <ODataEdmTypeSerializer>(ODataPayloadKind.Unsupported, serializerProvider).Object;
Assert.Same(serializerProvider, serializer.SerializerProvider);
}
public void GetODataPayloadSerializer_ThrowsArgumentNull_Model()
{
DefaultODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
Assert.ThrowsArgumentNull(
() => serializerProvider.GetODataPayloadSerializer(model: null, type: typeof(int), request: request),
"model");
}
public void GetODataPayloadSerializer_ThrowsArgumentNull_Type()
{
DefaultODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
Assert.ThrowsArgumentNull(
() => serializerProvider.GetODataPayloadSerializer(model: EdmCoreModel.Instance, type: null, request: request),
"type");
}
public void GetODataPayloadSerializer_ThrowsArgumentNull_Request()
{
DefaultODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
Assert.ThrowsArgumentNull(
() => serializerProvider.GetODataPayloadSerializer(EdmCoreModel.Instance, typeof(int), request: null),
"request");
}
public void GetODataPayloadSerializer_ThrowsArgumentNull_Request()
{
DefaultODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
Assert.ThrowsArgumentNull(
() => serializerProvider.GetODataPayloadSerializer(EdmCoreModel.Instance, typeof(int), request: null),
"request");
}
public void GetODataPayloadSerializer_ThrowsArgumentNull_Type()
{
DefaultODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
Assert.ThrowsArgumentNull(
() => serializerProvider.GetODataPayloadSerializer(model: EdmCoreModel.Instance, type: null, request: request),
"type");
}
public void GetODataPayloadSerializer_ThrowsArgumentNull_Model()
{
DefaultODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
Assert.ThrowsArgumentNull(
() => serializerProvider.GetODataPayloadSerializer(model: null, type: typeof(int), request: request),
"model");
}
public void GetODataSerializer_Primitive(Type type, EdmPrimitiveTypeKind edmPrimitiveTypeKind)
{
var serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
var serializer = serializerProvider.GetODataPayloadSerializer(_edmModel, type, request);
Assert.NotNull(serializer);
var primitiveSerializer = Assert.IsType<ODataPrimitiveSerializer>(serializer);
Assert.Equal(primitiveSerializer.ODataPayloadKind, ODataPayloadKind.Property);
}
public void GetODataSerializer_Returns_ExpectedSerializerType(Type payloadType, Type expectedSerializerType)
{
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
ODataSerializer serializer = serializerProvider.GetODataPayloadSerializer(_edmModel, payloadType, request);
Assert.NotNull(serializer);
Assert.IsType(expectedSerializerType, serializer);
}
public void GetODataSerializer_Primitive(Type type, EdmPrimitiveTypeKind edmPrimitiveTypeKind)
{
var serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
var serializer = serializerProvider.GetODataPayloadSerializer(_edmModel, type, request);
Assert.NotNull(serializer);
var primitiveSerializer = Assert.IsType <ODataPrimitiveSerializer>(serializer);
Assert.Equal(primitiveSerializer.ODataPayloadKind, ODataPayloadKind.Property);
}
public void GetODataSerializer_Enum()
{
var serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
var serializer = serializerProvider.GetODataPayloadSerializer(GetEnumModel(), typeof(TestEnum), request);
Assert.NotNull(serializer);
var enumSerializer = Assert.IsType <ODataEnumSerializer>(serializer);
Assert.Equal(ODataPayloadKind.Property, enumSerializer.ODataPayloadKind);
}
public void GetODataPayloadSerializer_ReturnsRawValueSerializer_ForValueRequests(Type type, EdmPrimitiveTypeKind edmPrimitiveTypeKind)
{
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
request.ODataProperties().Path = new ODataPath(new ValuePathSegment());
var serializer = serializerProvider.GetODataPayloadSerializer(_edmModel, type, request);
Assert.NotNull(serializer);
Assert.Equal(ODataPayloadKind.Value, serializer.ODataPayloadKind);
}
public void GetODataSerializer_Complex()
{
var serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
var serializer = serializerProvider.GetODataPayloadSerializer(_edmModel, typeof(ODataEntityDeserializerTests.Address), request);
Assert.NotNull(serializer);
var complexSerializer = Assert.IsType <ODataComplexTypeSerializer>(serializer);
Assert.Equal(complexSerializer.SerializerProvider, serializerProvider);
Assert.Equal(complexSerializer.ODataPayloadKind, ODataPayloadKind.Property);
}
public void GetODataSerializer_Feed(Type collectionType)
{
var serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
var serializer = serializerProvider.GetODataPayloadSerializer(_edmModel, collectionType, request);
Assert.NotNull(serializer);
var feedSerializer = Assert.IsType <ODataFeedSerializer>(serializer);
Assert.Equal(feedSerializer.ODataPayloadKind, ODataPayloadKind.Feed);
}
public void GetEdmTypeSerializer_ReturnODataEnumSerializer_ForEnumType()
{
// Arrange
IEdmTypeReference edmType = new EdmEnumTypeReference(new EdmEnumType("TestModel", "Color"), isNullable: false);
// Act
ODataEdmTypeSerializer serializer = new DefaultODataSerializerProvider().GetEdmTypeSerializer(edmType);
// Assert
Assert.NotNull(serializer);
Assert.IsType<ODataEnumSerializer>(serializer);
}
public void GetODataSerializer_ReturnsSameSerializer_ForSameType()
{
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
ODataSerializer firstCallSerializer = serializerProvider.GetODataPayloadSerializer(_edmModel,
typeof(ODataEntityDeserializerTests.Supplier), request);
ODataSerializer secondCallSerializer = serializerProvider.GetODataPayloadSerializer(_edmModel,
typeof(ODataEntityDeserializerTests.Supplier), request);
Assert.Same(firstCallSerializer, secondCallSerializer);
}
public void GetODataSerializer_Entity()
{
var serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
var serializer = serializerProvider.GetODataPayloadSerializer(_edmModel, typeof(ODataEntityDeserializerTests.Product), request);
Assert.NotNull(serializer);
var entitySerializer = Assert.IsType <ODataEntityTypeSerializer>(serializer);
Assert.Equal(entitySerializer.SerializerProvider, serializerProvider);
Assert.Equal(entitySerializer.ODataPayloadKind, ODataPayloadKind.Entry);
}
public void GetEdmTypeSerializer_Caches_CreateEdmTypeSerializerOutput()
{
// Arrange
DefaultODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
IEdmTypeReference edmType = new Mock <IEdmTypeReference>().Object;
// Act
var serializer1 = serializerProvider.GetEdmTypeSerializer(edmType);
var serializer2 = serializerProvider.GetEdmTypeSerializer(edmType);
// Assert
Assert.Same(serializer2, serializer1);
}
public void GetODataSerializer_ComplexCollection()
{
var serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
var serializer = serializerProvider.GetODataPayloadSerializer(_edmModel,
typeof(IEnumerable <ODataEntityDeserializerTests.Address>), request);
Assert.NotNull(serializer);
var collectionSerializer = Assert.IsType <ODataCollectionSerializer>(serializer);
Assert.Equal(collectionSerializer.ODataPayloadKind, ODataPayloadKind.Collection);
Assert.Equal(collectionSerializer.SerializerProvider, serializerProvider);
}
public void GetODataPayloadSerializer_ReturnsRawValueSerializer_ForEnumValueRequests()
{
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
request.ODataProperties().Path = new ODataPath(new ValuePathSegment());
var serializer = serializerProvider.GetODataPayloadSerializer(GetEnumModel(), typeof(TestEnum), request);
Assert.NotNull(serializer);
var rawValueSerializer = Assert.IsType <ODataRawValueSerializer>(serializer);
Assert.Equal(ODataPayloadKind.Value, rawValueSerializer.ODataPayloadKind);
}
public ODataCollectionSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_customerSet = _model.EntityContainer.FindEntitySet("Customers");
_edmIntType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false);
_customer = new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 10,
};
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
_collectionType = new EdmCollectionTypeReference(new EdmCollectionType(_edmIntType));
_serializer = new ODataCollectionSerializer(serializerProvider);
}
public ODataCollectionSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_customerSet = _model.EntityContainer.FindEntitySet("Customers");
_edmIntType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false);
_customer = new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 10,
};
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
_collectionType = new EdmCollectionTypeReference(new EdmCollectionType(_edmIntType));
_serializer = new ODataCollectionSerializer(serializerProvider);
}
public void CreateODataComplexValue_WritesBaseAndDerivedProperties_ForDerivedComplexType()
{
// Arrange
IEdmModel model = SerializationTestsHelpers.SimpleCustomerOrderModel();
IEdmComplexType addressType = model.FindDeclaredType("Default.CnAddress") as IEdmComplexType;
Type cnAddress = typeof(CnAddress);
model.SetAnnotationValue <ClrTypeAnnotation>(addressType, new ClrTypeAnnotation(cnAddress));
IEdmComplexTypeReference addressTypeRef = addressType.ToEdmTypeReference(isNullable: false).AsComplex();
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
ODataComplexTypeSerializer serializer = new ODataComplexTypeSerializer(serializerProvider);
ODataSerializerContext context = new ODataSerializerContext
{
Model = model
};
Address address = new CnAddress()
{
Street = "One Microsoft Way",
City = "Redmond",
State = "Washington",
Country = "United States",
ZipCode = "98052",
CnProp = new Guid("F83FB4CC-84BD-403B-B411-79926800F9A5")
};
// Act
var odataValue = serializer.CreateODataComplexValue(address, addressTypeRef, context);
// Assert
ODataComplexValue complexValue = Assert.IsType <ODataComplexValue>(odataValue);
Assert.Equal(complexValue.TypeName, "Default.CnAddress");
Assert.Equal(6, complexValue.Properties.Count());
// Verify the derived property
ODataProperty street = Assert.Single(complexValue.Properties.Where(p => p.Name == "CnProp"));
Assert.Equal(new Guid("F83FB4CC-84BD-403B-B411-79926800F9A5"), street.Value);
}
public void GetODataPayloadSerializer_ReturnsRawValueSerializer_ForDollarCountRequests(string uri, Type elementType)
{
// Arrange
IEdmModel model = ODataCountTest.GetEdmModel();
Type type = typeof(ICollection <>).MakeGenericType(elementType);
var request = new HttpRequestMessage();
var pathHandler = new DefaultODataPathHandler();
var path = pathHandler.Parse(model, "http://localhost/", uri);
request.ODataProperties().Path = path;
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
// Act
var serializer = serializerProvider.GetODataPayloadSerializer(model, type, request);
// Assert
Assert.NotNull(serializer);
var rawValueSerializer = Assert.IsType <ODataRawValueSerializer>(serializer);
Assert.Equal(ODataPayloadKind.Value, rawValueSerializer.ODataPayloadKind);
}
public void CreateODataComplexValue_Throws_IfDynamicPropertyNameSameAsDeclaredPropertyName()
{
// Arrange
IEdmModel model = SerializationTestsHelpers.SimpleOpenTypeModel();
IEdmComplexType addressType = model.FindDeclaredType("Default.Address") as IEdmComplexType;
Type simpleOpenAddress = typeof(SimpleOpenAddress);
model.SetAnnotationValue <ClrTypeAnnotation>(addressType, new ClrTypeAnnotation(simpleOpenAddress));
model.SetAnnotationValue(addressType, new DynamicPropertyDictionaryAnnotation(
simpleOpenAddress.GetProperty("Properties")));
IEdmComplexTypeReference addressTypeRef = addressType.ToEdmTypeReference(isNullable: false).AsComplex();
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
ODataComplexTypeSerializer serializer = new ODataComplexTypeSerializer(serializerProvider);
ODataSerializerContext context = new ODataSerializerContext
{
Model = model
};
SimpleOpenAddress address = new SimpleOpenAddress()
{
Street = "My Way",
City = "Redmond",
Properties = new Dictionary <string, object>()
};
address.Properties.Add("StringProperty", "My Country");
address.Properties.Add("Street", new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"));
// Act & Assert
Assert.Throws <InvalidOperationException>(() =>
serializer.CreateODataComplexValue(address, addressTypeRef, context),
"The name of dynamic property 'Street' was already used as the declared property name " +
"of open complex type 'Default.Address'.");
}
public void GetODataPayloadSerializer_ReturnsRawValueSerializer_ForDollarCountRequests(string uri, Type elementType)
{
// Arrange
IEdmModel model = ODataCountTest.GetEdmModel();
Type type = typeof(ICollection<>).MakeGenericType(elementType);
var request = new HttpRequestMessage();
var pathHandler = new DefaultODataPathHandler();
var path = pathHandler.Parse(model, "http://localhost/", uri);
request.ODataProperties().Path = path;
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
// Act
var serializer = serializerProvider.GetODataPayloadSerializer(model, type, request);
// Assert
Assert.NotNull(serializer);
var rawValueSerializer = Assert.IsType<ODataRawValueSerializer>(serializer);
Assert.Equal(ODataPayloadKind.Value, rawValueSerializer.ODataPayloadKind);
}
public void GetODataSerializer_Entity()
{
var serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
var serializer = serializerProvider.GetODataPayloadSerializer(_edmModel, typeof(ODataEntityDeserializerTests.Product), request);
Assert.NotNull(serializer);
var entitySerializer = Assert.IsType<ODataEntityTypeSerializer>(serializer);
Assert.Equal(entitySerializer.SerializerProvider, serializerProvider);
Assert.Equal(entitySerializer.ODataPayloadKind, ODataPayloadKind.Entry);
}
public void GetODataSerializer_Complex()
{
var serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
var serializer = serializerProvider.GetODataPayloadSerializer(_edmModel, typeof(ODataEntityDeserializerTests.Address), request);
Assert.NotNull(serializer);
var complexSerializer = Assert.IsType<ODataComplexTypeSerializer>(serializer);
Assert.Equal(complexSerializer.SerializerProvider, serializerProvider);
Assert.Equal(complexSerializer.ODataPayloadKind, ODataPayloadKind.Property);
}
public void GetODataSerializer_Feed(Type collectionType)
{
var serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
var serializer = serializerProvider.GetODataPayloadSerializer(_edmModel, collectionType, request);
Assert.NotNull(serializer);
var feedSerializer = Assert.IsType<ODataFeedSerializer>(serializer);
Assert.Equal(feedSerializer.ODataPayloadKind, ODataPayloadKind.Feed);
}
public void CreateEntry_Works_ToAppendNullDynamicProperties_ForOpenEntityType(bool enableNullDynamicProperty, int count)
{
// Arrange
IEdmModel model = SerializationTestsHelpers.SimpleOpenTypeModel();
IEdmEntitySet customers = model.EntityContainer.FindEntitySet("Customers");
IEdmEntityType customerType = model.FindDeclaredType("Default.Customer") as IEdmEntityType;
Type simpleOpenCustomer = typeof(SimpleOpenCustomer);
model.SetAnnotationValue(customerType, new ClrTypeAnnotation(simpleOpenCustomer));
IEdmComplexType addressType = model.FindDeclaredType("Default.Address") as IEdmComplexType;
Type simpleOpenAddress = typeof(SimpleOpenAddress);
model.SetAnnotationValue(addressType, new ClrTypeAnnotation(simpleOpenAddress));
IEdmEnumType enumType = model.FindDeclaredType("Default.SimpleEnum") as IEdmEnumType;
Type simpleEnumType = typeof(SimpleEnum);
model.SetAnnotationValue(enumType, new ClrTypeAnnotation(simpleEnumType));
model.SetAnnotationValue(customerType, new DynamicPropertyDictionaryAnnotation(
simpleOpenCustomer.GetProperty("CustomerProperties")));
model.SetAnnotationValue(addressType, new DynamicPropertyDictionaryAnnotation(
simpleOpenAddress.GetProperty("Properties")));
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
ODataEntityTypeSerializer serializer = new ODataEntityTypeSerializer(serializerProvider);
HttpConfiguration config = new HttpConfiguration();
config.SetSerializeNullDynamicProperty(enableNullDynamicProperty);
HttpRequestMessage request = new HttpRequestMessage();
request.SetConfiguration(config);
SelectExpandNode selectExpandNode = new SelectExpandNode(null, customerType, model);
ODataSerializerContext writeContext = new ODataSerializerContext
{
Model = model,
Path = new ODataPath(new EntitySetPathSegment(customers)),
Request = request
};
SimpleOpenCustomer customer = new SimpleOpenCustomer()
{
CustomerId = 991,
Name = "Name #991",
Address = new SimpleOpenAddress
{
City = "a city",
Street = "a street",
Properties = new Dictionary<string, object> { { "ArrayProperty", new[] { "15", "14", "13" } } }
},
CustomerProperties = new Dictionary<string, object>()
};
customer.CustomerProperties.Add("GuidProperty", new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"));
customer.CustomerProperties.Add("NullProperty", null);
EntityInstanceContext entityInstanceContext = new EntityInstanceContext(writeContext,
customerType.ToEdmTypeReference(false) as IEdmEntityTypeReference, customer);
// Act
ODataEntry entry = serializer.CreateEntry(selectExpandNode, entityInstanceContext);
// Assert
Assert.Equal(entry.TypeName, "Default.Customer");
Assert.Equal(count, entry.Properties.Count());
// Verify the declared properties
ODataProperty street = Assert.Single(entry.Properties.Where(p => p.Name == "CustomerId"));
Assert.Equal(991, street.Value);
ODataProperty city = Assert.Single(entry.Properties.Where(p => p.Name == "Name"));
Assert.Equal("Name #991", city.Value);
// Verify the nested open complex property
ODataProperty address = Assert.Single(entry.Properties.Where(p => p.Name == "Address"));
ODataComplexValue addressComplexValue = Assert.IsType<ODataComplexValue>(address.Value);
ODataProperty addressDynamicProperty =
Assert.Single(addressComplexValue.Properties.Where(p => p.Name == "ArrayProperty"));
ODataCollectionValue addressCollectionValue =
Assert.IsType<ODataCollectionValue>(addressDynamicProperty.Value);
Assert.Equal(new[] { "15", "14", "13" }, addressCollectionValue.Items.OfType<string>().ToList());
Assert.Equal("Collection(Edm.String)", addressCollectionValue.TypeName);
// Verify the dynamic properties
ODataProperty guidProperty = Assert.Single(entry.Properties.Where(p => p.Name == "GuidProperty"));
Assert.Equal(new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"), guidProperty.Value);
ODataProperty nullProperty = entry.Properties.SingleOrDefault(p => p.Name == "NullProperty");
if (enableNullDynamicProperty)
{
Assert.NotNull(nullProperty);
Assert.Null(nullProperty.Value);
}
else
{
Assert.Null(nullProperty);
}
}
public void CreateODataComplexValue_WritesNestedOpenComplexTypes()
{
// Arrange
IEdmModel model = SerializationTestsHelpers.SimpleOpenTypeModel();
IEdmComplexType addressType = model.FindDeclaredType("Default.Address") as IEdmComplexType;
Type simpleOpenAddress = typeof(SimpleOpenAddress);
model.SetAnnotationValue <ClrTypeAnnotation>(addressType, new ClrTypeAnnotation(simpleOpenAddress));
model.SetAnnotationValue(addressType, new DynamicPropertyDictionaryAnnotation(
simpleOpenAddress.GetProperty("Properties")));
IEdmComplexType zipCodeType = model.FindDeclaredType("Default.ZipCode") as IEdmComplexType;
Type simpleOpenZipCode = typeof(SimpleOpenZipCode);
model.SetAnnotationValue <ClrTypeAnnotation>(zipCodeType, new ClrTypeAnnotation(simpleOpenZipCode));
model.SetAnnotationValue(zipCodeType, new DynamicPropertyDictionaryAnnotation(
simpleOpenZipCode.GetProperty("Properties")));
IEdmComplexTypeReference addressTypeRef = addressType.ToEdmTypeReference(isNullable: false).AsComplex();
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
ODataComplexTypeSerializer serializer = new ODataComplexTypeSerializer(serializerProvider);
ODataSerializerContext context = new ODataSerializerContext
{
Model = model
};
SimpleOpenAddress topAddress = new SimpleOpenAddress()
{
Street = "TopStreet",
City = "TopCity",
Properties = new Dictionary <string, object>()
{
{ "PropertOfAddress", "Value1" }
}
};
SimpleOpenZipCode zipCode = new SimpleOpenZipCode()
{
Code = 101,
Properties = new Dictionary <string, object>()
{
{ "PropertyOfZipCode", "Value2" }
}
};
SimpleOpenAddress subAddress = new SimpleOpenAddress()
{
Street = "SubStreet",
City = "SubCity",
Properties = new Dictionary <string, object>()
{
{ "PropertOfSubAddress", "Value3" }
}
};
// TopAddress (SimpleOpenAddress)
// |-- Street (declare property, string)
// |-- City (declare property, string)
// |-- PropertyOfAddress (dynamic property, string)
// |-- ZipCodeOfAddress (dynamic property, SimpleOpenZipCode)
// |-- Code (declare property, int)
// |-- PropertyOfZipCode (dynamic property, string)
// |-- SubAddressOfZipCode (dynamic property, SimpleOpenAddress)
// |-- Street (declare property, string)
// |-- City (declare property, string)
// |-- PropertyOfAddress (dynamic property, string)
zipCode.Properties.Add("SubAddressOfZipCode", subAddress);
topAddress.Properties.Add("ZipCodeOfAddress", zipCode);
// Act
var odataValue = serializer.CreateODataComplexValue(topAddress, addressTypeRef, context);
// Assert
ODataComplexValue topAddressComplexValue = Assert.IsType <ODataComplexValue>(odataValue);
Assert.Equal(topAddressComplexValue.TypeName, "Default.Address");
Assert.Equal(4, topAddressComplexValue.Properties.Count());
// Verify the dynamic "ZipCodeOfAddress" property, it's nested open complex type
ODataProperty dynamicProperty = Assert.Single(topAddressComplexValue.Properties.Where(p => p.Name == "ZipCodeOfAddress"));
ODataComplexValue zipCodeComplexValue = Assert.IsType <ODataComplexValue>(dynamicProperty.Value);
Assert.Equal(zipCodeComplexValue.TypeName, "Default.ZipCode");
Assert.Equal(3, zipCodeComplexValue.Properties.Count());
// Verify the declared "Code" property of ZipCode
ODataProperty code = Assert.Single(zipCodeComplexValue.Properties.Where(p => p.Name == "Code"));
Assert.Equal(101, code.Value);
// Verify the dynamic "SubAddressOfZipCode" property of ZipCode
dynamicProperty = Assert.Single(zipCodeComplexValue.Properties.Where(p => p.Name == "SubAddressOfZipCode"));
ODataComplexValue subAddressComplexValue = Assert.IsType <ODataComplexValue>(dynamicProperty.Value);
Assert.Equal(subAddressComplexValue.TypeName, "Default.Address");
Assert.Equal(3, subAddressComplexValue.Properties.Count());
}
public void CreateEntry_Works_ToAppendDynamicProperties_ForOpenEntityType()
{
// Arrange
IEdmModel model = SerializationTestsHelpers.SimpleOpenTypeModel();
IEdmEntitySet customers = model.EntityContainer.FindEntitySet("Customers");
IEdmEntityType customerType = model.FindDeclaredType("Default.Customer") as IEdmEntityType;
Type simpleOpenCustomer = typeof(SimpleOpenCustomer);
model.SetAnnotationValue(customerType, new ClrTypeAnnotation(simpleOpenCustomer));
IEdmComplexType addressType = model.FindDeclaredType("Default.Address") as IEdmComplexType;
Type simpleOpenAddress = typeof(SimpleOpenAddress);
model.SetAnnotationValue(addressType, new ClrTypeAnnotation(simpleOpenAddress));
IEdmEnumType enumType = model.FindDeclaredType("Default.SimpleEnum") as IEdmEnumType;
Type simpleEnumType = typeof(SimpleEnum);
model.SetAnnotationValue(enumType, new ClrTypeAnnotation(simpleEnumType));
model.SetAnnotationValue(customerType, new DynamicPropertyDictionaryAnnotation(
simpleOpenCustomer.GetProperty("CustomerProperties")));
model.SetAnnotationValue(addressType, new DynamicPropertyDictionaryAnnotation(
simpleOpenAddress.GetProperty("Properties")));
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
ODataEntityTypeSerializer serializer = new ODataEntityTypeSerializer(serializerProvider);
SelectExpandNode selectExpandNode = new SelectExpandNode(null, customerType, model);
ODataSerializerContext writeContext = new ODataSerializerContext
{
Model = model,
Path = new ODataPath(new EntitySetPathSegment(customers))
};
SimpleOpenCustomer customer = new SimpleOpenCustomer()
{
CustomerId = 991,
Name = "Name #991",
Address = new SimpleOpenAddress
{
City = "a city",
Street = "a street",
Properties = new Dictionary<string, object> { {"ArrayProperty", new[] { "15", "14", "13" } } }
},
CustomerProperties = new Dictionary<string, object>()
};
customer.CustomerProperties.Add("EnumProperty", SimpleEnum.Fourth);
customer.CustomerProperties.Add("GuidProperty", new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"));
customer.CustomerProperties.Add("ListProperty", new List<int>{5,4,3,2,1});
customer.CustomerProperties.Add("DateTimeProperty", new DateTime(2014, 10, 24));
EntityInstanceContext entityInstanceContext = new EntityInstanceContext(writeContext,
customerType.ToEdmTypeReference(false) as IEdmEntityTypeReference, customer);
// Act
ODataEntry entry = serializer.CreateEntry(selectExpandNode, entityInstanceContext);
// Assert
Assert.Equal(entry.TypeName, "Default.Customer");
Assert.Equal(7, entry.Properties.Count());
// Verify the declared properties
ODataProperty street = Assert.Single(entry.Properties.Where(p => p.Name == "CustomerId"));
Assert.Equal(991, street.Value);
ODataProperty city = Assert.Single(entry.Properties.Where(p => p.Name == "Name"));
Assert.Equal("Name #991", city.Value);
// Verify the nested open complex property
ODataProperty address = Assert.Single(entry.Properties.Where(p => p.Name == "Address"));
ODataComplexValue addressComplexValue = Assert.IsType<ODataComplexValue>(address.Value);
ODataProperty addressDynamicProperty =
Assert.Single(addressComplexValue.Properties.Where(p => p.Name == "ArrayProperty"));
ODataCollectionValue addressCollectionValue =
Assert.IsType<ODataCollectionValue>(addressDynamicProperty.Value);
Assert.Equal(new[] { "15", "14", "13" }, addressCollectionValue.Items.OfType<string>().ToList());
Assert.Equal("Collection(Edm.String)", addressCollectionValue.TypeName);
// Verify the dynamic properties
ODataProperty enumProperty = Assert.Single(entry.Properties.Where(p => p.Name == "EnumProperty"));
ODataEnumValue enumValue = Assert.IsType<ODataEnumValue>(enumProperty.Value);
Assert.Equal("Fourth", enumValue.Value);
Assert.Equal("Default.SimpleEnum", enumValue.TypeName);
ODataProperty guidProperty = Assert.Single(entry.Properties.Where(p => p.Name == "GuidProperty"));
Assert.Equal(new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"), guidProperty.Value);
ODataProperty listProperty = Assert.Single(entry.Properties.Where(p => p.Name == "ListProperty"));
ODataCollectionValue collectionValue = Assert.IsType<ODataCollectionValue>(listProperty.Value);
Assert.Equal(new List<int>{5,4,3,2,1}, collectionValue.Items.OfType<int>().ToList());
Assert.Equal("Collection(Edm.Int32)", collectionValue.TypeName);
ODataProperty dateTimeProperty = Assert.Single(entry.Properties.Where(p => p.Name == "DateTimeProperty"));
Assert.Equal(new DateTimeOffset(new DateTime(2014, 10, 24)), dateTimeProperty.Value);
}
public void GetODataPayloadSerializer_ReturnsRawValueSerializer_ForEnumValueRequests()
{
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
request.ODataProperties().Path = new ODataPath(new ValuePathSegment());
var serializer = serializerProvider.GetODataPayloadSerializer(GetEnumModel(), typeof(TestEnum), request);
Assert.NotNull(serializer);
var rawValueSerializer = Assert.IsType<ODataRawValueSerializer>(serializer);
Assert.Equal(ODataPayloadKind.Value, rawValueSerializer.ODataPayloadKind);
}
public void CreateODataComplexValue_WritesDynamicCollectionProperty_ForOpenComplexType()
{
// Arrange
IEdmModel model = SerializationTestsHelpers.SimpleOpenTypeModel();
IEdmComplexType addressType = model.FindDeclaredType("Default.Address") as IEdmComplexType;
Type simpleOpenAddress = typeof(SimpleOpenAddress);
model.SetAnnotationValue<ClrTypeAnnotation>(addressType, new ClrTypeAnnotation(simpleOpenAddress));
IEdmEnumType enumType = model.FindDeclaredType("Default.SimpleEnum") as IEdmEnumType;
Type simpleEnumType = typeof(SimpleEnum);
model.SetAnnotationValue<ClrTypeAnnotation>(enumType, new ClrTypeAnnotation(simpleEnumType));
model.SetAnnotationValue(addressType, new DynamicPropertyDictionaryAnnotation(
simpleOpenAddress.GetProperty("Properties")));
IEdmComplexTypeReference addressTypeRef = addressType.ToEdmTypeReference(isNullable: false).AsComplex();
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
ODataComplexTypeSerializer serializer = new ODataComplexTypeSerializer(serializerProvider);
ODataSerializerContext context = new ODataSerializerContext
{
Model = model
};
SimpleOpenAddress address = new SimpleOpenAddress()
{
Street = "One Way",
City = "One City",
Properties = new Dictionary<string, object>()
};
address.Properties.Add("CollectionProperty", new[] { 1.1, 2.2 });
// Act
var odataValue = serializer.CreateODataComplexValue(address, addressTypeRef, context);
// Assert
ODataComplexValue complexValue = Assert.IsType<ODataComplexValue>(odataValue);
Assert.Equal(complexValue.TypeName, "Default.Address");
Assert.Equal(3, complexValue.Properties.Count());
// Verify the declared properties
ODataProperty street = Assert.Single(complexValue.Properties.Where(p => p.Name == "Street"));
Assert.Equal("One Way", street.Value);
ODataProperty city = Assert.Single(complexValue.Properties.Where(p => p.Name == "City"));
Assert.Equal("One City", city.Value);
// Verify the dynamic properties
ODataProperty enumProperty = Assert.Single(complexValue.Properties.Where(p => p.Name == "CollectionProperty"));
ODataCollectionValue collectionValue = Assert.IsType<ODataCollectionValue>(enumProperty.Value);
Assert.Equal("Collection(Edm.Double)", collectionValue.TypeName);
Assert.Equal(new List<double> { 1.1, 2.2 }, collectionValue.Items.OfType<double>().ToList());
}
public void CreateODataComplexValue_WritesNullDynamicProperties_ForOpenComplexType(bool enableNullDynamicProperty, int count)
{
// Arrange
IEdmModel model = SerializationTestsHelpers.SimpleOpenTypeModel();
IEdmComplexType addressType = model.FindDeclaredType("Default.Address") as IEdmComplexType;
Type simpleOpenAddress = typeof(SimpleOpenAddress);
model.SetAnnotationValue<ClrTypeAnnotation>(addressType, new ClrTypeAnnotation(simpleOpenAddress));
IEdmEnumType enumType = model.FindDeclaredType("Default.SimpleEnum") as IEdmEnumType;
Type simpleEnumType = typeof(SimpleEnum);
model.SetAnnotationValue<ClrTypeAnnotation>(enumType, new ClrTypeAnnotation(simpleEnumType));
model.SetAnnotationValue(addressType, new DynamicPropertyDictionaryAnnotation(
simpleOpenAddress.GetProperty("Properties")));
IEdmComplexTypeReference addressTypeRef = addressType.ToEdmTypeReference(isNullable: false).AsComplex();
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
ODataComplexTypeSerializer serializer = new ODataComplexTypeSerializer(serializerProvider);
HttpConfiguration config = new HttpConfiguration();
if (enableNullDynamicProperty)
{
config.EnableNullDynamicProperty();
}
HttpRequestMessage request = new HttpRequestMessage();
request.SetConfiguration(config);
ODataSerializerContext context = new ODataSerializerContext
{
Model = model,
Request = request
};
SimpleOpenAddress address = new SimpleOpenAddress()
{
Street = "My Way",
City = "Redmond",
Properties = new Dictionary<string, object>()
};
address.Properties.Add("GuidProperty", new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"));
address.Properties.Add("NullProperty", null);
// Act
var odataValue = serializer.CreateODataComplexValue(address, addressTypeRef, context);
// Assert
ODataComplexValue complexValue = Assert.IsType<ODataComplexValue>(odataValue);
Assert.Equal(complexValue.TypeName, "Default.Address");
Assert.Equal(count, complexValue.Properties.Count());
// Verify the declared properties
ODataProperty street = Assert.Single(complexValue.Properties.Where(p => p.Name == "Street"));
Assert.Equal("My Way", street.Value);
ODataProperty city = Assert.Single(complexValue.Properties.Where(p => p.Name == "City"));
Assert.Equal("Redmond", city.Value);
// Verify the dynamic properties
ODataProperty guidProperty = Assert.Single(complexValue.Properties.Where(p => p.Name == "GuidProperty"));
Assert.Equal(new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"), guidProperty.Value);
ODataProperty nullProperty = complexValue.Properties.SingleOrDefault(p => p.Name == "NullProperty");
if (enableNullDynamicProperty)
{
Assert.NotNull(nullProperty);
Assert.Null(nullProperty.Value);
}
else
{
Assert.Null(nullProperty);
}
}
public void CreateODataComplexValue_WritesBaseAndDerivedProperties_ForDerivedComplexType()
{
// Arrange
IEdmModel model = SerializationTestsHelpers.SimpleCustomerOrderModel();
IEdmComplexType addressType = model.FindDeclaredType("Default.CnAddress") as IEdmComplexType;
Type cnAddress = typeof(CnAddress);
model.SetAnnotationValue<ClrTypeAnnotation>(addressType, new ClrTypeAnnotation(cnAddress));
IEdmComplexTypeReference addressTypeRef = addressType.ToEdmTypeReference(isNullable: false).AsComplex();
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
ODataComplexTypeSerializer serializer = new ODataComplexTypeSerializer(serializerProvider);
ODataSerializerContext context = new ODataSerializerContext
{
Model = model
};
Address address = new CnAddress()
{
Street = "One Microsoft Way",
City = "Redmond",
State = "Washington",
Country = "United States",
ZipCode = "98052",
CnProp = new Guid("F83FB4CC-84BD-403B-B411-79926800F9A5")
};
// Act
var odataValue = serializer.CreateODataComplexValue(address, addressTypeRef, context);
// Assert
ODataComplexValue complexValue = Assert.IsType<ODataComplexValue>(odataValue);
Assert.Equal(complexValue.TypeName, "Default.CnAddress");
Assert.Equal(6, complexValue.Properties.Count());
// Verify the derived property
ODataProperty street = Assert.Single(complexValue.Properties.Where(p => p.Name == "CnProp"));
Assert.Equal(new Guid("F83FB4CC-84BD-403B-B411-79926800F9A5"), street.Value);
}
public void GetODataSerializer_ReturnsSameSerializer_ForSameType()
{
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
ODataSerializer firstCallSerializer = serializerProvider.GetODataPayloadSerializer(_edmModel,
typeof(ODataEntityDeserializerTests.Supplier), request);
ODataSerializer secondCallSerializer = serializerProvider.GetODataPayloadSerializer(_edmModel,
typeof(ODataEntityDeserializerTests.Supplier), request);
Assert.Same(firstCallSerializer, secondCallSerializer);
}
public void GetODataSerializer_Enum()
{
var serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
var serializer = serializerProvider.GetODataPayloadSerializer(GetEnumModel(), typeof(TestEnum), request);
Assert.NotNull(serializer);
var enumSerializer = Assert.IsType<ODataEnumSerializer>(serializer);
Assert.Equal(ODataPayloadKind.Property, enumSerializer.ODataPayloadKind);
}
public void CreateODataComplexValue_WritesNestedOpenComplexTypes()
{
// Arrange
IEdmModel model = SerializationTestsHelpers.SimpleOpenTypeModel();
IEdmComplexType addressType = model.FindDeclaredType("Default.Address") as IEdmComplexType;
Type simpleOpenAddress = typeof(SimpleOpenAddress);
model.SetAnnotationValue<ClrTypeAnnotation>(addressType, new ClrTypeAnnotation(simpleOpenAddress));
model.SetAnnotationValue(addressType, new DynamicPropertyDictionaryAnnotation(
simpleOpenAddress.GetProperty("Properties")));
IEdmComplexType zipCodeType = model.FindDeclaredType("Default.ZipCode") as IEdmComplexType;
Type simpleOpenZipCode = typeof(SimpleOpenZipCode);
model.SetAnnotationValue<ClrTypeAnnotation>(zipCodeType, new ClrTypeAnnotation(simpleOpenZipCode));
model.SetAnnotationValue(zipCodeType, new DynamicPropertyDictionaryAnnotation(
simpleOpenZipCode.GetProperty("Properties")));
IEdmComplexTypeReference addressTypeRef = addressType.ToEdmTypeReference(isNullable: false).AsComplex();
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
ODataComplexTypeSerializer serializer = new ODataComplexTypeSerializer(serializerProvider);
ODataSerializerContext context = new ODataSerializerContext
{
Model = model
};
SimpleOpenAddress topAddress = new SimpleOpenAddress()
{
Street = "TopStreet",
City = "TopCity",
Properties = new Dictionary<string, object>() { { "PropertOfAddress", "Value1"} }
};
SimpleOpenZipCode zipCode = new SimpleOpenZipCode()
{
Code = 101,
Properties = new Dictionary<string, object>() { { "PropertyOfZipCode", "Value2"} }
};
SimpleOpenAddress subAddress = new SimpleOpenAddress()
{
Street = "SubStreet",
City = "SubCity",
Properties = new Dictionary<string, object>() { { "PropertOfSubAddress", "Value3" } }
};
// TopAddress (SimpleOpenAddress)
// |-- Street (declare property, string)
// |-- City (declare property, string)
// |-- PropertyOfAddress (dynamic property, string)
// |-- ZipCodeOfAddress (dynamic property, SimpleOpenZipCode)
// |-- Code (declare property, int)
// |-- PropertyOfZipCode (dynamic property, string)
// |-- SubAddressOfZipCode (dynamic property, SimpleOpenAddress)
// |-- Street (declare property, string)
// |-- City (declare property, string)
// |-- PropertyOfAddress (dynamic property, string)
zipCode.Properties.Add("SubAddressOfZipCode", subAddress);
topAddress.Properties.Add("ZipCodeOfAddress", zipCode);
// Act
var odataValue = serializer.CreateODataComplexValue(topAddress, addressTypeRef, context);
// Assert
ODataComplexValue topAddressComplexValue = Assert.IsType<ODataComplexValue>(odataValue);
Assert.Equal(topAddressComplexValue.TypeName, "Default.Address");
Assert.Equal(4, topAddressComplexValue.Properties.Count());
// Verify the dynamic "ZipCodeOfAddress" property, it's nested open complex type
ODataProperty dynamicProperty = Assert.Single(topAddressComplexValue.Properties.Where(p => p.Name == "ZipCodeOfAddress"));
ODataComplexValue zipCodeComplexValue = Assert.IsType<ODataComplexValue>(dynamicProperty.Value);
Assert.Equal(zipCodeComplexValue.TypeName, "Default.ZipCode");
Assert.Equal(3, zipCodeComplexValue.Properties.Count());
// Verify the declared "Code" property of ZipCode
ODataProperty code = Assert.Single(zipCodeComplexValue.Properties.Where(p => p.Name == "Code"));
Assert.Equal(101, code.Value);
// Verify the dynamic "SubAddressOfZipCode" property of ZipCode
dynamicProperty = Assert.Single(zipCodeComplexValue.Properties.Where(p => p.Name == "SubAddressOfZipCode"));
ODataComplexValue subAddressComplexValue = Assert.IsType<ODataComplexValue>(dynamicProperty.Value);
Assert.Equal(subAddressComplexValue.TypeName, "Default.Address");
Assert.Equal(3, subAddressComplexValue.Properties.Count());
}
public void CreateODataComplexValue_WritesAllDeclaredAndDynamicProperties_ForOpenComplexType()
{
// Arrange
IEdmModel model = SerializationTestsHelpers.SimpleOpenTypeModel();
IEdmComplexType addressType = model.FindDeclaredType("Default.Address") as IEdmComplexType;
Type simpleOpenAddress = typeof(SimpleOpenAddress);
model.SetAnnotationValue <ClrTypeAnnotation>(addressType, new ClrTypeAnnotation(simpleOpenAddress));
IEdmEnumType enumType = model.FindDeclaredType("Default.SimpleEnum") as IEdmEnumType;
Type simpleEnumType = typeof(SimpleEnum);
model.SetAnnotationValue <ClrTypeAnnotation>(enumType, new ClrTypeAnnotation(simpleEnumType));
model.SetAnnotationValue(addressType, new DynamicPropertyDictionaryAnnotation(
simpleOpenAddress.GetProperty("Properties")));
IEdmComplexTypeReference addressTypeRef = addressType.ToEdmTypeReference(isNullable: false).AsComplex();
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
ODataComplexTypeSerializer serializer = new ODataComplexTypeSerializer(serializerProvider);
ODataSerializerContext context = new ODataSerializerContext
{
Model = model
};
SimpleOpenAddress address = new SimpleOpenAddress()
{
Street = "My Way",
City = "Redmond",
Properties = new Dictionary <string, object>()
};
address.Properties.Add("EnumProperty", SimpleEnum.Fourth);
address.Properties.Add("GuidProperty", new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"));
address.Properties.Add("DoubleProperty", 99.109);
address.Properties.Add("DateTimeProperty", new DateTime(2014, 10, 27));
// Act
var odataValue = serializer.CreateODataComplexValue(address, addressTypeRef, context);
// Assert
ODataComplexValue complexValue = Assert.IsType <ODataComplexValue>(odataValue);
Assert.Equal(complexValue.TypeName, "Default.Address");
Assert.Equal(6, complexValue.Properties.Count());
// Verify the declared properties
ODataProperty street = Assert.Single(complexValue.Properties.Where(p => p.Name == "Street"));
Assert.Equal("My Way", street.Value);
ODataProperty city = Assert.Single(complexValue.Properties.Where(p => p.Name == "City"));
Assert.Equal("Redmond", city.Value);
// Verify the dynamic properties
ODataProperty enumProperty = Assert.Single(complexValue.Properties.Where(p => p.Name == "EnumProperty"));
ODataEnumValue enumValue = Assert.IsType <ODataEnumValue>(enumProperty.Value);
Assert.Equal("Fourth", enumValue.Value);
Assert.Equal("Default.SimpleEnum", enumValue.TypeName);
ODataProperty guidProperty = Assert.Single(complexValue.Properties.Where(p => p.Name == "GuidProperty"));
Assert.Equal(new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"), guidProperty.Value);
ODataProperty doubleProperty = Assert.Single(complexValue.Properties.Where(p => p.Name == "DoubleProperty"));
Assert.Equal(99.109, doubleProperty.Value);
ODataProperty dateTimeProperty =
Assert.Single(complexValue.Properties.Where(p => p.Name == "DateTimeProperty"));
Assert.Equal(new DateTimeOffset(new DateTime(2014, 10, 27)), dateTimeProperty.Value);
}
public void GetODataSerializer_ComplexCollection()
{
var serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
var serializer = serializerProvider.GetODataPayloadSerializer(_edmModel,
typeof(IEnumerable<ODataEntityDeserializerTests.Address>), request);
Assert.NotNull(serializer);
var collectionSerializer = Assert.IsType<ODataCollectionSerializer>(serializer);
Assert.Equal(collectionSerializer.ODataPayloadKind, ODataPayloadKind.Collection);
Assert.Equal(collectionSerializer.SerializerProvider, serializerProvider);
}
public void CreateODataComplexValue_WritesDynamicCollectionProperty_ForOpenComplexType()
{
// Arrange
IEdmModel model = SerializationTestsHelpers.SimpleOpenTypeModel();
IEdmComplexType addressType = model.FindDeclaredType("Default.Address") as IEdmComplexType;
Type simpleOpenAddress = typeof(SimpleOpenAddress);
model.SetAnnotationValue <ClrTypeAnnotation>(addressType, new ClrTypeAnnotation(simpleOpenAddress));
IEdmEnumType enumType = model.FindDeclaredType("Default.SimpleEnum") as IEdmEnumType;
Type simpleEnumType = typeof(SimpleEnum);
model.SetAnnotationValue <ClrTypeAnnotation>(enumType, new ClrTypeAnnotation(simpleEnumType));
model.SetAnnotationValue(addressType, new DynamicPropertyDictionaryAnnotation(
simpleOpenAddress.GetProperty("Properties")));
IEdmComplexTypeReference addressTypeRef = addressType.ToEdmTypeReference(isNullable: false).AsComplex();
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
ODataComplexTypeSerializer serializer = new ODataComplexTypeSerializer(serializerProvider);
ODataSerializerContext context = new ODataSerializerContext
{
Model = model
};
SimpleOpenAddress address = new SimpleOpenAddress()
{
Street = "One Way",
City = "One City",
Properties = new Dictionary <string, object>()
};
address.Properties.Add("CollectionProperty", new[] { 1.1, 2.2 });
// Act
var odataValue = serializer.CreateODataComplexValue(address, addressTypeRef, context);
// Assert
ODataComplexValue complexValue = Assert.IsType <ODataComplexValue>(odataValue);
Assert.Equal(complexValue.TypeName, "Default.Address");
Assert.Equal(3, complexValue.Properties.Count());
// Verify the declared properties
ODataProperty street = Assert.Single(complexValue.Properties.Where(p => p.Name == "Street"));
Assert.Equal("One Way", street.Value);
ODataProperty city = Assert.Single(complexValue.Properties.Where(p => p.Name == "City"));
Assert.Equal("One City", city.Value);
// Verify the dynamic properties
ODataProperty enumProperty = Assert.Single(complexValue.Properties.Where(p => p.Name == "CollectionProperty"));
ODataCollectionValue collectionValue = Assert.IsType <ODataCollectionValue>(enumProperty.Value);
Assert.Equal("Collection(Edm.Double)", collectionValue.TypeName);
Assert.Equal(new List <double> {
1.1, 2.2
}, collectionValue.Items.OfType <double>().ToList());
}
public void GetEdmTypeSerializer_Caches_CreateEdmTypeSerializerOutput()
{
// Arrange
DefaultODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
IEdmTypeReference edmType = new Mock<IEdmTypeReference>().Object;
// Act
var serializer1 = serializerProvider.GetEdmTypeSerializer(edmType);
var serializer2 = serializerProvider.GetEdmTypeSerializer(edmType);
// Assert
Assert.Same(serializer2, serializer1);
}
public void CreateODataComplexValue_WritesNullDynamicProperties_ForOpenComplexType(bool enableNullDynamicProperty, int count)
{
// Arrange
IEdmModel model = SerializationTestsHelpers.SimpleOpenTypeModel();
IEdmComplexType addressType = model.FindDeclaredType("Default.Address") as IEdmComplexType;
Type simpleOpenAddress = typeof(SimpleOpenAddress);
model.SetAnnotationValue <ClrTypeAnnotation>(addressType, new ClrTypeAnnotation(simpleOpenAddress));
IEdmEnumType enumType = model.FindDeclaredType("Default.SimpleEnum") as IEdmEnumType;
Type simpleEnumType = typeof(SimpleEnum);
model.SetAnnotationValue <ClrTypeAnnotation>(enumType, new ClrTypeAnnotation(simpleEnumType));
model.SetAnnotationValue(addressType, new DynamicPropertyDictionaryAnnotation(
simpleOpenAddress.GetProperty("Properties")));
IEdmComplexTypeReference addressTypeRef = addressType.ToEdmTypeReference(isNullable: false).AsComplex();
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
ODataComplexTypeSerializer serializer = new ODataComplexTypeSerializer(serializerProvider);
HttpConfiguration config = new HttpConfiguration();
config.SetSerializeNullDynamicProperty(enableNullDynamicProperty);
HttpRequestMessage request = new HttpRequestMessage();
request.SetConfiguration(config);
ODataSerializerContext context = new ODataSerializerContext
{
Model = model,
Request = request
};
SimpleOpenAddress address = new SimpleOpenAddress()
{
Street = "My Way",
City = "Redmond",
Properties = new Dictionary <string, object>()
};
address.Properties.Add("GuidProperty", new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"));
address.Properties.Add("NullProperty", null);
// Act
var odataValue = serializer.CreateODataComplexValue(address, addressTypeRef, context);
// Assert
ODataComplexValue complexValue = Assert.IsType <ODataComplexValue>(odataValue);
Assert.Equal(complexValue.TypeName, "Default.Address");
Assert.Equal(count, complexValue.Properties.Count());
// Verify the declared properties
ODataProperty street = Assert.Single(complexValue.Properties.Where(p => p.Name == "Street"));
Assert.Equal("My Way", street.Value);
ODataProperty city = Assert.Single(complexValue.Properties.Where(p => p.Name == "City"));
Assert.Equal("Redmond", city.Value);
// Verify the dynamic properties
ODataProperty guidProperty = Assert.Single(complexValue.Properties.Where(p => p.Name == "GuidProperty"));
Assert.Equal(new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"), guidProperty.Value);
ODataProperty nullProperty = complexValue.Properties.SingleOrDefault(p => p.Name == "NullProperty");
if (enableNullDynamicProperty)
{
Assert.NotNull(nullProperty);
Assert.Null(nullProperty.Value);
}
else
{
Assert.Null(nullProperty);
}
}
public void GetEdmTypeSerializer_ThrowsArgumentNull_EdmType()
{
DefaultODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
Assert.ThrowsArgumentNull(
() => serializerProvider.GetEdmTypeSerializer(edmType: null),
"edmType");
}
public void CreateODataComplexValue_WritesAllDeclaredAndDynamicProperties_ForOpenComplexType()
{
// Arrange
IEdmModel model = SerializationTestsHelpers.SimpleOpenTypeModel();
IEdmComplexType addressType = model.FindDeclaredType("Default.Address") as IEdmComplexType;
Type simpleOpenAddress = typeof(SimpleOpenAddress);
model.SetAnnotationValue<ClrTypeAnnotation>(addressType, new ClrTypeAnnotation(simpleOpenAddress));
IEdmEnumType enumType = model.FindDeclaredType("Default.SimpleEnum") as IEdmEnumType;
Type simpleEnumType = typeof(SimpleEnum);
model.SetAnnotationValue<ClrTypeAnnotation>(enumType, new ClrTypeAnnotation(simpleEnumType));
model.SetAnnotationValue(addressType, new DynamicPropertyDictionaryAnnotation(
simpleOpenAddress.GetProperty("Properties")));
IEdmComplexTypeReference addressTypeRef = addressType.ToEdmTypeReference(isNullable: false).AsComplex();
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
ODataComplexTypeSerializer serializer = new ODataComplexTypeSerializer(serializerProvider);
ODataSerializerContext context = new ODataSerializerContext
{
Model = model
};
SimpleOpenAddress address = new SimpleOpenAddress()
{
Street = "My Way",
City = "Redmond",
Properties = new Dictionary<string, object>()
};
address.Properties.Add("EnumProperty", SimpleEnum.Fourth);
address.Properties.Add("GuidProperty", new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"));
address.Properties.Add("DoubleProperty", 99.109);
// Act
var odataValue = serializer.CreateODataComplexValue(address, addressTypeRef, context);
// Assert
ODataComplexValue complexValue = Assert.IsType<ODataComplexValue>(odataValue);
Assert.Equal(complexValue.TypeName, "Default.Address");
Assert.Equal(5, complexValue.Properties.Count());
// Verify the declared properties
ODataProperty street = Assert.Single(complexValue.Properties.Where(p => p.Name == "Street"));
Assert.Equal("My Way", street.Value);
ODataProperty city = Assert.Single(complexValue.Properties.Where(p => p.Name == "City"));
Assert.Equal("Redmond", city.Value);
// Verify the dynamic properties
ODataProperty enumProperty = Assert.Single(complexValue.Properties.Where(p => p.Name == "EnumProperty"));
ODataEnumValue enumValue = Assert.IsType<ODataEnumValue>(enumProperty.Value);
Assert.Equal("Fourth", enumValue.Value);
Assert.Equal("Default.SimpleEnum", enumValue.TypeName);
ODataProperty guidProperty = Assert.Single(complexValue.Properties.Where(p => p.Name == "GuidProperty"));
Assert.Equal(new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"), guidProperty.Value);
ODataProperty doubleProperty = Assert.Single(complexValue.Properties.Where(p => p.Name == "DoubleProperty"));
Assert.Equal(99.109, doubleProperty.Value);
}
public void GetODataSerializer_Returns_ExpectedSerializerType(Type payloadType, Type expectedSerializerType)
{
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
ODataSerializer serializer = serializerProvider.GetODataPayloadSerializer(_edmModel, payloadType, request);
Assert.NotNull(serializer);
Assert.IsType(expectedSerializerType, serializer);
}
public void CreateODataComplexValue_Throws_IfDynamicPropertyNameSameAsDeclaredPropertyName()
{
// Arrange
IEdmModel model = SerializationTestsHelpers.SimpleOpenTypeModel();
IEdmComplexType addressType = model.FindDeclaredType("Default.Address") as IEdmComplexType;
Type simpleOpenAddress = typeof(SimpleOpenAddress);
model.SetAnnotationValue<ClrTypeAnnotation>(addressType, new ClrTypeAnnotation(simpleOpenAddress));
model.SetAnnotationValue(addressType, new DynamicPropertyDictionaryAnnotation(
simpleOpenAddress.GetProperty("Properties")));
IEdmComplexTypeReference addressTypeRef = addressType.ToEdmTypeReference(isNullable: false).AsComplex();
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
ODataComplexTypeSerializer serializer = new ODataComplexTypeSerializer(serializerProvider);
ODataSerializerContext context = new ODataSerializerContext
{
Model = model
};
SimpleOpenAddress address = new SimpleOpenAddress()
{
Street = "My Way",
City = "Redmond",
Properties = new Dictionary<string, object>()
};
address.Properties.Add("StringProperty", "My Country");
address.Properties.Add("Street", new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"));
// Act & Assert
Assert.Throws<InvalidOperationException>(() =>
serializer.CreateODataComplexValue(address, addressTypeRef, context),
"The name of dynamic property 'Street' was already used as the declared property name " +
"of open complex type 'Default.Address'.");
}
public void GetODataPayloadSerializer_ReturnsRawValueSerializer_ForValueRequests(Type type, EdmPrimitiveTypeKind edmPrimitiveTypeKind)
{
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
HttpRequestMessage request = new HttpRequestMessage();
request.ODataProperties().Path = new ODataPath(new ValuePathSegment());
var serializer = serializerProvider.GetODataPayloadSerializer(_edmModel, type, request);
Assert.NotNull(serializer);
Assert.Equal(ODataPayloadKind.Value, serializer.ODataPayloadKind);
}