Пример #1
0
        public void HasAnyLearningDeliveryFAMCodesForType_False_Mismatch()
        {
            var learningDeliveryFAMs = new TestLearningDeliveryFAM[]
            {
                new TestLearningDeliveryFAM()
                {
                    LearnDelFAMType = "TypeOne", LearnDelFAMCode = "CodeOne"
                },
                new TestLearningDeliveryFAM()
                {
                    LearnDelFAMType = "TypeTwo", LearnDelFAMCode = "CodeTwo"
                },
                new TestLearningDeliveryFAM()
                {
                    LearnDelFAMType = "TypeTwo", LearnDelFAMCode = "CodeThree"
                },
            };

            var codes = new string[] { "CodeTwo", "CodeThree" };

            var queryService = new LearningDeliveryFAMQueryService();

            queryService.HasAnyLearningDeliveryFAMCodesForType(learningDeliveryFAMs, "TypeOne", codes).Should().BeFalse();
        }
Пример #2
0
        public void LearnDelFAMCodeConditionMet_False(string fAMType, string fAMCode, string dateFrom, string dateTo)
        {
            string   learnDelFAMType;
            string   learnDelFAMCode;
            DateTime?learnDelDateFrom = string.IsNullOrEmpty(dateFrom) ? (DateTime?)null : DateTime.Parse(dateFrom);
            DateTime?learnDelDateTo   = string.IsNullOrEmpty(dateTo) ? (DateTime?)null : DateTime.Parse(dateTo);

            var learningDeliveryFAMs = new TestLearningDeliveryFAM[]
            {
                new TestLearningDeliveryFAM()
                {
                    LearnDelFAMType             = LearningDeliveryFAMTypeConstants.ACT,
                    LearnDelFAMDateFromNullable = new DateTime(2017, 09, 01),
                    LearnDelFAMDateToNullable   = new DateTime(2017, 12, 31),
                    LearnDelFAMCode             = "1"
                },
                new TestLearningDeliveryFAM()
                {
                    LearnDelFAMType             = fAMType,
                    LearnDelFAMDateFromNullable = learnDelDateFrom,
                    LearnDelFAMDateToNullable   = learnDelDateTo,
                    LearnDelFAMCode             = fAMCode
                },
                new TestLearningDeliveryFAM()
                {
                    LearnDelFAMType             = LearningDeliveryFAMTypeConstants.ACT,
                    LearnDelFAMDateFromNullable = new DateTime(2018, 08, 01),
                    LearnDelFAMDateToNullable   = new DateTime(2018, 12, 01),
                    LearnDelFAMCode             = "1"
                }
            };

            NewRule().LearnDelFAMCodeConditionMet(learningDeliveryFAMs, out learnDelFAMType, out learnDelFAMCode).Should().BeFalse();
            learnDelFAMType.Should().BeEmpty();
            learnDelFAMCode.Should().BeEmpty();
        }
        public void ConditionMet_False_LearnDelFAMDateToNotReturned()
        {
            var fAMDateTo   = new DateTime(2019, 08, 15);
            var fAMDateFrom = new DateTime(2019, 07, 15);
            var achDate     = fAMDateTo; // achDate is equal to famDateTo

            var learningDeliveryFAMs = new TestLearningDeliveryFAM[]
            {
                new TestLearningDeliveryFAM()
                {
                    LearnDelFAMType = "ACT", LearnDelFAMCode = "01", LearnDelFAMDateToNullable = null, LearnDelFAMDateFromNullable = fAMDateFrom
                },
            };

            var learningDelivery = new TestLearningDelivery
            {
                LearnAimRef          = "00100325",
                AimSeqNumber         = 1,
                AchDateNullable      = achDate,
                FundModel            = 36,
                ProgTypeNullable     = 25,
                LearningDeliveryFAMs = learningDeliveryFAMs,
                CompStatus           = 1
            };

            var mockFamQueryService = new Mock <ILearningDeliveryFAMQueryService>();

            mockFamQueryService.Setup(x => x.HasLearningDeliveryFAMType(learningDeliveryFAMs, "ACT"))
            .Returns(true);

            var result = NewRule(mockFamQueryService.Object, null).ConditionMet(learningDelivery);

            result.Should().BeFalse();

            mockFamQueryService.Verify(x => x.HasLearningDeliveryFAMType(learningDeliveryFAMs, "ACT"), Times.Exactly(1));
        }
