Пример #1
0
            public void TracksBucketOverflow()
            {
                TimeService.CurrentDateTime.Returns(baseTime);
                var bucket = new LeakyBucket(TimeService, AnalyticsService, 1);

                bucket.TryClaimFreeSlot(out _);

                bucket.TryClaimFreeSlots(1, out _);
                AnalyticsService.Received().LeakyBucketOverflow.Track();
            }
Пример #2
0
            public void AllowsSlotsInAShortPeriodOfTimeUntilReachingTheLimit(int slotsPerWindow)
            {
                TimeService.CurrentDateTime.Returns(baseTime);
                var client = new LeakyBucket(TimeService, AnalyticsService, slotsPerWindow);

                var claimed = client.TryClaimFreeSlots(slotsPerWindow, out var timeToNextFreeSlot);

                claimed.Should().BeTrue();
                timeToNextFreeSlot.Should().Be(TimeSpan.Zero);
            }
Пример #3
0
            public void ReturnsNonZeroTimeToNextSlotTooManyRequestsAreSentInAShortPeriodOfTime(int slotsPerWindow)
            {
                TimeService.CurrentDateTime.Returns(baseTime);
                var bucket = new LeakyBucket(TimeService, AnalyticsService, slotsPerWindow);

                bucket.TryClaimFreeSlots(slotsPerWindow, out _);
                var claimed = bucket.TryClaimFreeSlot(out var time);

                claimed.Should().BeFalse();
                time.Should().BeGreaterThan(TimeSpan.Zero);
            }
Пример #4
0
            public void ReturnsNonZeroTimeToNextSlotWhenTooManySlotsAreUsedInAShortPeriodOfTime(int slotsPerWindowLimit)
            {
                timeService.CurrentDateTime.Returns(baseTime);
                var bucket = new LeakyBucket(timeService, slotsPerWindowLimit);

                bucket.TryClaimFreeSlot(out _);

                var claimed = bucket.TryClaimFreeSlots(slotsPerWindowLimit, out var time);

                claimed.Should().BeFalse();
                time.Should().BeGreaterThan(TimeSpan.Zero);
            }
Пример #5
0
            public void ThrowsWhenTooManySlotsAreRequested(PositiveInt slotsPerWindow)
            {
                if (slotsPerWindow.Get == int.MaxValue)
                {
                    return;
                }

                TimeService.CurrentDateTime.Returns(baseTime);
                var bucket = new LeakyBucket(TimeService, AnalyticsService, slotsPerWindow.Get);

                Action claimMany = () => bucket.TryClaimFreeSlots(slotsPerWindow.Get + 1, out _);

                claimMany.Should().Throw <InvalidOperationException>();
            }
Пример #6
0
            public void CalculatesTheDelayUntilNextFreeSlot()
            {
                TimeService.CurrentDateTime.Returns(
                    baseTime,
                    baseTime + TimeSpan.FromSeconds(
                        3),
                    baseTime + TimeSpan.FromSeconds(6),
                    baseTime + TimeSpan.FromSeconds(8));
                var bucket = new LeakyBucket(TimeService, AnalyticsService, slotsPerWindow: 4, movingWindowSize: TimeSpan.FromSeconds(10));

                bucket.TryClaimFreeSlot(out _);
                bucket.TryClaimFreeSlot(out _);
                bucket.TryClaimFreeSlot(out _);
                var claimed = bucket.TryClaimFreeSlots(3, out var timeToFreeSlot);

                claimed.Should().BeFalse();
                timeToFreeSlot.Should().Be(TimeSpan.FromSeconds(5));
            }