public async Task should_trigger_scope_closing_on_failing_handler()
{
var registry = new EventHandlerRegistry();
var container = Substitute.For <IContainer>();
var scope = Substitute.For <IContainerScope>();
var handler = new FailingHandler();
ScopeClosingEventArgs actual = null;
registry.Map <TestEvent>(handler.GetType());
scope.Resolve(handler.GetType()).Returns(handler);
container.CreateScope().Returns(scope);
var sut = new SeparateScopesIocEventBus(container, registry);
sut.ScopeClosing += (sender, args) => actual = args;
try
{
await sut.PublishAsync(new TestEvent());
}
catch (AggregateException)
{
//ignore for test purposes
}
actual.Should().NotBeNull();
actual.HandlersWasSuccessful.Should().BeFalse();
}
public async Task event_should_report_Failure_if_one_handler_throws_an_exception()
{
var registry = new EventHandlerRegistry();
var container = Substitute.For <IContainer>();
var scope1 = Substitute.For <IContainerScope>();
var scope2 = Substitute.For <IContainerScope>();
var successHandler = new SuccessfulHandler();
var failingHandler = new FailingHandler();
bool actual = false;
registry.Map <TestEvent>(failingHandler.GetType());
registry.Map <TestEvent>(successHandler.GetType());
container.CreateScope().Returns(scope1, scope2);
scope1.Resolve(failingHandler.GetType()).Returns(failingHandler);
scope2.Resolve(successHandler.GetType()).Returns(successHandler);
var sut = new SeparateScopesIocEventBus(container, registry);
sut.EventPublished += (sender, args) => actual = args.Successful;
try
{
sut.PublishAsync(new TestEvent());
}
catch
{
}
actual.Should().BeFalse();
}
public async Task one_failing_handler_should_not_abort_others()
{
var registry = new EventHandlerRegistry();
var container = Substitute.For <IContainer>();
var scope1 = Substitute.For <IContainerScope>();
var scope2 = Substitute.For <IContainerScope>();
var evt = new TestEvent();
var successHandler = new SuccessfulHandler();
var failingHandler = new FailingHandler();
Exception actual = null;
registry.Map <TestEvent>(failingHandler.GetType());
registry.Map <TestEvent>(successHandler.GetType());
container.CreateScope().Returns(scope1, scope2);
scope1.Resolve(failingHandler.GetType()).Returns(failingHandler);
scope2.Resolve(successHandler.GetType()).Returns(successHandler);
var sut = new SeparateScopesIocEventBus(container, registry);
try
{
await sut.PublishAsync(evt);
}
catch (Exception exception)
{
actual = exception;
}
successHandler.IsCalled.Should().BeTrue();
actual.Should().BeOfType <AggregateException>();
}
public void Can_send_event()
{
// arrange
MassTransit massTransit = null;
try
{
var container = new Container();
var handler = new TestEventHandler();
container.Register <IEventHandler <TestEvent> >(() => handler);
var eventRegistry = new EventHandlerRegistry(container);
var commandRegistry = new CommandHandlerRegistry(container);
massTransit = new MassTransit(commandRegistry, eventRegistry, container);
var eventBus = new EventBus(massTransit);
// act
eventBus.Publish(new TestEvent());
// assert
Thread.Sleep(TimeSpan.FromSeconds(2));
Assert.That(handler.NumberOfTimesRan, Is.EqualTo(1));
}
finally
{
if (massTransit != null)
{
massTransit.Dispose();
}
}
}
public void must_get_container_to_be_fully_functional()
{
var registry = new EventHandlerRegistry();
Action x = () => new SeparateScopesIocEventBus(null, registry);
x.ShouldThrow <ArgumentNullException>();
}
public async Task works_without_subscribers_since_there_is_no_coupling_between_the_publisher_and_subscribers()
{
var registry = new EventHandlerRegistry();
var container = Substitute.For <IContainer>();
var sut = new SeparateScopesIocEventBus(container, registry);
await sut.PublishAsync(new TestEvent());
}
public void CustomMappingStrategyUsedWhenExplicitStrategyDefined()
{
var typeLocator = new FakeTypeLocator(typeof(FakeEvent), typeof(ExplicitStrategyAggregate));
var registry = new EventHandlerRegistry(typeLocator, serviceProvider.Object, sagaStore.Object, new Lazy <IPublishCommands>(() => commandPublisher.Object));
var handler = registry.GetHandlersFor(new FakeEvent());
Assert.Equal(1, handler.Count());
}
public void should_not_Be_able_To_map_other_classes_than_Event_handlers()
{
var sut = new EventHandlerRegistry();
Action actual = () => sut.Map <SupriseSucceeded>(GetType());
actual.Should().Throw <ArgumentException>();
}
public void ReturnsEmptyList_WhenAskingForUnregisteredEventHandlers()
{
var testee = new EventHandlerRegistry();
var handlers = testee.GetEventHandlers(new ValueEvent(11));
handlers.Should().BeEmpty();
}
public void ReturnEventHandlersBeforeSagaEventHandlers()
{
var typeLocator = new FakeTypeLocator(typeof(PrimaryHandler), typeof(PrimarySaga), typeof(FakeEvent));
var registry = new EventHandlerRegistry(typeLocator, serviceProvider.Object, sagaStore.Object, new Lazy <IPublishCommands>(() => commandPublisher.Object));
var handlers = registry.GetHandlersFor(new FakeEvent()).ToArray();
Assert.Equal(typeof(PrimaryHandler), handlers[0].HandlerType);
Assert.Equal(typeof(PrimarySaga), handlers[1].HandlerType);
}
public void CanGetRegisteredEventHandlers()
{
var testee = new EventHandlerRegistry();
testee.Register(typeof(ValueEventHandler), typeof(ValueEvent));
var handlers = testee.GetEventHandlers(new ValueEvent(11));
handlers.Single().Should().BeAssignableTo <ValueEventHandler>();
}
public void should_not_Be_able_To_map_lookup_other_types_of_objects_than_events()
{
var sut = new EventHandlerRegistry();
sut.Map <SupriseSucceeded>(typeof(SupriseHandler));
Action actual = () => sut.Lookup(GetType());
actual.Should().Throw <ArgumentException>();
}
public void should_not_Be_able_To_map_using_assembly_scanning()
{
var sut = new EventHandlerRegistry();
sut.ScanAssembly(Assembly.GetExecutingAssembly());
var handlers = sut.Lookup(typeof(SupriseSucceeded)).ToList();
handlers.Count.Should().Be(1);
handlers[0].Should().Be(typeof(SupriseHandler));
}
public void should_Be_able_to_resolve_a_handler()
{
var sut = new EventHandlerRegistry();
sut.Map <SupriseSucceeded>(typeof(SupriseHandler));
var handlers = sut.Lookup(typeof(SupriseSucceeded)).ToList();
handlers.Count.Should().Be(1);
handlers[0].Should().Be(typeof(SupriseHandler));
}
public async Task should_dispose_scope_when_done()
{
var registry = new EventHandlerRegistry();
var container = Substitute.For <IContainer>();
var scope = Substitute.For <IContainerScope>();
var handler = new SuccessfulHandler();
registry.Map <TestEvent>(handler.GetType());
scope.Resolve(handler.GetType()).Returns(handler);
container.CreateScope().Returns(scope);
var sut = new SeparateScopesIocEventBus(container, registry);
await sut.PublishAsync(new TestEvent());
scope.Received().Dispose();
}
public async Task should_work_with_just_one_handler()
{
var registry = new EventHandlerRegistry();
var container = Substitute.For <IContainer>();
var scope1 = Substitute.For <IContainerScope>();
var subscriber1 = Substitute.For <IApplicationEventSubscriber <TestEvent> >();
var evt = new TestEvent();
registry.Map <TestEvent>(subscriber1.GetType());
container.CreateScope().Returns(scope1);
scope1.Resolve(subscriber1.GetType()).Returns(subscriber1);
var sut = new SeparateScopesIocEventBus(container, registry);
await sut.PublishAsync(evt);
subscriber1.Received().HandleAsync(evt);
}
public static void Main(params string[] args)
{
var myEventSource = new MyEventSource();
using (var handlerRegistry = new EventHandlerRegistry())
{
handlerRegistry.RegisterHandlerFor(
myEventSource,
myEventSource.GetEventInfo(),
() => Console.WriteLine("Yo there's some kinda event goin on"));
handlerRegistry.RegisterHandlerFor(
myEventSource,
myEventSource.GetEventInfo(),
() => Console.WriteLine("Yeah dawg let's check it out"));
myEventSource.FireOne();
}
myEventSource.FireOne();
}
public async Task should_trigger_event_upon_successful_completion()
{
var registry = new EventHandlerRegistry();
var container = Substitute.For <IContainer>();
var scope = Substitute.For <IContainerScope>();
var actual = false;
var handler = new SuccessfulHandler();
registry.Map <TestEvent>(handler.GetType());
scope.Resolve(handler.GetType()).Returns(handler);
container.CreateScope().Returns(scope);
var sut = new SeparateScopesIocEventBus(container, registry);
sut.EventPublished += (sender, args) => actual = true;
await sut.PublishAsync(new TestEvent());
actual.Should().BeTrue();
}
public static IServiceCollection AddEventProcessor(this IServiceCollection services, Action <IEventHandlerRegistry> action)
{
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
var queryHandlerRegistry = new EventHandlerRegistry();
action(queryHandlerRegistry);
foreach (var registeredHandler in queryHandlerRegistry.RegisteredHandlers)
{
services.AddScoped(registeredHandler);
}
services.AddSingleton <IEventHandlerRegistry>(queryHandlerRegistry);
services.AddHostedService <InternalEventProcessor>();
return(services);
}
public async Task should_trigger_scope_closing_on_successful_invocation()
{
var registry = new EventHandlerRegistry();
var container = Substitute.For <IContainer>();
var scope = Substitute.For <IContainerScope>();
var handler = new SuccessfulHandler();
ScopeClosingEventArgs actual = null;
registry.Map <TestEvent>(handler.GetType());
scope.Resolve(handler.GetType()).Returns(handler);
container.CreateScope().Returns(scope);
var sut = new SeparateScopesIocEventBus(container, registry);
sut.ScopeClosing += (sender, args) => actual = args;
await sut.PublishAsync(new TestEvent());
actual.Should().NotBeNull();
actual.HandlersWasSuccessful.Should().BeTrue();
}
public IEventBus CreateEventBus(IContainer container)
{
var registry = new EventHandlerRegistry();
registry.ScanAssembly(typeof(ValidateNewLoginHandler).Assembly);
registry.ScanAssembly(typeof(UserRepository).Assembly);
registry.ScanAssembly(typeof(ScanForNewErrorReports).Assembly);
var inner = new SeparateScopesIocEventBus(container, registry);
var bus = new QueuedEventBus(inner, _queueProvider);
inner.ScopeClosing += (sender, args) => CloseUnitOfWorks(args.Scope);
inner.HandlerFailed += (sender, args) =>
{
foreach (var failure in args.Failures)
{
_log.Error(failure.Handler.GetType().FullName + " failed to handle " + args.ApplicationEvent,
failure.Exception);
}
};
bus.Start();
return(bus);
}
public void CustomMappingStrategyUsedWhenExplicitStrategyDefined()
{
var typeLocator = new FakeTypeLocator(typeof(FakeEvent), typeof(ExplicitStrategyAggregate));
var registry = new EventHandlerRegistry(typeLocator, serviceProvider.Object, sagaStore.Object, new Lazy<IPublishCommands>(() => commandPublisher.Object));
var handler = registry.GetHandlersFor(new FakeEvent());
Assert.Equal(1, handler.Count());
}
public void ReturnHandlersOfSameEventTypeSortedByHandlerFullName()
{
var typeLocator = new FakeTypeLocator(typeof(PrimaryHandler), typeof(SecondaryHandler), typeof(PrimarySaga), typeof(SecondarySaga), typeof(FakeEvent));
var registry = new EventHandlerRegistry(typeLocator, serviceProvider.Object, sagaStore.Object, new Lazy<IPublishCommands>(() => commandPublisher.Object));
var handlers = registry.GetHandlersFor(new FakeEvent()).ToArray();
Assert.Equal(typeof(PrimaryHandler), handlers[0].HandlerType);
Assert.Equal(typeof(SecondaryHandler), handlers[1].HandlerType);
Assert.Equal(typeof(PrimarySaga), handlers[2].HandlerType);
Assert.Equal(typeof(SecondarySaga), handlers[3].HandlerType);
}
public void ReturnBaseTypesBeforeDerivedTypes()
{
var typeLocator = new FakeTypeLocator(typeof(PrimaryHandler), typeof(FakeEvent), typeof(DerivedFakeEvent));
var registry = new EventHandlerRegistry(typeLocator, serviceProvider.Object, sagaStore.Object, new Lazy<IPublishCommands>(() => commandPublisher.Object));
var handlers = registry.GetHandlersFor(new DerivedFakeEvent()).ToArray();
Assert.Equal(typeof(FakeEvent), handlers[0].EventType);
Assert.Equal(typeof(DerivedFakeEvent), handlers[1].EventType);
}
public PluginConfiguration(IContainerRegistrar containerRegistrar, EventHandlerRegistry registry)
{
_containerRegistrar = containerRegistrar;
_registry = registry;
}
public void Init()
{
_mockServiceProvider = Substitute.For <IServiceProvider>();
_mockServiceProvider.GetService(typeof(TestEventHandler)).Returns(new TestEventHandler());
_registry = new EventHandlerRegistry(_mockServiceProvider);
}
private void InitializeEventHandlers()
{
handlerRegistry = new EventHandlerRegistry();
handlerRegistry.RegisterHandler(new CustomerEventHandler(GetDocumentStore));
}
