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 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;
ODataResourceSet feed;
ODataResource entry;
if (collectionStart != null)
{
ODataCollectionWriter collectionWriter = parameterWriter.CreateCollectionWriter(parameter.Key);
this.WriteCollection(collectionWriter, collectionStart);
collectionWriter.Flush();
}
else if ((feed = parameter.Value as ODataResourceSet) != null)
{
this.WriteFeed(parameterWriter.CreateResourceSetWriter(parameter.Key), feed);
}
else if ((entry = parameter.Value as ODataResource) != null)
{
this.WriteEntry(parameterWriter.CreateResourceWriter(parameter.Key), entry);
}
else
{
parameterWriter.WriteValue(parameter.Key, parameter.Value);
}
}
parameterWriter.WriteEnd();
parameterWriter.Flush();
}
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);
}
/// <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)
{
Debug.Assert(this.messageStream != null, "Streaming test stream must have been created.");
TestMessage testMessage = this.CreateInputMessageFromStream((TestStream)this.messageStream, testConfiguration, this.PayloadKind, string.Empty, this.UrlResolver);
testMessage.SetContentType(testConfiguration.Format, this.PayloadKind);
Exception exception = TestExceptionUtils.RunCatching(() =>
{
ODataMessageReaderSettings readerSettings = this.settings.MessageReaderSettings.Clone();
readerSettings.EnableMessageStreamDisposal = testConfiguration.MessageWriterSettings.EnableMessageStreamDisposal;
ReaderTestConfiguration readerConfig = new ReaderTestConfiguration(
testConfiguration.Format,
readerSettings,
testConfiguration.IsRequest,
testConfiguration.Synchronous);
IEdmModel model = this.GetMetadataProvider();
using (ODataMessageReaderTestWrapper messageReaderWrapper = TestReaderUtils.CreateMessageReader(testMessage, model, readerConfig))
{
ODataPayloadElementToObjectModelConverter payloadElementToOMConverter = new ODataPayloadElementToObjectModelConverter(!testConfiguration.IsRequest);
ObjectModelToPayloadElementConverter reverseConverter = new ObjectModelToPayloadElementConverter();
ObjectModelWriteReadStreamer streamer = new ObjectModelWriteReadStreamer();
this.readObject = reverseConverter.Convert(streamer.WriteMessage(messageWriter, messageReaderWrapper, this.PayloadKind, payloadElementToOMConverter.Convert(this.PayloadElement)), !testConfiguration.IsRequest);
}
});
}
private void InvokeWriterAction(ODataMessageWriterTestWrapper messageWriter, ODataWriter writer, WriterAction writerAction)
{
switch (writerAction)
{
case WriterAction.StartResource:
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 WriteCollection(ODataMessageWriterTestWrapper messageWriter, ODataCollectionStart collection)
{
ODataCollectionWriter collectionWriter = messageWriter.CreateODataCollectionWriter();
this.WriteCollection(collectionWriter, collection);
collectionWriter.Flush();
}
private void WriteTopLevelEntry(ODataMessageWriterTestWrapper messageWriter, ODataResource entry)
{
ExceptionUtilities.CheckArgumentNotNull(messageWriter, "messageWriter");
ODataWriter entryWriter = messageWriter.CreateODataResourceWriter();
this.WriteEntry(entryWriter, entry);
entryWriter.Flush();
}
public override void RunTest(ReaderTestConfiguration testConfiguration)
{
//TODO: Use Logger to verify result, right now this change is only to unblock writer testcase checkin
BaselineLogger logger = null;
if (this.ShouldSkipForTestConfiguration(testConfiguration))
{
return;
}
var originalPayload = this.PayloadElement;
this.PayloadElement = this.PayloadElement.DeepCopy();
// Create messages (payload gets serialized in createInputMessage)
TestMessage readerMessage = this.CreateInputMessage(testConfiguration);
var settings = new ODataMessageWriterSettings()
{
Version = testConfiguration.Version,
BaseUri = testConfiguration.MessageReaderSettings.BaseUri,
EnableMessageStreamDisposal = testConfiguration.MessageReaderSettings.EnableMessageStreamDisposal,
};
settings.SetContentType(testConfiguration.Format);
WriterTestConfiguration writerConfig = new WriterTestConfiguration(testConfiguration.Format, settings, testConfiguration.IsRequest, testConfiguration.Synchronous);
TestMessage writerMessage = TestWriterUtils.CreateOutputMessageFromStream(new TestStream(new MemoryStream()), writerConfig, this.PayloadKind, String.Empty, this.UrlResolver);
IEdmModel model = this.GetMetadataProvider(testConfiguration);
WriterTestExpectedResults expectedResult = this.GetExpectedResult(writerConfig);
ExceptionUtilities.Assert(expectedResult != null, "The expected result could not be determined for the test. Did you specify it?");
Exception exception = TestExceptionUtils.RunCatching(() =>
{
using (ODataMessageReaderTestWrapper messageReaderWrapper = TestReaderUtils.CreateMessageReader(readerMessage, model, testConfiguration))
using (ODataMessageWriterTestWrapper messageWriterWrapper = TestWriterUtils.CreateMessageWriter(writerMessage, model, writerConfig, this.settings.Assert))
{
var streamer = new ObjectModelReadWriteStreamer();
streamer.StreamMessage(messageReaderWrapper, messageWriterWrapper, this.PayloadKind, writerConfig);
expectedResult.VerifyResult(writerMessage, this.PayloadKind, writerConfig, logger);
}
});
this.PayloadElement = originalPayload;
try
{
expectedResult.VerifyException(exception);
}
catch (Exception)
{
this.TraceFailureInformation(testConfiguration);
throw;
}
}
private void WriteTopLevelFeed(ODataMessageWriterTestWrapper messageWriter, ODataResourceSet feed)
{
ExceptionUtilities.CheckArgumentNotNull(messageWriter, "messageWriter");
var feedWriter = messageWriter.CreateODataResourceSetWriter();
this.WriteFeed(feedWriter, feed);
feedWriter.Flush();
}
/// <summary>
/// Creates an ODataWriter for the specified format and the specified version and
/// writes the property in the descriptor to an in-memory stream. It then parses
/// the written Xml and compares it to the expected result as specified in the descriptor.
/// </summary>
/// <param name="originalPayload">The payload to first clone and then write.</param>
/// <param name="testConfiguration">Configuration for the test</param>
/// <param name="model">The model to use.</param>
protected void WriteAndVerifyODataProperty(ODataPayloadElement originalPayload, WriterTestConfiguration testConfiguration, IEdmModel model)
{
this.Logger.LogConfiguration(testConfiguration);
this.Logger.LogModelPresence(model);
using (var memoryStream = new TestStream())
{
TestMessage testMessage;
using (ODataMessageWriterTestWrapper writer = TestWriterUtils.CreateMessageWriter(memoryStream, testConfiguration, this.Assert, out testMessage, null, model))
{
Action <ODataPayloadElement> writeElementToStream = payload => this.PropertyPayloadElementWriter.WriteProperty(writer.MessageWriter, payload);
this.WriteAndLogODataPayload(originalPayload, writer.Message, testConfiguration.Version, testConfiguration.Format, writeElementToStream);
}
}
}
/// <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());
}
/// <summary>
/// Runs the test specified by this test descriptor.
/// </summary>
/// <param name="testConfiguration">The test configuration to use for running the test.</param>
public override 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, this.PayloadElement);
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(() =>
{
// We create a new test configuration for batch because the payload indicates whether we are dealing with a request or a response and the configuration won't know that in advance
var newTestConfig = new WriterTestConfiguration(testConfiguration.Format, testConfiguration.MessageWriterSettings, this.PayloadElement is BatchRequestPayload, testConfiguration.Synchronous);
using (ODataMessageWriterTestWrapper messageWriterWrapper = TestWriterUtils.CreateMessageWriter(message, model, newTestConfig, this.settings.Assert, null))
{
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 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>
/// Runs the test specified by this test descriptor.
/// </summary>
/// <param name="testConfiguration">The test configuration to use for running the test.</param>
public override void RunTest(WriterTestConfiguration testConfiguration, BaselineLogger logger = null)
{
//TODO: Use Logger to verify result, right now this change is only to unblock writer testcase checkin
if (this.ShouldSkipForTestConfiguration(testConfiguration))
{
return;
}
// Generate a StreamingTestStream with a NonDisposingStream.
this.messageStream = new StreamingTestStream(new NonDisposingStream(new MemoryStream()));
TestMessage message = this.CreateOutputMessage(this.messageStream, testConfiguration);
IEdmModel model = this.GetMetadataProvider();
StreamingWriterTestExpectedResults expectedResult = (StreamingWriterTestExpectedResults)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.ObservedElement = this.readObject;
expectedResult.VerifyResult(message, this.PayloadKind, testConfiguration);
}
});
try
{
expectedResult.VerifyException(exception);
}
catch (Exception failureException)
{
this.TraceFailureInformation(message, this.messageStream, testConfiguration);
throw failureException;
}
}
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>
/// 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.ResourceSet:
this.WriteTopLevelFeed(messageWriter, (ODataResourceSet)payload);
break;
case ODataPayloadKind.Resource:
this.WriteTopLevelEntry(messageWriter, (ODataResource)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 WriteError(ODataMessageWriterTestWrapper messageWriter, ODataError error, bool debug)
{
messageWriter.WriteError(error, debug);
}
private void WriteMetadataDocument(ODataMessageWriterTestWrapper messageWriter)
{
messageWriter.WriteMetadataDocument();
}
private void WriteServiceDocument(ODataMessageWriterTestWrapper messageWriter, ODataServiceDocument serviceDocument)
{
messageWriter.WriteServiceDocument(serviceDocument);
}
/// <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();
}
}
/// <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();
}
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);
}
