public async Task Then_Handler_Returns_True_If_Allowed_To_Submit()
        {
            ApplyRepository.Setup(r => r.CanSubmitApplication(It.IsAny <Guid>())).ReturnsAsync(true);

            var request = new SubmitApplicationRequest
            {
                ApplicationId       = Guid.NewGuid(),
                SubmittingContactId = Guid.NewGuid(),
                ApplyData           = new ApplyData
                {
                    ApplyDetails = new ApplyDetails(),
                    Sequences    = new List <ApplySequence>
                    {
                        new ApplySequence
                        {
                            SequenceNo = 1,
                            Sections   = new List <ApplySection>
                            {
                                new ApplySection
                                {
                                    SectionNo = 1
                                }
                            }
                        }
                    }
                }
            };

            var result = await Handler.Handle(request, new CancellationToken());

            Assert.IsTrue(result);
            ApplyRepository.Verify(r => r.SubmitApplication(It.IsAny <Guid>(), It.IsAny <ApplyData>(), It.IsAny <FinancialData>(), It.IsAny <Guid>()), Times.Once);
        }
        public override void Arrange()
        {
            base.Arrange();

            // the QnAData is replaced for these tests
            ApplyRepository.Setup(r => r.GetSection(ApplicationId, 1, 1, UserId)).ReturnsAsync(new ApplicationSection()
            {
                Status  = ApplicationSectionStatus.Evaluated,
                QnAData = new QnAData()
                {
                    Pages = new List <Page>
                    {
                        new Page
                        {
                            PageId    = "1",
                            Questions = new List <Question>
                            {
                                new Question()
                                {
                                    QuestionId = "Q1",
                                    Input      = new Input {
                                        Type = "Text"
                                    }
                                }
                            },
                            PageOfAnswers = new List <PageOfAnswers>(),
                            Next          = new List <Next>()
                            {
                                new Next()
                                {
                                    Action = "NextPage", ReturnId = "2"
                                }
                            },
                            Feedback = new List <Feedback>()
                            {
                                new Feedback {
                                    IsNew = true, IsCompleted = true
                                }
                            }
                        },
                        new Page
                        {
                            PageId   = "2",
                            Feedback = new List <Feedback>()
                            {
                                new Feedback {
                                    IsNew = true, IsCompleted = true
                                }
                            }
                        }
                    }
                }
            });

            AnswerQ1.Value = "QuestionAnswer";

            Validator.Setup(v => v.Validate(It.Is <string>(p => p == QuestionIdQ1), It.Is <Answer>(p => p.QuestionId == AnswerQ1.QuestionId))).Returns(
                new List <KeyValuePair <string, string> >());
        }
        public async Task Then_Handler_Returns_False_If_Not_Allowed_To_Submit()
        {
            ApplyRepository.Setup(r => r.CanSubmitApplication(It.IsAny <Guid>())).ReturnsAsync(false);

            var request = new SubmitApplicationRequest {
                ApplicationId = Guid.NewGuid(), SubmittingContactId = Guid.NewGuid()
            };

            var result = await Handler.Handle(request, new CancellationToken());

            Assert.IsFalse(result);
            ApplyRepository.Verify(r => r.SubmitApplication(It.IsAny <Guid>(), It.IsAny <ApplyData>(), It.IsAny <FinancialData>(), It.IsAny <Guid>()), Times.Never);
        }
Exemple #4
0
        public void Then_validation_fail_if_application_is_not_still_in_draft()
        {
            AnswerQ1.Value     = "Yes";
            AnswerQ1Dot1.Value = "SomeAnswer";

            ApplyRepository.Setup(r => r.GetSection(ApplicationId, 1, 1, UserId)).ReturnsAsync(new ApplicationSection()
            {
                Status  = ApplicationSectionStatus.Evaluated,
                QnAData = QnAData
            });

            Validator.Setup(v => v.Validate(It.Is <string>(p => p == QuestionIdQ1), It.Is <Answer>(p => p.QuestionId == AnswerQ1.QuestionId)))
            .Returns
                ((string questionId, Answer answer) => !string.IsNullOrEmpty(answer.Value)
                    ? new List <KeyValuePair <string, string> >()
                    : new List <KeyValuePair <string, string> >()
            {
                new KeyValuePair <string, string>(questionId, $"{questionId} is required")
            });

            Validator.Setup(v => v.Validate(It.Is <string>(p => p == QuestionIdQ1Dot1), It.Is <Answer>(p => p.QuestionId == AnswerQ1Dot1.QuestionId)))
            .Returns
                ((string questionId, Answer answer) => !string.IsNullOrEmpty(answer.Value)
                    ? new List <KeyValuePair <string, string> >()
                    : new List <KeyValuePair <string, string> >()
            {
                new KeyValuePair <string, string>(questionId, $"{questionId} is required")
            });

            var result = Handler.Handle(new UpdatePageAnswersRequest(ApplicationId, UserId, 1, 1, "1",
                                                                     new List <Answer>()
            {
                AnswerQ1,
                AnswerQ1Dot1
            }, true), new CancellationToken()).Result;

            result.ValidationPassed.Should().BeFalse();
            result.ValidationErrors.Select(v => v.Key).Distinct().Should().ContainSingle(AnswerQ1.QuestionId);

            // Make sure it has verified the entirety of Question 1
            ValidatorFactory.Verify(v => v.Build(It.Is <Question>(question => question.QuestionId == AnswerQ1.QuestionId)));
            Validator.Verify(v => v.Validate(QuestionIdQ1, AnswerQ1));

            ValidatorFactory.Verify(v => v.Build(It.Is <Question>(question => question.QuestionId == AnswerQ1Dot1.QuestionId)));
            Validator.Verify(v => v.Validate(QuestionIdQ1Dot1, AnswerQ1Dot1));
        }
