public override async Task CanAcquireResourceAsync_QueuesAndGrabsNewest()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions(2, QueueProcessingOrder.NewestFirst, 3,
TimeSpan.FromMinutes(0), 2, autoReplenishment: false));
var lease = await limiter.WaitAndAcquireAsync(2);
Assert.True(lease.IsAcquired);
var wait1 = limiter.WaitAndAcquireAsync(2);
var wait2 = limiter.WaitAndAcquireAsync();
Assert.False(wait1.IsCompleted);
Assert.False(wait2.IsCompleted);
lease.Dispose();
Assert.True(limiter.TryReplenish());
Assert.False(wait2.IsCompleted);
Assert.True(limiter.TryReplenish());
// second queued item completes first with NewestFirst
lease = await wait2;
Assert.True(lease.IsAcquired);
Assert.False(wait1.IsCompleted);
lease.Dispose();
Assert.Equal(1, limiter.GetAvailablePermits());
Assert.True(limiter.TryReplenish());
Assert.True(limiter.TryReplenish());
lease = await wait1;
Assert.True(lease.IsAcquired);
}
public override async Task DropsMultipleOldestWhenQueuingMoreThanLimit_NewestFirst()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions(2, QueueProcessingOrder.NewestFirst, 2,
TimeSpan.Zero, 2, autoReplenishment: false));
var lease = limiter.Acquire(2);
Assert.True(lease.IsAcquired);
var wait = limiter.WaitAndAcquireAsync(1);
Assert.False(wait.IsCompleted);
var wait2 = limiter.WaitAndAcquireAsync(1);
Assert.False(wait2.IsCompleted);
var wait3 = limiter.WaitAndAcquireAsync(2);
var lease1 = await wait;
var lease2 = await wait2;
Assert.False(lease1.IsAcquired);
Assert.False(lease2.IsAcquired);
Assert.False(wait3.IsCompleted);
limiter.TryReplenish();
limiter.TryReplenish();
lease = await wait3;
Assert.True(lease.IsAcquired);
}
public override async Task DisposeAsyncReleasesQueuedAcquires()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions(1, QueueProcessingOrder.OldestFirst, 3,
TimeSpan.Zero, 2, autoReplenishment: false));
var lease = limiter.Acquire(1);
var wait1 = limiter.WaitAndAcquireAsync(1);
var wait2 = limiter.WaitAndAcquireAsync(1);
var wait3 = limiter.WaitAndAcquireAsync(1);
Assert.False(wait1.IsCompleted);
Assert.False(wait2.IsCompleted);
Assert.False(wait3.IsCompleted);
await limiter.DisposeAsync();
lease = await wait1;
Assert.False(lease.IsAcquired);
lease = await wait2;
Assert.False(lease.IsAcquired);
lease = await wait3;
Assert.False(lease.IsAcquired);
// Throws after disposal
Assert.Throws <ObjectDisposedException>(() => limiter.Acquire(1));
await Assert.ThrowsAsync <ObjectDisposedException>(() => limiter.WaitAndAcquireAsync(1).AsTask());
}
public void ReplenishingRateLimiterPropertiesHaveCorrectValues()
{
var replenishPeriod = TimeSpan.FromMinutes(1);
using ReplenishingRateLimiter limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions
{
PermitLimit = 1,
QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
QueueLimit = 2,
Window = replenishPeriod,
SegmentsPerWindow = 1,
AutoReplenishment = true
});
Assert.True(limiter.IsAutoReplenishing);
Assert.Equal(replenishPeriod, limiter.ReplenishmentPeriod);
replenishPeriod = TimeSpan.FromSeconds(2);
using ReplenishingRateLimiter limiter2 = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions
{
PermitLimit = 1,
QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
QueueLimit = 2,
Window = replenishPeriod,
SegmentsPerWindow = 1,
AutoReplenishment = false
});
Assert.False(limiter2.IsAutoReplenishing);
Assert.Equal(replenishPeriod, limiter2.ReplenishmentPeriod);
}
public override async Task CanDequeueMultipleResourcesAtOnce()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions(2, QueueProcessingOrder.OldestFirst, 4,
TimeSpan.Zero, 2, autoReplenishment: false));
using var lease = await limiter.WaitAndAcquireAsync(2);
Assert.True(lease.IsAcquired);
var wait1 = limiter.WaitAndAcquireAsync(1);
var wait2 = limiter.WaitAndAcquireAsync(1);
Assert.False(wait1.IsCompleted);
Assert.False(wait2.IsCompleted);
lease.Dispose();
Assert.True(limiter.TryReplenish());
Assert.True(limiter.TryReplenish());
var lease1 = await wait1;
var lease2 = await wait2;
Assert.True(lease1.IsAcquired);
Assert.True(lease2.IsAcquired);
}
public override async Task CannotAcquireResourcesWithWaitAndAcquireAsyncWithQueuedItemsIfOldestFirst()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions(3, QueueProcessingOrder.OldestFirst, 5,
TimeSpan.Zero, 2, autoReplenishment: false));
var lease = limiter.Acquire(3);
Assert.True(lease.IsAcquired);
var wait = limiter.WaitAndAcquireAsync(2);
var wait2 = limiter.WaitAndAcquireAsync(2);
Assert.False(wait.IsCompleted);
Assert.False(wait2.IsCompleted);
limiter.TryReplenish();
Assert.False(wait.IsCompleted);
Assert.False(wait2.IsCompleted);
limiter.TryReplenish();
lease = await wait;
Assert.True(lease.IsAcquired);
limiter.TryReplenish();
limiter.TryReplenish();
lease = await wait2;
Assert.True(lease.IsAcquired);
}
public override async Task CancelUpdatesQueueLimit()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions
{
PermitLimit = 2,
QueueProcessingOrder = QueueProcessingOrder.NewestFirst,
QueueLimit = 1,
Window = TimeSpan.Zero,
SegmentsPerWindow = 2,
AutoReplenishment = false
});
var lease = limiter.AttemptAcquire(2);
Assert.True(lease.IsAcquired);
var cts = new CancellationTokenSource();
var wait = limiter.AcquireAsync(1, cts.Token);
cts.Cancel();
var ex = await Assert.ThrowsAsync<TaskCanceledException>(() => wait.AsTask());
Assert.Equal(cts.Token, ex.CancellationToken);
wait = limiter.AcquireAsync(1);
Assert.False(wait.IsCompleted);
limiter.TryReplenish();
limiter.TryReplenish();
lease = await wait;
Assert.True(lease.IsAcquired);
Assert.Equal(1, limiter.GetStatistics().CurrentAvailablePermits);
}
public override void ThrowsWhenAcquiringLessThanZero()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions(1, QueueProcessingOrder.NewestFirst, 1,
TimeSpan.Zero, 1, autoReplenishment: false));
Assert.Throws <ArgumentOutOfRangeException>(() => limiter.Acquire(-1));
}
public override async Task LargeAcquiresAndQueuesDoNotIntegerOverflow()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions
{
PermitLimit = int.MaxValue,
QueueProcessingOrder = QueueProcessingOrder.NewestFirst,
QueueLimit = int.MaxValue,
Window = TimeSpan.Zero,
SegmentsPerWindow = 2,
AutoReplenishment = false
});
var lease = limiter.AttemptAcquire(int.MaxValue);
Assert.True(lease.IsAcquired);
// Fill queue
var wait = limiter.AcquireAsync(3);
Assert.False(wait.IsCompleted);
var wait2 = limiter.AcquireAsync(int.MaxValue);
Assert.False(wait2.IsCompleted);
var lease1 = await wait;
Assert.False(lease1.IsAcquired);
limiter.TryReplenish();
limiter.TryReplenish();
var lease2 = await wait2;
Assert.True(lease2.IsAcquired);
}
public override async Task CanDequeueMultipleResourcesAtOnce()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions
{
PermitLimit = 2,
QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
QueueLimit = 4,
Window = TimeSpan.Zero,
SegmentsPerWindow = 2,
AutoReplenishment = false
});
using var lease = await limiter.AcquireAsync(2);
Assert.True(lease.IsAcquired);
var wait1 = limiter.AcquireAsync(1);
var wait2 = limiter.AcquireAsync(1);
Assert.False(wait1.IsCompleted);
Assert.False(wait2.IsCompleted);
lease.Dispose();
Assert.True(limiter.TryReplenish());
Assert.True(limiter.TryReplenish());
var lease1 = await wait1;
var lease2 = await wait2;
Assert.True(lease1.IsAcquired);
Assert.True(lease2.IsAcquired);
}
public override async Task QueueAvailableAfterQueueLimitHitAndResources_BecomeAvailable()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions
{
PermitLimit = 3,
QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
QueueLimit = 2,
Window = TimeSpan.Zero,
SegmentsPerWindow = 3,
AutoReplenishment = false
});
var lease = limiter.AttemptAcquire(2);
var wait = limiter.AcquireAsync(2);
var failedLease = await limiter.AcquireAsync(2);
Assert.False(failedLease.IsAcquired);
limiter.TryReplenish();
limiter.TryReplenish();
Assert.False(wait.IsCompleted);
limiter.TryReplenish();
lease = await wait;
Assert.True(lease.IsAcquired);
wait = limiter.AcquireAsync(2);
Assert.False(wait.IsCompleted);
limiter.TryReplenish();
limiter.TryReplenish();
limiter.TryReplenish();
lease = await wait;
Assert.True(lease.IsAcquired);
}
public override async Task DropsRequestedLeaseIfPermitCountGreaterThanQueueLimitAndNoAvailability_NewestFirst()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions
{
PermitLimit = 2,
QueueProcessingOrder = QueueProcessingOrder.NewestFirst,
QueueLimit = 1,
Window = TimeSpan.Zero,
SegmentsPerWindow = 2,
AutoReplenishment = false
});
var lease = limiter.AttemptAcquire(2);
Assert.True(lease.IsAcquired);
// Fill queue
var wait = limiter.AcquireAsync(1);
Assert.False(wait.IsCompleted);
var lease1 = await limiter.AcquireAsync(2);
Assert.False(lease1.IsAcquired);
limiter.TryReplenish();
limiter.TryReplenish();
lease = await wait;
Assert.True(lease.IsAcquired);
}
public override async Task DropsMultipleOldestWhenQueuingMoreThanLimit_NewestFirst()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions
{
PermitLimit = 2,
QueueProcessingOrder = QueueProcessingOrder.NewestFirst,
QueueLimit = 2,
Window = TimeSpan.Zero,
SegmentsPerWindow = 2,
AutoReplenishment = false
});
var lease = limiter.AttemptAcquire(2);
Assert.True(lease.IsAcquired);
var wait = limiter.AcquireAsync(1);
Assert.False(wait.IsCompleted);
var wait2 = limiter.AcquireAsync(1);
Assert.False(wait2.IsCompleted);
var wait3 = limiter.AcquireAsync(2);
var lease1 = await wait;
var lease2 = await wait2;
Assert.False(lease1.IsAcquired);
Assert.False(lease2.IsAcquired);
Assert.False(wait3.IsCompleted);
limiter.TryReplenish();
limiter.TryReplenish();
lease = await wait3;
Assert.True(lease.IsAcquired);
}
public override async Task GetStatisticsWithZeroPermitCount()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions
{
PermitLimit = 100,
QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
QueueLimit = 50,
Window = TimeSpan.Zero,
SegmentsPerWindow = 3,
AutoReplenishment = false
});
var lease = limiter.AttemptAcquire(0);
Assert.True(lease.IsAcquired);
Assert.Equal(1, limiter.GetStatistics().TotalSuccessfulLeases);
Assert.Equal(100, limiter.GetStatistics().CurrentAvailablePermits);
lease = await limiter.AcquireAsync(0);
Assert.True(lease.IsAcquired);
Assert.Equal(2, limiter.GetStatistics().TotalSuccessfulLeases);
Assert.Equal(100, limiter.GetStatistics().CurrentAvailablePermits);
lease = limiter.AttemptAcquire(100);
Assert.True(lease.IsAcquired);
Assert.Equal(3, limiter.GetStatistics().TotalSuccessfulLeases);
Assert.Equal(0, limiter.GetStatistics().CurrentAvailablePermits);
var lease2 = limiter.AttemptAcquire(0);
Assert.False(lease2.IsAcquired);
Assert.Equal(3, limiter.GetStatistics().TotalSuccessfulLeases);
Assert.Equal(1, limiter.GetStatistics().TotalFailedLeases);
Assert.Equal(0, limiter.GetStatistics().CurrentAvailablePermits);
}
public override async Task DisposeReleasesQueuedAcquires()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions
{
PermitLimit = 1,
QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
QueueLimit = 3,
Window = TimeSpan.Zero,
SegmentsPerWindow = 1,
AutoReplenishment = false
});
var lease = limiter.AttemptAcquire(1);
var wait1 = limiter.AcquireAsync(1);
var wait2 = limiter.AcquireAsync(1);
var wait3 = limiter.AcquireAsync(1);
Assert.False(wait1.IsCompleted);
Assert.False(wait2.IsCompleted);
Assert.False(wait3.IsCompleted);
limiter.Dispose();
lease = await wait1;
Assert.False(lease.IsAcquired);
lease = await wait2;
Assert.False(lease.IsAcquired);
lease = await wait3;
Assert.False(lease.IsAcquired);
// Throws after disposal
Assert.Throws<ObjectDisposedException>(() => limiter.AttemptAcquire(1));
await Assert.ThrowsAsync<ObjectDisposedException>(() => limiter.AcquireAsync(1).AsTask());
}
public override async Task LargeAcquiresAndQueuesDoNotIntegerOverflow()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions(int.MaxValue, QueueProcessingOrder.NewestFirst, int.MaxValue,
TimeSpan.Zero, 2, autoReplenishment: false));
var lease = limiter.Acquire(int.MaxValue);
Assert.True(lease.IsAcquired);
// Fill queue
var wait = limiter.WaitAndAcquireAsync(3);
Assert.False(wait.IsCompleted);
var wait2 = limiter.WaitAndAcquireAsync(int.MaxValue);
Assert.False(wait2.IsCompleted);
var lease1 = await wait;
Assert.False(lease1.IsAcquired);
limiter.TryReplenish();
limiter.TryReplenish();
var lease2 = await wait2;
Assert.True(lease2.IsAcquired);
}
public override async Task CanAcquireResourcesWithAcquireAsyncWithQueuedItemsIfNewestFirst()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions
{
PermitLimit = 2,
QueueProcessingOrder = QueueProcessingOrder.NewestFirst,
QueueLimit = 2,
Window = TimeSpan.Zero,
SegmentsPerWindow = 3,
AutoReplenishment = false
});
var lease = limiter.AttemptAcquire(1);
Assert.True(lease.IsAcquired);
var wait = limiter.AcquireAsync(2);
Assert.False(wait.IsCompleted);
Assert.Equal(1, limiter.GetStatistics().CurrentAvailablePermits);
lease = await limiter.AcquireAsync(1);
Assert.True(lease.IsAcquired);
Assert.False(wait.IsCompleted);
limiter.TryReplenish();
Assert.True(limiter.TryReplenish());
Assert.False(wait.IsCompleted);
Assert.True(limiter.TryReplenish());
lease = await wait;
Assert.True(lease.IsAcquired);
}
public async Task CanAcquireMultipleRequestsAsync()
{
// This test verifies the following behavior
// 1. when we have available permits after replenish to serve the queued requests
// 2. when the oldest item from queue is remove to accommodate new requests (QueueProcessingOrder: NewestFirst)
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions(4, QueueProcessingOrder.NewestFirst, 4,
TimeSpan.Zero, 3, autoReplenishment: false));
using var lease = await limiter.WaitAndAcquireAsync(2);
Assert.True(lease.IsAcquired);
var wait = limiter.WaitAndAcquireAsync(3);
Assert.False(wait.IsCompleted);
Assert.True(limiter.TryReplenish());
Assert.False(wait.IsCompleted);
var wait2 = limiter.WaitAndAcquireAsync(2);
Assert.True(wait2.IsCompleted);
Assert.True(limiter.TryReplenish());
var wait3 = limiter.WaitAndAcquireAsync(2);
Assert.False(wait3.IsCompleted);
Assert.True(limiter.TryReplenish());
Assert.True((await wait3).IsAcquired);
Assert.False((await wait).IsAcquired);
Assert.Equal(0, limiter.GetAvailablePermits());
}
public override async Task CanAcquireResourceAsync()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions
{
PermitLimit = 2,
QueueProcessingOrder = QueueProcessingOrder.NewestFirst,
QueueLimit = 4,
Window = TimeSpan.Zero,
SegmentsPerWindow = 2,
AutoReplenishment = false
});
using var lease = await limiter.AcquireAsync();
Assert.True(lease.IsAcquired);
var wait = limiter.AcquireAsync(2);
Assert.False(wait.IsCompleted);
Assert.True(limiter.TryReplenish());
Assert.False(wait.IsCompleted);
var wait2 = limiter.AcquireAsync(2);
Assert.False(wait2.IsCompleted);
Assert.True(limiter.TryReplenish());
Assert.True((await wait2).IsAcquired);
}
public override async Task CancelUpdatesQueueLimit()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions(2, QueueProcessingOrder.NewestFirst, 1,
TimeSpan.Zero, 2, autoReplenishment: false));
var lease = limiter.Acquire(2);
Assert.True(lease.IsAcquired);
var cts = new CancellationTokenSource();
var wait = limiter.WaitAndAcquireAsync(1, cts.Token);
cts.Cancel();
var ex = await Assert.ThrowsAsync <TaskCanceledException>(() => wait.AsTask());
Assert.Equal(cts.Token, ex.CancellationToken);
wait = limiter.WaitAndAcquireAsync(1);
Assert.False(wait.IsCompleted);
limiter.TryReplenish();
limiter.TryReplenish();
lease = await wait;
Assert.True(lease.IsAcquired);
Assert.Equal(1, limiter.GetAvailablePermits());
}
public override async Task CannotAcquireResourcesWithAcquireWithQueuedItemsIfOldestFirst()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions
{
PermitLimit = 2,
QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
QueueLimit = 3,
Window = TimeSpan.Zero,
SegmentsPerWindow = 2,
AutoReplenishment = false
});
var lease = limiter.AttemptAcquire(1);
Assert.True(lease.IsAcquired);
var wait = limiter.AcquireAsync(2);
Assert.False(wait.IsCompleted);
lease = limiter.AttemptAcquire(1);
Assert.False(lease.IsAcquired);
limiter.TryReplenish();
Assert.True(limiter.TryReplenish());
lease = await wait;
Assert.True(lease.IsAcquired);
}
public override async Task CanAcquireResourcesWithWaitAndAcquireAsyncWithQueuedItemsIfNewestFirst()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions(2, QueueProcessingOrder.NewestFirst, 2,
TimeSpan.Zero, 3, autoReplenishment: false));
var lease = limiter.Acquire(1);
Assert.True(lease.IsAcquired);
var wait = limiter.WaitAndAcquireAsync(2);
Assert.False(wait.IsCompleted);
Assert.Equal(1, limiter.GetAvailablePermits());
lease = await limiter.WaitAndAcquireAsync(1);
Assert.True(lease.IsAcquired);
Assert.False(wait.IsCompleted);
limiter.TryReplenish();
Assert.True(limiter.TryReplenish());
Assert.False(wait.IsCompleted);
Assert.True(limiter.TryReplenish());
lease = await wait;
Assert.True(lease.IsAcquired);
}
public override async Task QueueAvailableAfterQueueLimitHitAndResources_BecomeAvailable()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions(3, QueueProcessingOrder.OldestFirst, 2,
TimeSpan.Zero, 3, autoReplenishment: false));
var lease = limiter.Acquire(2);
var wait = limiter.WaitAndAcquireAsync(2);
var failedLease = await limiter.WaitAndAcquireAsync(2);
Assert.False(failedLease.IsAcquired);
limiter.TryReplenish();
limiter.TryReplenish();
Assert.False(wait.IsCompleted);
limiter.TryReplenish();
lease = await wait;
Assert.True(lease.IsAcquired);
wait = limiter.WaitAndAcquireAsync(2);
Assert.False(wait.IsCompleted);
limiter.TryReplenish();
limiter.TryReplenish();
limiter.TryReplenish();
lease = await wait;
Assert.True(lease.IsAcquired);
}
public override async Task GetStatisticsHasCorrectValues()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions
{
PermitLimit = 100,
QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
QueueLimit = 50,
Window = TimeSpan.Zero,
SegmentsPerWindow = 2,
AutoReplenishment = false
});
var stats = limiter.GetStatistics();
Assert.Equal(100, stats.CurrentAvailablePermits);
Assert.Equal(0, stats.CurrentQueuedCount);
Assert.Equal(0, stats.TotalFailedLeases);
Assert.Equal(0, stats.TotalSuccessfulLeases);
var lease1 = limiter.AttemptAcquire(60);
stats = limiter.GetStatistics();
Assert.Equal(40, stats.CurrentAvailablePermits);
Assert.Equal(0, stats.CurrentQueuedCount);
Assert.Equal(0, stats.TotalFailedLeases);
Assert.Equal(1, stats.TotalSuccessfulLeases);
var lease2Task = limiter.AcquireAsync(50);
stats = limiter.GetStatistics();
Assert.Equal(40, stats.CurrentAvailablePermits);
Assert.Equal(50, stats.CurrentQueuedCount);
Assert.Equal(0, stats.TotalFailedLeases);
Assert.Equal(1, stats.TotalSuccessfulLeases);
limiter.TryReplenish();
var lease3 = await limiter.AcquireAsync(1);
Assert.False(lease3.IsAcquired);
stats = limiter.GetStatistics();
Assert.Equal(40, stats.CurrentAvailablePermits);
Assert.Equal(50, stats.CurrentQueuedCount);
Assert.Equal(1, stats.TotalFailedLeases);
Assert.Equal(1, stats.TotalSuccessfulLeases);
var lease4 = limiter.AttemptAcquire(100);
Assert.False(lease4.IsAcquired);
stats = limiter.GetStatistics();
Assert.Equal(40, stats.CurrentAvailablePermits);
Assert.Equal(50, stats.CurrentQueuedCount);
Assert.Equal(2, stats.TotalFailedLeases);
Assert.Equal(1, stats.TotalSuccessfulLeases);
limiter.TryReplenish();
await lease2Task;
stats = limiter.GetStatistics();
Assert.Equal(50, stats.CurrentAvailablePermits);
Assert.Equal(0, stats.CurrentQueuedCount);
Assert.Equal(2, stats.TotalFailedLeases);
Assert.Equal(2, stats.TotalSuccessfulLeases);
}
public override void NullIdleDurationWhenActive()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions(1, QueueProcessingOrder.OldestFirst, 2,
TimeSpan.FromMilliseconds(2), 1, autoReplenishment: false));
limiter.Acquire(1);
Assert.Null(limiter.IdleDuration);
}
public override void AcquireZero_WithAvailability()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions(1, QueueProcessingOrder.NewestFirst, 1,
TimeSpan.Zero, 1, autoReplenishment: false));
using var lease = limiter.Acquire(0);
Assert.True(lease.IsAcquired);
}
public override void NoMetadataOnAcquiredLease()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions(1, QueueProcessingOrder.OldestFirst, 1,
TimeSpan.Zero, 2, autoReplenishment: false));
using var lease = limiter.Acquire(1);
Assert.False(lease.TryGetMetadata(MetadataName.RetryAfter, out _));
}
public override void MetadataNamesContainsAllMetadata()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions(1, QueueProcessingOrder.OldestFirst, 1,
TimeSpan.Zero, 1, autoReplenishment: false));
using var lease = limiter.Acquire(1);
Assert.Collection(lease.MetadataNames, metadataName => Assert.Equal(metadataName, MetadataName.RetryAfter.Name));
}
public void TryReplenishWithAutoReplenish_ReturnsFalse()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions(2, QueueProcessingOrder.OldestFirst, 1,
TimeSpan.FromSeconds(1), 1, autoReplenishment: true));
Assert.Equal(2, limiter.GetAvailablePermits());
Assert.False(limiter.TryReplenish());
Assert.Equal(2, limiter.GetAvailablePermits());
}
public override void IdleDurationUpdatesWhenChangingFromActive()
{
var limiter = new SlidingWindowRateLimiter(new SlidingWindowRateLimiterOptions(1, QueueProcessingOrder.OldestFirst, 2,
TimeSpan.Zero, 2, autoReplenishment: false));
limiter.Acquire(1);
limiter.TryReplenish();
limiter.TryReplenish();
Assert.NotNull(limiter.IdleDuration);
}
