public void Parameter_Constructor()
{
HttpResponseMessage response = new HttpResponseMessage();
OperationResponseItem responseItem = new OperationResponseItem(response);
Assert.Same(response, responseItem.Response);
}
public async Task WriteResponseAsync_AsynchronouslyWritesOperation()
{
// Arrange
HttpContext context = HttpContextHelper.Create(StatusCodes.Status202Accepted);
OperationResponseItem responseItem = new OperationResponseItem(context);
MemoryStream memoryStream = new MemoryStream();
IODataResponseMessage responseMessage = new ODataMessageWrapper(memoryStream);
ODataMessageWriter writer = new ODataMessageWriter(responseMessage);
// Act
ODataBatchWriter batchWriter = await writer.CreateODataBatchWriterAsync();
await batchWriter.WriteStartBatchAsync();
await responseItem.WriteResponseAsync(batchWriter);
await batchWriter.WriteEndBatchAsync();
memoryStream.Position = 0;
string responseString = new StreamReader(memoryStream).ReadToEnd();
// Assert
Assert.Contains("Accepted", responseString);
}
public async Task WriteResponseAsync_NullWriter_Throws()
{
OperationResponseItem responseItem = new OperationResponseItem(new HttpResponseMessage());
await ExceptionAssert.ThrowsArgumentNullAsync(
() => responseItem.WriteResponseAsync(null, CancellationToken.None),
"writer");
}
public void Dispose_DisposesHttpResponseMessage()
{
OperationResponseItem responseItem = new OperationResponseItem(new MockHttpResponseMessage());
responseItem.Dispose();
Assert.True(((MockHttpResponseMessage)responseItem.Response).IsDisposed);
}
public void WriteResponseAsync_NullWriter_Throws()
{
OperationResponseItem responseItem = new OperationResponseItem(new HttpResponseMessage());
Assert.ThrowsArgumentNull(
() => responseItem.WriteResponseAsync(null, CancellationToken.None).Wait(),
"writer");
}
public async Task WriteResponseAsync_NullWriter_Throws()
{
// Arrange & Act
Mock <HttpContext> context = new Mock <HttpContext>();
OperationResponseItem responseItem = new OperationResponseItem(context.Object);
// Assert
await ExceptionAssert.ThrowsArgumentNullAsync(() => responseItem.WriteResponseAsync(null), "writer");
}
public void Parameter_Constructor()
{
// Arrange & Act
Mock <HttpContext> context = new Mock <HttpContext>();
OperationResponseItem responseItem = new OperationResponseItem(context.Object);
// Assert
Assert.Same(context.Object, responseItem.Context);
}
public void IsResponseSucess_TestResponse()
{
// Arrange
OperationResponseItem successResponseItem = new OperationResponseItem(new HttpResponseMessage(HttpStatusCode.OK));
OperationResponseItem errorResponseItem = new OperationResponseItem(new HttpResponseMessage(HttpStatusCode.Ambiguous));
// Act & Assert
Assert.True(successResponseItem.IsResponseSuccessful());
Assert.False(errorResponseItem.IsResponseSuccessful());
}
public void IsResponseSucess_TestResponse()
{
// Arrange
OperationResponseItem successResponseItem = new OperationResponseItem(HttpContextHelper.Create(StatusCodes.Status200OK));
OperationResponseItem errorResponseItem = new OperationResponseItem(HttpContextHelper.Create(StatusCodes.Status300MultipleChoices));
// Act & Assert
Assert.True(successResponseItem.IsResponseSuccessful());
Assert.False(errorResponseItem.IsResponseSuccessful());
}
public async Task ExecuteOperationAsync_CopiesPropertiesFromRequest_WithoutExcludedProperties()
{
// Arrange
RequestDelegate handler = context =>
{
context.Features[typeof(UnbufferedODataBatchHandlerTest)] = "foo";
return(Task.FromResult(context.Response));
};
UnbufferedODataBatchHandler batchHandler = new UnbufferedODataBatchHandler();
string batchRequest = @"--75148e61-e67a-4bb7-ac0f-78fa30d0da30
Content-Type: application/http
Content-Transfer-Encoding: binary
Content-ID: 318941389
GET / HTTP/1.1
Host: example.com
--75148e61-e67a-4bb7-ac0f-78fa30d0da30--
";
HttpRequest request = RequestFactory.Create("Post", "http://example.com/$batch", opt => opt.AddModel(EdmCoreModel.Instance));
HttpContext httpContext = request.HttpContext;
byte[] requestBytes = Encoding.UTF8.GetBytes(batchRequest);
request.Body = new MemoryStream(requestBytes);
request.ContentType = "multipart/mixed;boundary=\"75148e61-e67a-4bb7-ac0f-78fa30d0da30\"";
request.ContentLength = 431;
httpContext.ODataFeature().PrefixName = "";
IServiceProvider sp = request.GetSubServiceProvider();
IODataRequestMessage oDataRequestMessage = ODataMessageWrapperHelper.Create(httpContext.Request.Body, request.Headers, sp);
ODataMessageReader oDataMessageReader = new ODataMessageReader(oDataRequestMessage, new ODataMessageReaderSettings {
BaseUri = new Uri("http://example.com")
});
ODataBatchReader batchReader = await oDataMessageReader.CreateODataBatchReaderAsync();
List <ODataBatchResponseItem> responses = new List <ODataBatchResponseItem>();
await batchReader.ReadAsync();
// Act
var response = await batchHandler.ExecuteOperationAsync(batchReader, Guid.NewGuid(), httpContext.Request, handler);
// Assert
OperationResponseItem operationResponseItem = Assert.IsType <OperationResponseItem>(response);
Assert.Equal("foo", operationResponseItem.Context.Features[typeof(UnbufferedODataBatchHandlerTest)]);
}
public void WriteResponseAsync_WritesOperation()
{
OperationResponseItem responseItem = new OperationResponseItem(new HttpResponseMessage(HttpStatusCode.Accepted));
MemoryStream memoryStream = new MemoryStream();
IODataResponseMessage responseMessage = new ODataMessageWrapper(memoryStream);
ODataMessageWriter writer = new ODataMessageWriter(responseMessage);
ODataBatchWriter batchWriter = writer.CreateODataBatchWriter();
batchWriter.WriteStartBatch();
responseItem.WriteResponseAsync(batchWriter, CancellationToken.None).Wait();
batchWriter.WriteEndBatch();
memoryStream.Position = 0;
string responseString = new StreamReader(memoryStream).ReadToEnd();
Assert.Contains("Accepted", responseString);
}
public async Task ExecuteRequestMessagesAsync_CallsInvokerForEachRequest()
{
// Arrange
RequestDelegate handler = async context =>
{
HttpRequest request = context.Request;
string responseContent = request.GetDisplayUrl();
string content = request.ReadBody();
if (!string.IsNullOrEmpty(content))
{
responseContent += "," + content;
}
context.Response.Body = new MemoryStream();
await context.Response.WriteAsync(responseContent);
};
ODataBatchRequestItem[] requests = new ODataBatchRequestItem[]
{
new OperationRequestItem(HttpContextHelper.Create("Get", "http://example.com/")),
new ChangeSetRequestItem(new HttpContext[]
{
HttpContextHelper.Create("Post", "http://example.com/values", "foo", "text/plan")
})
};
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler();
// Act
IList <ODataBatchResponseItem> responses = await batchHandler.ExecuteRequestMessagesAsync(requests, handler);
// Assert
Assert.Equal(2, responses.Count);
// #1
OperationResponseItem response0 = Assert.IsType <OperationResponseItem>(responses[0]);
Assert.Equal("http://example.com/", response0.Context.Response.ReadBody());
// #2
ChangeSetResponseItem response1 = Assert.IsType <ChangeSetResponseItem>(responses[1]);
HttpContext subContext = Assert.Single(response1.Contexts);
Assert.Equal("http://example.com/values,foo", response1.Contexts.First().Response.ReadBody());
}
public async Task WriteResponseAsync_AsynchronouslyWritesOperation()
{
OperationResponseItem responseItem = new OperationResponseItem(new HttpResponseMessage(HttpStatusCode.Accepted));
MemoryStream memoryStream = new MemoryStream();
IODataResponseMessage responseMessage = new ODataMessageWrapper(memoryStream);
ODataMessageWriter writer = new ODataMessageWriter(responseMessage);
ODataBatchWriter batchWriter = await writer.CreateODataBatchWriterAsync();
await batchWriter.WriteStartBatchAsync();
await responseItem.WriteResponseAsync(batchWriter, CancellationToken.None, /*writeAsync*/ true);
await batchWriter.WriteEndBatchAsync();
memoryStream.Position = 0;
string responseString = new StreamReader(memoryStream).ReadToEnd();
Assert.Contains("Accepted", responseString);
}
public async Task WriteResponseAsync_SynchronouslyWritesOperation()
{
OperationResponseItem responseItem = new OperationResponseItem(new HttpResponseMessage(HttpStatusCode.Accepted));
MemoryStream memoryStream = new MemoryStream();
IODataResponseMessage responseMessage = new ODataMessageWrapper(memoryStream);
ODataMessageWriter writer = new ODataMessageWriter(responseMessage);
ODataBatchWriter batchWriter = writer.CreateODataBatchWriter();
batchWriter.WriteStartBatch();
// For backward compatibility, default is to write to use a synchronous batchWriter.
await responseItem.WriteResponseAsync(batchWriter, CancellationToken.None);
batchWriter.WriteEndBatch();
memoryStream.Position = 0;
string responseString = new StreamReader(memoryStream).ReadToEnd();
Assert.Contains("Accepted", responseString);
}
public async Task SendRequestAsync_ReturnsOperationResponse()
{
// Arrange
HttpContext context = HttpContextHelper.Create("Get", "http://example.com");
OperationRequestItem requestItem = new OperationRequestItem(context);
RequestDelegate handler = context =>
{
context.Response.StatusCode = StatusCodes.Status304NotModified;
return(Task.FromResult(context.Response));
};
// Act
ODataBatchResponseItem response = await requestItem.SendRequestAsync(handler);
// Assert
OperationResponseItem operationResponse = Assert.IsType <OperationResponseItem>(response);
Assert.Equal(StatusCodes.Status304NotModified, operationResponse.Context.Response.StatusCode);
}
public void WriteResponseAsync_SynchronouslyWritesOperation_Throws()
{
// Arrange
HttpContext context = HttpContextHelper.Create(StatusCodes.Status202Accepted);
OperationResponseItem responseItem = new OperationResponseItem(context);
MemoryStream memoryStream = new MemoryStream();
IODataResponseMessage responseMessage = new ODataMessageWrapper(memoryStream);
ODataMessageWriter writer = new ODataMessageWriter(responseMessage);
// Act
ODataBatchWriter batchWriter = writer.CreateODataBatchWriter();
batchWriter.WriteStartBatch();
// Assert
Action test = () => responseItem.WriteResponseAsync(batchWriter).Wait();
ODataException exception = ExceptionAssert.Throws <ODataException>(test);
Assert.Equal("An asynchronous operation was called on a synchronous batch writer. Calls on a batch writer instance must be either all synchronous or all asynchronous.",
exception.Message);
}