Exemple #5
0
        public async Task When_Versions_Has_One_Version_And_StandardReference_Set_Then_WithdrawalType_Should_Be_Version()
        {
            // Arrange

            ApplyRepository.Setup(m => m.GetWithdrawalApplications(It.IsAny <string>(), "New", "SubmittedDate", 0, 10, 1))
            .ReturnsAsync(new ApplicationsResult()
            {
                TotalCount    = 1,
                PageOfResults = new List <Domain.Entities.ApplicationListItem>()
                {
                    new Domain.Entities.ApplicationListItem()
                    {
                        StandardApplicationType = StandardApplicationTypes.VersionWithdrawal,
                        StandardReference       = "ST0205",
                        Versions = "[\"1.0\"]"
                    }
                }
            });

            // Act

            var paginatedList = await Handler.Handle(
                new WithdrawalApplicationsRequest(
                    new Guid().ToString(), // organisation id
                    "New",                 // reviewstatus
                    "SubmittedDate",       // sortcolumn
                    0,                     // sort ascending
                    10,                    // page size
                    1,                     // page index
                    6                      // page set size
                    ),
                new CancellationToken());

            // Assert

            paginatedList.Should().NotBeNull();
            paginatedList.Items.Should().HaveCount(1);
            paginatedList.Items[0].WithdrawalType.Should().Be(WithdrawalTypes.Version);
        }
        public async Task Then_FinancialData_Is_Persisted()
        {
            ApplyRepository.Setup(r => r.CanSubmitApplication(It.IsAny <Guid>())).ReturnsAsync(true);

            var request = new SubmitApplicationRequest
            {
                ApplicationId       = Guid.NewGuid(),
                SubmittingContactId = Guid.NewGuid(),
                ApplyData           = new ApplyData
                {
                    ApplyDetails = new ApplyDetails(),
                    Sequences    = new List <ApplySequence>
                    {
                        new ApplySequence
                        {
                            SequenceNo = 1,
                            Sections   = new List <ApplySection>
                            {
                                new ApplySection
                                {
                                    SectionNo = 1
                                }
                            }
                        }
                    }
                },
                FinancialData = new FinancialData
                {
                    TurnOver                    = 1,
                    Depreciation                = 2,
                    ProfitLoss                  = 3,
                    Dividends                   = 4,
                    IntangibleAssets            = 5,
                    Assets                      = 6,
                    Liabilities                 = 7,
                    ShareholderFunds            = 8,
                    Borrowings                  = 9,
                    AccountingReferenceDate     = new DateTime(2021, 1, 1),
                    AccountingPeriod            = 10,
                    AverageNumberofFTEEmployees = 11
                }
            };

            var result = await Handler.Handle(request, new CancellationToken());

            Assert.IsTrue(result);
            ApplyRepository.Verify(r => r.SubmitApplication(It.IsAny <Guid>(), It.IsAny <ApplyData>(), It.Is <FinancialData>(
                                                                x => x.TurnOver == 1 &&
                                                                x.Depreciation == 2 &&
                                                                x.ProfitLoss == 3 &&
                                                                x.Dividends == 4 &&
                                                                x.IntangibleAssets == 5 &&
                                                                x.Assets == 6 &&
                                                                x.Liabilities == 7 &&
                                                                x.ShareholderFunds == 8 &&
                                                                x.Borrowings == 9 &&
                                                                x.AccountingReferenceDate == new DateTime(2021, 1, 1) &&
                                                                x.AccountingPeriod == 10 &&
                                                                x.AverageNumberofFTEEmployees == 11
                                                                ), It.IsAny <Guid>()), Times.Once);
        }
 public void AdditionalSetup()
 {
     ApplyRepository.Setup(r => r.CanSubmitApplication(It.Is <Guid>(id => id == differentAppGuid))).ReturnsAsync(false);
     ApplyRepository.Setup(r => r.CanSubmitApplication(It.Is <Guid>(id => id == sameAppGuid))).ReturnsAsync(true);
 }