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