public async Task ChangeFeedIteratorCore_OfT_ReadAll()
{
int totalCount = 0;
int firstRunTotal = 25;
int batchSize = 25;
ContainerInternal itemsCore = await this.InitializeContainerAsync();
await this.CreateRandomItems(itemsCore, batchSize, randomPartitionKey : true);
FeedIterator <ToDoActivity> feedIterator = itemsCore.GetChangeFeedIterator <ToDoActivity>(ChangeFeedStartFrom.Beginning(), ChangeFeedMode.Incremental);
string continuation = null;
while (feedIterator.HasMoreResults)
{
try
{
FeedResponse <ToDoActivity> feedResponse = await feedIterator.ReadNextAsync(this.cancellationToken);
totalCount += feedResponse.Count;
continuation = feedResponse.ContinuationToken;
}
catch (CosmosException cosmosException) when(cosmosException.StatusCode == HttpStatusCode.NotModified)
{
continuation = cosmosException.Headers.ContinuationToken;
break;
}
}
Assert.AreEqual(firstRunTotal, totalCount);
int expectedFinalCount = 50;
// Insert another batch of 25 and use the last FeedToken from the first cycle
await this.CreateRandomItems(itemsCore, batchSize, randomPartitionKey : true);
FeedIterator <ToDoActivity> setIteratorNew = itemsCore.GetChangeFeedIterator <ToDoActivity>(ChangeFeedStartFrom.ContinuationToken(continuation), ChangeFeedMode.Incremental);
while (setIteratorNew.HasMoreResults)
{
try
{
FeedResponse <ToDoActivity> feedResponse = await feedIterator.ReadNextAsync(this.cancellationToken);
totalCount += feedResponse.Count;
}
catch (CosmosException cosmosException) when(cosmosException.StatusCode == HttpStatusCode.NotModified)
{
break;
}
}
Assert.AreEqual(expectedFinalCount, totalCount);
}
public async Task ChangeFeedIteratorCore_DeleteAfterCreate()
{
ContainerProperties properties = new ContainerProperties(id: Guid.NewGuid().ToString(), partitionKeyPath: ChangeFeedIteratorCoreTests.PartitionKey);
properties.ChangeFeedPolicy.FullFidelityRetention = TimeSpan.FromMinutes(5);
ContainerResponse response = await this.database.CreateContainerAsync(
properties,
cancellationToken : this.cancellationToken);
ContainerInternal container = (ContainerInternal)response;
// Insert documents and then delete them
int totalDocuments = 50;
IList <ToDoActivity> createdItems = await this.CreateRandomItems(container, totalDocuments, randomPartitionKey : true);
foreach (ToDoActivity item in createdItems)
{
await container.DeleteItemAsync <ToDoActivity>(item.id, new PartitionKey(item.pk));
}
FeedIterator <ToDoActivityWithMetadata> changefeedIterator = container.GetChangeFeedIterator <ToDoActivityWithMetadata>(
ChangeFeedStartFrom.Beginning(),
ChangeFeedMode.Incremental);
while (changefeedIterator.HasMoreResults)
{
FeedResponse <ToDoActivityWithMetadata> feedResponse = await changefeedIterator.ReadNextAsync(this.cancellationToken);
Assert.AreEqual(HttpStatusCode.NotModified, feedResponse.StatusCode, "Incremental Change Feed does not present intermediate results and should return nothing.");
if (feedResponse.StatusCode == HttpStatusCode.NotModified)
{
break;
}
}
}
public async Task ChangeFeedIteratorCore_OfT_ReadAll()
{
int totalCount = 0;
int firstRunTotal = 25;
int batchSize = 25;
await this.CreateRandomItems(this.Container, batchSize, randomPartitionKey : true);
ContainerInternal itemsCore = this.Container;
FeedIterator <ToDoActivity> feedIterator = itemsCore.GetChangeFeedIterator <ToDoActivity>(changeFeedRequestOptions: new ChangeFeedRequestOptions()
{
StartTime = DateTime.MinValue.ToUniversalTime()
});
string continuation = null;
while (feedIterator.HasMoreResults)
{
FeedResponse <ToDoActivity> feedResponse = await feedIterator.ReadNextAsync(this.cancellationToken);
totalCount += feedResponse.Count;
continuation = feedResponse.ContinuationToken;
}
Assert.AreEqual(firstRunTotal, totalCount);
int expectedFinalCount = 50;
// Insert another batch of 25 and use the last FeedToken from the first cycle
await this.CreateRandomItems(this.Container, batchSize, randomPartitionKey : true);
FeedIterator <ToDoActivity> setIteratorNew = itemsCore.GetChangeFeedIterator <ToDoActivity>(continuationToken: continuation, changeFeedRequestOptions: new ChangeFeedRequestOptions()
{
StartTime = DateTime.MinValue.ToUniversalTime()
});
while (setIteratorNew.HasMoreResults)
{
FeedResponse <ToDoActivity> feedResponse = await setIteratorNew.ReadNextAsync(this.cancellationToken);
totalCount += feedResponse.Count;
}
Assert.AreEqual(expectedFinalCount, totalCount);
}
public async Task ChangeFeedIteratorCore_WithFullFidelityReadFromBeginning()
{
ContainerProperties properties = new ContainerProperties(id: Guid.NewGuid().ToString(), partitionKeyPath: ChangeFeedIteratorCoreTests.PartitionKey);
properties.ChangeFeedPolicy.FullFidelityRetention = TimeSpan.FromMinutes(5);
ContainerResponse response = await this.database.CreateContainerAsync(
properties,
cancellationToken : this.cancellationToken);
ContainerInternal container = (ContainerInternal)response;
int totalDocuments = 10;
await this.CreateRandomItems(container, totalDocuments, randomPartitionKey : true);
// FF does not work with StartFromBeginning currently, capture error
FeedIterator <ToDoActivityWithMetadata> fullFidelityIterator = container.GetChangeFeedIterator <ToDoActivityWithMetadata>(
ChangeFeedStartFrom.Beginning(),
ChangeFeedMode.FullFidelity);
CosmosException cosmosException = await Assert.ThrowsExceptionAsync <CosmosException>(() => fullFidelityIterator.ReadNextAsync());
Assert.AreEqual(HttpStatusCode.BadRequest, cosmosException.StatusCode, "Full Fidelity Change Feed does not work with StartFromBeginning currently.");
Assert.IsTrue(cosmosException.Message.Contains("FullFidelity Change Feed must have valid If-None-Match header."));
}
public async Task ChangeFeedIteratorCore_WithFullFidelity()
{
ContainerProperties properties = new ContainerProperties(id: Guid.NewGuid().ToString(), partitionKeyPath: ChangeFeedIteratorCoreTests.PartitionKey);
properties.ChangeFeedPolicy.FullFidelityRetention = TimeSpan.FromMinutes(5);
ContainerResponse response = await this.database.CreateContainerAsync(
properties,
cancellationToken : this.cancellationToken);
ContainerInternal container = (ContainerInternal)response;
// FF does not work with StartFromBeginning currently, so we capture an initial continuation.
FeedIterator <ToDoActivityWithMetadata> fullFidelityIterator = container.GetChangeFeedIterator <ToDoActivityWithMetadata>(
ChangeFeedStartFrom.Now(),
ChangeFeedMode.FullFidelity);
string initialContinuation = null;
while (fullFidelityIterator.HasMoreResults)
{
try
{
FeedResponse <ToDoActivityWithMetadata> feedResponse = await fullFidelityIterator.ReadNextAsync(this.cancellationToken);
initialContinuation = feedResponse.ContinuationToken;
}
catch (CosmosException cosmosException) when(cosmosException.StatusCode == HttpStatusCode.NotModified)
{
initialContinuation = cosmosException.Headers.ContinuationToken;
break;
}
}
// Insert documents and then delete them
int totalDocuments = 50;
IList <ToDoActivity> createdItems = await this.CreateRandomItems(container, totalDocuments, randomPartitionKey : true);
foreach (ToDoActivity item in createdItems)
{
await container.DeleteItemAsync <ToDoActivity>(item.id, new PartitionKey(item.pk));
}
// Resume Change Feed and verify we pickup all the events
fullFidelityIterator = container.GetChangeFeedIterator <ToDoActivityWithMetadata>(
ChangeFeedStartFrom.ContinuationToken(initialContinuation),
ChangeFeedMode.FullFidelity);
int detectedEvents = 0;
bool hasInserts = false;
bool hasDeletes = false;
while (fullFidelityIterator.HasMoreResults)
{
try
{
FeedResponse <ToDoActivityWithMetadata> feedResponse = await fullFidelityIterator.ReadNextAsync(this.cancellationToken);
foreach (ToDoActivityWithMetadata item in feedResponse)
{
Assert.IsNotNull(item.metadata, "Metadata not present");
Assert.IsNotNull(item.metadata.operationType, "Metadata has no operationType");
hasInserts |= item.metadata.operationType == "create";
hasDeletes |= item.metadata.operationType == "delete";
}
detectedEvents += feedResponse.Count;
}
catch (CosmosException cosmosException) when(cosmosException.StatusCode == HttpStatusCode.NotModified)
{
break;
}
}
Assert.AreEqual(2 * totalDocuments, detectedEvents, "Full Fidelity should include inserts and delete events.");
Assert.IsTrue(hasInserts, "No metadata for create operationType found");
Assert.IsTrue(hasDeletes, "No metadata for delete operationType found");
}
public async Task ChangeFeedIteratorCore_PartitionKey_OfT_ReadAll()
{
int totalCount = 0;
int firstRunTotal = 25;
int batchSize = 25;
string pkToRead = "pkToRead";
string otherPK = "otherPK";
ContainerInternal itemsCore = await this.InitializeContainerAsync();
for (int i = 0; i < batchSize; i++)
{
await itemsCore.CreateItemAsync(ToDoActivity.CreateRandomToDoActivity(pk: pkToRead));
}
for (int i = 0; i < batchSize; i++)
{
await itemsCore.CreateItemAsync(ToDoActivity.CreateRandomToDoActivity(pk: otherPK));
}
FeedIterator <ToDoActivity> feedIterator = itemsCore.GetChangeFeedIterator <ToDoActivity>(
ChangeFeedStartFrom.Beginning(
new FeedRangePartitionKey(
new PartitionKey(pkToRead))),
ChangeFeedMode.Incremental,
new ChangeFeedRequestOptions()
{
PageSizeHint = 1,
});
string continuation = null;
while (feedIterator.HasMoreResults)
{
try
{
FeedResponse <ToDoActivity> feedResponse = await feedIterator.ReadNextAsync(this.cancellationToken);
totalCount += feedResponse.Count;
foreach (ToDoActivity toDoActivity in feedResponse)
{
Assert.AreEqual(pkToRead, toDoActivity.pk);
}
continuation = feedResponse.ContinuationToken;
}
catch (CosmosException cosmosException) when(cosmosException.StatusCode == HttpStatusCode.NotModified)
{
continuation = cosmosException.Headers.ContinuationToken;
break;
}
}
Assert.AreEqual(firstRunTotal, totalCount);
int expectedFinalCount = 50;
// Insert another batch of 25 and use the last FeedToken from the first cycle
for (int i = 0; i < batchSize; i++)
{
await itemsCore.CreateItemAsync(ToDoActivity.CreateRandomToDoActivity(pk: pkToRead));
}
FeedIterator <ToDoActivity> setIteratorNew = itemsCore.GetChangeFeedIterator <ToDoActivity>(
ChangeFeedStartFrom.ContinuationToken(continuation),
ChangeFeedMode.Incremental);
while (setIteratorNew.HasMoreResults)
{
try
{
FeedResponse <ToDoActivity> feedResponse = await setIteratorNew.ReadNextAsync(this.cancellationToken);
totalCount += feedResponse.Count;
foreach (ToDoActivity toDoActivity in feedResponse)
{
Assert.AreEqual(pkToRead, toDoActivity.pk);
}
}
catch (CosmosException cosmosException) when(cosmosException.StatusCode == HttpStatusCode.NotModified)
{
break;
}
}
Assert.AreEqual(expectedFinalCount, totalCount);
}
public async Task ChangeFeedIteratorCore_PartitionKey_OfT_ReadAll()
{
int totalCount = 0;
int firstRunTotal = 25;
int batchSize = 25;
string pkToRead = "pkToRead";
string otherPK = "otherPK";
for (int i = 0; i < batchSize; i++)
{
await this.Container.CreateItemAsync(this.CreateRandomToDoActivity(pkToRead));
}
for (int i = 0; i < batchSize; i++)
{
await this.Container.CreateItemAsync(this.CreateRandomToDoActivity(otherPK));
}
ContainerInternal itemsCore = this.Container;
FeedIterator <ToDoActivity> feedIterator = itemsCore.GetChangeFeedIterator <ToDoActivity>(
ChangeFeedStartFrom.Beginning(
new FeedRangePartitionKey(
new PartitionKey(pkToRead))),
new ChangeFeedRequestOptions()
{
PageSizeHint = 1,
});
string continuation = null;
while (feedIterator.HasMoreResults)
{
FeedResponse <ToDoActivity> feedResponse = await feedIterator.ReadNextAsync(this.cancellationToken);
totalCount += feedResponse.Count;
foreach (ToDoActivity toDoActivity in feedResponse)
{
Assert.AreEqual(pkToRead, toDoActivity.status);
}
continuation = feedResponse.ContinuationToken;
}
Assert.AreEqual(firstRunTotal, totalCount);
int expectedFinalCount = 50;
// Insert another batch of 25 and use the last FeedToken from the first cycle
for (int i = 0; i < batchSize; i++)
{
await this.Container.CreateItemAsync(this.CreateRandomToDoActivity(pkToRead));
}
FeedIterator <ToDoActivity> setIteratorNew = itemsCore.GetChangeFeedIterator <ToDoActivity>(
ChangeFeedStartFrom.ContinuationToken(continuation));
while (setIteratorNew.HasMoreResults)
{
FeedResponse <ToDoActivity> feedResponse = await setIteratorNew.ReadNextAsync(this.cancellationToken);
totalCount += feedResponse.Count;
foreach (ToDoActivity toDoActivity in feedResponse)
{
Assert.AreEqual(pkToRead, toDoActivity.status);
}
}
Assert.AreEqual(expectedFinalCount, totalCount);
}