public async Task Then_The_Location_Cookie_Is_Checked_And_Added_To_Model(
GetCoursesRequest request,
GetCoursesResult response,
LocationCookieItem cookieItem,
[Frozen] Mock <ICookieStorageService <LocationCookieItem> > locationCookieService,
[Frozen] Mock <IMediator> mediator,
[Greedy] CoursesController controller)
{
//Arrange
request.Location = string.Empty;
mediator.Setup(x =>
x.Send(It.Is <GetCoursesQuery>(c
=> c.Keyword.Equals(request.Keyword) &&
c.RouteIds.Equals(request.Sectors) &&
c.Levels.Equals(request.Levels)), It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
locationCookieService.Setup(x => x.Get(Constants.LocationCookieName)).Returns(cookieItem);
//Act
var actual = await controller.Courses(request);
//Assert
Assert.IsNotNull(actual);
var actualResult = actual as ViewResult;
Assert.IsNotNull(actualResult);
var actualModel = actualResult.Model as CoursesViewModel;
Assert.IsNotNull(actualModel);
actualModel.Location.Should().Be(cookieItem.Name);
}
public async Task Then_The_Query_Is_Sent_And_Data_Retrieved_And_View_Shown(
GetCoursesRequest request,
GetCoursesResult response,
ShortlistCookieItem cookieItem,
[Frozen] Mock <IMediator> mediator,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > shortlistCookieService,
[Greedy] CoursesController controller)
{
//Arrange
mediator.Setup(x =>
x.Send(It.Is <GetCoursesQuery>(c =>
c.Keyword.Equals(request.Keyword) &&
c.ShortlistUserId.Equals(cookieItem.ShortlistUserId)), It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
shortlistCookieService.Setup(x => x.Get(Constants.ShortlistCookieName))
.Returns(cookieItem);
//Act
var actual = await controller.Courses(request);
var actualResult = actual as ViewResult;
//Assert
Assert.IsNotNull(actual);
Assert.IsNotNull(actualResult);
}
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_Gets_Cached_Reservation(
ReservationsRouteModel routeModel,
GetCoursesResult coursesResult,
[Frozen] Mock <IMediator> mockMediator,
EmployerReservationsController controller)
{
mockMediator
.Setup(m => m.Send(It.IsAny <GetCoursesQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(coursesResult);
await controller.SelectCourse(routeModel);
mockMediator.Verify(mediator => mediator.Send(It.Is <GetCachedReservationQuery>(query => query.Id == routeModel.Id.Value), CancellationToken.None), Times.Once);
}
public async Task Then_The_Routes_Are_Added(
string serviceStartUrl,
string shortlistUrl,
string privacyUrl,
string accessibilityUrl,
string cookiesUrl,
string cookiesDetailsUrl,
string coursesUrl,
GetCoursesResult result,
[Frozen] Mock <IMediator> mediator,
[Frozen] Mock <IDistributedCache> cache)
{
var httpContext = new DefaultHttpContext();
var urlHelper = new Mock <IUrlHelper>();
cache.Setup(x => x.GetAsync("Sitemap", CancellationToken.None))
.ReturnsAsync((byte[])default);
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);
}
public async Task And_No_Cached_Reservation_Then_Redirects_Start_Again(
ReservationsRouteModel routeModel,
GetCoursesResult coursesResult,
[Frozen] Mock <IMediator> mockMediator,
EmployerReservationsController controller)
{
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((GetCachedReservationResult)null);
var result = await controller.SelectCourse(routeModel) as ViewResult;
result.Should().NotBeNull();
result?.ViewName.Should().Be("Index");
}
public async Task Then_Gets_Courses_From_Mediator(
GetCoursesResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] CoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetCoursesQuery>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var response = await controller.ChooseCourse() as ViewResult;
var model = response.Model as ChooseCourseViewModel;
model.Courses.Should().BeEquivalentTo(
mediatorResult.Courses.Select(item => (CourseListItemViewModel)item));
}
public async Task Then_Any_Sectors_In_The_Request_Are_Marked_As_Selected_On_The_ViewModel(
GetCoursesRequest request,
GetCoursesResult response,
[Frozen] Mock <ICookieStorageService <LocationCookieItem> > locationCookieService,
[Frozen] Mock <IMediator> mediator,
[Greedy] CoursesController controller)
{
//Arrange
request.Location = "";
response.Sectors.Add(new Sector
{
Route = request.Sectors.First()
});
response.Sectors.Add(new Sector
{
Route = request.Sectors.Skip(1).First()
});
mediator.Setup(x =>
x.Send(It.Is <GetCoursesQuery>(c
=> c.Keyword.Equals(request.Keyword) &&
c.RouteIds.Equals(request.Sectors)), It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
locationCookieService.Setup(x => x.Get(Constants.LocationCookieName)).Returns((LocationCookieItem)null);
//Act
var actual = await controller.Courses(request);
//Assert
Assert.IsNotNull(actual);
var actualResult = actual as ViewResult;
Assert.IsNotNull(actualResult);
var actualModel = actualResult.Model as CoursesViewModel;
Assert.IsNotNull(actualModel);
Assert.AreEqual(2, actualModel.Sectors.Count(sector => sector.Selected));
Assert.IsNotNull(actualModel.Sectors.SingleOrDefault(c => c.Route.Equals(request.Sectors.First())));
Assert.IsNotNull(actualModel.Sectors.SingleOrDefault(c => c.Route.Equals(request.Sectors.Skip(1).First())));
actualModel.Location.Should().BeEmpty();
}
public async Task Then_The_Keyword_And_Sectors_And_Levels_And_Location_Are_Added_To_The_Query_And_Returned_To_The_View(
GetCoursesRequest request,
GetCoursesResult response,
[Frozen] Mock <IMediator> mediator,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > shortlistCookieService,
[Greedy] CoursesController controller)
{
//Arrange
mediator.Setup(x =>
x.Send(It.Is <GetCoursesQuery>(c
=> c.Keyword.Equals(request.Keyword) &&
c.RouteIds.Equals(request.Sectors) &&
c.Levels.Equals(request.Levels)), It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
shortlistCookieService.Setup(x => x.Get(Constants.ShortlistCookieName))
.Returns((ShortlistCookieItem)null);
//Act
var actual = await controller.Courses(request);
//Assert
Assert.IsNotNull(actual);
var actualResult = actual as ViewResult;
Assert.IsNotNull(actualResult);
var actualModel = actualResult.Model as CoursesViewModel;
Assert.IsNotNull(actualModel);
actualModel.Courses.Should().BeEquivalentTo(response.Courses, options => options.Including(course => course.Id));
actualModel.Sectors.Should().BeEquivalentTo(response.Sectors);
actualModel.Levels.Should().BeEquivalentTo(response.Levels);
actualModel.Keyword.Should().Be(request.Keyword);
actualModel.SelectedLevels.Should().BeEquivalentTo(request.Levels);
actualModel.SelectedSectors.Should().BeEquivalentTo(request.Sectors);
actualModel.Total.Should().Be(response.Total);
actualModel.TotalFiltered.Should().Be(response.TotalFiltered);
actualModel.ShortlistItemCount.Should().Be(response.ShortlistItemCount);
actualModel.Location.Should().Be(request.Location);
}
public async Task And_Invalid_Then_Adds_ModelState_Error(
GetChooseCourseRequest request,
GetCoursesResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] CoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetCoursesQuery>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
await controller.ChooseCourse(request);
controller.ModelState.IsValid.Should().BeFalse();
controller.ModelState.ContainsKey("SelectedCourseId").Should().BeTrue();
controller.ModelState.ContainsKey("SelectedCourseIdNoJs").Should().BeTrue();
controller.ModelState["SelectedCourseId"].Errors[0].ErrorMessage
.Should().Be("Enter an apprenticeship training course");
controller.ModelState["SelectedCourseIdNoJs"].Errors[0].ErrorMessage
.Should().Be("Select an apprenticeship training course");
}
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_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);
}
