public void And_PageNumber_1_And_0_Records_Found_Then_Should_Be_0(ManageReservationsFilterModel filterModel)
{
filterModel.PageNumber = 1;
filterModel.NumberOfRecordsFound = 0;
filterModel.PagedRecordsFrom.Should().Be(0);
}
public void And_PageNumber_3_Then_Should_Be_Triple_PageSize(ManageReservationsFilterModel filterModel)
{
filterModel.PageNumber = 3;
filterModel.NumberOfRecordsFound = 20 * ManageReservationsFilterModel.PageSize;
filterModel.PagedRecordsTo.Should().Be(3 * ManageReservationsFilterModel.PageSize);
}
public void Then_Adds_PageLink_For_Every_Page()
{
var filterModel = new ManageReservationsFilterModel
{
SearchTerm = "asedfas",
SelectedCourse = "iknjso",
SelectedEmployer = "asdsad",
SelectedStartDate = "asdva",
NumberOfRecordsFound = ManageReservationsFilterModel.PageSize * 3
};
var pageLinks = filterModel.PageLinks.Where(link =>
link.Label.ToUpper() != "PREVIOUS" &&
link.Label.ToUpper() != "NEXT").ToList();
for (var i = 0; i < 3; i++)
{
pageLinks[i].Label.Should().Be($"{i+1}");
pageLinks[i].AriaLabel.Should().Be($"Page {i+1}");
pageLinks[i].RouteData.Should().BeEquivalentTo(new Dictionary <string, string>
{
{ "searchTerm", filterModel.SearchTerm },
{ "selectedCourse", filterModel.SelectedCourse },
{ "selectedEmployer", filterModel.SelectedEmployer },
{ "selectedStartDate", filterModel.SelectedStartDate },
{ "pageNumber", (i + 1).ToString() }
});
}
}
public async Task Then_The_Cached_Search_Is_Loaded_If_From_BackLink(
ReservationsRouteModel routeModel,
ManageReservationsFilterModel filterModel,
SearchReservationsResult searchResult,
ManageReservationsFilterModelBase baseFilterModel,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <ISessionStorageService <ManageReservationsFilterModelBase> > sessionStorageService,
ManageReservationsController controller)
{
routeModel.IsFromManage = true;
mockMediator
.Setup(mediator => mediator.Send(It.Is <SearchReservationsQuery>(c => c.Filter.SearchTerm.Equals(baseFilterModel.SearchTerm)), It.IsAny <CancellationToken>()))
.ReturnsAsync(searchResult);
sessionStorageService.Setup(x => x.Get()).Returns(baseFilterModel);
filterModel.SearchTerm = string.Empty;
await controller.ProviderManage(routeModel, filterModel);
mockMediator.Verify(x => x.Send(It.Is <SearchReservationsQuery>(
c =>
c.Filter.SearchTerm.Equals(baseFilterModel.SearchTerm) &&
c.Filter.SelectedCourse.Equals(baseFilterModel.SelectedCourse) &&
c.Filter.SelectedEmployer.Equals(baseFilterModel.SelectedEmployer) &&
c.Filter.SelectedStartDate.Equals(baseFilterModel.SelectedStartDate) &&
c.Filter.PageNumber.Equals(baseFilterModel.PageNumber)
), It.IsAny <CancellationToken>()), Times.Once);
routeModel.IsFromManage = false;
}
public async Task Then_The_Cached_Search_Is_Not_Saved_If_It_Is_Empty_But_The_Cache_Is_Still_Cleared(
ReservationsRouteModel routeModel,
ManageReservationsFilterModel filterModel,
SearchReservationsResult searchResult,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <ISessionStorageService <ManageReservationsFilterModelBase> > sessionStorageService,
ManageReservationsController controller)
{
routeModel.IsFromManage = false;
filterModel.SearchTerm = string.Empty;
filterModel.PageNumber = 1;
filterModel.SelectedCourse = string.Empty;
filterModel.SelectedEmployer = string.Empty;
filterModel.SelectedStartDate = string.Empty;
mockMediator
.Setup(mediator => mediator.Send(It.Is <SearchReservationsQuery>(c => c.Filter.SearchTerm.Equals(filterModel.SearchTerm)), It.IsAny <CancellationToken>()))
.ReturnsAsync(searchResult);
await controller.ProviderManage(routeModel, filterModel);
mockMediator.Verify(x => x.Send(It.Is <SearchReservationsQuery>(
c => c.Filter.SearchTerm.Equals(filterModel.SearchTerm)), It.IsAny <CancellationToken>()), Times.Once);
sessionStorageService.Verify(x => x.Delete(), Times.Once);
sessionStorageService.Verify(x => x.Store(It.IsAny <ManageReservationsFilterModelBase>()), Times.Never);
}
public void And_Has_SearchTerm_Then_True()
{
var filterModel = new ManageReservationsFilterModel
{
SearchTerm = "asedfas"
};
filterModel.SearchOrFiltersApplied.Should().BeTrue();
}
public void And_Search_And_No_Filters_Then_Quoted_SearchTerm(
string searchTerm)
{
var filterModel = new ManageReservationsFilterModel
{
SearchTerm = searchTerm
};
filterModel.FiltersUsedMessage.Value.Should().Be($"matching <strong>‘{searchTerm}’</strong>");
}
public void And_No_Search_And_SelectedEmployer_Then_SelectedEmployer(
string selectedEmployer)
{
var filterModel = new ManageReservationsFilterModel
{
SelectedEmployer = selectedEmployer
};
filterModel.FiltersUsedMessage.Value.Should().Be($"matching <strong>{selectedEmployer}</strong>");
}
public void And_No_Search_And_SelectedStartDate_Then_SelectedStartDate(
string selectedStartDate)
{
var filterModel = new ManageReservationsFilterModel
{
SelectedStartDate = selectedStartDate
};
filterModel.FiltersUsedMessage.Value.Should().Be($"matching <strong>{selectedStartDate}</strong>");
}
public void Then_Sets_SearchTerm(
ManageReservationsFilterModel filterModel)
{
ReservationFilter result = filterModel;
result.SearchTerm.Should().Be(filterModel.SearchTerm);
result.PageNumber.Should().Be(filterModel.PageNumber);
result.PageSize.Should().Be(ManageReservationsFilterModel.PageSize);
result.SelectedEmployer.Should().Be(filterModel.SelectedEmployer);
result.SelectedCourse.Should().Be(filterModel.SelectedCourse);
result.SelectedStartDate.Should().Be(filterModel.SelectedStartDate);
}
public void And_Is_First_Page_Then_No_Previous()
{
var filterModel = new ManageReservationsFilterModel
{
PageNumber = 1,
NumberOfRecordsFound = ManageReservationsFilterModel.PageSize * 6
};
var pageLinks = filterModel.PageLinks.ToList();
pageLinks.First().Label.Should().Be(1.ToString());
}
public void And_1_Page_Then_No_Next_Or_Previous()
{
var filterModel = new ManageReservationsFilterModel
{
PageNumber = 1,
NumberOfRecordsFound = ManageReservationsFilterModel.PageSize - 1
};
var pageLinks = filterModel.PageLinks.ToList();
pageLinks.Any(link => link.Label.ToUpper() == "PREVIOUS").Should().BeFalse();
pageLinks.Any(link => link.Label.ToUpper() == "NEXT").Should().BeFalse();
}
public void And_3_Pages_Then_Only_3_PageLinks()
{
var filterModel = new ManageReservationsFilterModel
{
PageNumber = 1,
NumberOfRecordsFound = ManageReservationsFilterModel.PageSize * 3
};
filterModel.PageLinks.Count(link =>
link.Label.ToUpper() != "PREVIOUS" &&
link.Label.ToUpper() != "NEXT")
.Should().Be(3);
}
public async Task And_The_Provider_Has_No_TrustedEmployers_Then_A_NoPermissions_View_Is_Returned(
ReservationsRouteModel routeModel,
ManageReservationsFilterModel filterModel,
[Frozen] Mock <IMediator> mockMediator,
ManageReservationsController controller)
{
filterModel.SearchTerm = string.Empty;
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <SearchReservationsQuery>(), It.IsAny <CancellationToken>()))
.ThrowsAsync(new ProviderNotAuthorisedException(0, 1));
var result = await controller.ProviderManage(routeModel, filterModel) as ViewResult;
result.ViewName.Should().Be("NoPermissions");
}
public void Then_The_Hide_Footer_Flag_Is_Set_Based_On_Number_Of_Filtered_Reservations(
int numberOfFilteredReservations, bool expectedBool)
{
//Arrange
var filterModel = new ManageReservationsFilterModel {
NumberOfRecordsFound = numberOfFilteredReservations
};
//Act
var actual = new ManageViewModel {
FilterModel = filterModel
};
//Assert
Assert.AreEqual(expectedBool, actual.ShowPageLinks);
}
public void And_Not_Last_Page_Then_Adds_Next()
{
var filterModel = new ManageReservationsFilterModel
{
PageNumber = 1,
NumberOfRecordsFound = ManageReservationsFilterModel.PageSize * 6
};
var pageLinks = filterModel.PageLinks.ToList();
pageLinks.Last().Label.Should().Be("Next");
pageLinks.Last().AriaLabel.Should().Be("Next page");
pageLinks.Last().RouteData.Should()
.BeEquivalentTo(pageLinks.Single(link =>
link.Label == (filterModel.PageNumber + 1).ToString()).RouteData);
}
public void And_Not_First_Page_Then_Adds_Previous()
{
var filterModel = new ManageReservationsFilterModel
{
PageNumber = 2,
NumberOfRecordsFound = ManageReservationsFilterModel.PageSize * 6
};
var pageLinks = filterModel.PageLinks.ToList();
pageLinks.First().Label.Should().Be("Previous");
pageLinks.First().AriaLabel.Should().Be("Previous page");
pageLinks.First().RouteData.Should()
.BeEquivalentTo(pageLinks.Single(link =>
link.Label == "1").RouteData);
}
public void And_PageNumber_3_Then_Sets_Current_On_3()
{
var filterModel = new ManageReservationsFilterModel
{
PageNumber = 3,
NumberOfRecordsFound = ManageReservationsFilterModel.PageSize * 3
};
var pageLinks = filterModel.PageLinks.Where(link =>
link.Label.ToUpper() != "PREVIOUS" &&
link.Label.ToUpper() != "NEXT").ToList();
pageLinks[0].IsCurrent.Should().BeNull();
pageLinks[1].IsCurrent.Should().BeNull();
pageLinks[2].IsCurrent.Should().BeTrue();
}
public async Task Then_Filter_Params_Assigned_To_View_Model(
ReservationsRouteModel routeModel,
ManageReservationsFilterModel filterModel,
SearchReservationsResult searchResult,
[Frozen] Mock <IMediator> mockMediator,
ManageReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <SearchReservationsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(searchResult);
var result = await controller.ProviderManage(routeModel, filterModel) as ViewResult;
var viewModel = result?.Model as ManageViewModel;
viewModel.FilterModel.Should().BeEquivalentTo(filterModel);
}
public void And_Search_And_SelectedEmployer_And_SelectedCourse_Then_SearchTerm_Comma_SelectedEmployer_And_SelectedCourse(
string searchTerm,
string selectedEmployer,
string selectedCourse)
{
var filterModel = new ManageReservationsFilterModel
{
SearchTerm = searchTerm,
SelectedEmployer = selectedEmployer,
SelectedCourse = selectedCourse
};
filterModel.FiltersUsedMessage.Value
.Should().Be($"matching <strong>‘{searchTerm}’</strong>" +
$", <strong>{selectedEmployer}</strong>" +
$" and <strong>{selectedCourse}</strong>");
}
public void And_Page_Number_10_Of_10_Then_Links_6_To_10()
{
var filterModel = new ManageReservationsFilterModel
{
PageNumber = 10,
NumberOfRecordsFound = ManageReservationsFilterModel.PageSize * 10
};
var pageLinks = filterModel.PageLinks.Where(link =>
link.Label.ToUpper() != "PREVIOUS" &&
link.Label.ToUpper() != "NEXT").ToList();
pageLinks[0].Label.Should().Be(6.ToString());
pageLinks[1].Label.Should().Be(7.ToString());
pageLinks[2].Label.Should().Be(8.ToString());
pageLinks[3].Label.Should().Be(9.ToString());
pageLinks[4].Label.Should().Be(10.ToString());
}
public void And_Page_Number_4_Of_5_Then_Links_1_To_5()
{
var filterModel = new ManageReservationsFilterModel
{
PageNumber = 4,
NumberOfRecordsFound = ManageReservationsFilterModel.PageSize * 5
};
var pageLinks = filterModel.PageLinks.Where(link =>
link.Label.ToUpper() != "PREVIOUS" &&
link.Label.ToUpper() != "NEXT").ToList();
pageLinks[0].Label.Should().Be(1.ToString());
pageLinks[1].Label.Should().Be(2.ToString());
pageLinks[2].Label.Should().Be(3.ToString());
pageLinks[3].Label.Should().Be(4.ToString());
pageLinks[4].Label.Should().Be(5.ToString());
}
public async Task Then_Gets_List_Of_Reservations_From_Search(
ReservationsRouteModel routeModel,
ManageReservationsFilterModel filterModel,
SearchReservationsResult searchResult,
[Frozen] Mock <IMediator> mockMediator,
ManageReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <SearchReservationsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(searchResult);
await controller.ProviderManage(routeModel, filterModel);
mockMediator.Verify(mediator =>
mediator.Send(
It.Is <SearchReservationsQuery>(query => query.ProviderId == routeModel.UkPrn),
It.IsAny <CancellationToken>()),
Times.Once);
}
public async Task Then_Returns_List_Of_Reservations_From_Mediator(
[Frozen] ReservationsRouteModel routeModel,
ManageReservationsFilterModel filterModel,
SearchReservationsResult searchResult,
string hashedId,
string homeLink,
[Frozen] ReservationsWebConfiguration config,
[Frozen] Mock <IExternalUrlHelper> externalUrlHelper,
[Frozen] Mock <IEncodingService> mockEncodingService,
[Frozen] Mock <IMediator> mockMediator,
ManageReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <SearchReservationsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(searchResult);
mockEncodingService
.Setup(service => service.Encode(It.IsAny <long>(), EncodingType.PublicAccountLegalEntityId))
.Returns(hashedId);
externalUrlHelper
.Setup(x => x.GenerateDashboardUrl(routeModel.EmployerAccountId)).Returns(homeLink);
var expectedReservations = new List <ReservationViewModel>();
expectedReservations.AddRange(searchResult.Reservations.Select(reservation =>
new ReservationViewModel(reservation, config.ApprenticeUrl, routeModel.UkPrn)));
var result = await controller.ProviderManage(routeModel, filterModel) as ViewResult;
result.Should().NotBeNull();
result.ViewName.Should().Be(ViewNames.ProviderManage);
var viewModel = result.Model as ManageViewModel;
viewModel.Should().NotBeNull();
viewModel.TotalReservationCount.Should().Be(searchResult.TotalReservationsForProvider);
viewModel.BackLink.Should().Be(homeLink);
viewModel.FilterModel.NumberOfRecordsFound.Should().Be(searchResult.NumberOfRecordsFound);
viewModel.Reservations.Should().BeEquivalentTo(expectedReservations,
options => options.ExcludingFields().Excluding(c => c.ApprenticeUrl));
viewModel.FilterModel.EmployerFilters.Should().BeEquivalentTo(searchResult.EmployerFilters);
viewModel.FilterModel.CourseFilters.Should().BeEquivalentTo(searchResult.CourseFilters);
viewModel.FilterModel.StartDateFilters.Should().BeEquivalentTo(searchResult.StartDateFilters);
}
public async Task Then_The_Cached_Search_Is_Deleted_If_Not_From_BackLink_And_New_One_Saved(
ReservationsRouteModel routeModel,
ManageReservationsFilterModel filterModel,
SearchReservationsResult searchResult,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <ISessionStorageService <ManageReservationsFilterModelBase> > sessionStorageService,
ManageReservationsController controller)
{
routeModel.IsFromManage = false;
mockMediator
.Setup(mediator => mediator.Send(It.Is <SearchReservationsQuery>(c => c.Filter.SearchTerm.Equals(filterModel.SearchTerm)), It.IsAny <CancellationToken>()))
.ReturnsAsync(searchResult);
await controller.ProviderManage(routeModel, filterModel);
mockMediator.Verify(x => x.Send(It.Is <SearchReservationsQuery>(
c => c.Filter.SearchTerm.Equals(filterModel.SearchTerm)), It.IsAny <CancellationToken>()), Times.Once);
sessionStorageService.Verify(x => x.Delete(), Times.Once);
sessionStorageService.Verify(x => x.Store(filterModel));
}
public async Task Add_Apprentice_Url_UkPrn_Will_Be_Populated_From_RouteModel_Reservation(
ReservationsRouteModel routeModel,
ManageReservationsFilterModel filterModel,
SearchReservationsResult searchResult,
string hashedId,
string expectedUrl,
[Frozen] Mock <IEncodingService> mockEncodingService,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IExternalUrlHelper> mockUrlHelper,
ManageReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <SearchReservationsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(searchResult);
mockEncodingService
.Setup(service => service.Encode(It.IsAny <long>(), EncodingType.PublicAccountLegalEntityId))
.Returns(hashedId);
mockUrlHelper.Setup(h => h.GenerateAddApprenticeUrl(
It.IsAny <Guid>(),
hashedId,
It.IsAny <string>(),
routeModel.UkPrn,
It.IsAny <DateTime>(),
routeModel.CohortReference,
routeModel.EmployerAccountId,
false,
"",
""))
.Returns(expectedUrl);
var result = await controller.ProviderManage(routeModel, filterModel) as ViewResult;
var viewModel = result?.Model as ManageViewModel;
viewModel.Should().NotBeNull();
viewModel.Reservations.Where(model => model.Status == ReservationStatusViewModel.Pending && !model.IsExpired)
.All(c => c.ApprenticeUrl.Equals(expectedUrl)).Should().BeTrue();
}
public async Task And_Reservation_From_This_Provider_Then_Is_Deletable(
[Frozen] ReservationsRouteModel routeModel,
ManageReservationsFilterModel filterModel,
[ReservationsFromThisProvider] SearchReservationsResult searchResult,
string hashedId,
[Frozen] Mock <IEncodingService> mockEncodingService,
[Frozen] Mock <IMediator> mockMediator,
ManageReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <SearchReservationsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(searchResult);
mockEncodingService
.Setup(service => service.Encode(It.IsAny <long>(), EncodingType.PublicAccountLegalEntityId))
.Returns(hashedId);
var result = await controller.ProviderManage(routeModel, filterModel) as ViewResult;
var viewModel = result.Model as ManageViewModel;
viewModel.Reservations
.Select(model => model.CanProviderDeleteReservation)
.Should().AllBeEquivalentTo(true);
}
public void And_No_Search_Or_Filter_Then_False()
{
var filterModel = new ManageReservationsFilterModel();
filterModel.SearchOrFiltersApplied.Should().BeFalse();
}
public void And_PageNumber_3_Then_Should_Be_Double_PageSize_Plus_1(ManageReservationsFilterModel filterModel)
{
filterModel.PageNumber = 3;
filterModel.PagedRecordsFrom.Should().Be(2 * ManageReservationsFilterModel.PageSize + 1);
}
public void And_PageNumber_1_Then_Should_Be_1(ManageReservationsFilterModel filterModel)
{
filterModel.PageNumber = 1;
filterModel.PagedRecordsFrom.Should().Be(1);
}
