public async Task And_The_Location_Cookie_Exists_Then_Location_Is_Added_To_Shortlist(
CreateShortlistItemRequest request,
ShortlistCookieItem shortlistCookie,
LocationCookieItem locationCookieItem,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > mockShortlistCookieService,
[Frozen] Mock <ICookieStorageService <LocationCookieItem> > mockLocationCookieService,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
//Arrange
mockShortlistCookieService
.Setup(service => service.Get(Constants.ShortlistCookieName))
.Returns(shortlistCookie);
mockLocationCookieService.Setup(x => x.Get(Constants.LocationCookieName))
.Returns(locationCookieItem);
request.RouteName = string.Empty;
//Act
var actual = await controller.CreateShortlistItem(request) as AcceptedResult;
//Assert
actual.Should().NotBeNull();
mockMediator.Verify(x => x.Send(It.Is <CreateShortlistItemForUserCommand>(c =>
c.ShortlistUserId.Equals(shortlistCookie.ShortlistUserId) &&
c.Lat.Equals(locationCookieItem.Lat) &&
c.Lon.Equals(locationCookieItem.Lon) &&
c.LocationDescription.Equals(locationCookieItem.Name) &&
c.Ukprn.Equals(request.Ukprn) &&
c.TrainingCode.Equals(request.TrainingCode)
), It.IsAny <CancellationToken>()), Times.Once);
}
public async Task And_Cookie_Exists_Then_Adds_To_Shortlist_For_User(
Guid expectedId,
CreateShortlistItemRequest request,
ShortlistCookieItem shortlistCookie,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > mockShortlistCookieService,
[Frozen] Mock <ICookieStorageService <LocationCookieItem> > mockLocationCookieService,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
//Arrange
mockMediator.Setup(x => x.Send(It.Is <CreateShortlistItemForUserCommand>(c =>
c.ShortlistUserId.Equals(shortlistCookie.ShortlistUserId) &&
c.Lat == null &&
c.Lon == null &&
c.LocationDescription == null &&
c.Ukprn.Equals(request.Ukprn) &&
c.TrainingCode.Equals(request.TrainingCode)
), It.IsAny <CancellationToken>())).ReturnsAsync(expectedId);
mockShortlistCookieService
.Setup(service => service.Get(Constants.ShortlistCookieName))
.Returns(shortlistCookie);
mockLocationCookieService.Setup(x => x.Get(Constants.LocationCookieName))
.Returns((LocationCookieItem)null);
request.RouteName = string.Empty;
//Act
var actual = await controller.CreateShortlistItem(request) as AcceptedResult;
//Assert
actual.Should().NotBeNull();
Guid.Parse(actual.Value.ToString()).Should().Be(expectedId);
mockShortlistCookieService.Verify(x => x.Update(Constants.ShortlistCookieName, shortlistCookie, 30), Times.Once);
}
public async Task Then_The_Shortlist_UserId_Is_Added_To_The_Cookie_If_Set(
GetCourseProvidersRequest request,
GetCourseProvidersResult response,
ShortlistCookieItem shortlistCookieItem,
[Frozen] Mock <IMediator> mediator,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > shortlistCookieService,
[Greedy] CoursesController controller)
{
//Arrange
response.Course.StandardDates.LastDateStarts = DateTime.UtcNow.AddDays(5);
mediator.Setup(x => x.Send(
It.Is <GetCourseProvidersQuery>(c => c.CourseId.Equals(request.Id) &&
c.ShortlistUserId.Equals(shortlistCookieItem.ShortlistUserId)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
shortlistCookieService.Setup(x => x.Get(Constants.ShortlistCookieName)).Returns(shortlistCookieItem);
//Act
var actual = await controller.CourseProviders(request) as ViewResult;
//Assert
Assert.IsNotNull(actual);
var actualModel = actual.Model as CourseProvidersViewModel;
Assert.IsNotNull(actualModel);
}
public async Task And_If_There_Is_A_Route_Name_Then_It_Is_Redirected(CreateShortlistItemRequest request,
ShortlistCookieItem shortlistCookie,
LocationCookieItem locationCookieItem,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > mockShortlistCookieService,
[Frozen] Mock <ICookieStorageService <LocationCookieItem> > mockLocationCookieService,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
//Arrange
mockShortlistCookieService
.Setup(service => service.Get(Constants.ShortlistCookieName))
.Returns(shortlistCookie);
mockLocationCookieService.Setup(x => x.Get(Constants.LocationCookieName))
.Returns(locationCookieItem);
request.RouteName = RouteNames.CourseProviders;
//Act
var actual = await controller.CreateShortlistItem(request) as RedirectToRouteResult;
//Assert
actual.Should().NotBeNull();
actual.RouteName.Should().Be(request.RouteName);
actual.RouteValues.Should().ContainKey("id");
actual.RouteValues["id"].Should().Be(request.TrainingCode);
actual.RouteValues.Should().ContainKey("providerId");
actual.RouteValues["providerId"].Should().Be(request.Ukprn);
}
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 And_Cookie_Exists_Then_Reads_Cookie_And_Builds_ViewModel_From_Mediator_Result(
ShortlistCookieItem shortlistCookie,
GetShortlistForUserResult resultFromMediator,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > mockCookieService,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IDataProtector> protector,
[Frozen] Mock <IDataProtectionProvider> provider,
[Frozen] Mock <IOptions <FindApprenticeshipTrainingWeb> > config,
[Greedy] ShortlistController controller)
{
//Arrange
config.Object.Value.EmployerDemandFeatureToggle = false;
mockCookieService
.Setup(service => service.Get(Constants.ShortlistCookieName))
.Returns(shortlistCookie);
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetShortlistForUserQuery>(c => c.ShortlistUserId.Equals(shortlistCookie.ShortlistUserId)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(resultFromMediator);
//Act
var actual = await controller.Index("") as ViewResult;
//Assert
actual.Should().NotBeNull();
var model = actual.Model as ShortlistViewModel;
model.Should().NotBeNull();
model.Shortlist.Should()
.BeEquivalentTo(
resultFromMediator.Shortlist.Select(item => (ShortlistItemViewModel)item));
model.Removed.Should().BeEmpty();
model.HelpBaseUrl.Should().BeEmpty();
}
public async Task And_Cookie_No_Exists_Then_Returns_Empty_ViewModel(
ShortlistCookieItem shortlistCookie,
GetShortlistForUserResult resultFromMediator,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > mockCookieService,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
//Arrange
mockCookieService
.Setup(service => service.Get(Constants.ShortlistCookieName))
.Returns(default(ShortlistCookieItem));
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetShortlistForUserQuery>(c => c.ShortlistUserId.Equals(shortlistCookie.ShortlistUserId)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(resultFromMediator);
//Act
var actual = await controller.Index(null) as ViewResult;
//Assert
actual.Should().NotBeNull();
var model = actual.Model as ShortlistViewModel;
model.Should().NotBeNull();
model.Shortlist.Should().BeEmpty();
mockMediator.Verify(mediator => mediator.Send(
It.IsAny <GetShortlistForUserQuery>(),
It.IsAny <CancellationToken>()),
Times.Never);
}
public async Task And_If_ProviderName_Is_In_The_Request_Is_Encoded_Using_The_Protector(
CreateShortlistItemRequest request,
ShortlistCookieItem shortlistCookie,
LocationCookieItem locationCookieItem,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > mockShortlistCookieService,
[Frozen] Mock <ICookieStorageService <LocationCookieItem> > mockLocationCookieService,
[Frozen] Mock <IDataProtector> protector,
[Frozen] Mock <IDataProtectionProvider> provider,
[Greedy] ShortlistController controller)
{
//Arrange
mockShortlistCookieService
.Setup(service => service.Get(Constants.ShortlistCookieName))
.Returns(shortlistCookie);
mockLocationCookieService.Setup(x => x.Get(Constants.LocationCookieName))
.Returns(locationCookieItem);
request.RouteName = RouteNames.CourseProviders;
//Act
await controller.CreateShortlistItem(request);
//Assert
protector.Verify(c => c.Protect(It.Is <byte[]>(
x => x[0].Equals(Encoding.UTF8.GetBytes($"{request.ProviderName}")[0]))), Times.Once);
}
public async Task Then_If_The_Encoded_Removed_Param_Is_Invalid_Then_It_Is_Set_To_Empty(
string removed,
ShortlistCookieItem shortlistCookie,
GetShortlistForUserResult resultFromMediator,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > mockCookieService,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IDataProtector> protector,
[Frozen] Mock <IDataProtectionProvider> provider,
[Greedy] ShortlistController controller)
{
var encodedData = Encoding.UTF8.GetBytes($"{removed}");
mockCookieService
.Setup(service => service.Get(Constants.ShortlistCookieName))
.Returns(shortlistCookie);
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetShortlistForUserQuery>(c => c.ShortlistUserId.Equals(shortlistCookie.ShortlistUserId)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(resultFromMediator);
//Act
var actual = await controller.Index(encodedData.ToString()) as ViewResult;
//Assert
actual.Should().NotBeNull();
var model = actual.Model as ShortlistViewModel;
model.Should().NotBeNull();
model.Shortlist.Should()
.BeEquivalentTo(
resultFromMediator.Shortlist.Select(item => (ShortlistItemViewModel)item));
model.Removed.Should().BeEmpty();
}
public async Task And_If_There_Is_A_RouteName_Then_It_Is_Redirected_And_ProviderName_Not_Encoded_If_Empty(
Guid id,
DeleteShortlistItemRequest request,
ShortlistCookieItem shortlistCookie,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > mockShortlistCookieService,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IDataProtector> protector,
[Greedy] ShortlistController controller)
{
//Arrange
request.ProviderName = string.Empty;
mockShortlistCookieService
.Setup(service => service.Get(Constants.ShortlistCookieName))
.Returns(shortlistCookie);
request.RouteName = RouteNames.CourseProviders;
//Act
var actual = await controller.DeleteShortlistItemForUser(request) as RedirectToRouteResult;
//Assert
actual.Should().NotBeNull();
actual.RouteName.Should().Be(RouteNames.CourseProviders);
actual.RouteValues.Should().ContainKey("id");
actual.RouteValues["id"].Should().Be(request.TrainingCode);
actual.RouteValues.Should().ContainKey("providerId");
actual.RouteValues["providerId"].Should().Be(request.Ukprn);
actual.RouteValues["removed"].Should().Be(string.Empty);
protector.Verify(c => c.Protect(It.IsAny <byte[]>()), Times.Never);
}
public async Task Then_The_Query_Is_Sent_And_Data_Retrieved_And_View_Shown(
int standardCode,
GetCourseResult response,
LocationCookieItem locationCookieItem,
ShortlistCookieItem shortlistCookieItem,
[Frozen] Mock <IMediator> mediator,
[Frozen] Mock <ICookieStorageService <LocationCookieItem> > cookieStorageService,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > shortlistStorageService,
[Greedy] CoursesController controller)
{
//Arrange
response.ShowEmployerDemand = true;
cookieStorageService
.Setup(x => x.Get(Constants.LocationCookieName))
.Returns(locationCookieItem);
shortlistStorageService
.Setup(x => x.Get(Constants.ShortlistCookieName))
.Returns(shortlistCookieItem);
mediator
.Setup(x =>
x.Send(It.Is <GetCourseQuery>(c =>
c.CourseId.Equals(standardCode) &&
c.ShortlistUserId.Equals(shortlistCookieItem.ShortlistUserId) &&
c.Lat.Equals(locationCookieItem.Lat) &&
c.Lon.Equals(locationCookieItem.Lon)
), It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
//Act
var actual = await controller.CourseDetail(standardCode, "");
//Assert
Assert.IsNotNull(actual);
var actualResult = actual as ViewResult;
Assert.IsNotNull(actualResult);
var actualModel = actualResult.Model as CourseViewModel;
Assert.IsNotNull(actualModel);
actualModel.TotalProvidersCount.Should().Be(response.ProvidersCount.TotalProviders);
actualModel.ProvidersAtLocationCount.Should().Be(response.ProvidersCount.ProvidersAtLocation);
actualModel.LocationName.Should().Be(locationCookieItem.Name);
actualModel.ShortlistItemCount.Should().Be(response.ShortlistItemCount);
}
public async Task Then_If_Removed_And_Added_Is_In_The_Request_And_Is_Invalid_Then_Empty_String_Is_Added_To_ViewModel(
int providerId,
int courseId,
string location,
string removed,
GetCourseProviderResult response,
ShortlistCookieItem shortlistCookieItem,
[Frozen] Mock <IMediator> mediator,
[Frozen] Mock <ICookieStorageService <LocationCookieItem> > cookieStorageService,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > shortlistCookieService,
[Frozen] Mock <IDataProtector> protector,
[Frozen] Mock <IDataProtectionProvider> provider,
[Greedy] CoursesController controller
)
{
//Arrange
var encodedData = Encoding.UTF8.GetBytes($"{removed}");
response.Course.StandardDates.LastDateStarts = DateTime.UtcNow.AddDays(5);
response.Location = string.Empty;
response.LocationGeoPoint = null;
protector.Setup(sut => sut.Unprotect(It.IsAny <byte[]>())).Returns(encodedData);
provider.Setup(x => x.CreateProtector(Constants.ShortlistProtectorName)).Returns(protector.Object);
mediator.Setup(x => x.Send(It.Is <GetCourseProviderQuery>(c =>
c.ProviderId.Equals(providerId) &&
c.CourseId.Equals(courseId) &&
c.Location.Equals(location) &&
c.ShortlistUserId.Equals(shortlistCookieItem.ShortlistUserId)
), It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
shortlistCookieService.Setup(x => x.Get(Constants.ShortlistCookieName))
.Returns(shortlistCookieItem);
//Act
var actual = await controller.CourseProviderDetail(courseId, providerId, location, encodedData.ToString(), encodedData.ToString()) as ViewResult;
//Assert
Assert.IsNotNull(actual);
var actualModel = actual.Model as CourseProviderViewModel;
Assert.IsNotNull(actualModel);
actualModel.BannerUpdateMessage.Should().BeEmpty();
}
public async Task Then_The_Query_Is_Sent_And_Provider_Detail_Retrieved_And_Shown_With_Shortlist(
int providerId,
int courseId,
string location,
GetCourseProviderResult response,
ShortlistCookieItem shortlistCookieItem,
[Frozen] Mock <IMediator> mediator,
[Frozen] Mock <ICookieStorageService <LocationCookieItem> > cookieStorageService,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > shortlistCookieService,
[Greedy] CoursesController controller
)
{
//Arrange
response.Course.StandardDates.LastDateStarts = DateTime.UtcNow.AddDays(5);
response.Location = string.Empty;
response.LocationGeoPoint = null;
mediator.Setup(x => x.Send(It.Is <GetCourseProviderQuery>(c =>
c.ProviderId.Equals(providerId) &&
c.CourseId.Equals(courseId) &&
c.Location.Equals(location) &&
c.ShortlistUserId.Equals(shortlistCookieItem.ShortlistUserId)
), It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
shortlistCookieService.Setup(x => x.Get(Constants.ShortlistCookieName))
.Returns(shortlistCookieItem);
//Act
var actual = await controller.CourseProviderDetail(courseId, providerId, location, "", "");
//Assert
Assert.IsNotNull(actual);
var actualResult = actual as ViewResult;
Assert.IsNotNull(actualResult);
var actualModel = actualResult.Model as CourseProviderViewModel;
Assert.IsNotNull(actualModel);
Assert.IsNotNull(actualModel.AdditionalCourses);
Assert.IsNotNull(actualModel.AdditionalCourses.Courses);
actualModel.Location.Should().BeNullOrEmpty();
cookieStorageService.Verify(x => x.Update(Constants.LocationCookieName, It.IsAny <LocationCookieItem>(), It.IsAny <int>()), Times.Never);
}
public async Task Then_The_Help_Url_Set_If_Feature_Disabled(
int providerId,
int courseId,
string location,
string removed,
GetCourseProviderResult response,
ShortlistCookieItem shortlistCookieItem,
[Frozen] Mock <IMediator> mediator,
[Frozen] Mock <ICookieStorageService <LocationCookieItem> > cookieStorageService,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > shortlistCookieService,
[Frozen] Mock <IDataProtector> protector,
[Frozen] Mock <IDataProtectionProvider> provider,
[Frozen] Mock <IOptions <FindApprenticeshipTrainingWeb> > config,
[Greedy] CoursesController controller)
{
//Arrange
config.Object.Value.EmployerDemandFeatureToggle = false;
response.Course.StandardDates.LastDateStarts = DateTime.UtcNow.AddDays(5);
response.Location = string.Empty;
response.LocationGeoPoint = null;
mediator.Setup(x => x.Send(It.Is <GetCourseProviderQuery>(c =>
c.ProviderId.Equals(providerId) &&
c.CourseId.Equals(courseId) &&
c.Location.Equals(location) &&
c.ShortlistUserId.Equals(shortlistCookieItem.ShortlistUserId)
), It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
shortlistCookieService.Setup(x => x.Get(Constants.ShortlistCookieName))
.Returns(shortlistCookieItem);
//Act
var actual = await controller.CourseProviderDetail(courseId, providerId, location, "", "") as ViewResult;
//Assert
Assert.IsNotNull(actual);
var actualModel = actual.Model as CourseProviderViewModel;
Assert.IsNotNull(actualModel);
actualModel.HelpFindingCourseUrl.Should().Be("https://help.apprenticeships.education.gov.uk/hc/en-gb#contact-us");
}
public async Task <IActionResult> CreateShortlistItem(CreateShortlistItemRequest request)
{
var cookie = _shortlistCookieService.Get(Constants.ShortlistCookieName);
if (cookie == null)
{
cookie = new ShortlistCookieItem
{
ShortlistUserId = Guid.NewGuid()
};
}
_shortlistCookieService.Update(Constants.ShortlistCookieName, cookie, 30);
var location = _locationCookieService.Get(Constants.LocationCookieName);
var result = await _mediator.Send(new CreateShortlistItemForUserCommand
{
Lat = location?.Lat,
Lon = location?.Lon,
Ukprn = request.Ukprn,
LocationDescription = string.IsNullOrEmpty(location?.Name) ? null : location.Name,
TrainingCode = request.TrainingCode,
ShortlistUserId = cookie.ShortlistUserId
});
if (!string.IsNullOrEmpty(request.RouteName))
{
return(RedirectToRoute(request.RouteName, new
{
Id = request.TrainingCode,
ProviderId = request.Ukprn,
Added = string.IsNullOrEmpty(request.ProviderName) ? "" : WebEncoders.Base64UrlEncode(_protector.Protect(
System.Text.Encoding.UTF8.GetBytes($"{request.ProviderName}")))
}));
}
return(Accepted(result));
}
public async Task Then_The_Help_Link_Is_Shown_If_The_Feature_Is_Toggled_On(ShortlistCookieItem shortlistCookie,
GetShortlistForUserResult resultFromMediator,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > mockCookieService,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IDataProtector> protector,
[Frozen] Mock <IDataProtectionProvider> provider,
[Frozen] Mock <IOptions <FindApprenticeshipTrainingWeb> > config,
[Greedy] ShortlistController controller)
{
//Arrange
config.Object.Value.EmployerDemandFeatureToggle = true;
mockCookieService
.Setup(service => service.Get(Constants.ShortlistCookieName))
.Returns(shortlistCookie);
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetShortlistForUserQuery>(c => c.ShortlistUserId.Equals(shortlistCookie.ShortlistUserId)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(resultFromMediator);
//Act
var actual = await controller.Index("") as ViewResult;
//Assert
actual.Should().NotBeNull();
var model = actual.Model as ShortlistViewModel;
model.Should().NotBeNull();
model.Shortlist.Should()
.BeEquivalentTo(
resultFromMediator.Shortlist.Select(item => (ShortlistItemViewModel)item));
model.Removed.Should().BeEmpty();
model.HelpBaseUrl.Should().Be(config.Object.Value.EmployerDemandUrl);
foreach (var itemViewModel in model.Shortlist)
{
itemViewModel.HelpFindingCourseUrl.Should().Be($"/registerdemand/course/{itemViewModel.Course.Id}/share-interest?entrypoint=0");
}
}
public async Task And_Cookie_Exists_Then_Deletes_Shortlist_Item_For_User(
DeleteShortlistItemRequest request,
ShortlistCookieItem shortlistCookie,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > mockShortlistCookieService,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
//Arrange
mockShortlistCookieService
.Setup(service => service.Get(Constants.ShortlistCookieName))
.Returns(shortlistCookie);
request.RouteName = string.Empty;
//Act
var actual = await controller.DeleteShortlistItemForUser(request) as AcceptedResult;
//Assert
actual.Should().NotBeNull();
mockMediator.Verify(x => x.Send(It.Is <DeleteShortlistItemForUserCommand>(c =>
c.ShortlistUserId.Equals(shortlistCookie.ShortlistUserId) &&
c.Id.Equals(request.ShortlistId)
), It.IsAny <CancellationToken>()), Times.Once);
}
public async Task Then_If_The_Removed_Query_Param_Is_Set_It_Is_Decoded(
string removed,
ShortlistCookieItem shortlistCookie,
GetShortlistForUserResult resultFromMediator,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > mockCookieService,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IDataProtector> protector,
[Frozen] Mock <IDataProtectionProvider> provider,
[Greedy] ShortlistController controller)
{
//Arrange
var encodedData = Encoding.UTF8.GetBytes($"{removed}");
protector.Setup(sut => sut.Unprotect(It.IsAny <byte[]>())).Returns(encodedData);
provider.Setup(x => x.CreateProtector(Constants.ShortlistProtectorName)).Returns(protector.Object);
mockCookieService
.Setup(service => service.Get(Constants.ShortlistCookieName))
.Returns(shortlistCookie);
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetShortlistForUserQuery>(c => c.ShortlistUserId.Equals(shortlistCookie.ShortlistUserId)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(resultFromMediator);
//Act
var actual = await controller.Index(WebEncoders.Base64UrlEncode(encodedData)) as ViewResult;
//Assert
actual.Should().NotBeNull();
var model = actual.Model as ShortlistViewModel;
model.Should().NotBeNull();
model.Shortlist.Should()
.BeEquivalentTo(
resultFromMediator.Shortlist.Select(item => (ShortlistItemViewModel)item));
model.Removed.Should().Be(removed);
}
