public async Task WhenConfirmAndSubmitIsInvoked_AndStandardUIdNotInModel_ButHasOptions_ReturnsOptionError(
CertificateCheckViewModel vm,
StandardOptions options)
{
//Setup
vm.StandardUId = null;
// Setup Options Call before HttpClientMock is instantiated from configuration.
// Setup StandardCode call as StandardUID is empty
_mockHttp.When($"http://localhost:59022/api/v1/standard-version/standard-options/{vm.StandardCode}")
.Respond("application/json", JsonConvert.SerializeObject(options));
//Set option to not set
vm.Option = null;
var sut = SetupController(vm);
// Act
var result = await sut.ConfirmAndSubmit(vm);
// Assert
var assertResult = result as ViewResult;
assertResult.ViewData.ModelState.IsValid.Should().BeFalse();
assertResult.ViewData.ModelState.ErrorCount.Should().Be(1);
assertResult.ViewData.ModelState.Keys.Should().Contain("Option");
var errorEnumerator = assertResult.ViewData.ModelState.Values.GetEnumerator();
errorEnumerator.MoveNext();
errorEnumerator.Current.Errors[0].ErrorMessage.Should().Be("Add an option");
}
public async Task <StandardOptions> GetStandardOptionsByStandardId(string id)
{
StandardOptions options = null;
try
{
var standardId = new StandardId(id);
switch (standardId.IdType)
{
case StandardId.StandardIdType.LarsCode:
options = await _standardRepository.GetStandardOptionsByLarsCode(standardId.LarsCode);
break;
case StandardId.StandardIdType.IFateReferenceNumber:
options = await _standardRepository.GetStandardOptionsByIFateReferenceNumber(standardId.IFateReferenceNumber);
break;
case StandardId.StandardIdType.StandardUId:
options = await _standardRepository.GetStandardOptionsByStandardUId(standardId.StandardUId);
break;
}
}
catch (Exception ex)
{
_logger.LogError(ex, $"STANDARD OPTIONS: Failed to get standard options for id {id}");
}
return(options);
}
public void SetupStandardOptionsTable()
{
_databaseConnection = new SqlConnection(_databaseService.WebConfiguration.SqlConnectionString);
_unitOfWork = new UnitOfWork(_databaseConnection);
_repository = new StandardRepository(_unitOfWork);
_options = GetListOfOptions();
_standards = GetListOfStandardVersions();
StandardOptionsHandler.InsertRecords(_options);
StandardsHandler.InsertRecords(_standards);
_expectedStandardResult = new StandardOptions
{
StandardUId = "ST0001_1.1",
StandardReference = "ST0001",
StandardCode = 1,
Version = "1.1",
CourseOption = new List <string>
{
"ST0001_1.1 Option 1",
"ST0001_1.1 Option 2"
}
};
}
private StandardOptions SetupOptions()
{
var option = new StandardOptions
{
CourseOption = new List <string> {
"CourseOption1"
},
StandardCode = 1,
StandardReference = "ST0001",
StandardUId = "StandardUId1"
};
return(option);
}
public async Task WhenConfirmAndSubmitIsInvoked_AndStandardUIdIsInModel_ButHasOptions_ReturnsRedirect(
CertificateCheckViewModel vm,
StandardOptions options)
{
//Setup
// Setup Options Call before HttpClientMock is instantiated from configuration.
// Setup StandardCode call as StandardUID is empty
_mockHttp.When($"http://localhost:59022/api/v1/standard-version/standard-options/{vm.StandardUId}")
.Respond("application/json", JsonConvert.SerializeObject(options));
var sut = SetupController(vm);
// Act
var result = await sut.ConfirmAndSubmit(vm);
// Assert
var redirectResult = result as RedirectToActionResult;
redirectResult.ControllerName.Should().Be("Comment");
redirectResult.ActionName.Should().Be("Index");
}
public async Task <StandardOptions> GetStandardOptionsByStandardUId(string standardUId)
{
var sql = @"SELECT [StandardUId],[Version],[IFateReferenceNumber],[LarsCode] FROM [Standards] WHERE [StandardUId] = @standardUId
SELECT [StandardUId],[OptionName] FROM [StandardOptions] WHERE [StandardUId] = @standardUId";
var filterResults = await _unitOfWork.Connection.QueryMultipleAsync(
sql,
param : new { standardUId },
transaction : _unitOfWork.Transaction);
var standard = filterResults.Read <Standard>().Single();
var options = filterResults.Read <StandardOption>();
var results = new StandardOptions
{
StandardUId = standard.StandardUId,
StandardCode = standard.LarsCode,
StandardReference = standard.IfateReferenceNumber,
Version = standard.Version,
CourseOption = options.Select(p => p.OptionName)
};
return(results);
}
public async Task WhenRequestingStandardVersionOptions_And_StandardVersionWithOptionsIsFound_Then_ReturnStandard(string standardReference, string version, StandardOptions standardOptionsResponse)
{
_mockApiClient.Setup(client => client.GetStandardOptionsByStandardIdAndVersion(standardReference, version))
.ReturnsAsync(standardOptionsResponse);
var result = await _controller.GetOptionsForStandardVersion(standardReference, version) as ObjectResult;
result.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = result.Value as StandardOptions;
model.Should().BeEquivalentTo(standardOptionsResponse);
}
public static string NormalizeCourseOption(StandardOptions standardOptions, string courseOption)
{
if (standardOptions is null || !standardOptions.HasOptions())
{
return(courseOption);
}
public async Task WhenPostingToSelectAVersion_WhenSavingModel_IfVersionHasOptions_AndOnlyOneOption_RedirectToDeclarePage(CertificateVersionViewModel vm, StandardVersion standardVersion, StandardOptions options, string option, CertificateSession session, List <StandardVersion> approvedVersions)
{
options.CourseOption = new List <string> {
option
};
var sessionString = JsonConvert.SerializeObject(session);
_mockSessionService.Setup(s => s.Get(nameof(CertificateSession))).Returns(sessionString);
standardVersion.StandardUId = vm.StandardUId;
approvedVersions.Add(standardVersion);
_mockStandardVersionClient.Setup(s => s.GetStandardVersionById(vm.StandardUId)).ReturnsAsync(standardVersion);
_mockStandardVersionClient.Setup(s => s.GetEpaoRegisteredStandardVersions(EpaoId, session.StandardCode)).ReturnsAsync(approvedVersions);
_mockStandardVersionClient.Setup(s => s.GetStandardOptions(vm.StandardUId)).ReturnsAsync(options);
var result = await _certificateVersionController.Version(vm) as RedirectToActionResult;
_mockSessionService.Verify(s => s.Set("RedirectedFromVersion", true), Times.Never);
result.ControllerName.Should().Be("CertificateDeclaration");
result.ActionName.Should().Be("Declare");
}
public async Task WhenPostingToSelectAVersion_WhenSavingModel_IfVersionNotChanged_AndRedirectToCheckSet_AndVersionHasOptions_ButOptionsNotSet_RedirectToOptionsPageWithRedirectToCheck(CertificateVersionViewModel vm, StandardVersion standardVersion, StandardOptions options, CertificateSession session, List <StandardVersion> approvedVersions)
{
var sessionString = JsonConvert.SerializeObject(session);
_mockSessionService.Setup(s => s.Get(nameof(CertificateSession))).Returns(sessionString);
vm.StandardUId = StandardUId;
standardVersion.StandardUId = StandardUId;
approvedVersions.Add(standardVersion);
_mockStandardVersionClient.Setup(s => s.GetStandardVersionById(vm.StandardUId)).ReturnsAsync(standardVersion);
_mockStandardVersionClient.Setup(s => s.GetEpaoRegisteredStandardVersions(EpaoId, session.StandardCode)).ReturnsAsync(approvedVersions);
_mockStandardVersionClient.Setup(s => s.GetStandardOptions(vm.StandardUId)).ReturnsAsync(options);
var expectedValue = true;
_mockSessionService.Setup(s => s.TryGet <bool>("RedirectToCheck", out expectedValue)).Returns(true);
var result = await _certificateVersionController.Version(vm) as RedirectToActionResult;
result.ControllerName.Should().Be("CertificateOption");
result.ActionName.Should().Be("Option");
result.RouteValues.Should().ContainKey("RedirectToCheck");
result.RouteValues.Should().ContainValue(true);
_mockSessionService.Verify(s => s.Set("RedirectedFromVersion", true), Times.Once);
}
public async Task When_GettingStandardOptionsByStandardId_AndIdIsLarsCode_Then_ReturnsStandardOptions(StandardOptions option, int larsCode)
{
_mockStandardRepository.Setup(s => s.GetStandardOptionsByLarsCode(larsCode)).ReturnsAsync(option);
var result = await _standardService.GetStandardOptionsByStandardId(larsCode.ToString());
result.Should().BeEquivalentTo(option);
}
public async Task WhenSelectingAVersion_WhenLoadingModel_WithOneVersion_WithOptions_RedirectsToOptionPage(CertificateSession session, StandardVersionViewModel standardVersion, StandardOptions options)
{
standardVersion.StandardUId = session.StandardUId;
session.Versions = new List <StandardVersionViewModel> {
standardVersion
};
var sessionString = JsonConvert.SerializeObject(session);
_mockSessionService.Setup(s => s.Get(nameof(CertificateSession))).Returns(sessionString);
_mockStandardVersionClient.Setup(s => s.GetStandardOptions(session.StandardUId)).ReturnsAsync(options);
var result = await _certificateVersionController.Version(false) as RedirectToActionResult;
result.ControllerName.Should().Be("CertificateOption");
result.ActionName.Should().Be("Option");
_mockSessionService.Verify(s => s.Set(nameof(CertificateSession), It.Is <CertificateSession>(c => c.Options.SequenceEqual(options.CourseOption.ToList()) && c.StandardUId == standardVersion.StandardUId)));
}
public async Task WhenRequestingGetStandardOptionByStandardId_ThenListOfOptionsForThatStandardIsReturned(StandardOptions options, string standard)
{
_mockStandardService.Setup(service => service.GetStandardOptionsByStandardId(standard))
.ReturnsAsync(options);
var controllerResult = await _standardServiceController.GetStandardOptionsForStandard(standard) as ObjectResult;
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as StandardOptions;
model.Should().BeEquivalentTo(options);
}
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 When_GettingStandardOptionsByStandardReferenceAndVersion_Then_UseStandardUIdToCallOuterApi(string version, Standard getStandardResponse, StandardOptions option)
{
var standardReference = "ST0001";
_mockStandardRepository.Setup(repository => repository.GetStandardVersionByIFateReferenceNumber(standardReference, version))
.ReturnsAsync(getStandardResponse);
_mockStandardRepository.Setup(repository => repository.GetStandardOptionsByStandardUId(getStandardResponse.StandardUId)).ReturnsAsync(option);
var result = await _standardService.GetStandardOptionsByStandardIdAndVersion(standardReference, version);
result.Should().BeEquivalentTo(option);
}
public async Task When_GettingStandardOptionsByStandardId_AndIdIsStandardReferenceNumber_Then_ReturnsStandardOptions(StandardOptions option)
{
var ifateReferenceNumber = "ST0023";
_mockStandardRepository.Setup(s => s.GetStandardOptionsByIFateReferenceNumber(ifateReferenceNumber)).ReturnsAsync(option);
var result = await _standardService.GetStandardOptionsByStandardId(ifateReferenceNumber);
result.Should().BeEquivalentTo(option);
}
public async Task When_GettingStandardOptionsByLarsCodeAndVersion_Then_UseStandardUIdToCallOuterApi(string version, Standard getStandardResponse, StandardOptions option)
{
var standardId = "1";
_mockStandardRepository.Setup(repository => repository.GetStandardVersionByLarsCode(int.Parse(standardId), version))
.ReturnsAsync(getStandardResponse);
_mockStandardRepository.Setup(repository => repository.GetStandardOptionsByStandardUId(getStandardResponse.StandardUId)).ReturnsAsync(option);
var result = await _standardService.GetStandardOptionsByStandardIdAndVersion(standardId, version);
result.Should().BeEquivalentTo(option);
}
private CertificateData CombineCertificateData(CertificateData certData, CertificateData requestData, StandardOptions options)
{
var epaDetails = certData.EpaDetails ?? new EpaDetails();
if (epaDetails.Epas is null)
{
epaDetails.Epas = new List <EpaRecord>();
}
var epaOutcome = certData.OverallGrade == CertificateGrade.Fail ? EpaOutcome.Fail : EpaOutcome.Pass;
if (requestData.AchievementDate != null && !epaDetails.Epas.Any(rec => rec.EpaDate == requestData.AchievementDate.Value && rec.EpaOutcome == epaOutcome))
{
var record = new EpaRecord {
EpaDate = requestData.AchievementDate.Value, EpaOutcome = epaOutcome
};
epaDetails.Epas.Add(record);
// sort pass outcomes before fail outcomes as pass is the final state even if earlier than the fail
var latestRecord = epaDetails.Epas
.OrderByDescending(epa => epa.EpaOutcome != EpaOutcome.Fail ? 1 : 0)
.ThenByDescending(epa => epa.EpaDate)
.First();
epaDetails.LatestEpaDate = latestRecord.EpaDate;
epaDetails.LatestEpaOutcome = latestRecord.EpaOutcome;
}
return(new CertificateData()
{
LearnerGivenNames = certData.LearnerGivenNames,
LearnerFamilyName = certData.LearnerFamilyName,
LearningStartDate = certData.LearningStartDate,
StandardReference = certData.StandardReference,
StandardName = certData.StandardName,
StandardLevel = certData.StandardLevel,
StandardPublicationDate = certData.StandardPublicationDate,
FullName = certData.FullName,
ProviderName = certData.ProviderName,
ContactName = requestData.ContactName,
ContactOrganisation = requestData.ContactOrganisation,
Department = requestData.Department,
ContactAddLine1 = requestData.ContactAddLine1,
ContactAddLine2 = requestData.ContactAddLine2,
ContactAddLine3 = requestData.ContactAddLine3,
ContactAddLine4 = requestData.ContactAddLine4,
ContactPostCode = requestData.ContactPostCode,
Registration = requestData.Registration,
AchievementDate = requestData.AchievementDate,
CourseOption = CertificateHelpers.NormalizeCourseOption(options, requestData.CourseOption),
Version = requestData.Version,
OverallGrade = CertificateHelpers.NormalizeOverallGrade(requestData.OverallGrade),
EpaDetails = epaDetails
});
}
public async Task WhenStartingANewCertificate_WithVersionSetFromApprovals_OptionRequiredButNotSet_GoesToOptionsPage(CertificateStartViewModel model, ApprovalsLearnerResult learner, StandardVersion version, StandardOptions options)
{
CertificateSession setSession = new CertificateSession();
version.LarsCode = model.StdCode;
learner.Version = version.Version;
learner.VersionConfirmed = true;
learner.CourseOption = string.Empty;
_mockLearnerApiClient.Setup(c => c.GetLearnerRecord(It.IsAny <int>(), It.IsAny <long>()))
.ReturnsAsync(learner);
_mockStandardVersionClient.Setup(c => c.GetStandardVersionsByLarsCode(It.IsAny <int>()))
.ReturnsAsync(new List <StandardVersion> {
version
});
_mockStandardVersionClient.Setup(s => s.GetStandardOptions(version.StandardUId))
.ReturnsAsync(options);
_mockSessionService.Setup(c => c.Set(nameof(CertificateSession), It.IsAny <object>()))
.Callback <string, object>((key, session) =>
{
if (key == nameof(CertificateSession) && session is CertificateSession)
{
setSession = (CertificateSession)session;
}
});
var result = await _certificateController.Start(model) as RedirectToActionResult;
_mockCertificateApiClient.Verify(s => s.Start(It.Is <StartCertificateRequest>(
m => m.StandardCode == model.StdCode &&
m.Uln == model.Uln &&
m.Username == Username &&
m.UkPrn == Ukprn &&
m.StandardUId == version.StandardUId &&
m.CourseOption == null)));
setSession.CertificateId.Should().Be(CertificateId);
setSession.Uln.Should().Be(model.Uln);
setSession.StandardCode.Should().Be(model.StdCode);
setSession.Options.Should().BeEquivalentTo(options.CourseOption.ToList());
setSession.Versions.Count().Should().Be(1);
setSession.Versions.Single().StandardUId.Should().Be(version.StandardUId);
result.ControllerName.Should().Be("CertificateOption");
result.ActionName.Should().Be("Option");
}
public async Task WhenStartingANewCertificate_WithVersionAndOptionSetFromApprovalsButNotConfirmed_WithOneVersion_WithOptions_GoesToOptionPage(CertificateStartViewModel model, ApprovalsLearnerResult learner, StandardVersion standard, StandardOptions options)
{
CertificateSession setSession = new CertificateSession();
learner.Version = null;
learner.CourseOption = null;
learner.VersionConfirmed = false;
_mockStandardVersionClient.Setup(s => s.GetStandardVersionsByLarsCode(model.StdCode)).ReturnsAsync(new List <StandardVersion> {
standard
});
_mockStandardVersionClient.Setup(s => s.GetStandardOptions(standard.StandardUId)).ReturnsAsync(options);
_mockLearnerApiClient.Setup(c => c.GetLearnerRecord(model.StdCode, model.Uln)).ReturnsAsync(learner);
_mockSessionService.Setup(c => c.Set(nameof(CertificateSession), It.IsAny <object>()))
.Callback <string, object>((key, session) =>
{
if (key == nameof(CertificateSession) && session is CertificateSession)
{
setSession = (CertificateSession)session;
}
});
var result = await _certificateController.Start(model) as RedirectToActionResult;
_mockCertificateApiClient.Verify(s => s.Start(It.Is <StartCertificateRequest>(
m => m.StandardCode == model.StdCode && m.Uln == model.Uln &&
m.Username == Username && m.UkPrn == Ukprn)));
setSession.CertificateId.Should().Be(CertificateId);
setSession.Uln.Should().Be(model.Uln);
setSession.StandardCode.Should().Be(model.StdCode);
setSession.Options.Should().BeEquivalentTo(options.CourseOption.ToList());
setSession.Versions.Should().BeEquivalentTo(new List <StandardVersionViewModel> {
Mapper.Map <StandardVersionViewModel>(standard)
});
result.ControllerName.Should().Be("CertificateOption");
result.ActionName.Should().Be(CertificateActions.Option);
}
public async Task When_GettingStandardOptionsByStandardId_AndIdIsStandardUId_Then_ReturnsStandardOptions(StandardOptions option)
{
var standardUId = "ST0023_1.0";
_mockStandardRepository.Setup(s => s.GetStandardOptionsByStandardUId(standardUId)).ReturnsAsync(option);
var result = await _standardService.GetStandardOptionsByStandardId(standardUId);
result.Should().BeEquivalentTo(option);
}
