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 And_GlobalRule_Is_In_Place_Then_The_Funding_Paused_View_Is_Shown_For_Provider(
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 GlobalReservationRuleException(viewModel.AccountId));
//Act
var result = await controller.PostSelectReservation(routeModel, viewModel) as ViewResult;
//Assert
result.ViewName.Should().Be("ProviderFundingPaused");
}
public async Task And_Has_Ukprn_Then_Gets_List_Of_Reservations_For_All_Trusted_Employer_Accounts(
ReservationsRouteModel routeModel,
GetTrustedEmployersResponse getTrustedEmployersResponse,
GetReservationsResult getReservationsResult,
[Frozen] Mock <IMediator> mockMediator,
ManageReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetTrustedEmployersQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(getTrustedEmployersResponse);
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetReservationsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(getReservationsResult);
await controller.Manage(routeModel);
mockMediator.Verify(mediator =>
mediator.Send(
It.Is <GetTrustedEmployersQuery>(query => query.UkPrn == routeModel.UkPrn),
It.IsAny <CancellationToken>()),
Times.Once);
foreach (var employer in getTrustedEmployersResponse.Employers)
{
mockMediator.Verify(mediator =>
mediator.Send(
It.Is <GetReservationsQuery>(query => query.AccountId == employer.AccountId),
It.IsAny <CancellationToken>()),
Times.Once);
}
}
public async Task Add_Apprentice_Url_UkPrn_Will_Be_Populated_From_RouteModel_Reservation(
ReservationsRouteModel routeModel,
GetTrustedEmployersResponse getTrustedEmployersResponse,
Reservation reservation,
string hashedId,
string expectedUrl,
[Frozen] Mock <IEncodingService> mockEncodingService,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IExternalUrlHelper> mockUrlHelper,
ManageReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetTrustedEmployersQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(getTrustedEmployersResponse);
reservation.ProviderId = null;
reservation.IsExpired = false;
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetReservationsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetReservationsResult
{
Reservations = new [] { reservation }
});
mockEncodingService
.Setup(service => service.Encode(It.IsAny <long>(), EncodingType.PublicAccountLegalEntityId))
.Returns(hashedId);
mockUrlHelper.Setup(h => h.GenerateAddApprenticeUrl(
reservation.Id,
hashedId,
reservation.Course.Id,
routeModel.UkPrn,
reservation.StartDate,
routeModel.CohortReference,
routeModel.EmployerAccountId,
false,
"",
""))
.Returns(expectedUrl);
var result = await controller.EmployerManage(routeModel) as ViewResult;
var viewModel = result?.Model as ManageViewModel;
viewModel.Should().NotBeNull();
Assert.IsTrue(viewModel.Reservations.All(c => c.ApprenticeUrl.Equals(expectedUrl)));
}
public async Task And_Has_UkPrn_And_New_Reservation_Then_Redirects_To_ProviderApprenticeshipTraining_And_The_Cached_Reservation_Is_Created(
ReservationsRouteModel routeModel,
SelectReservationViewModel viewModel,
GetTrustedEmployersResponse employersResponse,
[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(m =>
m.Send(It.IsAny <GetProviderCacheReservationCommandQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetProviderCacheReservationCommandResponse
{
Command = new CacheReservationEmployerCommand
{
Id = Guid.NewGuid(),
AccountId = matchedEmployer.AccountId,
AccountLegalEntityPublicHashedId = matchedEmployer.AccountLegalEntityPublicHashedId,
AccountLegalEntityId = matchedEmployer.AccountLegalEntityId,
AccountLegalEntityName = matchedEmployer.AccountLegalEntityName,
AccountName = matchedEmployer.AccountName,
CohortRef = viewModel.CohortReference,
UkPrn = routeModel.UkPrn.Value
}
});
var result = await controller.PostSelectReservation(routeModel, viewModel) as RedirectToRouteResult;
result?.RouteName.Should().NotBeNull();
result.RouteName.Should().Be(RouteNames.ProviderApprenticeshipTrainingRuleCheck);
result.RouteValues["ukPrn"].Should().Be(routeModel.UkPrn);
result.RouteValues["id"].Should().NotBe(Guid.Empty);
mockMediator.Verify(x =>
x.Send(It.Is <CacheReservationEmployerCommand>(
c =>
c.CohortRef.Equals(viewModel.CohortReference) &&
c.AccountId.Equals(matchedEmployer.AccountId) &&
c.AccountLegalEntityName.Equals(matchedEmployer.AccountLegalEntityName) &&
c.AccountLegalEntityPublicHashedId.Equals(matchedEmployer.AccountLegalEntityPublicHashedId) &&
c.AccountName.Equals(matchedEmployer.AccountName) &&
c.UkPrn.Equals(routeModel.UkPrn) &&
!c.Id.Equals(Guid.Empty) &&
c.AccountLegalEntityId.Equals(matchedEmployer.AccountLegalEntityId))
, It.IsAny <CancellationToken>()), Times.Once);
}
public async Task And_Has_Ukprn_Then_Returns_List_Of_Reservations_For_All_Trusted_Employer_Accounts(
[Frozen] ReservationsRouteModel routeModel,
GetTrustedEmployersResponse getTrustedEmployersResponse,
[ReservationsFromThisProvider] GetReservationsResult getReservationsResult1,
[ReservationsFromThisProvider] GetReservationsResult getReservationsResult2,
[ReservationsFromThisProvider] GetReservationsResult getReservationsResult3,
string hashedId,
string homeLink,
[Frozen] ReservationsWebConfiguration config,
[Frozen] Mock <IExternalUrlHelper> externalUrlHelper,
[Frozen] Mock <IEncodingService> mockEncodingService,
[Frozen] Mock <IMediator> mockMediator,
ManageReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetTrustedEmployersQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(getTrustedEmployersResponse);
mockMediator
.SetupSequence(mediator =>
mediator.Send(It.IsAny <GetReservationsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(getReservationsResult1)
.ReturnsAsync(getReservationsResult2)
.ReturnsAsync(getReservationsResult3);
mockEncodingService
.Setup(service => service.Encode(It.IsAny <long>(), EncodingType.PublicAccountLegalEntityId))
.Returns(hashedId);
externalUrlHelper
.Setup(x => x.GenerateDashboardUrl(routeModel.EmployerAccountId)).Returns(homeLink);
var expectedReservations = new List <ReservationViewModel>();
expectedReservations.AddRange(getReservationsResult1.Reservations.Select(reservation =>
new ReservationViewModel(reservation, config.ApprenticeUrl, routeModel.UkPrn)));
expectedReservations.AddRange(getReservationsResult2.Reservations.Select(reservation =>
new ReservationViewModel(reservation, config.ApprenticeUrl, routeModel.UkPrn)));
expectedReservations.AddRange(getReservationsResult3.Reservations.Select(reservation =>
new ReservationViewModel(reservation, config.ApprenticeUrl, routeModel.UkPrn)));
var result = await controller.Manage(routeModel) as ViewResult;
result.Should().NotBeNull();
result.ViewName.Should().Be(ViewNames.ProviderManage);
var viewModel = result.Model as ManageViewModel;
viewModel.Should().NotBeNull();
viewModel.BackLink.Should().Be(homeLink);
viewModel.Reservations.Should().BeEquivalentTo(expectedReservations,
options => options.ExcludingMissingMembers().ExcludingFields().Excluding(c => c.ApprenticeUrl));
}
public async Task And_Provider_Is_Not_Trusted_For_Account_Legal_Entity_Then_Mark_As_Not_Authorised(
CacheReservationEmployerCommand command,
[Frozen] Mock <IMediator> mediator,
[Frozen] GetTrustedEmployersResponse response,
CacheReservationEmployerCommandValidator validator)
{
SetupAccountLegalEntityAsNonLevy(mediator);
command.IsEmptyCohortFromSelect = false;
mediator.Setup(m => m.Send(It.IsAny <GetTrustedEmployersQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
var result = await validator.ValidateAsync(command);
result.IsValid().Should().BeTrue();
result.FailedAuthorisationValidation.Should().BeTrue();
}
public async Task And_Provider_Is_Supplied_For_Empty_Cohort_Then_It_Is_Not_Validated_For_Account_Legal_Entity(
CacheReservationEmployerCommand command,
[Frozen] Mock <IMediator> mediator,
[Frozen] GetTrustedEmployersResponse response,
CacheReservationEmployerCommandValidator validator)
{
SetupAccountLegalEntityAsEoi(mediator);
command.IsEmptyCohortFromSelect = true;
mediator.Setup(m => m.Send(It.IsAny <GetTrustedEmployersQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
var result = await validator.ValidateAsync(command);
result.IsValid().Should().BeTrue();
result.FailedAuthorisationValidation.Should().BeFalse();
mediator.Verify(x => x.Send(It.IsAny <GetTrustedEmployersQuery>(), It.IsAny <CancellationToken>()), Times.Never);
}
public async Task And_Has_Ukprn_And_Reservation_From_Different_Provider_Then_Not_Deletable(
[Frozen] ReservationsRouteModel routeModel,
GetTrustedEmployersResponse getTrustedEmployersResponse,
GetReservationsResult getReservationResultDifferentProvider,
[ReservationsFromThisProvider] GetReservationsResult getReservationsResult1,
[ReservationsFromThisProvider] GetReservationsResult getReservationsResult2,
string hashedId,
[Frozen] Mock <IEncodingService> mockEncodingService,
[Frozen] Mock <IMediator> mockMediator,
ManageReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetTrustedEmployersQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(getTrustedEmployersResponse);
mockMediator
.SetupSequence(mediator =>
mediator.Send(It.IsAny <GetReservationsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(getReservationsResult1)
.ReturnsAsync(getReservationsResult2)
.ReturnsAsync(getReservationResultDifferentProvider);
mockEncodingService
.Setup(service => service.Encode(It.IsAny <long>(), EncodingType.PublicAccountLegalEntityId))
.Returns(hashedId);
var result = await controller.Manage(routeModel) as ViewResult;
var viewModel = result.Model as ManageViewModel;
var nonDeletableReservationIds = getReservationResultDifferentProvider.Reservations
.Select(reservation => reservation.Id);
viewModel.Reservations
.Where(model => nonDeletableReservationIds.Contains(model.Id))
.Select(model => model.CanProviderDeleteReservation)
.Should().AllBeEquivalentTo(false);
viewModel.Reservations
.Where(model => !nonDeletableReservationIds.Contains(model.Id))
.Select(model => model.CanProviderDeleteReservation)
.Should().AllBeEquivalentTo(true);
}
public void Arrange()
{
_mediator = new Mock <IMediator>();
_validator = new Mock <IValidator <GetProviderCacheReservationCommandQuery> >();
_query = new GetProviderCacheReservationCommandQuery
{
UkPrn = 12,
AccountLegalEntityPublicHashedId = "ABC123",
CohortRef = "1234"
};
_handler = new GetProviderCacheReservationCommandQueryHandler(_mediator.Object, _validator.Object);
_expectedEmployer = new AccountLegalEntity
{
AccountId = 1,
AccountLegalEntityPublicHashedId = _query.AccountLegalEntityPublicHashedId,
AccountLegalEntityName = "Test Employer",
AccountLegalEntityId = 123,
AccountName = "Test Account",
AccountPublicHashedId = "DEF123"
};
_expectedAccountLegalEntity = new AccountLegalEntity
{
AccountId = 1,
AccountLegalEntityPublicHashedId = _query.AccountLegalEntityPublicHashedId,
AccountLegalEntityName = "Test Employer",
AccountLegalEntityId = 123,
LegalEntityId = 456,
ReservationLimit = 3
};
_expectedCohort = new Cohort()
{
CohortId = 123,
AccountLegalEntityId = _expectedAccountLegalEntity.AccountLegalEntityId,
LegalEntityName = _expectedAccountLegalEntity.AccountLegalEntityName,
ProviderName = "Test Provider",
IsFundedByTransfer = false,
WithParty = CohortParty.Provider
};
_getTrustedEmployersResponse = new GetTrustedEmployersResponse
{
Employers = new [] { _expectedEmployer }
};
_getAccountLegalEntityResponse = new GetAccountLegalEntityResult
{
LegalEntity = _expectedAccountLegalEntity
};
_mediator.Setup(mediator => mediator.Send(
It.IsAny <GetTrustedEmployersQuery>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(_getTrustedEmployersResponse);
_mediator.Setup(mediator => mediator.Send(
It.IsAny <GetAccountLegalEntityQuery>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(_getAccountLegalEntityResponse);
_mediator.Setup(m => m.Send(
It.IsAny <GetCohortQuery>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetCohortResponse {
Cohort = _expectedCohort
});
_validator.Setup(v => v.ValidateAsync(_query))
.ReturnsAsync(new ValidationResult {
ValidationDictionary = new Dictionary <string, string>()
});
}
