public Task Should_Check_For_Correct_Command_Type() { return(Assert.ThrowsAnyAsync <ArgumentException>(async() => { var eventHandler = new TestEventHandler1(_testOutputHelper); var registration = new EventHandlerRegistration(); registration.Register(() => (IEventAsyncHandler <TestEvent1>)eventHandler); IEnumerable <EventHandlerDelegate> eventHandlerDelegates = registration.ResolveEventHandlers <TestEvent1>(); Assert.NotNull(eventHandlerDelegates); Assert.NotEmpty(eventHandlerDelegates); try { // This delegate handles TestEvent1, but was passed in a TestEvent2. await eventHandlerDelegates.First().Invoke(new TestEvent2()); } catch (Exception ex) { _testOutputHelper.WriteLine(ex.ToString()); throw; } })); }
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 async Task Should_Invoke_The_Actual_Registered_Command_Handler() { var eventHandler = new TestEventHandler1(_testOutputHelper); var registration = new EventHandlerRegistration(); registration.Register(() => (IEventHandler <TestEvent1>)eventHandler); IEnumerable <EventHandlerDelegate> eventHandlerDelegates = registration.ResolveEventHandlers <TestEvent1>(); Assert.NotNull(eventHandlerDelegates); Assert.NotEmpty(eventHandlerDelegates); // Invoke. await eventHandlerDelegates.First().Invoke(new TestEvent1()); // Check if actual command handler instance was invoked. Assert.Equal(1, eventHandler.HandledEvents.Count); Assert.Contains(eventHandler.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()); }