public async Task AndIsANonLevyEmployer_ThenContinuesToAction(
[Frozen] ServiceParameters serviceParameters,
[Frozen] Mock <IMediator> mockMediator,
GetLegalEntitiesResponse legalEntitiesResponse,
IEnumerable <AccountLegalEntity> legalEntities,
string employerAccountId,
long decodedId,
[Frozen] Mock <IEncodingService> mockEncodingService,
[ArrangeActionContext] ActionExecutingContext context,
[Frozen] Mock <ActionExecutionDelegate> nextMethod,
LevyNotPermittedFilter filter)
{
//Arrange
serviceParameters.AuthenticationType = AuthenticationType.Employer;
legalEntitiesResponse.AccountLegalEntities = legalEntities;
context.RouteData.Values.Add("employerAccountId", employerAccountId);
foreach (var legalEntity in legalEntitiesResponse.AccountLegalEntities)
{
legalEntity.IsLevy = false;
}
mockEncodingService
.Setup(x => x.TryDecode(employerAccountId, EncodingType.AccountId, out decodedId))
.Returns(true);
mockMediator
.Setup(x => x.Send(It.Is <GetLegalEntitiesQuery>(y => y.AccountId == decodedId), It.IsAny <CancellationToken>()))
.ReturnsAsync(legalEntitiesResponse);
//Act
await filter.OnActionExecutionAsync(context, nextMethod.Object);
//Assert
Assert.Null(context.Result);
nextMethod.Verify(x => x(), Times.Once);
}
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 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 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 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);
}
And_User_Has_Owner_Role_And_Chosen_Legal_Entity_Has_Not_Signed_Agreement_Then_Redirect_To_Owner_Sign_Route(
ReservationsRouteModel routeModel,
AccountLegalEntity accountLegalEntity,
GetLegalEntitiesResponse getLegalEntitiesResponse,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IUserClaimsService> mockClaimsService,
EmployerReservationsController controller)
{
getLegalEntitiesResponse.AccountLegalEntities =
new List <AccountLegalEntity>
{
accountLegalEntity
};
accountLegalEntity.AgreementSigned = false;
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(true);
var result = await controller.SelectLegalEntity(routeModel) as RedirectToRouteResult;
result.RouteName.Should().Be(RouteNames.EmployerOwnerSignAgreement);
result.RouteValues[nameof(ReservationsRouteModel.PreviousPage)].Should().Be(RouteNames.EmployerIndex);
}
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 async Task Then_Caches_New_Reservation(
ReservationsRouteModel routeModel,
ConfirmLegalEntityViewModel viewModel,
GetLegalEntitiesResponse getLegalEntitiesResponse,
long decodedAccountId,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IEncodingService> mockEncodingService,
EmployerReservationsController controller)
{
var firstLegalEntity = getLegalEntitiesResponse.AccountLegalEntities.First();
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 != Guid.Empty &&
command.AccountId == firstLegalEntity.AccountId &&
command.AccountLegalEntityId == firstLegalEntity.AccountLegalEntityId &&
command.AccountLegalEntityName == firstLegalEntity.AccountLegalEntityName &&
command.AccountLegalEntityPublicHashedId == firstLegalEntity.AccountLegalEntityPublicHashedId &&
!command.EmployerHasSingleLegalEntity),
It.IsAny <CancellationToken>()),
Times.Once);
}
public async Task Then_error_returned_for_non_existing_account()
{
// Arrange
const long accountId = 7;
var expected = new GetLegalEntitiesResponse();
_queryDispatcherMock.Setup(x => x.Send <GetLegalEntitiesRequest, GetLegalEntitiesResponse>(
It.Is <GetLegalEntitiesRequest>(r => r.AccountId == accountId)))
.ReturnsAsync(expected);
// Act
var actual = await _sut.GetLegalEntities(accountId) as NotFoundResult;
// Assert
actual.Should().NotBeNull();
}
public async Task And_Employer_Is_Non_Levy_And_Not_EOI_Then_Show_EOI_Holding_View(
[ArrangeActionContext] ActionExecutingContext context,
string employerAccountId,
long decodedEmployerAccountId,
string homeUrl,
GetLegalEntitiesResponse legalEntitiesResponse,
Mock <ActionExecutionDelegate> mockNext,
[Frozen] ServiceParameters serviceParameters,
[Frozen] Mock <IEncodingService> mockEncodingService,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IExternalUrlHelper> mockUrlHelper,
NonEoiNotPermittedFilterAttribute filter)
{
serviceParameters.AuthenticationType = AuthenticationType.Employer;
context.HttpContext = new DefaultHttpContext();
context.RouteData.Values.Add("employerAccountId", employerAccountId);
foreach (var accountLegalEntity in legalEntitiesResponse.AccountLegalEntities)
{
accountLegalEntity.IsLevy = false;
accountLegalEntity.AgreementType = AgreementType.Levy;
}
mockEncodingService
.Setup(service => service.Decode(
context.RouteData.Values["employerAccountId"].ToString(),
EncodingType.AccountId))
.Returns(decodedEmployerAccountId);
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetLegalEntitiesQuery>(query => query.AccountId == decodedEmployerAccountId),
It.IsAny <CancellationToken>()))
.ReturnsAsync(legalEntitiesResponse);
mockUrlHelper
.Setup(helper => helper.GenerateDashboardUrl(employerAccountId))
.Returns(homeUrl);
await filter.OnActionExecutionAsync(context, mockNext.Object);
mockNext.Verify(next => next(), Times.Never());
var result = context.Result as ViewResult;
result.ViewName.Should().Be("NonEoiHolding");
var model = result.Model as NonEoiHoldingViewModel;
model.HomeLink.Should().Be(homeUrl);
}
public async Task Then_data_is_fetched_via_data_repository()
{
//Arrange
var query = _fixture.Create <GetLegalEntitiesRequest>();
var data = _fixture.CreateMany <LegalEntityDto>().ToList();
var expected = new GetLegalEntitiesResponse
{
LegalEntities = data
};
_repositoryMock.Setup(x => x.GetList(dto => dto.AccountId == query.AccountId)).ReturnsAsync(data);
//Act
var result = await _sut.Handle(query, CancellationToken.None);
//Assert
result.Should().BeEquivalentTo(expected);
}
public async Task Then_If_There_Is_A_Reservation_Created_The_Entity_Is_Taken_From_The_Cache(
ReservationsRouteModel routeModel,
GetLegalEntitiesResponse getLegalEntitiesResponse,
[Frozen] Mock <IMediator> mockMediator,
EmployerReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetLegalEntitiesQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(getLegalEntitiesResponse);
var result = await controller.SelectLegalEntity(routeModel) as ViewResult;
result.Should().NotBeNull();
mockMediator.Verify(x => x.Send(It.Is <GetCachedReservationQuery>(c => c.Id.Equals(routeModel.Id)), It.IsAny <CancellationToken>()), Times.Once);
var viewModel = result?.Model.Should().BeOfType <SelectLegalEntityViewModel>().Subject;
viewModel.Should().NotBeNull();
}
public async Task Then_data_is_returned_for_existing_account()
{
// Arrange
const long accountId = 7;
var expected = new GetLegalEntitiesResponse {
LegalEntities = _fixture.CreateMany <LegalEntityDto>()
};
_queryDispatcherMock.Setup(x => x.Send <GetLegalEntitiesRequest, GetLegalEntitiesResponse>(
It.Is <GetLegalEntitiesRequest>(r => r.AccountId == accountId)))
.ReturnsAsync(expected);
// Act
var actual = await _sut.GetLegalEntities(accountId) as OkObjectResult;
// Assert
actual.Should().NotBeNull();
actual.Value.Should().Be(expected.LegalEntities);
}
public async Task Then_Returns_Populated_View_Model(
ReservationsRouteModel routeModel,
GetLegalEntitiesResponse getLegalEntitiesResponse,
[Frozen] Mock <IMediator> mockMediator,
EmployerReservationsController controller)
{
routeModel.Id = null;
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetLegalEntitiesQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(getLegalEntitiesResponse);
var result = await controller.SelectLegalEntity(routeModel) as ViewResult;
result.Should().NotBeNull();
var viewModel = result?.Model.Should().BeOfType <SelectLegalEntityViewModel>().Subject;
viewModel.Should().NotBeNull();
viewModel?.RouteModel.Should().BeEquivalentTo(routeModel);
viewModel?.LegalEntities.Should().BeEquivalentTo(getLegalEntitiesResponse.AccountLegalEntities, options => options.ExcludingMissingMembers());
}
public async Task And_Is_An_Employer_And_New_Reservation_Then_Redirects_To_EmployerApprenticeshipTraining_And_The_Cached_Reservation_Is_Created(
ReservationsRouteModel routeModel,
SelectReservationViewModel viewModel,
long expectedAccountId,
GetLegalEntitiesResponse employersResponse,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IEncodingService> encodingService,
SelectReservationsController controller)
{
viewModel.SelectedReservationId = Guid.Parse(Guid.Empty.ToString().Replace("0", "9"));
routeModel.Id = Guid.Empty;
routeModel.UkPrn = null;
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);
var result = await controller.PostSelectReservation(routeModel, viewModel) as RedirectToRouteResult;
result?.RouteName.Should().NotBeNull();
result.RouteName.Should().Be(RouteNames.EmployerSelectCourseRuleCheck);
result.RouteValues["EmployerAccountId"].Should().Be(routeModel.EmployerAccountId);
result.RouteValues["id"].Should().NotBe(Guid.Empty);
mockMediator.Verify(x =>
x.Send(It.Is <CacheReservationEmployerCommand>(
c =>
c.CohortRef.Equals(viewModel.CohortReference) &&
c.AccountId.Equals(expectedAccountId) &&
c.AccountLegalEntityName.Equals(matchedEmployer.AccountLegalEntityName) &&
c.AccountLegalEntityPublicHashedId.Equals(matchedEmployer.AccountLegalEntityPublicHashedId) &&
!c.Id.Equals(Guid.Empty) &&
c.AccountLegalEntityId.Equals(matchedEmployer.AccountLegalEntityId))
, It.IsAny <CancellationToken>()), Times.Once);
}
public async Task And_NonLevy_And_Not_Eoi_Then_Not_Valid(
CacheReservationEmployerCommand command,
GetLegalEntitiesResponse getLegalEntitiesResponse,
[Frozen] Mock <IFundingRulesService> rulesService,
[Frozen] Mock <IMediator> mockMediator,
CacheReservationEmployerCommandValidator validator)
{
ConfigureRulesServiceWithNoGlobalRules(rulesService);
foreach (var accountLegalEntity in getLegalEntitiesResponse.AccountLegalEntities)
{
accountLegalEntity.IsLevy = false;
accountLegalEntity.AgreementType = AgreementType.Levy;
}
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetLegalEntitiesQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(getLegalEntitiesResponse);
var result = await validator.ValidateAsync(command);
result.IsValid().Should().BeTrue();
result.FailedEoiCheck.Should().BeTrue();
}
public async Task Then_Redirects_To_Select_Course(
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);
var result = await controller.PostSelectLegalEntity(routeModel, viewModel) as RedirectToRouteResult;
result.Should().NotBeNull();
result.RouteName.Should().Be(RouteNames.EmployerSelectCourse);
}
public async Task Then_It_Calls_ProviderPermissions_Service_To_Get_Employers(
ReservationsRouteModel routeModel,
IEnumerable <AccountLegalEntity> expectedEmployers,
GetLegalEntitiesResponse getLegalEntitiesResponse,
[Frozen] Mock <IMediator> mockMediator,
ProviderReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetLegalEntitiesQuery>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(getLegalEntitiesResponse);
mockMediator
.Setup(m => m.Send(It.IsAny <GetTrustedEmployersQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetTrustedEmployersResponse {
Employers = expectedEmployers
});
await controller.ChooseEmployer(routeModel);
mockMediator.Verify(m => m.Send(It.IsAny <GetTrustedEmployersQuery>(), It.IsAny <CancellationToken>()), Times.Once);
}
public async Task Then_Gets_Legal_Entities(
ReservationsRouteModel routeModel,
long decodedAccountId,
GetLegalEntitiesResponse getLegalEntitiesResponse,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IEncodingService> mockEncodingService,
EmployerReservationsController controller)
{
routeModel.Id = null;
mockEncodingService
.Setup(service => service.Decode(routeModel.EmployerAccountId, EncodingType.AccountId))
.Returns(decodedAccountId);
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetLegalEntitiesQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(getLegalEntitiesResponse);
await controller.SelectLegalEntity(routeModel);
mockMediator.Verify(mediator => mediator.Send(
It.Is <GetLegalEntitiesQuery>(query => query.AccountId == decodedAccountId),
It.IsAny <CancellationToken>()),
Times.Once);
}
public async Task And_Employer_Is_Non_Levy_And_Is_EOI_Then_Executes_Action(
[ArrangeActionContext] ActionExecutingContext context,
string employerAccountId,
long decodedEmployerAccountId,
GetLegalEntitiesResponse legalEntitiesResponse,
Mock <ActionExecutionDelegate> mockNext,
[Frozen] ServiceParameters serviceParameters,
[Frozen] Mock <IEncodingService> mockEncodingService,
[Frozen] Mock <IMediator> mockMediator,
NonEoiNotPermittedFilterAttribute filter)
{
context.Result = null;
context.HttpContext = new DefaultHttpContext();
serviceParameters.AuthenticationType = AuthenticationType.Employer;
context.RouteData.Values.Add("employerAccountId", employerAccountId);
foreach (var accountLegalEntity in legalEntitiesResponse.AccountLegalEntities)
{
accountLegalEntity.IsLevy = false;
accountLegalEntity.AgreementType = AgreementType.NonLevyExpressionOfInterest;
}
mockEncodingService
.Setup(service => service.Decode(
context.RouteData.Values["employerAccountId"].ToString(),
EncodingType.AccountId))
.Returns(decodedEmployerAccountId);
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetLegalEntitiesQuery>(query => query.AccountId == decodedEmployerAccountId),
It.IsAny <CancellationToken>()))
.ReturnsAsync(legalEntitiesResponse);
await filter.OnActionExecutionAsync(context, mockNext.Object);
mockNext.Verify(next => next(), Times.Once);
context.Result.Should().Be(null);
}
public async Task Then_It_Returns_The_Trusted_Employers(
ReservationsRouteModel routeModel,
IEnumerable <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.NonLevyExpressionOfInterest
})
};
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);
var viewModel = result.Should().BeOfType <ViewResult>()
.Which.Model.Should().BeOfType <ChooseEmployerViewModel>()
.Subject;
viewModel.Employers.Should().BeEquivalentTo(expectedEmployers);
}