Пример #4
0
        public void Validate_Error_MultipleDelivieries()
        {
            var learningDeliveryFamOne = new TestLearningDeliveryFAM
            {
                LearnDelFAMType             = "LSF",
                LearnDelFAMDateFromNullable = new DateTime(2018, 8, 1),
                LearnDelFAMDateToNullable   = new DateTime(2018, 8, 31)
            };

            var learningDeliveryFamTwo = new TestLearningDeliveryFAM
            {
                LearnDelFAMType             = "LSF",
                LearnDelFAMDateFromNullable = new DateTime(2018, 9, 1),
                LearnDelFAMDateToNullable   = new DateTime(2018, 9, 2)
            };

            var learningDeliveryFamThree = new TestLearningDeliveryFAM
            {
                LearnDelFAMType             = "LSF",
                LearnDelFAMDateFromNullable = new DateTime(2018, 9, 2),
            };

            var learningDeliveryFAMs = new List <TestLearningDeliveryFAM>
            {
                learningDeliveryFamOne,
                learningDeliveryFamTwo,
                learningDeliveryFamThree
            };

            var learner = new TestLearner()
            {
                LearnRefNumber     = "00100309",
                LearningDeliveries = new TestLearningDelivery[]
                {
                    new TestLearningDelivery()
                    {
                        AimSeqNumber         = 1,
                        LearningDeliveryFAMs = learningDeliveryFAMs
                    },
                    new TestLearningDelivery()
                    {
                        AimSeqNumber         = 2,
                        AimType              = 5,
                        LearnStartDate       = new DateTime(2018, 9, 1),
                        LearningDeliveryFAMs = learningDeliveryFAMs
                    }
                }
            };

            var learningDeliveryFAMQueryServiceMock = new Mock <ILearningDeliveryFAMQueryService>();

            learningDeliveryFAMQueryServiceMock
            .Setup(qs => qs.GetOverLappingLearningDeliveryFAMsForType(learningDeliveryFAMs, _famTypeLSF))
            .Returns(new List <TestLearningDeliveryFAM> {
                learningDeliveryFamThree
            });

            using (var validationErrorHandlerMock = BuildValidationErrorHandlerMockForError())
            {
                NewRule(learningDeliveryFAMQueryServiceMock.Object, validationErrorHandlerMock.Object).Validate(learner);
                validationErrorHandlerMock.Verify(h => h.BuildErrorMessageParameter(It.IsAny <string>(), It.IsAny <object>()), Times.Exactly(6));
            }
        }
        public void Validate_NoError()
        {
            var learningDeliveryFamOne = new TestLearningDeliveryFAM
            {
                LearnDelFAMType             = "LSF",
                LearnDelFAMDateFromNullable = new DateTime(2018, 8, 1),
                LearnDelFAMDateToNullable   = new DateTime(2018, 8, 31)
            };

            var learningDeliveryFamTwo = new TestLearningDeliveryFAM
            {
                LearnDelFAMType             = "LSF",
                LearnDelFAMDateFromNullable = new DateTime(2018, 9, 1),
                LearnDelFAMDateToNullable   = new DateTime(2018, 9, 2)
            };

            var learningDeliveryFamThree = new TestLearningDeliveryFAM
            {
                LearnDelFAMType             = "LSF",
                LearnDelFAMDateFromNullable = new DateTime(2018, 9, 3),
            };

            var learningDeliveryFAMsOne = new List <TestLearningDeliveryFAM>
            {
                learningDeliveryFamOne,
                learningDeliveryFamTwo
            };

            var learningDeliveryFAMsTwo = new List <TestLearningDeliveryFAM>
            {
                learningDeliveryFamThree
            };

            var learner = new TestLearner()
            {
                LearnRefNumber     = "00100309",
                LearningDeliveries = new TestLearningDelivery[]
                {
                    new TestLearningDelivery()
                    {
                        AimSeqNumber         = 1,
                        LearningDeliveryFAMs = learningDeliveryFAMsOne
                    },
                    new TestLearningDelivery()
                    {
                        AimSeqNumber         = 2,
                        AimType              = 5,
                        LearningDeliveryFAMs = learningDeliveryFAMsTwo
                    }
                }
            };

            var learningDeliveryFAMQueryServiceMock = new Mock <ILearningDeliveryFAMQueryService>();

            learningDeliveryFAMQueryServiceMock
            .Setup(qs => qs.GetOverLappingLearningDeliveryFAMsForType(It.IsAny <IEnumerable <TestLearningDeliveryFAM> >(), "LSF"))
            .Returns(new List <TestLearningDeliveryFAM>());

            using (var validationErrorHandlerMock = BuildValidationErrorHandlerMockForNoError())
            {
                NewRule(learningDeliveryFAMQueryServiceMock.Object, validationErrorHandlerMock.Object).Validate(learner);
            }
        }
        public void Validate_Error()
        {
            var testLearningDeliveryFAMs = new TestLearningDeliveryFAM[]
            {
                new TestLearningDeliveryFAM()
                {
                    LearnDelFAMType             = LearningDeliveryFAMTypeConstants.ACT,
                    LearnDelFAMDateFromNullable = new DateTime(0001, 01, 01),
                    LearnDelFAMDateToNullable   = new DateTime(2018, 10, 08),
                    LearnDelFAMCode             = "1"
                },
                new TestLearningDeliveryFAM()
                {
                    LearnDelFAMType             = LearningDeliveryFAMTypeConstants.ACT,
                    LearnDelFAMDateFromNullable = new DateTime(2018, 08, 01),
                    LearnDelFAMDateToNullable   = new DateTime(2018, 12, 08),
                    LearnDelFAMCode             = "1"
                },
                new TestLearningDeliveryFAM()
                {
                    LearnDelFAMType             = LearningDeliveryFAMTypeConstants.ACT,
                    LearnDelFAMDateFromNullable = null,
                    LearnDelFAMDateToNullable   = new DateTime(2018, 12, 08),
                    LearnDelFAMCode             = "1"
                },
                new TestLearningDeliveryFAM()
                {
                    LearnDelFAMType           = LearningDeliveryFAMTypeConstants.ACT,
                    LearnDelFAMDateToNullable = new DateTime(2018, 12, 08),
                    LearnDelFAMCode           = "1"
                }
            };
            var testLearner = new TestLearner()
            {
                LearningDeliveries = new TestLearningDelivery[]
                {
                    new TestLearningDelivery()
                    {
                        LearnActEndDateNullable = null,
                        LearningDeliveryFAMs    = testLearningDeliveryFAMs
                    },
                    new TestLearningDelivery()
                    {
                        LearnActEndDateNullable = null,
                        LearningDeliveryFAMs    = new TestLearningDeliveryFAM[]
                        {
                            new TestLearningDeliveryFAM()
                            {
                                LearnDelFAMType             = LearningDeliveryFAMTypeConstants.ACT,
                                LearnDelFAMDateFromNullable = new DateTime(2018, 11, 02),
                                LearnDelFAMDateToNullable   = new DateTime(2019, 01, 01),
                                LearnDelFAMCode             = "213"
                            }
                        }
                    }
                },
            };

            using (var validationErrorHandlerMock = BuildValidationErrorHandlerMockForError())
            {
                NewRule(validationErrorHandler: validationErrorHandlerMock.Object).Validate(testLearner);
            }
        }
        public void Validate_MultipleLearningDeliveriesACTDateToNull_Error()
        {
            var learningDeliveryFAMAim1 = new TestLearningDeliveryFAM()
            {
                LearnDelFAMType             = LearningDeliveryFAMTypeConstants.ACT,
                LearnDelFAMDateFromNullable = new DateTime(2017, 09, 06),
                LearnDelFAMDateToNullable   = new DateTime(2018, 09, 07)
            };

            var learningDeliveryFAMAim2 = new TestLearningDeliveryFAM()
            {
                LearnDelFAMType             = LearningDeliveryFAMTypeConstants.ACT,
                LearnDelFAMDateFromNullable = new DateTime(2018, 01, 10),
                LearnDelFAMDateToNullable   = null
            };

            var learningDeliveryFAMsOne = new List <ILearningDeliveryFAM>()
            {
                learningDeliveryFAMAim1
            };

            var learningDeliveryFAMsTwo = new List <ILearningDeliveryFAM>()
            {
                learningDeliveryFAMAim2
            };

            var learner = new TestLearner()
            {
                LearningDeliveries = new TestLearningDelivery[]
                {
                    new TestLearningDelivery()
                    {
                        LearnActEndDateNullable = new DateTime(2018, 09, 19),
                        LearningDeliveryFAMs    = learningDeliveryFAMsOne
                    },
                    new TestLearningDelivery()
                    {
                        LearnActEndDateNullable = new DateTime(2018, 09, 07),
                        LearningDeliveryFAMs    = learningDeliveryFAMsTwo
                    }
                }
            };

            var learningDeliveryFAMsQueryServiceMock = new Mock <ILearningDeliveryFAMQueryService>();

            learningDeliveryFAMsQueryServiceMock.Setup(fam => fam.GetLearningDeliveryFAMsForType(learningDeliveryFAMsOne, LearningDeliveryFAMTypeConstants.ACT))
            .Returns(learningDeliveryFAMsOne);
            learningDeliveryFAMsQueryServiceMock.Setup(fam => fam.HasLearningDeliveryFAMType(
                                                           learner.LearningDeliveries.ElementAt(0).LearningDeliveryFAMs, LearningDeliveryFAMTypeConstants.ACT))
            .Returns(true);

            learningDeliveryFAMsQueryServiceMock.Setup(fam => fam.GetLearningDeliveryFAMsForType(learningDeliveryFAMsTwo, LearningDeliveryFAMTypeConstants.ACT))
            .Returns(learningDeliveryFAMsTwo);
            learningDeliveryFAMsQueryServiceMock.Setup(fam => fam.HasLearningDeliveryFAMType(
                                                           learner.LearningDeliveries.ElementAt(1).LearningDeliveryFAMs, LearningDeliveryFAMTypeConstants.ACT))
            .Returns(true);

            using (var validationErrorHandlerMock = BuildValidationErrorHandlerMockForError())
            {
                NewRule(validationErrorHandler: validationErrorHandlerMock.Object, learningDeliveryFAMQueryService: learningDeliveryFAMsQueryServiceMock.Object).Validate(learner);
            }
        }