Example #1
0
        public async Task EstimateForOwnedPartition_ShouldReturnEmpty_WhenNothingSucceeds()
        {
            IEnumerable <ILease> leases = new List <ILease>
            {
                Mock.Of <ILease>(l => l.PartitionId == "1" && l.ContinuationToken == "100")
            };
            var sut = new RemainingWorkEstimator(
                Mock.Of <ILeaseContainer>(m => m.GetOwnedLeasesAsync() == Task.FromResult(leases)),
                Mock.Of <IChangeFeedDocumentClient>()
                .SetupQueryResponseFailure("1", "100"),
                collectionSelfLink,
                1);
            var pendingWork = await sut.GetEstimatedRemainingWorkForOwnedPartitionsAsync();

            Assert.Empty(pendingWork);
        }
Example #2
0
        public async Task EstimateForOwnedPartition_ShouldReturnPendingWork_IfOnePartition()
        {
            IEnumerable <ILease> leases = new List <ILease> {
                Mock.Of <ILease>(l => l.PartitionId == "1" && l.ContinuationToken == "100")
            };
            var sut = new RemainingWorkEstimator(
                Mock.Of <ILeaseContainer>(m => m.GetOwnedLeasesAsync() == Task.FromResult(leases)),
                Mock.Of <IChangeFeedDocumentClient>()
                .SetupQueryResponse("1", "100", "101", "1:106"),
                collectionSelfLink,
                1);

            var pendingWork = await sut.GetEstimatedRemainingWorkForOwnedPartitionsAsync();

            Assert.Contains(pendingWork, work => work.PartitionKeyRangeId == "1" && work.RemainingWork == 6);
            Assert.Single(pendingWork);
        }
Example #3
0
        public async Task EstimateForOwnedPartition_ShouldRunInParallel_IfDegreeOfParallelismIsTwo()
        {
            IEnumerable <ILease> leases = new List <ILease>
            {
                Mock.Of <ILease>(l => l.PartitionId == "1" && l.ContinuationToken == "100"),
                Mock.Of <ILease>(l => l.PartitionId == "2" && l.ContinuationToken == "200")
            };

            TaskCompletionSource <bool> cts1   = new TaskCompletionSource <bool>();
            TaskCompletionSource <bool> cts2   = new TaskCompletionSource <bool>();
            TaskCompletionSource <bool> ctsAll = new TaskCompletionSource <bool>();
            var sut = new RemainingWorkEstimator(
                Mock.Of <ILeaseContainer>(m => m.GetOwnedLeasesAsync() == Task.FromResult(leases)),
                Mock.Of <IChangeFeedDocumentClient>()
                .SetupQueryResponse("1", "100", "101", "1:106", async r =>
            {
                cts1.SetResult(true);
                await ctsAll.Task;
                return(r);
            })
                .SetupQueryResponse("2", "200", "201", "2:-1#201", async r =>
            {
                cts2.SetResult(true);
                await ctsAll.Task;
                return(r);
            }),
                collectionSelfLink,
                2);

            var workPerPartitionTask = sut.GetEstimatedRemainingWorkForOwnedPartitionsAsync();

            await Task.WhenAll(cts1.Task, cts2.Task);

            ctsAll.SetResult(true);

            var pendingWork = await workPerPartitionTask;

            Assert.Contains(pendingWork, work => work.PartitionKeyRangeId == "1" && work.RemainingWork == 6);
            Assert.Contains(pendingWork, work => work.PartitionKeyRangeId == "2" && work.RemainingWork == 1);
            Assert.Equal(2, pendingWork.Count);
        }