/// <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); } }