public async Task WhenHandlingStartCertificateRequest_AndThereIsExistingCertificate_NotDeleted_UpdatesCertificateForNewGrade( StartCertificateRequest request, Organisation organisationRecord, Certificate existingCertificate, CertificateData certificateData, Standard standard, Provider provider, Domain.Entities.Learner learnerRecord) { // Arrange existingCertificate.Status = CertificateStatus.Submitted; certificateData.OverallGrade = CertificateGrade.Fail; existingCertificate.CertificateData = JsonConvert.SerializeObject(certificateData); _mockOrganisationQueryRepository.Setup(s => s.GetByUkPrn(request.UkPrn)).ReturnsAsync(organisationRecord); _mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync(existingCertificate); _mockStandardService.Setup(s => s.GetStandardVersionById(request.StandardUId, null)).ReturnsAsync(standard); _mockLearnerRepository.Setup(s => s.Get(request.Uln, request.StandardCode)).ReturnsAsync(learnerRecord); _mockProvidersRepository.Setup(s => s.GetProvider(learnerRecord.UkPrn)).ReturnsAsync(provider); Certificate updatedCertficate = null; _mockCertificateRepository.Setup(s => s.Update(It.IsAny <Certificate>(), It.IsAny <string>(), It.IsAny <string>(), true, null)) .Callback <Certificate, string, string, bool, string>((cert, username, action, updateLogs, reason) => { updatedCertficate = cert; }).ReturnsAsync(updatedCertficate); // Act var response = await _sut.Handle(request, new CancellationToken()); // Assertions updatedCertficate.Status.Should().Be(CertificateStatus.Draft); _mockCertificateRepository.Verify(s => s.Update(existingCertificate, request.Username, CertificateActions.Restart, true, null), Times.Once); }
public async Task WhenHandlingStartCertificateRequest_AndNoExistingCertificate_StandardUIdSet_CreatesNewCertificate_WithVersionDetails( StartCertificateRequest request, Domain.Entities.Learner learnerRecord, Organisation organisationRecord, Provider provider, Certificate stubCertificate, Standard standard) { // Arrange learnerRecord.FundingModel = 81; _mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync((Certificate)null); _mockLearnerRepository.Setup(s => s.Get(request.Uln, request.StandardCode)).ReturnsAsync(learnerRecord); _mockOrganisationQueryRepository.Setup(s => s.GetByUkPrn(request.UkPrn)).ReturnsAsync(organisationRecord); _mockProvidersRepository.Setup(s => s.GetProvider(learnerRecord.UkPrn)).ReturnsAsync(provider); _mockStandardService.Setup(s => s.GetStandardVersionById(request.StandardUId, null)).ReturnsAsync(standard); Certificate createdCertificate = null; _mockCertificateRepository.Setup(s => s.New(It.IsAny <Certificate>())).Callback <Certificate>((cert) => { createdCertificate = cert; }).ReturnsAsync(stubCertificate); // Act var response = await _sut.Handle(request, new CancellationToken()); // Assertions response.Should().BeEquivalentTo(stubCertificate); createdCertificate.Should().BeEquivalentTo(new { request.Uln, request.StandardCode, ProviderUkPrn = learnerRecord.UkPrn, OrganisationId = organisationRecord.Id, CreatedBy = request.Username, Status = CertificateStatus.Draft, CertificateReference = string.Empty, learnerRecord.LearnRefNumber, CreateDay = DateTime.UtcNow.Date, IsPrivatelyFunded = false, StandardUId = standard.StandardUId }); var certData = JsonConvert.DeserializeObject <CertificateData>(createdCertificate.CertificateData); certData.Should().BeEquivalentTo(new { LearnerGivenNames = learnerRecord.GivenNames, LearnerFamilyName = learnerRecord.FamilyName, LearningStartDate = learnerRecord.LearnStartDate, FullName = $"{learnerRecord.GivenNames} {learnerRecord.FamilyName}", ProviderName = provider.Name, StandardName = standard.Title, StandardReference = standard.IfateReferenceNumber, StandardLevel = standard.Level, StandardPublicationDate = standard.VersionApprovedForDelivery, Version = standard.Version, CourseOption = request.CourseOption }); }
public async Task WhenHandlingStartCertificateRequest_AndNoExistingCertificate_CreatesNewCertificate_WhenStandardUIdNotSet( StartCertificateRequest request, Domain.Entities.Learner learnerRecord, Organisation organisationRecord, Provider provider, Certificate stubCertificate, IEnumerable <Standard> standards) { // Arrange request.StandardUId = null; learnerRecord.FundingModel = 81; _mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync((Certificate)null); _mockLearnerRepository.Setup(s => s.Get(request.Uln, request.StandardCode)).ReturnsAsync(learnerRecord); _mockOrganisationQueryRepository.Setup(s => s.GetByUkPrn(request.UkPrn)).ReturnsAsync(organisationRecord); _mockProvidersRepository.Setup(s => s.GetProvider(learnerRecord.UkPrn)).ReturnsAsync(provider); _mockStandardService.Setup(s => s.GetStandardVersionsByLarsCode(learnerRecord.StdCode)).ReturnsAsync(standards); Certificate createdCertificate = null; _mockCertificateRepository.Setup(s => s.New(It.IsAny <Certificate>())).Callback <Certificate>((cert) => { createdCertificate = cert; }).ReturnsAsync(stubCertificate); // Act var response = await _sut.Handle(request, new CancellationToken()); // Assertions response.Should().BeEquivalentTo(stubCertificate); createdCertificate.Should().BeEquivalentTo(new { request.Uln, request.StandardCode, ProviderUkPrn = learnerRecord.UkPrn, OrganisationId = organisationRecord.Id, CreatedBy = request.Username, Status = CertificateStatus.Draft, CertificateReference = string.Empty, learnerRecord.LearnRefNumber, CreateDay = DateTime.UtcNow.Date, IsPrivatelyFunded = false }); var certData = JsonConvert.DeserializeObject <CertificateData>(createdCertificate.CertificateData); certData.Should().BeEquivalentTo(new { LearnerGivenNames = learnerRecord.GivenNames, LearnerFamilyName = learnerRecord.FamilyName, LearningStartDate = learnerRecord.LearnStartDate, FullName = $"{learnerRecord.GivenNames} {learnerRecord.FamilyName}", ProviderName = provider.Name, StandardName = standards.OrderByDescending(s => s.VersionMajor).ThenByDescending(t => t.VersionMinor).First().Title }); }
public void Arrange() { _request = Builder <GetBatchLearnerRequest> .CreateNew() .With(r => r.IncludeCertificate = true).Build(); _certificateData = Builder <CertificateData> .CreateNew().Build(); _learnerResponse = Builder <Domain.Entities.Learner> .CreateNew().Build(); _epaoResponse = Builder <Organisation> .CreateNew().Build(); _certificateResponse = Builder <Certificate> .CreateNew() .With(cr => cr.CertificateData = JsonConvert.SerializeObject(_certificateData)) .Build(); _standardResponse = Builder <Standard> .CreateNew().Build(); _mockMediator = new Mock <IMediator>(); _mockLearnerRepository = new Mock <ILearnerRepository>(); _mockOrgQueryRepository = new Mock <IOrganisationQueryRepository>(); _mockStandardService = new Mock <IStandardService>(); _mockCertificateRepoistory = new Mock <ICertificateRepository>(); _mockStandardService.Setup(ss => ss.GetStandardVersionById(_request.Standard, null)) .ReturnsAsync(_standardResponse); _mockLearnerRepository.Setup(learner => learner.Get(_request.Uln, It.IsAny <int>())) .ReturnsAsync(_learnerResponse); _mockOrgQueryRepository.Setup(org => org.GetByUkPrn(It.IsAny <long>())) .ReturnsAsync(_epaoResponse); _mockMediator.Setup(m => m.Send(It.IsAny <GetBatchCertificateRequest>(), It.IsAny <CancellationToken>())) .ReturnsAsync(_certificateResponse); _mockCertificateRepoistory.Setup(cr => cr.GetCertificate(_request.Uln, It.IsAny <int>(), _request.FamilyName)) .ReturnsAsync(_certificateResponse); _handler = new GetBatchLearnerHandler(_mockMediator.Object, Mock.Of <ILogger <GetBatchLearnerHandler> >(), _mockLearnerRepository.Object, _mockOrgQueryRepository.Object, _mockStandardService.Object, _mockCertificateRepoistory.Object); }
public async Task WhenHandlingStartCertificateRequest_AndThereIsExistingCertificate_WhichIsDeleted_ResetCertificateData( StartCertificateRequest request, Organisation organisationRecord, Certificate existingCertificate, Domain.Entities.Learner learnerRecord, CertificateData certificateData, Standard standard, Provider provider, Certificate stubCertificate) { // Arrange learnerRecord.FundingModel = 81; existingCertificate.Status = CertificateStatus.Deleted; existingCertificate.CertificateData = JsonConvert.SerializeObject(certificateData); _mockOrganisationQueryRepository.Setup(s => s.GetByUkPrn(request.UkPrn)).ReturnsAsync(organisationRecord); _mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync(existingCertificate); _mockLearnerRepository.Setup(s => s.Get(request.Uln, request.StandardCode)).ReturnsAsync(learnerRecord); _mockStandardService.Setup(s => s.GetStandardVersionById(request.StandardUId, null)).ReturnsAsync(standard); _mockProvidersRepository.Setup(s => s.GetProvider(learnerRecord.UkPrn)).ReturnsAsync(provider); Certificate updatedCertficate = null; _mockCertificateRepository.Setup(s => s.Update(It.IsAny <Certificate>(), It.IsAny <string>(), It.IsAny <string>(), true, null)) .Callback <Certificate, string, string, bool, string>((cert, username, action, updateLogs, reason) => { updatedCertficate = cert; }).ReturnsAsync(stubCertificate); // Act var response = await _sut.Handle(request, new CancellationToken()); // Assertions updatedCertficate.IsPrivatelyFunded.Should().BeFalse(); var responseCertData = JsonConvert.DeserializeObject <CertificateData>(updatedCertficate.CertificateData); responseCertData.LearnerGivenNames.Should().Be(learnerRecord.GivenNames); responseCertData.LearnerFamilyName.Should().Be(learnerRecord.FamilyName); responseCertData.LearningStartDate.Should().Be(learnerRecord.LearnStartDate); responseCertData.FullName.Should().Be($"{learnerRecord.GivenNames} {learnerRecord.FamilyName}"); _mockCertificateRepository.Verify(s => s.Update(existingCertificate, request.Username, null, true, null), Times.Once); }
public void WhenHandlingStartCertificateRequest_AndNoExistingCertificate_WhenStandardUIdSet_ButVersionInvalid_ThrowsException( StartCertificateRequest request, Domain.Entities.Learner learnerRecord, Organisation organisationRecord, Provider provider, Certificate stubCertificate, IEnumerable <Standard> standards) { // Arrange _mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync((Certificate)null); _mockLearnerRepository.Setup(s => s.Get(request.Uln, request.StandardCode)).ReturnsAsync(learnerRecord); _mockOrganisationQueryRepository.Setup(s => s.GetByUkPrn(request.UkPrn)).ReturnsAsync(organisationRecord); _mockProvidersRepository.Setup(s => s.GetProvider(learnerRecord.UkPrn)).ReturnsAsync(provider); _mockStandardService.Setup(s => s.GetStandardVersionById(request.StandardUId, null)).ReturnsAsync((Standard)null); // Act Func <Task> act = async() => { await _sut.Handle(request, new CancellationToken()); }; act.Should().Throw <InvalidOperationException>().WithMessage($"StandardUId:{request.StandardUId} not found, unable to populate certificate data"); }
public async Task ThenSelectsCorrectVersionBasedOnLearnerStartDate_WhenLatestVersionStartDateIsNull( [Frozen] Mock <IStandardService> standardService, [Frozen] Mock <ILearnerRepository> learnerRepository, GetCalculatedStandardVersionForApprenticeshipRequest request, IEnumerable <Standard> standards, DateTime baseDate, int baseVersion, int larsCode, Domain.Entities.Learner learnerRecord, GetCalculatedStandardVersionForApprenticeshipHandler sut) { //Arrange //List defaults to 3 records in autofixture // Set learner date for last version learnerRecord.LearnStartDate = baseDate.AddYears(2); foreach (var s in standards) { s.Version = baseVersion.ToString(); s.VersionLatestStartDate = baseDate; s.LarsCode = larsCode; baseVersion++; baseDate = baseDate.AddYears(1); } // Set latest Standard EndDate to null var latestVersion = standards.OrderByDescending(d => d.Version).First(); latestVersion.VersionLatestStartDate = null; standardService.Setup(s => s.GetStandardVersionById(request.StandardId, null)).ReturnsAsync(latestVersion); standardService.Setup(s => s.GetStandardVersionsByLarsCode(larsCode)).ReturnsAsync(standards); learnerRepository.Setup(s => s.Get(request.Uln, larsCode)).ReturnsAsync(learnerRecord); //Act var result = await sut.Handle(request, new CancellationToken()); //Assert result.Should().BeEquivalentTo(latestVersion); }
private CertificateData CombineCertificateData(CertificateData data, Domain.Entities.Learner learner, Standard standard, Provider provider, StandardOptions options, Certificate certificate) { var epaDetails = new EpaDetails(); if (certificate != null) { var certData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData); if (certData.EpaDetails != null) { epaDetails = certData.EpaDetails; } } if (epaDetails.Epas is null) { epaDetails.Epas = new List <EpaRecord>(); } var epaOutcome = data.OverallGrade == CertificateGrade.Fail ? EpaOutcome.Fail : EpaOutcome.Pass; if (data.AchievementDate != null && !epaDetails.Epas.Any(rec => rec.EpaDate == data.AchievementDate.Value && rec.EpaOutcome == epaOutcome)) { var record = new EpaRecord { EpaDate = data.AchievementDate.Value, EpaOutcome = epaOutcome }; epaDetails.Epas.Add(record); var latestRecord = epaDetails.Epas.OrderByDescending(epa => epa.EpaDate).First(); epaDetails.LatestEpaDate = latestRecord.EpaDate; epaDetails.LatestEpaOutcome = latestRecord.EpaOutcome; } return(new CertificateData() { LearnerGivenNames = learner.GivenNames, LearnerFamilyName = learner.FamilyName, LearningStartDate = learner.LearnStartDate, StandardReference = standard.IfateReferenceNumber, StandardName = standard.Title, StandardLevel = standard.Level, StandardPublicationDate = standard.EffectiveFrom, FullName = $"{learner.GivenNames} {learner.FamilyName}", ProviderName = provider.Name, ContactName = data.ContactName, ContactOrganisation = data.ContactOrganisation, Department = data.Department, ContactAddLine1 = data.ContactAddLine1, ContactAddLine2 = data.ContactAddLine2, ContactAddLine3 = data.ContactAddLine3, ContactAddLine4 = data.ContactAddLine4, ContactPostCode = data.ContactPostCode, Registration = data.Registration, AchievementDate = data.AchievementDate, CourseOption = CertificateHelpers.NormalizeCourseOption(options, data.CourseOption), OverallGrade = CertificateHelpers.NormalizeOverallGrade(data.OverallGrade), Version = data.Version, EpaDetails = epaDetails }); }
public async Task Then_Return_Learner_If_Found(GetApprovalsLearnerRecordRequest request, Domain.Entities.Learner learner) { // Arrange. _learnerRepositoryMock.Setup(s => s.Get(request.Uln, request.StdCode)).ReturnsAsync(learner); // Act. var result = await _sut.Handle(request, new CancellationToken()); // Assert. result.Should().BeEquivalentTo(new { learner.Uln, learner.FamilyName, learner.GivenNames, StandardCode = learner.StdCode, learner.Version, learner.VersionConfirmed, learner.CourseOption }); }