void HandlersAreCalled()
{
var handler1 = new TestEventHandler1();
var handler2 = new TestEventHandler2();
var services = new ServiceCollection();
services.AddOptions();
services.AddEventing(opt => {
opt.RegisterEventHandler(handler1);
opt.RegisterEventHandler(handler2);
});
Assert.Null(handler1.Message);
Assert.Null(handler2.Message);
var serviceProvider = services.BuildServiceProvider();
var publisher = serviceProvider.GetService <IEventPublisher>();
var appEvent = new TestEvent()
{
Message = "Hello from test"
};
publisher.Publish(appEvent);
Assert.Contains(appEvent.Message, handler1.Message);
Assert.Contains(appEvent.Message, handler2.Message);
}
public async Task Should_Invoke_All_Registered_Event_Handlers_In_Registration()
{
var asyncHandler1 = new TestEventAsyncHandler1(_testOutputHelper);
var asyncHandler2 = new TestEventAsyncHandler2(_testOutputHelper);
var asyncHandler3 = new TestEventAsyncHandler3(_testOutputHelper);
var handler1 = new TestEventHandler1(_testOutputHelper);
var handler2 = new TestEventHandler2(_testOutputHelper);
var handler3 = new TestEventHandler3(_testOutputHelper);
var registration = new EventHandlerRegistration();
registration.Register <TestEvent1>(() => handler1);
registration.Register <TestEvent1>(() => handler2);
registration.Register <TestEvent1>(() => handler3);
registration.Register <TestEvent1>(() => asyncHandler1);
registration.Register <TestEvent1>(() => asyncHandler2);
registration.Register <TestEvent1>(() => asyncHandler3);
var publisher = new EventPublisher(registration);
publisher.OnError += (@event, ex) =>
{
_testOutputHelper.WriteLine(ex.Message);
};
await publisher.PublishAsync(new TestEvent1());
// Event may not have yet been handled in background.
await Task.Delay(500);
// AsyncHandler1 should have 1 event.
// 1. TestEvent1
Assert.Equal(1, asyncHandler1.HandledEvents.Count);
Assert.Contains(asyncHandler1.HandledEvents, (e) => e is TestEvent1);
// AsyncHandler2 should have 1 event.
// 1. TestEvent1
Assert.Equal(1, asyncHandler2.HandledEvents.Count);
Assert.Contains(asyncHandler2.HandledEvents, (e) => e is TestEvent1);
// AsyncHandler3 should have 1 event.
// 1. TestEvent1
Assert.Equal(1, asyncHandler3.HandledEvents.Count);
Assert.Contains(asyncHandler3.HandledEvents, (e) => e is TestEvent1);
// Handler1 should have 1 event.
// 1. TestEvent1
Assert.Equal(1, handler1.HandledEvents.Count);
Assert.Contains(handler1.HandledEvents, (e) => e is TestEvent1);
// Handler2 should have 1 event.
// 1. TestEvent1
Assert.Equal(1, handler2.HandledEvents.Count);
Assert.Contains(handler2.HandledEvents, (e) => e is TestEvent1);
// Handler3 should have 1 event.
// 1. TestEvent1
Assert.Equal(1, handler3.HandledEvents.Count);
Assert.Contains(handler3.HandledEvents, (e) => e is TestEvent1);
}
public void Should_Store_All_Event_Handlers()
{
var asyncHandler1 = new TestEventAsyncHandler1(_testOutputHelper);
var asyncHandler2 = new TestEventAsyncHandler2(_testOutputHelper);
var asyncHandler3 = new TestEventAsyncHandler3(_testOutputHelper);
var handler1 = new TestEventHandler1(_testOutputHelper);
var handler2 = new TestEventHandler2(_testOutputHelper);
var handler3 = new TestEventHandler3(_testOutputHelper);
var registration = new EventHandlerRegistration();
registration.Register <TestEvent1>(() => asyncHandler1);
registration.Register <TestEvent1>(() => asyncHandler2);
registration.Register <TestEvent1>(() => asyncHandler3);
registration.Register <TestEvent1>(() => handler1);
registration.Register <TestEvent1>(() => handler2);
registration.Register <TestEvent1>(() => handler3);
IEnumerable <EventHandlerDelegate> eventHandlerDelegates = registration.ResolveEventHandlers <TestEvent1>();
Assert.Equal(6, eventHandlerDelegates.Count());
}
