/// <summary>
/// Creates an <see cref="ODataCollectionWriter"/> for the specified format and the specified version and
/// invokes the specified methods on it. It then parses
/// the written Xml/JSON and compares it to the expected result as specified in the descriptor.
/// </summary>
/// <param name="descriptor">The test descriptor to process.</param>
/// <param name="testConfiguration">The configuration of the test.</param>
/// <param name="assert">The assertion handler to report errors to.</param>
/// <param name="baselineLogger">Logger to log baseline.</param>
internal static void WriteAndVerifyCollectionPayload(CollectionWriterTestDescriptor descriptor, WriterTestConfiguration testConfiguration, AssertionHandler assert, BaselineLogger baselineLogger)
{
baselineLogger.LogConfiguration(testConfiguration);
baselineLogger.LogModelPresence(descriptor.Model);
// serialize to a memory stream
using (var memoryStream = new MemoryStream())
using (var testMemoryStream = new TestStream(memoryStream, ignoreDispose: true))
{
TestMessage testMessage = null;
Exception exception = TestExceptionUtils.RunCatching(() =>
{
using (var messageWriter = TestWriterUtils.CreateMessageWriter(testMemoryStream, testConfiguration, assert, out testMessage, null, descriptor.Model))
{
IEdmTypeReference itemTypeReference = descriptor.ItemTypeParameter;
ODataCollectionWriter writer = itemTypeReference == null
? messageWriter.CreateODataCollectionWriter()
: messageWriter.CreateODataCollectionWriter(itemTypeReference);
WriteCollectionPayload(messageWriter, writer, true, descriptor);
}
});
exception = TestExceptionUtils.UnwrapAggregateException(exception, assert);
WriterTestExpectedResults expectedResults = descriptor.ExpectedResultCallback(testConfiguration);
TestWriterUtils.ValidateExceptionOrLogResult(testMessage, testConfiguration, expectedResults, exception, assert, descriptor.TestDescriptorSettings.ExpectedResultSettings.ExceptionVerifier, baselineLogger);
TestWriterUtils.ValidateContentType(testMessage, expectedResults, true, assert);
}
}
public void FatalExceptionTest()
{
ODataResource entry = ObjectModelUtils.CreateDefaultEntry();
this.CombinatorialEngineProvider.RunCombinations(
new ODataItem[] { entry },
new bool[] { true, false }, // flush
// TODO: also enable this test for the sync scenarios
this.WriterTestConfigurationProvider.ExplicitFormatConfigurations.Where(tc => !tc.Synchronous),
(payload, flush, testConfiguration) =>
{
testConfiguration = testConfiguration.Clone();
testConfiguration.MessageWriterSettings.SetServiceDocumentUri(ServiceDocumentUri);
using (var memoryStream = new TestStream())
using (var messageWriter = TestWriterUtils.CreateMessageWriter(memoryStream, testConfiguration, this.Assert))
{
ODataWriter writer = messageWriter.CreateODataWriter(isFeed: false);
ODataWriterCoreInspector inspector = new ODataWriterCoreInspector(writer);
// close the memory stream so that any attempt to flush will cause a fatal error
memoryStream.CloseInner();
// write the payload and call FlushAsync() to trigger a fatal exception
Exception ex = TestExceptionUtils.RunCatching(() => TestWriterUtils.WritePayload(messageWriter, writer, true, entry));
this.Assert.IsNotNull(ex, "Expected exception but none was thrown.");
NotSupportedException notSupported = null;
#if SILVERLIGHT || WINDOWS_PHONE
var baseEx = ex.GetBaseException();
this.Assert.IsNotNull(baseEx, "BaseException of exception:" + ex.ToString() + " should not be null");
notSupported = baseEx as NotSupportedException;
this.Assert.IsNotNull(notSupported, "Expected NotSupportedException but " + baseEx.GetType().FullName + " was reported.");
#else
notSupported = TestExceptionUtils.UnwrapAggregateException(ex, this.Assert) as NotSupportedException;
this.Assert.IsNotNull(notSupported, "Expected NotSupportedException but " + ex.ToString() + " was reported.");
#endif
this.Assert.AreEqual("Stream does not support writing.", notSupported.Message, "Did not find expected error message.");
this.Assert.IsTrue(inspector.IsInErrorState, "Writer is not in expected 'Error' state.");
if (flush)
{
// Flush should work in error state.
writer.Flush();
}
// in all cases we have to be able to dispose the writer without problems.
}
});
}
/// <summary>
/// Verifies that the test correctly threw an exception.
/// </summary>
/// <param name="exception">null if the test didn't throw, the exception thrown by the test otherwise.</param>
public virtual void VerifyException(Exception exception)
{
exception = TestExceptionUtils.UnwrapAggregateException(exception, this.settings.Assert);
if (this.ExpectedException != null)
{
this.settings.Assert.IsNotNull(exception,
"Expected exception of type '{0}' with message resource ID '{1}' but none was thrown.",
this.ExpectedException.ExpectedExceptionType.ToString(),
this.ExpectedException.ExpectedMessage == null ? "<null>" : this.ExpectedException.ExpectedMessage.ResourceIdentifier);
this.settings.ExceptionVerifier.VerifyExceptionResult(this.ExpectedException, exception);
}
else
{
this.settings.Assert.IsNull(exception, "Unexpected exception was thrown: {0}", (exception == null) ? string.Empty : exception.ToString());
}
}
public void WriteAfterExceptionTest()
{
// create a default entry and then set both read and edit links to null to provoke an exception during writing
ODataResource faultyEntry = ObjectModelUtils.CreateDefaultEntry();
this.Assert.IsNull(faultyEntry.EditLink, "entry.EditLink == null");
ODataResource defaultEntry = ObjectModelUtils.CreateDefaultEntry();
ODataResourceSet defaultFeed = ObjectModelUtils.CreateDefaultFeed();
this.CombinatorialEngineProvider.RunCombinations(
new ODataItem[] { faultyEntry },
new ODataItem[] { defaultFeed, defaultEntry },
this.WriterTestConfigurationProvider.ExplicitFormatConfigurations,
(faultyPayload, contentPayload, testConfiguration) =>
{
testConfiguration = testConfiguration.Clone();
testConfiguration.MessageWriterSettings.SetServiceDocumentUri(ServiceDocumentUri);
using (var memoryStream = new TestStream())
using (var messageWriter = TestWriterUtils.CreateMessageWriter(memoryStream, testConfiguration, this.Assert))
{
ODataWriter writer = messageWriter.CreateODataWriter(isFeed: false);
ODataWriterCoreInspector inspector = new ODataWriterCoreInspector(writer);
// write the invalid entry and expect an exception
this.Assert.ExpectedException(
() => TestWriterUtils.WritePayload(messageWriter, writer, false, faultyEntry),
ODataExpectedExceptions.ODataException("WriterValidationUtils_EntriesMustHaveNonEmptyId"),
this.ExceptionVerifier);
this.Assert.IsTrue(inspector.IsInErrorState, "Writer is not in expected 'error' state.");
// now write some non-error content which is invalid to do
Exception ex = TestExceptionUtils.RunCatching(() => TestWriterUtils.WritePayload(messageWriter, writer, false, contentPayload));
ex = TestExceptionUtils.UnwrapAggregateException(ex, this.Assert);
this.Assert.IsNotNull(ex, "Expected exception but none was thrown");
this.Assert.IsTrue(ex is ODataException, "Expected an ODataException instance but got a " + ex.GetType().FullName + ".");
this.Assert.IsTrue(ex.Message.Contains("Cannot transition from state 'Error' to state "), "Did not find expected start of error message.");
this.Assert.IsTrue(ex.Message.Contains("Nothing can be written once the writer entered the error state."), "Did not find expected end of error message in '" + ex.Message + "'.");
this.Assert.IsTrue(inspector.IsInErrorState, "Writer is not in expected 'error' state.");
writer.Flush();
}
});
}
/// <summary>
/// Verifies that the test correctly threw an exception.
/// </summary>
/// <param name="exception">null if the test didn't throw, the exception thrown by the test otherwise.</param>
public virtual void VerifyException(Exception exception)
{
exception = TestExceptionUtils.UnwrapAggregateException(exception, this.settings.Assert);
if (this.ExpectedException2 != null)
{
this.settings.ExceptionVerifier.VerifyExceptionResult(this.ExpectedException2, exception);
}
else if (this.ExpectedException != null)
{
this.settings.Assert.IsExpectedException <Exception>(exception, this.ExpectedException.Message);
}
else if (this.ExpectedODataErrorException != null)
{
this.settings.Assert.IsExpectedException <ODataErrorException>(exception, this.ExpectedODataErrorException.Message);
this.settings.Assert.IsTrue(ODataObjectModelValidationUtils.AreEqual(this.ExpectedODataErrorException.Error, ((ODataErrorException)exception).Error), "Expected ODataError instances to be equal.");
}
else
{
this.settings.Assert.IsExpectedException <ODataException>(exception, this.ExpectedODataExceptionMessage);
}
}