public void ComplexValueTest()
{
EdmModel model = new EdmModel();
var emptyComplexType = new EdmComplexType(DefaultNamespaceName, "EmptyComplexType");
model.AddElement(emptyComplexType);
var complexTypeWithStringProperty = new EdmComplexType(DefaultNamespaceName, "ComplexTypeWithStringProperty");
complexTypeWithStringProperty.AddStructuralProperty("stringProperty", EdmCoreModel.Instance.GetString(isNullable: true));
complexTypeWithStringProperty.AddStructuralProperty("numberProperty", EdmCoreModel.Instance.GetInt32(isNullable: false));
model.AddElement(complexTypeWithStringProperty);
model.Fixup();
IEnumerable <PayloadReaderTestDescriptor> testDescriptors = new[]
{
// Empty element is a valid complex value
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.ComplexValue("TestModel.EmptyComplexType")
.XmlValueRepresentation(new XNode[0])
.WithTypeAnnotation(emptyComplexType),
PayloadEdmModel = model
},
};
testDescriptors = testDescriptors.Concat(
PropertiesElementAtomValues.CreatePropertiesElementPaddingPayloads <ComplexInstance>(
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.ComplexValue("TestModel.ComplexTypeWithStringProperty")
.WithTypeAnnotation(complexTypeWithStringProperty),
PayloadEdmModel = model
},
(complexInstance, xmlValue) => complexInstance.XmlValueRepresentation(xmlValue)));
testDescriptors = testDescriptors.Select(td => td.InProperty());
testDescriptors = testDescriptors.Concat(new []
{
// Top-level property without expected type and no type name - this is read as primitive string!
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.Property(null, PayloadBuilder.PrimitiveValue(string.Empty))
.XmlRepresentation("<m:value/>"),
PayloadEdmModel = model,
},
});
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.ReaderTestConfigurationProvider.AtomFormatConfigurations,
(testDescriptor, testConfiguration) =>
{
testDescriptor.RunTest(testConfiguration);
});
}
public void DeferredLinkTest()
{
IEdmModel model = Test.OData.Utils.Metadata.TestModels.BuildTestModel();
var cityType = model.FindType("TestModel.CityType");
Debug.Assert(cityType != null, "cityType != null");
// TODO: add test cases that use relative URIs
// Few hand-crafted payloads
IEnumerable <PayloadReaderTestDescriptor> testDescriptors = new PayloadReaderTestDescriptor[]
{
// Single deferred link
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadDescriptor = new PayloadTestDescriptor(),
PayloadElement = PayloadBuilder.Entity("TestModel.CityType").PrimitiveProperty("Id", 1).WithTypeAnnotation(cityType)
.NavigationProperty("CityHall", "http://odata.org/CityHall"),
PayloadEdmModel = model
},
// Multiple deferred links
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadDescriptor = new PayloadTestDescriptor(),
PayloadElement = PayloadBuilder.Entity("TestModel.CityType").PrimitiveProperty("Id", 1).WithTypeAnnotation(cityType)
.NavigationProperty("CityHall", "http://odata.org/CityHall")
.NavigationProperty("DOL", "http://odata.org/DOL"),
PayloadEdmModel = model
},
// Multiple deferred links with primitive properties in between
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadDescriptor = new PayloadTestDescriptor(),
PayloadElement = PayloadBuilder.Entity("TestModel.CityType").WithTypeAnnotation(cityType)
.Property("Id", PayloadBuilder.PrimitiveValue(1))
.NavigationProperty("CityHall", "http://odata.org/CityHall")
.Property("Name", PayloadBuilder.PrimitiveValue("Vienna"))
.NavigationProperty("DOL", "http://odata.org/DOL"),
PayloadEdmModel = model
},
};
// Add standard deferred link payloads
testDescriptors = testDescriptors.Concat(PayloadReaderTestDescriptorGenerator.CreateDeferredNavigationLinkTestDescriptors(this.Settings, true));
// Generate interesting payloads around the entry
testDescriptors = testDescriptors.SelectMany(td => this.PayloadGenerator.GenerateReaderPayloads(td));
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
// Deferred links are response only.
// TODO: Reenable Json Light support
this.ReaderTestConfigurationProvider.ExplicitFormatConfigurations.Where(tc => !tc.IsRequest && tc.Format == ODataFormat.Atom),
(testDescriptor, testConfiguration) =>
{
testDescriptor.RunTest(testConfiguration);
});
}
private static ODataPayloadElement ConvertToStringPayloadElement(ODataPayloadElement binaryPayload)
{
Debug.Assert(binaryPayload != null && binaryPayload.ElementType == ODataPayloadElementType.PrimitiveValue, "Expected non-null, primitive value as payload");
PrimitiveValue primitiveValue = (PrimitiveValue)binaryPayload;
Debug.Assert(primitiveValue.ClrValue.GetType() == typeof(byte[]), "Only expect byte[] primitive values.");
byte[] bytes = (byte[])primitiveValue.ClrValue;
return(PayloadBuilder.PrimitiveValue(System.Text.Encoding.UTF8.GetString(bytes, 0, bytes.Length)));
}
public void CollectionMessageSizeLimitReadTest()
{
EdmModel model = Test.OData.Utils.Metadata.TestModels.BuildTestModel() as EdmModel;
var itemTypeAnnotationType = MetadataUtils.GetPrimitiveTypeReference(typeof(string)).Definition;
var collectionTypeAnnotationType = MetadataUtils.GetPrimitiveTypeReference(typeof(string)).ToCollectionTypeReference().Definition;
ODataPayloadElement payload = new PrimitiveCollection(
PayloadBuilder.PrimitiveValue("Vienna").WithTypeAnnotation(itemTypeAnnotationType),
PayloadBuilder.PrimitiveValue("Prague").WithTypeAnnotation(itemTypeAnnotationType),
PayloadBuilder.PrimitiveValue("Redmond").WithTypeAnnotation(itemTypeAnnotationType))
.WithTypeAnnotation(collectionTypeAnnotationType)
.ExpectedCollectionItemType(itemTypeAnnotationType).CollectionName("PrimitiveCollection");
var testCases = new MessageSizeLimitTestCase[]
{
// Single byte size should fail
new MessageSizeLimitTestCase
{
MaxMessageSize = 1,
AtomSizes = new RequestResponseSizes {
RequestSize = 411, ResponseSize = 411
},
JsonLightSizes = new RequestResponseSizes {
RequestSize = 123, ResponseSize = 123
},
},
// Small number should fail
new MessageSizeLimitTestCase
{
MaxMessageSize = 20,
AtomSizes = new RequestResponseSizes {
RequestSize = 411, ResponseSize = 411
},
JsonLightSizes = new RequestResponseSizes {
RequestSize = 123, ResponseSize = 123
},
},
// Large number should work
new MessageSizeLimitTestCase
{
MaxMessageSize = 10000,
},
// Default should work
new MessageSizeLimitTestCase
{
MaxMessageSize = -1,
},
};
this.RunAtomJsonMessageSizeLimitTests(model, payload, testCases);
}
public void HeterogeneousCollectionReaderTest()
{
EdmModel model = new EdmModel();
var cityType = new EdmComplexType("TestModel", "CityType");
cityType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(true));
model.AddElement(cityType);
var addressType = new EdmComplexType("TestModel", "AddressType");
addressType.AddStructuralProperty("Street", EdmCoreModel.Instance.GetString(true));
model.AddElement(addressType);
var testContainer = new EdmEntityContainer("TestModel", "TestContainer");
model.AddElement(testContainer);
EdmFunction citiesFunction = new EdmFunction("TestModel", "Cities", EdmCoreModel.GetCollection(cityType.ToTypeReference()));
model.AddElement(citiesFunction);
EdmOperationImport citiesFunctionImport = testContainer.AddFunctionImport("Cities", citiesFunction);
model.Fixup();
// Add some hand-crafted payloads
IEnumerable <PayloadReaderTestDescriptor> testDescriptors = new PayloadReaderTestDescriptor[]
{
// expected type without type names in the payload and heterogeneous items
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = new ComplexInstanceCollection(
PayloadBuilder.ComplexValue().Property("Name", PayloadBuilder.PrimitiveValue("Vienna")),
PayloadBuilder.ComplexValue().Property("Street", PayloadBuilder.PrimitiveValue("Am Euro Platz")))
.ExpectedFunctionImport(citiesFunctionImport)
.CollectionName(null),
PayloadEdmModel = model,
ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_PropertyDoesNotExistOnType", "Street", "TestModel.CityType"),
},
};
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.ReaderTestConfigurationProvider.ExplicitFormatConfigurations,
(testDescriptor, testConfiguration) =>
{
testDescriptor.RunTest(testConfiguration);
});
}
private static ODataPayloadElement ConvertToBinaryPayloadElement(ODataPayloadElement stringPayload)
{
Debug.Assert(stringPayload != null && stringPayload.ElementType == ODataPayloadElementType.PrimitiveValue, "Expected non-null, primitive value as payload");
PrimitiveValue primitiveValue = (PrimitiveValue)stringPayload;
Debug.Assert(primitiveValue.ClrValue.GetType() == typeof(string), "Only expect string primitive values.");
string stringValue = (string)primitiveValue.ClrValue;
// very simple conversion assuming all chars are in the range of byte
byte[] bytes = new byte[stringValue.Length];
for (int i = 0; i < stringValue.Length; ++i)
{
bytes[i] = (byte)stringValue[i];
}
return(PayloadBuilder.PrimitiveValue(bytes));
}
public void BinaryValueMessageSizeLimitReadTest()
{
EdmModel model = Test.OData.Utils.Metadata.TestModels.BuildTestModel() as EdmModel;
ODataPayloadElement payload = PayloadBuilder.PrimitiveValue(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21 })
.WithTypeAnnotation(EdmCoreModel.Instance.GetBinary(false))
.ExpectedPrimitiveValueType(EdmCoreModel.Instance.GetBinary(false));
var testCases = new MessageSizeLimitTestCase[]
{
// Single byte size should fail
new MessageSizeLimitTestCase
{
MaxMessageSize = 1,
RawSizes = new RequestResponseSizes {
RequestSize = 21, ResponseSize = 21
}
},
// Small number should fail
new MessageSizeLimitTestCase
{
MaxMessageSize = 20,
RawSizes = new RequestResponseSizes {
RequestSize = 21, ResponseSize = 21
}
},
// Large number should work
new MessageSizeLimitTestCase
{
MaxMessageSize = 10000,
},
// Default should work
new MessageSizeLimitTestCase
{
MaxMessageSize = -1,
},
};
this.RunRawMessageSizeLimitTests(model, payload, testCases);
}
public void SpatialPropertyWithDisabledPrimitiveTypeConversionTest()
{
IEdmModel testModel = TestModels.BuildTestModel();
var testValues = new object[]
{
GeographyFactory.Point(10, 20).Build(),
GeometryFactory.Point(10, 20).Build()
};
IEnumerable <PayloadReaderTestDescriptor> testDescriptors =
TestValues.PrimitiveTypes.SelectMany(primitiveTypes => testValues.Select(testValue =>
{
PrimitiveDataType targetType = EntityModelUtils.GetPrimitiveEdmType(primitiveTypes);
ODataPayloadElement payloadElement = PayloadBuilder
.Property(null, PayloadBuilder.PrimitiveValue(testValue))
.ExpectedPropertyType(targetType);
return(new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = payloadElement,
PayloadEdmModel = testModel
});
}));
// TODO: Task 1429690:Fix places where we've lost JsonVerbose coverage to add JsonLight
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
new bool[] { false, true },
this.ReaderTestConfigurationProvider.ExplicitFormatConfigurations.Where(tc => false),
(testDescriptor, disableStrictValidation, testConfig) =>
{
testConfig = new ReaderTestConfiguration(testConfig);
testConfig.MessageReaderSettings.EnablePrimitiveTypeConversion = false;
if (disableStrictValidation)
{
testConfig = testConfig.CloneAndApplyBehavior(TestODataBehaviorKind.WcfDataServicesServer);
}
testDescriptor.RunTest(testConfig);
});
}
public void JsonLightTaupoSerializerCollectionTest()
{
var testCases = new JsonLightSerializerTestCase[]
{
// Primitive collection
new JsonLightSerializerTestCase
{
PayloadElement = new PrimitiveCollection(PayloadBuilder.PrimitiveValue((long)1), PayloadBuilder.PrimitiveValue((long)2)).WithContextUri("http://odata.org/metadatauri"),
ExpectedJson = @"
{
""" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + @""":""http://odata.org/metadatauri"",
""" + JsonLightConstants.ODataValuePropertyName + @""":[1,2]
}"
},
// Complex collection
new JsonLightSerializerTestCase
{
PayloadElement = new ComplexInstanceCollection(
PayloadBuilder.ComplexValue("TestModel.City")
.PrimitiveProperty("City", "Vienna"))
.WithContextUri("http://odata.org/metadatauri"),
ExpectedJson = @"
{
""" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + @""":""http://odata.org/metadatauri"",
""" + JsonLightConstants.ODataValuePropertyName + @""":[{ """ + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataTypeAnnotationName + @""":""TestModel.City"", ""City"":""Vienna"" }]
}"
},
};
this.CombinatorialEngineProvider.RunCombinations(
testCases,
(testCase) =>
{
JsonValue actualValue = this.JsonLightSerializer.ConvertToJsonLightValue(testCase.PayloadElement);
JsonValue expectedValue = JsonTextPreservingParser.ParseValue(new StringReader(testCase.ExpectedJson));
this.JsonValueComparer.Compare(expectedValue, actualValue);
});
}
public void PrimitiveValueMessageSizeLimitReadTest()
{
EdmModel model = Test.OData.Utils.Metadata.TestModels.BuildTestModel() as EdmModel;
ODataPayloadElement payload = PayloadBuilder.PrimitiveValue("This is a long string representing a value that will hit the message size limit.");
var testCases = new MessageSizeLimitTestCase[]
{
// Single byte size should fail
new MessageSizeLimitTestCase
{
MaxMessageSize = 1,
RawSizes = new RequestResponseSizes {
RequestSize = 80, ResponseSize = 80
}
},
// Small number should fail
new MessageSizeLimitTestCase
{
MaxMessageSize = 20,
RawSizes = new RequestResponseSizes {
RequestSize = 80, ResponseSize = 80
}
},
// Large number should work
new MessageSizeLimitTestCase
{
MaxMessageSize = 10000,
},
// Default should work
new MessageSizeLimitTestCase
{
MaxMessageSize = -1,
},
};
this.RunRawMessageSizeLimitTests(model, payload, testCases);
}
/// <summary>
/// Visits a collection of parameters.
/// </summary>
/// <param name="parameters">The parameters to visit.</param>
protected override ODataPayloadElement VisitParameters(ODataParameters parameters)
{
ExceptionUtilities.CheckArgumentNotNull(parameters, "parameters");
ComplexInstance result = new ComplexInstance();
result.IsNull = parameters.Count == 0;
foreach (var parameter in parameters)
{
if (parameter.Value == null)
{
result.Add(new PrimitiveProperty(parameter.Key, null, null));
continue;
}
ODataCollectionStart odataCollectionStart = parameter.Value as ODataCollectionStart;
if (odataCollectionStart != null)
{
ODataCollectionItemsObjectModelAnnotation annotation = odataCollectionStart.GetAnnotation <ODataCollectionItemsObjectModelAnnotation>();
PrimitiveMultiValue primitiveCollection = PayloadBuilder.PrimitiveMultiValue();
foreach (var value in annotation)
{
primitiveCollection.Item(value);
}
PrimitiveMultiValueProperty primitiveCollectionProperty = new PrimitiveMultiValueProperty(parameter.Key, primitiveCollection);
result.Add(primitiveCollectionProperty);
}
else
{
result.Add(new PrimitiveProperty(parameter.Key, null, PayloadBuilder.PrimitiveValue(parameter.Value).ClrValue));
}
}
return(result);
}
public void CollectionReaderTest()
{
IEdmModel model = Test.OData.Utils.Metadata.TestModels.BuildTestModel();
IEdmEntityContainer container = model.FindEntityContainer("DefaultContainer");
EdmOperationImport primitiveCollectionResultOperation = container.FindOperationImports("PrimitiveCollectionResultOperation").Single() as EdmOperationImport;
var primitiveCollection = PayloadBuilder.PrimitiveCollection("PrimitiveCollectionResultOperation");
primitiveCollection.Add(PayloadBuilder.PrimitiveValue(1));
primitiveCollection.Add(PayloadBuilder.PrimitiveValue(2));
primitiveCollection.Add(PayloadBuilder.PrimitiveValue(3));
IEnumerable <PayloadReaderTestDescriptor> testDescriptors = new[]
{
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Primitive collection - should work.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", \"" + JsonLightConstants.ODataValuePropertyName + "\":[ 1, 2, 3 ] }")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "null collection - should fail.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy().JsonRepresentation("null")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("JsonReaderExtensions_UnexpectedNodeDetected", "StartObject", "PrimitiveValue")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Primitive value for collection - should fail.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy().JsonRepresentation("42")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("JsonReaderExtensions_UnexpectedNodeDetected", "StartObject", "PrimitiveValue")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Array value for collection - should fail.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy().JsonRepresentation("[]")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("JsonReaderExtensions_UnexpectedNodeDetected", "StartObject", "StartArray")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Extra property before collection property - should fail.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", \"extra\": null, \"" + JsonLightConstants.ODataValuePropertyName + "\":[ 1, 2, 3 ] }")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightPropertyAndValueDeserializer_InvalidTopLevelPropertyName", "extra", "value")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Extra property after collection property - should fail.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", \"" + JsonLightConstants.ODataValuePropertyName + "\":[ 1, 2, 3 ], \"extra\": null }")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightCollectionDeserializer_CannotReadCollectionEnd", "extra")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Custom instance annotation before collection property - should work.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", \"@my.extra\": null, \"" + JsonLightConstants.ODataValuePropertyName + "\":[ 1, 2, 3 ] }")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Custom instance annotation after collection property - should work.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", \"" + JsonLightConstants.ODataValuePropertyName + "\":[ 1, 2, 3 ], \"@my.extra\": null }")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "OData instance annotations before collection property - should work.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{" +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\"," +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataCountAnnotationName + "\":3," +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataNextLinkAnnotationName + "\":\"http://next-link\"," +
"\"" + JsonLightConstants.ODataValuePropertyName + "\":[ 1, 2, 3 ] }")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "OData instance annotations after collection property - should work.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{" +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\"," +
"\"" + JsonLightConstants.ODataValuePropertyName + "\":[ 1, 2, 3 ]," +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataNextLinkAnnotationName + "\":\"http://next-link\"," +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataCountAnnotationName + "\":3}")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Custom property annotation before collection property - should work.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", \"[email protected]\": null, \"" + JsonLightConstants.ODataValuePropertyName + "\":[ 1, 2, 3 ] }")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Custom property annotation on 'value' after collection property - should fail.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", \"" + JsonLightConstants.ODataValuePropertyName + "\":[ 1, 2, 3 ], \"[email protected]\": null }")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightCollectionDeserializer_CannotReadCollectionEnd", "value")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Custom property annotation on 'extra' before collection property - should fail.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", \"[email protected]\": null, \"" + JsonLightConstants.ODataValuePropertyName + "\":[ 1, 2, 3 ] }")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightPropertyAndValueDeserializer_TopLevelPropertyAnnotationWithoutProperty", "extra")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Custom property annotation on 'extra' after collection property - should fail.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", \"" + JsonLightConstants.ODataValuePropertyName + "\":[ 1, 2, 3 ], \"[email protected]\": null }")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightCollectionDeserializer_CannotReadCollectionEnd", "extra")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Invalid collection property name - should fail.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", \"invalid\":[ 1, 2, 3 ] }")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightPropertyAndValueDeserializer_InvalidTopLevelPropertyName", "invalid", JsonLightConstants.ODataValuePropertyName)
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Missing collection property - should fail.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\" }")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightCollectionDeserializer_ExpectedCollectionPropertyNotFound", JsonLightConstants.ODataValuePropertyName)
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Invalid collection property value - should fail.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", \"" + JsonLightConstants.ODataValuePropertyName + "\":{} }")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightCollectionDeserializer_CannotReadCollectionContentStart", "StartObject")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Invalid OData instance annotation before collection property - should fail.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{" +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", " +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataEditLinkAnnotationName + "\":null, " +
"\"" + JsonLightConstants.ODataValuePropertyName + "\":[] }")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightPropertyAndValueDeserializer_UnexpectedAnnotationProperties", JsonLightConstants.ODataEditLinkAnnotationName)
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Invalid OData instance annotation after collection property - should fail.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{" +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", " +
"\"" + JsonLightConstants.ODataValuePropertyName + "\":[], " +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataEditLinkAnnotationName + "\":null }")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightCollectionDeserializer_CannotReadCollectionEnd", JsonLightConstants.ODataEditLinkAnnotationName)
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Invalid OData instance annotation after collection property - should fail.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{" +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", " +
"\"" + JsonLightConstants.ODataValuePropertyName + "\":[], " +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataEditLinkAnnotationName + "\":null }")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightCollectionDeserializer_CannotReadCollectionEnd", JsonLightConstants.ODataEditLinkAnnotationName)
},
};
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.ReaderTestConfigurationProvider.JsonLightFormatConfigurations,
(testDescriptor, testConfiguration) =>
{
// These descriptors are already tailored specifically for Json Light and
// do not require normalization.
testDescriptor.TestDescriptorNormalizers.Clear();
testDescriptor.RunTest(testConfiguration);
});
}
public void CollectionWithODataTypeReaderTest()
{
IEdmModel model = Test.OData.Utils.Metadata.TestModels.BuildTestModel();
IEdmEntityContainer container = model.FindEntityContainer("DefaultContainer");
EdmOperationImport primitiveCollectionResultOperation = container.FindOperationImports("PrimitiveCollectionResultOperation").Single() as EdmOperationImport;
EdmOperationImport complexCollectionResultOperation = container.FindOperationImports("ComplexCollectionResultOperation").Single() as EdmOperationImport;
var primitiveCollection = PayloadBuilder.PrimitiveCollection("PrimitiveCollectionResultOperation");
primitiveCollection.Add(PayloadBuilder.PrimitiveValue(1));
primitiveCollection.Add(PayloadBuilder.PrimitiveValue(2));
primitiveCollection.Add(PayloadBuilder.PrimitiveValue(3));
var complexCollection = PayloadBuilder.ComplexCollection("ComplexCollectionResultOperation");
var complexValue1 = PayloadBuilder.ComplexValue("TestModel.Address")
.PrimitiveProperty("Street", "Am Euro Platz")
.AddAnnotation(new SerializationTypeNameTestAnnotation()
{
TypeName = null
});
complexCollection.Add(complexValue1);
// NOTE: tests to cover consistency between the expected function import and the function import
// in the payload exist in the ContextUriValidationJsonLightTests.
IEnumerable <PayloadReaderTestDescriptor> testDescriptors = new[]
{
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Non-collection type specified in odata.type - should fail.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{" +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", " +
"\"" + JsonLightUtils.GetPropertyAnnotationName(JsonLightConstants.ODataValuePropertyName, JsonLightConstants.ODataTypeAnnotationName) + "\":\"TestModel.Address\"," +
"\"" + JsonLightConstants.ODataValuePropertyName + "\":[ 1, 2, 3 ]" +
"}")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightCollectionDeserializer_InvalidCollectionTypeName", "TestModel.Address"),
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Expected primitive item type and odata.type consistent - should work.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{" +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", " +
"\"" + JsonLightUtils.GetPropertyAnnotationName(JsonLightConstants.ODataValuePropertyName, JsonLightConstants.ODataTypeAnnotationName) + "\":\"Collection(Edm.Int32)\"," +
"\"" + JsonLightConstants.ODataValuePropertyName + "\":[ 1, 2, 3 ]" +
"}")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Context URI (primitive collection) and odata.type consistent - should work.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{" +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", " +
"\"" + JsonLightUtils.GetPropertyAnnotationName(JsonLightConstants.ODataValuePropertyName, JsonLightConstants.ODataTypeAnnotationName) + "\":\"Collection(Edm.Int32)\"," +
"\"" + JsonLightConstants.ODataValuePropertyName + "\":[ 1, 2, 3 ]" +
"}")
.ExpectedFunctionImport(primitiveCollectionResultOperation)
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Expected primitive item type and odata.type NOT consistent - should fail.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{" +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", " +
"\"" + JsonLightUtils.GetPropertyAnnotationName(JsonLightConstants.ODataValuePropertyName, JsonLightConstants.ODataTypeAnnotationName) + "\":\"Collection(Edm.Single)\"," +
"\"" + JsonLightConstants.ODataValuePropertyName + "\":[ 1, 2, 3 ]" +
"}")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_IncompatibleType", "Edm.Single", "Edm.Int32")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Expected primitive item type and odata.type NOT consistent (2) - should fail.",
PayloadEdmModel = model,
PayloadElement = primitiveCollection.DeepCopy()
.JsonRepresentation("{" +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(TestModel.Address)\", " +
"\"" + JsonLightUtils.GetPropertyAnnotationName(JsonLightConstants.ODataValuePropertyName, JsonLightConstants.ODataTypeAnnotationName) + "\":\"Collection(Edm.Int32)\"," +
"\"" + JsonLightConstants.ODataValuePropertyName + "\":[ 1, 2, 3 ]" +
"}")
.ExpectedFunctionImport(complexCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_IncorrectTypeKind", "Edm.Int32", "Complex", "Primitive")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Expected complex item type and odata.type NOT consistent - should fail.",
PayloadEdmModel = model,
PayloadElement = complexCollection.DeepCopy()
.JsonRepresentation("{" +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(TestModel.Address)\", " +
"\"" + JsonLightUtils.GetPropertyAnnotationName(JsonLightConstants.ODataValuePropertyName, JsonLightConstants.ODataTypeAnnotationName) + "\":\"Collection(TestModel.OfficeType)\"," +
"\"" + JsonLightConstants.ODataValuePropertyName + "\":[ { \"Street\": \"Am Euro Platz\"} ]" +
"}")
.ExpectedFunctionImport(complexCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_IncorrectTypeKind", "TestModel.OfficeType", "Complex", "Entity")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Expected primitive item type and odata.type NOT consistent (2) - should fail.",
PayloadEdmModel = model,
PayloadElement = complexCollection.DeepCopy()
.JsonRepresentation("{" +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", " +
"\"" + JsonLightUtils.GetPropertyAnnotationName(JsonLightConstants.ODataValuePropertyName, JsonLightConstants.ODataTypeAnnotationName) + "\":\"Collection(TestModel.Address)\"," +
"\"" + JsonLightConstants.ODataValuePropertyName + "\":[ { \"Street\": \"Am Euro Platz\"} ]" +
"}")
.ExpectedFunctionImport(primitiveCollectionResultOperation),
ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_IncorrectTypeKind", "TestModel.Address", "Primitive", "Complex")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Complex item type in context URI and odata.type NOT consistent - should fail.",
PayloadEdmModel = model,
PayloadElement = complexCollection.DeepCopy()
.JsonRepresentation("{" +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(TestModel.Address)\", " +
"\"" + JsonLightUtils.GetPropertyAnnotationName(JsonLightConstants.ODataValuePropertyName, JsonLightConstants.ODataTypeAnnotationName) + "\":\"Collection(TestModel.OfficeType)\"," +
"\"" + JsonLightConstants.ODataValuePropertyName + "\":[ { \"Street\": \"Am Euro Platz\"} ]" +
"}"),
SkipTestConfiguration = tc => tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_IncorrectTypeKind", "TestModel.OfficeType", "Complex", "Entity")
},
new PayloadReaderTestDescriptor(this.Settings)
{
DebugDescription = "Primitive item type in context URI and odata.type NOT consistent - should fail.",
PayloadEdmModel = model,
PayloadElement = complexCollection.DeepCopy()
.JsonRepresentation("{" +
"\"" + JsonLightConstants.ODataPropertyAnnotationSeparator + JsonLightConstants.ODataContextAnnotationName + "\":\"http://odata.org/test/$metadata#Collection(Edm.Int32)\", " +
"\"" + JsonLightUtils.GetPropertyAnnotationName(JsonLightConstants.ODataValuePropertyName, JsonLightConstants.ODataTypeAnnotationName) + "\":\"Collection(TestModel.Address)\"," +
"\"" + JsonLightConstants.ODataValuePropertyName + "\":[ { \"Street\": \"Am Euro Platz\"} ]" +
"}"),
SkipTestConfiguration = tc => tc.IsRequest,
ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_IncorrectTypeKind", "TestModel.Address", "Primitive", "Complex")
},
};
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.ReaderTestConfigurationProvider.JsonLightFormatConfigurations,
(testDescriptor, testConfiguration) =>
{
// These descriptors are already tailored specifically for Json Light and
// do not require normalization.
testDescriptor.TestDescriptorNormalizers.Clear();
testDescriptor.RunTest(testConfiguration);
});
}
public void CollectionReaderAtomTest()
{
EdmModel edmModel = new EdmModel();
EdmComplexType edmComplexTypeCity = edmModel.ComplexType("CityType", ModelNamespace);
edmComplexTypeCity.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(true));
edmModel.Fixup();
IEnumerable <PayloadReaderTestDescriptor> testDescriptors = new[]
{
#region primitive collection
// Empty primitive collection.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection().CollectionName(null),
},
// Yet another empty collection with extra elements not in the d namespace.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection().CollectionName(null)
.XmlRepresentation("<m:value><c:foo xmlns:c='customns'>bar</c:foo></m:value>"),
},
// Empty collection with text inside the collection element.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection().CollectionName(null)
.XmlRepresentation("<m:value>foo</m:value>"),
},
// Empty collection with insignificant nodes inside the collection element.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection().CollectionName(null)
.XmlRepresentation("<m:value><!-- some comment --> </m:value>"),
},
// TODO:: Currently the test infrastructure drops any top level node other than the root element.
// Once the test infrstructure is fixed, we should add some test to verify that insignificant nodes
// before the collection start are discarded.
// Verify that anything which is not in the d namespace, after the collection start, is discarded.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection(
new PrimitiveValue[]
{
PayloadBuilder.PrimitiveValue("vineet"),
}
).CollectionName(null)
.XmlRepresentation(@"<m:value>
<!-- some comment -->
<c:foo xmlns:c='customns'>bar</c:foo>
<m:element>vineet</m:element>
<c:foo xmlns:c='customns'>bar</c:foo>
</m:value>"),
},
// Verify that insignificant nodes after the collection end are discarded.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection().CollectionName(null)
.XmlRepresentation(@"
<m:value>
</m:value>
<!-- some comment -->
some text
"),
},
// Primitive collection with 'element' as collection name.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection(
new PrimitiveValue[]
{
PayloadBuilder.PrimitiveValue("vineet"),
}
).CollectionName(null),
},
// Collection with 'element' as collection name.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection(
new PrimitiveValue[]
{
PayloadBuilder.PrimitiveValue("redmond"),
PayloadBuilder.PrimitiveValue(""),
PayloadBuilder.PrimitiveValue("seattle"),
}
).XmlRepresentation(@"<m:value>
<m:element>redmond</m:element>
<m:element/>
<m:element>seattle</m:element>
</m:value>")
.CollectionName(null),
},
#endregion
#region complex collection
// yet another empty complex collection
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new ComplexInstanceCollection(
PayloadBuilder.ComplexValue("TestModel.CityType").PrimitiveProperty("Name", null)
).CollectionName(null),
},
// Verify that anything which is not in the d namespace, after the collection start, is discarded.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new ComplexInstanceCollection(
PayloadBuilder.ComplexValue("TestModel.CityType").Property("City", PayloadBuilder.PrimitiveValue("Vienna"))
).CollectionName(null)
.XmlRepresentation(@"<m:value>
<!-- some comment -->
<c:foo xmlns:c='customns'>bar</c:foo>
<m:element m:type='TestModel.CityType'>
<c:foo xmlns:c='customns'>bar</c:foo>
<d:City>Vienna</d:City>
<!-- some more comments -->
</m:element>
<c:foo xmlns:c='customns'>bar</c:foo>
</m:value>"),
},
// Verify that insignificant nodes after the collection end are discarded.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new ComplexInstanceCollection(
PayloadBuilder.ComplexValue("TestModel.CityType").Property("City", PayloadBuilder.PrimitiveValue("Vienna")))
.CollectionName(null)
.XmlRepresentation(@"
<m:value>
<m:element m:type='TestModel.CityType'>
<d:City>Vienna</d:City>
</m:element>
</m:value>
<!-- some comment -->
some text
"),
},
#endregion
#region no metadata
// primitive collection with no expected type and no metadata.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection(
PayloadBuilder.PrimitiveValue(1),
PayloadBuilder.PrimitiveValue(2)
).CollectionName(null),
},
// complex collection with no expected type and no metadata.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new ComplexInstanceCollection(
PayloadBuilder.ComplexValue("TestModel.CityType").Property("Name", PayloadBuilder.PrimitiveValue("Vienna")),
PayloadBuilder.ComplexValue("TestModel.CityType").Property("Name", PayloadBuilder.PrimitiveValue("Am Euro Platz"))
).CollectionName(null),
},
#endregion
};
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.ReaderTestConfigurationProvider.AtomFormatConfigurations,
(testDescriptor, testConfiguration) =>
{
testDescriptor.RunTest(testConfiguration);
});
}
public void HomogeneousCollectionReaderAtomTest()
{
EdmModel edmModel = new EdmModel();
EdmComplexType edmComplexTypeEmpty = new EdmComplexType(ModelNamespace, "EmptyComplexType");
edmModel.AddElement(edmComplexTypeEmpty);
EdmComplexType edmComplexTypeCity = new EdmComplexType(ModelNamespace, "CityType");
edmComplexTypeCity.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(true));
edmModel.AddElement(edmComplexTypeCity);
EdmComplexType edmComplexTypeAddress = new EdmComplexType(ModelNamespace, "AddressType");
edmComplexTypeAddress.AddStructuralProperty("Street", EdmCoreModel.Instance.GetString(true));
edmModel.AddElement(edmComplexTypeAddress);
edmModel.Fixup();
IEnumerable <PayloadReaderTestDescriptor> testDescriptors = new PayloadReaderTestDescriptor[]
{
// complex collection with primitive expected type
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new ComplexInstanceCollection(
PayloadBuilder.ComplexValue("TestModel.CityType").Property("Name", PayloadBuilder.PrimitiveValue("Vienna")),
PayloadBuilder.ComplexValue("TestModel.CityType").Property("Name", PayloadBuilder.PrimitiveValue("Prague"))
).ExpectedCollectionItemType(EdmDataTypes.Int32).CollectionName(null),
PayloadEdmModel = edmModel,
ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_IncorrectTypeKind", "TestModel.CityType", "Primitive", "Complex"),
},
// primitive collection in XMLRepresentation with complex expected type.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new ComplexInstanceCollection(
PayloadBuilder.ComplexValue("TestModel.CityType"),
PayloadBuilder.ComplexValue("TestModel.CityType")
).ExpectedCollectionItemType(edmComplexTypeCity).CollectionName(null)
.XmlRepresentation(@"
<m:value>
<m:element m:type='Edm.Int32'>1</m:element>
<m:element m:type='Edm.Int32'>2</m:element>
</m:value>"),
PayloadEdmModel = edmModel,
ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_IncorrectTypeKind", "Edm.Int32", "Complex", "Primitive"),
},
};
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.ReaderTestConfigurationProvider.AtomFormatConfigurations,
(testDescriptor, testConfiguration) =>
{
testDescriptor.RunTest(testConfiguration);
});
}
public void HomogeneousCollectionReaderWithoutMetadataAtomTest()
{
IEnumerable <PayloadReaderTestDescriptor> testDescriptors = new[]
{
// Primitive collection with only nulls
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection(
PayloadBuilder.PrimitiveValue(null),
PayloadBuilder.PrimitiveValue(null)
).CollectionName(null),
},
// Primitive collection with type names on string values
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection(
PayloadBuilder.PrimitiveValue("foo"),
PayloadBuilder.PrimitiveValue("bar")
).CollectionName(null),
},
// Primitive collection with type names on Int32 values
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection(
PayloadBuilder.PrimitiveValue(1),
PayloadBuilder.PrimitiveValue(2)
).CollectionName(null),
},
// Primitive collection without type names on some string values
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection(
new PrimitiveValue("Edm.String", "foo"),
new PrimitiveValue(/*fullTypeName*/ null, "bar")
).CollectionName(null),
},
// Primitive collection without type names on string values
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection(
new PrimitiveValue(/*fullTypeName*/ null, "foo"),
new PrimitiveValue(/*fullTypeName*/ null, "bar")
).CollectionName(null),
},
// Primitive collection with type names on Int32 values and null values
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection(
PayloadBuilder.PrimitiveValue(1),
PayloadBuilder.PrimitiveValue(null),
PayloadBuilder.PrimitiveValue(2),
PayloadBuilder.PrimitiveValue(null)
).CollectionName(null),
},
// Complex collection with type names on complex values
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new ComplexInstanceCollection(
PayloadBuilder.ComplexValue("TestModel.ComplexType").PrimitiveProperty("StringProperty", "abc"),
PayloadBuilder.ComplexValue("TestModel.ComplexType").PrimitiveProperty("StringProperty", "123")
).CollectionName(null),
},
// Complex collection with type names on complex values and null values
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new ComplexInstanceCollection(
PayloadBuilder.ComplexValue("TestModel.ComplexType").PrimitiveProperty("StringProperty", "abc"),
PayloadBuilder.ComplexValue(null, /*isNull*/ true),
PayloadBuilder.ComplexValue("TestModel.ComplexType").PrimitiveProperty("StringProperty", "123")
).CollectionName(null),
},
// Complex collection without type names on complex values
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new ComplexInstanceCollection(
PayloadBuilder.ComplexValue().PrimitiveProperty("Name", "Clemens"),
PayloadBuilder.ComplexValue().PrimitiveProperty("Name", "Vitek")
).CollectionName(null),
},
// Complex collection without type names on complex values and null values
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new ComplexInstanceCollection(
PayloadBuilder.ComplexValue().PrimitiveProperty("FirstName", "Clemens"),
PayloadBuilder.ComplexValue(null, /*isNull*/ true),
PayloadBuilder.ComplexValue().PrimitiveProperty("LastName", "Kerer")
).CollectionName(null),
},
};
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.ReaderTestConfigurationProvider.AtomFormatConfigurations,
(testDescriptor, testConfiguration) =>
{
testDescriptor.RunTest(testConfiguration);
});
}
/// <summary>
/// Creates several PayloadTestDescriptors containing Batch Requests
/// </summary>
/// <param name="requestManager">Used for building the requests</param>
/// <param name="model">The model to use for adding additional types.</param>
/// <param name="withTypeNames">Whether or not to use full type names.</param>
/// <returns>PayloadTestDescriptors</returns>
public static IEnumerable <PayloadTestDescriptor> CreateBatchRequestTestDescriptors(
IODataRequestManager requestManager,
EdmModel model,
bool withTypeNames = false)
{
ExceptionUtilities.CheckArgumentNotNull(requestManager, "requestManager");
EdmEntityType personType = null;
EdmComplexType carType = null;
EdmEntitySet personsEntitySet = null;
EdmEntityContainer container = model.EntityContainer as EdmEntityContainer;
if (model != null)
{
//TODO: Clone EdmModel
//model = model.Clone();
if (container == null)
{
container = new EdmEntityContainer("TestModel", "DefaultContainer");
model.AddElement(container);
}
personType = model.FindDeclaredType("TestModel.TFPerson") as EdmEntityType;
carType = model.FindDeclaredType("TestModel.TFCar") as EdmComplexType;
// Create the metadata types for the entity instance used in the entity set
if (carType == null)
{
carType = new EdmComplexType("TestModel", "TFCar");
model.AddElement(carType);
carType.AddStructuralProperty("Make", EdmPrimitiveTypeKind.String, true);
carType.AddStructuralProperty("Color", EdmPrimitiveTypeKind.String, true);
}
if (personType == null)
{
personType = new EdmEntityType("TestModel", "TFPerson");
model.AddElement(personType);
personType.AddKeys(personType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
personType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String, true);
personType.AddStructuralProperty("Car", carType.ToTypeReference());
container.AddEntitySet("Customers", personType);
}
personsEntitySet = container.AddEntitySet("People", personType);
}
ComplexInstance carInstance = PayloadBuilder.ComplexValue(withTypeNames ? "TestModel.TFCar" : null)
.Property("Make", PayloadBuilder.PrimitiveValue("Ford"))
.Property("Color", PayloadBuilder.PrimitiveValue("Blue"));
ComplexProperty carProperty = (ComplexProperty)PayloadBuilder.Property("Car", carInstance)
.WithTypeAnnotation(personType);
EntityInstance personInstance = PayloadBuilder.Entity(withTypeNames ? "TestModel.TFPerson" : null)
.Property("Id", PayloadBuilder.PrimitiveValue(1))
.Property("Name", PayloadBuilder.PrimitiveValue("John Doe"))
.Property("Car", carInstance)
.WithTypeAnnotation(personType);
var carPropertyPayload = new PayloadTestDescriptor()
{
PayloadElement = carProperty,
PayloadEdmModel = model
};
var emptyPayload = new PayloadTestDescriptor()
{
PayloadEdmModel = CreateEmptyEdmModel()
};
var personPayload = new PayloadTestDescriptor()
{
PayloadElement = personInstance,
PayloadEdmModel = model
};
var root = ODataUriBuilder.Root(new Uri("http://www.odata.org/service.svc"));
var entityset = ODataUriBuilder.EntitySet(personsEntitySet);
// Get operations
var queryOperation1 = emptyPayload.InRequestOperation(HttpVerb.Get, new ODataUri(new ODataUriSegment[] { root }), requestManager);
var queryOperation2 = emptyPayload.InRequestOperation(HttpVerb.Get, new ODataUri(new ODataUriSegment[] { root }), requestManager);
// Post operation containing a complex property
var postOperation = carPropertyPayload.InRequestOperation(HttpVerb.Post, new ODataUri(new ODataUriSegment[] { root, entityset }), requestManager, MimeTypes.ApplicationJsonLight);
// Delete operation with no payload
var deleteOperation = emptyPayload.InRequestOperation(HttpVerb.Delete, new ODataUri(new ODataUriSegment[] { root, entityset }), requestManager);
// Put operation where the payload is an EntityInstance
var putOperation = personPayload.InRequestOperation(HttpVerb.Put, new ODataUri(new ODataUriSegment[] { root, entityset }), requestManager);
// A changeset containing a delete with no payload and a put
var twoOperationsChangeset = BatchUtils.GetRequestChangeset(new IMimePart[] { postOperation, deleteOperation }, requestManager);
// A changeset containing a delete with no payload
var oneOperationChangeset = BatchUtils.GetRequestChangeset(new IMimePart[] { deleteOperation }, requestManager);
// A changeset containing a put, post and delete
var threeOperationsChangeset = BatchUtils.GetRequestChangeset(new IMimePart[] { putOperation, postOperation, deleteOperation }, requestManager);
// A changeset containing no operations
var emptyChangeset = BatchUtils.GetRequestChangeset(new IMimePart[] { }, requestManager);
// Empty Batch
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload()
.AddAnnotation(new BatchBoundaryAnnotation("bb_emptybatch")),
PayloadEdmModel = emptyPayload.PayloadEdmModel,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
// Single Operation
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(queryOperation1)
.AddAnnotation(new BatchBoundaryAnnotation("bb_singleoperation")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
// Multiple Operations
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(queryOperation1, queryOperation2)
.AddAnnotation(new BatchBoundaryAnnotation("bb_multipleoperations")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
// Single Changeset
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(twoOperationsChangeset)
.AddAnnotation(new BatchBoundaryAnnotation("bb_singlechangeset")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
// Multiple Changesets (different content types)
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(twoOperationsChangeset, oneOperationChangeset, emptyChangeset)
.AddAnnotation(new BatchBoundaryAnnotation("bb_multiplechangesets")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
// Operations and changesets
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(twoOperationsChangeset, queryOperation1, oneOperationChangeset)
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_1")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(queryOperation1, oneOperationChangeset, queryOperation2)
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_2")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(queryOperation1, queryOperation2, twoOperationsChangeset, oneOperationChangeset)
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_3")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(queryOperation1, threeOperationsChangeset, queryOperation2, twoOperationsChangeset, queryOperation1, oneOperationChangeset)
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_4")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchRequestPayload(queryOperation1, emptyChangeset, queryOperation1, threeOperationsChangeset, queryOperation2, oneOperationChangeset)
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_5")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => !tc.IsRequest,
});
}
public void CollectionReaderAtomErrorTest()
{
EdmModel edmModel = new EdmModel();
EdmComplexType edmComplexTypeEmpty = new EdmComplexType(ModelNamespace, "EmptyComplexType");
edmModel.AddElement(edmComplexTypeEmpty);
EdmComplexType edmComplexTypeCity = new EdmComplexType(ModelNamespace, "CityType");
edmComplexTypeCity.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(true));
edmModel.AddElement(edmComplexTypeCity);
EdmComplexType edmComplexTypeAddress = new EdmComplexType(ModelNamespace, "AddressType");
edmComplexTypeAddress.AddStructuralProperty("Street", EdmCoreModel.Instance.GetString(true));
edmModel.AddElement(edmComplexTypeAddress);
edmModel.Fixup();
IEnumerable <PayloadReaderTestDescriptor> testDescriptors = new[]
{
// Verify that collections do not support top level collection type.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new ComplexInstanceCollection().CollectionName(null)
.XmlRepresentation(@"<m:value>
<m:element m:type='" + EntityModelUtils.GetCollectionTypeName("Edm.Int32") + @"'>
<m:element>42</m:element>
</m:element>
</m:value>"),
PayloadEdmModel = edmModel,
ExpectedException = ODataExpectedExceptions.ODataException("CollectionWithoutExpectedTypeValidator_InvalidItemTypeKind", "Collection"),
SkipTestConfiguration = tc => tc.Version < Microsoft.OData.Core.ODataVersion.V4,
},
// Verify that collection inside complex type is not supported.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new ComplexInstanceCollection().CollectionName(null)
.XmlRepresentation(@"<m:value>
<m:element>
<m:element m:type='" + EntityModelUtils.GetCollectionTypeName("Edm.Int32") + @"'>
<m:element>42</m:element>
</m:element>
</m:element>
</m:value>"),
PayloadEdmModel = null, // No model, since otherwise we would fail to read the top-level item as it has no type information
ExpectedException = ODataExpectedExceptions.ODataException("CollectionWithoutExpectedTypeValidator_InvalidItemTypeKind", "Collection"),
SkipTestConfiguration = tc => tc.Version < Microsoft.OData.Core.ODataVersion.V4,
},
// Collection with m:type attribute in the root collection element.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection().CollectionName(null)
.XmlRepresentation("<m:value m:type='Edm.Int32'></m:value>"),
PayloadEdmModel = edmModel,
ExpectedException = ODataExpectedExceptions.ODataException("ODataAtomCollectionDeserializer_TypeOrNullAttributeNotAllowed"),
},
// Collection with m:null attribute in the Collection element.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection().CollectionName(null)
.XmlRepresentation("<m:value m:null='true'></m:value>"),
PayloadEdmModel = edmModel,
ExpectedException = ODataExpectedExceptions.ODataException("ODataAtomCollectionDeserializer_TypeOrNullAttributeNotAllowed"),
},
// Collection with both m:type and m:null attribute in the Collection element.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection().CollectionName(null)
.XmlRepresentation("<m:value m:null='true' m:type='Edm.Int32'></m:value>"),
PayloadEdmModel = edmModel,
ExpectedException = ODataExpectedExceptions.ODataException("ODataAtomCollectionDeserializer_TypeOrNullAttributeNotAllowed"),
},
// root collection element not in the d namespace.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection().CollectionName("PrimitiveCollection")
.XmlRepresentation("<d:PrimitiveCollection></d:PrimitiveCollection>"),
PayloadEdmModel = edmModel,
ExpectedException = ODataExpectedExceptions.ODataException("ODataAtomCollectionDeserializer_TopLevelCollectionElementWrongNamespace", "http://docs.oasis-open.org/odata/ns/data", "http://docs.oasis-open.org/odata/ns/metadata"),
},
// complex value instead of collection.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection().CollectionName(null)
.XmlRepresentation(@"<m:value>
<m:city>Seattle</m:city>
</m:value>"),
PayloadEdmModel = edmModel,
ExpectedException = ODataExpectedExceptions.ODataException("ODataAtomCollectionDeserializer_WrongCollectionItemElementName", "city", "http://docs.oasis-open.org/odata/ns/data", "http://docs.oasis-open.org/odata/ns/data"),
},
// complex collection with expected type and no metadata.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new ComplexInstanceCollection(
PayloadBuilder.ComplexValue("TestModel.CityType").Property("Name", PayloadBuilder.PrimitiveValue("Vienna")),
PayloadBuilder.ComplexValue("TestModel.CityType").Property("Name", PayloadBuilder.PrimitiveValue("Am Euro Platz"))
).ExpectedCollectionItemType(edmComplexTypeCity).CollectionName(null),
ExpectedResultCallback = tc =>
new PayloadReaderTestExpectedResult(this.PayloadExpectedResultSettings)
{
// There was no simple way to specify the complex type as the expected type, so specifying a primitive type as the
// expected type. Since the expected type is only used to trigger the exception any expected type works.
ReaderMetadata = new PayloadReaderTestDescriptor.ReaderMetadata(EdmCoreModel.Instance.GetInt32(false)),
ExpectedException = ODataExpectedExceptions.ArgumentException("ODataMessageReader_ExpectedTypeSpecifiedWithoutMetadata", "expectedItemTypeReference"),
}
},
// primitive collection with expected type and no metadata.
new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
{
PayloadElement = new PrimitiveCollection(
PayloadBuilder.PrimitiveValue(1),
PayloadBuilder.PrimitiveValue(2)
).ExpectedCollectionItemType(EdmDataTypes.Int32).CollectionName(null),
ExpectedException = ODataExpectedExceptions.ArgumentException("ODataMessageReader_ExpectedTypeSpecifiedWithoutMetadata", "expectedItemTypeReference"),
},
};
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.ReaderTestConfigurationProvider.AtomFormatConfigurations,
(testDescriptor, testConfiguration) =>
{
testDescriptor.RunTest(testConfiguration);
});
}
/// <summary>
/// Creates a feed containing entities of types that derive from the same base
/// </summary>
/// <param name="model">The entity model schema. The method will modify the model and call Fixup().</param>
/// <param name="withTypeNames">True if the payloads should specify type names.</param>
/// <returns>The feed containing derived typed entities.</returns>
public static IEnumerable <Taupo.OData.Common.PayloadTestDescriptor> GetFeeds(EdmModel model, bool withTypeNames)
{
ExceptionUtilities.CheckArgumentNotNull(model, "model");
List <Taupo.OData.Common.PayloadTestDescriptor> payloads = new List <Taupo.OData.Common.PayloadTestDescriptor>();
EdmEntityType baseType = model.EntityType("MyBaseType").KeyProperty("Id", (EdmPrimitiveTypeReference)EdmCoreModel.Instance.GetGuid(false));
model.Fixup();
EntityInstance instance = PayloadBuilder.Entity(withTypeNames ? "TestModel." + baseType.Name : null).Property("Id", PayloadBuilder.PrimitiveValue(Guid.NewGuid()));
instance.Id = "urn:id";
EntitySetInstance emptySet = PayloadBuilder.EntitySet().WithTypeAnnotation(baseType);
payloads.Add(new Taupo.OData.Common.PayloadTestDescriptor()
{
PayloadEdmModel = model,
PayloadElement = emptySet
});
var emptySetWithInlineCount = emptySet.DeepCopy();
emptySetWithInlineCount.InlineCount = 0;
// Inline count (note we skip for v1 and request because inline count is valid on response only on V2 and above.
payloads.Add(new Taupo.OData.Common.PayloadTestDescriptor()
{
PayloadEdmModel = model,
PayloadElement = emptySetWithInlineCount,
SkipTestConfiguration = (tc => tc.IsRequest)
});
var emptySetWithNextLinkAndCount = emptySet.DeepCopy();
emptySetWithNextLinkAndCount.InlineCount = 0;
emptySetWithNextLinkAndCount.NextLink = "http://www.odata.org/Feed";
// inline count + next link
payloads.Add(new Taupo.OData.Common.PayloadTestDescriptor()
{
PayloadEdmModel = model,
PayloadElement = emptySetWithNextLinkAndCount,
SkipTestConfiguration = (tc => tc.IsRequest)
});
var emptySetWithNextLink = emptySet.DeepCopy();
emptySetWithNextLink.NextLink = "http://www.odata.org/Feed";
// next link
payloads.Add(new Taupo.OData.Common.PayloadTestDescriptor()
{
PayloadEdmModel = model,
PayloadElement = emptySetWithNextLink,
SkipTestConfiguration = (tc => tc.IsRequest)
});
EntitySetInstance singleEntity = PayloadBuilder.EntitySet().Append(instance).WithTypeAnnotation(baseType);
payloads.Add(new Taupo.OData.Common.PayloadTestDescriptor()
{
PayloadEdmModel = model,
PayloadElement = singleEntity.DeepCopy()
});
var singleEntityWithInlineCount = singleEntity.DeepCopy();
singleEntityWithInlineCount.InlineCount = 1;
// inline count
payloads.Add(new Taupo.OData.Common.PayloadTestDescriptor()
{
PayloadEdmModel = model,
PayloadElement = singleEntityWithInlineCount,
SkipTestConfiguration = (tc => tc.IsRequest)
});
var singleEntityWithNextLinkAndCount = singleEntity.DeepCopy();
singleEntityWithInlineCount.InlineCount = 1;
singleEntityWithNextLinkAndCount.NextLink = "http://www.odata.org/Feed";
// inline count + next link
payloads.Add(new Taupo.OData.Common.PayloadTestDescriptor()
{
PayloadEdmModel = model,
PayloadElement = singleEntityWithNextLinkAndCount,
SkipTestConfiguration = (tc => tc.IsRequest)
});
var singleEntityWithNextLink = singleEntity.DeepCopy();
singleEntityWithNextLink.NextLink = "http://www.odata.org/Feed";
// next link
payloads.Add(new Taupo.OData.Common.PayloadTestDescriptor()
{
PayloadEdmModel = model,
PayloadElement = singleEntityWithNextLink,
SkipTestConfiguration = (tc => tc.IsRequest)
});
EntitySetInstance multipleEntity = PayloadBuilder.EntitySet().Append(instance.GenerateSimilarEntries(3)).WithTypeAnnotation(baseType);
payloads.Add(new Taupo.OData.Common.PayloadTestDescriptor()
{
PayloadEdmModel = model,
PayloadElement = multipleEntity
});
var multipleEntityWithInlineCount = multipleEntity.DeepCopy();
multipleEntityWithInlineCount.InlineCount = 3;
// inline count
payloads.Add(new Taupo.OData.Common.PayloadTestDescriptor()
{
PayloadEdmModel = model,
PayloadElement = multipleEntityWithInlineCount,
SkipTestConfiguration = (tc => tc.IsRequest)
});
var multipleEntityWithNextLinkAndCount = multipleEntity.DeepCopy();
multipleEntityWithNextLinkAndCount.InlineCount = 3;
multipleEntityWithNextLinkAndCount.NextLink = "http://www.odata.org/Feed";
// inline count + next link
payloads.Add(new Taupo.OData.Common.PayloadTestDescriptor()
{
PayloadEdmModel = model,
PayloadElement = multipleEntityWithNextLinkAndCount,
SkipTestConfiguration = (tc => tc.IsRequest)
});
var multipleEntityWithNextLink = multipleEntity.DeepCopy();
multipleEntityWithNextLink.NextLink = "http://www.odata.org/Feed";
// next link
payloads.Add(new Taupo.OData.Common.PayloadTestDescriptor()
{
PayloadEdmModel = model,
PayloadElement = multipleEntityWithNextLink,
SkipTestConfiguration = (tc => tc.IsRequest)
});
return(payloads);
}
/// <summary>
/// Creates a set of interesting entity set instances along with metadata.
/// </summary>
/// <param name="settings">The test descriptor settings to use.</param>
/// <param name="model">If non-null, the method creates types as needed and adds them to the model.</param>
/// <param name="withTypeNames">true if the payloads should specify type names.</param>
/// <returns>List of test descriptors with interesting entity instances as payload.</returns>
public static IEnumerable <PayloadTestDescriptor> CreateEntitySetTestDescriptors(
EdmModel model,
bool withTypeNames)
{
EdmEntityType personType = null;
EdmComplexType carType = null;
var container = model.EntityContainer as EdmEntityContainer;
if (container == null)
{
container = new EdmEntityContainer("TestModel", "DefaultNamespace");
model.AddElement(container);
}
if (model != null)
{
personType = model.FindDeclaredType("TestModel.TFPerson") as EdmEntityType;
carType = model.FindDeclaredType("TestModel.TFCar") as EdmComplexType;
// Create the metadata types for the entity instance used in the entity set
if (carType == null)
{
carType = new EdmComplexType("TestModel", "TFCar");
carType.AddStructuralProperty("Make", EdmPrimitiveTypeKind.String);
carType.AddStructuralProperty("Color", EdmPrimitiveTypeKind.String);
model.AddElement(carType);
}
if (personType == null)
{
personType = new EdmEntityType("TestModel", "TFPerson");
var keyProperty = personType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
personType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
personType.AddStructuralProperty("Car", carType.ToTypeReference());
personType.AddKeys(keyProperty);
model.AddElement(personType);
container.AddEntitySet("TFPerson", personType);
}
}
ComplexInstance carInstance = PayloadBuilder.ComplexValue(withTypeNames ? "TestModel.TFCar" : null)
.Property("Make", PayloadBuilder.PrimitiveValue("Ford"))
.Property("Color", PayloadBuilder.PrimitiveValue("Blue"));
EntityInstance personInstance = PayloadBuilder.Entity(withTypeNames ? "TestModel.TFPerson" : null)
.Property("Id", PayloadBuilder.PrimitiveValue(1))
.Property("Name", PayloadBuilder.PrimitiveValue("John Doe"))
.Property("Car", carInstance);
// empty feed
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.EntitySet().WithTypeAnnotation(personType), PayloadEdmModel = model
});
// entity set with a single entity
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.EntitySet().Append(personInstance).WithTypeAnnotation(personType), PayloadEdmModel = model
});
// entity set with the person instance in the middle
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.EntitySet()
.Append(personInstance.GenerateSimilarEntries(2))
.Append(personInstance)
.Append(personInstance.GenerateSimilarEntries(1))
.WithTypeAnnotation(personType),
PayloadEdmModel = model
});
// entity set with a single entity and a next link
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.EntitySet().Append(personInstance).NextLink(nextLink).WithTypeAnnotation(personType),
PayloadEdmModel = model,
SkipTestConfiguration = tc => tc.IsRequest
});
// entity set with a single entity and inline count
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.EntitySet().Append(personInstance).InlineCount(1).WithTypeAnnotation(personType),
PayloadEdmModel = model,
SkipTestConfiguration = tc => tc.IsRequest
});
// entity set with a single entity, a next link and inline count
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.EntitySet().Append(personInstance).NextLink(nextLink).InlineCount(1).WithTypeAnnotation(personType),
PayloadEdmModel = model,
SkipTestConfiguration = tc => tc.IsRequest
});
// entity set with a single entity, a next link and a negative inline count
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.EntitySet().Append(personInstance).NextLink(nextLink).InlineCount(-1).WithTypeAnnotation(personType),
PayloadEdmModel = model,
SkipTestConfiguration = tc => tc.IsRequest
});
// entity set containing many entities of types derived from the same base
//yield return new PayloadTestDescriptor()
//{
// PayloadElement = CreateDerivedEntitySetInstance(model, withTypeNames),
// PayloadEdmModel = model,
//};
}
/// <summary>
/// Visits a collection of parameters.
/// </summary>
/// <param name="parameters">The parameters to visit.</param>
protected override ODataPayloadElement VisitParameters(ODataParameters parameters)
{
ExceptionUtilities.CheckArgumentNotNull(parameters, "parameters");
ComplexInstance result = new ComplexInstance();
result.IsNull = parameters.Count == 0;
foreach (var parameter in parameters)
{
if (parameter.Value == null)
{
result.Add(new PrimitiveProperty(parameter.Key, null, null));
continue;
}
ODataComplexValue odataComplexValue = parameter.Value as ODataComplexValue;
ODataCollectionStart odataCollectionStart = parameter.Value as ODataCollectionStart;
if (odataCollectionStart != null)
{
ODataCollectionItemsObjectModelAnnotation annotation = odataCollectionStart.GetAnnotation <ODataCollectionItemsObjectModelAnnotation>();
if (annotation.OfType <ODataComplexValue>().FirstOrDefault() != null)
{
ComplexMultiValue complexCollection = PayloadBuilder.ComplexMultiValue();
foreach (var value in annotation)
{
complexCollection.Item(this.VisitComplexValue(value as ODataComplexValue) as ComplexInstance);
}
ComplexMultiValueProperty complexCollectionProperty = new ComplexMultiValueProperty(parameter.Key, complexCollection);
result.Add(complexCollectionProperty);
}
else
{
PrimitiveMultiValue primitiveCollection = PayloadBuilder.PrimitiveMultiValue();
foreach (var value in annotation)
{
primitiveCollection.Item(value);
}
PrimitiveMultiValueProperty primitiveCollectionProperty = new PrimitiveMultiValueProperty(parameter.Key, primitiveCollection);
result.Add(primitiveCollectionProperty);
}
}
else if (odataComplexValue != null)
{
ComplexInstance complexInstance = PayloadBuilder.ComplexValue(odataComplexValue.TypeName);
complexInstance.IsNull = false;
foreach (ODataProperty odataProperty in odataComplexValue.Properties)
{
complexInstance.Property(odataProperty.Name, this.Visit(odataProperty.Value));
}
result.Add(new ComplexProperty(parameter.Key, complexInstance));
}
else
{
result.Add(new PrimitiveProperty(parameter.Key, null, PayloadBuilder.PrimitiveValue(parameter.Value).ClrValue));
}
}
return(result);
}
private static ODataPayloadElement CreatePayloadElement(IEdmModel model, ODataPayloadKind payloadKind, ReaderTestConfiguration testConfig)
{
IEdmEntitySet citySet = model.EntityContainer.FindEntitySet("Cities");
IEdmEntityType cityType = model.EntityTypes().Single(e => e.Name == "CityType");
IEdmProperty cityNameProperty = cityType.Properties().Single(e => e.Name == "Name");
IEdmNavigationProperty policeStationNavProp = cityType.NavigationProperties().Single(e => e.Name == "PoliceStation");
IEdmOperationImport primitiveCollectionResultOperation = model.EntityContainer.FindOperationImports("PrimitiveCollectionResultOperation").Single();
IEdmOperationImport serviceOp1 = model.EntityContainer.FindOperationImports("ServiceOperation1").Single();
bool isRequest = testConfig.IsRequest;
bool isJsonLightRequest = isRequest && testConfig.Format == ODataFormat.Json;
switch (payloadKind)
{
case ODataPayloadKind.Feed:
{
return(PayloadBuilder.EntitySet().WithTypeAnnotation(cityType).ExpectedEntityType(cityType, citySet));
}
case ODataPayloadKind.Entry:
{
return(PayloadBuilder.Entity("TestModel.CityType").PrimitiveProperty("Id", 1).WithTypeAnnotation(cityType).ExpectedEntityType(cityType, citySet));
}
case ODataPayloadKind.Property:
return(PayloadBuilder.PrimitiveProperty(isJsonLightRequest ? string.Empty : null, "SomeCityValue").ExpectedProperty(cityType, "Name"));
case ODataPayloadKind.EntityReferenceLink:
return(PayloadBuilder.DeferredLink("http://odata.org/entityreferencelink").ExpectedNavigationProperty(citySet, cityType, "PoliceStation"));
case ODataPayloadKind.EntityReferenceLinks:
return(PayloadBuilder.LinkCollection().Item(PayloadBuilder.DeferredLink("http://odata.org/entityreferencelink")).ExpectedNavigationProperty((EdmEntitySet)citySet, (EdmEntityType)cityType, "CityHall"));
case ODataPayloadKind.Value:
return(PayloadBuilder.PrimitiveValue("PrimitiveValue"));
case ODataPayloadKind.BinaryValue:
return(PayloadBuilder.PrimitiveValue(new byte[] { 0, 0, 1, 1 }));
case ODataPayloadKind.Collection:
return(PayloadBuilder.PrimitiveCollection().CollectionName(null).ExpectedFunctionImport((EdmOperationImport)primitiveCollectionResultOperation));
case ODataPayloadKind.ServiceDocument:
Debug.Assert(!isRequest, "Not supported in requests.");
return(new ServiceDocumentInstance().Workspace(PayloadBuilder.Workspace()));
case ODataPayloadKind.MetadataDocument:
Debug.Assert(!isRequest, "Not supported in requests.");
throw new NotImplementedException();
case ODataPayloadKind.Error:
Debug.Assert(!isRequest, "Not supported in requests.");
return(PayloadBuilder.Error("ErrorCode"));
case ODataPayloadKind.Parameter:
// build parameter payload based on model definition
var parameterPayload = new ComplexInstance(null, false);
ODataPayloadElement a = PayloadBuilder.PrimitiveValue(123).WithTypeAnnotation(EdmCoreModel.Instance.GetInt32(false));
ODataPayloadElement b = PayloadBuilder.PrimitiveValue("stringvalue").WithTypeAnnotation(EdmCoreModel.Instance.GetString(false));
PrimitiveProperty parametera = new PrimitiveProperty("a", "Edm.Integer", ((PrimitiveValue)a).ClrValue);
PrimitiveProperty parameterb = new PrimitiveProperty("b", "Edm.String", ((PrimitiveValue)b).ClrValue);
parameterPayload.Add(parametera);
parameterPayload.Add(parameterb);
parameterPayload.ExpectedFunctionImport((EdmOperationImport)serviceOp1);
return(parameterPayload);
case ODataPayloadKind.Unsupported: // fall through
default:
throw new NotSupportedException();
}
}
public void BatchReaderMixedEncodingTest()
{
EdmModel model = new EdmModel();
EdmEntityType personType = model.EntityType("Person")
.KeyProperty("Id", EdmCoreModel.Instance.GetInt32(false) as EdmTypeReference)
.Property("Name", EdmPrimitiveTypeKind.String, isNullable: true);
model.Fixup();
EdmEntitySet personSet = model.EntitySet("Person", personType);
EntityInstance personInstance = PayloadBuilder.Entity("TestModel.Person")
.Property("Id", PayloadBuilder.PrimitiveValue(1))
.Property("Name", PayloadBuilder.PrimitiveValue("Mr Foo Baz"));
ODataUriSegment root = ODataUriBuilder.Root(new Uri("http://www.odata.org"));
ODataUri testUri = new ODataUri(root, ODataUriBuilder.EntitySet(personSet));
Encoding[] encodings = new Encoding[]
{
Encoding.UTF8,
Encoding.BigEndianUnicode,
Encoding.Unicode
};
IEnumerable <BatchReaderMixedEncodingTestCase> testCases =
encodings.SelectMany(batchEncoding =>
encodings.Select(changesetEncoding =>
new BatchReaderMixedEncodingTestCase
{
BatchEncoding = batchEncoding,
Changesets = new[]
{
new BatchReaderMixedEncodingChangeset
{
ChangesetEncoding = changesetEncoding,
Operations = new[]
{
new BatchReaderMixedEncodingOperation
{
OperationEncoding = Encoding.Unicode,
PayloadFormat = ODataFormat.Atom,
},
new BatchReaderMixedEncodingOperation
{
// Uses changeset's encoding
PayloadFormat = ODataFormat.Atom,
},
},
},
new BatchReaderMixedEncodingChangeset
{
Operations = new[]
{
new BatchReaderMixedEncodingOperation
{
// Uses batch's encoding
OperationEncoding = batchEncoding,
PayloadFormat = ODataFormat.Atom,
},
},
},
},
}
));
this.CombinatorialEngineProvider.RunCombinations(
testCases,
this.ReaderTestConfigurationProvider.DefaultFormatConfigurations,
(testCase, testConfiguration) =>
{
var testPayload = personInstance.DeepCopy();
if (!testConfiguration.IsRequest)
{
testPayload.AddAnnotation(new PayloadFormatVersionAnnotation()
{
Response = true, ResponseWrapper = true
});
}
var testDescriptor = this.CreateTestDescriptor(testCase, testPayload, testUri, testConfiguration.IsRequest);
testDescriptor.PayloadEdmModel = model;
testDescriptor.RunTest(testConfiguration);
});
}
public void PrimitiveTopLevelValueWithDisabledTypeConversionTest()
{
IEdmModel testModel = TestModels.BuildTestModel();
IEnumerable <ReaderContentTypeTestDescriptor> testDescriptors = primitiveValueConversionTestCases
.SelectMany(testCase => TestValues.PrimitiveTypes
.SelectMany(nonNullableTargetType => new bool[] { true, false }
.SelectMany(includeNullableType => new bool[] { true, false }
.Select(useExpectedType =>
{
PrimitiveDataType targetType = EntityModelUtils.GetPrimitiveEdmType(nonNullableTargetType);
if (includeNullableType)
{
targetType = targetType.Nullable();
}
ODataPayloadElement resultValue;
if (nonNullableTargetType == typeof(byte[]))
{
resultValue = testCase.ConversionValues.Where(cv => cv.ClrValue.GetType() == typeof(byte[])).Single().DeepCopy();
}
else
{
resultValue = testCase.ConversionValues.Where(cv => cv.ClrValue.GetType() == typeof(string)).Single().DeepCopy();
}
ODataPayloadElement payloadElement;
if (useExpectedType)
{
payloadElement = PayloadBuilder.PrimitiveValue(testCase.SourceString).ExpectedPrimitiveValueType(targetType);
}
else
{
payloadElement = PayloadBuilder.PrimitiveValue(testCase.SourceString);
}
return(new ReaderContentTypeTestDescriptor(this.Settings)
{
PayloadElement = payloadElement,
ExpectedResultPayloadElement = (testConfig) => resultValue,
ContentType = ComputeContentType(nonNullableTargetType),
ExpectedFormat = ODataFormat.RawValue,
});
}))));
// add variants that use a metadata provider
testDescriptors = testDescriptors.Concat(testDescriptors.Select(td => new ReaderContentTypeTestDescriptor(td)
{
PayloadEdmModel = testModel
}));
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
// restricting the set of default format configurations to limiti runtime of the tests
this.ReaderTestConfigurationProvider.DefaultFormatConfigurations.Where(tc => tc.MessageReaderSettings.EnableMessageStreamDisposal && !tc.IsRequest),
(testDescriptor, testConfig) =>
{
testConfig = new ReaderTestConfiguration(testConfig);
testConfig.MessageReaderSettings.EnablePrimitiveTypeConversion = false;
testDescriptor.RunTest(testConfig);
});
}
public void EntityReferenceLinkTest()
{
IEdmModel model = Test.OData.Utils.Metadata.TestModels.BuildTestModel();
var cityType = model.FindType("TestModel.CityType");
Debug.Assert(cityType != null, "cityType != null");
// TODO: add test cases that use relative URIs
// Few hand-crafted payloads
IEnumerable <PayloadReaderTestDescriptor> testDescriptors = new PayloadReaderTestDescriptor[]
{
// Single entity reference link for a singleton
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadDescriptor = new PayloadTestDescriptor(),
PayloadElement = PayloadBuilder.Entity("TestModel.CityType").WithTypeAnnotation(cityType)
.Property(PayloadBuilder.NavigationProperty("PoliceStation", "http://odata.org/PoliceStation").IsCollection(false)),
PayloadEdmModel = model
},
// Single entity reference link for a collection
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadDescriptor = new PayloadTestDescriptor(),
PayloadElement = PayloadBuilder.Entity("TestModel.CityType").WithTypeAnnotation(cityType)
.Property(PayloadBuilder.NavigationProperty("CityHall", "http://odata.org/CityHall").IsCollection(true)),
PayloadEdmModel = model
},
// Multiple entity reference links
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadDescriptor = new PayloadTestDescriptor(),
PayloadElement = PayloadBuilder.Entity("TestModel.CityType").WithTypeAnnotation(cityType)
.Property(PayloadBuilder.NavigationProperty("CityHall", "http://odata.org/CityHall").IsCollection(true))
.Property(PayloadBuilder.NavigationProperty("PoliceStation", "http://odata.org/PoliceStation").IsCollection(false)),
PayloadEdmModel = model
},
// Multiple entity reference links with primitive properties in between
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadDescriptor = new PayloadTestDescriptor(),
PayloadElement = PayloadBuilder.Entity("TestModel.CityType").WithTypeAnnotation(cityType)
.Property("Id", PayloadBuilder.PrimitiveValue(1))
.Property(PayloadBuilder.NavigationProperty("CityHall", "http://odata.org/CityHall").IsCollection(true))
.Property("Name", PayloadBuilder.PrimitiveValue("Vienna"))
.Property(PayloadBuilder.NavigationProperty("DOL", "http://odata.org/DOL").IsCollection(true)),
PayloadEdmModel = model
},
};
// Generate interesting payloads around the entry
testDescriptors = testDescriptors.SelectMany(td => this.PayloadGenerator.GenerateReaderPayloads(td));
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
// Entity reference links are request only.
this.ReaderTestConfigurationProvider.ExplicitFormatConfigurations.Where(tc => tc.IsRequest),
(testDescriptor, testConfiguration) =>
{
testDescriptor.RunTest(testConfiguration);
});
}
/// <summary>
/// Creates several PayloadTestDescriptors containing Batch Responses
/// </summary>
/// <param name="requestManager">Used for building the requests/responses.</param>
/// <param name="model">The model to use for adding additional types.</param>
/// <param name="withTypeNames">Whether or not to use full type names.</param>
/// <returns>PayloadTestDescriptors</returns>
public static IEnumerable <PayloadTestDescriptor> CreateBatchResponseTestDescriptors(
IODataRequestManager requestManager,
EdmModel model,
bool withTypeNames = false)
{
EdmEntityType personType = null;
EdmComplexType carType = null;
if (model != null)
{
//TODO: CLONE for EdmModel
//model = model.Clone();
personType = model.FindDeclaredType("TestModel.TFPerson") as EdmEntityType;
carType = model.FindDeclaredType("TestModel.TFCar") as EdmComplexType;
// Create the metadata types for the entity instance used in the entity set
if (carType == null)
{
carType = new EdmComplexType("TestModel", "TFCar");
model.AddElement(carType);
carType.AddStructuralProperty("Make", EdmPrimitiveTypeKind.String, true);
carType.AddStructuralProperty("Color", EdmPrimitiveTypeKind.String, true);
}
if (personType == null)
{
personType = new EdmEntityType("TestModel", "TFPerson");
model.AddElement(personType);
personType.AddKeys(personType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
personType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String, true);
personType.AddStructuralProperty("Car", carType.ToTypeReference());
EdmEntityContainer container = (EdmEntityContainer)model.EntityContainer;
if (container == null)
{
container = new EdmEntityContainer("TestModel", "DefaultContainer");
model.AddElement(container);
container.AddEntitySet("Customers", personType);
container.AddEntitySet("TFPerson", personType);
}
}
}
ComplexInstance carInstance = PayloadBuilder.ComplexValue(withTypeNames ? "TestModel.TFCar" : null)
.Property("Make", PayloadBuilder.PrimitiveValue("Ford"))
.Property("Color", PayloadBuilder.PrimitiveValue("Blue"));
ComplexProperty carProperty = (ComplexProperty)PayloadBuilder.Property("Car", carInstance)
.WithTypeAnnotation(carType);
EntityInstance personInstance = PayloadBuilder.Entity(withTypeNames ? "TestModel.TFPerson" : null)
.Property("Id", PayloadBuilder.PrimitiveValue(1))
.Property("Name", PayloadBuilder.PrimitiveValue("John Doe"))
.Property("Car", carInstance)
.WithTypeAnnotation(personType);
ODataErrorPayload errorInstance = PayloadBuilder.Error("ErrorCode")
.Message("ErrorValue")
.InnerError(
PayloadBuilder.InnerError().Message("InnerErrorMessage").StackTrace("InnerErrorStackTrace").TypeName("InnerErrorTypeName"));
var carPropertyPayload = new PayloadTestDescriptor()
{
PayloadElement = carProperty,
PayloadEdmModel = model
};
var emptyPayload = new PayloadTestDescriptor()
{
PayloadEdmModel = CreateEmptyEdmModel()
};
var personPayload = new PayloadTestDescriptor()
{
// This payload will be serialised to JSON so we need the annotation to mark it as a response.
PayloadElement = personInstance.AddAnnotation(new PayloadFormatVersionAnnotation()
{
Response = true, ResponseWrapper = true
}),
PayloadEdmModel = model
};
var errorPayload = new PayloadTestDescriptor()
{
PayloadElement = errorInstance,
PayloadEdmModel = model,
};
// response operation with a status code of 5 containing a complex instance
var carPropertyPayloadOperation = carPropertyPayload.InResponseOperation(5, requestManager);
// response operation with no payload and a status code of 200
var emptyPayloadOperation = emptyPayload.InResponseOperation(200, requestManager);
// response operation with a status code of 418 containing an entity instance
var personPayloadOperation = personPayload.InResponseOperation(418, requestManager, MimeTypes.ApplicationJsonLight);
// response operation with a status code of 404 containing an error instance
var errorPayloadOperation = errorPayload.InResponseOperation(404, requestManager);
// changeset with multiple operations
var twoOperationsChangeset = BatchUtils.GetResponseChangeset(new IMimePart[] { carPropertyPayloadOperation, emptyPayloadOperation }, requestManager);
// changesets with a single operation
var oneOperationChangeset = BatchUtils.GetResponseChangeset(new IMimePart[] { personPayloadOperation }, requestManager);
var oneErrorChangeset = BatchUtils.GetResponseChangeset(new IMimePart[] { errorPayloadOperation }, requestManager);
// empty changeset
var emptyChangeset = BatchUtils.GetResponseChangeset(new IMimePart[] { }, requestManager);
// Empty Batch
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(new IMimePart[] { })
.AddAnnotation(new BatchBoundaryAnnotation("bb_emptybatch")),
PayloadEdmModel = emptyPayload.PayloadEdmModel,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
// Single Operation
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(new IMimePart[] { carPropertyPayloadOperation })
.AddAnnotation(new BatchBoundaryAnnotation("bb_singleoperation")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
// Multiple Operations
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(new IMimePart[] { carPropertyPayloadOperation, emptyPayloadOperation, errorPayloadOperation, personPayloadOperation })
.AddAnnotation(new BatchBoundaryAnnotation("bb_multipleoperations")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
// Single Changeset
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(new IMimePart[] { twoOperationsChangeset })
.AddAnnotation(new BatchBoundaryAnnotation("bb_singlechangeset")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
// Multiple Changesets
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(new IMimePart[] { twoOperationsChangeset, oneOperationChangeset })
.AddAnnotation(new BatchBoundaryAnnotation("bb_multiplechangesets")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
// Operations and changesets
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(new IMimePart[] { twoOperationsChangeset, carPropertyPayloadOperation, oneOperationChangeset })
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_1")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(new IMimePart[] { carPropertyPayloadOperation, oneOperationChangeset, emptyPayloadOperation })
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_2")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(new IMimePart[] { errorPayloadOperation, carPropertyPayloadOperation, emptyPayloadOperation, twoOperationsChangeset, oneOperationChangeset })
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_3")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
yield return(new PayloadTestDescriptor()
{
PayloadElement = PayloadBuilder.BatchResponsePayload(
new IMimePart[] { oneErrorChangeset, carPropertyPayloadOperation, emptyChangeset, emptyPayloadOperation, twoOperationsChangeset, personPayloadOperation, oneOperationChangeset, errorPayloadOperation })
.AddAnnotation(new BatchBoundaryAnnotation("bb_operationsandchangesets_4")),
PayloadEdmModel = model,
SkipTestConfiguration = (tc) => tc.IsRequest,
});
}
// TODO: Change the payload of null top-level properties #645
public void NonNullablePropertiesWithNullValuesTest()
{
IEnumerable <NonNullablePropertyTest> testCases = new NonNullablePropertyTest[]
{
new NonNullablePropertyTest {
Value = null, DataType = EdmCoreModel.Instance.GetString(false), TypeName = "Edm.String"
},
new NonNullablePropertyTest {
Value = "foo", DataType = EdmCoreModel.Instance.GetString(false), TypeName = "Edm.String"
},
new NonNullablePropertyTest {
Value = null, DataType = EdmCoreModel.Instance.GetBinary(false), TypeName = "Edm.Binary"
},
new NonNullablePropertyTest {
Value = new byte[] { 1, 2, 3 }, DataType = EdmCoreModel.Instance.GetBinary(false), TypeName = "Edm.Binary"
},
new NonNullablePropertyTest {
Value = null, DataType = EdmCoreModel.Instance.GetBoolean(false), TypeName = "Edm.Boolean"
},
new NonNullablePropertyTest {
Value = true, DataType = EdmCoreModel.Instance.GetBoolean(false), TypeName = "Edm.Boolean"
},
new NonNullablePropertyTest {
Value = null, DataType = EdmCoreModel.Instance.GetByte(false), TypeName = "Edm.Byte"
},
new NonNullablePropertyTest {
Value = (byte)1, DataType = EdmCoreModel.Instance.GetByte(false), TypeName = "Edm.Byte"
},
new NonNullablePropertyTest {
Value = null, DataType = EdmCoreModel.Instance.GetDateTimeOffset(false), TypeName = "Edm.DateTimeOffset"
},
new NonNullablePropertyTest {
Value = new DateTimeOffset(new DateTime(2011, 08, 31), TimeSpan.Zero), DataType = EdmCoreModel.Instance.GetDateTimeOffset(false), TypeName = "Edm.DateTimeOffset"
},
new NonNullablePropertyTest {
Value = null, DataType = EdmCoreModel.Instance.GetDecimal(false), TypeName = "Edm.Decimal"
},
new NonNullablePropertyTest {
Value = (decimal)1.0, DataType = EdmCoreModel.Instance.GetDecimal(false), TypeName = "Edm.Decimal"
},
new NonNullablePropertyTest {
Value = null, DataType = EdmCoreModel.Instance.GetDouble(false), TypeName = "Edm.Double"
},
new NonNullablePropertyTest {
Value = (double)1.0, DataType = EdmCoreModel.Instance.GetDouble(false), TypeName = "Edm.Double"
},
new NonNullablePropertyTest {
Value = null, DataType = EdmCoreModel.Instance.GetSingle(false), TypeName = "Edm.Single"
},
new NonNullablePropertyTest {
Value = (float)1.0, DataType = EdmCoreModel.Instance.GetSingle(false), TypeName = "Edm.Single"
},
new NonNullablePropertyTest {
Value = null, DataType = EdmCoreModel.Instance.GetSByte(false), TypeName = "Edm.SByte"
},
new NonNullablePropertyTest {
Value = (sbyte)1, DataType = EdmCoreModel.Instance.GetSByte(false), TypeName = "Edm.SByte"
},
new NonNullablePropertyTest {
Value = null, DataType = EdmCoreModel.Instance.GetInt16(false), TypeName = "Edm.Int16"
},
new NonNullablePropertyTest {
Value = (Int16)1, DataType = EdmCoreModel.Instance.GetInt16(false), TypeName = "Edm.Int16"
},
new NonNullablePropertyTest {
Value = null, DataType = EdmCoreModel.Instance.GetInt32(false), TypeName = "Edm.Int32"
},
new NonNullablePropertyTest {
Value = (Int32)1, DataType = EdmCoreModel.Instance.GetInt32(false), TypeName = "Edm.Int32"
},
new NonNullablePropertyTest {
Value = null, DataType = EdmCoreModel.Instance.GetInt64(false), TypeName = "Edm.Int64"
},
new NonNullablePropertyTest {
Value = (Int64)1, DataType = EdmCoreModel.Instance.GetInt64(false), TypeName = "Edm.Int64"
},
new NonNullablePropertyTest {
Value = null, DataType = EdmCoreModel.Instance.GetGuid(false), TypeName = "Edm.Guid"
},
new NonNullablePropertyTest {
Value = Guid.NewGuid(), DataType = EdmCoreModel.Instance.GetGuid(false), TypeName = "Edm.Guid"
},
};
IEnumerable <PayloadReaderTestDescriptor> testDescriptors =
testCases.Select(testCase => new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.PrimitiveValue(testCase.Value).WithTypeAnnotation(testCase.DataType),
PayloadEdmModel = new EdmModel().Fixup(),
ExpectedException = testCase.Value == null
? ODataExpectedExceptions.ODataException("ReaderValidationUtils_NullNamedValueForNonNullableType", "value", testCase.TypeName)
: null,
});
testDescriptors = testDescriptors.Select(td => td.InProperty("propertyName"));
testDescriptors = testDescriptors.SelectMany(td => this.PayloadGenerator.GenerateReaderPayloads(td));
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.ReaderTestConfigurationProvider.ExplicitFormatConfigurations,
(testDescriptor, testConfiguration) =>
{
if (!(testDescriptor.PayloadElement is PrimitiveProperty) &&
testDescriptor.ExpectedException != null)
{
testDescriptor = new PayloadReaderTestDescriptor(testDescriptor);
testDescriptor.ExpectedException = ODataExpectedExceptions.ODataException(
"ReaderValidationUtils_NullNamedValueForNonNullableType",
"propertyName",
testDescriptor.ExpectedException.ExpectedMessage.Arguments.ElementAt(1));
}
var property = testDescriptor.PayloadElement as PropertyInstance;
testDescriptor.RunTest(testConfiguration);
});
}
/// <summary>
/// Creates a set of interesting entity instances along with metadata.
/// </summary>
/// <param name="settings">The test descriptor settings to use.</param>
/// <param name="model">If non-null, the method creates complex types for the complex values and adds them to the model.</param>
/// <param name="withTypeNames">true if the payloads should specify type names.</param>
/// <returns>List of test descriptors with interesting entity instances as payload.</returns>
public static IEnumerable <PayloadTestDescriptor> CreateEntityInstanceTestDescriptors(
EdmModel model,
bool withTypeNames)
{
IEnumerable <PrimitiveValue> primitiveValues = TestValues.CreatePrimitiveValuesWithMetadata(fullSet: false);
IEnumerable <ComplexInstance> complexValues = TestValues.CreateComplexValues(model, withTypeNames, fullSet: false);
IEnumerable <NamedStreamInstance> streamReferenceValues = TestValues.CreateStreamReferenceValues(fullSet: false);
IEnumerable <PrimitiveMultiValue> primitiveMultiValues = TestValues.CreatePrimitiveCollections(withTypeNames, fullSet: false);
IEnumerable <ComplexMultiValue> complexMultiValues = TestValues.CreateComplexCollections(model, withTypeNames, fullSet: false);
IEnumerable <NavigationPropertyInstance> navigationProperties = TestValues.CreateDeferredNavigationLinks();
// NOTE we have to copy the EntityModelTypeAnnotation on the primitive value to the NullPropertyInstance for null values since the
// NullPropertyInstance does not expose a value. We will later copy it back to the value we generate for the null property.
IEnumerable <PropertyInstance> primitiveProperties =
primitiveValues.Select((pv, ix) => PayloadBuilder.Property("PrimitiveProperty" + ix, pv).CopyAnnotation <PropertyInstance, EntityModelTypeAnnotation>(pv));
IEnumerable <PropertyInstance> complexProperties = complexValues.Select((cv, ix) => PayloadBuilder.Property("ComplexProperty" + ix, cv));
IEnumerable <PropertyInstance> primitiveMultiValueProperties = primitiveMultiValues.Select((pmv, ix) => PayloadBuilder.Property("PrimitiveMultiValueProperty" + ix, pmv));
IEnumerable <PropertyInstance> complexMultiValueProperties = complexMultiValues.Select((cmv, ix) => PayloadBuilder.Property("ComplexMultiValueProperty" + ix, cmv));
PropertyInstance[][] propertyMatrix = new PropertyInstance[6][];
propertyMatrix[0] = primitiveProperties.ToArray();
propertyMatrix[1] = complexProperties.ToArray();
propertyMatrix[2] = streamReferenceValues.ToArray();
propertyMatrix[3] = primitiveMultiValueProperties.ToArray();
propertyMatrix[4] = complexMultiValueProperties.ToArray();
propertyMatrix[5] = navigationProperties.ToArray();
IEnumerable <PropertyInstance[]> propertyCombinations = propertyMatrix.ColumnCombinations(0, 1, 6);
int count = 0;
foreach (PropertyInstance[] propertyCombination in propertyCombinations)
{
// build the entity type, add it to the model
EdmEntityType generatedEntityType = null;
string typeName = "PGEntityType" + count;
EdmEntityContainer container = null;
EdmEntitySet entitySet = null;
if (model != null)
{
// generate a new type with the auto-generated name, check that no type with this name exists and add the default key property to it.
Debug.Assert(model.FindDeclaredType(typeName) == null, "Entity type '" + typeName + "' already exists.");
generatedEntityType = new EdmEntityType("TestModel", typeName);
generatedEntityType.AddKeys(generatedEntityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
model.AddElement(generatedEntityType);
container = model.EntityContainer as EdmEntityContainer;
if (container == null)
{
container = new EdmEntityContainer("TestModel", "DefaultNamespace");
model.AddElement(container);
}
entitySet = container.AddEntitySet(typeName, generatedEntityType);
}
EntityInstance entityInstance = PayloadBuilder.Entity("TestModel." + typeName)
.Property("Id", PayloadBuilder.PrimitiveValue(count).WithTypeAnnotation(EdmCoreModel.Instance.GetInt32(false)));
for (int i = 0; i < propertyCombination.Length; ++i)
{
PropertyInstance currentProperty = propertyCombination[i];
entityInstance.Add(currentProperty);
if (model != null)
{
if (entitySet == null)
{
entitySet = container.FindEntitySet(typeName) as EdmEntitySet;
}
switch (currentProperty.ElementType)
{
case ODataPayloadElementType.ComplexProperty:
ComplexProperty complexProperty = (ComplexProperty)currentProperty;
generatedEntityType.AddStructuralProperty(complexProperty.Name,
complexProperty.Value.GetAnnotation <EntityModelTypeAnnotation>().EdmModelType);
break;
case ODataPayloadElementType.PrimitiveProperty:
PrimitiveProperty primitiveProperty = (PrimitiveProperty)currentProperty;
if (primitiveProperty.Value == null)
{
generatedEntityType.AddStructuralProperty(
primitiveProperty.Name,
PayloadBuilder.PrimitiveValueType(null));
}
else
{
generatedEntityType.AddStructuralProperty(primitiveProperty.Name,
primitiveProperty.Value.GetAnnotation <EntityModelTypeAnnotation>().EdmModelType);
}
break;
case ODataPayloadElementType.NamedStreamInstance:
NamedStreamInstance streamProperty = (NamedStreamInstance)currentProperty;
generatedEntityType.AddStructuralProperty(streamProperty.Name, EdmPrimitiveTypeKind.Stream);
break;
case ODataPayloadElementType.EmptyCollectionProperty:
throw new NotImplementedException();
case ODataPayloadElementType.NavigationPropertyInstance:
NavigationPropertyInstance navigationProperty = (NavigationPropertyInstance)currentProperty;
var navProperty = generatedEntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
ContainsTarget = false,
Name = navigationProperty.Name,
Target = generatedEntityType,
TargetMultiplicity = EdmMultiplicity.One
});
entitySet.AddNavigationTarget(navProperty, entitySet);
break;
case ODataPayloadElementType.ComplexMultiValueProperty:
ComplexMultiValueProperty complexMultiValueProperty = (ComplexMultiValueProperty)currentProperty;
generatedEntityType.AddStructuralProperty(complexMultiValueProperty.Name,
complexMultiValueProperty.Value.GetAnnotation <EntityModelTypeAnnotation>().EdmModelType);
break;
case ODataPayloadElementType.PrimitiveMultiValueProperty:
PrimitiveMultiValueProperty primitiveMultiValueProperty = (PrimitiveMultiValueProperty)currentProperty;
generatedEntityType.AddStructuralProperty(primitiveMultiValueProperty.Name,
primitiveMultiValueProperty.Value.GetAnnotation <EntityModelTypeAnnotation>().EdmModelType);
break;
default:
throw new NotSupportedException("Unsupported element type found : " + propertyCombination[i].ElementType);
}
}
}
if (generatedEntityType != null)
{
entityInstance.AddAnnotation(new EntityModelTypeAnnotation(generatedEntityType.ToTypeReference(true)));
}
yield return(new PayloadTestDescriptor()
{
PayloadElement = entityInstance, PayloadEdmModel = model
});
count++;
}
}
