public Task Should_Throw_If_Cancellation_Token_Source_Is_Cancelled()
{
return(Assert.ThrowsAnyAsync <OperationCanceledException>(async() =>
{
var asyncHandler1 = new TestEventAsyncHandler1(_testOutputHelper);
var registration = new EventHandlerRegistration();
registration.Register <TriggerLongRunningEvent>(() => asyncHandler1);
var publisher = new EventPublisher(registration);
publisher.OnError += (@event, ex) =>
{
_testOutputHelper.WriteLine(ex.Message);
};
var cts = new CancellationTokenSource();
Task publishTask = publisher.PublishAsync(new TriggerLongRunningEvent(1000), cts.Token);
cts.Cancel();
try
{
await publishTask;
}
catch (Exception ex)
{
_testOutputHelper.WriteLine(ex.Message);
throw;
}
}));
}
/// <summary>
/// Manages counting down dividers and invoking handlers.
/// </summary>
/// <param name="registration">The event handler callback registration. Must not be null.</param>
private void InvokeEventHandler(EventHandlerRegistration <CallbackRegistration> registration)
{
Check.IfArgumentNull(registration, "registration");
if (registration.UserData != null)
{
if (registration.UserData.DividerCount > 1)
{
registration.UserData.RunningDivider--;
if (registration.UserData.RunningDivider != 0)
{
// exit, divider not counted down.
return;
}
registration.UserData.RunningDivider = registration.UserData.DividerCount;
}
if (registration.UserData.Dispatcher != null)
{
registration.UserData.Dispatcher.BeginInvoke(
new Action(() => { InvokeHandlerDirect(registration); }));
}
else
{
this.InvokeHandlerDirect(registration);
}
}
else
{
this.InvokeHandlerDirect(registration);
}
}
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;
}
}));
}
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 static IEventPublisher CreatePublisher(Action <IEventHandlerRegistration> registrationMutator = null)
{
var registration = new EventHandlerRegistration();
if (registrationMutator != null)
{
registrationMutator.Invoke(registration);
}
return(new EventPublisher(registration));
}
/// <summary>
/// Register event handler for the event interface.
/// </summary>
/// <typeparam name="TEventInterface">Event interface of the type <see cref="IEvent"/>.</typeparam>
/// <typeparam name="TImplementation">Handler for the event interface.</typeparam>
/// <param name="builder">Instance of <see cref="IEventBusBuilder"/>.</param>
/// <returns>Instance of <see cref="IEventBusBuilder"/>.</returns>
public static IEventBusBuilder AddHandler <TEventInterface, TImplementation>(this IEventBusBuilder builder)
where TEventInterface : IEvent
where TImplementation : class, IEventHandler <TEventInterface>
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
return(builder.Add(EventHandlerRegistration.Register <TEventInterface, TImplementation>()));
}
/// <summary>
/// Directly invokes the handler (no synchronization).
/// </summary>
/// <param name="registration">Must not be null.</param>
private void InvokeHandlerDirect(EventHandlerRegistration <CallbackRegistration> registration)
{
try
{
registration.Handler?.DynamicInvoke(this, EventArgs.Empty);
}
catch (Exception e)
{
registration.UserData.LastError = e;
}
}
/// <summary>
/// Add event hander registration to event bus.
/// </summary>
/// <param name="registration"><see cref="EventHandlerRegistration"/>.</param>
/// <returns><see cref="IEventBusBuilder"/>.</returns>
public IEventBusBuilder Add(EventHandlerRegistration registration)
{
if (registration == null)
{
throw new ArgumentNullException(nameof(registration));
}
Services.Configure <EventBusServiceOptions>(options =>
{
options.Registrations.Add(registration);
});
return(this);
}
public Task Should_Throw_If_Null_Is_Being_Published()
{
return(Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
var registration = new EventHandlerRegistration();
var publisher = new EventPublisher(registration);
try
{
await publisher.PublishAsync((IEvent)null);
}
catch (Exception ex)
{
_testOutputHelper.WriteLine(ex.Message);
throw;
}
}));
}
public async Task Should_Trigger_OnError_If_EventHandlerRegistration_Produces_Null_Instance()
{
var registration = new EventHandlerRegistration();
// Produces null.
registration.Register(() => (IEventAsyncHandler <TestEvent1>)null);
var publisher = new EventPublisher(registration);
publisher.OnError += (@event, ex) =>
{
_testOutputHelper.WriteLine(ex.Message);
Assert.IsType <InvalidOperationException>(ex);
};
await publisher.PublishAsync(new 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());
}