public async Task StandByFeedIterator_WithMaxItemCount()
{
await this.CreateRandomItems(2, randomPartitionKey : true);
CosmosItemsCore itemsCore = (CosmosItemsCore)this.Container.Items;
CosmosFeedResultSetIterator setIterator = itemsCore.GetStandByFeedIterator(maxItemCount: 1, requestOptions: new CosmosChangeFeedRequestOptions()
{
StartTime = DateTime.MinValue
});
while (setIterator.HasMoreResults)
{
using (CosmosResponseMessage responseMessage =
await setIterator.FetchNextSetAsync(this.cancellationToken))
{
if (responseMessage.IsSuccessStatusCode)
{
Collection <ToDoActivity> response = new CosmosDefaultJsonSerializer().FromStream <CosmosFeedResponse <ToDoActivity> >(responseMessage.Content).Data;
if (response.Count > 0)
{
Assert.AreEqual(1, response.Count);
return;
}
}
}
}
Assert.Fail("Found no batch with size 1");
}
public async Task TestInitialize()
{
await base.TestInit();
string PartitionKey = "/status";
CosmosContainerResponse response = await this.database.Containers.CreateContainerAsync(
new CosmosContainerSettings(id : Guid.NewGuid().ToString(), partitionKeyPath : PartitionKey),
cancellationToken : this.cancellationToken);
Assert.IsNotNull(response);
this.container = response;
this.jsonSerializer = new CosmosDefaultJsonSerializer();
}
public void ValidateJson()
{
CosmosDefaultJsonSerializer cosmosDefaultJsonSerializer = new CosmosDefaultJsonSerializer();
using (Stream stream = cosmosDefaultJsonSerializer.ToStream <ToDoActivity>(toDoActivity))
{
Assert.IsNotNull(stream);
using (StreamReader reader = new StreamReader(stream))
{
string responseAsString = reader.ReadToEnd();
Assert.IsNotNull(responseAsString);
Assert.AreEqual(toDoActivityJson, responseAsString);
}
}
}
public async Task StandByFeedIterator_NoFetchNext()
{
var pkRanges = await this.Container.ClientContext.DocumentClient.ReadPartitionKeyRangeFeedAsync(this.Container.LinkUri);
int expected = 25;
int iterations = 0;
await this.CreateRandomItems(expected, randomPartitionKey : true);
CosmosItemsCore itemsCore = (CosmosItemsCore)this.Container.Items;
string continuationToken = null;
int count = 0;
while (true)
{
CosmosChangeFeedRequestOptions requestOptions = new CosmosChangeFeedRequestOptions()
{
StartTime = DateTime.MinValue
};
CosmosFeedResultSetIterator setIterator = itemsCore.GetStandByFeedIterator(continuationToken, requestOptions: requestOptions);
using (CosmosResponseMessage responseMessage =
await setIterator.FetchNextSetAsync(this.cancellationToken))
{
continuationToken = responseMessage.Headers.Continuation;
if (responseMessage.IsSuccessStatusCode)
{
Collection <ToDoActivity> response = new CosmosDefaultJsonSerializer().FromStream <CosmosFeedResponse <ToDoActivity> >(responseMessage.Content).Data;
count += response.Count;
}
}
if (count > expected)
{
Assert.Fail($"{count} does not equal {expected}");
}
if (count.Equals(expected))
{
break;
}
if (iterations++ > pkRanges.Count)
{
Assert.Fail("Feed does not contain all elements even after looping through PK ranges. Either the continuation is not moving forward or there is some state problem.");
}
}
}
public void ValidateSerializer()
{
CosmosDefaultJsonSerializer cosmosDefaultJsonSerializer = new CosmosDefaultJsonSerializer();
using (Stream stream = cosmosDefaultJsonSerializer.ToStream <ToDoActivity>(toDoActivity))
{
Assert.IsNotNull(stream);
ToDoActivity result = cosmosDefaultJsonSerializer.FromStream <ToDoActivity>(stream);
Assert.IsNotNull(result);
Assert.AreEqual(toDoActivity.id, result.id);
Assert.AreEqual(toDoActivity.taskNum, result.taskNum);
Assert.AreEqual(toDoActivity.cost, result.cost);
Assert.AreEqual(toDoActivity.description, result.description);
Assert.AreEqual(toDoActivity.status, result.status);
}
}
public async Task StreamIteratorTest()
{
string containerName = Guid.NewGuid().ToString();
string partitionKeyPath = "/users";
CosmosContainerResponse containerResponse = await this.cosmosDatabase.Containers.CreateContainerAsync(containerName, partitionKeyPath);
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
Assert.AreEqual(containerName, containerResponse.Resource.Id);
Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First());
containerName = Guid.NewGuid().ToString();
containerResponse = await this.cosmosDatabase.Containers.CreateContainerAsync(containerName, partitionKeyPath);
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
Assert.AreEqual(containerName, containerResponse.Resource.Id);
Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First());
HashSet <string> containerIds = new HashSet <string>();
CosmosFeedResultSetIterator resultSet = this.cosmosDatabase.Containers.GetContainerStreamIterator(
maxItemCount: 1,
requestOptions: new CosmosQueryRequestOptions());
while (resultSet.HasMoreResults)
{
using (CosmosResponseMessage message = await resultSet.FetchNextSetAsync())
{
Assert.AreEqual(HttpStatusCode.OK, message.StatusCode);
CosmosDefaultJsonSerializer defaultJsonSerializer = new CosmosDefaultJsonSerializer();
dynamic containers = defaultJsonSerializer.FromStream <dynamic>(message.Content).DocumentCollections;
foreach (dynamic container in containers)
{
string id = container.id.ToString();
containerIds.Add(id);
}
}
}
Assert.IsTrue(containerIds.Count > 0, "The iterator did not find any containers.");
Assert.IsTrue(containerIds.Contains(containerName), "The iterator did not find the created container");
containerResponse = await containerResponse.Container.DeleteAsync();
Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode);
}
public async Task ItemStreamIterator()
{
IList <ToDoActivity> deleteList = null;
HashSet <string> itemIds = null;
try
{
deleteList = await CreateRandomItems(3, randomPartitionKey : true);
itemIds = deleteList.Select(x => x.id).ToHashSet <string>();
CosmosFeedResultSetIterator setIterator =
this.Container.Items.GetItemStreamIterator();
while (setIterator.HasMoreResults)
{
using (CosmosResponseMessage iterator =
await setIterator.FetchNextSetAsync(this.cancellationToken))
{
Collection <ToDoActivity> response = new CosmosDefaultJsonSerializer().FromStream <CosmosFeedResponse <ToDoActivity> >(iterator.Content).Data;
foreach (ToDoActivity toDoActivity in response)
{
if (itemIds.Contains(toDoActivity.id))
{
itemIds.Remove(toDoActivity.id);
}
}
}
}
}
finally
{
foreach (ToDoActivity delete in deleteList)
{
CosmosResponseMessage deleteResponse = await this.Container.Items.DeleteItemStreamAsync(delete.status, delete.id);
deleteResponse.Dispose();
}
}
Assert.AreEqual(itemIds.Count, 0);
}
public async Task TestInitialize()
{
this.cancellationTokenSource = new CancellationTokenSource();
this.cancellationToken = this.cancellationTokenSource.Token;
this.cosmosClient = TestCommon.CreateCosmosClient();
this.database = await this.cosmosClient.Databases.CreateDatabaseAsync(Guid.NewGuid().ToString(),
cancellationToken : this.cancellationToken);
this.documentClient = TestCommon.CreateClient(true, defaultConsistencyLevel: Documents.ConsistencyLevel.Session);
string PartitionKey = "/partitionKey";
CosmosContainerResponse response = await this.database.Containers.CreateContainerAsync(
new CosmosContainerSettings(id : Guid.NewGuid().ToString(), partitionKeyPath : PartitionKey),
cancellationToken : this.cancellationToken);
Assert.IsNotNull(response);
Assert.IsNotNull(response.Container);
Assert.IsNotNull(response.Resource);
this.Container = response;
this.jsonSerializer = new CosmosDefaultJsonSerializer();
}
public async Task ItemStreamIterator(bool useStatelessIterator)
{
IList <ToDoActivity> deleteList = await this.CreateRandomItems(3, randomPartitionKey : true);
HashSet <string> itemIds = deleteList.Select(x => x.id).ToHashSet <string>();
string lastContinuationToken = null;
int pageSize = 1;
CosmosItemRequestOptions requestOptions = new CosmosItemRequestOptions();
CosmosFeedResultSetIterator setIterator =
this.Container.Items.GetItemStreamIterator(maxItemCount: pageSize, continuationToken: lastContinuationToken, requestOptions: requestOptions);
while (setIterator.HasMoreResults)
{
if (useStatelessIterator)
{
setIterator = this.Container.Items.GetItemStreamIterator(maxItemCount: pageSize, continuationToken: lastContinuationToken, requestOptions: requestOptions);
}
using (CosmosResponseMessage responseMessage =
await setIterator.FetchNextSetAsync(this.cancellationToken))
{
lastContinuationToken = responseMessage.Headers.Continuation;
Collection <ToDoActivity> response = new CosmosDefaultJsonSerializer().FromStream <CosmosFeedResponse <ToDoActivity> >(responseMessage.Content).Data;
foreach (ToDoActivity toDoActivity in response)
{
if (itemIds.Contains(toDoActivity.id))
{
itemIds.Remove(toDoActivity.id);
}
}
}
}
Assert.IsNull(lastContinuationToken);
Assert.AreEqual(itemIds.Count, 0);
}
public async Task StandByFeedIterator()
{
int totalCount = 0;
string lastcontinuation = string.Empty;
int firstRunTotal = 25;
int batchSize = 25;
Documents.Routing.Range <string> previousRange = null;
Documents.Routing.Range <string> currentRange = null;
int pkRangesCount = (await this.Container.ClientContext.DocumentClient.ReadPartitionKeyRangeFeedAsync(this.Container.LinkUri)).Count;
int visitedPkRanges = 0;
await this.CreateRandomItems(batchSize, randomPartitionKey : true);
CosmosItemsCore itemsCore = (CosmosItemsCore)this.Container.Items;
CosmosFeedResultSetIterator setIterator = itemsCore.GetStandByFeedIterator(requestOptions: new CosmosChangeFeedRequestOptions()
{
StartTime = DateTime.MinValue
});
while (setIterator.HasMoreResults)
{
using (CosmosResponseMessage responseMessage =
await setIterator.FetchNextSetAsync(this.cancellationToken))
{
lastcontinuation = responseMessage.Headers.Continuation;
List <CompositeContinuationToken> deserializedToken = JsonConvert.DeserializeObject <List <CompositeContinuationToken> >(lastcontinuation);
currentRange = deserializedToken[0].Range;
Assert.AreEqual(pkRangesCount, deserializedToken.Count);
if (responseMessage.IsSuccessStatusCode)
{
Collection <ToDoActivity> response = new CosmosDefaultJsonSerializer().FromStream <CosmosFeedResponse <ToDoActivity> >(responseMessage.Content).Data;
totalCount += response.Count;
}
if (!currentRange.Equals(previousRange))
{
visitedPkRanges++;
}
if (visitedPkRanges == pkRangesCount && responseMessage.StatusCode == System.Net.HttpStatusCode.NotModified)
{
break;
}
previousRange = currentRange;
}
}
Assert.AreEqual(firstRunTotal, totalCount);
int expectedFinalCount = 50;
previousRange = null;
currentRange = null;
visitedPkRanges = 0;
// Insert another batch of 25 and use the last continuation token from the first cycle
await this.CreateRandomItems(batchSize, randomPartitionKey : true);
CosmosFeedResultSetIterator setIteratorNew =
itemsCore.GetStandByFeedIterator(lastcontinuation);
while (setIteratorNew.HasMoreResults)
{
using (CosmosResponseMessage responseMessage =
await setIteratorNew.FetchNextSetAsync(this.cancellationToken))
{
lastcontinuation = responseMessage.Headers.Continuation;
currentRange = JsonConvert.DeserializeObject <List <CompositeContinuationToken> >(lastcontinuation)[0].Range;
if (responseMessage.IsSuccessStatusCode)
{
Collection <ToDoActivity> response = new CosmosDefaultJsonSerializer().FromStream <CosmosFeedResponse <ToDoActivity> >(responseMessage.Content).Data;
totalCount += response.Count;
}
if (!currentRange.Equals(previousRange))
{
visitedPkRanges++;
}
if (visitedPkRanges == pkRangesCount && responseMessage.StatusCode == System.Net.HttpStatusCode.NotModified)
{
break;
}
previousRange = currentRange;
}
}
Assert.AreEqual(expectedFinalCount, totalCount);
}
private async Task VerifyItemNullExceptions(
dynamic testItem,
CosmosItemRequestOptions 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 = MockDocumentClient.CreateMockCosmosClient(
(cosmosClientBuilder) => cosmosClientBuilder.AddCustomHandlers(testHandler));
CosmosContainer container = client.Databases["testdb"]
.Containers["testcontainer"];
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() =>
{
await container.Items.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.Items.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.Items.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.Items.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.Items.DeleteItemAsync <dynamic>(
partitionKey: null,
id: testItem.id,
requestOptions: requestOptions);
}, "DeleteItemAsync should throw ArgumentNullException without the correct request option set.");
CosmosDefaultJsonSerializer jsonSerializer = new CosmosDefaultJsonSerializer();
using (Stream itemStream = jsonSerializer.ToStream <dynamic>(testItem))
{
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() =>
{
await container.Items.CreateItemStreamAsync(
partitionKey: null,
streamPayload: itemStream,
requestOptions: requestOptions);
}, "CreateItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() =>
{
await container.Items.ReadItemStreamAsync(
partitionKey: null,
id: testItem.id,
requestOptions: requestOptions);
}, "ReadItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() =>
{
await container.Items.UpsertItemStreamAsync(
partitionKey: null,
streamPayload: itemStream,
requestOptions: requestOptions);
}, "UpsertItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() =>
{
await container.Items.ReplaceItemStreamAsync(
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.Items.DeleteItemStreamAsync(
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,
CosmosItemRequestOptions 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 = MockDocumentClient.CreateMockCosmosClient(
(builder) => builder.AddCustomHandlers(testHandler));
CosmosContainer container = client.Databases["testdb"]
.Containers["testcontainer"];
CosmosItemResponse <dynamic> itemResponse = await container.Items.CreateItemAsync <dynamic>(
partitionKey : partitionKey,
item : testItem,
requestOptions : requestOptions);
Assert.IsNotNull(itemResponse);
Assert.AreEqual(httpStatusCode, itemResponse.StatusCode);
itemResponse = await container.Items.ReadItemAsync <dynamic>(
partitionKey : partitionKey,
id : testItem.id,
requestOptions : requestOptions);
Assert.IsNotNull(itemResponse);
Assert.AreEqual(httpStatusCode, itemResponse.StatusCode);
itemResponse = await container.Items.UpsertItemAsync <dynamic>(
partitionKey : partitionKey,
item : testItem,
requestOptions : requestOptions);
Assert.IsNotNull(itemResponse);
Assert.AreEqual(httpStatusCode, itemResponse.StatusCode);
itemResponse = await container.Items.ReplaceItemAsync <dynamic>(
partitionKey : partitionKey,
id : testItem.id,
item : testItem,
requestOptions : requestOptions);
Assert.IsNotNull(itemResponse);
Assert.AreEqual(httpStatusCode, itemResponse.StatusCode);
itemResponse = await container.Items.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");
CosmosDefaultJsonSerializer jsonSerializer = new CosmosDefaultJsonSerializer();
using (Stream itemStream = jsonSerializer.ToStream <dynamic>(testItem))
{
using (CosmosResponseMessage streamResponse = await container.Items.CreateItemStreamAsync(
partitionKey: partitionKey,
streamPayload: itemStream))
{
Assert.IsNotNull(streamResponse);
Assert.AreEqual(httpStatusCode, streamResponse.StatusCode);
}
}
using (Stream itemStream = jsonSerializer.ToStream <dynamic>(testItem))
{
using (CosmosResponseMessage streamResponse = await container.Items.ReadItemStreamAsync(
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.Items.UpsertItemStreamAsync(
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.Items.ReplaceItemStreamAsync(
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.Items.DeleteItemStreamAsync(
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");
}
