public async Task And_The_Cookie_Does_Not_Exist_Then_A_New_Cookie_Is_Created_And_Used_For_Shortlist(
CreateShortlistItemRequest request,
[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((ShortlistCookieItem)null);
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();
mockMediator.Verify(x => x.Send(It.Is <CreateShortlistItemForUserCommand>(c =>
c.Lat == null &&
c.Lon == null &&
c.LocationDescription == null &&
c.Ukprn.Equals(request.Ukprn) &&
c.TrainingCode.Equals(request.TrainingCode)
), It.IsAny <CancellationToken>()), Times.Once);
mockShortlistCookieService.Verify(x =>
x.Update(
Constants.ShortlistCookieName,
It.Is <ShortlistCookieItem>(c => c.ShortlistUserId != Guid.Empty),
30), Times.Once);
}
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_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_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 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_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_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 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_Calls_Mediator_Passing_The_Id(
Guid shortlistUserId,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
var actual = await controller.DeleteShortlistForUser(shortlistUserId) as ObjectResult;
Assert.IsNotNull(actual);
actual.StatusCode.Should().Be((int)HttpStatusCode.Accepted);
mockMediator.Verify(
x => x.Send(It.Is <DeleteShortlistForUserCommand>(c => c.ShortlistUserId.Equals(shortlistUserId)),
It.IsAny <CancellationToken>()), Times.Once);
}
public async Task And_Exception_Then_Returns_InternalServerError(
Guid shortlistUserId,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
mockMediator.Setup(
x => x.Send(It.Is <DeleteShortlistForUserCommand>(c => c.ShortlistUserId.Equals(shortlistUserId)),
It.IsAny <CancellationToken>())).ThrowsAsync(new Exception());
var actual = await controller.DeleteShortlistForUser(shortlistUserId) as StatusCodeResult;
actual !.StatusCode.Should().Be((int)HttpStatusCode.InternalServerError);
}
public async Task And_Exception_Then_Returns_InternalServerError(
uint expiryPeriodInDays,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetExpiredShortlistUsersQuery>(c => c.ExpiryInDays.Equals(expiryPeriodInDays)),
It.IsAny <CancellationToken>())).ThrowsAsync(new Exception());
var actual = await controller.GetExpiredShortlistUserIds(expiryPeriodInDays) as StatusCodeResult;
actual !.StatusCode.Should().Be((int)HttpStatusCode.InternalServerError);
}
public async Task Then_Deletes_Shortlist_For_User_From_Mediator(
Guid id,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
var controllerResult = await controller.DeleteShortlistForUser(id) as ObjectResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.Accepted);
mockMediator
.Verify(mediator => mediator.Send(
It.Is <DeleteShortlistForUserCommand>(command =>
command.UserId == id),
It.IsAny <CancellationToken>()), Times.Once);
}
public async Task Then_If_There_Is_An_Error_A_Bad_Request_Is_Returned(
CreateShortListRequest shortlistRequest,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <CreateShortlistForUserCommand>(),
It.IsAny <CancellationToken>())).ThrowsAsync(new Exception());
var controllerResult = await controller.CreateShortlistForUser(shortlistRequest) as StatusCodeResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
}
public async Task And_Exception_Then_Returns_Bad_Request(
Guid id,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <DeleteShortlistForUserCommand>(),
It.IsAny <CancellationToken>()))
.Throws <InvalidOperationException>();
var controllerResult = await controller.DeleteShortlistForUser(id) as StatusCodeResult;
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
}
public async Task And_Exception_Then_Returns_Bad_Request(
uint expiryInDays,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetExpiredShortlistsQuery>(),
It.IsAny <CancellationToken>()))
.Throws <InvalidOperationException>();
var controllerResult = await controller.GetExpiredShortlistUserIds(expiryInDays) as StatusCodeResult;
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
}
public async Task And_Exception_Then_Returns_Error(
CreateShortlistRequest request,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <CreateShortlistItemForUserRequest>(),
It.IsAny <CancellationToken>()))
.Throws <InvalidOperationException>();
var controllerResult = await controller.CreateShortlistItemForUser(request) as StatusCodeResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.InternalServerError);
}
public async Task Then_Calls_Delete_Shortlist_From_Mediator(
Guid userId,
Guid id,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
var controllerResult = await controller.DeleteShortlistItemForUser(userId, id) as ObjectResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.Accepted);
mockMediator
.Verify(mediator => mediator.Send(
It.Is <DeleteShortlistItemForUserRequest>(query =>
query.ShortlistUserId == userId && query.Id == id),
It.IsAny <CancellationToken>()), Times.Once);
}
public async Task Then_If_There_Is_A_HttpException_It_Is_Returned(
string errorContent,
CreateShortListRequest shortlistRequest,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <CreateShortlistForUserCommand>(),
It.IsAny <CancellationToken>()))
.ThrowsAsync(new HttpRequestContentException("Error", HttpStatusCode.BadRequest, errorContent));
var controllerResult = await controller.CreateShortlistForUser(shortlistRequest) as ObjectResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
controllerResult.Value.Should().Be(errorContent);
}
public async Task Then_Gets_Shortlist_UserIds_From_Mediator(
uint expiryPeriodInDays,
GetExpiredShortlistUsersQueryResult result,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetExpiredShortlistUsersQuery>(c => c.ExpiryInDays.Equals(expiryPeriodInDays)),
It.IsAny <CancellationToken>())).ReturnsAsync(result);
var actual = await controller.GetExpiredShortlistUserIds(expiryPeriodInDays) as ObjectResult;
actual !.StatusCode.Should().Be((int)HttpStatusCode.OK);
var actualModel = actual.Value;
actualModel.Should().BeEquivalentTo(new { result.UserIds });
}
public async Task Then_Gets_Expired_Shortlist_UserIds_For_User_From_Mediator(
uint expiryInDays,
GetExpiredShortlistsQueryResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetExpiredShortlistsQuery>(query => query.ExpiryInDays == expiryInDays),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetExpiredShortlistUserIds(expiryInDays) as ObjectResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value;
model !.Should().BeEquivalentTo(new { mediatorResult.UserIds });
}
public async Task Then_Gets_Shortlist_For_User_From_Mediator(
Guid shortlistUserId,
GetShortlistForUserResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetShortlistForUserQuery>(query => query.ShortlistUserId == shortlistUserId),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetAllForUser(shortlistUserId) as ObjectResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetShortlistForUserResponse;
model !.Shortlist.Should().BeEquivalentTo(mediatorResult.Shortlist.Select(item => (GetShortlistItem)item));
}
public async Task Then_Gets_Shortlist_Item_Count_From_Mediator(
Guid userId,
int queryResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetShortlistForUserCountQuery>(query =>
query.UserId == userId),
It.IsAny <CancellationToken>()))
.ReturnsAsync(queryResult);
var controllerResult = await controller.GetShortlistForUserCount(userId) as ObjectResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetShortlistForUserCountResponse;
model !.Count.Should().Be(queryResult);
}
public async Task And_Validation_Exception_Then_Returns_BadRequest(
string errorKey,
CreateShortlistRequest request,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
var validationResult = new ValidationResult {
ValidationDictionary = { { errorKey, "Some error" } }
};
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <CreateShortlistItemForUserRequest>(),
It.IsAny <CancellationToken>()))
.Throws(new ValidationException(validationResult.DataAnnotationResult, null, null));
var controllerResult = await controller.CreateShortlistItemForUser(request) as ObjectResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
controllerResult.Value.ToString().Should().Contain(errorKey);
}
public async Task And_Cookie_Does_Not_Exists_Then_Deletes_Command_Is_Not_Called(
Guid id,
DeleteShortlistItemRequest request,
[Frozen] Mock <ICookieStorageService <ShortlistCookieItem> > mockShortlistCookieService,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
//Arrange
mockShortlistCookieService
.Setup(service => service.Get(Constants.ShortlistCookieName))
.Returns((ShortlistCookieItem)null);
request.RouteName = string.Empty;
//Act
var actual = await controller.DeleteShortlistItemForUser(request) as AcceptedResult;
//Assert
actual.Should().NotBeNull();
mockMediator.Verify(x => x.Send(It.IsAny <DeleteShortlistItemForUserCommand>(),
It.IsAny <CancellationToken>()), Times.Never);
}
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_Creates_Shortlist_From_Mediator_Command(
Guid returnId,
CreateShortListRequest shortlistRequest,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] ShortlistController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <CreateShortlistForUserCommand>(command =>
command.ShortlistUserId == shortlistRequest.ShortlistUserId &&
command.Lat.Equals(shortlistRequest.Lat) &&
command.Lon.Equals(shortlistRequest.Lon) &&
command.Ukprn.Equals(shortlistRequest.Ukprn) &&
command.LocationDescription.Equals(shortlistRequest.LocationDescription) &&
command.StandardId.Equals(shortlistRequest.StandardId)
),
It.IsAny <CancellationToken>())).ReturnsAsync((returnId));
var controllerResult = await controller.CreateShortlistForUser(shortlistRequest) as CreatedResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.Created);
controllerResult.Value.Should().Be(returnId);
}
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);
}
public async Task Then_Gets_Shortlist_From_Mediator(
string controllerName,
Guid returnId,
CreateShortlistRequest request,
[Frozen] Mock <HttpContext> httpContext,
[Frozen] Mock <IMediator> mockMediator)
{
httpContext = new Mock <HttpContext>();
var controller = new ShortlistController(mockMediator.Object, Mock.Of <ILogger <ShortlistController> >())
{
ControllerContext = { HttpContext = httpContext.Object,
ActionDescriptor = new ControllerActionDescriptor
{
ControllerName = controllerName
} }
};
mockMediator
.Setup(mediator => mediator.Send(
It.Is <CreateShortlistItemForUserRequest>(query =>
query.ShortlistUserId == request.ShortlistUserId &&
query.Lat.Equals(request.Lat) &&
query.Lon.Equals(request.Lon) &&
query.StandardId == request.StandardId &&
query.LocationDescription == request.LocationDescription &&
query.Ukprn == request.Ukprn &&
query.SectorSubjectArea == request.SectorSubjectArea
),
It.IsAny <CancellationToken>())).ReturnsAsync(returnId);
var controllerResult = await controller.CreateShortlistItemForUser(request) as CreatedResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.Created);
controllerResult.Location.Should().Be($"/api/{controllerName}/{request.ShortlistUserId}/items/{returnId}");
}
