public void Should_be_called_when_send_faulted()
{
IPipeRouter router = new PipeRouter();
router.ConnectPipe(Pipe.New <CommandContext <SetConcurrencyLimit> >(cfg =>
{
cfg.UseExecute(cxt =>
{
throw new IntentionalTestException("Wow!");
});
}));
var observer = new Observer <CommandContext <SetConcurrencyLimit> >();
router.ConnectObserver(observer);
var observer2 = new Observer();
router.ConnectObserver(observer2);
Assert.That(async() => await router.SetConcurrencyLimit(32), Throws.TypeOf <IntentionalTestException>());
Assert.That(async() => await observer.SendFaulted, Throws.TypeOf <IntentionalTestException>());
Assert.That(async() => await observer2.SendFaulted, Throws.TypeOf <IntentionalTestException>());
}
public async Task Should_be_called_pre_send()
{
IPipeRouter router = new PipeRouter();
router.ConnectPipe(Pipe.Empty <CommandContext <SetConcurrencyLimit> >());
var observer = new Observer <CommandContext <SetConcurrencyLimit> >();
router.ConnectObserver(observer);
var observer2 = new Observer();
router.ConnectObserver(observer2);
await router.SetConcurrencyLimit(32);
await observer.PreSent;
Assert.That(async() => await observer2.PreSent, Is.InstanceOf <CommandContext <SetConcurrencyLimit> >());
}
public async Task Should_allow_reconfiguration_at_runtime()
{
var currentCount = 0;
var maxCount = 0;
IPipeRouter dynamicRouter = new PipeRouter();
IPipe <InputContext> pipe = Pipe.New <InputContext>(cfg =>
{
cfg.UseConcurrencyLimit(1, dynamicRouter);
cfg.UseExecuteAsync(async cxt =>
{
var current = Interlocked.Increment(ref currentCount);
while (current > maxCount)
{
Interlocked.CompareExchange(ref maxCount, current, maxCount);
}
await Task.Delay(10);
Interlocked.Decrement(ref currentCount);
});
});
await dynamicRouter.SetConcurrencyLimit(32);
var context = new InputContext("Hello");
Task[] tasks = Enumerable.Range(0, 500)
.Select(index => Task.Run(async() => await pipe.Send(context)))
.ToArray();
await Task.WhenAll(tasks);
Assert.That(maxCount, Is.EqualTo(32));
}