private async Task ItemOperations(CosmosContainer container, bool containerNotExist)
{
if (containerNotExist)
{
dynamic randomItem = new { id = "test", pk = "doesnotexist" };
Stream create = jsonSerializer.ToStream <dynamic>(randomItem);
this.VerifyNotFoundResponse(await container.CreateItemAsStreamAsync(randomItem.pk, create));
var queryIterator = container.CreateItemQueryAsStream("select * from t where true", maxConcurrency: 2);
this.VerifyQueryNotFoundResponse(await queryIterator.FetchNextSetAsync());
var feedIterator = container.GetItemsStreamIterator();
this.VerifyNotFoundResponse(await feedIterator.FetchNextSetAsync());
dynamic randomUpsertItem = new { id = DoesNotExist, pk = DoesNotExist, status = 42 };
Stream upsert = jsonSerializer.ToStream <dynamic>(randomUpsertItem);
this.VerifyNotFoundResponse(await container.UpsertItemAsStreamAsync(
partitionKey: randomUpsertItem.pk,
streamPayload: upsert));
}
this.VerifyNotFoundResponse(await container.ReadItemAsStreamAsync(partitionKey: DoesNotExist, id: DoesNotExist));
this.VerifyNotFoundResponse(await container.DeleteItemAsStreamAsync(partitionKey: DoesNotExist, id: DoesNotExist));
dynamic randomReplaceItem = new { id = "test", pk = "doesnotexist", status = 42 };
Stream replace = jsonSerializer.ToStream <dynamic>(randomReplaceItem);
this.VerifyNotFoundResponse(await container.ReplaceItemAsStreamAsync(
partitionKey: randomReplaceItem.pk,
id: randomReplaceItem.id,
streamPayload: replace));
}
private async Task VerifyItemNullExceptions(
dynamic testItem,
ItemRequestOptions requestOptions = null)
{
TestHandler testHandler = new TestHandler((request, cancellationToken) =>
{
Assert.Fail("Null partition key should be blocked without the correct request option");
return null;
});
CosmosClient client = MockCosmosUtil.CreateMockCosmosClient(
(cosmosClientBuilder) => cosmosClientBuilder.AddCustomHandlers(testHandler));
CosmosContainer container = client.Databases["testdb"]
.Containers["testcontainer"];
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.CreateItemAsync<dynamic>(
partitionKey: null,
item: testItem,
requestOptions: requestOptions);
}, "CreateItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.ReadItemAsync<dynamic>(
partitionKey: null,
id: testItem.id,
requestOptions: requestOptions);
}, "ReadItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.UpsertItemAsync<dynamic>(
partitionKey: null,
item: testItem,
requestOptions: requestOptions);
}, "UpsertItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.ReplaceItemAsync<dynamic>(
partitionKey: null,
id: testItem.id,
item: testItem,
requestOptions: requestOptions);
}, "ReplaceItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.DeleteItemAsync<dynamic>(
partitionKey: null,
id: testItem.id,
requestOptions: requestOptions);
}, "DeleteItemAsync should throw ArgumentNullException without the correct request option set.");
CosmosJsonSerializerCore jsonSerializer = new CosmosJsonSerializerCore();
using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem))
{
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.CreateItemAsStreamAsync(
partitionKey: null,
streamPayload: itemStream,
requestOptions: requestOptions);
}, "CreateItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.ReadItemAsStreamAsync(
partitionKey: null,
id: testItem.id,
requestOptions: requestOptions);
}, "ReadItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.UpsertItemAsStreamAsync(
partitionKey: null,
streamPayload: itemStream,
requestOptions: requestOptions);
}, "UpsertItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.ReplaceItemAsStreamAsync(
partitionKey: null,
id: testItem.id,
streamPayload: itemStream,
requestOptions: requestOptions);
}, "ReplaceItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.DeleteItemAsStreamAsync(
partitionKey: null,
id: testItem.id,
requestOptions: requestOptions);
}, "DeleteItemAsync should throw ArgumentNullException without the correct request option set.");
}
}
private async Task VerifyItemOperations(
object partitionKey,
string partitionKeySerialized,
dynamic testItem,
ItemRequestOptions requestOptions = null)
{
CosmosResponseMessage response = null;
HttpStatusCode httpStatusCode = HttpStatusCode.OK;
int testHandlerHitCount = 0;
TestHandler testHandler = new TestHandler((request, cancellationToken) =>
{
Assert.IsTrue(request.RequestUri.OriginalString.StartsWith(@"/dbs/testdb/colls/testcontainer"));
Assert.AreEqual(requestOptions, request.RequestOptions);
Assert.AreEqual(ResourceType.Document, request.ResourceType);
Assert.IsNotNull(request.Headers.PartitionKey);
Assert.AreEqual(partitionKeySerialized, request.Headers.PartitionKey);
testHandlerHitCount++;
response = new CosmosResponseMessage(httpStatusCode, request, errorMessage: null);
response.Content = request.Content;
return Task.FromResult(response);
});
CosmosClient client = MockCosmosUtil.CreateMockCosmosClient(
(builder) => builder.AddCustomHandlers(testHandler));
CosmosContainer container = client.Databases["testdb"]
.Containers["testcontainer"];
ItemResponse<dynamic> itemResponse = await container.CreateItemAsync<dynamic>(
partitionKey: partitionKey,
item: testItem,
requestOptions: requestOptions);
Assert.IsNotNull(itemResponse);
Assert.AreEqual(httpStatusCode, itemResponse.StatusCode);
itemResponse = await container.ReadItemAsync<dynamic>(
partitionKey: partitionKey,
id: testItem.id,
requestOptions: requestOptions);
Assert.IsNotNull(itemResponse);
Assert.AreEqual(httpStatusCode, itemResponse.StatusCode);
itemResponse = await container.UpsertItemAsync<dynamic>(
partitionKey: partitionKey,
item: testItem,
requestOptions: requestOptions);
Assert.IsNotNull(itemResponse);
Assert.AreEqual(httpStatusCode, itemResponse.StatusCode);
itemResponse = await container.ReplaceItemAsync<dynamic>(
partitionKey: partitionKey,
id: testItem.id,
item: testItem,
requestOptions: requestOptions);
Assert.IsNotNull(itemResponse);
Assert.AreEqual(httpStatusCode, itemResponse.StatusCode);
itemResponse = await container.DeleteItemAsync<dynamic>(
partitionKey: partitionKey,
id: testItem.id,
requestOptions: requestOptions);
Assert.IsNotNull(itemResponse);
Assert.AreEqual(httpStatusCode, itemResponse.StatusCode);
Assert.AreEqual(5, testHandlerHitCount, "An operation did not make it to the handler");
CosmosJsonSerializerCore jsonSerializer = new CosmosJsonSerializerCore();
using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem))
{
using (CosmosResponseMessage streamResponse = await container.CreateItemAsStreamAsync(
partitionKey: partitionKey,
streamPayload: itemStream))
{
Assert.IsNotNull(streamResponse);
Assert.AreEqual(httpStatusCode, streamResponse.StatusCode);
}
}
using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem))
{
using (CosmosResponseMessage streamResponse = await container.ReadItemAsStreamAsync(
partitionKey: partitionKey,
id: testItem.id,
requestOptions: requestOptions))
{
Assert.IsNotNull(streamResponse);
Assert.AreEqual(httpStatusCode, streamResponse.StatusCode);
}
}
using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem))
{
using (CosmosResponseMessage streamResponse = await container.UpsertItemAsStreamAsync(
partitionKey: partitionKey,
streamPayload: itemStream,
requestOptions: requestOptions))
{
Assert.IsNotNull(streamResponse);
Assert.AreEqual(httpStatusCode, streamResponse.StatusCode);
}
}
using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem))
{
using (CosmosResponseMessage streamResponse = await container.ReplaceItemAsStreamAsync(
partitionKey: partitionKey,
id: testItem.id,
streamPayload: itemStream,
requestOptions: requestOptions))
{
Assert.IsNotNull(streamResponse);
Assert.AreEqual(httpStatusCode, streamResponse.StatusCode);
}
}
using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem))
{
using (CosmosResponseMessage streamResponse = await container.DeleteItemAsStreamAsync(
partitionKey: partitionKey,
id: testItem.id,
requestOptions: requestOptions))
{
Assert.IsNotNull(streamResponse);
Assert.AreEqual(httpStatusCode, streamResponse.StatusCode);
}
}
Assert.AreEqual(10, testHandlerHitCount, "A stream operation did not make it to the handler");
}