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 SendRequestAsync_ReturnsSingleErrorResponse()
{
HttpRequestMessage[] requests = new HttpRequestMessage[]
{
new HttpRequestMessage(HttpMethod.Get, "http://example.com"),
new HttpRequestMessage(HttpMethod.Post, "http://example.com"),
new HttpRequestMessage(HttpMethod.Put, "http://example.com")
};
ChangeSetRequestItem requestItem = new ChangeSetRequestItem(requests);
Mock <HttpMessageInvoker> invoker = new Mock <HttpMessageInvoker>(new HttpServer());
invoker.Setup(i => i.SendAsync(It.IsAny <HttpRequestMessage>(), CancellationToken.None))
.Returns <HttpRequestMessage, CancellationToken>((req, c) =>
{
if (req.Method == HttpMethod.Post)
{
return(Task.FromResult(new HttpResponseMessage(HttpStatusCode.BadRequest)));
}
return(Task.FromResult(new HttpResponseMessage()));
});
var response = requestItem.SendRequestAsync(invoker.Object, CancellationToken.None).Result;
var changesetResponse = Assert.IsType <ChangeSetResponseItem>(response);
Assert.Equal(1, changesetResponse.Responses.Count());
Assert.Equal(HttpStatusCode.BadRequest, changesetResponse.Responses.First().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 SendRequestAsync_DisposesResponseInCaseOfException()
{
List <MockHttpResponseMessage> responses = new List <MockHttpResponseMessage>();
ChangeSetRequestItem requestItem = new ChangeSetRequestItem(new HttpRequestMessage[]
{
new HttpRequestMessage(HttpMethod.Get, "http://example.com"),
new HttpRequestMessage(HttpMethod.Post, "http://example.com"),
new HttpRequestMessage(HttpMethod.Put, "http://example.com")
});
Mock <HttpMessageInvoker> invoker = new Mock <HttpMessageInvoker>(new HttpServer());
invoker.Setup(i => i.SendAsync(It.IsAny <HttpRequestMessage>(), CancellationToken.None))
.Returns <HttpRequestMessage, CancellationToken>((req, cancel) =>
{
if (req.Method == HttpMethod.Put)
{
throw new InvalidOperationException();
}
var response = new MockHttpResponseMessage();
responses.Add(response);
return(Task.FromResult <HttpResponseMessage>(response));
});
Assert.Throws <InvalidOperationException>(
() => requestItem.SendRequestAsync(invoker.Object, CancellationToken.None).Result);
Assert.Equal(2, responses.Count);
foreach (var response in responses)
{
Assert.True(response.IsDisposed);
}
}
private async Task ExecuteChangeSet(ChangeSetRequestItem changeSet, IList <ODataBatchResponseItem> responses, CancellationToken cancellation)
{
ChangeSetResponseItem changeSetResponse;
using (var context = new SqliteContext())
{
foreach (HttpRequestMessage request in changeSet.Requests)
{
request.SetContext(context);
}
using (DbContextTransaction transaction = context.Database.BeginTransaction())
{
changeSetResponse = (ChangeSetResponseItem)await changeSet.SendRequestAsync(Invoker, cancellation);
responses.Add(changeSetResponse);
if (changeSetResponse.Responses.All(r => r.IsSuccessStatusCode))
{
transaction.Commit();
}
else
{
transaction.Rollback();
}
}
}
}
private async Task ExecuteChangeSet(
ChangeSetRequestItem changeSet,
IList <ODataBatchResponseItem> responses,
CancellationToken cancellation)
{
ChangeSetResponseItem changeSetResponse;
// Create a new ShoppingContext instance, associate it with each of the requests, start a new
// transaction, execute the changeset and then commit or rollback the transaction depending on
// whether the responses were all successful or not.
using (ShoppingContext context = new ShoppingContext())
{
foreach (HttpRequestMessage request in changeSet.Requests)
{
request.SetContext(context);
}
using (DbContextTransaction transaction = context.Database.BeginTransaction())
{
changeSetResponse = (ChangeSetResponseItem)await changeSet.SendRequestAsync(Invoker, cancellation);
responses.Add(changeSetResponse);
if (changeSetResponse.Responses.All(r => r.IsSuccessStatusCode))
{
transaction.Commit();
}
else
{
transaction.Rollback();
}
}
}
}
public void SendRequestAsync_NullInvoker_Throws()
{
ChangeSetRequestItem requestItem = new ChangeSetRequestItem(new HttpRequestMessage[0]);
Assert.ThrowsArgumentNull(
() => requestItem.SendRequestAsync(null, CancellationToken.None).Wait(),
"invoker");
}
public async Task SendRequestAsync_NullInvoker_Throws()
{
ChangeSetRequestItem requestItem = new ChangeSetRequestItem(new HttpRequestMessage[0]);
await ExceptionAssert.ThrowsArgumentNullAsync(
() => requestItem.SendRequestAsync(null, CancellationToken.None),
"invoker");
}
public async Task SendRequestAsync_NullHandler_Throws()
{
// Arrange
HttpContext[] contexts = Array.Empty <HttpContext>();
ChangeSetRequestItem requestItem = new ChangeSetRequestItem(contexts);
// Act & Assert
await ExceptionAssert.ThrowsArgumentNullAsync(() => requestItem.SendRequestAsync(null), "handler");
}
public override async Task <ODataBatchResponseItem> SendRequestAsync(RequestDelegate handler)
{
using (var transaction = await _dbContext.Database.BeginTransactionAsync()) {
var response = await _changeSetRequestItem.SendRequestAsync(handler) as ChangeSetResponseItem;
if (response.Contexts.All(c => c.Response.IsSuccessStatusCode()))
{
transaction.Commit();
}
else
{
transaction.Rollback();
}
return(response);
}
}
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 SendRequestAsync_ReturnsChangeSetResponse()
{
HttpRequestMessage[] requests = new HttpRequestMessage[]
{
new HttpRequestMessage(HttpMethod.Get, "http://example.com"),
new HttpRequestMessage(HttpMethod.Post, "http://example.com")
};
ChangeSetRequestItem requestItem = new ChangeSetRequestItem(requests);
Mock <HttpMessageInvoker> invoker = new Mock <HttpMessageInvoker>(new HttpServer());
invoker.Setup(i => i.SendAsync(It.IsAny <HttpRequestMessage>(), CancellationToken.None))
.Returns(() =>
{
return(Task.FromResult(new HttpResponseMessage()));
});
var response = requestItem.SendRequestAsync(invoker.Object, CancellationToken.None).Result;
var changesetResponse = Assert.IsType <ChangeSetResponseItem>(response);
Assert.Equal(2, changesetResponse.Responses.Count());
}
