public void Should_publish_to_all_handlers()
{
var handler = new TestAggregateDidSomethingHandler();
_bus.RegisterHandler<TestAggregateDidSomething>(handler.Handle);
_bus.RegisterHandler<TestAggregateDidSomething>(handler.Handle);
_bus.Publish(new TestAggregateDidSomething());
Assert.Equal(2, handler.TimesRun);
}
public void Should_publish_to_all_handlers()
{
var handler = new TestAggregateDidSomethingHandler();
_bus.RegisterHandler <TestAggregateDidSomething>(handler.Handle, handler.GetType());
_bus.RegisterHandler <TestAggregateDidSomething>(handler.Handle, handler.GetType());
_bus.Publish(new TestAggregateDidSomething());
Assert.AreEqual(2, handler.TimesRun);
}
public async Task Should_wait_for_published_to_finish()
{
var handler = new TestAggregateDidSomethingHandler();
_bus.RegisterHandler <TestAggregateDidSomething>(handler.Handle);
await _bus.Publish(new TestAggregateDidSomething { LongRunning = true });
Assert.Equal(1, handler.TimesRun);
}
public object GetService(Type type)
{
if (ReturnNull)
{
return(null);
}
if (type == typeof(IHandlerRegistrar))
{
return(_registrar);
}
if (type == typeof(TestAggregateDidSomethingHandler))
{
var handler = new TestAggregateDidSomethingHandler();
Handlers.Add(handler);
return(handler);
}
if (type == typeof(TestAggregateDidSomethingInternalHandler))
{
var handler = new TestAggregateDidSomethingInternalHandler();
Handlers.Add(handler);
return(handler);
}
if (type == typeof(TestAggregateDoSomethingElseHandler))
{
var handler = new TestAggregateDoSomethingElseHandler();
Handlers.Add(handler);
return(handler);
}
if (type == typeof(TestAggregateDoSomethingHandler))
{
var handler = new TestAggregateDoSomethingHandler();
Handlers.Add(handler);
return(handler);
}
if (type == typeof(TestAggregateDoSomethingHandlerExplicit))
{
var handler = new TestAggregateDoSomethingHandlerExplicit();
Handlers.Add(handler);
return(handler);
}
if (type == typeof(TestAggregateDoSomethingHandlerExplicit2))
{
var handler = new TestAggregateDoSomethingHandlerExplicit2();
Handlers.Add(handler);
return(handler);
}
if (type == typeof(AllHandler))
{
var handler = new AllHandler();
Handlers.Add(handler);
return(handler);
}
throw new ArgumentException($"Type {type.Name} not registered");
}
public async Task Should_forward_cancellation_token()
{
var token = new CancellationToken();
var handler = new TestAggregateDidSomethingHandler();
_bus.RegisterHandler <TestAggregateDidSomething>(handler.Handle);
await _bus.Publish(new TestAggregateDidSomething { LongRunning = true }, token);
Assert.Equal(token, handler.Token);
}
public async Task Should_throw_if_handler_throws()
{
var handler = new TestAggregateDidSomethingHandler();
_bus.RegisterHandler <TestAggregateDidSomething>(handler.Handle);
await Assert.ThrowsAsync <ConcurrencyException>(
async() => await _bus.Publish(new TestAggregateDidSomething {
Version = -10
}));
}
public async Task Should_publish_to_all_handlers()
{
var handler = new TestAggregateDidSomethingHandler();
_bus.RegisterHandler <TestAggregateDidSomething>(handler.Handle);
_bus.RegisterHandler <TestAggregateDidSomething>(handler.Handle);
await _bus.Publish(new TestAggregateDidSomething());
Assert.Equal(2, handler.TimesRun);
}
public async Task Should_publish_to_all_handlers()
{
var handler = new TestAggregateDidSomethingHandler();
_router.RegisterHandler <TestAggregateDidSomethingElse>((x, token) => handler.Handle(x));
_router.RegisterHandler <TestAggregateDidSomethingElse>((x, token) => handler.Handle(x));
await _router.Publish(new TestAggregateDidSomethingElse());
Assert.Equal(2, handler.TimesRun);
}
public void Should_work_when_handler_throws_exception()
{
var failingHandler = new TestAggregateDidSomethingHandlerThrowsException();
var handler = new TestAggregateDidSomethingHandler();
_bus.RegisterHandler <TestAggregateDidSomething>(handler.HandleAsync);
_bus.RegisterHandler <TestAggregateDidSomething>(failingHandler.HandleAsync);
_bus.RegisterHandler <TestAggregateDidSomething>(failingHandler.HandleAsync);
_bus.RegisterHandler <TestAggregateDidSomething>(handler.HandleAsync);
try
{
_bus.PublishAsync(new TestAggregateDidSomething());
}
catch (AggregateException ex)
{
Assert.AreEqual(2, ex.InnerExceptions.Count);
}
Assert.AreEqual(2, handler.TimesRun);
}
