/// <summary>
/// Initializes a new instance of <see cref="EventHandler"/> using a delegate <paramref name="delegateHandler"/> instance.
/// </summary>
/// <param name="delegateHandler">The delegate event handler.</param>
protected EventHandler(EventHandler delegateHandler)
{
Verify.NotNull(delegateHandler, nameof(delegateHandler));
this.eventHandlerFactory = delegateHandler.eventHandlerFactory;
this.handlerType = delegateHandler.handlerType;
this.eventType = delegateHandler.eventType;
this.executor = delegateHandler.executor;
}
protected UsingSagaEventHandlerBase()
{
var sagaMetadata = new FakeSaga().GetMetadata();
var commandPublisher = new Mock <IPublishCommands>();
var executor = new Action <Object, Event>((handler, e) => { ((FakeSaga)handler).Handle((Timeout)e); Handled = true; });
var eventHandler = new EventHandler(typeof(FakeSaga), typeof(Timeout), executor, () => { throw new NotSupportedException(); });
SystemTime.ClearOverride();
SagaEventHandler = new SagaTimeoutHandler(eventHandler, sagaMetadata, SagaStore.Object, new Lazy <IPublishCommands>(() => commandPublisher.Object));
}
public void InvokeUnderlyingExecutorWithEventAndHandlerInstance()
{
var handled = false;
var e = new FakeEvent();
var handler = new Object();
var eventHandler = new EventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { handled = a == handler && b == e; }, () => handler);
using (var context = new EventContext(GuidStrategy.NewGuid(), HeaderCollection.Empty, e))
eventHandler.Handle(context);
Assert.True(handled);
}
protected UsingSagaEventHandlerBase()
{
var executor = new Action <Object, Event>((handler, e) => { ((FakeSaga)handler).Handle((FakeEvent)e); Handled = true; });
SagaId = GuidStrategy.NewGuid();
AggregateId = GuidStrategy.NewGuid();
Event = new FakeEvent {
Id = SagaId
};
SagaMetadata = new FakeSaga().GetMetadata();
EventContext = new EventContext(AggregateId, HeaderCollection.Empty, Event);
EventHandler = new EventHandler(typeof(FakeSaga), typeof(FakeEvent), executor, () => { throw new NotSupportedException(); });
SagaEventHandler = new SagaEventHandler(EventHandler, SagaMetadata, SagaStore.Object, new Lazy <IPublishCommands>(() => CommandPublisher.Object));
}
/// <summary>
/// Discover all event handlers methods associated with any locatable class marked with with <see cref="EventHandlerAttribute"/>.
/// </summary>
/// <param name="sagaStore">The saga store to pass on to any <see cref="SagaEventHandler"/> instances.</param>
/// <param name="typeLocator">The type locator use to retrieve all known classes marked with <see cref="EventHandlerAttribute"/>.</param>
/// <param name="serviceProvider">The service locator used to retrieve singleton event handler dependencies.</param>
/// <param name="commandPublisher">The command publisher used to publish saga commands.</param>
private static Dictionary<Type, List<EventHandler>> DiscoverHandleMethods(ILocateTypes typeLocator, IServiceProvider serviceProvider, IStoreSagas sagaStore, Lazy<IPublishCommands> commandPublisher)
{
var handlerTypes = typeLocator.GetTypes(type => !type.IsAbstract && type.IsClass && type.GetCustomAttribute<EventHandlerAttribute>() != null);
var knownEventHandlers = new Dictionary<Type, List<EventHandler>>();
foreach (var handlerType in handlerTypes)
{
var handleMethods = GetHandleMethods(handlerType, serviceProvider);
var sagaMetadata = typeof(Saga).IsAssignableFrom(handlerType) ? GetSagaMetadata(handlerType, handleMethods) : null;
foreach (var handleMethod in handleMethods)
{
List<EventHandler> eventHandlers;
Type eventType = handleMethod.Key;
if (!knownEventHandlers.TryGetValue(eventType, out eventHandlers))
knownEventHandlers.Add(eventType, eventHandlers = new List<EventHandler>());
var eventHandler = new EventHandler(handlerType, eventType, handleMethod.Value, GetHandlerFactory(handlerType, serviceProvider));
if (sagaMetadata != null)
eventHandler = eventType == typeof(Timeout) ? new SagaTimeoutHandler(eventHandler, sagaMetadata, sagaStore, commandPublisher) : new SagaEventHandler(eventHandler, sagaMetadata, sagaStore, commandPublisher);
eventHandlers.Add(eventHandler);
}
}
return knownEventHandlers;
}
public void ReturnFriendlyDescription()
{
var eventHandler = new EventHandler(typeof(Object), typeof(FakeEvent), (h, e) => { }, () => new Object());
Assert.Equal($"{typeof (FakeEvent)} Event Handler ({typeof (Object)})", eventHandler.ToString());
}
public void ContextCannotBeNull()
{
var eventHandler = new EventHandler(typeof(Object), typeof(FakeEvent), (h, e) => { }, () => new Object());
Assert.Throws <ArgumentNullException>(() => eventHandler.Handle(null));
}
