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