public void HasValidLearningAimWithNulEndDatesMeetsExpectation(string candidate, string previousYearEnd, bool expectation, params string[] startDates)
        {
            // arrange
            const string learnAimRef = "salddfkjeifdnase";

            var testDate     = DateTime.Parse(candidate);
            var mockDelivery = new Mock <ILearningDelivery>();

            mockDelivery
            .SetupGet(y => y.LearnAimRef)
            .Returns(learnAimRef);
            mockDelivery
            .SetupGet(y => y.LearnStartDate)
            .Returns(testDate);

            var handler = new Mock <IValidationErrorHandler>(MockBehavior.Strict);

            var category       = "larsCat";
            var larsValidities = Collection.Empty <ILARSLearningDeliveryValidity>();

            startDates.ForEach(sd =>
            {
                var mockValidity = new Mock <ILARSLearningDeliveryValidity>();
                mockValidity
                .SetupGet(x => x.ValidityCategory)
                .Returns(category);
                mockValidity
                .SetupGet(x => x.StartDate)
                .Returns(DateTime.Parse(sd));

                larsValidities.Add(mockValidity.Object);
            });

            var provider = new Mock <IProvideLearnAimRefRuleActions>(MockBehavior.Strict);

            var service = new Mock <ILARSDataService>(MockBehavior.Strict);

            service
            .Setup(x => x.GetValiditiesFor(learnAimRef))
            .Returns(larsValidities.AsSafeReadOnlyList());

            var yearData = new Mock <IAcademicYearDataService>(MockBehavior.Strict);

            yearData
            .Setup(x => x.GetAcademicYearOfLearningDate(testDate, AcademicYearDates.PreviousYearEnd))
            .Returns(DateTime.Parse(previousYearEnd));

            var sut = new LearnAimRef_89Rule(handler.Object, provider.Object, service.Object, yearData.Object);

            // act
            var result = sut.HasValidLearningAim(mockDelivery.Object, category);

            // assert
            handler.VerifyAll();
            provider.VerifyAll();
            service.VerifyAll();
            yearData.VerifyAll();

            Assert.Equal(expectation, result);
        }
        public void GetClosingDateOfLastAcademicYearMeetsExpectation(string candidate, string expectation)
        {
            // arrange
            var learnStart = DateTime.Parse(candidate);
            var testDate   = DateTime.Parse(expectation);

            var handler  = new Mock <IValidationErrorHandler>(MockBehavior.Strict);
            var provider = new Mock <IProvideLearnAimRefRuleActions>(MockBehavior.Strict);
            var service  = new Mock <ILARSDataService>(MockBehavior.Strict);
            var yearData = new Mock <IAcademicYearDataService>(MockBehavior.Strict);

            yearData
            .Setup(x => x.GetAcademicYearOfLearningDate(learnStart, AcademicYearDates.PreviousYearEnd))
            .Returns(testDate);

            var sut = new LearnAimRef_89Rule(handler.Object, provider.Object, service.Object, yearData.Object);

            var mockDelivery = new Mock <ILearningDelivery>();

            mockDelivery
            .SetupGet(y => y.LearnStartDate)
            .Returns(learnStart);

            // act, not interested in the result just that we hit a strict signature
            var result = sut.GetClosingDateOfLastAcademicYear(mockDelivery.Object);

            // assert
            handler.VerifyAll();
            provider.VerifyAll();
            service.VerifyAll();
            yearData.VerifyAll();

            Assert.Equal(testDate, result);
        }
        public void ValidItemDoesNotRaiseValidationMessage(string candidate, string previousYearEnd, string category, params string[] startDates)
        {
            // arrange
            const string learnRefNumber = "123456789X";
            const string learnAimRef    = "salddfkjeifdnase";

            var testDate     = DateTime.Parse(candidate);
            var mockDelivery = new Mock <ILearningDelivery>();

            mockDelivery
            .SetupGet(y => y.LearnAimRef)
            .Returns(learnAimRef);
            mockDelivery
            .SetupGet(y => y.LearnStartDate)
            .Returns(testDate);

            var deliveries = new ILearningDelivery[] { mockDelivery.Object };

            var mockLearner = new Mock <ILearner>();

            mockLearner
            .SetupGet(x => x.LearnRefNumber)
            .Returns(learnRefNumber);
            mockLearner
            .SetupGet(x => x.LearningDeliveries)
            .Returns(deliveries);

            var handler = new Mock <IValidationErrorHandler>(MockBehavior.Strict);

            var mockResult = new Mock <IBranchResult>();

            mockResult
            .SetupGet(x => x.OutOfScope)
            .Returns(false);
            mockResult
            .SetupGet(x => x.Category)
            .Returns(category);
            var provider = new Mock <IProvideLearnAimRefRuleActions>(MockBehavior.Strict);

            provider
            .Setup(x => x.GetBranchingResultFor(mockDelivery.Object, mockLearner.Object))
            .Returns(mockResult.Object);

            var larsValidities = Collection.Empty <ILARSLearningDeliveryValidity>();

            startDates.ForEach(sd =>
            {
                var mockValidity = new Mock <ILARSLearningDeliveryValidity>();
                mockValidity
                .SetupGet(x => x.ValidityCategory)
                .Returns(category);
                mockValidity
                .SetupGet(x => x.StartDate)
                .Returns(DateTime.Parse(sd));
                mockValidity
                .SetupGet(x => x.EndDate)
                .Returns(DateTime.Parse(sd));

                larsValidities.Add(mockValidity.Object);
            });

            var service = new Mock <ILARSDataService>(MockBehavior.Strict);

            service
            .Setup(x => x.GetValiditiesFor(learnAimRef))
            .Returns(larsValidities.AsSafeReadOnlyList());

            var yearData = new Mock <IAcademicYearDataService>(MockBehavior.Strict);

            yearData
            .Setup(x => x.GetAcademicYearOfLearningDate(testDate, AcademicYearDates.PreviousYearEnd))
            .Returns(DateTime.Parse(previousYearEnd));

            var sut = new LearnAimRef_89Rule(handler.Object, provider.Object, service.Object, yearData.Object);

            // act
            sut.Validate(mockLearner.Object);

            // assert
            handler.VerifyAll();
            provider.VerifyAll();
            service.VerifyAll();
            yearData.VerifyAll();
        }