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 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 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 static Controller CreateController([NotNull] Type type, RouteData routeData = null)
{
if (!typeof(Controller).IsAssignableFrom(type))
{
throw new TypeAccessException($"Type '{type}' is not a Controller.");
}
Controller controller = (Controller)Activator.CreateInstance(type);
routeData ??= new RouteData();
if (!routeData.Values.Any(v => v.Key.IsSame("controller")))
{
routeData.Values.Add("controller", controller.GetType().Name.ToLower().Replace("controller", string.Empty));
}
if (HttpContext.Current == null)
{
HttpContext ctx = HttpContextHelper.Create((Uri)null);
HttpContext.Current = ctx;
}
HttpContextWrapper wrapper = new HttpContextWrapper(HttpContext.Current);
controller.ControllerContext = new ControllerContext(wrapper, routeData, controller);
controller.Url = new UrlHelper(new RequestContext(wrapper, routeData));
return(controller);
}
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 SendRequestAsync_CallsHandler()
{
// Arrange
HttpContext context = HttpContextHelper.Create("Get", "http://example.com");
RequestDelegate handler = context =>
{
context.Response.StatusCode = StatusCodes.Status201Created;
return(Task.FromResult(context.Response));
};
// Act
await ODataBatchRequestItem.SendRequestAsync(handler, context, new Dictionary <string, string>());
// Assert
Assert.Equal(StatusCodes.Status201Created, context.Response.StatusCode);
}
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 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);
}
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());
}
public async Task ParseBatchRequestsAsync_CopiesPropertiesFromRequest_WithoutExcludedProperties()
{
// Arrange
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler();
string batchRequest = @"
--7289e6c2-adbd-4dd8-bfb1-f36099442947
Content-Type: application/http
Content-Transfer-Encoding: binary
Content-ID: 1430195875
GET / HTTP/1.1
Host: example.com
--7289e6c2-adbd-4dd8-bfb1-f36099442947
Content-Type: multipart/mixed;boundary=e58fa556-67f1-4180-b04e-e28df22ac4d9
--e58fa556-67f1-4180-b04e-e28df22ac4d9
Content-Type: application/http
Content-Transfer-Encoding: binary
Content-ID: 675766617
POST /values HTTP/1.1
Host: example.com
--e58fa556-67f1-4180-b04e-e28df22ac4d9--
--7289e6c2-adbd-4dd8-bfb1-f36099442947--
";
HttpContext httpContext = HttpContextHelper.Create("Post", "http://example.com/$batch");
byte[] requestBytes = Encoding.UTF8.GetBytes(batchRequest);
httpContext.Request.Body = new MemoryStream(requestBytes);
httpContext.Request.ContentType = "multipart/mixed;boundary=7289e6c2-adbd-4dd8-bfb1-f36099442947";
httpContext.Request.ContentLength = requestBytes.Length;
IEdmModel model = new EdmModel();
httpContext.ODataFeature().PrefixName = "odata";
httpContext.RequestServices = BuildServiceProvider(opt => opt.AddModel("odata", model));
httpContext.Response.Body = new MemoryStream();
batchHandler.PrefixName = "odata";
httpContext.Features[typeof(DefaultODataBatchHandlerTest)] = "bar";
// Act
IList <ODataBatchRequestItem> requests = await batchHandler.ParseBatchRequestsAsync(httpContext);
// Assert
Assert.Equal(2, requests.Count);
var operationContext = ((OperationRequestItem)requests[0]).Context;
Assert.Equal("GET", operationContext.Request.Method);
Assert.Equal("http://example.com/", operationContext.Request.GetDisplayUrl());
Assert.Equal("bar", operationContext.Features[typeof(DefaultODataBatchHandlerTest)]);
var changeSetContext = ((ChangeSetRequestItem)requests[1]).Contexts.First();
Assert.Equal("POST", changeSetContext.Request.Method);
Assert.Equal("http://example.com/values", changeSetContext.Request.GetDisplayUrl());
Assert.Equal("bar", operationContext.Features[typeof(DefaultODataBatchHandlerTest)]);
}
public async Task ProcessBatchAsync_DoesNotCopyContentHeadersToGetAndDelete()
{
// Arrange
string batchRequest = @"
--40e2c6b6-e6ce-43aa-9985-ddc12dc4bb9b
Content-Type: application/http
Content-Transfer-Encoding: binary
Content-ID: 483818399
GET / HTTP/1.1
Host: example.com
--40e2c6b6-e6ce-43aa-9985-ddc12dc4bb9b
Content-Type: application/http
Content-Transfer-Encoding: binary
Content-ID: 1035669256
DELETE / HTTP/1.1
Host: example.com
--40e2c6b6-e6ce-43aa-9985-ddc12dc4bb9b
Content-Type: application/http
Content-Transfer-Encoding: binary
Content-ID: 632310651
POST /values HTTP/1.1
Host: example.com
Content-Type: text/plain; charset=utf-8
bar
--40e2c6b6-e6ce-43aa-9985-ddc12dc4bb9b--
";
RequestDelegate handler = async context =>
{
HttpRequest request = context.Request;
string responseContent = $"{request.Method},{request.ContentLength},{request.ContentType}";
await context.Response.WriteAsync(responseContent);
};
HttpContext httpContext = HttpContextHelper.Create("Post", "http://example.com/$batch");
byte[] requestBytes = Encoding.UTF8.GetBytes(batchRequest);
httpContext.Request.Body = new MemoryStream(requestBytes);
httpContext.Request.ContentType = "multipart/mixed;boundary=40e2c6b6-e6ce-43aa-9985-ddc12dc4bb9b";
httpContext.Request.ContentLength = requestBytes.Length;
IEdmModel model = new EdmModel();
httpContext.ODataFeature().PrefixName = "odata";
httpContext.RequestServices = BuildServiceProvider(opt => opt.AddModel("odata", model));
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler();
httpContext.Response.Body = new MemoryStream();
batchHandler.PrefixName = "odata";
// Act
await batchHandler.ProcessBatchAsync(httpContext, handler);
string responseBody = httpContext.Response.ReadBody();
// Assert
Assert.NotNull(responseBody);
Assert.Contains("GET,,", responseBody);
Assert.Contains("DELETE,,", responseBody);
Assert.Contains("POST,3,text/plain; charset=utf-8", responseBody);
}
public async Task ProcessBatchAsync_ContinueOnError(bool enableContinueOnError, string preferenceHeader, bool hasThirdResponse)
{
// Arrange
RequestDelegate handler = async context =>
{
HttpRequest request = context.Request;
string responseContent = request.GetDisplayUrl();
string content = request.ReadBody();
if (!string.IsNullOrEmpty(content))
{
responseContent += "," + content;
}
HttpResponse response = context.Response;
if (content.Equals("foo"))
{
response.StatusCode = StatusCodes.Status400BadRequest;
}
await response.WriteAsync(responseContent);
};
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler();
HttpContext httpContext = HttpContextHelper.Create("Post", "http://example.com/$batch");
string batchRequest = @"--d3df74a8-8212-4c2a-b4fb-d713a4ba383e
Content-Type: application/http
Content-Transfer-Encoding: binary
Content-ID: 1948857409
GET / HTTP/1.1
Host: example.com
--d3df74a8-8212-4c2a-b4fb-d713a4ba383e
Content-Type: multipart/mixed; boundary=""3c4d5753-d325-4806-8c80-38f4a5fbe523""
--3c4d5753-d325-4806-8c80-38f4a5fbe523
Content-Type: application/http
Content-Transfer-Encoding: binary
Content-ID: 1856004745
POST /values HTTP/1.1
Host: example.com
Content-Type: text/plain; charset=utf-8
foo
--3c4d5753-d325-4806-8c80-38f4a5fbe523--
--d3df74a8-8212-4c2a-b4fb-d713a4ba383e
Content-Type: application/http
Content-Transfer-Encoding: binary
Content-ID: -2010824035
POST /values HTTP/1.1
Host: example.com
Content-Type: text/plain; charset=utf-8
bar
--d3df74a8-8212-4c2a-b4fb-d713a4ba383e--
";
byte[] requestBytes = Encoding.UTF8.GetBytes(batchRequest);
httpContext.Request.Body = new MemoryStream(requestBytes);
httpContext.Request.ContentType = "multipart/mixed;boundary=\"d3df74a8-8212-4c2a-b4fb-d713a4ba383e\"";
httpContext.Request.ContentLength = 827;
IEdmModel model = new EdmModel();
httpContext.ODataFeature().PrefixName = "odata";
httpContext.RequestServices = BuildServiceProvider(opt => opt.AddModel("odata", model).EnableContinueOnErrorHeader = enableContinueOnError);
if (preferenceHeader != null)
{
httpContext.Request.Headers.Add("prefer", preferenceHeader);
}
httpContext.Response.Body = new MemoryStream();
batchHandler.PrefixName = "odata";
// Act
await batchHandler.ProcessBatchAsync(httpContext, handler);
string responseBody = httpContext.Response.ReadBody();
// Assert
Assert.NotNull(responseBody);
// #1 response
Assert.Contains("http://example.com/", responseBody);
// #2 bad response
Assert.Contains("Bad Request", responseBody);
Assert.Contains("http://example.com/values,foo", responseBody);
// #3 response
if (hasThirdResponse)
{
Assert.Contains("http://example.com/values,bar", responseBody);
}
else
{
Assert.DoesNotContain("http://example.com/values,bar", responseBody);
}
}