public async Task <IActionResult> EmployerManage(ReservationsRouteModel routeModel)
{
var reservations = new List <ReservationViewModel>();
var decodedAccountId = _encodingService.Decode(routeModel.EmployerAccountId, EncodingType.AccountId);
var reservationsResult = await _mediator.Send(new GetReservationsQuery { AccountId = decodedAccountId });
foreach (var reservation in reservationsResult.Reservations)
{
var accountLegalEntityPublicHashedId = _encodingService.Encode(reservation.AccountLegalEntityId,
EncodingType.PublicAccountLegalEntityId);
var apprenticeUrl = reservation.Status == ReservationStatus.Pending && !reservation.IsExpired
? _urlHelper.GenerateAddApprenticeUrl(
reservation.Id,
accountLegalEntityPublicHashedId,
reservation.Course.Id,
routeModel.UkPrn,
reservation.StartDate,
routeModel.CohortReference,
routeModel.EmployerAccountId)
: string.Empty;
var viewModel = new ReservationViewModel(reservation, apprenticeUrl, routeModel.UkPrn);
reservations.Add(viewModel);
}
return(View(ViewNames.EmployerManage, new ManageViewModel
{
Reservations = reservations,
BackLink = _urlHelper.GenerateDashboardUrl(routeModel.EmployerAccountId)
}));
}
public async Task <IActionResult> Completed(ReservationsRouteModel routeModel)
{
if (!routeModel.Id.HasValue)
{
throw new ArgumentException("Reservation ID must be in URL.", nameof(routeModel.Id));
}
var query = new GetReservationQuery
{
Id = routeModel.Id.Value,
UkPrn = routeModel.UkPrn.GetValueOrDefault()
};
var queryResult = await _mediator.Send(query);
//todo: null check on result, redirect to error
var model = new CompletedViewModel
{
AccountLegalEntityName = queryResult.AccountLegalEntityName,
TrainingDateDescription = new TrainingDateModel()
{
StartDate = queryResult.StartDate,
EndDate = queryResult.ExpiryDate
}.GetGDSDateString(),
CourseDescription = queryResult.Course.CourseDescription,
StartDate = queryResult.StartDate,
CourseId = queryResult.Course?.Id,
UkPrn = queryResult.UkPrn ?? routeModel.ProviderId,
CohortRef = routeModel.CohortReference
};
var viewName = routeModel.UkPrn.HasValue ? ViewNames.ProviderCompleted : ViewNames.EmployerCompleted;
return(View(viewName, model));
}
public async Task Then_It_Returns_The_ViewModel(
ReservationsRouteModel routeModel,
GetReservationResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IOptions <ReservationsWebConfiguration> > mockConfig,
ReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetReservationQuery>(), CancellationToken.None))
.ReturnsAsync(mediatorResult);
var result = await controller.Completed(routeModel);
var viewResult = result.Should().BeOfType <ViewResult>().Subject;
var model = viewResult.Model.Should().BeOfType <CompletedViewModel>().Subject;
viewResult.ViewName.Should().Be(ViewNames.ProviderCompleted);
model.AccountLegalEntityName.Should().Be(mediatorResult.AccountLegalEntityName);
model.TrainingDateDescription.Should().Be(new TrainingDateModel
{
StartDate = mediatorResult.StartDate,
EndDate = mediatorResult.ExpiryDate
}.GetGDSDateString());
model.CourseDescription.Should().Be(mediatorResult.Course.CourseDescription);
model.StartDate.Should().Be(mediatorResult.StartDate);
model.CourseId.Should().Be(mediatorResult.Course.Id);
model.UkPrn.Should().Be(mediatorResult.UkPrn);
model.CohortRef.Should().Be(routeModel.CohortReference);
}
public async Task Then_The_BackLink_Is_Set_To_Return_To_CohortDetails_From_ValidationError_If_There_Is_A_Cohort_Ref(
ReservationsRouteModel routeModel,
string cohortUrl,
PostSelectCourseViewModel postSelectCourseViewModel
)
{
//Arrange
_cachedReservationResult.CohortRef = "ABC123";
_cachedReservationResult.UkPrn = null;
_cachedReservationResult.IsEmptyCohortFromSelect = false;
_mediator.Setup(mediator => mediator.Send(It.IsAny <CacheReservationCourseCommand>(), It.IsAny <CancellationToken>()))
.ThrowsAsync(new ValidationException(new ValidationResult("Failed", new List <string> {
"Course|The Course field is not valid."
}), null, null));
postSelectCourseViewModel.SelectedCourseId = string.Empty;
postSelectCourseViewModel.ApprenticeTrainingKnown = true;
_externalUrlHelper
.Setup(x => x.GenerateCohortDetailsUrl(null, routeModel.EmployerAccountId, _cachedReservationResult.CohortRef, false))
.Returns(cohortUrl);
//Act
var result = await _controller.PostSelectCourse(routeModel, postSelectCourseViewModel) as ViewResult;
var viewModel = result?.Model as EmployerSelectCourseViewModel;
Assert.IsNotNull(viewModel);
Assert.AreEqual(cohortUrl, viewModel.BackLink);
Assert.AreEqual(_cachedReservationResult.CohortRef, viewModel.CohortReference);
}
public async Task And_Single_Legal_Entity_Then_The_BackLink_Is_Set_To_Return_To_Start(
ReservationsRouteModel routeModel,
ICollection <Course> courses,
GetCachedReservationResult cachedReservationResult,
[Frozen] Mock <IMediator> mockMediator,
EmployerReservationsController controller)
{
//Arrange
routeModel.FromReview = false;
cachedReservationResult.CohortRef = string.Empty;
cachedReservationResult.IsEmptyCohortFromSelect = false;
cachedReservationResult.EmployerHasSingleLegalEntity = true;
mockMediator
.Setup(m => m.Send(It.IsAny <GetCoursesQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetCoursesResult {
Courses = courses
});
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetCachedReservationQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(cachedReservationResult);
//Act
var result = await controller.SelectCourse(routeModel) as ViewResult;
//Assert
var viewModel = result?.Model as EmployerSelectCourseViewModel;
Assert.IsNotNull(viewModel);
Assert.AreEqual(RouteNames.EmployerStart, viewModel.BackLink);
}
private async Task <EmployerSelectCourseViewModel> BuildEmployerSelectCourseViewModel(
ReservationsRouteModel routeModel,
bool?apprenticeTrainingKnownOrFromReview,
bool failedValidation = false)
{
var cachedReservation = await _mediator.Send(new GetCachedReservationQuery { Id = routeModel.Id.Value });
if (cachedReservation == null)
{
return(null);
}
var getCoursesResponse = await _mediator.Send(new GetCoursesQuery());
var courseViewModels = getCoursesResponse.Courses.Select(course => new CourseViewModel(course, failedValidation? null : cachedReservation.CourseId));
var viewModel = new EmployerSelectCourseViewModel
{
ReservationId = routeModel.Id.Value,
Courses = courseViewModels,
BackLink = GenerateBackLink(routeModel, cachedReservation),
CohortReference = cachedReservation.CohortRef,
ApprenticeTrainingKnown = !string.IsNullOrEmpty(cachedReservation.CourseId) ? true : apprenticeTrainingKnownOrFromReview,
IsEmptyCohortFromSelect = cachedReservation.IsEmptyCohortFromSelect
};
return(viewModel);
}
public async Task Then_The_Cached_Search_Is_Not_Saved_If_It_Is_Empty_But_The_Cache_Is_Still_Cleared(
ReservationsRouteModel routeModel,
ManageReservationsFilterModel filterModel,
SearchReservationsResult searchResult,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <ISessionStorageService <ManageReservationsFilterModelBase> > sessionStorageService,
ManageReservationsController controller)
{
routeModel.IsFromManage = false;
filterModel.SearchTerm = string.Empty;
filterModel.PageNumber = 1;
filterModel.SelectedCourse = string.Empty;
filterModel.SelectedEmployer = string.Empty;
filterModel.SelectedStartDate = string.Empty;
mockMediator
.Setup(mediator => mediator.Send(It.Is <SearchReservationsQuery>(c => c.Filter.SearchTerm.Equals(filterModel.SearchTerm)), It.IsAny <CancellationToken>()))
.ReturnsAsync(searchResult);
await controller.ProviderManage(routeModel, filterModel);
mockMediator.Verify(x => x.Send(It.Is <SearchReservationsQuery>(
c => c.Filter.SearchTerm.Equals(filterModel.SearchTerm)), It.IsAny <CancellationToken>()), Times.Once);
sessionStorageService.Verify(x => x.Delete(), Times.Once);
sessionStorageService.Verify(x => x.Store(It.IsAny <ManageReservationsFilterModelBase>()), Times.Never);
}
public async Task Then_Updates_Existing_Reservation_If_Supplied(ReservationsRouteModel routeModel,
ConfirmLegalEntityViewModel viewModel,
GetLegalEntitiesResponse getLegalEntitiesResponse,
long decodedAccountId,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IEncodingService> mockEncodingService,
EmployerReservationsController controller)
{
var firstLegalEntity = getLegalEntitiesResponse.AccountLegalEntities.First();
firstLegalEntity.AgreementSigned = true;
viewModel.LegalEntity = firstLegalEntity.AccountLegalEntityPublicHashedId;
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetLegalEntitiesQuery>(query => query.AccountId == decodedAccountId),
It.IsAny <CancellationToken>()))
.ReturnsAsync(getLegalEntitiesResponse);
mockEncodingService
.Setup(service => service.Decode(routeModel.EmployerAccountId, EncodingType.AccountId))
.Returns(decodedAccountId);
await controller.PostSelectLegalEntity(routeModel, viewModel);
mockMediator.Verify(mediator => mediator.Send(
It.Is <CacheReservationEmployerCommand>(command =>
command.Id == routeModel.Id),
It.IsAny <CancellationToken>()),
Times.Once);
}
public async Task ThenRedirectToStartIfNoActiveFromDateFoundOnNextGlobalFundingRule(
string expectedUserId,
[Frozen] Mock <IMediator> mockMediator,
ReservationsRouteModel routeModel,
EmployerReservationsController controller)
{
//arrange
controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[]
{
new Claim(EmployerClaims.IdamsUserIdClaimTypeIdentifier, expectedUserId)
}));
mockMediator.Setup(x => x.Send(It.IsAny <GetNextUnreadGlobalFundingRuleQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetNextUnreadGlobalFundingRuleResult {
Rule = new GlobalRule {
Id = 2
}
});
//act
var redirect = await controller.Index(routeModel) as RedirectToRouteResult;
//assert
Assert.IsNotNull(redirect);
Assert.AreEqual(redirect.RouteName, RouteNames.EmployerStart);
}
public async Task And_ValidationException_Then_Redirects_To_SelectLegalEntity(
ReservationsRouteModel routeModel,
ConfirmLegalEntityViewModel viewModel,
GetLegalEntitiesResponse getLegalEntitiesResponse,
[Frozen] Mock <IMediator> mockMediator,
EmployerReservationsController controller)
{
var firstLegalEntity = getLegalEntitiesResponse.AccountLegalEntities.First();
firstLegalEntity.AgreementSigned = true;
viewModel.LegalEntity = firstLegalEntity.AccountLegalEntityPublicHashedId;
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetLegalEntitiesQuery>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(getLegalEntitiesResponse);
mockMediator.Setup(x => x.Send(It.IsAny <CacheReservationEmployerCommand>(), It.IsAny <CancellationToken>()))
.ThrowsAsync(new ValidationException(
new ValidationResult("Failed",
new List <string> {
"AccountId| Account reservation limit has been reached."
}), null, null));
var actual = await controller.PostSelectLegalEntity(routeModel, viewModel);
actual.Should().NotBeNull();
var actualViewResult = actual as ViewResult;
actualViewResult.Should().NotBeNull();
actualViewResult?.ViewName.Should().Be("SelectLegalEntity");
controller.ModelState.IsValid.Should().BeFalse();
controller.ModelState.Should().Contain(pair => pair.Key == "AccountId");
}
And_User_Has_Transactor_Role_And_Chosen_Legal_Entity_Has_Not_Signed_Agreement_Then_Redirect_To_Transactor_Sign_Route(
ReservationsRouteModel routeModel,
ConfirmLegalEntityViewModel viewModel,
GetLegalEntitiesResponse getLegalEntitiesResponse,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IUserClaimsService> mockClaimsService,
EmployerReservationsController controller)
{
var firstLegalEntity = getLegalEntitiesResponse.AccountLegalEntities.First();
firstLegalEntity.AgreementSigned = false;
viewModel.LegalEntity = firstLegalEntity.AccountLegalEntityPublicHashedId;
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetLegalEntitiesQuery>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(getLegalEntitiesResponse);
mockClaimsService
.Setup(service => service.UserIsInRole(
routeModel.EmployerAccountId,
EmployerUserRole.Owner,
It.IsAny <IEnumerable <Claim> >()))
.Returns(false);
var result = await controller.PostSelectLegalEntity(routeModel, viewModel) as RedirectToRouteResult;
result.RouteName.Should().Be(RouteNames.EmployerTransactorSignAgreement);
result.RouteValues[nameof(ReservationsRouteModel.PreviousPage)].Should().Be(RouteNames.EmployerSelectLegalEntity);
}
public async Task Then_If_Employer_Reads_UserId_Claim_And_Sends_Command_To_Mark_Rule_As_Read_And_Redirects_To_Route_In_Model(
FundingRestrictionNotificationViewModel viewModel,
ReservationsRouteModel routeModel,
string expectedUserId,
[Frozen] Mock <IMediator> mockMediator,
ReservationsController controller)
{
//arrange
viewModel.RouteName = RouteNames.ProviderApprenticeshipTraining;
routeModel.UkPrn = null;
viewModel.MarkRuleAsRead = true;
var claim = new Claim(EmployerClaims.IdamsUserIdClaimTypeIdentifier, expectedUserId);
controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { claim }));
//act
var actual = await controller.SaveRuleNotificationChoice(routeModel, viewModel) as RedirectToRouteResult;
//assert
mockMediator.Verify(m => m.Send(It.Is <MarkRuleAsReadCommand>(c =>
c.Id.Equals(expectedUserId) &&
c.RuleId.Equals(viewModel.RuleId) &&
c.TypeOfRule.Equals(viewModel.TypeOfRule)), It.IsAny <CancellationToken>()));
Assert.IsNotNull(actual);
Assert.AreEqual(viewModel.RouteName, actual.RouteName);
}
public async Task Then_It_Sets_The_Back_Link_Correctly_Coming_From_The_SelectReservation_Screen(
ReservationsRouteModel routeModel,
GetCoursesResult getCoursesResult,
GetCachedReservationResult cachedReservationResult,
string cohortDetailsUrl,
[Frozen] Mock <IExternalUrlHelper> mockUrlHelper,
[Frozen] Mock <IMediator> mockMediator,
ReservationsController controller)
{
cachedReservationResult.CohortRef = "ABC123";
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetCachedReservationQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(cachedReservationResult);
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetCoursesQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(getCoursesResult);
routeModel.FromReview = true;
mockUrlHelper
.Setup(helper => helper.GenerateCohortDetailsUrl(routeModel.UkPrn, routeModel.EmployerAccountId,
cachedReservationResult.CohortRef, false, It.IsAny <string>()))
.Returns(cohortDetailsUrl);
var result = await controller.ApprenticeshipTraining(routeModel);
var viewModel = result.Should().BeOfType <ViewResult>()
.Which.Model.Should().BeOfType <ApprenticeshipTrainingViewModel>()
.Subject;
viewModel.CohortRef.Should().Be(cachedReservationResult.CohortRef);
viewModel.BackLink.Should().Be(cohortDetailsUrl);
}
public async Task <IActionResult> ChooseEmployer(ReservationsRouteModel routeModel)
{
if (!routeModel.UkPrn.HasValue)
{
throw new ArgumentException("UkPrn must be set", nameof(ReservationsRouteModel.UkPrn));
}
var getTrustedEmployersResponse = await _mediator.Send(new GetTrustedEmployersQuery { UkPrn = routeModel.UkPrn.Value });
var eoiEmployers = new List <AccountLegalEntity>();
foreach (var employer in getTrustedEmployersResponse.Employers)
{
employer.AccountLegalEntityPublicHashedId = _encodingService.Encode(employer.AccountLegalEntityId,
EncodingType.PublicAccountLegalEntityId);
eoiEmployers.Add(employer);
}
var viewModel = new ChooseEmployerViewModel
{
Employers = eoiEmployers
};
return(View(viewModel));
}
public async Task Then_Sets_Owner_Users_On_ViewModel(
ReservationsRouteModel routeModel,
GetAccountUsersResponse usersResponse,
long decodedAccountId,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IEncodingService> mockEncodingService,
EmployerReservationsController controller)
{
usersResponse.AccountUsers.First().Role = "Owner";
mockEncodingService
.Setup(service => service.Decode(
routeModel.EmployerAccountId,
EncodingType.AccountId))
.Returns(decodedAccountId);
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetAccountUsersQuery>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(usersResponse);
var result = await controller.TransactorSignAgreement(routeModel) as ViewResult;
var model = result.Model as SignAgreementViewModel;
model.OwnersOfThisAccount.Should().BeEquivalentTo(usersResponse.AccountUsers
.Where(user => user.Role.Equals(EmployerUserRole.Owner.ToString(), StringComparison.InvariantCultureIgnoreCase))
.OrderBy(user => user.Name)
.Select(user => (EmployerAccountUserViewModel)user));
}
public async Task And_GlobalRule_Is_In_Place_Then_The_Funding_Paused_View_Is_Shown_For_Employer(
ReservationsRouteModel routeModel,
SelectReservationViewModel viewModel,
GetLegalEntitiesResponse employersResponse,
string cohortDetailsUrl,
long expectedAccountId,
[Frozen] Mock <IExternalUrlHelper> mockUrlHelper,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IEncodingService> encodingService,
SelectReservationsController controller)
{
routeModel.UkPrn = null;
viewModel.SelectedReservationId = Guid.Parse(Guid.Empty.ToString().Replace("0", "9"));
routeModel.Id = Guid.Empty;
encodingService.Setup(x => x.Decode(routeModel.EmployerAccountId, EncodingType.AccountId)).Returns(expectedAccountId);
var matchedEmployer = employersResponse.AccountLegalEntities.First();
routeModel.AccountLegalEntityPublicHashedId = matchedEmployer.AccountLegalEntityPublicHashedId;
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetLegalEntitiesQuery>(c => c.AccountId.Equals(expectedAccountId)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(employersResponse);
mockMediator.Setup(x => x.Send(It.IsAny <CacheReservationEmployerCommand>(), It.IsAny <CancellationToken>()))
.ThrowsAsync(new GlobalReservationRuleException(viewModel.AccountId));
//Act
var result = await controller.PostSelectReservation(routeModel, viewModel) as ViewResult;
//Assert
result.ViewName.Should().Be("EmployerFundingPaused");
}
public async Task <IActionResult> TransactorSignAgreement(ReservationsRouteModel routeModel)
{
try
{
var decodedAccountId = _encodingService.Decode(
routeModel.EmployerAccountId,
EncodingType.AccountId);
var users = await _mediator.Send(new GetAccountUsersQuery
{
AccountId = decodedAccountId
});
var owners = users.AccountUsers
.Where(user => user.Role.Equals(EmployerUserRole.Owner.ToString(), StringComparison.InvariantCultureIgnoreCase))
.OrderBy(user => user.Name)
.Select(user => (EmployerAccountUserViewModel)user);
var model = new SignAgreementViewModel
{
BackRouteName = routeModel.PreviousPage,
OwnersOfThisAccount = owners,
IsUrl = routeModel.IsFromSelect.HasValue && routeModel.IsFromSelect.Value
};
return(View("TransactorSignAgreement", model));
}
catch (Exception e)
{
_logger.LogError(e, "Error attempting to show the transactor sign agreement page.");
return(RedirectToRoute(RouteNames.Error500));
}
}
public async Task And_Provider_Has_No_Create_Permission_Then_NoPermissions_View_Is_Shown_With_The_Back_Link_Going_To_Cohort_Details(
ReservationsRouteModel routeModel,
SelectReservationViewModel viewModel,
GetTrustedEmployersResponse employersResponse,
string cohortDetailsUrl,
[Frozen] Mock <IExternalUrlHelper> mockUrlHelper,
[Frozen] Mock <IMediator> mockMediator,
SelectReservationsController controller)
{
var matchedEmployer = employersResponse.Employers.First();
routeModel.AccountLegalEntityPublicHashedId = matchedEmployer.AccountLegalEntityPublicHashedId;
viewModel.SelectedReservationId = Guid.Parse(Guid.Empty.ToString().Replace("0", "9"));
routeModel.Id = Guid.Empty;
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetTrustedEmployersQuery>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(employersResponse);
mockMediator.Setup(x => x.Send(It.IsAny <CacheReservationEmployerCommand>(), It.IsAny <CancellationToken>()))
.ThrowsAsync(new ProviderNotAuthorisedException(viewModel.AccountId, routeModel.UkPrn.Value));
mockUrlHelper
.Setup(helper => helper.GenerateCohortDetailsUrl(routeModel.UkPrn, routeModel.EmployerAccountId,
routeModel.CohortReference, false, It.IsAny <string>()))
.Returns(cohortDetailsUrl);
//Act
var result = await controller.PostSelectReservation(routeModel, viewModel) as ViewResult;
//Assert
result.ViewName.Should().Be("NoPermissions");
result.Model.Should().Be(cohortDetailsUrl);
}
public async Task Then_The_Cached_Search_Is_Loaded_If_From_BackLink(
ReservationsRouteModel routeModel,
ManageReservationsFilterModel filterModel,
SearchReservationsResult searchResult,
ManageReservationsFilterModelBase baseFilterModel,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <ISessionStorageService <ManageReservationsFilterModelBase> > sessionStorageService,
ManageReservationsController controller)
{
routeModel.IsFromManage = true;
mockMediator
.Setup(mediator => mediator.Send(It.Is <SearchReservationsQuery>(c => c.Filter.SearchTerm.Equals(baseFilterModel.SearchTerm)), It.IsAny <CancellationToken>()))
.ReturnsAsync(searchResult);
sessionStorageService.Setup(x => x.Get()).Returns(baseFilterModel);
filterModel.SearchTerm = string.Empty;
await controller.ProviderManage(routeModel, filterModel);
mockMediator.Verify(x => x.Send(It.Is <SearchReservationsQuery>(
c =>
c.Filter.SearchTerm.Equals(baseFilterModel.SearchTerm) &&
c.Filter.SelectedCourse.Equals(baseFilterModel.SelectedCourse) &&
c.Filter.SelectedEmployer.Equals(baseFilterModel.SelectedEmployer) &&
c.Filter.SelectedStartDate.Equals(baseFilterModel.SelectedStartDate) &&
c.Filter.PageNumber.Equals(baseFilterModel.PageNumber)
), It.IsAny <CancellationToken>()), Times.Once);
routeModel.IsFromManage = false;
}
public async Task And_Has_Ukprn_And_ReservationId_And_Not_CohortRef_Then_Redirects_To_AddApprentice_With_Reservation_Details(
ReservationsRouteModel routeModel,
SelectReservationViewModel viewModel,
GetReservationResult reservationResult,
string addApprenticeUrl,
[Frozen] Mock <IExternalUrlHelper> mockUrlHelper,
[Frozen] Mock <IMediator> mockMediator,
SelectReservationsController controller)
{
routeModel.CohortReference = string.Empty;
viewModel.CohortReference = string.Empty;
mockMediator.Setup(x => x.Send(It.Is <GetReservationQuery>(c => c.Id.Equals(viewModel.SelectedReservationId)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(reservationResult);
mockUrlHelper
.Setup(helper => helper.GenerateAddApprenticeUrl(viewModel.SelectedReservationId.Value,
routeModel.AccountLegalEntityPublicHashedId, reservationResult.Course.Id, routeModel.UkPrn.Value,
reservationResult.StartDate, viewModel.CohortReference, routeModel.EmployerAccountId,
true, string.Empty, viewModel.JourneyData))
.Returns(addApprenticeUrl);
var result = await controller.PostSelectReservation(routeModel, viewModel) as RedirectResult;
result.Url.Should().Be(addApprenticeUrl);
}
public async Task Then_It_Returns_The_Trusted_Employers(
string accountLegalEntityPublicHashedId,
ReservationsRouteModel routeModel,
List <AccountLegalEntity> expectedEmployers,
[Frozen] Mock <IEncodingService> encodingService,
[Frozen] Mock <IMediator> mockMediator,
ProviderReservationsController controller)
{
encodingService.Setup(x => x.Encode(It.IsAny <long>(), EncodingType.PublicAccountLegalEntityId))
.Returns(accountLegalEntityPublicHashedId);
expectedEmployers = expectedEmployers.Select(arg => new AccountLegalEntity
{
AccountLegalEntityPublicHashedId = arg.AccountLegalEntityPublicHashedId,
AccountId = arg.AccountId,
IsLevy = false
}).ToList();
mockMediator
.Setup(service => service.Send(It.IsAny <GetTrustedEmployersQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetTrustedEmployersResponse {
Employers = expectedEmployers
});
var result = await controller.ChooseEmployer(routeModel);
var viewModel = result.Should().BeOfType <ViewResult>()
.Which.Model.Should().BeOfType <ChooseEmployerViewModel>()
.Subject;
viewModel.Employers.Should()
.BeEquivalentTo(expectedEmployers, options => options.Excluding(c => c.AccountLegalEntityPublicHashedId));
viewModel.Employers.All(c => c.AccountLegalEntityPublicHashedId.Equals(accountLegalEntityPublicHashedId))
.Should().BeTrue();
}
public async Task And_No_Option_Has_Been_Selected_And_ReservationId_Is_Null_Then_The_Validation_Errors_Are_Returned_To_The_User_And_ViewModel_Recreated(
ReservationsRouteModel routeModel,
GetAvailableReservationsResult availableReservationsResult,
SelectReservationViewModel viewModel,
string cohortDetailsUrl,
[Frozen] Mock <IExternalUrlHelper> mockUrlHelper,
[Frozen] Mock <IMediator> mockMediator,
SelectReservationsController controller)
{
viewModel.SelectedReservationId = null;
mockMediator
.Setup(x => x.Send(It.Is <GetAvailableReservationsQuery>(c => c.AccountId.Equals(viewModel.AccountId)),
It.IsAny <CancellationToken>())).ReturnsAsync(availableReservationsResult);
mockUrlHelper
.Setup(helper => helper.GenerateUrl(
It.Is <UrlParameters>(parameters =>
parameters.Id == routeModel.UkPrn.ToString() &&
parameters.Controller == $"apprentices/{viewModel.CohortReference}" &&
parameters.Action == "details")))
.Returns(cohortDetailsUrl);
var result = await controller.PostSelectReservation(routeModel, viewModel) as ViewResult;
result.ViewName.Should().Be("Select");
var actualModel = result.Model as SelectReservationViewModel;
actualModel.Should().NotBeNull();
actualModel.AvailableReservations.Should().BeEquivalentTo(availableReservationsResult.Reservations.Select(c => new AvailableReservationViewModel(c)));
}
public async Task Then_The_BackLink_Is_Set_To_Return_To_SelectLegalEntityView(
ICollection <Course> courses,
[Frozen] Mock <IMediator> mockMediator,
ReservationsRouteModel routeModel,
EmployerReservationsController controller,
PostSelectCourseViewModel postSelectCourseViewModel)
{
//Arrange
_cachedReservationResult.CohortRef = "";
_cachedReservationResult.EmployerHasSingleLegalEntity = false;
routeModel.CohortReference = "";
routeModel.FromReview = false;
_mediator.Setup(mediator => mediator.Send(It.IsAny <CacheReservationCourseCommand>(), It.IsAny <CancellationToken>()))
.ThrowsAsync(new ValidationException(new ValidationResult("Failed", new List <string> {
"Course|The Course field is not valid."
}), null, null));
postSelectCourseViewModel.SelectedCourseId = _course.Id;
//Act
var result = await _controller.PostSelectCourse(routeModel, postSelectCourseViewModel) as ViewResult;
var viewModel = result?.Model as EmployerSelectCourseViewModel;
Assert.IsNotNull(viewModel);
Assert.AreEqual(RouteNames.EmployerSelectLegalEntity, viewModel.BackLink);
Assert.AreEqual(routeModel.CohortReference, viewModel.CohortReference);
}
public async Task Then_Redirects_To_The_Confirmation_Employer_View_With_ProviderId_When_Part_Of_Empty_Cohort(
ReservationsRouteModel routeModel,
PostReviewViewModel viewModel,
CreateReservationResult createReservationResult,
[Frozen] Mock <IMediator> mockMediator,
ReservationsController controller)
{
createReservationResult.IsEmptyCohortFromSelect = true;
routeModel.UkPrn = null;
var claim = new Claim(EmployerClaims.IdamsUserIdClaimTypeIdentifier, Guid.NewGuid().ToString());
controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { claim }));
viewModel.Reserve = true;
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <CreateReservationCommand>(), CancellationToken.None))
.ReturnsAsync(createReservationResult);
var result = await controller.PostReview(routeModel, viewModel) as RedirectToRouteResult;
result.Should().NotBeNull($"result was not a {typeof(RedirectToRouteResult)}");
result.RouteName.Should().Be(RouteNames.EmployerCompleted);
result.RouteValues.Should().ContainKey("id").WhichValue.Should().NotBe(Guid.Empty);
result.RouteValues.Should().ContainKey("cohortReference")
.WhichValue.Should().Be(createReservationResult.CohortRef);
result.RouteValues.Should().ContainKey("accountLegalEntityPublicHashedId")
.WhichValue.Should().Be(createReservationResult.AccountLegalEntityPublicHashedId);
result.RouteValues.Should().ContainKey("providerId")
.WhichValue.Should().Be(createReservationResult.ProviderId);
}
public async Task Then_If_The_Id_Is_Null_Or_Empty_Then_The_RouteModel_Is_Checked_For_The_Id(
string accountLegalEntityId,
string dashboardUrl,
GetAccountLegalEntityResult result,
[Frozen] Mock <IExternalUrlHelper> externalUrlHelper,
[Frozen] Mock <IMediator> mediator,
ReservationsRouteModel routeModel,
ProviderReservationsController controller,
EmployerAgreementNotSignedViewModel viewModel)
{
//Arrange
result.LegalEntity.AgreementSigned = false;
externalUrlHelper.Setup(x => x.GenerateDashboardUrl(null)).Returns(dashboardUrl);
mediator.Setup(x =>
x.Send(
It.Is <GetAccountLegalEntityQuery>(c =>
c.AccountLegalEntityPublicHashedId.Equals(accountLegalEntityId)),
It.IsAny <CancellationToken>())).ReturnsAsync(result);
routeModel.AccountLegalEntityPublicHashedId = accountLegalEntityId;
//Act
var actual = await controller.EmployerAgreementNotSigned(routeModel, "");
//Assert
Assert.IsNotNull(actual);
var viewResult = actual as ViewResult;
Assert.IsNotNull(viewResult);
var model = viewResult.Model as EmployerAgreementNotSignedViewModel;
Assert.IsNotNull(model);
model.AccountName.Should().Be(result.LegalEntity.AccountLegalEntityName);
model.DashboardUrl.Should().Be(dashboardUrl);
mediator.Verify(x => x.Send(It.IsAny <GetAccountLegalEntityQuery>(), It.IsAny <CancellationToken>()), Times.Once);
}
public async Task Then_Back_Link_Set_To_Dashboard_If_Not_From_Manage()
{
//Arrange
var routeModel = new ReservationsRouteModel
{
UkPrn = 1,
IsFromManage = false
};
//act
var view = await _controller.Index(routeModel) as ViewResult;
var viewModel = view?.Model as FundingRestrictionNotificationViewModel;
//assert
Assert.IsNotNull(view);
Assert.IsNotNull(viewModel);
Assert.AreEqual(view.ViewName, "FundingRestrictionNotification");
Assert.AreEqual(_expectedRule.Id, viewModel.RuleId);
Assert.AreEqual(RuleType.GlobalRule, viewModel.TypeOfRule);
Assert.AreEqual(_expectedRule.ActiveFrom, viewModel.RestrictionStartDate);
Assert.AreEqual(true, viewModel.IsProvider);
Assert.AreEqual(ExpectedDashboardUrl, viewModel.BackLink);
Assert.AreEqual(RouteNames.ProviderSaveRuleNotificationChoiceNoReservation, viewModel.PostRouteName);
}
public async Task And_Only_One_Legal_Entity_Then_Adds_Legal_Entity_To_Reservation_And_Redirects_To_Course_Selection(
ReservationsRouteModel routeModel,
AccountLegalEntity accountLegalEntity,
[Frozen] Mock <IMediator> mockMediator,
EmployerReservationsController controller)
{
routeModel.Id = null;
var getLegalEntitiesResponse = new GetLegalEntitiesResponse
{
AccountLegalEntities = new List <AccountLegalEntity> {
accountLegalEntity
}
};
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetLegalEntitiesQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(getLegalEntitiesResponse);
var result = await controller.SelectLegalEntity(routeModel) as RedirectToRouteResult;
result.RouteName.Should().Be(RouteNames.EmployerSelectCourse);
mockMediator.Verify(mediator => mediator.Send(
It.Is <CacheReservationEmployerCommand>(command =>
command.Id != Guid.Empty &&
command.AccountId == accountLegalEntity.AccountId &&
command.AccountLegalEntityId == accountLegalEntity.AccountLegalEntityId &&
command.AccountLegalEntityName == accountLegalEntity.AccountLegalEntityName &&
command.AccountLegalEntityPublicHashedId == accountLegalEntity.AccountLegalEntityPublicHashedId &&
command.EmployerHasSingleLegalEntity),
It.IsAny <CancellationToken>()),
Times.Once);
}
public async Task Then_It_Filters_NonLevy_NonEoi_Employers(
ReservationsRouteModel routeModel,
List <Employer> expectedEmployers,
[Frozen] Mock <IMediator> mockMediator,
ProviderReservationsController controller)
{
var getLegalEntitiesResponse = new GetLegalEntitiesResponse
{
AccountLegalEntities = expectedEmployers.Select(arg => new AccountLegalEntity
{
AccountLegalEntityPublicHashedId = arg.AccountLegalEntityPublicHashedId,
AccountId = arg.AccountId,
IsLevy = false,
AgreementType = AgreementType.Levy
})
};
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetLegalEntitiesQuery>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(getLegalEntitiesResponse);
mockMediator
.Setup(service => service.Send(It.IsAny <GetTrustedEmployersQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetTrustedEmployersResponse {
Employers = expectedEmployers
});
var result = await controller.ChooseEmployer(routeModel) as ViewResult;
var viewModel = result.Model as ChooseEmployerViewModel;
viewModel.Employers.Count().Should().Be(0);
}
public void Then_The_Model_Is_Constructed_With_Correct_Route_Names_Using_Other_Constructor(uint?ukPrn)
{
//Arrange
var startDate = new TrainingDateModel {
StartDate = DateTime.Now
};
var reservationsRouteModel = new ReservationsRouteModel
{
AccountLegalEntityPublicHashedId = AccountLegalEntityPublicHashedId,
UkPrn = ukPrn,
Id = new Guid(),
EmployerAccountId = "123FDS",
FromReview = true
};
var postReviewViewModel = new PostReviewViewModel
{
AccountLegalEntityName = AccountLegalEntityName,
AccountLegalEntityPublicHashedId = AccountLegalEntityPublicHashedId,
CourseDescription = CourseDescription,
TrainingDate = startDate,
Reserve = ExpectedReserve
};
//Act
var actual = new ReviewViewModel(reservationsRouteModel, postReviewViewModel);
//Assert
AssertAllProperties(actual, ukPrn, startDate);
Assert.AreEqual(ExpectedReserve, actual.Reserve);
}
public async Task <IActionResult> Delete(ReservationsRouteModel routeModel)
{
var isProvider = routeModel.UkPrn.HasValue;
try
{
if (!routeModel.Id.HasValue)
{
_logger.LogInformation($"Reservation ID must be in URL, parameter [{nameof(routeModel.Id)}]");
var manageRoute = isProvider ? RouteNames.ProviderManage : RouteNames.EmployerManage;
return(RedirectToRoute(manageRoute, routeModel));
}
var query = new GetReservationQuery
{
Id = routeModel.Id.Value,
UkPrn = routeModel.UkPrn.GetValueOrDefault()
};
var queryResult = await _mediator.Send(query);
var viewName = isProvider ? ViewNames.ProviderDelete : ViewNames.EmployerDelete;
return(View(viewName, new DeleteViewModel(queryResult)));
}
catch (Exception e)
{
_logger.LogError(e, "Error preparing for the delete view");
throw;
}
}
