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
});
}
