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);
            }
        }
Example #2
0
 public EventPlayerUnitTests()
 {
     _eventEvaluatorRegistry          = Substitute.For <IEventEvaluatorRegistry>();
     _eventDataDeserializationService = Substitute.For <IEventDataDeserializationService>();
     _target = new EventPlayer(_eventEvaluatorRegistry, _eventDataDeserializationService);
 }
 public EventPlayer(IEventEvaluatorRegistry eventEvaluatorRegistry,
                    IEventDataDeserializationService eventDataDeserializationService)
 {
     _eventEvaluatorRegistry          = eventEvaluatorRegistry;
     _eventDataDeserializationService = eventDataDeserializationService;
 }