public void TokensBecomeAvailableAtLimitPerSecondRate()
{
// arrange
var clock = new FakeSystemClock();
var limiter = new Limiter(new Limit(10), 50, clock);
// act
var initiallyAllowed = limiter.AllowN(clock.UtcNow, 50);
var thenNotAllowed1 = limiter.Allow();
clock.Advance(TimeSpan.FromMilliseconds(100));
var oneTokenAvailable = limiter.Allow();
var thenNotAllowed2 = limiter.Allow();
clock.Advance(TimeSpan.FromMilliseconds(200));
var twoTokensAvailable1 = limiter.Allow();
var twoTokensAvailable2 = limiter.Allow();
var thenNotAllowed3 = limiter.Allow();
// assert
initiallyAllowed.ShouldBeTrue();
thenNotAllowed1.ShouldBeFalse();
oneTokenAvailable.ShouldBeTrue();
thenNotAllowed2.ShouldBeFalse();
twoTokensAvailable1.ShouldBeTrue();
twoTokensAvailable2.ShouldBeTrue();
thenNotAllowed3.ShouldBeFalse();
}
public void ReserveTellsYouHowLongToWait()
{
var clock = new FakeSystemClock();
var limiter = new Limiter(new Limit(10), 50, clock);
var initiallyAllowed = limiter.AllowN(clock.UtcNow, 50);
var thenNotAllowed1 = limiter.Allow();
var reserveOne = limiter.Reserve();
var delayOne = reserveOne.Delay();
var reserveTwoMore = limiter.Reserve(clock.UtcNow, 2);
var delayTwoMore = reserveTwoMore.Delay();
clock.Advance(TimeSpan.FromMilliseconds(450));
var reserveAlreadyAvailable = limiter.Reserve();
var delayAlreadyAvailable = reserveAlreadyAvailable.Delay();
var reserveHalfAvailable = limiter.Reserve();
var delayHalfAvailable = reserveHalfAvailable.Delay();
Assert.True(initiallyAllowed);
Assert.False(thenNotAllowed1);
Assert.True(reserveOne.Ok);
Assert.Equal(TimeSpan.FromMilliseconds(100), delayOne);
Assert.True(reserveTwoMore.Ok);
Assert.Equal(TimeSpan.FromMilliseconds(300), delayTwoMore);
Assert.True(reserveAlreadyAvailable.Ok);
Assert.Equal(TimeSpan.Zero, delayAlreadyAvailable);
Assert.True(reserveHalfAvailable.Ok);
Assert.Equal(TimeSpan.FromMilliseconds(50), delayHalfAvailable);
}
public void TokensBecomeAvailableAtLimitPerSecondRate()
{
var clock = new FakeSystemClock();
var limiter = new Limiter(new Limit(10), 50, clock);
var initiallyAllowed = limiter.AllowN(clock.UtcNow, 50);
var thenNotAllowed1 = limiter.Allow();
clock.Advance(TimeSpan.FromMilliseconds(100));
var oneTokenAvailable = limiter.Allow();
var thenNotAllowed2 = limiter.Allow();
clock.Advance(TimeSpan.FromMilliseconds(200));
var twoTokensAvailable1 = limiter.Allow();
var twoTokensAvailable2 = limiter.Allow();
var thenNotAllowed3 = limiter.Allow();
Assert.True(initiallyAllowed);
Assert.False(thenNotAllowed1);
Assert.True(oneTokenAvailable);
Assert.False(thenNotAllowed2);
Assert.True(twoTokensAvailable1);
Assert.True(twoTokensAvailable2);
Assert.False(thenNotAllowed3);
}
public void NotOkayAlwaysReturnsMaxValueDelay()
{
// arrange
var clock = new FakeSystemClock();
var reservation = new Reservation(
clock: clock,
limiter: default,
public async Task ZeroDelayAddsInline()
{
// arrange
var state = "setup";
var added = new List <(string state, string item)>();
var fake = new FakeQueue <string>
{
OnAdd = item => added.Add((state, item)),
};
var clock = new FakeSystemClock();
IDelayingQueue <string> delayingQueue = new DelayingQueue <string>(clock, fake);
// act
state = "before-one";
delayingQueue.AddAfter("one", TimeSpan.FromMilliseconds(1));
state = "after-one";
await Task.Delay(TimeSpan.FromMilliseconds(40));
state = "before-two";
delayingQueue.AddAfter("two", TimeSpan.FromMilliseconds(0));
state = "after-two";
await Task.Delay(TimeSpan.FromMilliseconds(40));
state = "before-three";
delayingQueue.AddAfter("three", TimeSpan.FromMilliseconds(1));
state = "after-three";
await Task.Delay(TimeSpan.FromMilliseconds(40));
// assert
added.ShouldHaveSingleItem().ShouldBe(("before-two", "two"));
}
public void FirstTokenIsAvailable()
{
var clock = new FakeSystemClock();
var limiter = new Limiter(new Limit(10), 1, clock);
var allowed = limiter.Allow();
Assert.True(allowed);
}
public void FirstTokenIsAvailable()
{
// arrange
var clock = new FakeSystemClock();
var limiter = new Limiter(new Limit(10), 1, clock);
// act
var allowed = limiter.Allow();
// assert
allowed.ShouldBe(true);
}
public async Task DelayingQueueAddsWhenTimePasses()
{
// arrange
var added = new List <string>();
var fake = new FakeQueue <string>
{
OnAdd = added.Add,
};
var clock = new FakeSystemClock();
IDelayingQueue <string> delayingQueue = new DelayingQueue <string>(clock, fake);
// act
delayingQueue.AddAfter("50ms", TimeSpan.FromMilliseconds(50));
delayingQueue.AddAfter("100ms", TimeSpan.FromMilliseconds(100));
clock.Advance(TimeSpan.FromMilliseconds(25));
delayingQueue.AddAfter("75ms", TimeSpan.FromMilliseconds(50));
delayingQueue.AddAfter("125ms", TimeSpan.FromMilliseconds(100));
await Task.Delay(TimeSpan.FromMilliseconds(40));
var countAfter25ms = added.Count;
clock.Advance(TimeSpan.FromMilliseconds(30));
await Task.Delay(TimeSpan.FromMilliseconds(40));
var countAfter55ms = added.Count;
clock.Advance(TimeSpan.FromMilliseconds(25));
await Task.Delay(TimeSpan.FromMilliseconds(40));
var countAfter80ms = added.Count;
clock.Advance(TimeSpan.FromMilliseconds(25));
await Task.Delay(TimeSpan.FromMilliseconds(40));
var countAfter105ms = added.Count;
clock.Advance(TimeSpan.FromMilliseconds(25));
await Task.Delay(TimeSpan.FromMilliseconds(40));
var countAfter135ms = added.Count;
// assert
countAfter25ms.ShouldBe(0);
countAfter55ms.ShouldBe(1);
countAfter80ms.ShouldBe(2);
countAfter105ms.ShouldBe(3);
countAfter135ms.ShouldBe(4);
added.ShouldBe(new[] { "50ms", "75ms", "100ms", "125ms" }, ignoreOrder: false);
}
public void AsManyAsBurstTokensAreAvailableRightAway(int burst)
{
var clock = new FakeSystemClock();
var limiter = new Limiter(new Limit(10), burst, clock);
var allowed = new List <bool>();
foreach (var index in Enumerable.Range(1, burst))
{
allowed.Add(limiter.Allow());
}
var notAllowed = limiter.Allow();
Assert.All(allowed, item => Assert.True(item));
Assert.False(notAllowed);
}
public async Task DelayingQueueAddsWhenTimePasses()
{
var added = new List <string>();
var fake = new FakeQueue <string>
{
OnAdd = added.Add,
};
var clock = new FakeSystemClock();
IDelayingQueue <string> delayingQueue = new DelayingQueue <string>(clock, fake);
delayingQueue.AddAfter("50ms", TimeSpan.FromMilliseconds(50));
delayingQueue.AddAfter("100ms", TimeSpan.FromMilliseconds(100));
clock.Advance(TimeSpan.FromMilliseconds(25));
delayingQueue.AddAfter("75ms", TimeSpan.FromMilliseconds(50));
delayingQueue.AddAfter("125ms", TimeSpan.FromMilliseconds(100));
await Task.Delay(TimeSpan.FromMilliseconds(40));
var countAfter25ms = added.Count;
clock.Advance(TimeSpan.FromMilliseconds(30));
await Task.Delay(TimeSpan.FromMilliseconds(40));
var countAfter55ms = added.Count;
clock.Advance(TimeSpan.FromMilliseconds(25));
await Task.Delay(TimeSpan.FromMilliseconds(40));
var countAfter80ms = added.Count;
clock.Advance(TimeSpan.FromMilliseconds(25));
await Task.Delay(TimeSpan.FromMilliseconds(40));
var countAfter105ms = added.Count;
clock.Advance(TimeSpan.FromMilliseconds(25));
await Task.Delay(TimeSpan.FromMilliseconds(40));
var countAfter135ms = added.Count;
Assert.Equal(0, countAfter25ms);
Assert.Equal(1, countAfter55ms);
Assert.Equal(2, countAfter80ms);
Assert.Equal(3, countAfter105ms);
Assert.Equal(4, countAfter135ms);
Assert.Equal(new[] { "50ms", "75ms", "100ms", "125ms" }, added);
}
public async Task NoAddingAfterShutdown()
{
var added = new List <string>();
var fake = new FakeQueue <string>
{
OnAdd = added.Add,
};
var clock = new FakeSystemClock();
IDelayingQueue <string> delayingQueue = new DelayingQueue <string>(clock, fake);
delayingQueue.AddAfter("one", TimeSpan.FromMilliseconds(10));
delayingQueue.ShutDown();
delayingQueue.AddAfter("two", TimeSpan.FromMilliseconds(10));
clock.Advance(TimeSpan.FromMilliseconds(25));
await Task.Delay(TimeSpan.FromMilliseconds(40));
Assert.Empty(added);
}
public void AsManyAsBurstTokensAreAvailableRightAway(int burst)
{
// arrange
var clock = new FakeSystemClock();
var limiter = new Limiter(new Limit(10), burst, clock);
// act
var allowed = new List <bool>();
foreach (var index in Enumerable.Range(1, burst))
{
allowed.Add(limiter.Allow());
}
var notAllowed = limiter.Allow();
// assert
allowed.ShouldAllBe(item => item == true);
notAllowed.ShouldBeFalse();
}
public void DelayingQueuePassesCallsThrough()
{
var added = new List <string>();
var doned = new List <string>();
var fake = new FakeQueue <string>
{
OnAdd = added.Add,
OnDone = doned.Add,
OnLen = () => 42,
};
var clock = new FakeSystemClock();
IDelayingQueue <string> delayingQueue = new DelayingQueue <string>(clock, fake);
delayingQueue.Add("one");
delayingQueue.Done("two");
var len = delayingQueue.Len();
Assert.Equal("one", Assert.Single(added));
Assert.Equal("two", Assert.Single(doned));
Assert.Equal(42, len);
}
public void ReserveTellsYouHowLongToWait()
{
// arrange
var clock = new FakeSystemClock();
var limiter = new Limiter(new Limit(10), 50, clock);
// act
var initiallyAllowed = limiter.AllowN(clock.UtcNow, 50);
var thenNotAllowed1 = limiter.Allow();
var reserveOne = limiter.Reserve();
var delayOne = reserveOne.Delay();
var reserveTwoMore = limiter.Reserve(clock.UtcNow, 2);
var delayTwoMore = reserveTwoMore.Delay();
clock.Advance(TimeSpan.FromMilliseconds(450));
var reserveAlreadyAvailable = limiter.Reserve();
var delayAlreadyAvailable = reserveAlreadyAvailable.Delay();
var reserveHalfAvailable = limiter.Reserve();
var delayHalfAvailable = reserveHalfAvailable.Delay();
// assert
initiallyAllowed.ShouldBeTrue();
thenNotAllowed1.ShouldBeFalse();
reserveOne.Ok.ShouldBeTrue();
delayOne.ShouldBe(TimeSpan.FromMilliseconds(100));
reserveTwoMore.Ok.ShouldBeTrue();
delayTwoMore.ShouldBe(TimeSpan.FromMilliseconds(300));
reserveAlreadyAvailable.Ok.ShouldBeTrue();
delayAlreadyAvailable.ShouldBe(TimeSpan.Zero);
reserveHalfAvailable.Ok.ShouldBeTrue();
delayHalfAvailable.ShouldBe(TimeSpan.FromMilliseconds(50));
}
public void DelayingQueuePassesCallsThrough()
{
// arrange
var added = new List <string>();
var doned = new List <string>();
var fake = new FakeQueue <string>
{
OnAdd = added.Add,
OnDone = doned.Add,
OnLen = () => 42,
};
var clock = new FakeSystemClock();
IDelayingQueue <string> delayingQueue = new DelayingQueue <string>(clock, fake);
// act
delayingQueue.Add("one");
delayingQueue.Done("two");
var len = delayingQueue.Len();
// assert
added.ShouldHaveSingleItem().ShouldBe("one");
doned.ShouldHaveSingleItem().ShouldBe("two");
len.ShouldBe(42);
}
public void SimpleAutoSyncTrackingCancelledCycle()
{
// arrange identifiers
var scopeId = Guid.NewGuid();
var scopeName = Guid.NewGuid().ToString();
var trackingId = Guid.NewGuid();
// arrange a stopwatch that tracks a known interval
var elapsed = TimeSpan.FromSeconds(123);
var watch = new FakeTrackerStopwatch
{
TargetElapsed = elapsed
};
var factory = Mock.Of <ITrackerStopwatchFactory>(x => x.Create() == watch);
// arrange a test sink
var sink = new FakeSink();
// arrange a system clock
var now = DateTimeOffset.Now;
var clock = new FakeSystemClock {
Now = now
};
// act - build host
using (var host = Host
.CreateDefaultBuilder()
.UseChronoscope(chrono =>
{
chrono.ConfigureServices(services =>
{
services.AddSingleton(factory);
services.AddSingleton <ITrackingSink>(sink);
services.AddSingleton <ISystemClock>(clock);
});
})
.Build())
{
// act - request services
var chrono = host.Services.GetRequiredService <IChronoscope>();
var scope = chrono.CreateScope(scopeId, scopeName);
var tracker = scope.CreateAutoTracker(trackingId);
// assert - elapsed is zero
Assert.Equal(TimeSpan.Zero, tracker.Elapsed);
// act - do tracking
int result = -1;
try
{
var token = new CancellationToken(true);
result = tracker.Track((scope, token) =>
{
token.ThrowIfCancellationRequested();
return(1);
}, token);
}
catch (OperationCanceledException)
{
/* noop */
}
// assert - the result is correct
Assert.Equal(-1, result);
// assert - elapsed time is correct
Assert.Equal(elapsed, tracker.Elapsed);
// assert - events were generated
Assert.Collection(sink.Events,
e =>
{
var x = Assert.IsAssignableFrom <IScopeCreatedEvent>(e);
Assert.Equal(scopeId, x.ScopeId);
Assert.Equal(scopeName, x.Name);
Assert.Null(x.ParentScopeId);
Assert.Equal(now, x.Timestamp);
},
e =>
{
var x = Assert.IsAssignableFrom <ITrackerCreatedEvent>(e);
Assert.Equal(scopeId, x.ScopeId);
Assert.Equal(trackingId, x.TrackerId);
Assert.Equal(now, x.Timestamp);
Assert.Equal(TimeSpan.Zero, x.Elapsed);
},
e =>
{
var x = Assert.IsAssignableFrom <ITrackerStartedEvent>(e);
Assert.Equal(scopeId, x.ScopeId);
Assert.Equal(trackingId, x.TrackerId);
Assert.Equal(now, x.Timestamp);
Assert.Equal(TimeSpan.Zero, x.Elapsed);
},
e =>
{
var x = Assert.IsAssignableFrom <ITrackerStoppedEvent>(e);
Assert.Equal(scopeId, x.ScopeId);
Assert.Equal(trackingId, x.TrackerId);
Assert.Equal(now, x.Timestamp);
Assert.Equal(elapsed, x.Elapsed);
},
e =>
{
var x = Assert.IsAssignableFrom <ITrackerCancelledEvent>(e);
Assert.Equal(scopeId, x.ScopeId);
Assert.Equal(trackingId, x.TrackerId);
Assert.Equal(now, x.Timestamp);
Assert.Equal(elapsed, x.Elapsed);
Assert.IsAssignableFrom <OperationCanceledException>(x.Exception);
});
}
}
private static FakeClaimsAuthenticationService2 Authentication(
FakeHttpContextAccessor httpContextAccessor = null,
FakeUserStore userStore = null, ClaimOptions options = null,
FakeSystemClock clock = null) =>
new FakeClaimsAuthenticationService2(httpContextAccessor ?? HttpContextAccessor(),
userStore ?? UserStore(), options ?? Options(), clock ?? Clock());
private static UserClaimsConverter <User> Converter(ClaimOptions options = null,
FakeSystemClock clock = null) =>
new UserClaimsConverter <User>(options ?? Options(), clock ?? Clock());
private static FakeClaimsAuthenticationServiceBase Authentication(
FakeUserStore userStore = null, ClaimOptions options = null,
FakeSystemClock clock = null) =>
new FakeClaimsAuthenticationServiceBase(userStore ?? UserStore(),
options ?? Options(), clock ?? Clock());
private static ClaimsPrincipal Principal(bool hasUserKey = true,
bool hasSecurityStamp = true, bool hasSecurityStampValidated = true,
FakeSystemClock clock = null) =>
FakeClaimsAuthenticationServiceBase.Principal(hasUserKey, hasSecurityStamp,
hasSecurityStampValidated, clock);
