public async Task Then_If_Confirmed_And_Funding_Limit_Not_Reached_User_Is_Redirected_To_Next_Stage(
uint ukPrn,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IFundingRulesService> mockFundingRulesService,
ProviderReservationsController controller,
ConfirmEmployerViewModel viewModel)
{
viewModel.Confirm = true;
mockMediator.Setup(m => m.Send(It.IsAny <CacheReservationEmployerCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(Unit.Value);
mockFundingRulesService.Setup(m => m.GetAccountFundingRules(It.IsAny <long>()))
.ReturnsAsync(new GetAccountFundingRulesApiResponse()
{
GlobalRules = new List <GlobalRule>()
});
var result = await controller.ProcessConfirmEmployer(viewModel);
var redirectResult = result as RedirectToRouteResult;
Assert.IsNotNull(redirectResult);
Assert.AreEqual(RouteNames.ProviderApprenticeshipTraining, redirectResult.RouteName);
Assert.AreEqual(viewModel.UkPrn, redirectResult.RouteValues["UkPrn"]);
Assert.AreEqual(viewModel.AccountPublicHashedId, redirectResult.RouteValues["EmployerAccountId"]);
}
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_If_Confirmed_The_Choosen_Employer_Is_Stored(
uint ukPrn,
long accountId,
long accountLegalEntityId,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IEncodingService> encodingService,
ProviderReservationsController controller,
ConfirmEmployerViewModel viewModel)
{
viewModel.Confirm = true;
encodingService.Setup(x => x.Decode(viewModel.AccountPublicHashedId, EncodingType.PublicAccountId))
.Returns(accountId);
encodingService.Setup(x => x.Decode(viewModel.AccountLegalEntityPublicHashedId, EncodingType.PublicAccountLegalEntityId))
.Returns(accountLegalEntityId);
mockMediator.Setup(m => m.Send(It.IsAny <CacheReservationEmployerCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(Unit.Value);
await controller.ProcessConfirmEmployer(viewModel);
mockMediator.Verify(m => m.Send(It.Is <CacheReservationEmployerCommand>(c =>
c.AccountId.Equals(accountId) &&
c.AccountLegalEntityId.Equals(accountLegalEntityId) &&
c.AccountLegalEntityPublicHashedId.Equals(viewModel.AccountLegalEntityPublicHashedId) &&
c.AccountLegalEntityName.Equals(viewModel.AccountLegalEntityName) &&
c.AccountName.Equals(viewModel.AccountName) &&
c.UkPrn.Equals(viewModel.UkPrn)), It.IsAny <CancellationToken>()), Times.Once);
}
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_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 WhenFundingIsPaused_AndFromManage_ThenBackLinkSetToManage(
string expectedBackLink,
uint ukprn,
[Frozen] Mock <IMediator> mockMediator,
GetFundingRulesResult result,
[Frozen] Mock <IUrlHelper> mockUrlHelper,
[Frozen] Mock <IExternalUrlHelper> mockExternalUrlHelper,
GlobalRule rule,
ProviderReservationsController controller)
{
//Arrange
rule.ActiveFrom = DateTime.UtcNow.AddDays(-5);
result.GlobalRules.Add(rule);
mockMediator
.Setup(x => x.Send(It.IsAny <GetFundingRulesQuery>(), CancellationToken.None))
.ReturnsAsync(result);
mockUrlHelper
.Setup(x => x.RouteUrl(It.IsAny <UrlRouteContext>()))
.Returns(expectedBackLink);
mockExternalUrlHelper
.Setup(x => x.GenerateDashboardUrl(It.IsAny <string>()))
.Returns("unexpectedUrl");
controller.Url = mockUrlHelper.Object;
//Act
var viewResult = await controller.Start(ukprn, true) as ViewResult;
//Assert
Assert.NotNull(viewResult);
Assert.NotNull(viewResult.Model as string);
Assert.AreEqual(expectedBackLink, viewResult.Model as string);
mockUrlHelper.Verify(x => x.RouteUrl(It.Is <UrlRouteContext>(y => y.RouteName == RouteNames.ProviderManage)), Times.Once);
mockExternalUrlHelper.Verify(x => x.GenerateDashboardUrl(It.IsAny <string>()), Times.Never);
}
public async Task Then_If_The_ViewModel_Is_Null_It_Is_Read_From_The_Cache_And_Account_Id_Is_Hashed(
string hashedAccountId,
[Frozen] Mock <IMediator> mediator,
[Frozen] Mock <IEncodingService> encodingService,
ProviderReservationsController controller,
ConfirmEmployerViewModel viewModel,
GetCachedReservationResult cachedResult)
{
//Arrange
mediator
.Setup(x => x.Send(
It.Is <GetCachedReservationQuery>(c => c.Id.Equals(viewModel.Id) && c.UkPrn.Equals(viewModel.UkPrn)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(cachedResult);
encodingService.Setup(x => x.Encode(cachedResult.AccountId, EncodingType.AccountId)).Returns(hashedAccountId);
//Act
var actual = await controller.ConfirmEmployer(new ConfirmEmployerViewModel { Id = viewModel.Id, UkPrn = viewModel.UkPrn });
//Assert
Assert.IsNotNull(actual);
var viewResult = actual as ViewResult;
Assert.IsNotNull(viewResult);
var model = viewResult.Model as ConfirmEmployerViewModel;
Assert.IsNotNull(model);
Assert.AreEqual(cachedResult.AccountLegalEntityName, model.AccountLegalEntityName);
Assert.AreEqual(hashedAccountId, model.AccountPublicHashedId);
Assert.AreEqual(cachedResult.AccountLegalEntityPublicHashedId, model.AccountLegalEntityPublicHashedId);
Assert.AreEqual(viewModel.UkPrn, model.UkPrn);
}
public void Arrange()
{
_mockMediator = new Mock <IMediator>();
_config = new ReservationsWebConfiguration
{
EmployerDashboardUrl = "test.com/test"
};
var options = new Mock <IOptions <ReservationsWebConfiguration> >();
options.Setup(o => o.Value).Returns(_config);
_controller = new ProviderReservationsController(_mockMediator.Object, Mock.Of <IExternalUrlHelper>());
}
public async Task Then_If_Not_Confirmed_The_Choosen_Employer_Is_Not_Stored(
uint ukPrn,
[Frozen] Mock <IMediator> mockMediator,
ProviderReservationsController controller,
ConfirmEmployerViewModel viewModel)
{
viewModel.Confirm = false;
mockMediator.Setup(m => m.Send(It.IsAny <CacheReservationEmployerCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(Unit.Value);
await controller.ProcessConfirmEmployer(viewModel);
mockMediator.Verify(m => m.Send(It.IsAny <CacheReservationEmployerCommand>(), It.IsAny <CancellationToken>()), Times.Never);
}
public void Arrange()
{
var fixture = new Fixture().Customize(new AutoMoqCustomization {
ConfigureMembers = true
});
_expectedRule = new GlobalRule {
Id = 2, ActiveFrom = DateTime.Now.AddDays(2)
};
var result = new GetNextUnreadGlobalFundingRuleResult {
Rule = _expectedRule
};
_mockMediator = fixture.Freeze <Mock <IMediator> >();
_config = new ReservationsWebConfiguration
{
DashboardUrl = "test.com/test"
};
var options = fixture.Freeze <Mock <IOptions <ReservationsWebConfiguration> > >();
options.Setup(o => o.Value).Returns(_config);
_mockMediator.Setup(x => x.Send(It.IsAny <GetNextUnreadGlobalFundingRuleQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(result);
_externalUrlHelper = fixture.Freeze <Mock <IExternalUrlHelper> >();
_externalUrlHelper.Setup(x => x.GenerateDashboardUrl(null)).Returns(ExpectedDashboardUrl);
_urlHelper = fixture.Freeze <Mock <IUrlHelper> >();
_urlHelper.Setup(h => h.RouteUrl(It.Is <UrlRouteContext>(c =>
c.RouteName.Equals(RouteNames.ProviderManage))))
.Returns(ExpectedManageUrl);
_controller = fixture.Create <ProviderReservationsController>();
var claim = new Claim(ProviderClaims.ProviderUkprn, ExpectedUkPrn);
_controller.ControllerContext.HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new[] { claim }))
};
}
public async Task Then_If_Not_Confirmed_User_Is_Redirected_Back_To_Start_Step(
uint ukPrn,
[Frozen] Mock <IMediator> mockMediator,
ProviderReservationsController controller,
ConfirmEmployerViewModel viewModel)
{
viewModel.Confirm = false;
mockMediator.Setup(m => m.Send(It.IsAny <CacheReservationEmployerCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(Unit.Value);
var result = await controller.ProcessConfirmEmployer(viewModel);
var redirectResult = result as RedirectToRouteResult;
Assert.IsNotNull(redirectResult);
Assert.AreEqual(RouteNames.ProviderChooseEmployer, redirectResult.RouteName);
Assert.AreEqual(viewModel.UkPrn, redirectResult.RouteValues["UkPrn"]);
}
public async Task Then_The_ViewModel_Is_Passed_To_The_View(
[Frozen] Mock <IMediator> mediator,
ProviderReservationsController controller,
ConfirmEmployerViewModel viewModel)
{
//Arrange
viewModel.Id = null;
//Act
var actual = await controller.ConfirmEmployer(viewModel);
//Assert
Assert.IsNotNull(actual);
var viewResult = actual as ViewResult;
Assert.IsNotNull(viewResult);
var model = viewResult.Model as ConfirmEmployerViewModel;
model.Should().BeEquivalentTo(viewModel);
mediator.Verify(x => x.Send(It.IsAny <GetCachedReservationQuery>(), It.IsAny <CancellationToken>()), Times.Never);
}
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 void Arrange()
{
var fixture = new Fixture().Customize(new AutoMoqCustomization {
ConfigureMembers = true
});
_mediator = fixture.Freeze <Mock <IMediator> >();
_mediator.Setup(m => m.Send(It.IsAny <GetFundingRulesQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetFundingRulesResult
{
AccountRules = new List <ReservationRule>(),
GlobalRules = new List <GlobalRule>()
});
_mediator.Setup(m => m.Send(It.IsAny <GetTrustedEmployersQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetTrustedEmployersResponse
{
Employers = new List <AccountLegalEntity> {
new AccountLegalEntity()
}
});
_controller = fixture.Create <ProviderReservationsController>();
}
public async Task Then_If_The_User_Has_Come_From_Select_Reservation_The_BackUrl_Is_Populated(
string accountLegalEntityId,
string dashboardUrl,
string previousPageUrl,
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;
routeModel.IsFromSelect = true;
routeModel.PreviousPage = previousPageUrl;
//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.BackUrl.Should().Be(previousPageUrl);
}
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);
}
public async Task Then_If_Confirmed_And_Funding_Limit_Is_Reached_User_Is_Redirected_To_ReservationLimitReached_Page(
uint ukPrn,
[Frozen] Mock <IMediator> mockMediator,
ProviderReservationsController controller,
ConfirmEmployerViewModel viewModel)
{
viewModel.Confirm = true;
var validationResult = new Application.Validation.ValidationResult();
validationResult.AddError(nameof(viewModel.AccountId), "Reservation limit has been reached for this account");
mockMediator.Setup(m => m.Send(It.IsAny <CacheReservationEmployerCommand>(), It.IsAny <CancellationToken>()))
.ThrowsAsync(new ReservationLimitReachedException(It.IsAny <long>()));
var result = await controller.ProcessConfirmEmployer(viewModel);
var viewResult = result as ViewResult;
Assert.IsNotNull(viewResult);
Assert.AreEqual("ReservationLimitReached", viewResult.ViewName);
}
