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 WhenIFilterEventEvaluatorsTheyAreFilteredCorrectly(
int matchingQuantity,
bool interfaceMatches,
bool nameMatches,
string minimumVersionCondition,
string maximumVersionCondition)
{
_eventEvaluatorAttributeService = Substitute.For <IEventEvaluatorAttributeService>();
_eventEvaluatorAttributeService.Get(Arg.Any <Type>())
.Returns(new EventValidityData()
{
EventName = Guid.NewGuid().ToString(),
MinimumVersion = new Version(0, 0),
MaximumVersion = null
});
var expectedEventName = Guid.NewGuid().ToString();
var expectedVersion = new Version(1, 2, 3, 4);
var eventType = Substitute.For <IEventType>();
eventType.Name.Returns(expectedEventName);
eventType.Version.Returns(expectedVersion);
var shouldMatch = interfaceMatches &&
nameMatches &&
(minimumVersionCondition == "EQ" || minimumVersionCondition == "LT") && // minimum version is {} than event version
(maximumVersionCondition == null || maximumVersionCondition == "GT" || maximumVersionCondition == "EQ"); // maximum version is {} than event version
_output.WriteLine(shouldMatch ? "Expecting to match" : "Expecting no matches");
var expectedEvaluators = new List <IEventEvaluator>();
var allEvaluators = new List <IEventEvaluator>();
for (var i = 1; i <= matchingQuantity; i++)
{
var expectedEvaluator = CreateEventEvaluatorSubstitute(interfaceMatches, nameMatches, minimumVersionCondition,
maximumVersionCondition, expectedEventName, expectedVersion);
expectedEvaluators.Add(expectedEvaluator);
allEvaluators.Add(expectedEvaluator);
}
allEvaluators.Add(Substitute.For <IEventEvaluator <SomeOtherView, IEventData> >());
_target = new EventEvaluatorRegistry(_eventEvaluatorAttributeService, allEvaluators.ToArray());
var matchingEvaluators = _target.Filter <TestView>(eventType);
if (!shouldMatch)
{
Assert.Empty(matchingEvaluators);
}
else
{
var actions = expectedEvaluators.Select <IEventEvaluator, Action <IEventEvaluator> >(q => (e => Assert.Same(q, e))).ToArray();
Assert.Collection(matchingEvaluators, actions);
}
}
public void Play <TView>(IEnumerable <IEvent> events, TView view)
where TView : class, IView
{
foreach (var @event in events)
{
var eventEvaluators = _eventEvaluatorRegistry.Filter <TView>(@event.EventType);
foreach (var eventEvaluator in eventEvaluators)
{
EvaluateEvent(eventEvaluator, view, @event);
}
}
}