public void Should_Resolve_All_Event_Handlers()
{
Assembly assembly = typeof(TestEvent1).Assembly;
var container = new Container();
container.RegisterCollection(typeof(IEventAsyncHandler <>), assembly);
container.RegisterCollection(typeof(IEventHandler <>), assembly);
container.Register(() => _testOutputHelper);
var adapter = new SimpleInjectorContainerAdapter(container);
var eventHandlerResolver = new ContainerEventHandlerResolver(adapter);
IEnumerable <EventHandlerDelegate> eventHandlerDelegates = eventHandlerResolver.ResolveEventHandlers <TestEvent1>();
// Get all handlers in assembly.
int asyncHandlerCount = assembly.DefinedTypes.Count(t =>
!t.IsAbstract && !t.IsInterface &&
t.ImplementedInterfaces.Any(i =>
i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEventAsyncHandler <>)));
int syncHandlerCount = assembly.DefinedTypes.Count(t =>
!t.IsAbstract && !t.IsInterface &&
t.ImplementedInterfaces.Any(i =>
i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEventHandler <>)));
int totalHandlerCount = asyncHandlerCount + syncHandlerCount;
// Important Note: This should equal all handlers in this assembly.
Assert.Equal(totalHandlerCount, eventHandlerDelegates.Count());
}
public async Task ShouldNotThrowIfNoEventHandlerIsRegisteredInContainer()
{
var container = new Container();
var adapter = new SimpleInjectorContainerAdapter(container);
var eventHandlerResolver = new ContainerEventHandlerResolver(adapter);
var delegator = new EventDelegator(eventHandlerResolver);
await delegator.SendAsync(new TestEvent1());
}
public async Task Should_Be_Good_If_No_Event_Handler_Is_Registered_In_Container()
{
var container = new Container();
var adapter = new SimpleInjectorContainerAdapter(container);
var eventHandlerResolver = new ContainerEventHandlerResolver(adapter);
var publisher = new EventPublisher(eventHandlerResolver);
publisher.OnError += (@event, ex) =>
{
_testOutputHelper.WriteLine(ex.Message);
};
await publisher.PublishAsync(new TestEvent1());
}
public async Task Should_Invoke_All_Registered_Event_Handlers_In_Container()
{
var container = new Container();
container.RegisterCollection(typeof(IEventAsyncHandler <>), typeof(TestEvent1).Assembly);
container.RegisterCollection(typeof(IEventHandler <>), typeof(TestEvent1).Assembly);
container.Register(() => _testOutputHelper);
var adapter = new SimpleInjectorContainerAdapter(container);
var eventHandlerResolver = new ContainerEventHandlerResolver(adapter);
var publisher = new EventPublisher(eventHandlerResolver);
publisher.OnError += (@event, ex) =>
{
_testOutputHelper.WriteLine(ex.Message);
Assert.IsType <TestEventHandlerException>(ex);
};
await publisher.PublishAsync(new TestEvent1());
}
public async Task ShouldResolverAllEventHandlersFromContainer()
{
Assembly assembly = typeof(TestEvent1).Assembly;
// Register all event handlers.
var containerWithEventHandlers = new Container();
containerWithEventHandlers.Register(() => _outputHelper);
containerWithEventHandlers.RegisterCollection(typeof(IEventAsyncHandler <>), assembly);
containerWithEventHandlers.RegisterCollection(typeof(IEventHandler <>), assembly);
// Get all event handlers from above container and register in this new container as singletons.
// Register event handlers as singletons so that we can verify HandledEvents property.
var container = new Container();
container.Register(() => _outputHelper);
container.RegisterCollection <IEventAsyncHandler <TestEvent1> >(containerWithEventHandlers.GetAllInstances <IEventAsyncHandler <TestEvent1> >().ToList());
container.RegisterCollection <IEventHandler <TestEvent1> >(containerWithEventHandlers.GetAllInstances <IEventHandler <TestEvent1> >().ToList());
var eventHandlerResolver = new ContainerEventHandlerResolver(new SimpleInjectorContainerAdapter(container));
MessageHandlerDelegate eventHandlerDelegate = eventHandlerResolver.ResolveMessageHandler(typeof(TestEvent1));
await eventHandlerDelegate.Invoke(new TestEvent1());
// Get all handlers in assembly.
var eventAsyncHandlers = container.GetAllInstances <IEventAsyncHandler <TestEvent1> >().Cast <TestEventHandler>().ToList();
var eventSyncHandlers = container.GetAllInstances <IEventHandler <TestEvent1> >().Cast <TestEventHandler>().ToList();
int totalEventHandlerCount = eventAsyncHandlers.Count + eventSyncHandlers.Count;
int totalEventsHandledCount = eventAsyncHandlers.Sum(e => e.HandledEvents.Count) +
eventSyncHandlers.Sum(e => e.HandledEvents.Count);
// Important Note: This should equal all handlers in this assembly.
totalEventHandlerCount.Should().Be(totalEventsHandledCount);
}
public async Task Should_Invoke_All_Registered_Event_Handlers_In_Container_For_Each_Events()
{
var container = new Container();
container.RegisterCollection(typeof(IEventAsyncHandler <>), typeof(TestEvent1).Assembly);
container.RegisterCollection(typeof(IEventHandler <>), typeof(TestEvent1).Assembly);
container.Register(() => _testOutputHelper);
var adapter = new SimpleInjectorContainerAdapter(container);
var eventHandlerResolver = new ContainerEventHandlerResolver(adapter);
var publisher = new EventPublisher(eventHandlerResolver);
publisher.OnError += (@event, ex) =>
{
_testOutputHelper.WriteLine(ex.Message);
};
await publisher.PublishAsync(new List <IEvent> {
new TestEvent1(), new TestEvent2(), new TestEvent3()
});
// Event may not have yet been handled in background.
await Task.Delay(500);
}
