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 void WriteMessageAsync_SynchronousResponseContainsContentId_IfHasContentIdInRequestChangeSet()
{
// Arrange
HeaderDictionary headers = new HeaderDictionary
{
{ "Content-Type", $"multipart/mixed;charset=utf-8;boundary={Guid.NewGuid()}" },
};
MemoryStream ms = new MemoryStream();
IODataResponseMessage odataResponse = ODataMessageWrapperHelper.Create(ms, headers);
string contentId = Guid.NewGuid().ToString();
HttpResponse httpResponse = CreateResponse("any", new HeaderDictionary(), "text/example;charset=utf-8");
httpResponse.HttpContext.Request.SetODataContentId(contentId);
// Act
ODataBatchWriter batchWriter = new ODataMessageWriter(odataResponse).CreateODataBatchWriter();
batchWriter.WriteStartBatch();
batchWriter.WriteStartChangeset();
// Assert
Action test = () => ODataBatchResponseItem.WriteMessageAsync(batchWriter, httpResponse.HttpContext).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 async Task WriteMessageAsync_WritesResponseMessage()
{
MemoryStream ms = new MemoryStream();
HttpContent content = new StringContent(String.Empty, Encoding.UTF8, "multipart/mixed");
content.Headers.ContentType.Parameters.Add(new NameValueHeaderValue("boundary", Guid.NewGuid().ToString()));
IODataResponseMessage odataResponse = ODataMessageWrapperHelper.Create(ms, content.Headers);
var batchWriter = new ODataMessageWriter(odataResponse).CreateODataBatchWriter();
HttpResponseMessage response = new HttpResponseMessage()
{
Content = new StringContent("example content", Encoding.UTF8, "text/example")
};
response.Headers.Add("customHeader", "bar");
batchWriter.WriteStartBatch();
await ODataBatchResponseItem.WriteMessageAsync(batchWriter, response, CancellationToken.None);
batchWriter.WriteEndBatch();
ms.Position = 0;
string result = new StreamReader(ms).ReadToEnd();
Assert.Contains("example content", result);
Assert.Contains("text/example", result);
Assert.Contains("customHeader", result);
Assert.Contains("bar", result);
}
public async Task WriteMessageAsync_ResponseContainsContentId_IfHasContentIdInRequestChangeSet()
{
MemoryStream ms = new MemoryStream();
HttpContent content = new StringContent(String.Empty, Encoding.UTF8, "multipart/mixed");
content.Headers.ContentType.Parameters.Add(new NameValueHeaderValue("boundary", Guid.NewGuid().ToString()));
IODataResponseMessage odataResponse = ODataMessageWrapperHelper.Create(ms, content.Headers);
var batchWriter = new ODataMessageWriter(odataResponse).CreateODataBatchWriter();
HttpResponseMessage response = new HttpResponseMessage
{
Content = new StringContent("any", Encoding.UTF8, "text/example")
};
var request = new HttpRequestMessage();
var contentId = Guid.NewGuid().ToString();
request.SetODataContentId(contentId);
response.RequestMessage = request;
batchWriter.WriteStartBatch();
batchWriter.WriteStartChangeset();
await ODataBatchResponseItem.WriteMessageAsync(batchWriter, response, CancellationToken.None);
batchWriter.WriteEndChangeset();
batchWriter.WriteEndBatch();
ms.Position = 0;
string result = new StreamReader(ms).ReadToEnd();
Assert.Contains("any", result);
Assert.Contains("text/example", result);
Assert.Contains("Content-ID", result);
Assert.Contains(contentId, result);
}
public void WriteMessageAsync_NullWriter_Throws()
{
Assert.ThrowsArgumentNull(
() => ODataBatchResponseItem.WriteMessageAsync(null, new HttpResponseMessage(), CancellationToken.None)
.Wait(),
"writer");
}
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 WriteMessageAsync_AsynchronouslyWritesResponseMessage()
{
// Arrange
HeaderDictionary headers = new HeaderDictionary
{
{ "Content-Type", $"multipart/mixed;charset=utf-8;boundary={Guid.NewGuid()}" },
};
MemoryStream ms = new MemoryStream();
IODataResponseMessage odataResponse = ODataMessageWrapperHelper.Create(ms, headers);
HeaderDictionary responseHeaders = new HeaderDictionary
{
{ "customHeader", "bar" }
};
HttpResponse response = CreateResponse("example content", responseHeaders, "text/example");
// Act
ODataBatchWriter batchWriter = await new ODataMessageWriter(odataResponse).CreateODataBatchWriterAsync();
await batchWriter.WriteStartBatchAsync();
await ODataBatchResponseItem.WriteMessageAsync(batchWriter, response.HttpContext);
await batchWriter.WriteEndBatchAsync();
ms.Position = 0;
string result = new StreamReader(ms).ReadToEnd();
// Assert
Assert.Contains("example content", result);
Assert.Contains("text/example", result);
Assert.Contains("customHeader", result);
Assert.Contains("bar", result);
}
public void WriteMessage_SynchronouslyWritesResponseMessage_Throws()
{
HeaderDictionary headers = new HeaderDictionary
{
{ "Content-Type", $"multipart/mixed;charset=utf-8;boundary={Guid.NewGuid()}" },
};
MemoryStream ms = new MemoryStream();
IODataResponseMessage odataResponse = ODataMessageWrapperHelper.Create(ms, headers);
HeaderDictionary responseHeaders = new HeaderDictionary
{
{ "customHeader", "bar" }
};
HttpResponse response = CreateResponse("example content", responseHeaders, "text/example");
// Act
ODataBatchWriter batchWriter = new ODataMessageWriter(odataResponse).CreateODataBatchWriter();
batchWriter.WriteStartBatch();
// Assert
Action test = () => ODataBatchResponseItem.WriteMessageAsync(batchWriter, response.HttpContext).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 async Task WriteMessageAsync_NullWriter_Throws()
{
// Arrange
HttpContext context = new Mock <HttpContext>().Object;
// Act & Assert
await ExceptionAssert.ThrowsArgumentNullAsync(() => ODataBatchResponseItem.WriteMessageAsync(null, context), "writer");
}
public void WriteMessageAsync_NullResponse_Throws()
{
HttpContent content = new StringContent(String.Empty, Encoding.UTF8, "multipart/mixed");
content.Headers.ContentType.Parameters.Add(new NameValueHeaderValue("boundary", Guid.NewGuid().ToString()));
IODataResponseMessage odataResponse = new ODataMessageWrapper(new MemoryStream(), content.Headers);
ODataMessageWriter messageWriter = new ODataMessageWriter(odataResponse);
Assert.ThrowsArgumentNull(
() => ODataBatchResponseItem.WriteMessageAsync(messageWriter.CreateODataBatchWriter(), null).Wait(),
"response");
}
public async Task WriteMessageAsync_NullResponse_Throws()
{
HttpContent content = new StringContent(String.Empty, Encoding.UTF8, "multipart/mixed");
content.Headers.ContentType.Parameters.Add(new NameValueHeaderValue("boundary", Guid.NewGuid().ToString()));
IODataResponseMessage odataResponse = ODataMessageWrapperHelper.Create(new MemoryStream(), content.Headers);
ODataMessageWriter messageWriter = new ODataMessageWriter(odataResponse);
await ExceptionAssert.ThrowsArgumentNullAsync(
() => ODataBatchResponseItem.WriteMessageAsync(messageWriter.CreateODataBatchWriter(), null, CancellationToken.None),
"response");
}
public void CreateODataBatchResponseAsync_ReturnsHttpStatusCodeOK()
{
// Arrange
HttpRequestMessage request = new HttpRequestMessage();
var responses = new ODataBatchResponseItem[] { };
var quotas = new ODataMessageQuotas();
// Act
var response = request.CreateODataBatchResponseAsync(responses, quotas).Result;
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public async Task WriteMessageAsync_NullContext_Throws()
{
// Arrange
HeaderDictionary headers = new HeaderDictionary
{
{ "Content-Type", $"multipart/mixed;charset=utf-8;boundary={Guid.NewGuid()}" },
};
IODataResponseMessage odataResponse = ODataMessageWrapperHelper.Create(new MemoryStream(), headers);
ODataMessageWriter messageWriter = new ODataMessageWriter(odataResponse);
// Act & Assert
await ExceptionAssert.ThrowsArgumentNullAsync(
() => ODataBatchResponseItem.WriteMessageAsync(messageWriter.CreateODataBatchWriter(), null), "context");
}
public async Task CreateODataBatchResponseAsync_ReturnsHttpStatusCodeOK()
{
// Arrange
HttpRequestMessage request = new HttpRequestMessage();
request.EnableHttpDependencyInjectionSupport();
var responses = new ODataBatchResponseItem[] { };
var quotas = new ODataMessageQuotas();
// Act
var response = await request.CreateODataBatchResponseAsync(responses, quotas);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public void CreateResponseMessageAsync_ReturnsODataBatchContent()
{
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler(new HttpServer());
ODataBatchResponseItem[] responses = new ODataBatchResponseItem[]
{
new OperationResponseItem(new HttpResponseMessage(HttpStatusCode.OK))
};
HttpResponseMessage response = batchHandler.CreateResponseMessageAsync(responses, new HttpRequestMessage(), CancellationToken.None).Result;
var batchContent = Assert.IsType <ODataBatchContent>(response.Content);
Assert.Equal(1, batchContent.Responses.Count());
}
public async Task CreateResponseMessageAsync_ReturnsODataBatchContent()
{
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler(new HttpServer());
ODataBatchResponseItem[] responses = new ODataBatchResponseItem[]
{
new OperationResponseItem(new HttpResponseMessage(HttpStatusCode.OK))
};
HttpRequestMessage request = new HttpRequestMessage();
request.EnableHttpDependencyInjectionSupport();
HttpResponseMessage response = await batchHandler.CreateResponseMessageAsync(responses, request, CancellationToken.None);
var batchContent = Assert.IsType <ODataBatchContent>(response.Content);
Assert.Single(batchContent.Responses);
}
public async Task CreateODataBatchResponseAsync_ReturnsHttpStatusCodeOK()
{
// Arrange
IEdmModel model = new EdmModel();
HttpContext context = new DefaultHttpContext();
HttpRequest request = context.Request;
context.ODataFeature().RoutePrefix = "odata";
context.RequestServices = BuildServiceProvider(opt => opt.AddRouteComponents("odata", model));
ODataBatchResponseItem[] responses = new ODataBatchResponseItem[] { };
ODataMessageQuotas quotas = new ODataMessageQuotas();
// Act
await request.CreateODataBatchResponseAsync(responses, quotas);
// Assert
Assert.Equal(StatusCodes.Status200OK, context.Response.StatusCode);
}
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 async Task WriteMessageAsync_ResponseContainsContentId_IfHasContentIdInRequestChangeSet()
{
// Arrange
HeaderDictionary headers = new HeaderDictionary
{
{ "Content-Type", $"multipart/mixed;charset=utf-8;boundary={Guid.NewGuid()}" },
};
MemoryStream ms = new MemoryStream();
IODataResponseMessage odataResponse = ODataMessageWrapperHelper.Create(ms, headers);
string contentId = Guid.NewGuid().ToString();
HttpResponse httpResponse = CreateResponse("any", new HeaderDictionary(), "text/example;charset=utf-8");
httpResponse.HttpContext.Request.SetODataContentId(contentId);
// Act
ODataBatchWriter batchWriter = await new ODataMessageWriter(odataResponse).CreateODataBatchWriterAsync();
await batchWriter.WriteStartBatchAsync();
await batchWriter.WriteStartChangesetAsync();
await ODataBatchResponseItem.WriteMessageAsync(batchWriter, httpResponse.HttpContext);
await batchWriter.WriteEndChangesetAsync();
await batchWriter.WriteEndBatchAsync();
ms.Position = 0;
string result = new StreamReader(ms).ReadToEnd();
// Assert
Assert.Contains("any", result);
Assert.Contains("text/example", result);
Assert.Contains("Content-ID", result);
Assert.Contains(contentId, result);
}
public async Task CreateResponseMessageAsync_ReturnsODataBatchContent()
{
// Arrange
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler();
HttpRequest request = RequestFactory.Create(opt => opt.AddModel("odata", EdmCoreModel.Instance));
request.ODataFeature().PrefixName = "odata";
HttpContext httpContext = request.HttpContext;
httpContext.Response.StatusCode = StatusCodes.Status200OK;
httpContext.Response.Body = new MemoryStream();
ODataBatchResponseItem[] responses = new ODataBatchResponseItem[]
{
new OperationResponseItem(httpContext)
};
// Act
await batchHandler.CreateResponseMessageAsync(responses, request);
// Assert
string responseString = httpContext.Response.ReadBody();
Assert.Contains("200 OK", responseString);
}
public async Task WriteMessageAsync_NullWriter_Throws()
{
await ExceptionAssert.ThrowsArgumentNullAsync(
() => ODataBatchResponseItem.WriteMessageAsync(null, new HttpResponseMessage(), CancellationToken.None),
"writer");
}
