public void CreateCollectionReaderArgumentTest()
{
IEdmEntityType entityType = null;
IEdmComplexType complexType = null;
IEdmModel model = this.CreateTestMetadata(out entityType, out complexType);
IEdmEntityContainer defaultContainer = model.FindEntityContainer("TestNS.TestContainer");
IEdmOperationImport primitiveValueFunctionImport = defaultContainer.FindOperationImports("PrimitiveValueFunctionImport").Single();
IEdmOperationImport collectionOfEntitiesFunctionImport = defaultContainer.FindOperationImports("CollectionOfEntitiesFunctionImport").Single();
this.CombinatorialEngineProvider.RunCombinations(
this.ReaderTestConfigurationProvider.ExplicitFormatConfigurations,
(testConfiguration) =>
{
TestMessage message = TestReaderUtils.CreateInputMessageFromStream(new TestStream(), testConfiguration);
ODataMessageReaderTestWrapper messageReader = TestReaderUtils.CreateMessageReader(message, null, testConfiguration);
this.Assert.ExpectedException(
() => messageReader.CreateODataCollectionReader(new EdmComplexTypeReference(complexType, false)),
ODataExpectedExceptions.ArgumentException("ODataMessageReader_ExpectedTypeSpecifiedWithoutMetadata", "expectedItemTypeReference"),
this.ExceptionVerifier);
messageReader = TestReaderUtils.CreateMessageReader(message, model, testConfiguration);
this.Assert.ExpectedException(
() => messageReader.CreateODataCollectionReader(new EdmEntityTypeReference(entityType, false)),
ODataExpectedExceptions.ArgumentException("ODataMessageReader_ExpectedCollectionTypeWrongKind", "Entity"),
this.ExceptionVerifier);
messageReader = TestReaderUtils.CreateMessageReader(message, model, testConfiguration);
this.Assert.ExpectedException(
() => messageReader.CreateODataCollectionReader(collectionOfEntitiesFunctionImport),
ODataExpectedExceptions.ArgumentException("ODataMessageReader_ExpectedCollectionTypeWrongKind", "Entity"),
this.ExceptionVerifier);
});
}
public void ContentTypeHeaderParsingErrorTest()
{
var testCases = new ContentTypeTestCase[]
{
new ContentTypeTestCase
{
ContentType = null,
ExpectedException = ODataExpectedExceptions.ODataContentTypeException("ODataMessageReader_NoneOrEmptyContentTypeHeader")
},
new ContentTypeTestCase
{
ContentType = string.Empty,
ExpectedException = ODataExpectedExceptions.ODataContentTypeException("ODataMessageReader_NoneOrEmptyContentTypeHeader")
},
new ContentTypeTestCase
{
ContentType = ";foo=bar",
ExpectedException = ODataExpectedExceptions.ODataContentTypeException("HttpUtils_MediaTypeRequiresSlash", ";foo=bar")
},
new ContentTypeTestCase
{
ContentType = "application/*",
ExpectedException = ODataExpectedExceptions.ODataContentTypeException("ODataMessageReader_WildcardInContentType", "application/*")
},
new ContentTypeTestCase
{
ContentType = "*/*",
ExpectedException = ODataExpectedExceptions.ODataContentTypeException("ODataMessageReader_WildcardInContentType", "*/*")
},
new ContentTypeTestCase
{
ContentType = "application/json, application/xml",
ExpectedException = ODataExpectedExceptions.ODataContentTypeException("MediaTypeUtils_NoOrMoreThanOneContentTypeSpecified", "application/json, application/xml")
},
};
this.CombinatorialEngineProvider.RunCombinations(
testCases,
this.ReaderTestConfigurationProvider.AllFormatConfigurations.Where(tc => tc.Format != ODataFormat.Json),
(testCase, testConfiguration) =>
{
// create a message reader and call GetFormat; this should fail with the expected error message
TestMessage testMessage = TestReaderUtils.CreateInputMessageFromStream(new TestStream(), testConfiguration);
testMessage.SetHeader(Microsoft.OData.Core.ODataConstants.ContentTypeHeader, testCase.ContentType);
testMessage.SetHeader(Microsoft.OData.Core.ODataConstants.ContentLengthHeader, testCase.ContentLength.ToString());
TestExceptionUtils.ExpectedException(
this.Assert,
() =>
{
using (ODataMessageReaderTestWrapper messageReader = TestReaderUtils.CreateMessageReader(testMessage, null, testConfiguration))
{
ODataFormat actualFormat = messageReader.DetectPayloadKind().Single().Format;
}
},
testCase.ExpectedException,
this.ExceptionVerifier);
});
}
public void CreateParameterReaderTest()
{
IEdmOperationImport functionImport;
IEdmModel model = this.CreateTestMetadata(out functionImport);
var testConfigurations = this.ReaderTestConfigurationProvider.JsonLightFormatConfigurations.Where(c => c.IsRequest);
this.CombinatorialEngineProvider.RunCombinations(
testConfigurations,
(testConfiguration) =>
{
TestMessage message;
ODataMessageReaderTestWrapper messageReader;
// Specifying a non-null functionImport without an EdmModel should fail.
message = TestReaderUtils.CreateInputMessageFromStream(new TestStream(), testConfiguration, ODataPayloadKind.Parameter, /*customContentTypeHeader*/ null, /*urlResolver*/ null);
messageReader = TestReaderUtils.CreateMessageReader(message, null, testConfiguration);
this.Assert.ExpectedException(
() => messageReader.CreateODataParameterReader(functionImport),
ODataExpectedExceptions.ArgumentException("ODataMessageReader_OperationSpecifiedWithoutMetadata", "operation"),
this.ExceptionVerifier);
// Specifying a null functionImport should fail.
message = TestReaderUtils.CreateInputMessageFromStream(new TestStream(), testConfiguration, ODataPayloadKind.Parameter, /*customContentTypeHeader*/ null, /*urlResolver*/ null);
messageReader = TestReaderUtils.CreateMessageReader(message, model, testConfiguration);
this.Assert.ExpectedException(
() => messageReader.CreateODataParameterReader(null),
ODataExpectedExceptions.ArgumentNullException("ODataJsonLightInputContext_OperationCannotBeNullForCreateParameterReader", "operation"),
this.ExceptionVerifier);
message = TestReaderUtils.CreateInputMessageFromStream(new TestStream(), testConfiguration, ODataPayloadKind.Parameter, /*customContentTypeHeader*/ null, /*urlResolver*/ null);
messageReader = TestReaderUtils.CreateMessageReader(message, model, testConfiguration);
if (testConfiguration.IsRequest)
{
// CreateParameterReader should succeed.
messageReader.CreateODataParameterReader(functionImport);
}
else
{
// CreateODataParameterReader on a response message should fail.
this.Assert.ExpectedException(
() => messageReader.CreateODataParameterReader(functionImport),
ODataExpectedExceptions.ODataException("ODataMessageReader_ParameterPayloadInResponse"),
this.ExceptionVerifier);
}
});
}
public void CreateResourceReaderArgumentTest()
{
IEdmEntityType entityType = null;
IEdmComplexType complexType = null;
IEdmModel model = this.CreateTestMetadata(out entityType, out complexType);
this.CombinatorialEngineProvider.RunCombinations(
this.ReaderTestConfigurationProvider.ExplicitFormatConfigurations,
(testConfiguration) =>
{
TestMessage message = TestReaderUtils.CreateInputMessageFromStream(new TestStream(), testConfiguration);
ODataMessageReaderTestWrapper messageReader = TestReaderUtils.CreateMessageReader(message, null, testConfiguration);
this.Assert.ExpectedException(
() => messageReader.CreateODataResourceReader(entityType),
ODataExpectedExceptions.ArgumentException("ODataMessageReader_ExpectedTypeSpecifiedWithoutMetadata", "resourceType"),
this.ExceptionVerifier);
});
}
/// <summary>
/// Called to create the input message for the reader test.
/// </summary>
/// <param name="testConfiguration">The test configuration.</param>
/// <returns>The newly created test message to use.</returns>
protected override TestMessage CreateInputMessage(ReaderTestConfiguration testConfiguration)
{
bool originalApplyTransformValue = false;
var odataTransformFactory = this.settings.PayloadTransformFactory as ODataLibPayloadTransformFactory;
try
{
if (this.ApplyPayloadTransformations.HasValue && odataTransformFactory != null)
{
originalApplyTransformValue = odataTransformFactory.ApplyTransform;
odataTransformFactory.ApplyTransform = this.ApplyPayloadTransformations.Value;
}
MemoryStream memoryStream = new MemoryStream(TestReaderUtils.GetPayload(testConfiguration, this.PayloadNormalizers, this.settings, this.PayloadElement));
TestStream messageStream = new BatchReaderTestStream(memoryStream);
if (testConfiguration.Synchronous)
{
messageStream.FailAsynchronousCalls = true;
}
else
{
messageStream.FailSynchronousCalls = true;
}
TestMessage testMessage = TestReaderUtils.CreateInputMessageFromStream(
messageStream,
testConfiguration,
this.PayloadElement.GetPayloadKindFromPayloadElement(),
this.PayloadElement.GetCustomContentTypeHeader(),
this.UrlResolver);
return(testMessage);
}
finally
{
if (this.ApplyPayloadTransformations.HasValue && odataTransformFactory != null)
{
odataTransformFactory.ApplyTransform = originalApplyTransformValue;
}
}
}
/// <summary>
/// Creates an ODataParameterReader with the given input.
/// </summary>
/// <param name="model">Model containing the function import.</param>
/// <param name="functionImport">function import whose parameters are being read.</param>
/// <param name="testConfiguration">test configuration.</param>
/// <param name="payload">optional parameter payload.</param>
/// <returns>Returns the created ODataParameterReader</returns>
internal static ODataParameterReaderTestWrapper CreateODataParameterReader(IEdmModel model, IEdmOperationImport functionImport, ReaderTestConfiguration testConfiguration, string payload = null)
{
// TODO: ODataLib test item: Add new ODataPayloadElement for parameters payload
// Once the bug is fixed, we should generate the parameters payload from the new ODataPayloadElement to make
// tests in this file format agnostic.
TestStream messageStream;
if (payload != null)
{
messageStream = new TestStream(new MemoryStream(Encoding.UTF8.GetBytes(payload)));
}
else
{
messageStream = new TestStream();
}
TestMessage message = TestReaderUtils.CreateInputMessageFromStream(messageStream, testConfiguration, ODataPayloadKind.Parameter, /*customContentTypeHeader*/ null, /*urlResolver*/ null);
ODataMessageReaderTestWrapper messageReader = TestReaderUtils.CreateMessageReader(message, model, testConfiguration);
return(messageReader.CreateODataParameterReader(functionImport));
}
protected override TestMessage CreateInputMessage(ReaderTestConfiguration testConfiguration)
{
MemoryStream memoryStream = new MemoryStream(this.RawMessage);
TestStream messageStream = new TestStream(memoryStream);
if (testConfiguration.Synchronous)
{
messageStream.FailAsynchronousCalls = true;
}
else
{
messageStream.FailSynchronousCalls = true;
}
TestMessage testMessage = TestReaderUtils.CreateInputMessageFromStream(
messageStream,
testConfiguration,
this.PayloadElement.GetPayloadKindFromPayloadElement(),
this.BatchContentTypeHeader,
this.UrlResolver);
return(testMessage);
}
public void ReadPropertyArgumentTest()
{
IEdmEntityType entityType = null;
IEdmComplexType complexType = null;
IEdmModel model = this.CreateTestMetadata(out entityType, out complexType);
IEdmEntityContainer container = model.FindEntityContainer("TestContainer");
IEdmOperationImport entityValueFunctionImport = container.FindOperationImports("EntityValueFunctionImport").Single();
IEdmOperationImport entityCollectionValueFunctionImport = container.FindOperationImports("CollectionOfEntitiesFunctionImport").Single();
IEdmStructuralProperty entityValueStructuralProperty = (IEdmStructuralProperty)complexType.FindProperty("EntityProp");
IEdmStructuralProperty entityCollectionValueStructuralProperty = (IEdmStructuralProperty)complexType.FindProperty("EntityCollectionProp");
this.CombinatorialEngineProvider.RunCombinations(
this.ReaderTestConfigurationProvider.ExplicitFormatConfigurations,
(testConfiguration) =>
{
TestMessage message = TestReaderUtils.CreateInputMessageFromStream(new TestStream(), testConfiguration);
ODataMessageReaderTestWrapper messageReader = TestReaderUtils.CreateMessageReader(message, null, testConfiguration);
this.Assert.ExpectedException(
() => messageReader.ReadProperty(new EdmComplexTypeReference(complexType, false)),
ODataExpectedExceptions.ArgumentException("ODataMessageReader_ExpectedTypeSpecifiedWithoutMetadata", "expectedPropertyTypeReference"),
this.ExceptionVerifier);
messageReader = TestReaderUtils.CreateMessageReader(message, model, testConfiguration);
this.Assert.ExpectedException(
() => messageReader.ReadProperty(new EdmEntityTypeReference(entityType, false)),
ODataExpectedExceptions.ArgumentException("ODataMessageReader_ExpectedPropertyTypeEntityKind"),
this.ExceptionVerifier);
messageReader = TestReaderUtils.CreateMessageReader(message, model, testConfiguration);
this.Assert.ExpectedException(
() => messageReader.ReadProperty(new EdmCollectionType(new EdmEntityTypeReference(entityType, false)).ToTypeReference()),
ODataExpectedExceptions.ArgumentException("ODataMessageReader_ExpectedPropertyTypeEntityCollectionKind"),
this.ExceptionVerifier);
messageReader = TestReaderUtils.CreateMessageReader(message, model, testConfiguration);
this.Assert.ExpectedException(
() => messageReader.ReadProperty(entityValueFunctionImport),
ODataExpectedExceptions.ArgumentException("ODataMessageReader_ExpectedPropertyTypeEntityKind"),
this.ExceptionVerifier);
messageReader = TestReaderUtils.CreateMessageReader(message, model, testConfiguration);
this.Assert.ExpectedException(
() => messageReader.ReadProperty(entityCollectionValueFunctionImport),
ODataExpectedExceptions.ArgumentException("ODataMessageReader_ExpectedPropertyTypeEntityCollectionKind"),
this.ExceptionVerifier);
messageReader = TestReaderUtils.CreateMessageReader(message, model, testConfiguration);
this.Assert.ExpectedException(
() => messageReader.ReadProperty(entityValueStructuralProperty),
ODataExpectedExceptions.ArgumentException("ODataMessageReader_ExpectedPropertyTypeEntityKind"),
this.ExceptionVerifier);
messageReader = TestReaderUtils.CreateMessageReader(message, model, testConfiguration);
this.Assert.ExpectedException(
() => messageReader.ReadProperty(entityCollectionValueStructuralProperty),
ODataExpectedExceptions.ArgumentException("ODataMessageReader_ExpectedPropertyTypeEntityCollectionKind"),
this.ExceptionVerifier);
});
}
public void BatchContentTypeHeaderParsingTest()
{
IEnumerable <ContentTypeTestCase> testCases = new ContentTypeTestCase[]
{
// correct batch content type
new ContentTypeTestCase
{
ContentType = "multipart/mixed;boundary=--aa_bb_cc--",
ExpectedFormat = ODataFormat.Batch,
},
// missing batch boundary
new ContentTypeTestCase
{
ContentType = "multipart/mixed",
ExpectedFormat = ODataFormat.Batch,
ExpectedException = ODataExpectedExceptions.ODataException("MediaTypeUtils_BoundaryMustBeSpecifiedForBatchPayloads", "multipart/mixed", "boundary")
},
// multiple batch boundary parameters
new ContentTypeTestCase
{
ContentType = "multipart/mixed;boundary=boundary1;boundary=boundary2",
ExpectedFormat = ODataFormat.Batch,
ExpectedException = ODataExpectedExceptions.ODataException("MediaTypeUtils_BoundaryMustBeSpecifiedForBatchPayloads", "multipart/mixed;boundary=boundary1;boundary=boundary2", "boundary")
},
// invalid batch content types
new ContentTypeTestCase
{
ContentType = "multipart/bar",
ExpectedFormat = ODataFormat.Batch,
ExpectedException = ODataExpectedExceptions.ODataContentTypeException("MediaTypeUtils_CannotDetermineFormatFromContentType", TestMediaTypeUtils.GetSupportedMediaTypes(ODataPayloadKind.Batch), "multipart/bar")
},
new ContentTypeTestCase
{
ContentType = "foo/mixed",
ExpectedFormat = ODataFormat.Batch,
ExpectedException = ODataExpectedExceptions.ODataContentTypeException("MediaTypeUtils_CannotDetermineFormatFromContentType", TestMediaTypeUtils.GetSupportedMediaTypes(ODataPayloadKind.Batch), "foo/mixed")
},
new ContentTypeTestCase
{
ContentType = "abc/pqr",
ExpectedFormat = ODataFormat.Batch,
ExpectedException = ODataExpectedExceptions.ODataContentTypeException("MediaTypeUtils_CannotDetermineFormatFromContentType", TestMediaTypeUtils.GetSupportedMediaTypes(ODataPayloadKind.Batch), "abc/pqr")
},
new ContentTypeTestCase
{
ContentType = ApplicationJson,
ExpectedFormat = ODataFormat.Batch,
ExpectedException = ODataExpectedExceptions.ODataContentTypeException("MediaTypeUtils_CannotDetermineFormatFromContentType", TestMediaTypeUtils.GetSupportedMediaTypes(ODataPayloadKind.Batch), ApplicationJson)
}
};
this.CombinatorialEngineProvider.RunCombinations(
testCases,
this.ReaderTestConfigurationProvider.DefaultFormatConfigurations,
(testCase, testConfiguration) =>
{
// create a message reader and call GetFormat; this should fail with the expected error message
TestMessage testMessage = TestReaderUtils.CreateInputMessageFromStream(new TestStream(), testConfiguration);
testMessage.SetHeader(Microsoft.OData.Core.ODataConstants.ContentTypeHeader, testCase.ContentType);
TestExceptionUtils.ExpectedException(
this.Assert,
() =>
{
using (ODataMessageReaderTestWrapper messageReader = TestReaderUtils.CreateMessageReader(testMessage, null, testConfiguration))
{
messageReader.CreateODataBatchReader();
ODataFormat actualFormat = ODataUtils.GetReadFormat(messageReader.MessageReader);
this.Assert.AreEqual(testCase.ExpectedFormat, actualFormat, "Formats don't match.");
}
},
testCase.ExpectedException,
this.ExceptionVerifier);
});
}