public async Task DispatcherShouldRegisterPipelineForMultipleEventsAsync()
{
var actWrapper = ActWrapper <Event> .From(nopAct);
var eventTypes = new List <Type> {
typeof(Event1), typeof(Event2)
};
var acts = new ActList {
actWrapper.Act
};
dispatcher.RegisterPipeline(eventTypes, acts);
Event1 event1 = new Event1 {
Property = "event1"
};
dispatcher.Dispatch(event1);
await actWrapper.ActTask;
(actWrapper.Event as Event1).Property.ShouldBeEquivalentTo(event1.Property);
actWrapper.Rearm();
Event2 event2 = new Event2 {
Property = "event2"
};
dispatcher.Dispatch(event2);
await actWrapper.ActTask;
(actWrapper.Event as Event2).Property.ShouldBeEquivalentTo(event2.Property);
}
public async Task DispatcherShouldRegisterMultiplePipelinesPerEventAsync()
{
var actWrapperForPipe1 = ActWrapper <Event> .From(nopAct);
var actWrapperForPipe2 = ActWrapper <Event> .From(nopAct);
var eventTypes = new List <Type> {
typeof(Event1)
};
var actsForPipe1 = new ActList {
actWrapperForPipe1.Act
};
var actsForPipe2 = new ActList {
actWrapperForPipe2.Act
};
dispatcher.RegisterPipeline(eventTypes, actsForPipe1);
dispatcher.RegisterPipeline(eventTypes, actsForPipe2);
dispatcher.Dispatch(new Event1());
await Task.WhenAll(new Task[] { actWrapperForPipe1.ActTask, actWrapperForPipe2.ActTask });
actWrapperForPipe1.HasBeenCalled.Should().BeTrue();
actWrapperForPipe2.HasBeenCalled.Should().BeTrue();
}
public async Task DispatcherShoulDispatchWithReconciliation()
{
var resolvedEvent = new ReconciliationEvent {
Id = Guid.NewGuid()
};
var actWrapper = ActWrapper <Event>
.From((e, context) =>
{
resolvedEvent.ReconciliationId = (e as ReconciliationEvent).ReconciliationId;
context.ReconciliationService.ResolveTask(resolvedEvent);
});
var eventTypes = new List <Type> {
typeof(TestReconciliationEvent)
};
var acts = new ActList {
actWrapper.Act
};
dispatcher.RegisterPipeline(eventTypes, acts);
var originalEvent = new TestReconciliationEvent();
var reconciliationEvent = await dispatcher.DispatchWithReconciliation(originalEvent);
reconciliationEvent.ShouldBeEquivalentTo(resolvedEvent);
}
public static ActWrapper <TEvent> From(Act <TEvent> act)
{
var actWrapper = new ActWrapper <TEvent>();
actWrapper.HasBeenCalled = false;
actWrapper.ActTask = new Task(() => {});
actWrapper.Act = (e, context) =>
{
actWrapper.Event = e;
actWrapper.PipelineContext = context;
actWrapper.HasBeenCalled = true;
act(e, context);
actWrapper.ActTask.RunSynchronously();
};
return(actWrapper);
}
public async Task DispatcherShouldDispatchEventToPipelineAsync()
{
var actWrapper = ActWrapper <Event> .From(nopAct);
var actions = new ActList {
actWrapper.Act
};
var eventTypes = new List <Type>
{
typeof(Event1)
};
dispatcher.RegisterPipeline(eventTypes, actions);
dispatcher.Dispatch(new Event1());
await actWrapper.ActTask;
actWrapper.HasBeenCalled.Should().BeTrue();
}
public void Initialize()
{
dispatcherMock = new Mock <IDispatcher>(MockBehavior.Strict);
reconciliationServiceMock = new Mock <IReconciliationService>(MockBehavior.Strict);
eventStoreMock = new Mock <IEventStore>(MockBehavior.Strict);
actWrapper = ActWrapper <Event> .From(nopAct);
pipeline = new Pipeline(
new List <Type> {
typeof(Event)
},
new ActList {
actWrapper.Act
},
dispatcherMock.Object,
reconciliationServiceMock.Object,
eventStoreMock.Object
);
}
public async Task DispatcherShouldSaveEventAsync()
{
var actWrapper = ActWrapper <Event> .From(nopAct);
var eventTypes = new List <Type> {
typeof(Event1)
};
var acts = new ActList {
actWrapper.Act
};
dispatcher.RegisterPipeline(eventTypes, acts);
var originalEvent = new Event1();
dispatcher.Dispatch(originalEvent);
await actWrapper.ActTask;
var savedEvent = await eventStore.Get <Event1>(actWrapper.Event.Id);
savedEvent.Should().NotBeNull();
}
