public ODataFeedSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_customerSet = _model.EntityContainer.FindEntitySet("Customers");
_model.SetAnnotationValue(_customerSet.EntityType(), new ClrTypeAnnotation(typeof(Customer)));
_customers = new[] {
new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 10,
},
new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 42,
}
};
_customersType = _model.GetEdmTypeReference(typeof(Customer[])).AsCollection();
_writeContext = new ODataSerializerContext()
{
NavigationSource = _customerSet, Model = _model
};
}
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 ODataResourceSetSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_customerSet = _model.EntityContainer.FindEntitySet("Customers");
IEdmComplexType addressType = _model.SchemaElements.OfType <IEdmComplexType>()
.First(c => c.Name == "Address");
_model.SetAnnotationValue(_customerSet.EntityType(), new ClrTypeAnnotation(typeof(Customer)));
_model.SetAnnotationValue(addressType, new ClrTypeAnnotation(typeof(Address)));
_customers = new[] {
new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 10,
},
new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 42,
}
};
_customersType = _model.GetEdmTypeReference(typeof(Customer[])).AsCollection();
_addressesType = _model.GetEdmTypeReference(typeof(Address[])).AsCollection();
_writeContext = new ODataSerializerContext()
{
NavigationSource = _customerSet, Model = _model
};
_serializerProvider = DependencyInjectionHelper.GetDefaultODataSerializerProvider();
}
public ODataDeltaFeedSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_customerSet = _model.EntityContainer.FindEntitySet("Customers");
_model.SetAnnotationValue(_customerSet.EntityType(), new ClrTypeAnnotation(typeof(Customer)));
_path = new ODataPath(new EntitySetPathSegment(_customerSet));
_customers = new[] {
new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 10,
},
new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 42,
}
};
_deltaFeedCustomers = new EdmChangedObjectCollection(_customerSet.EntityType());
EdmDeltaEntityObject newCustomer = new EdmDeltaEntityObject(_customerSet.EntityType());
newCustomer.TrySetPropertyValue("ID", 10);
newCustomer.TrySetPropertyValue("FirstName", "Foo");
_deltaFeedCustomers.Add(newCustomer);
_customersType = _model.GetEdmTypeReference(typeof(Customer[])).AsCollection();
_writeContext = new ODataSerializerContext()
{
NavigationSource = _customerSet, Model = _model, Path = _path
};
}
public ODataCollectionSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_edmIntType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false);
_serializerProvider = DependencyInjectionHelper.GetDefaultODataSerializerProvider();
_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 ODataDeltaFeedSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_customerSet = _model.EntityContainer.FindEntitySet("Customers");
_model.SetAnnotationValue(_customerSet.EntityType(), new ClrTypeAnnotation(typeof(Customer)));
_path = new ODataPath(new EntitySetSegment(_customerSet));
_customers = new[] {
new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 10,
HomeAddress = new Address()
{
Street = "Street",
ZipCode = null,
}
},
new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 42,
}
};
_deltaFeedCustomers = new EdmChangedObjectCollection(_customerSet.EntityType());
EdmDeltaEntityObject newCustomer = new EdmDeltaEntityObject(_customerSet.EntityType());
newCustomer.TrySetPropertyValue("ID", 10);
newCustomer.TrySetPropertyValue("FirstName", "Foo");
EdmDeltaComplexObject newCustomerAddress = new EdmDeltaComplexObject(_model.FindType("Default.Address") as IEdmComplexType);
newCustomerAddress.TrySetPropertyValue("Street", "Street");
newCustomerAddress.TrySetPropertyValue("ZipCode", null);
newCustomer.TrySetPropertyValue("HomeAddress", newCustomerAddress);
_deltaFeedCustomers.Add(newCustomer);
_customersType = _model.GetEdmTypeReference(typeof(Customer[])).AsCollection();
_writeContext = new ODataSerializerContext()
{
NavigationSource = _customerSet, Model = _model, Path = _path
};
_serializerProvider = DependencyInjectionHelper.GetDefaultODataSerializerProvider();
}
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 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 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 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_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);
}
