private void CheckSequence()
{
Received.InOrder(() => {
_IAwaitableConstraint.WaitForReadiness(CancellationToken.None);
_FuncTask.Invoke();
_Diposable.Dispose();
});
}
public async Task Perform(Func <Task> perform, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
using (await _AwaitableConstraint.WaitForReadiness(cancellationToken))
{
await perform();
}
}
public async Task Compose_Use_both_AwaitableConstraints()
{
await _Composed.WaitForReadiness(CancellationToken.None);
await _AwaitableConstraint1.Received(1).WaitForReadiness(CancellationToken.None);
await _AwaitableConstraint2.Received(1).WaitForReadiness(CancellationToken.None);
}
public async void Dispatch(Action action)
{
using (await _AwaitableConstraint.WaitForReadiness(CancellationToken.None))
{
action();
}
}
public RateLimiterTest()
{
_FuncTask = Substitute.For <Func <Task> >();
_FuncTaskInt = Substitute.For <Func <Task <int> > >();
_IAwaitableConstraint = Substitute.For <IAwaitableConstraint>();
_Diposable = Substitute.For <IDisposable>();
_IAwaitableConstraint.WaitForReadiness(Arg.Any <CancellationToken>()).Returns(Task.FromResult(_Diposable));
_TimeConstraint = new RateLimiter.TimeLimiter(_IAwaitableConstraint);
}
public AwaitableConstraintExtensionTests()
{
_AwaitableConstraint1 = Substitute.For <IAwaitableConstraint>();
_AwaitableConstraint2 = Substitute.For <IAwaitableConstraint>();
_Disposable1 = Substitute.For <IDisposable>();
_Disposable2 = Substitute.For <IDisposable>();
_AwaitableConstraint1.WaitForReadiness(Arg.Any <CancellationToken>()).Returns(Task.FromResult(_Disposable1));
_AwaitableConstraint2.WaitForReadiness(Arg.Any <CancellationToken>()).Returns(Task.FromResult(_Disposable2));
_Composed = _AwaitableConstraint1.Compose(_AwaitableConstraint2);
}
public ComposedAwaitableConstraintTest()
{
_IAwaitableConstraint1 = Substitute.For <IAwaitableConstraint>();
_IAwaitableConstraint2 = Substitute.For <IAwaitableConstraint>();
_Diposable1 = Substitute.For <IDisposable>();
_Diposable2 = Substitute.For <IDisposable>();
_IAwaitableConstraint1.WaitForReadiness(Arg.Any <CancellationToken>()).Returns(Task.FromResult(_Diposable1));
_IAwaitableConstraint2.WaitForReadiness(Arg.Any <CancellationToken>()).Returns(Task.FromResult(_Diposable2));
_Composed = new ComposedAwaitableConstraint(_IAwaitableConstraint1, _IAwaitableConstraint2);
}
public async Task Execute_Rethrows_error()
{
var exception = new Exception();
_AwaitableConstraint1.WaitForReadiness(Arg.Any <CancellationToken>()).Throws(exception);
Func <Task> wait = async() => await _Composed.WaitForReadiness(CancellationToken.None);
var exceptionAssertion = await wait.Should().ThrowAsync <Exception>();
exceptionAssertion.Where(ex => ex == exception);
}
public async Task <IDisposable> WaitForReadiness(CancellationToken cancellationToken)
{
await _Semaphore.WaitAsync(cancellationToken);
IDisposable[] disposables;
try
{
disposables = await Task.WhenAll(_AwaitableConstraint1.WaitForReadiness(cancellationToken), _AwaitableConstraint2.WaitForReadiness(cancellationToken));
}
catch (Exception)
{
_Semaphore.Release();
throw;
}
return(new DisposeAction(() =>
{
foreach (var disposable in disposables)
{
disposable.Dispose();
}
_Semaphore.Release();
}));
}
private static async Task SetUpSaturated(IAwaitableConstraint countByIntervalAwaitableConstraint)
{
using (await countByIntervalAwaitableConstraint.WaitForReadiness(CancellationToken.None))
{
}
}