/// <summary> /// Called to write the payload to the specified <paramref name="messageWriter"/>. /// </summary> /// <param name="messageWriter">The <see cref="ODataMessageWriterTestWrapper"/> to use for writing the payload.</param> /// <param name="testConfiguration">The test configuration to generate the payload for.</param> protected override void WritePayload(ODataMessageWriterTestWrapper messageWriter, WriterTestConfiguration testConfiguration) { ODataPayloadElement payload = this.PayloadElement.DeepCopy(); if (testConfiguration.Format == ODataFormat.Json) { payload.Accept(new ODataPayloadJsonNormalizer()); //Fixup added as odatalib requires ids on feeds even though it can't be represented in json payload.Accept(new AddFeedIDFixup()); } else if (testConfiguration.Format == ODataFormat.Atom) { // TODO: Remove visitor payload.Accept(new ODataPayloadElementNullIDVisitor()); } ODataPayloadElementToObjectModelConverter converter = new ODataPayloadElementToObjectModelConverter(!testConfiguration.IsRequest); if (this.PayloadKind != ODataPayloadKind.Batch) { this.settings.ObjectModelToMessageWriter.WriteMessage(messageWriter, this.PayloadKind, converter.Convert(payload)); } else { TestWriterUtils.WriteBatchPayload(messageWriter, payload, converter, this.settings.ObjectModelToMessageWriter, this.Model, this.settings.Assert, testConfiguration, true); } }
/// <summary> /// Write payload kind to message. /// </summary> /// <param name="messageWriter">Message writer to write payload to.</param> /// <param name="payloadKind">The kind of payload we are writing.</param> /// <param name="payload">The payload to write.</param> /// <param name="functionImport">Function import whose parameters are to be written when the payload kind is Parameters.</param> /// <returns>The object read after writing.</returns> public ODataItem WriteMessage(ODataMessageWriterTestWrapper messageWriter, ODataMessageReaderTestWrapper messageReader, ODataPayloadKind payloadKind, object payload, IEdmOperationImport functionImport = null) { ExceptionUtilities.CheckArgumentNotNull(messageWriter, "messageWriter"); ExceptionUtilities.CheckArgumentNotNull(messageReader, "messageReader"); switch (payloadKind) { case ODataPayloadKind.Feed: this.WriteTopLevelFeed(messageWriter, messageReader, (ODataFeed)payload); break; case ODataPayloadKind.Entry: this.WriteTopLevelEntry(messageWriter, messageReader, (ODataEntry)payload); break; default: ExceptionUtilities.Assert(false, "The payload kind '{0}' is not yet supported by ObjectModelWriteReadStreamer.", payloadKind); break; } return readItems.SingleOrDefault(); }
public void StreamMessage(ODataMessageReaderTestWrapper reader, ODataMessageWriterTestWrapper writer, ODataPayloadKind payloadKind, WriterTestConfiguration config) { ExceptionUtilities.CheckArgumentNotNull(reader, "reader is required"); ExceptionUtilities.CheckArgumentNotNull(writer, "writer is required"); ExceptionUtilities.CheckArgumentNotNull(payloadKind, "payloadKind is required"); ExceptionUtilities.CheckArgumentNotNull(config, "config is required"); this.testConfiguration = config; switch(payloadKind) { case ODataPayloadKind.Entry: this.StartRead(reader.CreateODataEntryReader(), writer.CreateODataEntryWriter()); break; case ODataPayloadKind.Feed: this.StartRead(reader.CreateODataFeedReader(), writer.CreateODataFeedWriter()); break; default: throw new NotSupportedException("ObjectModelReadWriteStreamer currently supports only feed and entry"); }; }
/// <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; } }
/// <summary> /// Writes the collection payload as specified in the <paramref name="testDescriptor"/>. /// </summary> /// <param name="messageWriter">The message writer.</param> /// <param name="writer">The writer to write to.</param> /// <param name="flush">True if the stream should be flush before returning; otherwise false.</param> /// <param name="testDescriptor">The test descriptor specifying the collection to write.</param> internal static void WriteCollectionPayload(ODataMessageWriterTestWrapper messageWriter, ODataCollectionWriter writer, bool flush, CollectionWriterTestDescriptor testDescriptor) { Debug.Assert(writer != null, "writer != null"); Debug.Assert(testDescriptor != null, "testDescriptor != null"); object[] payloadItems = testDescriptor.PayloadItems; int payloadItemIndex = 0; foreach (CollectionWriterTestDescriptor.WriterInvocations invocation in testDescriptor.Invocations) { switch (invocation) { case CollectionWriterTestDescriptor.WriterInvocations.StartCollection: ODataCollectionStartSerializationInfo serInfo = null; if (!string.IsNullOrEmpty(testDescriptor.CollectionTypeName)) { serInfo = new ODataCollectionStartSerializationInfo(); serInfo.CollectionTypeName = testDescriptor.CollectionTypeName; } writer.WriteStart(new ODataCollectionStart { Name = testDescriptor.CollectionName, SerializationInfo = serInfo }); break; case CollectionWriterTestDescriptor.WriterInvocations.Item: object payloadItem = payloadItems[payloadItemIndex]; ODataError error = payloadItem as ODataError; if (error != null) { throw new InvalidOperationException("Expected payload item but found an error."); } writer.WriteItem(payloadItem); payloadItemIndex++; break; case CollectionWriterTestDescriptor.WriterInvocations.Error: ODataAnnotatedError error2 = testDescriptor.PayloadItems[payloadItemIndex] as ODataAnnotatedError; if (error2 == null) { throw new InvalidOperationException("Expected an error but found a payload item."); } messageWriter.WriteError(error2.Error, error2.IncludeDebugInformation); payloadItemIndex++; break; case CollectionWriterTestDescriptor.WriterInvocations.EndCollection: writer.WriteEnd(); break; case CollectionWriterTestDescriptor.WriterInvocations.UserException: throw new Exception("User code triggered an exception."); default: break; } } if (flush) { writer.Flush(); } }
private void InvokeCollectionWriterAction(ODataMessageWriterTestWrapper messageWriter, ODataCollectionWriter writer, CollectionWriterAction writerAction) { switch (writerAction) { case CollectionWriterAction.Start: writer.WriteStart(new ODataCollectionStart { Name = "foo" }); break; case CollectionWriterAction.Item: writer.WriteItem(42); break; case CollectionWriterAction.End: writer.WriteEnd(); break; case CollectionWriterAction.Error: messageWriter.WriteError(new ODataError(), false); break; } }
/// <summary> /// Called to write the payload to the specified <paramref name="messageWriter"/>. /// </summary> /// <param name="messageWriter">The <see cref="ODataMessageWriterTestWrapper"/> to use for writing the payload.</param> protected abstract void WritePayload(ODataMessageWriterTestWrapper messageWriter, WriterTestConfiguration config);
private void WriteTopLevelFeed(ODataMessageWriterTestWrapper messageWriter, ODataMessageReaderTestWrapper messageReader, ODataFeed feed) { var feedWriter = messageWriter.CreateODataFeedWriter(); Lazy<ODataReader> lazyReader = new Lazy<ODataReader>(() => messageReader.CreateODataFeedReader()); this.WriteFeed(feedWriter, lazyReader, feed); }
private void InvokeWriterAction(ODataMessageWriterTestWrapper messageWriter, ODataWriter writer, WriterAction writerAction) { switch (writerAction) { case WriterAction.StartEntry: writer.WriteStart(ObjectModelUtils.CreateDefaultEntry()); break; case WriterAction.StartFeed: writer.WriteStart(ObjectModelUtils.CreateDefaultFeed()); break; case WriterAction.StartLink: writer.WriteStart(ObjectModelUtils.CreateDefaultCollectionLink()); break; case WriterAction.End: writer.WriteEnd(); break; case WriterAction.Error: messageWriter.WriteError(new ODataError(), false); break; } }
private void WriteParameters(ODataMessageWriterTestWrapper messageWriter, ODataParameters parameters, IEdmOperationImport functionImport) { ODataParameterWriter parameterWriter = messageWriter.CreateODataParameterWriter(functionImport); parameterWriter.WriteStart(); foreach (var parameter in parameters) { ODataCollectionStart collectionStart = parameter.Value as ODataCollectionStart; ODataFeed feed; ODataEntry entry; if (collectionStart != null) { ODataCollectionWriter collectionWriter = parameterWriter.CreateCollectionWriter(parameter.Key); this.WriteCollection(collectionWriter, collectionStart); collectionWriter.Flush(); } else if ((feed = parameter.Value as ODataFeed) != null) { this.WriteFeed(parameterWriter.CreateFeedWriter(parameter.Key), feed); } else if ((entry = parameter.Value as ODataEntry) != null) { this.WriteEntry(parameterWriter.CreateEntryWriter(parameter.Key), entry); } else { parameterWriter.WriteValue(parameter.Key, parameter.Value); } } parameterWriter.WriteEnd(); parameterWriter.Flush(); }
private void WriteCollection(ODataMessageWriterTestWrapper messageWriter, ODataCollectionStart collection) { ODataCollectionWriter collectionWriter = messageWriter.CreateODataCollectionWriter(); this.WriteCollection(collectionWriter, collection); collectionWriter.Flush(); }
private void WriteValue(ODataMessageWriterTestWrapper messageWriter, object value) { messageWriter.WriteValue(value); }
private void WriteEntityReferenceLinks(ODataMessageWriterTestWrapper messageWriter, ODataEntityReferenceLinks referenceLinks) { messageWriter.WriteEntityReferenceLinks(referenceLinks); }
public void WriteEntityReferenceLink(ODataMessageWriterTestWrapper messageWriter, ODataEntityReferenceLink referenceLink) { messageWriter.WriteEntityReferenceLink(referenceLink); }
private void WriteTopLevelEntry(ODataMessageWriterTestWrapper messageWriter, ODataEntry entry) { ExceptionUtilities.CheckArgumentNotNull(messageWriter, "messageWriter"); ODataWriter entryWriter = messageWriter.CreateODataEntryWriter(); this.WriteEntry(entryWriter, entry); entryWriter.Flush(); }
public void NullStreamMessageTest() { IEdmModel model = Microsoft.Test.OData.Utils.Metadata.TestModels.BuildTestModel(); this.CombinatorialEngineProvider.RunCombinations( writerActionsForPayloadKinds, this.WriterTestConfigurationProvider.ExplicitFormatConfigurations, (writerInvocation, testConfiguration) => { if (!writerInvocation.PayloadKind.IsSupported(testConfiguration)) { return; } ODataMessageWriter messageWriter; if (testConfiguration.IsRequest) { messageWriter = new ODataMessageWriter(new NullStreamRequestMessage(), testConfiguration.MessageWriterSettings, model); } else { messageWriter = new ODataMessageWriter(new NullStreamResponseMessage(), testConfiguration.MessageWriterSettings, model); } using (ODataMessageWriterTestWrapper messageWriterWrapper = new ODataMessageWriterTestWrapper(messageWriter, testConfiguration)) { this.Assert.ExpectedException( () => TestExceptionUtils.UnwrapAggregateException(() => writerInvocation.WriterAction(messageWriterWrapper), this.Assert), testConfiguration.IsRequest ? ODataExpectedExceptions.ODataException("ODataRequestMessage_MessageStreamIsNull") : ODataExpectedExceptions.ODataException("ODataResponseMessage_MessageStreamIsNull"), this.ExceptionVerifier); } }); }
public void NullStreamTaskMessageTest() { this.CombinatorialEngineProvider.RunCombinations( writerActionsForPayloadKinds, this.WriterTestConfigurationProvider.ExplicitFormatConfigurations.Where(tc => !tc.Synchronous), (writerInvocation, testConfiguration) => { if (!writerInvocation.PayloadKind.IsSupported(testConfiguration)) { return; } ODataMessageWriter messageWriter; if (testConfiguration.IsRequest) { messageWriter = new ODataMessageWriter(new NullStreamTaskRequestMessage(), testConfiguration.MessageWriterSettings); } else { messageWriter = new ODataMessageWriter(new NullStreamTaskResponseMessage(), testConfiguration.MessageWriterSettings); } using (ODataMessageWriterTestWrapper messageWriterWrapper = new ODataMessageWriterTestWrapper(messageWriter, testConfiguration)) { this.Assert.ExpectedException( () => TestExceptionUtils.UnwrapAggregateException(() => writerInvocation.WriterAction(messageWriterWrapper), this.Assert), testConfiguration.IsRequest ? ODataExpectedExceptions.ODataException("ODataRequestMessage_StreamTaskIsNull") : ODataExpectedExceptions.ODataException("ODataResponseMessage_StreamTaskIsNull"), this.ExceptionVerifier); } }); }
private void WriteServiceDocument(ODataMessageWriterTestWrapper messageWriter, ODataServiceDocument serviceDocument) { messageWriter.WriteServiceDocument(serviceDocument); }
private void WriteMetadataDocument(ODataMessageWriterTestWrapper messageWriter) { messageWriter.WriteMetadataDocument(); }
private void WriteError(ODataMessageWriterTestWrapper messageWriter, ODataError error, bool debug) { messageWriter.WriteError(error, debug); }
/// <summary> /// Write payload kind to message. /// </summary> /// <param name="messageWriter">Message writer to write payload to.</param> /// <param name="payloadKind">The kind of payload we are writing.</param> /// <param name="payload">The payload to write.</param> /// <param name="model">The model used for writing the payloads.</param> /// <param name="functionImport">Function import whose parameters are to be written when the payload kind is Parameters.</param> public virtual void WriteMessage( ODataMessageWriterTestWrapper messageWriter, ODataPayloadKind payloadKind, object payload, IEdmModel model = null, IEdmOperationImport functionImport = null) { ExceptionUtilities.CheckArgumentNotNull(messageWriter, "messageReader"); switch (payloadKind) { case ODataPayloadKind.Property: messageWriter.WriteProperty((ODataProperty)payload); break; case ODataPayloadKind.Feed: this.WriteTopLevelFeed(messageWriter, (ODataFeed)payload); break; case ODataPayloadKind.Entry: this.WriteTopLevelEntry(messageWriter, (ODataEntry)payload); break; case ODataPayloadKind.Collection: this.WriteCollection(messageWriter, (ODataCollectionStart)payload); break; case ODataPayloadKind.ServiceDocument: this.WriteServiceDocument(messageWriter, (ODataServiceDocument)payload); break; case ODataPayloadKind.MetadataDocument: this.WriteMetadataDocument(messageWriter); break; case ODataPayloadKind.Error: this.WriteError(messageWriter, (ODataError)payload, true); break; case ODataPayloadKind.EntityReferenceLink: this.WriteEntityReferenceLink(messageWriter, (ODataEntityReferenceLink)payload); break; case ODataPayloadKind.EntityReferenceLinks: this.WriteEntityReferenceLinks(messageWriter, (ODataEntityReferenceLinks)payload); break; case ODataPayloadKind.Value: this.WriteValue(messageWriter, payload); break; case ODataPayloadKind.Batch: // TODO: Have to figure out product representation of batch payloads or perhaps keep it separate throw new NotSupportedException("Batch not supported in ObjectModelToMessageWriter"); case ODataPayloadKind.Parameter: this.WriteParameters(messageWriter, (ODataParameters)payload, functionImport); break; default: ExceptionUtilities.Assert(false, "The payload kind '{0}' is not yet supported by MessageToObjectModelReader.", payloadKind); break; } }
private void WriteTopLevelEntry(ODataMessageWriterTestWrapper messageWriter, ODataMessageReaderTestWrapper messageReader, ODataEntry entry) { ODataWriter entryWriter = messageWriter.CreateODataEntryWriter(); Lazy<ODataReader> lazyEntryReader = new Lazy<ODataReader>(() => messageReader.CreateODataEntryReader()); this.WriteEntry(entryWriter, lazyEntryReader, entry); }
private void WriteTopLevelFeed(ODataMessageWriterTestWrapper messageWriter, ODataFeed feed) { ExceptionUtilities.CheckArgumentNotNull(messageWriter, "messageWriter"); var feedWriter = messageWriter.CreateODataFeedWriter(); this.WriteFeed(feedWriter, feed); feedWriter.Flush(); }
/// <summary> /// Called to write the payload to the specified <paramref name="messageWriter"/>. /// </summary> /// <param name="messageWriter">The <see cref="ODataMessageWriterTestWrapper"/> to use for writing the payload.</param> protected override void WritePayload(ODataMessageWriterTestWrapper messageWriter, WriterTestConfiguration config) { Debug.Assert(messageWriter != null, "messageWriter != null"); messageWriter.WriteMetadataDocument(); }