public void Arrange()
        {
            var fixture = new Fixture();

            _accountLegalEntityId       = fixture.Create <long>();
            _accountLegalEntityResponse = fixture.Create <AccountLegalEntityResponse>();

            _mockCommitmentsApiClient = new Mock <ICommitmentsApiClient>();
            _mockCommitmentsApiClient.Setup(x => x.GetAccountLegalEntity(_accountLegalEntityId, It.IsAny <CancellationToken>()))
            .ReturnsAsync(_accountLegalEntityResponse);

            var birthDate = fixture.Create <DateTime?>();
            var startDate = fixture.Create <DateTime?>();
            var endDate   = fixture.Create <DateTime?>();
            var accountLegalEntityPublicHashedId = fixture.Create <string>();

            _mapper = new CreateCohortRequestMapper(_mockCommitmentsApiClient.Object);

            _source = fixture.Build <AddDraftApprenticeshipViewModel>()
                      .With(x => x.EmployerAccountLegalEntityPublicHashedId, accountLegalEntityPublicHashedId)
                      .With(x => x.AccountLegalEntityId, _accountLegalEntityId)
                      .With(x => x.BirthDay, birthDate?.Day)
                      .With(x => x.BirthMonth, birthDate?.Month)
                      .With(x => x.BirthYear, birthDate?.Year)
                      .With(x => x.EndMonth, endDate?.Month)
                      .With(x => x.EndYear, endDate?.Year)
                      .With(x => x.StartMonth, startDate?.Month)
                      .With(x => x.StartYear, startDate?.Year)
                      .Without(x => x.StartDate)
                      .Without(x => x.Courses)
                      .Create();

            _act = () => _mapper.Map(TestHelper.Clone(_source));
        }
        public DetailsViewModelMapperTestsFixture()
        {
            _autoFixture = new Fixture();

            Cohort = _autoFixture.Build <GetCohortResponse>().Without(x => x.TransferSenderId).Without(x => x.ChangeOfPartyRequestId).Create();
            AccountLegalEntityResponse = _autoFixture.Create <AccountLegalEntityResponse>();
            LegalEntityViewModel       = _autoFixture.Create <LegalEntityViewModel>();

            var draftApprenticeships = CreateDraftApprenticeshipDtos(_autoFixture);

            _autoFixture.Register(() => draftApprenticeships);
            DraftApprenticeshipsResponse = _autoFixture.Create <GetDraftApprenticeshipsResponse>();

            CommitmentsApiClient = new Mock <ICommitmentsApiClient>();
            CommitmentsApiClient.Setup(x => x.GetCohort(It.IsAny <long>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(Cohort);
            CommitmentsApiClient.Setup(x => x.GetDraftApprenticeships(It.IsAny <long>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(DraftApprenticeshipsResponse);
            CommitmentsApiClient.Setup(x => x.GetAccountLegalEntity(It.IsAny <long>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(AccountLegalEntityResponse);

            AccountApiClient = new Mock <IAccountApiClient>();
            AccountApiClient.Setup(x => x.GetLegalEntity(It.IsAny <string>(), It.IsAny <long>())).ReturnsAsync(LegalEntityViewModel);

            _fundingPeriods = new List <TrainingProgrammeFundingPeriod>
            {
                new TrainingProgrammeFundingPeriod {
                    EffectiveFrom = _startFundingPeriod, EffectiveTo = _endFundingPeriod, FundingCap = 1000
                },
                new TrainingProgrammeFundingPeriod {
                    EffectiveFrom = _startFundingPeriod.AddMonths(1), EffectiveTo = _endFundingPeriod.AddMonths(1), FundingCap = 500
                }
            };
            _trainingProgramme = new TrainingProgramme {
                EffectiveFrom = DefaultStartDate, EffectiveTo = DefaultStartDate.AddYears(1), FundingPeriods = _fundingPeriods
            };

            CommitmentsApiClient.Setup(x => x.GetTrainingProgramme(It.Is <string>(c => !string.IsNullOrEmpty(c)), CancellationToken.None))
            .ReturnsAsync(new GetTrainingProgrammeResponse {
                TrainingProgramme = _trainingProgramme
            });
            CommitmentsApiClient.Setup(x => x.GetTrainingProgramme("no-course", CancellationToken.None))
            .ThrowsAsync(new RestHttpClientException(new HttpResponseMessage(HttpStatusCode.NotFound)
            {
                RequestMessage = new HttpRequestMessage(),
                ReasonPhrase   = "Url not found"
            }, "Course not found"));

            EncodingService = new Mock <IEncodingService>();
            SetEncodingOfApprenticeIds();

            Mapper = new DetailsViewModelMapper(CommitmentsApiClient.Object, EncodingService.Object, AccountApiClient.Object);
            Source = _autoFixture.Create <DetailsRequest>();
        }
Пример #3
0
        public void Setup()
        {
            var autoFixture = new Fixture();

            _request = autoFixture.Create <SelectProviderRequest>();
            _commitmentsApiClientResponse = autoFixture.Create <AccountLegalEntityResponse>();

            _commitmentsApiClientMock = new Mock <ICommitmentsApiClient>();
            _commitmentsApiClientMock
            .Setup(x => x.GetAccountLegalEntity(_request.AccountLegalEntityId, CancellationToken.None))
            .ReturnsAsync(_commitmentsApiClientResponse);

            _mapper = new SelectProviderViewModelMapper(_commitmentsApiClientMock.Object);
        }
Пример #4
0
        public void Arrange()
        {
            var fixture = new Fixture();

            _commitmentApiClient        = new Mock <ICommitmentsApiClient>();
            _accountlegalEntityResponse = fixture.Create <AccountLegalEntityResponse>();

            _source = fixture.Create <ConfirmEmployerViewModel>();
            _commitmentApiClient.Setup(x => x.GetAccountLegalEntity(It.IsAny <long>(), It.IsAny <CancellationToken>())).ReturnsAsync(_accountlegalEntityResponse);

            _mapper = new ConfirmEmployerViewModelToCreateEmptyCohortRequestMapper(_commitmentApiClient.Object);

            _act = async() => await _mapper.Map(_source);
        }
        public async Task Then_Maps_LegalEntityName(
            [Frozen] AssignRequest request,
            [Frozen] AccountLegalEntityResponse response,
            [Frozen] Mock <ICommitmentsApiClient> commitmentsApiClientMock,
            AssignViewModelMapper mapper)
        {
            commitmentsApiClientMock
            .Setup(x => x.GetAccountLegalEntity(request.AccountLegalEntityId, default))
            .ReturnsAsync(response);

            var viewModel = await mapper.Map(request);

            viewModel.LegalEntityName.Should().Be(response.LegalEntityName);
        }
        public EmployerAgreementServiceTestsFixture()
        {
            LegalEntityViewModel            = new LegalEntityViewModel();
            LegalEntityViewModel.Agreements = new List <AgreementViewModel>();

            AccountLegalEntityResponse = new AccountLegalEntityResponse();
            AccountLegalEntityResponse.MaLegalEntityId = MaLegalEntityId;

            EncodingService = new Mock <IEncodingService>();
            EncodingService.Setup(x => x.Encode(It.IsAny <long>(), EncodingType.AccountId)).Returns((long x, EncodingType t) => $"X{x}X");

            AccountApiClient = new Mock <IAccountApiClient>();
            AccountApiClient.Setup(x => x.GetLegalEntity(It.IsAny <string>(), It.IsAny <long>())).ReturnsAsync(LegalEntityViewModel);


            Sut = new EmployerAgreementService(AccountApiClient.Object, EncodingService.Object, Mock.Of <ILogger <EmployerAgreementService> >());
        }
Пример #7
0
        public async Task Arrange()
        {
            var autoFixture = new Fixture();

            _course                     = autoFixture.Create <TrainingProgramme>();
            _courseStandard             = autoFixture.Create <TrainingProgramme>();
            _providerResponse           = autoFixture.Create <GetProviderResponse>();
            _accountLegalEntityResponse = autoFixture.Build <AccountLegalEntityResponse>().With(x => x.LevyStatus, ApprenticeshipEmployerType.Levy).Create();
            _source                     = autoFixture.Create <ApprenticeRequest>();
            _source.StartMonthYear      = "062020";
            _source.TransferSenderId    = string.Empty;
            _source.AccountId           = 12345;

            _commitmentsApiClient = new Mock <ICommitmentsApiClient>();
            _commitmentsApiClient.Setup(x => x.GetProvider(It.IsAny <long>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(_providerResponse);
            _commitmentsApiClient.Setup(x => x.GetAccountLegalEntity(_source.AccountLegalEntityId, It.IsAny <CancellationToken>()))
            .ReturnsAsync(_accountLegalEntityResponse);
            _standardTrainingProgrammes = new List <TrainingProgramme> {
                _courseStandard
            };
            _commitmentsApiClient
            .Setup(x => x.GetAllTrainingProgrammeStandards(It.IsAny <CancellationToken>()))
            .ReturnsAsync(new GetAllTrainingProgrammeStandardsResponse
            {
                TrainingProgrammes = _standardTrainingProgrammes
            });
            _allTrainingProgrammes = new List <TrainingProgramme> {
                _courseStandard, _course
            };
            _commitmentsApiClient
            .Setup(x => x.GetAllTrainingProgrammes(It.IsAny <CancellationToken>()))
            .ReturnsAsync(new GetAllTrainingProgrammesResponse
            {
                TrainingProgrammes = _allTrainingProgrammes
            });


            _mapper = new ApprenticeViewModelMapper(
                _commitmentsApiClient.Object);

            _result = await _mapper.Map(TestHelper.Clone(_source));
        }
Пример #8
0
        public void Arrange()
        {
            var fixture = new Fixture();

            _source = fixture.Build <CreateCohortWithDraftApprenticeshipRequest>().With(x => x.StartMonthYear, "042020").Create();
            _accountLegalEntityResponse = fixture.Create <AccountLegalEntityResponse>();

            _trainingCoursesQueryResponse = fixture.Create <GetTrainingCoursesQueryResponse>();

            _commitmentsApiClient = new Mock <ICommitmentsApiClient>();
            _commitmentsApiClient.Setup(x => x.GetAccountLegalEntity(_source.AccountLegalEntityId, It.IsAny <CancellationToken>()))
            .ReturnsAsync(_accountLegalEntityResponse);

            _mediator = new Mock <IMediator>();
            _mediator.Setup(x => x.Send(It.IsAny <GetTrainingCoursesQueryRequest>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(_trainingCoursesQueryResponse);

            _mapper = new AddDraftApprenticeshipViewModelMapper(_commitmentsApiClient.Object, _mediator.Object);
        }
Пример #9
0
        public EndDateViewModelMapperFixture()
        {
            Request = new EndDateRequest
            {
                AccountLegalEntityId   = 143,
                ApprenticeshipHashedId = "SF45G54",
                ApprenticeshipId       = 234,
                ProviderId             = 645621,
                EmployerAccountLegalEntityPublicHashedId = "GD35SD35",
                StartDate = "122019"
            };

            AccountLegalEntityResponse = new AccountLegalEntityResponse {
                LegalEntityName = "TestName"
            };
            _commitmentsApiClientMock = new Mock <ICommitmentsApiClient>();

            _commitmentsApiClientMock
            .Setup(x => x.GetAccountLegalEntity(Request.AccountLegalEntityId, default(CancellationToken)))
            .ReturnsAsync(AccountLegalEntityResponse);

            _sut = new EndDateViewModelMapper(_commitmentsApiClientMock.Object);
        }