/// <summary>
/// Helper method to create a test message from its content.
/// </summary>
/// <param name="messageContent">Stream with the content of the message.</param>
/// <param name="testConfiguration">The test configuration.</param>
/// <param name="payloadKind">The payload kind to use to compute and set the content type header; or null if no content type header should be set.</param>
/// <param name="customContentTypeHeader">A custom content type header to be used in the message.</param>
/// <param name="urlResolver">Url resolver to add to the test message created.</param>
/// <returns>Newly created test message.</returns>
protected TestMessage CreateInputMessageFromStream(
TestStream messageContent,
WriterTestConfiguration testConfiguration,
ODataPayloadKind?payloadKind,
string customContentTypeHeader,
IODataPayloadUriConverter urlResolver)
{
TestMessage message;
if (testConfiguration.IsRequest)
{
if (urlResolver != null)
{
message = new TestRequestMessageWithUrlResolver(messageContent, urlResolver, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
}
else
{
message = new TestRequestMessage(messageContent, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
}
}
else
{
if (urlResolver != null)
{
message = new TestResponseMessageWithUrlResolver(messageContent, urlResolver, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
}
else
{
message = new TestResponseMessage(messageContent, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
}
}
return(message);
}
/// <summary>
/// Creates the URI for a batch request operation.
/// </summary>
/// <param name="uri">The uri to process.</param>
/// <param name="baseUri">The base Uri to use.</param>
/// <param name="payloadUriConverter">An optional custom URL converter to convert URLs for writing them into the payload.</param>
/// <returns>An URI to be used in the request line of a batch request operation. It uses the <paramref name="payloadUriConverter"/>
/// first and falls back to the default URI building schema if the no URL resolver is specified or the URL resolver
/// returns null. In the default scheme, the method either returns the specified <paramref name="uri"/> if it was absolute,
/// or it's combination with the <paramref name="baseUri"/> if it was relative.</returns>
/// <remarks>
/// This method will fail if no custom resolution is implemented and the specified <paramref name="uri"/> is
/// relative and there's no base URI available.
/// </remarks>
internal static Uri CreateOperationRequestUri(Uri uri, Uri baseUri, IODataPayloadUriConverter payloadUriConverter)
{
Debug.Assert(uri != null, "uri != null");
Uri resultUri;
if (payloadUriConverter != null)
{
// The resolver returns 'null' if no custom resolution is desired.
resultUri = payloadUriConverter.ConvertPayloadUri(baseUri, uri);
if (resultUri != null)
{
return(resultUri);
}
}
if (uri.IsAbsoluteUri)
{
resultUri = uri;
}
else
{
if (baseUri == null)
{
string errorMessage = UriUtils.UriToString(uri).StartsWith("$", StringComparison.Ordinal)
? Strings.ODataBatchUtils_RelativeUriStartingWithDollarUsedWithoutBaseUriSpecified(UriUtils.UriToString(uri))
: Strings.ODataBatchUtils_RelativeUriUsedWithoutBaseUriSpecified(UriUtils.UriToString(uri));
throw new ODataException(errorMessage);
}
resultUri = UriUtils.UriToAbsoluteUri(baseUri, uri);
}
return(resultUri);
}
/// <summary>
/// Constructor. Creates a request message for an operation of a batch request.
/// </summary>
/// <param name="contentStreamCreatorFunc">A function to create the content stream.</param>
/// <param name="method">The HTTP method used for this request message.</param>
/// <param name="requestUrl">The request Url for this request message.</param>
/// <param name="headers">The headers for this request message.</param>
/// <param name="operationListener">Listener interface to be notified of operation changes.</param>
/// <param name="contentId">The content-ID for the operation request message.</param>
/// <param name="payloadUriConverter">The optional URL converter to perform custom URL conversion for URLs written to the payload.</param>
/// <param name="writing">true if the request message is being written; false when it is read.</param>
/// <param name="container">The dependency injection container to get related services.</param>
/// <param name="dependsOnIds">
/// Request or group Ids that current request has dependency on. Values are added to a new list.
/// Empty list will be created if value is null.
/// </param>
/// <param name="groupId">Value for the group id that current request belongs to. Can be null.</param>
internal ODataBatchOperationRequestMessage(
Func <Stream> contentStreamCreatorFunc,
string method,
Uri requestUrl,
ODataBatchOperationHeaders headers,
IODataBatchOperationListener operationListener,
string contentId,
IODataPayloadUriConverter payloadUriConverter,
bool writing,
IServiceProvider container,
IEnumerable <string> dependsOnIds,
string groupId)
{
Debug.Assert(contentStreamCreatorFunc != null, "contentStreamCreatorFunc != null");
Debug.Assert(operationListener != null, "operationListener != null");
Debug.Assert(payloadUriConverter != null, "payloadUriConverter != null");
this.Method = method;
this.Url = requestUrl;
this.ContentId = contentId;
this.groupId = groupId;
this.message = new ODataBatchOperationMessage(contentStreamCreatorFunc, headers, operationListener, payloadUriConverter, writing);
this.Container = container;
this.dependsOnIds = dependsOnIds == null
? new List <string>()
: new List <string>(dependsOnIds);
}
public BatchWriterTestDescriptor(Settings settings, InvocationAndOperationDescriptor[] invocationsAndOperationDescriptors, Dictionary <string, string> expectedHeaders = null, Uri baseUri = null, IODataPayloadUriConverter urlResolver = null)
{
this.TestDescriptorSettings = settings;
this.invocationsAndOperationDescriptors = invocationsAndOperationDescriptors;
this.expectedResultCallback = CreateExpectedResultCallback(invocationsAndOperationDescriptors, expectedHeaders, this.TestDescriptorSettings.ExpectedResultSettings);
this.baseUri = baseUri;
this.urlResolver = urlResolver;
}
/// <summary>
/// Creates an operation response message that can be used to write the operation content to.
/// </summary>
/// <param name="outputStream">The output stream underlying the operation message.</param>
/// <param name="operationListener">The operation listener.</param>
/// <param name="payloadUriConverter">The (optional) URL converter for the message to create.</param>
/// <param name="container">The dependency injection container to get related services.</param>
/// <returns>An <see cref="ODataBatchOperationResponseMessage"/> that can be used to write the operation content.</returns>
internal static ODataBatchOperationResponseMessage CreateWriteMessage(
Stream outputStream,
IODataBatchOperationListener operationListener,
IODataPayloadUriConverter payloadUriConverter,
IServiceProvider container)
{
Func <Stream> streamCreatorFunc = () => ODataBatchUtils.CreateBatchOperationWriteStream(outputStream, operationListener);
return(new ODataBatchOperationResponseMessage(streamCreatorFunc, /*headers*/ null, operationListener, /*contentId*/ null, payloadUriConverter, /*writing*/ true, container));
}
/// <summary>
/// Creates an operation request message that can be used to write the operation content to.
/// </summary>
/// <param name="outputStream">The output stream underlying the operation message.</param>
/// <param name="method">The HTTP method to use for the message to create.</param>
/// <param name="requestUrl">The request URL for the message to create.</param>
/// <param name="operationListener">The operation listener.</param>
/// <param name="payloadUriConverter">The (optional) URL converter for the message to create.</param>
/// <param name="container">The dependency injection container to get related services.</param>
/// <returns>An <see cref="ODataBatchOperationRequestMessage"/> to write the request content to.</returns>
internal static ODataBatchOperationRequestMessage CreateWriteMessage(
Stream outputStream,
string method,
Uri requestUrl,
IODataBatchOperationListener operationListener,
IODataPayloadUriConverter payloadUriConverter,
IServiceProvider container)
{
Debug.Assert(outputStream != null, "outputStream != null");
Debug.Assert(operationListener != null, "operationListener != null");
Func <Stream> streamCreatorFunc = () => ODataBatchUtils.CreateBatchOperationWriteStream(outputStream, operationListener);
return(new ODataBatchOperationRequestMessage(streamCreatorFunc, method, requestUrl, /*headers*/ null, operationListener, /*contentId*/ null, payloadUriConverter, /*writing*/ true, container));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="contentStreamCreatorFunc">A function to retrieve the content stream for this batch operation message.</param>
/// <param name="headers">The headers of the batch operation message.</param>
/// <param name="operationListener">Listener interface to be notified of part changes.</param>
/// <param name="contentId">The content-ID for the operation response message.</param>
/// <param name="payloadUriConverter">The optional URL converter to perform custom URL conversion for URLs written to the payload.</param>
/// <param name="writing">true if the request message is being written; false when it is read.</param>
/// <param name="container">The dependency injection container to get related services.</param>
private ODataBatchOperationResponseMessage(
Func <Stream> contentStreamCreatorFunc,
ODataBatchOperationHeaders headers,
IODataBatchOperationListener operationListener,
string contentId,
IODataPayloadUriConverter payloadUriConverter,
bool writing,
IServiceProvider container)
{
Debug.Assert(contentStreamCreatorFunc != null, "contentStreamCreatorFunc != null");
Debug.Assert(operationListener != null, "operationListener != null");
this.message = new ODataBatchOperationMessage(contentStreamCreatorFunc, headers, operationListener, payloadUriConverter, writing);
this.ContentId = contentId;
this.Container = container;
}
/// <summary>
/// Constructor. Base class constructor to create a message for an operation of a batch request/response.
/// </summary>
/// <param name="contentStreamCreatorFunc">A function to retrieve the content stream for this batch operation message.</param>
/// <param name="headers">The headers of the batch operation message.</param>
/// <param name="operationListener">Listener interface to be notified of part changes.</param>
/// <param name="payloadUriConverter">The URL resolver to perform custom URL resolution for URLs read or written from/to the payload.</param>
/// <param name="writing">true if the request message is being written; false when it is read.</param>
internal ODataBatchOperationMessage(
Func <Stream> contentStreamCreatorFunc,
ODataBatchOperationHeaders headers,
IODataStreamListener operationListener,
IODataPayloadUriConverter payloadUriConverter,
bool writing)
: base(writing, /*disableMessageStreamDisposal*/ false, /*maxMessageSize*/ -1)
{
Debug.Assert(contentStreamCreatorFunc != null, "contentStreamCreatorFunc != null");
Debug.Assert(operationListener != null, "operationListener != null");
this.contentStreamCreatorFunc = contentStreamCreatorFunc;
this.operationListener = operationListener;
this.headers = headers;
this.payloadUriConverter = payloadUriConverter;
}
/// <summary>
/// Creates an operation request message that can be used to read the operation content from.
/// </summary>
/// <param name="batchReaderStream">The batch stream underyling the operation response message.</param>
/// <param name="method">The HTTP method to use for the message to create.</param>
/// <param name="requestUrl">The request URL for the message to create.</param>
/// <param name="headers">The headers to use for the operation request message.</param>
/// <param name="operationListener">The operation listener.</param>
/// <param name="contentId">The content-ID for the operation request message.</param>
/// <param name="payloadUriConverter">The (optional) URL converter for the message to create.</param>
/// <param name="container">The dependency injection container to get related services.</param>
/// <returns>An <see cref="ODataBatchOperationRequestMessage"/> to read the request content from.</returns>
internal static ODataBatchOperationRequestMessage CreateReadMessage(
ODataBatchReaderStream batchReaderStream,
string method,
Uri requestUrl,
ODataBatchOperationHeaders headers,
IODataBatchOperationListener operationListener,
string contentId,
IODataPayloadUriConverter payloadUriConverter,
IServiceProvider container)
{
Debug.Assert(batchReaderStream != null, "batchReaderStream != null");
Debug.Assert(operationListener != null, "operationListener != null");
Func <Stream> streamCreatorFunc = () => ODataBatchUtils.CreateBatchOperationReadStream(batchReaderStream, headers, operationListener);
return(new ODataBatchOperationRequestMessage(streamCreatorFunc, method, requestUrl, headers, operationListener, contentId, payloadUriConverter, /*writing*/ false, container));
}
/// <summary>
/// Helper method to create a test message from its content.
/// </summary>
/// <param name="messageContent">Stream with the content of the message.</param>
/// <param name="testConfiguration">The test configuration.</param>
/// <param name="payloadKind">The payload kind to use to compute and set the content type header; or null if no content type header should be set.</param>
/// <param name="customContentTypeHeader">A custom content type header to be used in the message.</param>
/// <param name="urlResolver">Url resolver to add to the test message created.</param>
/// <returns>Newly created test message.</returns>
public static TestMessage CreateInputMessageFromStream(
TestStream messageContent,
ReaderTestConfiguration testConfiguration,
ODataPayloadKind?payloadKind,
string customContentTypeHeader,
IODataPayloadUriConverter urlResolver)
{
TestMessage message;
if (testConfiguration.IsRequest)
{
if (urlResolver != null)
{
message = new TestRequestMessageWithUrlResolver(messageContent, urlResolver, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
}
else
{
message = new TestRequestMessage(messageContent, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
}
}
else
{
if (urlResolver != null)
{
message = new TestResponseMessageWithUrlResolver(messageContent, urlResolver, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
}
else
{
message = new TestResponseMessage(messageContent, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
}
}
// set the OData-Version header
message.SetHeader(ODataConstants.ODataVersionHeader, testConfiguration.Version.ToText());
if (customContentTypeHeader != null)
{
message.SetHeader(ODataConstants.ContentTypeHeader, customContentTypeHeader);
}
else if (payloadKind.HasValue)
{
message.SetContentType(testConfiguration.Format, payloadKind.Value);
}
return(message);
}
/// <summary>
/// Creates an operation response message that can be used to read the operation content from.
/// </summary>
/// <param name="batchReaderStream">The batch stream underyling the operation response message.</param>
/// <param name="statusCode">The status code to use for the operation response message.</param>
/// <param name="headers">The headers to use for the operation response message.</param>
/// <param name="contentId">The content-ID for the operation response message.</param>
/// <param name="operationListener">The operation listener.</param>
/// <param name="payloadUriConverter">The (optional) URL converter for the message to create.</param>
/// <param name="container">The dependency injection container to get related services.</param>
/// <returns>An <see cref="ODataBatchOperationResponseMessage"/> that can be used to read the operation content.</returns>
internal static ODataBatchOperationResponseMessage CreateReadMessage(
ODataBatchReaderStream batchReaderStream,
int statusCode,
ODataBatchOperationHeaders headers,
string contentId,
IODataBatchOperationListener operationListener,
IODataPayloadUriConverter payloadUriConverter,
IServiceProvider container)
{
Debug.Assert(batchReaderStream != null, "batchReaderStream != null");
Debug.Assert(operationListener != null, "operationListener != null");
Func <Stream> streamCreatorFunc = () => ODataBatchUtils.CreateBatchOperationReadStream(batchReaderStream, headers, operationListener);
ODataBatchOperationResponseMessage responseMessage =
new ODataBatchOperationResponseMessage(streamCreatorFunc, headers, operationListener, contentId, payloadUriConverter, /*writing*/ false, container);
responseMessage.statusCode = statusCode;
return(responseMessage);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="format">The format for this input context.</param>
/// <param name="messageInfo">The context information for the message.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
protected ODataInputContext(
ODataFormat format,
ODataMessageInfo messageInfo,
ODataMessageReaderSettings messageReaderSettings)
{
ExceptionUtils.CheckArgumentNotNull(format, "format");
ExceptionUtils.CheckArgumentNotNull(messageInfo, "messageInfo");
ExceptionUtils.CheckArgumentNotNull(messageReaderSettings, "messageReaderSettings");
this.format = format;
this.messageReaderSettings = messageReaderSettings;
this.readingResponse = messageInfo.IsResponse;
this.synchronous = !messageInfo.IsAsync;
this.model = messageInfo.Model ?? EdmCoreModel.Instance;
this.payloadUriConverter = messageInfo.PayloadUriConverter;
this.container = messageInfo.Container;
this.edmTypeResolver = new EdmTypeReaderResolver(this.Model, this.MessageReaderSettings.ClientCustomTypeResolver);
this.payloadValueConverter = ODataPayloadValueConverter.GetPayloadValueConverter(this.container);
this.odataSimplifiedOptions = ODataSimplifiedOptions.GetODataSimplifiedOptions(this.container, messageReaderSettings.Version);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="format">The format for this output context.</param>
/// <param name="messageInfo">The context information for the message.</param>
/// <param name="messageWriterSettings">Configuration settings of the OData writer.</param>
protected ODataOutputContext(
ODataFormat format,
ODataMessageInfo messageInfo,
ODataMessageWriterSettings messageWriterSettings)
{
ExceptionUtils.CheckArgumentNotNull(format, "format");
ExceptionUtils.CheckArgumentNotNull(messageWriterSettings, "messageWriterSettings");
this.format = format;
this.messageWriterSettings = messageWriterSettings;
this.writingResponse = messageInfo.IsResponse;
this.synchronous = !messageInfo.IsAsync;
this.model = messageInfo.Model ?? EdmCoreModel.Instance;
this.payloadUriConverter = messageInfo.PayloadUriConverter;
this.container = messageInfo.Container;
this.edmTypeResolver = EdmTypeWriterResolver.Instance;
this.payloadValueConverter = ODataPayloadValueConverter.GetPayloadValueConverter(this.container);
this.writerValidator = messageWriterSettings.Validator;
this.odataSimplifiedOptions = ODataSimplifiedOptions.GetODataSimplifiedOptions(this.container);
}
private ODataJsonLightServiceDocumentDeserializer CreateODataJsonServiceDocumentDeserializer(MemoryStream stream, IODataPayloadUriConverter urlResolver = null)
{
var messageInfo = new ODataMessageInfo
{
Encoding = Encoding.UTF8,
IsResponse = true,
MediaType = new ODataMediaType("application", "json"),
IsAsync = false,
Model = new EdmModel(),
PayloadUriConverter = urlResolver,
MessageStream = stream
};
var inputContext = new ODataJsonLightInputContext(messageInfo, new ODataMessageReaderSettings());
return(new ODataJsonLightServiceDocumentDeserializer(inputContext));
}
private static Action WriteServiceDocumentShouldError(ODataServiceDocument serviceDocument, IODataPayloadUriConverter urlResolver = null)
{
MemoryStream memoryStream = new MemoryStream();
var serializer = CreateODataJsonLightServiceDocumentSerializer(memoryStream, urlResolver);
return(() => serializer.WriteServiceDocument(serviceDocument));
}
private static ODataJsonLightServiceDocumentSerializer CreateODataJsonLightServiceDocumentSerializer(MemoryStream memoryStream, IODataPayloadUriConverter urlResolver = null)
{
var model = new EdmModel();
var messageWriterSettings = new ODataMessageWriterSettings();
var mainModel = TestUtils.WrapReferencedModelsToMainModel(model);
var messageInfo = new ODataMessageInfo
{
MessageStream = memoryStream,
MediaType = new ODataMediaType("application", "json"),
Encoding = Encoding.UTF8,
IsResponse = false,
IsAsync = false,
Model = mainModel,
PayloadUriConverter = urlResolver
};
var jsonLightOutputContext = new ODataJsonLightOutputContext(messageInfo, messageWriterSettings);
return(new ODataJsonLightServiceDocumentSerializer(jsonLightOutputContext));
}
public TestODataOutputContext(ODataFormat format, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, bool synchronous, IEdmModel model, IODataPayloadUriConverter urlResolver)
: base(format,
new ODataMessageInfo
{
IsAsync = !synchronous,
IsResponse = writingResponse,
Model = model,
PayloadUriConverter = urlResolver
}, messageWriterSettings)
{
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="batchMessagePayloadUriConverter">The URL converter from the batch message.</param>
internal ODataBatchPayloadUriConverter(IODataPayloadUriConverter batchMessagePayloadUriConverter)
{
this.batchMessagePayloadUriConverter = batchMessagePayloadUriConverter;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="stream">The stream with the content of the message.</param>
/// <param name="flags">The flags modifying the behavior of the message.</param>
public TestRequestMessageWithUrlResolver(Stream stream, IODataPayloadUriConverter urlResolver, TestMessageFlags flags = TestMessageFlags.None)
: base(stream, flags)
{
this.urlResolver = urlResolver;
}
