public void ReadFeedIteratorCore_Create_WithRange()
{
Documents.Routing.Range <string> range = new Documents.Routing.Range <string>("A", "B", true, false);
FeedRangeEPK feedRangeEPK = new FeedRangeEPK(range);
FeedRangeIteratorCore feedTokenIterator = FeedRangeIteratorCore.Create(Mock.Of <ContainerInternal>(), feedRangeEPK, null, null);
Assert.AreEqual(feedRangeEPK, feedTokenIterator.FeedRangeInternal);
Assert.IsNull(feedTokenIterator.FeedRangeContinuation);
}
public void ReadFeedIteratorCore_Create_Default()
{
FeedRangeIteratorCore feedTokenIterator = FeedRangeIteratorCore.Create(Mock.Of <ContainerInternal>(), null, null, null);
FeedRangeEPK defaultRange = feedTokenIterator.FeedRangeInternal as FeedRangeEPK;
Assert.AreEqual(FeedRangeEPK.FullRange.Range.Min, defaultRange.Range.Min);
Assert.AreEqual(FeedRangeEPK.FullRange.Range.Max, defaultRange.Range.Max);
Assert.IsNull(feedTokenIterator.FeedRangeContinuation);
}
public async Task FeedRangeEPK_GetEffectiveRangesAsync()
{
Documents.Routing.Range <string> range = new Documents.Routing.Range <string>("AA", "BB", true, false);
FeedRangeEPK feedRangeEPK = new FeedRangeEPK(range);
List <Documents.Routing.Range <string> > ranges = await feedRangeEPK.GetEffectiveRangesAsync(Mock.Of <IRoutingMapProvider>(), null, null);
Assert.AreEqual(1, ranges.Count);
Assert.AreEqual(range, ranges[0]);
}
public void FeedRangeEPK_RequestVisitor()
{
Documents.Routing.Range <string> range = new Documents.Routing.Range <string>("AA", "BB", true, false);
FeedRangeEPK feedRange = new FeedRangeEPK(range);
RequestMessage requestMessage = new RequestMessage();
FeedRangeVisitor feedRangeVisitor = new FeedRangeVisitor(requestMessage);
feedRange.Accept(feedRangeVisitor);
Assert.AreEqual(0, requestMessage.Properties.Count);
}
public void ReadFeedIteratorCore_Create_WithContinuation()
{
string continuation = Guid.NewGuid().ToString();
FeedRangeIteratorCore feedTokenIterator = FeedRangeIteratorCore.Create(Mock.Of <ContainerInternal>(), null, continuation, null);
FeedRangeEPK defaultRange = feedTokenIterator.FeedRangeInternal as FeedRangeEPK;
Assert.AreEqual(FeedRangeEPK.ForFullRange().Range.Min, defaultRange.Range.Min);
Assert.AreEqual(FeedRangeEPK.ForFullRange().Range.Max, defaultRange.Range.Max);
Assert.IsNotNull(feedTokenIterator.FeedRangeContinuation);
Assert.AreEqual(continuation, feedTokenIterator.FeedRangeContinuation.GetContinuation());
}
public void FeedRangeEPK_ToJsonFromJson()
{
Documents.Routing.Range <string> range = new Documents.Routing.Range <string>("AA", "BB", true, false);
FeedRangeEPK feedRangeEPK = new FeedRangeEPK(range);
string representation = feedRangeEPK.ToJsonString();
FeedRangeEPK feedRangeEPKDeserialized = Cosmos.FeedRange.FromJsonString(representation) as FeedRangeEPK;
Assert.IsNotNull(feedRangeEPKDeserialized);
Assert.AreEqual(feedRangeEPK.Range.Min, feedRangeEPKDeserialized.Range.Min);
Assert.AreEqual(feedRangeEPK.Range.Max, feedRangeEPKDeserialized.Range.Max);
}
public void FeedRangeEPK_RequestVisitor()
{
Documents.Routing.Range <string> range = new Documents.Routing.Range <string>("AA", "BB", true, false);
FeedRangeEPK feedRange = new FeedRangeEPK(range);
RequestMessage requestMessage = new RequestMessage();
FeedRangeRequestMessagePopulatorVisitor feedRangeVisitor = new FeedRangeRequestMessagePopulatorVisitor(requestMessage);
feedRange.Accept(feedRangeVisitor);
Assert.AreEqual(2, requestMessage.Properties.Count);
Assert.AreEqual("AA", requestMessage.Properties[HandlerConstants.StartEpkString]);
Assert.AreEqual("BB", requestMessage.Properties[HandlerConstants.EndEpkString]);
}
public async Task ReadFeedIteratorCore_WithNoInitialState_ReadNextAsync()
{
string continuation = "TBD";
ResponseMessage responseMessage = new ResponseMessage(HttpStatusCode.OK);
responseMessage.Headers.ContinuationToken = continuation;
responseMessage.Headers[Documents.HttpConstants.HttpHeaders.ItemCount] = "1";
responseMessage.Content = new MemoryStream(Encoding.UTF8.GetBytes("{}"));
MultiRangeMockDocumentClient documentClient = new MultiRangeMockDocumentClient();
Mock <CosmosClientContext> cosmosClientContext = new Mock <CosmosClientContext>();
cosmosClientContext.Setup(c => c.ClientOptions).Returns(new CosmosClientOptions());
cosmosClientContext.Setup(c => c.DocumentClient).Returns(documentClient);
cosmosClientContext
.Setup(c => c.ProcessResourceOperationStreamAsync(
It.IsAny <string>(),
It.Is <Documents.ResourceType>(rt => rt == Documents.ResourceType.Document),
It.IsAny <Documents.OperationType>(),
It.IsAny <RequestOptions>(),
It.IsAny <ContainerInternal>(),
It.IsAny <PartitionKey?>(),
It.IsAny <Stream>(),
It.IsAny <Action <RequestMessage> >(),
It.IsAny <CosmosDiagnosticsContext>(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(responseMessage));
ContainerInternal containerCore = Mock.Of <ContainerInternal>();
Mock.Get(containerCore)
.Setup(c => c.ClientContext)
.Returns(cosmosClientContext.Object);
Mock.Get(containerCore)
.Setup(c => c.GetRIDAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(Guid.NewGuid().ToString());
FeedRangeIteratorCore feedTokenIterator = FeedRangeIteratorCore.Create(containerCore, null, null, new QueryRequestOptions());
ResponseMessage response = await feedTokenIterator.ReadNextAsync();
Assert.IsTrue(FeedRangeContinuation.TryParse(response.ContinuationToken, out FeedRangeContinuation parsedToken));
FeedRangeCompositeContinuation feedRangeCompositeContinuation = parsedToken as FeedRangeCompositeContinuation;
FeedRangeEPK feedTokenEPKRange = feedRangeCompositeContinuation.FeedRange as FeedRangeEPK;
// Assert that a FeedToken for the entire range is used
Assert.AreEqual(Documents.Routing.PartitionKeyInternal.MinimumInclusiveEffectivePartitionKey, feedTokenEPKRange.Range.Min);
Assert.AreEqual(Documents.Routing.PartitionKeyInternal.MaximumExclusiveEffectivePartitionKey, feedTokenEPKRange.Range.Max);
Assert.AreEqual(continuation, feedRangeCompositeContinuation.CompositeContinuationTokens.Peek().Token);
Assert.IsFalse(feedRangeCompositeContinuation.IsDone);
}
public void FeedRangeCompositeContinuation_TryParse()
{
const string containerRid = "containerRid";
List <Documents.Routing.Range <string> > keyRanges = new List <Documents.Routing.Range <string> >()
{
new Documents.Routing.Range <string>("A", "B", true, false),
new Documents.Routing.Range <string>("D", "E", true, false),
};
FeedRangeInternal feedRangeInternal = new FeedRangeEPK(new Documents.Routing.Range <string>("A", "E", true, false));
FeedRangeCompositeContinuation token = new FeedRangeCompositeContinuation(containerRid, feedRangeInternal, keyRanges);
Assert.IsTrue(FeedRangeContinuation.TryParse(token.ToString(), out _));
Assert.IsFalse(FeedRangeContinuation.TryParse("whatever", out _));
}
public void ReadFeedIteratorCore_Create_WithFeedContinuation()
{
string continuation = Guid.NewGuid().ToString();
FeedRangeEPK feedRangeEPK = FeedRangeEPK.ForFullRange();
FeedRangeCompositeContinuation feedRangeSimpleContinuation = new FeedRangeCompositeContinuation(Guid.NewGuid().ToString(), feedRangeEPK, new List <Documents.Routing.Range <string> >()
{
feedRangeEPK.Range
}, continuation);
FeedRangeIteratorCore feedTokenIterator = FeedRangeIteratorCore.Create(Mock.Of <ContainerInternal>(), null, feedRangeSimpleContinuation.ToString(), null);
FeedRangeEPK defaultRange = feedTokenIterator.FeedRangeInternal as FeedRangeEPK;
Assert.AreEqual(FeedRangeEPK.ForFullRange().Range.Min, defaultRange.Range.Min);
Assert.AreEqual(FeedRangeEPK.ForFullRange().Range.Max, defaultRange.Range.Max);
Assert.IsNotNull(feedTokenIterator.FeedRangeContinuation);
Assert.AreEqual(continuation, feedTokenIterator.FeedRangeContinuation.GetContinuation());
}
public async Task FeedRange_EPK_Serialization()
{
string continuation = "TBD";
string containerRid = Guid.NewGuid().ToString();
List <FeedRange> ranges = (await this.Container.GetFeedRangesAsync()).ToList();
List <string> serializations = new List <string>();
List <FeedRangeCompositeContinuation> tokens = new List <FeedRangeCompositeContinuation>();
foreach (FeedRange range in ranges)
{
FeedRangeEPK feedRangeEPK = range as FeedRangeEPK;
FeedRangeCompositeContinuation feedRangeCompositeContinuation = new FeedRangeCompositeContinuation(containerRid, feedRangeEPK, new List <Documents.Routing.Range <string> >()
{
feedRangeEPK.Range
}, continuation);
tokens.Add(feedRangeCompositeContinuation);
serializations.Add(feedRangeCompositeContinuation.ToString());
}
List <FeedRangeContinuation> deserialized = new List <FeedRangeContinuation>();
foreach (string serialized in serializations)
{
Assert.IsTrue(FeedRangeContinuation.TryParse(serialized, out FeedRangeContinuation token));
deserialized.Add(token);
}
Assert.AreEqual(tokens.Count, deserialized.Count);
for (int i = 0; i < tokens.Count; i++)
{
FeedRangeCompositeContinuation originalToken = tokens[i] as FeedRangeCompositeContinuation;
FeedRangeCompositeContinuation deserializedToken = deserialized[i] as FeedRangeCompositeContinuation;
Assert.AreEqual(originalToken.GetContinuation(), deserializedToken.GetContinuation());
Assert.AreEqual(originalToken.ContainerRid, deserializedToken.ContainerRid);
Assert.AreEqual(originalToken.CompositeContinuationTokens.Count, deserializedToken.CompositeContinuationTokens.Count);
Assert.AreEqual(originalToken.CompositeContinuationTokens.Peek().Token, deserializedToken.CompositeContinuationTokens.Peek().Token);
Assert.AreEqual(originalToken.CompositeContinuationTokens.Peek().Range.Min, deserializedToken.CompositeContinuationTokens.Peek().Range.Min);
Assert.AreEqual(originalToken.CompositeContinuationTokens.Peek().Range.Max, deserializedToken.CompositeContinuationTokens.Peek().Range.Max);
Assert.AreEqual(originalToken.CompositeContinuationTokens.Peek().Range.IsMinInclusive, deserializedToken.CompositeContinuationTokens.Peek().Range.IsMinInclusive);
Assert.AreEqual(originalToken.CompositeContinuationTokens.Peek().Range.IsMaxInclusive, deserializedToken.CompositeContinuationTokens.Peek().Range.IsMaxInclusive);
}
}
public async Task FeedRangeEPK_GetPartitionKeyRangesAsync()
{
Documents.Routing.Range <string> range = new Documents.Routing.Range <string>("AA", "BB", true, false);
Documents.PartitionKeyRange partitionKeyRange = new Documents.PartitionKeyRange()
{
Id = Guid.NewGuid().ToString(), MinInclusive = range.Min, MaxExclusive = range.Max
};
FeedRangePartitionKeyRange feedRangePartitionKeyRange = new FeedRangePartitionKeyRange(partitionKeyRange.Id);
IRoutingMapProvider routingProvider = Mock.Of <IRoutingMapProvider>();
Mock.Get(routingProvider)
.Setup(f => f.TryGetOverlappingRangesAsync(It.IsAny <string>(), It.Is <Documents.Routing.Range <string> >(s => s == range), It.IsAny <bool>()))
.ReturnsAsync(new List <Documents.PartitionKeyRange>()
{
partitionKeyRange
});
FeedRangeEPK feedRangeEPK = new FeedRangeEPK(range);
IEnumerable <string> pkRanges = await feedRangeEPK.GetPartitionKeyRangesAsync(routingProvider, null, null, default(CancellationToken));
Assert.AreEqual(1, pkRanges.Count());
Assert.AreEqual(partitionKeyRange.Id, pkRanges.First());
}
public async Task ChangeFeed_FeedRange_FromV2SDK()
{
ContainerResponse largerContainer = await this.database.CreateContainerAsync(
new ContainerProperties(id : Guid.NewGuid().ToString(), partitionKeyPath : "/status"),
throughput : 20000,
cancellationToken : this.cancellationToken);
ContainerCore container = (ContainerInlineCore)largerContainer;
int expected = 100;
int count = 0;
await this.CreateRandomItems(container, expected, randomPartitionKey : true);
IReadOnlyList <FeedRange> feedRanges = await container.GetFeedRangesAsync();
List <string> continuations = new List <string>();
// First do one request to construct the old model information based on Etag
foreach (FeedRange feedRange in feedRanges)
{
IEnumerable <string> pkRangeIds = await container.GetPartitionKeyRangesAsync(feedRange);
ChangeFeedRequestOptions requestOptions = new ChangeFeedRequestOptions()
{
FeedRange = feedRange,
From = ChangeFeedRequestOptions.StartFrom.CreateFromBeginning(),
MaxItemCount = 1
};
ChangeFeedIteratorCore feedIterator = container.GetChangeFeedStreamIterator(changeFeedRequestOptions: requestOptions) as ChangeFeedIteratorCore;
ResponseMessage firstResponse = await feedIterator.ReadNextAsync();
if (firstResponse.IsSuccessStatusCode)
{
Collection <ToDoActivity> response = TestCommon.SerializerCore.FromStream <CosmosFeedResponseUtil <ToDoActivity> >(firstResponse.Content).Data;
count += response.Count;
}
FeedRangeEPK feedRangeEpk = feedRange as FeedRangeEPK;
// Construct the continuation's range, using PKRangeId + ETag
List <dynamic> ct = new List <dynamic>()
{
new
{
min = feedRangeEpk.Range.Min,
max = feedRangeEpk.Range.Max,
token = firstResponse.Headers.ETag
}
};
// Extract Etag and manually construct the continuation
dynamic oldContinuation = new
{
V = 0,
PKRangeId = pkRangeIds.First(),
Continuation = ct
};
continuations.Add(JsonConvert.SerializeObject(oldContinuation));
}
// Now start the new iterators with the constructed continuations from migration
foreach (string continuation in continuations)
{
ChangeFeedRequestOptions requestOptions = new ChangeFeedRequestOptions()
{
From = ChangeFeedRequestOptions.StartFrom.CreateFromContinuation(continuation),
MaxItemCount = 100
};
ChangeFeedIteratorCore feedIterator = container.GetChangeFeedStreamIterator(changeFeedRequestOptions: requestOptions) as ChangeFeedIteratorCore;
ResponseMessage firstResponse = await feedIterator.ReadNextAsync();
if (firstResponse.IsSuccessStatusCode)
{
Collection <ToDoActivity> response = TestCommon.SerializerCore.FromStream <CosmosFeedResponseUtil <ToDoActivity> >(firstResponse.Content).Data;
count += response.Count;
}
}
Assert.AreEqual(expected, count);
}
