public void WhenIRunMultipleEventsOnTheEventPlayerTheyAreEvaluated()
{
var evaluator1 = Substitute.For <IEventEvaluator <IView, IEventData> >();
var evaluator2 = Substitute.For <IEventEvaluator <IView, IEventData> >();
var evaluator3 = Substitute.For <IEventEvaluator <IView, IEventData> >();
var eventData1 = Substitute.For <IEventData>();
var eventData2 = Substitute.For <IEventData>();
var eventData3 = Substitute.For <IEventData>();
var events = new[]
{
CreateEvent(Guid.NewGuid().ToString()),
CreateEvent(Guid.NewGuid().ToString()),
CreateEvent(Guid.NewGuid().ToString()),
};
_eventDataDeserializationService.Deserialize(typeof(IEventData), events[0].EventData).Returns(eventData1);
_eventDataDeserializationService.Deserialize(typeof(IEventData), events[1].EventData).Returns(eventData2);
_eventDataDeserializationService.Deserialize(typeof(IEventData), events[2].EventData).Returns(eventData3);
_eventEvaluatorRegistry.Filter <IView>(events[0].EventType).Returns(new IEventEvaluator[] { evaluator1 });
_eventEvaluatorRegistry.Filter <IView>(events[1].EventType).Returns(new IEventEvaluator[] { evaluator2 });
_eventEvaluatorRegistry.Filter <IView>(events[2].EventType).Returns(new IEventEvaluator[] { evaluator3 });
var view = Substitute.For <IView>();
_target.Play(events, view);
evaluator1.Received().Evaluate(view, events[0], eventData1);
evaluator2.Received().Evaluate(view, events[1], eventData2);
evaluator3.Received().Evaluate(view, events[2], eventData3);
}
public void WhenIUndoEventsTheyAreUndone(IEventDataDeserializationService eventDataDeserializationService)
{
var target = new UndoEventProcessingService(eventDataDeserializationService);
var eventDataSerialized = Guid.NewGuid().ToString();
var fixture = new Fixture().Customize(new AutoConfiguredNSubstituteCustomization());
fixture.Register(() => false);
var events = fixture.CreateMany <IEvent>(4).OrderBy(t => t.EffectiveDateTime).ToList();
var undoEvent = Substitute.For <IEvent>();
var eventData = new UndoData(events.Select(t => t.EventId).ToList());
var latestEvent = events.Max(t => t.EffectiveDateTime).AddSeconds(1);
var expectedToBeUndone = new List <IEvent>();
expectedToBeUndone.AddRange(events);
undoEvent.EventType.Name.Returns("Undo");
undoEvent.EventData.Returns(eventDataSerialized);
undoEvent.EffectiveDateTime.Returns(latestEvent);
events.Add(undoEvent);
eventDataDeserializationService.Deserialize(typeof(UndoData), eventDataSerialized).Returns(eventData);
target.Execute(events);
Assert.All(expectedToBeUndone, @event => @event.Received().Undone = true);
}
private void EvaluateEvent <TView>(IEventEvaluator eventEvaluator, TView view, IEvent @event)
where TView : class, IView
{
var eventDataTypes = eventEvaluator
.GetType()
.GetInterfaces()
.Where(t => t.IsGenericType &&
t.GetGenericTypeDefinition() == typeof(IEventEvaluator <,>) &&
t.GetGenericArguments()[0] == typeof(TView))
.Select(t => t.GetGenericArguments()[1]).ToArray();
foreach (var eventDataType in eventDataTypes)
{
var eventData = _eventDataDeserializationService.Deserialize(eventDataType, @event.EventData);
((dynamic)eventEvaluator).Evaluate(view, @event, (dynamic)eventData);
}
}
public IEnumerable <IEvent> Execute(IEnumerable <IEvent> events)
{
//TODO: Should the repository do this to be efficant
var orderedEvents = events.OrderByDescending(@event => @event.EffectiveDateTime);
var eventIdToUndo = new List <Guid>();
orderedEvents.ForEach(@event =>
{
if (eventIdToUndo.Contains(@event.EventId))
{
@event.Undone = true;
return;
}
if (@event.EventType.Name == "Undo")
{
eventIdToUndo.AddRange(((UndoData)_eventDataDeserializationService.Deserialize(typeof(UndoData), @event.EventData)).EventIds);
}
});
return(orderedEvents.Reverse());
}
