public async Task WriteResponse_SynchronouslyWritesChangeSet()
{
HttpResponseMessage[] responses = new HttpResponseMessage[]
{
new HttpResponseMessage(HttpStatusCode.Accepted),
new HttpResponseMessage(HttpStatusCode.NoContent)
};
ChangeSetResponseItem responseItem = new ChangeSetResponseItem(responses);
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 assume a synchronous batch writer
await responseItem.WriteResponseAsync(batchWriter, CancellationToken.None);
batchWriter.WriteEndBatch();
memoryStream.Position = 0;
string responseString = new StreamReader(memoryStream).ReadToEnd();
Assert.Contains("changesetresponse", responseString);
Assert.Contains("Accepted", responseString);
Assert.Contains("No Content", responseString);
}
public async Task SendRequestAsync_ReturnsSingleErrorResponse()
{
// Arrange
HttpContext[] contexts = new HttpContext[]
{
HttpContextHelper.Create("Get", "http://example.com"),
HttpContextHelper.Create("Post", "http://example.com"),
HttpContextHelper.Create("Put", "http://example.com")
};
ChangeSetRequestItem requestItem = new ChangeSetRequestItem(contexts);
RequestDelegate handler = context =>
{
if (context.Request.Method == "Post")
{
context.Response.StatusCode = StatusCodes.Status400BadRequest;
}
return(Task.FromResult(context.Response));
};
// Act
ODataBatchResponseItem response = await requestItem.SendRequestAsync(handler);
// Assert
ChangeSetResponseItem changesetResponse = Assert.IsType <ChangeSetResponseItem>(response);
HttpContext responseContext = Assert.Single(changesetResponse.Contexts);
Assert.Equal(StatusCodes.Status400BadRequest, responseContext.Response.StatusCode);
}
public async Task SendRequestAsync_DisposesResponseInCaseOfException()
{
// Arrange
HttpContext[] contexts = new HttpContext[]
{
HttpContextHelper.Create("Get", "http://example.com"),
HttpContextHelper.Create("Post", "http://example.com"),
HttpContextHelper.Create("Put", "http://example.com")
};
ChangeSetRequestItem requestItem = new ChangeSetRequestItem(contexts);
List <HttpResponse> responses = new List <HttpResponse>();
RequestDelegate handler = context =>
{
if (context.Request.Method == "Put")
{
throw new InvalidOperationException();
}
responses.Add(context.Response);
return(Task.FromResult(context.Response));
};
// Act
ODataBatchResponseItem response = await requestItem.SendRequestAsync(handler);
// Assert
ChangeSetResponseItem changesetResponse = Assert.IsType <ChangeSetResponseItem>(response);
HttpContext responseContext = Assert.Single(changesetResponse.Contexts);
Assert.Equal(StatusCodes.Status500InternalServerError, responseContext.Response.StatusCode);
Assert.Equal(2, responses.Count);
}
public void WriteResponseAsync_WritesChangeSet()
{
HttpResponseMessage[] responses = new HttpResponseMessage[]
{
new HttpResponseMessage(HttpStatusCode.Accepted),
new HttpResponseMessage(HttpStatusCode.NoContent)
};
ChangeSetResponseItem responseItem = new ChangeSetResponseItem(responses);
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("changesetresponse", responseString);
Assert.Contains("Accepted", responseString);
Assert.Contains("No Content", responseString);
}
public void Parameter_Constructor()
{
HttpResponseMessage[] responses = new HttpResponseMessage[0];
ChangeSetResponseItem responseItem = new ChangeSetResponseItem(responses);
Assert.Same(responses, responseItem.Responses);
}
public async Task WriteResponseAsync_WritesChangeSet()
{
// Arrange
HttpContext context1 = HttpContextHelper.Create(StatusCodes.Status202Accepted);
HttpContext context2 = HttpContextHelper.Create(StatusCodes.Status204NoContent);
ChangeSetResponseItem responseItem = new ChangeSetResponseItem(new[] { context1, context2 });
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("changesetresponse", responseString);
Assert.Contains("Accepted", responseString);
Assert.Contains("No Content", responseString);
}
public void WriteResponseAsync_NullWriter_Throws()
{
ChangeSetResponseItem responseItem = new ChangeSetResponseItem(new HttpResponseMessage[0]);
Assert.ThrowsArgumentNull(
() => responseItem.WriteResponseAsync(null, CancellationToken.None).Wait(),
"writer");
}
public async Task WriteResponseAsync_NullWriter_Throws()
{
ChangeSetResponseItem responseItem = new ChangeSetResponseItem(new HttpResponseMessage[0]);
await ExceptionAssert.ThrowsArgumentNullAsync(
() => responseItem.WriteResponseAsync(null, CancellationToken.None),
"writer");
}
public async Task WriteResponseAsync_NullWriter_Throws()
{
// Arrange & Act
HttpContext[] contexts = Array.Empty <HttpContext>();
ChangeSetResponseItem responseItem = new ChangeSetResponseItem(contexts);
await ExceptionAssert.ThrowsArgumentNullAsync(() => responseItem.WriteResponseAsync(null), "writer");
}
public void Parameter_Constructor()
{
// Arrange & Act
HttpContext[] contexts = Array.Empty <HttpContext>();
ChangeSetResponseItem responseItem = new ChangeSetResponseItem(contexts);
// Assert
Assert.Same(contexts, responseItem.Contexts);
}
public async Task ExecuteChangeSetAsync_CopiesPropertiesFromRequest_WithoutExcludedProperties()
{
// Arrange
RequestDelegate handler = context =>
{
context.Features[typeof(UnbufferedODataBatchHandlerTest)] = "bar";
return(Task.FromResult(context.Response));
};
UnbufferedODataBatchHandler batchHandler = new UnbufferedODataBatchHandler();
string batchRequest = @"--cb7bb9ee-dce2-4c94-bf11-b742b2bc6072
Content-Type: multipart/mixed; boundary=""09f27d33-41ea-4334-8ace-1738bd2793a9""
--09f27d33-41ea-4334-8ace-1738bd2793a9
Content-Type: application/http
Content-Transfer-Encoding: binary
Content-ID: 1328966982
POST /values HTTP/1.1
Host: example.com
Content-Type: text/plain; charset=utf-8
foo
--09f27d33-41ea-4334-8ace-1738bd2793a9--
--cb7bb9ee-dce2-4c94-bf11-b742b2bc6072--
";
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=\"09f27d33-41ea-4334-8ace-1738bd2793a9\"";
request.ContentLength = 431;
httpContext.ODataFeature().PrefixName = "";
IServiceProvider sp = request.GetSubServiceProvider();
IODataRequestMessage oDataRequestMessage = ODataMessageWrapperHelper.Create(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>();
// Act
var response = await batchHandler.ExecuteChangeSetAsync(batchReader, Guid.NewGuid(), request, handler);
// Arrange
ChangeSetResponseItem changeSetResponseItem = Assert.IsType <ChangeSetResponseItem>(response);
HttpContext changeSetContext = Assert.Single(changeSetResponseItem.Contexts);
Assert.Equal("bar", changeSetContext.Features[typeof(UnbufferedODataBatchHandlerTest)]);
}
public override async Task <ODataBatchResponseItem> SendRequestAsync(HttpMessageInvoker invoker, CancellationToken cancellationToken)
{
if (invoker == null)
{
throw new ArgumentNullException("invoker");
}
List <HttpResponseMessage> responses = new List <HttpResponseMessage>();
SetUpChangeSetContext(_parentRequest);
ChangeSetResponseItem changeSetResponse;
try
{
foreach (HttpRequestMessage request in Requests)
{
HttpResponseMessage response = await SendSubRequestAsync(invoker, request, cancellationToken);
if (response.IsSuccessStatusCode)
{
responses.Add(response);
}
else
{
// In the case of an error response, just return the single error response
responses.DisposeAll();
responses.Clear();
responses.Add(response);
break;
}
}
// Execute the changeset completion actions
await ExecuteChangeSetCompletionActions(responses, cancellationToken);
changeSetResponse = new ChangeSetResponseItem(responses);
}
catch
{
responses.DisposeAll();
throw;
}
return(changeSetResponse);
}
public void Dispose_DisposesAllHttpResponseMessages()
{
ChangeSetResponseItem responseItem = new ChangeSetResponseItem(new MockHttpResponseMessage[]
{
new MockHttpResponseMessage(),
new MockHttpResponseMessage(),
new MockHttpResponseMessage()
});
responseItem.Dispose();
Assert.Equal(3, responseItem.Responses.Count());
foreach (var response in responseItem.Responses)
{
Assert.True(((MockHttpResponseMessage)response).IsDisposed);
}
}
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 SendRequestAsync_ReturnsChangeSetResponse()
{
// Arrange
HttpContext[] contexts = new HttpContext[]
{
HttpContextHelper.Create("Get", "http://example.com"),
HttpContextHelper.Create("Post", "http://example.com")
};
ChangeSetRequestItem requestItem = new ChangeSetRequestItem(contexts);
RequestDelegate handler = context => Task.FromResult(context.Response);
// Act
ODataBatchResponseItem response = await requestItem.SendRequestAsync(handler);
// Assert
ChangeSetResponseItem changesetResponse = Assert.IsType <ChangeSetResponseItem>(response);
Assert.Equal(2, changesetResponse.Contexts.Count());
}
public void IsResponseSuccessful_TestResponse()
{
// Arrange
HttpResponseMessage[] successResponses = new HttpResponseMessage[]
{
new HttpResponseMessage(HttpStatusCode.Accepted),
new HttpResponseMessage(HttpStatusCode.Created),
new HttpResponseMessage(HttpStatusCode.OK)
};
HttpResponseMessage[] errorResponses = new HttpResponseMessage[]
{
new HttpResponseMessage(HttpStatusCode.Created),
new HttpResponseMessage(HttpStatusCode.BadGateway),
new HttpResponseMessage(HttpStatusCode.Ambiguous)
};
ChangeSetResponseItem successResponseItem = new ChangeSetResponseItem(successResponses);
ChangeSetResponseItem errorResponseItem = new ChangeSetResponseItem(errorResponses);
// Act & Assert
Assert.True(successResponseItem.IsResponseSuccessful());
Assert.False(errorResponseItem.IsResponseSuccessful());
}
public void WriteResponse_SynchronouslyWritesChangeSet_Throws()
{
// Arrange
HttpContext context1 = HttpContextHelper.Create(StatusCodes.Status202Accepted);
HttpContext context2 = HttpContextHelper.Create(StatusCodes.Status204NoContent);
ChangeSetResponseItem responseItem = new ChangeSetResponseItem(new[] { context1, context2 });
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);
}
public void IsResponseSuccessful_TestResponse()
{
// Arrange
HttpContext[] successResponses = new HttpContext[]
{
HttpContextHelper.Create(StatusCodes.Status202Accepted),
HttpContextHelper.Create(StatusCodes.Status201Created),
HttpContextHelper.Create(StatusCodes.Status200OK)
};
HttpContext[] errorResponses = new HttpContext[]
{
HttpContextHelper.Create(StatusCodes.Status201Created),
HttpContextHelper.Create(StatusCodes.Status502BadGateway),
HttpContextHelper.Create(StatusCodes.Status300MultipleChoices)
};
ChangeSetResponseItem successResponseItem = new ChangeSetResponseItem(successResponses);
ChangeSetResponseItem errorResponseItem = new ChangeSetResponseItem(errorResponses);
// Act & Assert
Assert.True(successResponseItem.IsResponseSuccessful());
Assert.False(errorResponseItem.IsResponseSuccessful());
}
