/// <summary> /// Copy constructor. /// </summary> /// <param name="other">The <see cref="WriterTestExpectedResults"/> instance to copy.</param> public WriterTestExpectedResults(WriterTestExpectedResults other) { ExceptionUtilities.CheckArgumentNotNull(other, "other"); this.settings = other.settings; this.ExpectedContentType = other.ExpectedContentType; this.ExpectedException = other.ExpectedException; this.ExpectedException2 = other.ExpectedException2; this.ExpectedODataErrorException = other.ExpectedODataErrorException; this.ExpectedODataExceptionMessage = other.ExpectedODataExceptionMessage; }
/// <summary> /// Copy constructor. /// </summary> /// <param name="other">The <see cref="WriterTestExpectedResults"/> instance to copy.</param> public WriterTestExpectedResults(WriterTestExpectedResults other) { ExceptionUtilities.CheckArgumentNotNull(other, "other"); this.settings = other.settings; this.ExpectedContentType = other.ExpectedContentType; this.ExpectedException = other.ExpectedException; this.ExpectedException2 = other.ExpectedException2; this.ExpectedODataErrorException = other.ExpectedODataErrorException; this.ExpectedODataExceptionMessage = other.ExpectedODataExceptionMessage; }
/// <summary> /// Called to get the expected result of the test. /// </summary> /// <param name="testConfiguration">The test configuration to use.</param> /// <returns>The expected result.</returns> protected override WriterTestExpectedResults GetExpectedResult(WriterTestConfiguration testConfiguration) { WriterTestExpectedResults expectedResult = base.GetExpectedResult(testConfiguration); if (expectedResult == null) { throw new NotImplementedException(); } else { return(expectedResult); } }
/// <summary> /// Creates the expected result callback by computing the expected Xml and JSON responses /// based on the expected results for the items in a collection. /// </summary> /// <param name="collectionName">The name of the collection.</param> /// <param name="itemDescriptions">The items descriptions to created the expected result for.</param> /// <param name="errorOnly">A flag indicating whether we are writing only error items or not.</param> /// <param name="assert">The assertion handler to use.</param> /// <returns> /// A <see cref="PayloadWriterTestDescriptor.WriterTestExpectedResultCallback"/> that will be used /// during test execution to validate the results. /// </returns> internal static PayloadWriterTestDescriptor.WriterTestExpectedResultCallback CreateExpectedResultCallback( string collectionName, CollectionWriterTestDescriptor.ItemDescription[] itemDescriptions, bool errorOnly, WriterTestExpectedResults.Settings settings) { CollectionWriterTestDescriptor.ItemDescription[] items = itemDescriptions; bool writeCollection = items != null; items = items ?? new CollectionWriterTestDescriptor.ItemDescription[0]; string xmlResultTemplate, jsonLightResultTemplate; CreateResultTemplates(writeCollection, items, out xmlResultTemplate, out jsonLightResultTemplate); return (testConfiguration) => { if (testConfiguration.Format == ODataFormat.Atom) { return new AtomWriterTestExpectedResults(settings) { Xml = PopulateXmlResultTemplate(collectionName, xmlResultTemplate), FragmentExtractor = (result) => NormalizeNamespacePrefixes(result), }; } else if (testConfiguration.Format == ODataFormat.Json) { return new JsonWriterTestExpectedResults(settings) { Json = jsonLightResultTemplate, FragmentExtractor = (result) => errorOnly ? result.Object().PropertyValue(JsonLightConstants.ODataErrorPropertyName) : result.Object().PropertyValue("value"), }; } else { throw new NotSupportedException("Unsupported format " + testConfiguration.Format.ToString() + " found."); } }; }
/// <summary> /// Runs the test specified by this test descriptor. /// </summary> /// <param name="testConfiguration">The test configuration to use for running the test.</param> public virtual void RunTest(WriterTestConfiguration testConfiguration, BaselineLogger logger) { if (this.ShouldSkipForTestConfiguration(testConfiguration)) { return; } // Wrap the memory stream in a non-disposing stream so we can dump the message content // even in the case of a failure where the message stream normally would get disposed. logger.LogConfiguration(testConfiguration); logger.LogModelPresence(this.Model); this.messageStream = new NonDisposingStream(new MemoryStream()); TestMessage message = this.CreateOutputMessage(this.messageStream, testConfiguration); IEdmModel model = this.GetMetadataProvider(); WriterTestExpectedResults expectedResult = this.GetExpectedResult(testConfiguration); ExceptionUtilities.Assert(expectedResult != null, "The expected result could not be determined for the test. Did you specify it?"); Exception exception = TestExceptionUtils.RunCatching(() => { using (ODataMessageWriterTestWrapper messageWriterWrapper = TestWriterUtils.CreateMessageWriter(message, model, testConfiguration, this.settings.Assert)) { this.WritePayload(messageWriterWrapper, testConfiguration); expectedResult.VerifyResult(message, this.PayloadKind, testConfiguration, logger); } }); try { expectedResult.VerifyException(exception); } catch (Exception failureException) { this.TraceFailureInformation(message, this.messageStream, testConfiguration); throw failureException; } }
private static PayloadWriterTestDescriptor.WriterTestExpectedResultCallback CreateErrorResultCallback( ExpectedException expectedException, ODataFormat onlyForFormat, WriterTestExpectedResults.Settings expectedResultSettings) { return testConfiguration => { if (onlyForFormat != null && testConfiguration.Format != onlyForFormat) { return null; } return new WriterTestExpectedResults(expectedResultSettings) { // Replace the expected exception for requests where an ODataException is expected ExpectedException2 = testConfiguration.IsRequest && (expectedException != null && expectedException.ExpectedExceptionType.Equals(typeof(ODataException))) ? ODataExpectedExceptions.ODataException("ODataMessageWriter_ServiceDocumentInRequest") : expectedException, }; }; }
/// <summary> /// Creates the expected result callback by setting the expected exception message(s). /// </summary> /// <param name="collectionName">The name of the collection.</param> /// <param name="expectedExceptionFunc">A func to compute the expected exception from the writer test configuration.</param> /// <param name="settings">The settings to use.</param> /// <returns> /// A <see cref="PayloadWriterTestDescriptor.WriterTestExpectedResultCallback"/> that will be used /// during test execution to validate the results. /// </returns> internal static PayloadWriterTestDescriptor.WriterTestExpectedResultCallback CreateExpectedErrorResultCallback( string collectionName, Func<WriterTestConfiguration, ExpectedException> expectedExceptionFunc, WriterTestExpectedResults.Settings settings) { return (testConfiguration) => { if (testConfiguration.Format == ODataFormat.Atom) { return new AtomWriterTestExpectedResults(settings) { FragmentExtractor = (result) => NormalizeNamespacePrefixes(result), ExpectedException2 = expectedExceptionFunc(testConfiguration) }; } else if (testConfiguration.Format == ODataFormat.Json) { return new JsonWriterTestExpectedResults(settings) { FragmentExtractor = (result) => JsonUtils.UnwrapTopLevelValue(testConfiguration, result), ExpectedException2 = expectedExceptionFunc(testConfiguration) }; } else { throw new NotSupportedException("Unsupported format " + testConfiguration.Format.ToString() + " found."); } }; }
private static PayloadWriterTestDescriptor.WriterTestExpectedResultCallback CreateErrorResultCallback( string expectedErrorMessage, object value, WriterTestExpectedResults.Settings expectedResultSettings) { return testConfiguration => { return new WriterTestExpectedResults(expectedResultSettings) { ExpectedODataExceptionMessage = testConfiguration.Format != null ? (value == null ? expectedErrorMessage : "A default MIME type could not be found for the requested payload in format 'Atom'.") : expectedErrorMessage }; }; }
private static PayloadWriterTestDescriptor.WriterTestExpectedResultCallback CreateExpectedResultCallback( InvocationAndOperationDescriptor[] invocationsAndOperationDescriptors, Dictionary<string, string> expectedHeaders, WriterTestExpectedResults.Settings settings) { return (testConfiguration) => { if (testConfiguration.Format != null && testConfiguration.Format != ODataFormat.Batch) { throw new NotSupportedException("Unsupported format " + testConfiguration.Format.ToString() + " for writing batch messages found."); } return new BatchWriterTestExpectedResults(settings) { ExpectedContentType = "multipart/mixed", InvocationsAndOperationDescriptors = invocationsAndOperationDescriptors, ExpectedHeaders = expectedHeaders, }; }; }
private static PayloadWriterTestDescriptor.WriterTestExpectedResultCallback CreateExpectedErrorResultCallback( string expectedExceptionMessage, Exception exception, ExpectedException expectedException, WriterTestExpectedResults.Settings settings) { return (testConfiguration) => { string errorMessage = expectedExceptionMessage; Exception error = exception; return new BatchWriterTestExpectedResults(settings) { ExpectedODataExceptionMessage = errorMessage, ExpectedException = error, ExpectedException2 = expectedException, }; }; }