public async Task Then_Redirects_To_The_Confirmation_Employer_View_With_ProviderId_When_Part_Of_Empty_Cohort(
ReservationsRouteModel routeModel,
PostReviewViewModel viewModel,
CreateReservationResult createReservationResult,
[Frozen] Mock <IMediator> mockMediator,
ReservationsController controller)
{
createReservationResult.IsEmptyCohortFromSelect = true;
routeModel.UkPrn = null;
var claim = new Claim(EmployerClaims.IdamsUserIdClaimTypeIdentifier, Guid.NewGuid().ToString());
controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { claim }));
viewModel.Reserve = true;
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <CreateReservationCommand>(), CancellationToken.None))
.ReturnsAsync(createReservationResult);
var result = await controller.PostReview(routeModel, viewModel) as RedirectToRouteResult;
result.Should().NotBeNull($"result was not a {typeof(RedirectToRouteResult)}");
result.RouteName.Should().Be(RouteNames.EmployerCompleted);
result.RouteValues.Should().ContainKey("id").WhichValue.Should().NotBe(Guid.Empty);
result.RouteValues.Should().ContainKey("cohortReference")
.WhichValue.Should().Be(createReservationResult.CohortRef);
result.RouteValues.Should().ContainKey("accountLegalEntityPublicHashedId")
.WhichValue.Should().Be(createReservationResult.AccountLegalEntityPublicHashedId);
result.RouteValues.Should().ContainKey("providerId")
.WhichValue.Should().Be(createReservationResult.ProviderId);
}
public void Then_The_Model_Is_Constructed_With_Correct_Route_Names_Using_Other_Constructor(uint?ukPrn)
{
//Arrange
var startDate = new TrainingDateModel {
StartDate = DateTime.Now
};
var reservationsRouteModel = new ReservationsRouteModel
{
AccountLegalEntityPublicHashedId = AccountLegalEntityPublicHashedId,
UkPrn = ukPrn,
Id = new Guid(),
EmployerAccountId = "123FDS",
FromReview = true
};
var postReviewViewModel = new PostReviewViewModel
{
AccountLegalEntityName = AccountLegalEntityName,
AccountLegalEntityPublicHashedId = AccountLegalEntityPublicHashedId,
CourseDescription = CourseDescription,
TrainingDate = startDate,
Reserve = ExpectedReserve
};
//Act
var actual = new ReviewViewModel(reservationsRouteModel, postReviewViewModel);
//Assert
AssertAllProperties(actual, ukPrn, startDate);
Assert.AreEqual(ExpectedReserve, actual.Reserve);
}
public void Add_A_Stat_For_Sentences_Per_Paragraph()
{
Post.Content = "<p>This is a dog. This is a basset hound.</p><p>This is something.</p>";
Target = new PostReviewViewModel(Post, new RenderedPostContents(Post.Content));
Target.Stats["Sentences Per Paragraph"].ShouldBe("1.5");
}
public void Add_A_Warning_For_Non_SSL_Links()
{
Post.Content = $@"<p>Only an external <a href=""http://wwww.theonion.com/blah"">link</a>.</p>";
Target = new PostReviewViewModel(Post, new RenderedPostContents(Post.Content));
Target.Warnings.ShouldContain(s => s.Contains("non-SSL links"));
}
public void Add_A_Warning_When_Post_Is_Less_Than_Ninety_Percent_Of_Length()
{
RenderedContents.Arrange(rc => rc.WordCount).Returns(1079);
Target = new PostReviewViewModel(Post, RenderedContents);
Target.Warnings.ShouldContain(s => s.Contains("too short"));
}
public void Add_A_Warning_When_No_Internal_Links_Exist()
{
Post.Content = $@"<p>Only an external <a href=""https://wwww.theonion.com/blah"">link</a>.</p>";
Target = new PostReviewViewModel(Post, new RenderedPostContents(Post.Content));
Target.Warnings.ShouldNotBeEmpty();
}
public async Task And_Invalid_ViewModel_And_Has_Ukprn_Then_Continues_As_Normal(
ReservationsRouteModel routeModel,
PostReviewViewModel viewModel,
ReservationsController controller)
{
controller.ModelState.AddModelError("key", "error message");
var result = await controller.PostReview(routeModel, viewModel) as RedirectToRouteResult;
result.RouteName.Should().Be(RouteNames.ProviderCompleted);
}
public ActionResult Review(int postId)
{
var post = _blogContext.BlogPosts.First(p => p.Id == postId);
AuthorizeWordpress();
post.Content = _wordpressService.GetBlogPostById(post.WordpressId).Content;
var viewModel = new PostReviewViewModel(post, new RenderedPostContents(post.Content));
_blogContext.SaveChanges();
return(View(viewModel));
}
public async Task Then_Sends_Create_Command_With_Correct_Values_Set(
ReservationsRouteModel routeModel,
PostReviewViewModel viewModel,
[Frozen] Mock <IMediator> mockMediator,
ReservationsController controller)
{
await controller.PostReview(routeModel, viewModel);
mockMediator.Verify(mediator =>
mediator.Send(It.Is <CreateReservationCommand>(command =>
command.Id == routeModel.Id), It.IsAny <CancellationToken>()));
}
public async Task And_Invalid_ViewModel_And_No_Ukprn_Then_Renders_Provider_Review_Again(
ReservationsRouteModel routeModel,
PostReviewViewModel viewModel,
ReservationsController controller)
{
routeModel.UkPrn = null;
controller.ModelState.AddModelError("key", "error message");
var result = await controller.PostReview(routeModel, viewModel) as ViewResult;
result.ViewName.Should().Be(ViewNames.EmployerReview);
result.Model.Should().BeEquivalentTo(new ReviewViewModel(routeModel, viewModel));
}
public async Task And_Reserve_False_And_No_Ukprn_Then_Redirect_To_Account_Home(
ReservationsRouteModel routeModel,
PostReviewViewModel viewModel,
string expectedUrl,
[Frozen] Mock <IExternalUrlHelper> mockUrlHelper,
ReservationsController controller)
{
viewModel.Reserve = false;
routeModel.UkPrn = null;
mockUrlHelper
.Setup(helper => helper.GenerateDashboardUrl(routeModel.EmployerAccountId))
.Returns(expectedUrl);
var result = await controller.PostReview(routeModel, viewModel) as RedirectResult;
result.Url.Should().Be(expectedUrl);
}
private IActionResult PostReviewStep(bool reserve)
{
var controller = Services.GetService <ReservationsController>();
var claim = new Claim(EmployerClaims.IdamsUserIdClaimTypeIdentifier, TestData.UserId.ToString());
controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { claim }));
var viewModel = new PostReviewViewModel
{
Reserve = reserve,
TrainingDate = TestData.TrainingDate
};
var result = controller.PostReview(TestData.ReservationRouteModel, viewModel)
.Result;
return(result);
}
public async Task And_CachedReservationNotFoundException_And_Has_Ukprn_Then_Redirects_To_ProviderIndex(
ReservationsRouteModel routeModel,
PostReviewViewModel viewModel,
CachedReservationNotFoundException notFoundException,
[Frozen] Mock <IMediator> mockMediator,
ReservationsController controller)
{
mockMediator.Setup(x => x.Send(It.IsAny <CreateReservationCommand>(), It.IsAny <CancellationToken>()))
.ThrowsAsync(notFoundException);
var actual = await controller.PostReview(routeModel, viewModel);
actual.Should().NotBeNull();
var redirectToRouteResult = actual as RedirectToRouteResult;
redirectToRouteResult.Should().NotBeNull();
redirectToRouteResult?.RouteName.Should().Be(RouteNames.ProviderIndex);
}
public async Task Then_Sends_UserId_If_Employer_Command_With_Correct_Values_Set(
Guid expectedUserId,
ReservationsRouteModel routeModel,
PostReviewViewModel viewModel,
[Frozen] Mock <IMediator> mockMediator,
ReservationsController controller)
{
routeModel.UkPrn = null;
viewModel.Reserve = true;
var claim = new Claim(EmployerClaims.IdamsUserIdClaimTypeIdentifier, expectedUserId.ToString());
controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { claim }));
await controller.PostReview(routeModel, viewModel);
mockMediator.Verify(mediator =>
mediator.Send(It.Is <CreateReservationCommand>(command =>
command.Id == routeModel.Id && command.UserId.Equals(expectedUserId)), It.IsAny <CancellationToken>()));
}
public async Task Then_Redirects_To_The_Confirmation_Provider_View_When_Has_UkPrn(
ReservationsRouteModel routeModel,
PostReviewViewModel viewModel,
CreateReservationResult createReservationResult,
[Frozen] Mock <IMediator> mockMediator,
ReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <CreateReservationCommand>(), CancellationToken.None))
.ReturnsAsync(createReservationResult);
var result = await controller.PostReview(routeModel, viewModel) as RedirectToRouteResult;
result.Should().NotBeNull($"result was not a {typeof(RedirectToRouteResult)}");
result.RouteName.Should().Be(RouteNames.ProviderCompleted);
result.RouteValues.Should().ContainKey("id").WhichValue.Should().NotBe(Guid.Empty);
result.RouteValues.Should().ContainKey("accountLegalEntityPublicHashedId")
.WhichValue.Should().Be(createReservationResult.AccountLegalEntityPublicHashedId);
result.RouteValues.Should().ContainKey("cohortReference")
.WhichValue.Should().Be(createReservationResult.CohortRef);
}
public async Task And_CachedReservationNotFoundException_And_No_Ukprn_Then_Redirects_To_EmployerIndex(
ReservationsRouteModel routeModel,
PostReviewViewModel viewModel,
CachedReservationNotFoundException notFoundException,
[Frozen] Mock <IMediator> mockMediator,
ReservationsController controller)
{
routeModel.UkPrn = null;
var claim = new Claim(EmployerClaims.IdamsUserIdClaimTypeIdentifier, Guid.NewGuid().ToString());
controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { claim }));
viewModel.Reserve = true;
mockMediator.Setup(x => x.Send(It.IsAny <CreateReservationCommand>(), It.IsAny <CancellationToken>()))
.ThrowsAsync(notFoundException);
var actual = await controller.PostReview(routeModel, viewModel);
actual.Should().NotBeNull();
var redirectToRouteResult = actual as RedirectToRouteResult;
redirectToRouteResult.Should().NotBeNull();
redirectToRouteResult?.RouteName.Should().Be(RouteNames.EmployerIndex);
}
//[OutputCache(Duration = 120)]
public ActionResult PostInfo(Guid postId)
{
var review = this.reviewService.GetPostReview(postId, this.HttpContext.User.Identity.GetUserId());
Guard.WhenArgument(review, "review").IsNull().Throw();
var reviewVm = new PostReviewViewModel()
{
PostId = review.PostId,
IsRated = review.Ratings.Any(),
RatedFromViewer = review.RatedFromViewer,
Comments = review.Comments.Select(c => new CommentReviewViewModel()
{
Username = c.AuthorId,
Content = c.Content,
CreatedOn = c.CreatedOn
}),
Book = new BookReviewViewModel()
{
Id = review.Book.Id,
Author = review.Book.Author,
Category = review.Book.Category,
Title = review.Book.Title,
Wishers = review.Book.Wishers
},
Description = review.Description,
CreatedOn = review.CreatedOn,
IsOwned = review.IsOwned,
IsRead = review.IsRead,
IsTradable = review.IsTradable,
Price = review.Price,
Username = this.userManager.FindById(review.PublisherId).UserName,
Ratings = review.Ratings
};
return(this.PartialView("_PostInfo", reviewVm));
}
public async Task <IActionResult> PostReview(ReservationsRouteModel routeModel, PostReviewViewModel viewModel)
{
var isProvider = routeModel.UkPrn.HasValue;
var reviewViewName = isProvider ? ViewNames.ProviderReview : ViewNames.EmployerReview;
try
{
if (!isProvider)
{
if (!ModelState.IsValid)
{
var reviewViewModel = new ReviewViewModel(routeModel, viewModel);
return(View(reviewViewName, reviewViewModel));
}
if (!viewModel.Reserve.Value)
{
var homeUrl = _urlHelper.GenerateDashboardUrl(routeModel.EmployerAccountId);
return(Redirect(homeUrl));
}
}
Guid?userId = null;
if (!isProvider)
{
var userAccountIdClaim = HttpContext.User.Claims.First(c => c.Type.Equals(EmployerClaims.IdamsUserIdClaimTypeIdentifier));
userId = Guid.Parse(userAccountIdClaim.Value);
}
var command = new CreateReservationCommand
{
Id = routeModel.Id.GetValueOrDefault(),
UkPrn = routeModel.UkPrn,
UserId = userId
};
var result = await _mediator.Send(command);
routeModel.AccountLegalEntityPublicHashedId = result.AccountLegalEntityPublicHashedId;
routeModel.CohortReference = result.CohortRef;
if (result.IsEmptyCohortFromSelect)
{
routeModel.ProviderId = result.ProviderId;
}
}
catch (ValidationException ex)
{
_logger.LogWarning(ex, "Validation error when trying to create reservation from cached reservation.");
return(RedirectToRoute(routeModel.UkPrn.HasValue ? RouteNames.ProviderIndex : RouteNames.EmployerIndex, routeModel));
}
catch (CachedReservationNotFoundException ex)
{
_logger.LogWarning(ex, "Expected a cached reservation but did not find one.");
return(RedirectToRoute(routeModel.UkPrn.HasValue ? RouteNames.ProviderIndex : RouteNames.EmployerIndex, routeModel));
}
return(RedirectToRoute(routeModel.UkPrn.HasValue ? RouteNames.ProviderCompleted : RouteNames.EmployerCompleted, routeModel));
}
public void Have_No_Internal_Links_When_Post_Blog_Is_Null()
{
Post.Blog = null;
Target = new PostReviewViewModel(Post, new RenderedPostContents(Post.Content));
Target.InternalLinks.Count().ShouldBe(0);
}
public void BeforeEachTest()
{
Target = new PostReviewViewModel(Post, new RenderedPostContents(Post.Content));
}
