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); }
public void Arrange() { var fixture = new Fixture().Customize(new AutoMoqCustomization { ConfigureMembers = true }); _course = new Course("1-4-5", "test", 1); _cachedReservationResult = fixture.Create <GetCachedReservationResult>(); _externalUrlHelper = fixture.Freeze <Mock <IExternalUrlHelper> >(); _mediator = fixture.Freeze <Mock <IMediator> >(); _controller = fixture.Create <EmployerReservationsController>(); _mediator.Setup(mediator => mediator.Send( It.IsAny <GetCachedReservationQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(() => _cachedReservationResult); _mediator.Setup(mediator => mediator.Send( It.IsAny <CacheReservationCourseCommand>(), It.IsAny <CancellationToken>())) .ReturnsAsync(Unit.Value); _mediator.Setup(m => m.Send(It.IsAny <GetCoursesQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(new GetCoursesResult { Courses = new List <Course> { _course } }); }
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 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 async Task Then_It_Returns_The_Apprenticeship_Training_View_With_Mapped_Values( ReservationsRouteModel routeModel, IEnumerable <TrainingDateModel> expectedStartDates, GetCoursesResult getCoursesResult, GetCachedReservationResult cachedReservationResult, long accountLegalEntityId, [Frozen] Mock <IEncodingService> mockEncodingService, [Frozen] Mock <ITrainingDateService> mockStartDateService, [Frozen] Mock <IMediator> mockMediator, ReservationsController controller) { cachedReservationResult.CohortRef = string.Empty; 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); mockEncodingService .Setup(service => service.Decode( cachedReservationResult.AccountLegalEntityPublicHashedId, EncodingType.PublicAccountLegalEntityId)) .Returns(accountLegalEntityId); mockStartDateService .Setup(service => service.GetTrainingDates(accountLegalEntityId)) .ReturnsAsync(expectedStartDates); var mappedDates = expectedStartDates.Select(startDateModel => new TrainingDateViewModel(startDateModel)).OrderBy(model => model.StartDate); var mappedCourses = getCoursesResult.Courses.Select(course => new CourseViewModel(course)); routeModel.FromReview = false; var result = await controller.ApprenticeshipTraining(routeModel); var viewModel = result.Should().BeOfType <ViewResult>() .Which.Model.Should().BeOfType <ApprenticeshipTrainingViewModel>() .Subject; viewModel.PossibleStartDates.Should().BeEquivalentTo(mappedDates); viewModel.Courses.Should().BeEquivalentTo(mappedCourses); viewModel.CourseId.Should().Be(cachedReservationResult.CourseId); viewModel.IsProvider.Should().BeTrue(); viewModel.RouteName.Should().Be(RouteNames.ProviderCreateApprenticeshipTraining); viewModel.BackLink.Should().Be(RouteNames.ProviderConfirmEmployer); viewModel.AccountLegalEntityPublicHashedId.Should() .Be(cachedReservationResult.AccountLegalEntityPublicHashedId); }
private string GenerateBackLink(ReservationsRouteModel routeModel, GetCachedReservationResult result) { if (!string.IsNullOrEmpty(result.CohortRef) || result.IsEmptyCohortFromSelect) { return(_urlHelper.GenerateCohortDetailsUrl(result.UkPrn, routeModel.EmployerAccountId, result.CohortRef, result.IsEmptyCohortFromSelect)); } if (routeModel.FromReview.HasValue && routeModel.FromReview.Value) { return(RouteNames.EmployerReview); } if (result.EmployerHasSingleLegalEntity) { return(RouteNames.EmployerStart); } return(RouteNames.EmployerSelectLegalEntity); }
public async Task <IActionResult> SelectLegalEntity(ReservationsRouteModel routeModel) { try { GetCachedReservationResult cachedResponse = null; if (routeModel.Id.HasValue) { cachedResponse = await _mediator.Send(new GetCachedReservationQuery { Id = routeModel.Id.Value }); } var legalEntitiesResponse = await _mediator.Send(new GetLegalEntitiesQuery { AccountId = _encodingService.Decode(routeModel.EmployerAccountId, EncodingType.AccountId) }); if (legalEntitiesResponse.AccountLegalEntities.Count() == 1) { var accountLegalEntity = legalEntitiesResponse.AccountLegalEntities.First(); if (!accountLegalEntity.AgreementSigned) { return(RedirectToSignAgreement(routeModel, RouteNames.EmployerIndex)); } await CacheReservation(routeModel, accountLegalEntity, true); return(RedirectToRoute(RouteNames.EmployerSelectCourse, routeModel)); } var viewModel = new SelectLegalEntityViewModel(routeModel, legalEntitiesResponse.AccountLegalEntities, cachedResponse?.AccountLegalEntityPublicHashedId); return(View("SelectLegalEntity", viewModel)); } catch (ReservationLimitReachedException) { return(View("ReservationLimitReached", GenerateLimitReachedBackLink(routeModel))); } catch (GlobalReservationRuleException) { return(View("EmployerFundingPaused", GenerateLimitReachedBackLink(routeModel))); } catch (Exception e) { _logger.LogError(e, e.Message); return(RedirectToRoute(RouteNames.Error500)); } }
public void Arrange() { _fixture = new Fixture().Customize(new AutoMoqCustomization()); _course = new Course("1-4-5", "test", 1); _cachedReservationResult = _fixture.Create <GetCachedReservationResult>(); _mediator = new Mock <IMediator>(); _urlHelper = new Mock <IExternalUrlHelper>(); _controller = new ReservationsController( _mediator.Object, Mock.Of <ITrainingDateService>(), Mock.Of <IOptions <ReservationsWebConfiguration> >(), Mock.Of <ILogger <ReservationsController> >(), Mock.Of <IEncodingService>(), _urlHelper.Object); _mediator.Setup(mediator => mediator.Send( It.IsAny <GetCachedReservationQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(() => _cachedReservationResult); _mediator.Setup(mediator => mediator.Send( It.IsAny <CacheReservationCourseCommand>(), It.IsAny <CancellationToken>())) .ReturnsAsync(Unit.Value); _mediator.Setup(mediator => mediator.Send( It.IsAny <CacheReservationStartDateCommand>(), It.IsAny <CancellationToken>())) .ReturnsAsync(Unit.Value); _mediator.Setup(m => m.Send(It.IsAny <GetCoursesQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(new GetCoursesResult { Courses = new List <Course> { _course } }); }
public async Task Then_The_BackLink_Is_Set_To_Return_To_CohortDetails_If_There_Is_A_Cohort_Ref( ICollection <Course> courses, [Frozen] Mock <IExternalUrlHelper> externalUrlHelper, [Frozen] Mock <IMediator> mockMediator, ReservationsRouteModel routeModel, GetCachedReservationResult cachedReservationResult, string cohortUrl, EmployerReservationsController controller ) { //Arrange cachedReservationResult.CohortRef = "ABC123"; cachedReservationResult.IsEmptyCohortFromSelect = false; cachedReservationResult.UkPrn = null; 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); externalUrlHelper.Setup(x => x.GenerateCohortDetailsUrl( null, routeModel.EmployerAccountId, cachedReservationResult.CohortRef, false, It.IsAny <string>() )) .Returns(cohortUrl); //Act var result = await controller.SelectCourse(routeModel) as ViewResult; //Assert var viewModel = result?.Model as EmployerSelectCourseViewModel; Assert.IsNotNull(viewModel); Assert.AreEqual(cohortUrl, viewModel.BackLink); Assert.AreEqual(cachedReservationResult.CohortRef, viewModel.CohortReference); Assert.AreEqual(cachedReservationResult.IsEmptyCohortFromSelect, viewModel.IsEmptyCohortFromSelect); }
public async Task Then_It_Calls_Start_Date_Service_To_Get_Start_Dates( ReservationsRouteModel routeModel, GetCachedReservationResult cachedReservationResult, long accountLegalEntityId, [Frozen] Mock <IMediator> mockMediator, [Frozen] Mock <IEncodingService> mockEncodingService, [Frozen] Mock <ITrainingDateService> mockStartDateService, ReservationsController controller) { mockMediator .Setup(mediator => mediator.Send(It.IsAny <GetCachedReservationQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(cachedReservationResult); mockEncodingService .Setup(service => service.Decode( cachedReservationResult.AccountLegalEntityPublicHashedId, EncodingType.PublicAccountLegalEntityId)) .Returns(accountLegalEntityId); await controller.ApprenticeshipTraining(routeModel); mockStartDateService.Verify(provider => provider.GetTrainingDates(accountLegalEntityId), Times.Once); }
public async Task <IActionResult> ApprenticeshipTraining(ReservationsRouteModel routeModel) { GetCachedReservationResult cachedReservation = null; if (routeModel.Id.HasValue) { cachedReservation = await _mediator.Send(new GetCachedReservationQuery { Id = routeModel.Id.GetValueOrDefault() }); //todo: error handling if fails validation e.g. id not found, redirect to index. } var viewModel = await BuildApprenticeshipTrainingViewModel( routeModel.UkPrn != null, cachedReservation?.AccountLegalEntityPublicHashedId, cachedReservation?.CourseId, cachedReservation?.TrainingDate, routeModel.FromReview ?? false, cachedReservation?.CohortRef, routeModel.UkPrn, routeModel.EmployerAccountId); return(View(viewModel)); }
public async Task And_Previously_Selected_Course_Then_Sets_Selected_Course( ReservationsRouteModel routeModel, GetCoursesResult coursesResult, GetCachedReservationResult cachedReservationResult, [Frozen] Mock <IMediator> mockMediator, EmployerReservationsController controller) { cachedReservationResult.CourseId = coursesResult.Courses.First().Id; mockMediator .Setup(m => m.Send(It.IsAny <GetCoursesQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(coursesResult); mockMediator .Setup(mediator => mediator.Send(It.IsAny <GetCachedReservationQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(cachedReservationResult); var result = await controller.SelectCourse(routeModel) as ViewResult; result.Should().NotBeNull(); var viewModel = result.Model as EmployerSelectCourseViewModel; viewModel.Courses.Single(model => model.Selected == "selected").Id .Should().Be(cachedReservationResult.CourseId); }
public async Task Then_It_Returns_The_ViewModel( ReservationsRouteModel routeModel, GetCachedReservationResult cachedReservationResult, [Frozen] Mock <IMediator> mockMediator, ReservationsController controller) { mockMediator .Setup(mediator => mediator.Send(It.IsAny <GetCachedReservationQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(cachedReservationResult); routeModel.FromReview = false; var result = await controller.Review(routeModel); var viewModel = result.Should().BeOfType <ViewResult>() .Which.Model.Should().BeOfType <ReviewViewModel>().Subject; viewModel.RouteModel.Should().BeEquivalentTo(routeModel); viewModel.TrainingDate.Should().Be(cachedReservationResult.TrainingDate); viewModel.CourseDescription.Should().Be(cachedReservationResult.CourseDescription); viewModel.AccountLegalEntityName.Should().Be(cachedReservationResult.AccountLegalEntityName); viewModel.AccountLegalEntityPublicHashedId.Should().Be(cachedReservationResult.AccountLegalEntityPublicHashedId); viewModel.RouteModel.FromReview.Should().BeTrue(); }
public async Task Then_It_Sets_The_Back_Link_Correctly_Coming_From_The_Review_Screen( ReservationsRouteModel routeModel, GetCoursesResult getCoursesResult, GetCachedReservationResult cachedReservationResult, [Frozen] Mock <IMediator> mockMediator, ReservationsController controller) { cachedReservationResult.CohortRef = string.Empty; 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; var result = await controller.ApprenticeshipTraining(routeModel); var viewModel = result.Should().BeOfType <ViewResult>() .Which.Model.Should().BeOfType <ApprenticeshipTrainingViewModel>() .Subject; viewModel.BackLink.Should().Be(RouteNames.ProviderReview); }