[Ignore] // Remove Atom
// [TestMethod, Variation(Description = "Test feed payloads.")]
public void TaupoTopLevelFeedTest()
{
EntitySetInstance entitySet = new EntitySetInstance(PayloadGenerator.GenerateAtomPayloads().First())
.WithDefaultAtomFeedAnnotations();
this.CombinatorialEngineProvider.RunCombinations(
new[] { entitySet },
this.WriterTestConfigurationProvider.AtomFormatConfigurationsWithIndent,
(testCase, testConfiguration) =>
{
WriterTestConfiguration newConfiguration = testConfiguration.Clone();
newConfiguration.MessageWriterSettings.SetServiceDocumentUri(ServiceDocumentUri);
this.WriteAndVerifyODataPayloadElement(testCase, newConfiguration);
});
// The ID annotation is added for JSON as even though JSON has no way to represent the ID ODataLib requires it.
entitySet = new EntitySetInstance(PayloadGenerator.GenerateJsonPayloads().ToArray()).WithDefaultAtomIDAnnotation();
// TODO: Fix places where we've lost JsonVerbose coverage to add JsonLight
//this.CombinatorialEngineProvider.RunCombinations(
// new[] { entitySet },
// this.WriterTestConfigurationProvider.JsonLightFormatConfigurationsWithIndent,
// (testCase, testConfiguration) =>
// {
// this.WriteAndVerifyODataPayloadElement(testCase, testConfiguration);
// });
}
/// <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)
{
ODataErrorException errorException = null;
Exception regularException = null;
if (this.ExpectedException != null)
{
errorException = this.ExpectedException as ODataErrorException;
regularException = errorException == null ? this.ExpectedException : null;
}
return(new MetadataWriterTestExpectedResult(this.settings.ExpectedResultSettings)
{
EdmVersion = this.EdmVersion,
ExpectedException = regularException,
ExpectedODataErrorException = errorException,
ExpectedODataExceptionMessage = this.ExpectedODataExceptionMessage,
});
}
else
{
return(expectedResult);
}
}
private void InvokeBatchWriterAction(
ODataBatchWriterTestWrapper writer,
BatchWriterAction writerAction,
WriterTestConfiguration testConfiguration,
bool readOperationReady,
BatchWriterStatesTestSetupResult setupResult)
{
switch (writerAction)
{
case BatchWriterAction.StartBatch:
writer.WriteStartBatch();
break;
case BatchWriterAction.EndBatch:
writer.WriteEndBatch();
break;
case BatchWriterAction.StartChangeset:
writer.WriteStartChangeset();
break;
case BatchWriterAction.EndChangeset:
writer.WriteEndChangeset();
break;
case BatchWriterAction.Operation:
if (testConfiguration.IsRequest)
{
writer.CreateOperationRequestMessage(readOperationReady ? "GET" : "POST", new Uri("http://odata.org"), "4");
}
else
{
writer.CreateOperationResponseMessage();
}
break;
case BatchWriterAction.GetOperationStream:
GetOperationStream(setupResult == null ? null : setupResult.Message, testConfiguration);
break;
case BatchWriterAction.DisposeOperationStream:
Stream s = setupResult == null ? null : setupResult.MessageStream;
if (s != null)
{
try
{
s.Dispose();
}
catch (ObjectDisposedException e)
{
// Replace the disposed exception with OData exception so that our type checks work correctly.
// No need to verify that the Dispose thrown the right type of the exception.
throw new ODataException(e.Message);
}
}
break;
}
}
/// <summary>
/// Unwraps top-level multiple JSON results from the "d" and/or "results" wrappers as appropriate depending on <paramref name="testConfiguration"/>.
/// </summary>
/// <param name="testConfiguration">The test configuration to consider.</param>
/// <param name="value">The value to unwrap.</param>
/// <returns>Unwrapped value.</returns>
public static JsonValue UnwrapTopLevelResults(WriterTestConfiguration testConfiguration, JsonValue value)
{
value = UnwrapTopLevelValue(testConfiguration, value);
value = GetFeedItemsArray(testConfiguration, value);
TrimSurroundingWhitespaces(value);
return(value);
}
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;
}
}
/// <summary>
/// Called before the test is actually executed for the specified test configuration to determine if the test should be skipped.
/// </summary>
/// <param name="testConfiguration">The test configuration to use.</param>
/// <returns>true if the test should be skipped for the <paramref name="testConfiguration"/> or false to run the test.</returns>
/// <remarks>Derived classes should always call the base class and return true if the base class returned true.</remarks>
protected override bool ShouldSkipForTestConfiguration(WriterTestConfiguration testConfiguration)
{
if (this.SkipTestConfiguration != null)
{
return(this.SkipTestConfiguration(testConfiguration));
}
else
{
return(false);
}
}
protected WriterTestExpectedResults GetExpectedResult(WriterTestConfiguration testConfiguration)
{
if (this.ExpectedResultCallback != null)
{
return(this.ExpectedResultCallback(testConfiguration));
}
else
{
return(null);
}
}
/// <summary>
/// Gets the JSON array holding the entries of the given feed.
/// </summary>
/// <param name="testConfiguration">The test configuration to consider.</param>
/// <param name="feed">The JSON value representing the feed.</param>
/// <returns>A JSON array with the items in a feed.</returns>
public static JsonArray GetFeedItemsArray(WriterTestConfiguration testConfiguration, JsonValue feed)
{
if (!testConfiguration.IsRequest)
{
feed = feed.Object().PropertyValue("results");
ExceptionUtilities.CheckObjectNotNull(feed, "The specified JSON payload is not wrapped in the expected \"results\": wrapper.");
}
ExceptionUtilities.Assert(feed.JsonType == JsonValueType.JsonArray, "Feed contents must be an array.");
return((JsonArray)feed);
}
/// <summary>
/// Unwraps top-level JSON payload from the "d" wrapper as appropriate depending on <paramref name="testConfiguration"/>.
/// </summary>
/// <param name="testConfiguration">The test configuration to consider.</param>
/// <param name="value">The value to unwrap.</param>
/// <returns>Unwrapped value.</returns>
public static JsonValue UnwrapTopLevelValue(WriterTestConfiguration testConfiguration, JsonValue value)
{
if (!testConfiguration.IsRequest)
{
value = value.Object().PropertyValue("d");
ExceptionUtilities.CheckObjectNotNull(value, "The specified JSON payload is not wrapped in the expected \"d\":{{}} wrapper.");
}
TrimSurroundingWhitespaces(value);
return(value);
}
private TestMessage CreateOutputMessage(Stream innerStream, WriterTestConfiguration testConfiguration, ODataPayloadElement payload)
{
TestStream messageStream = new TestStream(innerStream);
TestWriterUtils.SetFailAsynchronousCalls(messageStream, testConfiguration.Synchronous);
var boundary = this.PayloadElement.GetAnnotation <BatchBoundaryAnnotation>();
// 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);
TestMessage testMessage = TestWriterUtils.CreateOutputMessageFromStream(messageStream, newTestConfig, this.PayloadKind, boundary.BatchBoundaryInHeader, this.UrlResolver);
return(testMessage);
}
/// <summary>
/// Verifies that the result of the test is what the test expected.
/// </summary>
/// <param name="stream">The stream after writing the message content. This method should use it
/// to read the message content and verify it.</param>
/// <param name="payloadKind">The payload kind specified in the test descriptor.</param>
/// <param name="testConfiguration">The test configuration to use.</param>
public override void VerifyResult(
TestMessage message,
ODataPayloadKind payloadKind,
WriterTestConfiguration testConfiguration,
BaselineLogger logger)
{
this.settings.Assert.IsTrue(payloadKind == ODataPayloadKind.MetadataDocument, "Only metadata payload kind is supported.");
// read the message content using the Taupo infrastructure
ExceptionUtilities.CheckArgumentNotNull(message.TestStream, "stream != null");
var observed = TestWriterUtils.ReadToString(message);
if (logger != null)
{
logger.LogPayload(TestWriterUtils.BaseLineFixup(observed));
}
}
/// <summary>
/// Compute the resulting string representation of a URI in a given test configuration.
/// </summary>
/// <param name="uri">The URI to convert to string.</param>
/// <param name="testConfig">The test configuration to use.</param>
/// <returns>The string representation of the <paramref name="uri"/> for the given test configuration.</returns>
private string GetResultUri(Uri uri, WriterTestConfiguration testConfig)
{
Uri baseUri = testConfig.MessageWriterSettings.BaseUri;
Debug.Assert(testConfig.Format == ODataFormat.Json, "Only ATOM and JSON lite are supported.");
if (uri.IsAbsoluteUri)
{
return(uri.AbsoluteUri);
}
else if (baseUri != null)
{
// In JSON we expect the absolute URI if a base URI is present
return(new Uri(baseUri, uri).AbsoluteUri);
}
else
{
// This will fail; return the original relative URI.
return(uri.OriginalString);
}
}
public void RawPrimitiveValueTests()
{
var testCases = new PayloadWriterTestDescriptor <object> []
{
new PayloadWriterTestDescriptor <object>(this.Settings, (object)(double)1, "1", null, TextPlainContentType), // double
new PayloadWriterTestDescriptor <object>(this.Settings, (object)new byte[] { 0, 1, 0, 1 }, (string)null, new byte[] { 0, 1, 0, 1 }, ApplicationOctetStreamContentType), // binary
new PayloadWriterTestDescriptor <object>(this.Settings, (object)(Single)1, "1", (byte[])null, TextPlainContentType), // single
new PayloadWriterTestDescriptor <object>(this.Settings, (object)true, "true", (byte[])null, TextPlainContentType), // boolean
new PayloadWriterTestDescriptor <object>(this.Settings, (object)(byte)1, "1", (byte[])null, TextPlainContentType), // byte
new PayloadWriterTestDescriptor <object>(this.Settings, (object)DateTimeOffset.Parse("2010-10-10T10:10:10Z"), "2010-10-10T10:10:10Z", (byte[])null, TextPlainContentType), // DateTimeOffset
new PayloadWriterTestDescriptor <object>(this.Settings, (object)DateTimeOffset.Parse("2010-10-10T10:10:10+01:00"), "2010-10-10T10:10:10+01:00", (byte[])null, TextPlainContentType), // DateTimeOffset (2)
new PayloadWriterTestDescriptor <object>(this.Settings, (object)DateTimeOffset.Parse("2010-10-10T10:10:10-08:00"), "2010-10-10T10:10:10-08:00", (byte[])null, TextPlainContentType), // DateTimeOffset (3)
new PayloadWriterTestDescriptor <object>(this.Settings, (object)(decimal)1, "1", (byte[])null, TextPlainContentType), // Decimal
new PayloadWriterTestDescriptor <object>(this.Settings, (object)new Guid("11111111-2222-3333-4444-555555555555"), "11111111-2222-3333-4444-555555555555", (byte[])null, TextPlainContentType), // Guid
new PayloadWriterTestDescriptor <object>(this.Settings, (object)(sbyte)1, "1", (byte[])null, TextPlainContentType), // SByte
new PayloadWriterTestDescriptor <object>(this.Settings, (object)(Int16)1, "1", (byte[])null, TextPlainContentType), // Int16
new PayloadWriterTestDescriptor <object>(this.Settings, (object)(Int32)1, "1", (byte[])null, TextPlainContentType), // Int32
new PayloadWriterTestDescriptor <object>(this.Settings, (object)(Int64)1, "1", (byte[])null, TextPlainContentType), // Int64
new PayloadWriterTestDescriptor <object>(this.Settings, (object)"1", "1", (byte[])null, TextPlainContentType), // string
new PayloadWriterTestDescriptor <object>(this.Settings, (object)TimeSpan.FromMinutes(12.34), "PT12M20.4S", (byte[])null, TextPlainContentType), // Duration
new PayloadWriterTestDescriptor <object>(this.Settings, (object)string.Empty, string.Empty, (byte[])null, TextPlainContentType), // empty
};
this.CombinatorialEngineProvider.RunCombinations(
testCases,
this.WriterTestConfigurationProvider.DefaultFormatConfigurationsWithIndent,
(testCase, testConfiguration) =>
{
// fix up the accept header for binary content
bool binaryPayload = testCase.PayloadItems.Single() is byte[];
if (binaryPayload)
{
ODataMessageWriterSettings settings = testConfiguration.MessageWriterSettings.Clone();
settings.SetContentType("application/octet-stream", null);
testConfiguration = new WriterTestConfiguration(testConfiguration.Format, settings, testConfiguration.IsRequest, testConfiguration.Synchronous);
}
TestWriterUtils.WriteAndVerifyRawContent(testCase, testConfiguration, this.Assert, this.Logger);
});
}
public void WorkspaceNamesTests()
{
string[] workspaceNames = new string[] { null, string.Empty, "MyWorkspaceName" };
var testCases = workspaceNames.Select(name => new PayloadWriterTestDescriptor <ODataServiceDocument>(this.Settings, CreateWorkspace(/*createMetadataFirst*/ true, name), this.CreateExpectedResultCallback(baseUri, name)));
this.CombinatorialEngineProvider.RunCombinations(
testCases,
this.WriterTestConfigurationProvider.ExplicitFormatConfigurationsWithIndent,
(testCase, testConfig) =>
{
WriterTestConfiguration newConfiguration = testConfig.Clone();
newConfiguration.MessageWriterSettings.PayloadBaseUri = new Uri(baseUri);
newConfiguration.MessageWriterSettings.SetServiceDocumentUri(ServiceDocumentUri);
TestWriterUtils.WriteAndVerifyTopLevelContent(
testCase,
newConfiguration,
(messageWriter) => messageWriter.WriteServiceDocument(testCase.PayloadItems.Single()),
this.Assert,
baselineLogger: this.Logger);
});
}
/// <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;
}
}
/// <summary>
/// Depending on the passed in <paramref name="testConfiguration"/> wraps the specified <paramref name="json"/>
/// in either the "d" or "results" wrapper or both.
/// </summary>
/// <param name="testConfiguration">The test configuration to consider.</param>
/// <param name="countString">An optional string that represents the inline count.</param>
/// <param name="nextLinkString">An optional string that represents the next page link.</param>
/// <param name="jsonLines">The json payload to wrap.</param>
/// <returns>The wrapped json payload.</returns>
public static string WrapTopLevelResults(WriterTestConfiguration testConfiguration, string countString, string nextLinkString, string[] jsonLines)
{
if (!testConfiguration.IsRequest)
{
List <string> wrappedJsonLines = new List <string>();
wrappedJsonLines.Add("{");
for (int i = 0; i < jsonLines.Length; ++i)
{
// remove the $(Indent) from the first line (if it exists) and add the 'results' property
if (i == 0)
{
if (countString != null)
{
wrappedJsonLines.Add(indentString + countString + ",\"results\":" + RemoveIndent(jsonLines[i]));
}
else
{
wrappedJsonLines.Add(indentString + "\"results\":" + RemoveIndent(jsonLines[i]));
}
}
else
{
wrappedJsonLines.Add(indentString + jsonLines[i]);
}
}
if (nextLinkString != null)
{
int lastIx = wrappedJsonLines.Count - 1;
wrappedJsonLines[lastIx] = wrappedJsonLines[lastIx] + "," + nextLinkString;
}
wrappedJsonLines.Add("}");
jsonLines = wrappedJsonLines.ToArray();
}
return(WrapTopLevelValue(testConfiguration, jsonLines));
}
/// <summary>
/// Called to create the input message for the reader test.
/// </summary>
/// <param name="innerStream">The <see cref="Stream"/> instance to be used as inner stream of the <see cref="TestStream"/>.</param>
/// <param name="testConfiguration">The test configuration.</param>
/// <returns>The newly created test message to use.</returns>
protected override TestMessage CreateOutputMessage(Stream innerStream, WriterTestConfiguration testConfiguration)
{
Debug.Assert(innerStream is StreamingTestStream, "StreamingTestStream expected.");
StreamingTestStream streamingTestStream = (StreamingTestStream)innerStream;
if (testConfiguration.Synchronous)
{
streamingTestStream.FailAsynchronousCalls = true;
}
else
{
streamingTestStream.FailSynchronousCalls = true;
}
TestMessage testMessage = TestWriterUtils.CreateOutputMessageFromStream(
streamingTestStream,
testConfiguration,
this.PayloadKind,
this.PayloadElement.GetCustomContentTypeHeader(),
this.UrlResolver);
return(testMessage);
}
/// <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 BaseUriValidationTest()
{
string relativeUriString = "abc/pqr/";
Uri absoluteUri = new Uri("http://odata.org");
Uri relativeUri = absoluteUri.MakeRelativeUri(new Uri(absoluteUri, relativeUriString));
string expectedError = "The base URI '" + relativeUriString + "' specified in ODataMessageWriterSettings.BaseUri is invalid; it must either be null or an absolute URI.";
ODataResource entry = ObjectModelUtils.CreateDefaultEntry();
var testDescriptors = new []
{
new
{
BaseUri = relativeUri,
TestDescriptor = new PayloadWriterTestDescriptor <ODataItem>(this.Settings, entry, testConfiguration =>
new WriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
ExpectedODataExceptionMessage = expectedError
})
}
};
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.WriterTestConfigurationProvider.ExplicitFormatConfigurations,
(testDescriptor, testConfiguration) =>
{
// clone the test configuration and set an invalid base Uri
ODataMessageWriterSettings settings = testConfiguration.MessageWriterSettings.Clone();
settings.BaseUri = testDescriptor.BaseUri;
WriterTestConfiguration config =
new WriterTestConfiguration(testConfiguration.Format, settings, testConfiguration.IsRequest, testConfiguration.Synchronous);
TestWriterUtils.WriteAndVerifyODataPayload(testDescriptor.TestDescriptor, config, this.Assert, this.Logger);
});
}
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>
/// Depending on the passed in <paramref name="testConfiguration"/> wraps the specified <paramref name="json"/>
/// in the start of the "d" wrapper but does not add the closing '}' for the "d" wrapper; used for error payloads.
/// </summary>
/// <param name="testConfiguration">The test configuration to consider.</param>
/// <param name="jsonLines">The json payload (as separate lines) to (partially) wrap.</param>
/// <returns>The partially wrapped json payload.</returns>
public static string WrapTopLevelValuePartial(WriterTestConfiguration testConfiguration, params string[] jsonLines)
{
if (!testConfiguration.IsRequest)
{
string[] wrappedJsonLines = new string[jsonLines.Length + 1];
wrappedJsonLines[0] = "{";
for (int i = 0; i < jsonLines.Length; ++i)
{
if (i == 0)
{
wrappedJsonLines[i + 1] = indentString + "\"d\":" + RemoveIndent(jsonLines[i]);
}
else
{
wrappedJsonLines[i + 1] = indentString + jsonLines[i];
}
}
jsonLines = wrappedJsonLines;
}
return(string.Join("$(NL)", jsonLines));
}
/// <summary>
/// Compute the resulting string representation of a URI in a given test configuration.
/// </summary>
/// <param name="uri">The URI to convert to string.</param>
/// <param name="testConfig">The test configuration to use.</param>
/// <returns>The string representation of the <paramref name="uri"/> for the given test configuration.</returns>
private string GetResultUri(Uri uri, WriterTestConfiguration testConfig)
{
Uri baseUri = testConfig.MessageWriterSettings.PayloadBaseUri;
if (testConfig.Format == ODataFormat.Atom)
{
if (uri.IsAbsoluteUri)
{
return(uri.AbsoluteUri);
}
else
{
// In ATOM we expect the original, relative URI in the payload if a base URI is present;
// If no base URI exists, we will fail so we don't consider the case here.
return(uri.OriginalString);
}
}
else
{
Debug.Assert(testConfig.Format == ODataFormat.Json, "Only ATOM and JSON lite are supported.");
if (uri.IsAbsoluteUri)
{
return(uri.AbsoluteUri);
}
else if (baseUri != null)
{
// In JSON we expect the absolute URI if a base URI is present
return(new Uri(baseUri, uri).AbsoluteUri);
}
else
{
// This will fail; return the original relative URI.
return(uri.OriginalString);
}
}
}
/// <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();
}
/// <summary>
/// Depending on the passed in <paramref name="testConfiguration"/> wraps the specified <paramref name="json"/>
/// in either the "d" or "results" wrapper or both.
/// </summary>
/// <param name="testConfiguration">The test configuration to consider.</param>
/// <param name="jsonLines">The json payload to wrap.</param>
/// <returns>The wrapped json payload.</returns>
public static string WrapTopLevelResults(WriterTestConfiguration testConfiguration, string[] jsonLines)
{
return(WrapTopLevelResults(testConfiguration, null, null, jsonLines));
}
private WriterTestExpectedResults CreateExpectedResults(WriterTestConfiguration testConfiguration, ProjectedPropertiesTestCase testCase, bool withModel)
{
if (testCase.ExpectedException != null)
{
ExpectedException expectedException = testCase.ExpectedException(withModel);
if (expectedException != null)
{
return(new WriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
ExpectedException2 = expectedException
});
}
}
if (testConfiguration.Format == ODataFormat.Atom)
{
#region Atom expected result
var atomExpectedResults = new AtomWriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
Xml = new XElement("properties", testCase.ExpectedProperties.OrderBy(p => p).Select(p => new XElement(p))).ToString(),
FragmentExtractor = (result) =>
{
// Navigation links
IEnumerable <string> actualProperties;
if (result == null)
{
actualProperties = new string[0];
}
else
{
actualProperties = result.Elements(TestAtomConstants.AtomXNamespace + TestAtomConstants.AtomLinkElementName)
.Where(link => link.Attribute(TestAtomConstants.AtomLinkRelationAttributeName).Value.StartsWith(TestAtomConstants.ODataNavigationPropertiesRelatedLinkRelationPrefix))
.Select(link => link.Attribute(TestAtomConstants.AtomLinkTitleAttributeName).Value);
// Named stream links
actualProperties = actualProperties.Concat(result.Elements(TestAtomConstants.AtomXNamespace + TestAtomConstants.AtomLinkElementName)
.Where(link => link.Attribute(TestAtomConstants.AtomLinkRelationAttributeName).Value.StartsWith(TestAtomConstants.ODataStreamPropertyEditMediaRelatedLinkRelationPrefix))
.Select(link => link.Attribute(TestAtomConstants.AtomLinkTitleAttributeName).Value));
// Association links
actualProperties = actualProperties.Concat(result.Elements(TestAtomConstants.AtomXNamespace + TestAtomConstants.AtomLinkElementName)
.Where(link => link.Attribute(TestAtomConstants.AtomLinkRelationAttributeName).Value.StartsWith(TestAtomConstants.ODataNavigationPropertiesAssociationLinkRelationPrefix))
.Select(link => link.Attribute(TestAtomConstants.AtomLinkTitleAttributeName).Value));
// Properties
actualProperties = actualProperties.Concat(result.Elements(TestAtomConstants.AtomXNamespace + TestAtomConstants.AtomContentElementName)
.Elements(TestAtomConstants.ODataMetadataXNamespace + TestAtomConstants.AtomPropertiesElementName)
.Elements().Where(e => e.Name.Namespace == TestAtomConstants.ODataXNamespace)
.Select(pe => pe.Name.LocalName));
}
return(new XElement("properties",
actualProperties.OrderBy(p => p).Select(p => new XElement(p))));
}
};
if (testCase.NestedPayload)
{
var originalFragmentExtractor = atomExpectedResults.FragmentExtractor;
atomExpectedResults.FragmentExtractor = (result) =>
{
// Verify that the Wrapping_ID property is not written
this.Assert.IsNull(result
.Element(TestAtomConstants.AtomXNamespace + TestAtomConstants.AtomContentElementName)
.Element(TestAtomConstants.ODataMetadataXNamespace + TestAtomConstants.AtomPropertiesElementName),
"There should be no other property but the nav link and thus no m:properties in the content.");
XElement expandedNavLinkElement = result.Elements(TestAtomConstants.AtomXNamespace + TestAtomConstants.AtomLinkElementName)
.Where(link => link.Attribute(TestAtomConstants.AtomLinkRelationAttributeName).Value
.StartsWith(TestAtomConstants.ODataNavigationPropertiesRelatedLinkRelationPrefix + "Wrapping_ExpandedEntry"))
.SingleOrDefault();
return(originalFragmentExtractor(
expandedNavLinkElement == null
? null
: expandedNavLinkElement
.Element(TestAtomConstants.ODataMetadataXNamespace + TestAtomConstants.ODataInlineElementName)
.Element(TestAtomConstants.AtomXNamespace + TestAtomConstants.AtomEntryElementName)));
};
}
return(atomExpectedResults);
#endregion Atom expected result
}
else if (testConfiguration.Format == ODataFormat.Json)
{
#region JSON Light expected result
JsonArray expectedJson = new JsonArray();
foreach (var p in testCase.ExpectedProperties.Distinct().OrderBy(p => p))
{
expectedJson.Add(new JsonPrimitiveValue(p));
}
var jsonExpectedResults = new JsonWriterTestExpectedResults(this.Settings.ExpectedResultSettings)
{
Json = expectedJson.ToText(/*writingJsonLight*/ true, testConfiguration.MessageWriterSettings.Indent),
FragmentExtractor = (result) =>
{
// Everything except association links
IEnumerable <string> actualProperties;
if (result == null)
{
actualProperties = new string[0];
}
else
{
List <string> propertyNames = new List <string>();
foreach (JsonProperty jsonProperty in result.Object().Properties)
{
string propertyName = jsonProperty.Name;
int atIndex = propertyName.IndexOf('@');
int dotIndex = propertyName.IndexOf('.');
if (dotIndex < 0)
{
propertyNames.Add(propertyName);
}
else if (atIndex >= 0)
{
propertyNames.Add(propertyName.Substring(0, atIndex));
}
}
actualProperties = propertyNames.Distinct();
}
JsonArray r = new JsonArray();
foreach (var p in actualProperties.OrderBy(p => p))
{
r.Add(new JsonPrimitiveValue(p));
}
return(r);
}
};
if (testCase.NestedPayload)
{
var originalFragmentExtractor = jsonExpectedResults.FragmentExtractor;
jsonExpectedResults.FragmentExtractor = (result) =>
{
// Verify that the Wrapping_ID property is not written
JsonObject resultObject = result.Object();
this.Assert.IsNull(resultObject.Property("Wrapping_ID"), "No other property but the nav. link should be written.");
return(originalFragmentExtractor(
resultObject.Property("Wrapping_ExpandedEntry") == null
? null
: resultObject.PropertyObject("Wrapping_ExpandedEntry")));
};
}
return(jsonExpectedResults);
#endregion JSON Light expected result
}
else
{
throw new TaupoInvalidOperationException("The format " + testConfiguration.Format.GetType().FullName + " is not supported.");
}
}
public void ResolverUriTest()
{
Uri inputUri = new Uri("inputUri", UriKind.Relative);
Uri resultRelativeUri = new Uri("resultRelativeUri", UriKind.Relative);
Uri resultAbsoluteUri = new Uri("http://odata.org/absoluteresolve");
var resolvers = new[]
{
// Resolver which always returns relative URL
new
{
Resolver = new Func <Uri, Uri, Uri>((baseUri, payloadUri) => {
if (payloadUri.OriginalString == inputUri.OriginalString)
{
return(resultRelativeUri);
}
else
{
return(null);
}
}),
ResultUri = resultRelativeUri
},
// Resolver which always returns absolute URL
new
{
Resolver = new Func <Uri, Uri, Uri>((baseUri, payloadUri) => {
if (payloadUri.OriginalString == inputUri.OriginalString)
{
return(resultAbsoluteUri);
}
else
{
return(null);
}
}),
ResultUri = resultAbsoluteUri
}
};
var testDescriptors = uriTestCases.SelectMany(testCase => resolvers.Select(resolver =>
{
return(new
{
TestCase = testCase,
Descriptor = new PayloadWriterTestDescriptor <ODataItem>(
this.Settings,
testCase.ItemFunc(inputUri),
CreateUriTestCaseExpectedResultCallback(/*baseUri*/ null, resolver.ResultUri, testCase))
{
UrlResolver = new TestUrlResolver()
{
ResolutionCallback = resolver.Resolver
}
}
});
}));
// ToDo: Fix places where we've lost JsonVerbose coverage to add JsonLight
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
new bool[] { false, true },
this.WriterTestConfigurationProvider.ExplicitFormatConfigurations.Where(c => false),
(testDescriptor, runInBatch, testConfiguration) =>
{
testConfiguration = testConfiguration.Clone();
testConfiguration.MessageWriterSettings.SetServiceDocumentUri(ServiceDocumentUri);
if ((!testConfiguration.IsRequest || !testDescriptor.TestCase.ResponseOnly) &&
(testConfiguration.Format == ODataFormat.Json && testDescriptor.TestCase.JsonExtractor != null))
{
var td = testDescriptor.Descriptor.DeferredLinksToEntityReferenceLinksInRequest(testConfiguration);
if (!runInBatch)
{
TestWriterUtils.WriteAndVerifyODataPayload(td, testConfiguration, this.Assert, this.Logger);
}
else
{
testConfiguration = testConfiguration.Clone();
testConfiguration.MessageWriterSettings.EnableMessageStreamDisposal = true;
var batchDescriptor = new List <BatchWriterTestDescriptor.InvocationAndOperationDescriptor>();
if (testConfiguration.IsRequest)
{
batchDescriptor.Add(BatchWriterUtils.StartBatch());
batchDescriptor.Add(BatchWriterUtils.StartChangeSet());
batchDescriptor.Add(BatchWriterUtils.ChangeSetRequest(
"PUT",
new Uri("http://odata.org"),
null,
null,
new BatchWriterUtils.ODataPayload()
{
Items = td.PayloadItems.ToArray(),
WriterTestExpectedResults = td.ExpectedResultCallback(testConfiguration),
TestConfiguration = testConfiguration
}));
batchDescriptor.Add(BatchWriterUtils.EndChangeSet());
batchDescriptor.Add(BatchWriterUtils.EndBatch());
}
else
{
batchDescriptor.Add(BatchWriterUtils.StartBatch());
batchDescriptor.Add(BatchWriterUtils.QueryOperationResponse(
200,
new BatchWriterUtils.ODataPayload()
{
Items = td.PayloadItems.ToArray(),
WriterTestExpectedResults = td.ExpectedResultCallback(testConfiguration),
TestConfiguration = testConfiguration
}));
batchDescriptor.Add(BatchWriterUtils.EndBatch());
}
var batchTd = new BatchWriterTestDescriptor(
this.BatchSettings,
batchDescriptor.ToArray(),
(Dictionary <string, string>)null,
new Uri("http://odata.org/service"),
td.UrlResolver);
ODataMessageWriterSettings batchWriterSettings = testConfiguration.MessageWriterSettings.Clone();
batchWriterSettings.SetContentType(null);
WriterTestConfiguration batchTestConfiguration = new WriterTestConfiguration(
null,
batchWriterSettings,
testConfiguration.IsRequest,
testConfiguration.Synchronous);
BatchWriterUtils.WriteAndVerifyBatchPayload(batchTd, batchTestConfiguration, testConfiguration, this.Assert);
}
}
});
}
/// <summary>
/// Verifies the result of the write-read.
/// </summary>
/// <param name="message">The test message is not used but is required to keep the method signature the same.</param>
/// <param name="payloadKind">The payload kind is not used but is required to keep the method signature the same.</param>
/// <param name="testConfiguration">The test configuration is used for some fixups.</param>
public override void VerifyResult(TestMessage message, ODataPayloadKind payloadKind, WriterTestConfiguration testConfiguration, BaselineLogger logger = null)
{
//TODO: Use Logger to verify result, right now this change is only to unblock writer testcase checkin
Debug.Assert(ObservedElement != null, "ObservedElement not provided");
// Fixup the expected and get the content type
ODataPayloadElement expected = this.ExpectedPayload.DeepCopy();
ODataPayloadElement observed = this.ObservedElement.DeepCopy();
observed.Accept(new RemoveTypeNameAnnotationFromComplexInCollection());
expected.Accept(new ReorderProperties());
expected.Accept(new RemoveComplexWithNoProperties());
// Compare
this.settings.PayloadElementComparer.Compare(expected, observed);
}
private static Stream GetMessageStream(ODataBatchOperationResponseMessage responseMessage, WriterTestConfiguration testConfiguration)
{
if (testConfiguration.Synchronous)
{
return(responseMessage.GetStream());
}
else
{
var t = responseMessage.GetStreamAsync();
t.Wait();
return(t.Result);
}
}
/// <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 = new ODataMessageReaderSettings(this.settings.MessageReaderSettings)
{
DisableMessageStreamDisposal = testConfiguration.MessageWriterSettings.DisableMessageStreamDisposal,
EnableAtom = true
};
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();
if (testConfiguration.Format == ODataFormat.Atom)
{
this.PayloadElement.Accept(new AddFeedIDFixup());
}
this.readObject = reverseConverter.Convert(streamer.WriteMessage(messageWriter, messageReaderWrapper, this.PayloadKind, payloadElementToOMConverter.Convert(this.PayloadElement)), !testConfiguration.IsRequest);
}
});
}
private static BatchWriterStatesTestSetupResult GetOperationStream(object message, WriterTestConfiguration testConfiguration)
{
BatchWriterStatesTestSetupResult result = new BatchWriterStatesTestSetupResult {
Message = message
};
ODataBatchOperationRequestMessage requestMessage = message as ODataBatchOperationRequestMessage;
if (requestMessage != null)
{
if (testConfiguration.Synchronous)
{
result.MessageStream = requestMessage.GetStream();
return(result);
}
else
{
// TODO: 191417: Enable async Tests on Phone and Silverlight when Product Supports them
#if SILVERLIGHT || WINDOWS_PHONE
throw new TaupoNotSupportedException("This test is not supported in aSynchronous mode in Silverlight or Phone");
#else
var t = requestMessage.GetStreamAsync();
t.Wait();
result.MessageStream = t.Result;
return(result);
#endif
}
}
ODataBatchOperationResponseMessage responseMessage = message as ODataBatchOperationResponseMessage;
if (responseMessage != null)
{
if (testConfiguration.Synchronous)
{
result.MessageStream = responseMessage.GetStream();
return(result);
}
else
{
// TODO: Enable async Tests on Phone and Silverlight when Product Supports them
#if SILVERLIGHT || WINDOWS_PHONE
throw new TaupoNotSupportedException("This test is not supported in aSynchronous mode in Silverlight or Phone");
#else
var t = responseMessage.GetStreamAsync();
t.Wait();
result.MessageStream = t.Result;
return(result);
#endif
}
}
return(null);
}
