private CertificateAmendController SetupController(CertificateCheckViewModel vm)
{
return(new CertificateAmendController(_logger.Object, SetupMockHttpAccessor().Object, SetupApiClient(vm))
{
TempData = new TempDataDictionary(new DefaultHttpContext(), Mock.Of <ITempDataProvider>())
});
}
private async Task <IActionResult> LoadViewModel(string view)
{
var username = GetUsernameFromClaim();
Logger.LogInformation($"Load View Model for CertificateCheckViewModel for {username}");
var viewModel = new CertificateCheckViewModel();
CheckAndSetRedirectToCheck(viewModel);
if (!TryGetCertificateSession("CertificateCheckViewModel", username, out var certSession))
{
return(RedirectToAction("Index", "Search"));
}
var certificate = await CertificateApiClient.GetCertificate(certSession.CertificateId);
Logger.LogInformation($"Got Certificate for CertificateCheckViewModel requested by {username} with Id {certificate.Id}");
viewModel.FromCertificate(certificate);
viewModel.SetStandardHasVersionsAndOptions(certSession);
Logger.LogInformation($"Got View Model of type CertificateCheckViewModel requested by {username}");
return(View(view, viewModel));
}
protected CertificateCheckViewModel SetupViewModel()
{
var viewModel = new CertificateCheckViewModel();
viewModel.FromCertificate(Certificate);
return(viewModel);
}
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");
}
private ApiClient SetupApiClient(CertificateCheckViewModel vm)
{
var fixture = new Fixture();
fixture.Behaviors.Add(new OmitOnRecursionBehavior());
var organisation = fixture.Create <Organisation>();
var certificate = fixture.Create <Certificate>();
certificate.Id = vm.Id;
certificate.StandardCode = vm.StandardCode;
certificate.StandardUId = vm.StandardUId;
var certificateData = fixture.Create <CertificateData>();
certificateData.CourseOption = vm.Option;
certificate.CertificateData = JsonConvert.SerializeObject(certificateData);
var standardVersions = fixture.CreateMany <StandardVersion>();
_mockHttp.When($"http://localhost:59022/api/v1/certificates/{certificate.Id}")
.Respond("application/json", JsonConvert.SerializeObject(certificate));
_mockHttp.When($"http://localhost:59022/api/v1/organisations/organisation/{certificate.OrganisationId}")
.Respond("application/json", JsonConvert.SerializeObject(organisation));
_mockHttp.When($"http://localhost:59022/api/v1/standard-version/standards/versions/{vm.StandardCode}")
.Respond("application/json", JsonConvert.SerializeObject(standardVersions));
var client = _mockHttp.ToHttpClient();
client.BaseAddress = new Uri("http://localhost:59022/");
var tokenServiceMock = new Mock <ITokenService>();
return(new ApiClient(client, tokenServiceMock.Object));
}
public void When_AllFieldsAreCorrect_Then_ValidatorReturnsValid(CertificateSendTo sendTo)
{
_viewModel = CreateValidViewModel(sendTo);
var result = _validator.Validate(_viewModel);
result.IsValid.Should().Be(true);
}
public void When_SendToIsNone_Then_ValidatorReturnsInvalid()
{
_viewModel = CreateValidViewModel(CertificateSendTo.None);
var result = _validator.Validate(_viewModel);
result.IsValid.Should().Be(false);
}
public async Task When_CertificateCheckViewModelIsInvalid(CertificateCheckViewModel vm)
{
_validator.Setup(s => s.Validate(It.IsAny <CertificateCheckViewModel>())).Returns(new ValidationResult(new List <ValidationFailure> {
new ValidationFailure("Error", "Error message")
}));
var result = await _certificateCheckController.Check(vm) as ViewResult;
result.ViewName.Should().Be("~/Views/Certificate/Check.cshtml");
}
public async Task <IActionResult> ConfirmAndSubmit(CertificateCheckViewModel vm)
{
var(actionResult, model) = await GetCheckViewModel(vm.Id, vm.SearchString, vm.Page);
var options = await ApiClient.GetStandardOptions(vm.GetStandardId());
var isDueCertificate = vm.SelectedGrade != null & vm.SelectedGrade != CertificateGrade.Fail;
var isMissingOptions = options != null && options.HasOptions() && string.IsNullOrWhiteSpace(model.Option);
var isMissingRecipient = string.IsNullOrWhiteSpace(model.AddressLine1) || string.IsNullOrWhiteSpace(model.Name);
if ((isDueCertificate & isMissingRecipient) || isMissingOptions)
{
if (isMissingOptions)
{
ModelState.AddModelError("Option", "Add an option");
}
if (isDueCertificate & string.IsNullOrWhiteSpace(model.Name))
{
ModelState.AddModelError("Name", "You need to give a name of who will receive the certificate");
}
if (isDueCertificate & string.IsNullOrWhiteSpace(model.AddressLine1))
{
ModelState.AddModelError("AddressLine1", "You need to give an address of where we will send the certificate");
}
return(actionResult);
}
if (vm.CanRequestDuplicate)
{
return(RedirectToAction("ConfirmReprint", "DuplicateRequest",
new
{
certificateId = vm.Id,
redirectToCheck = vm.RedirectToCheck,
Uln = vm.Uln,
StdCode = vm.StandardCode,
Page = vm.Page,
SearchString = vm.SearchString
}));
}
return(RedirectToAction("Index", "Comment",
new
{
certificateId = vm.Id,
redirectToCheck = vm.RedirectToCheck,
Uln = vm.Uln,
StdCode = vm.StandardCode,
Page = vm.Page,
SearchString = vm.SearchString
}));
}
public async Task <IActionResult> ConfirmAndSubmit(CertificateCheckViewModel vm)
{
if (vm.CanRequestDuplicate)
{
return(RedirectToAction("Index", "DuplicateRequest",
new
{
certificateId = vm.Id, redirectToCheck = vm.RedirectToCheck,
Uln = vm.Uln,
StdCode = vm.StandardCode,
Page = vm.Page,
SearchString = vm.SearchString
}));
}
if (vm.Status == CertificateStatus.Draft &
vm.PrivatelyFundedStatus == CertificateStatus.Rejected & vm.FromApproval)
{
var certificate = await ApiClient.GetCertificate(vm.Id);
var approvalResults = new ApprovalResult[1];
approvalResults[0] = new ApprovalResult
{
IsApproved = CertificateStatus.Submitted,
CertificateReference = certificate.CertificateReference,
PrivatelyFundedStatus = CertificateStatus.Approved
};
await ApiClient.ApproveCertificates(new CertificatePostApprovalViewModel
{
UserName = ContextAccessor.HttpContext.User
.FindFirst("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/upn")?.Value,
ApprovalResults = approvalResults
});
return(RedirectToAction("Approved", "CertificateApprovals"));
}
else
{
return(RedirectToAction("Index", "Comment",
new
{
certificateId = vm.Id, redirectToCheck = vm.RedirectToCheck,
Uln = vm.Uln,
StdCode = vm.StandardCode,
Page = vm.Page,
SearchString = vm.SearchString
}));
}
}
public void Arange()
{
_mockStringLocalizer = new Mock <IStringLocalizer <CertificateCheckViewModelValidator> >();
_mockStringLocalizer.Setup(l => l["VersionCannotBeNull"]).Returns(new LocalizedString("Version", _versionError));
_mockStringLocalizer.Setup(l => l["OptionCannotBeNull"]).Returns(new LocalizedString("Option", _optionError));
_mockStringLocalizer.Setup(l => l["GradeCannotBeNull"]).Returns(new LocalizedString("Option", _gradeError));
_mockStringLocalizer.Setup(l => l["DateCannotBeEmpty"]).Returns(new LocalizedString("Date", _dateError));
_mockStringLocalizer.Setup(l => l["AchievementDateCannotBeEmpty"]).Returns(new LocalizedString("Date", _passDateError));
_mockStringLocalizer.Setup(l => l["FailDateCannotBeEmpty"]).Returns(new LocalizedString("Date", _failDateError));
_mockStringLocalizer.Setup(l => l["AddressCannotBeEmpty"]).Returns(new LocalizedString("Address", _addressError));
_mockStringLocalizer.Setup(l => l["NameCannotBeEmpty"]).Returns(new LocalizedString("Name", _nameError));
_mockStringLocalizer.Setup(l => l["SendToCannotBeNone"]).Returns(new LocalizedString("SendTo", _sendToError));
_viewModel = CreateValidViewModel(CertificateSendTo.Apprentice);
_validator = new CertificateCheckViewModelValidator(_mockStringLocalizer.Object);
}
public async Task <IActionResult> Check(CertificateCheckViewModel vm)
{
// This is the final step in the process so get the latest version of the certificate!
if (vm is null)
{
vm = new CertificateCheckViewModel();
}
vm.FromCertificate(await CertificateApiClient.GetCertificate(vm.Id));
var result = _validator.Validate(vm);
if (!result.IsValid)
{
return(await Check());
}
return(await SaveViewModel(vm,
returnToIfModelNotValid : "~/Views/Certificate/Check.cshtml",
nextAction : RedirectToAction("Confirm", "CertificateConfirmation"), action : CertificateActions.Submit));
}
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 When_CertificateCheckViewModelIsValid_Then_CallUpdateCertificate(CertificateCheckViewModel vm)
{
_validator.Setup(s => s.Validate(It.IsAny <CertificateCheckViewModel>())).Returns(new ValidationResult());
await _certificateCheckController.Check(vm);
_mockCertificateApiClient.Verify(client => client.UpdateCertificate(It.IsAny <UpdateCertificateRequest>()), Times.Once);
}
public async Task When_CertificateCheckViewModelIsValid_Then_ReturnRedirectToCertificateConfirmation(CertificateCheckViewModel vm)
{
_validator.Setup(s => s.Validate(It.IsAny <CertificateCheckViewModel>())).Returns(new ValidationResult());
var result = await _certificateCheckController.Check(vm) as RedirectToActionResult;
result.ActionName.Should().Be("Confirm");
result.ControllerName.Should().Be("CertificateConfirmation");
}
