public async Task CreateReviewFailureTest(ReviewEntity reviewEntity, string authorUserName)
{
// Arrange
var mockUserRepository = new Mock <IUserProfileRepository>();
mockUserRepository.Setup(x => x.GetAsync(It.IsAny <Expression <Func <UserProfileEntity, bool> > >()))
.Returns(Task.FromResult(_userProfileEntityCollection.Where(x => x.UserName.Equals(authorUserName, StringComparison.OrdinalIgnoreCase))));
var mockReviewRepository = new Mock <IReviewRepository>();
mockReviewRepository.Setup(x => x.CreateAsync(It.IsAny <ReviewEntity>()))
.Returns(Task.FromResult(default(ReviewEntity)));
mockReviewRepository.Setup(x => x.GetAsync(It.IsAny <Expression <Func <ReviewEntity, bool> > >()))
.Throws <EntityAlreadyExistException>();
var mockUnitOfWork = new Mock <IUnitOfWork>();
mockUnitOfWork.SetupGet(x => x.ReviewRepository).Returns(mockReviewRepository.Object);
mockUnitOfWork.SetupGet(x => x.UserProfileRepository).Returns(mockUserRepository.Object);
// Act
var reviewService = new ReviewService(mockUnitOfWork.Object);
await Assert.ThrowsAsync <EntityAlreadyExistException>(() => reviewService.CreateAsync(reviewEntity, authorUserName));
// Assert
mockReviewRepository.Verify(x => x.CreateAsync(It.IsAny <ReviewEntity>()), Times.Never);
mockReviewRepository.Verify(x => x.GetAsync(It.IsAny <Expression <Func <ReviewEntity, bool> > >()), Times.Once);
}
public async Task <IActionResult> AddReview(ReviewEditModel model, long productId)
{
if (HttpMethods.IsGet(Request.Method))
{
ModelState.Clear();
await _appService.PrepareModelAsync(model, null);
}
else if (HttpMethods.IsPost(Request.Method))
{
if (ModelState.IsValid)
{
var seller = await HttpContext.GetSellerAsync();
var customer = await HttpContext.GetMemberAsync();
var review = new Review();
await _appService.PrepareReviewAsync(review, model);
review.ProductId = productId;
review.CustomerId = customer.Id;
review.Approved = true;
await _reviewService.CreateAsync(review);
TempData.AddAlert(AlertMode.Notify, AlertType.Success, $"\"{review.Title}\" review was added.");
}
}
return(PartialView("ReviewEdit", model));
}
public async Task CreateReviewSuccessfully()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var dbContext = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository <Review>(dbContext);
var service = new ReviewService(repository);
await service.CreateAsync(1, UserId, "Fantastic");
await service.CreateAsync(2, UserId, "Not bad");
Assert.Equal(2, repository.All().Count());
}
public async Task <IActionResult> Create([FromBody] ReviewViewModel model)
{
var user = await GetCurrentUserAsync();
var review = model.Adapt <Review>();
review.User = user;
await _reviewService.CreateAsync(review);
return(Ok(review.Id));
}
public async Task <IActionResult> New(NewReviewModel model)
{
var result = await _movies.GetDetailsAsync(model.MovieId);
if (result.IsAccessDenied)
{
return(Forbid());
}
if (!result.Succeeded)
{
return(Error(result.Errors));
}
var movie = result.Value;
if (movie == null)
{
return(RedirectToAction("Index", "Movies"));
}
if (!movie.CanReview)
{
return(Forbid());
}
if (ModelState.IsValid)
{
var create = await _reviews.CreateAsync(model.MovieId, model.Stars, model.Comment);
if (create.IsAccessDenied)
{
return(new ForbidResult());
}
if (create.Succeeded)
{
return(View("Success", new ReviewSuccessViewModel {
MovieId = model.MovieId, Action = "Created"
}));
}
else
{
foreach (var error in create.Errors)
{
ModelState.AddModelError("", error);
}
}
}
model.MovieTitle = movie.Title;
return(View(model));
}
public async Task CreateAsync_ShouldCreateNewReview()
{
// Arrange
FitStoreDbContext database = this.Database;
IReviewService reviewService = new ReviewService(database);
// Act
await reviewService.CreateAsync(content, rating, userId, supplementId);
// Assert
Review review = database.Reviews.Find(reviewId);
review.Content.Should().Be(content);
review.Rating.Should().Be(rating);
review.AuthorId.Should().Be(userId);
review.SupplementId.Should().Be(supplementId);
}
public async Task CreateReviewSuccessTest(ReviewEntity reviewEntity, string authorUserName, ReviewEntity expected)
{
// Arrange
var mockUserRepository = new Mock <IUserProfileRepository>();
mockUserRepository.Setup(x => x.GetAsync(It.IsAny <Expression <Func <UserProfileEntity, bool> > >()))
.Returns(Task.FromResult(_userProfileEntityCollection.Where(x => x.UserName.Equals(authorUserName, StringComparison.OrdinalIgnoreCase))));
var mockReviewRepository = new Mock <IReviewRepository>();
mockReviewRepository.Setup(x => x.CreateAsync(It.IsAny <ReviewEntity>()))
.Returns(Task.FromResult(expected));
mockReviewRepository.Setup(x => x.GetAsync(It.IsAny <Expression <Func <ReviewEntity, bool> > >()))
.Returns(Task.FromResult(EntityCollection.Where(x => Equals(x.AuthorId, reviewEntity.AuthorId) &&
Equals(x.MovieId, reviewEntity.MovieId))));
var mockUnitOfWork = new Mock <IUnitOfWork>();
mockUnitOfWork.SetupGet(x => x.ReviewRepository).Returns(mockReviewRepository.Object);
mockUnitOfWork.SetupGet(x => x.UserProfileRepository).Returns(mockUserRepository.Object);
// Act
var reviewService = new ReviewService(mockUnitOfWork.Object);
var result = await reviewService.CreateAsync(reviewEntity, authorUserName);
// Assert
Assert.False(string.IsNullOrEmpty(result.Id));
Assert.Equal(expected.MovieId, result.MovieId);
Assert.Equal(expected.AuthorId, result.AuthorId);
Assert.Equal(expected.ReviewTitle, result.ReviewTitle);
Assert.Equal(expected.ReviewDescription, result.ReviewDescription);
Assert.Equal(expected.Rating, result.Rating);
mockReviewRepository.Verify(x => x.CreateAsync(It.IsAny <ReviewEntity>()), Times.Once);
mockReviewRepository.Verify(x => x.GetAsync(It.IsAny <Expression <Func <ReviewEntity, bool> > >()), Times.Once);
}
public async Task Create_Review_WithWrongCategory()
{
var options = Utils.GetOptions(nameof(Create_Review_WithWrongCategory));
var userStore = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(userStore.Object, null, null, null,
null, null, null, null, null);
var contextAccessor = new Mock <IHttpContextAccessor>();
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >().Object;
var signManager = new Mock <SignInManager <User> >(userManager.Object, contextAccessor.Object, userPrincipalFactory, null, null, null, null).Object;
var context = new Mock <HttpContext>();
contextAccessor.Setup(x => x.HttpContext).Returns(context.Object);
var userService = new Mock <IUserService>();
var photoService = new Mock <IPhotoService>();
var newReviewDTO = new Mock <NewReviewDTO>().Object;
newReviewDTO.PhotoId = Guid.Parse("e165b91f-03bf-414e-88b7-c51b87775683");
newReviewDTO.Comment = "new comment";
newReviewDTO.Score = 5;
newReviewDTO.WrongCategory = true;
using (var arrContext = new PhotoContestContext(options))
{
await arrContext.Contests.AddRangeAsync(Utils.SeedContests());
await arrContext.Ranks.AddRangeAsync(Utils.SeedRanks());
await arrContext.Categories.AddRangeAsync(Utils.SeedCategories());
await arrContext.Statuses.AddRangeAsync(Utils.SeedStatuses());
await arrContext.Photos.AddRangeAsync(Utils.SeedPhotos());
await arrContext.Juries.AddRangeAsync(Utils.SeedJuries());
await arrContext.Users.AddRangeAsync(Utils.SeedUsers());
await arrContext.SaveChangesAsync();
};
using (var actContext = new PhotoContestContext(options))
{
var userToGet = await actContext.Users.Include(u => u.Rank).Skip(1).FirstAsync();
userManager.Setup(x => x.GetUserName(signManager.Context.User)).Returns(userToGet.UserName);
userService.Setup(x => x.GetUserByUsernameAsync(It.IsAny <string>())).Returns(Task.FromResult(userToGet));
var photo = await actContext.Photos
.Include(p => p.User)
.Include(p => p.Contest)
.ThenInclude(p => p.Category)
.Include(p => p.Contest)
.ThenInclude(c => c.Status)
.Where(p => p.IsDeleted == false)
.FirstOrDefaultAsync(p => p.Id == Guid.Parse("e165b91f-03bf-414e-88b7-c51b87775683"));
photoService.Setup(x => x.FindPhotoAsync(It.IsAny <Guid>())).Returns(Task.FromResult(photo));
var sut = new ReviewService(actContext, photoService.Object, userService.Object, contextAccessor.Object, userManager.Object, signManager);
var result = await sut.CreateAsync(newReviewDTO);
Assert.AreEqual("Photo is in a wrong category.", result.Comment);
Assert.AreEqual(0, result.Score);
Assert.AreEqual(userToGet.FirstName + " " + userToGet.LastName, result.Evaluator);
Assert.AreEqual(photo.Title, result.PhotoTitle);
}
}
public async Task Throw_When_ContestIsInvalidPhase()
{
var options = Utils.GetOptions(nameof(Throw_When_ContestIsInvalidPhase));
var userStore = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(userStore.Object, null, null, null,
null, null, null, null, null);
var contextAccessor = new Mock <IHttpContextAccessor>();
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >().Object;
var signManager = new Mock <SignInManager <User> >(userManager.Object, contextAccessor.Object, userPrincipalFactory, null, null, null, null).Object;
var context = new Mock <HttpContext>();
contextAccessor.Setup(x => x.HttpContext).Returns(context.Object);
var userService = new Mock <IUserService>();
var photoService = new Mock <IPhotoService>();
var newReviewDTO = new Mock <NewReviewDTO>().Object;
newReviewDTO.PhotoId = Guid.Parse("94499cdd-e18c-4743-b0c4-2e1b7564c46c");
newReviewDTO.Comment = "new comment";
newReviewDTO.Score = 5;
newReviewDTO.WrongCategory = false;
using (var arrContext = new PhotoContestContext(options))
{
await arrContext.Contests.AddRangeAsync(Utils.SeedContests());
await arrContext.Ranks.AddRangeAsync(Utils.SeedRanks());
await arrContext.Categories.AddRangeAsync(Utils.SeedCategories());
await arrContext.Statuses.AddRangeAsync(Utils.SeedStatuses());
await arrContext.Photos.AddRangeAsync(Utils.SeedPhotos());
await arrContext.Juries.AddRangeAsync(Utils.SeedJuries());
await arrContext.Users.AddRangeAsync(Utils.SeedUsers());
await arrContext.SaveChangesAsync();
};
using (var actContext = new PhotoContestContext(options))
{
var userToGet = await actContext.Users.Include(u => u.Rank).Skip(1).FirstAsync();
userManager.Setup(x => x.GetUserName(signManager.Context.User)).Returns(userToGet.UserName);
userService.Setup(x => x.GetUserByUsernameAsync(It.IsAny <string>())).Returns(Task.FromResult(userToGet));
var photo = await actContext.Photos
.Include(p => p.User)
.Include(p => p.Contest)
.ThenInclude(p => p.Category)
.Include(p => p.Contest)
.ThenInclude(c => c.Status)
.Where(p => p.IsDeleted == false)
.FirstOrDefaultAsync(p => p.Id == Guid.Parse("94499cdd-e18c-4743-b0c4-2e1b7564c46c"));
photoService.Setup(x => x.FindPhotoAsync(It.IsAny <Guid>())).Returns(Task.FromResult(photo));
var sut = new ReviewService(actContext, photoService.Object, userService.Object, contextAccessor.Object, userManager.Object, signManager);
await Assert.ThrowsExceptionAsync <ArgumentException>(() => sut.CreateAsync(newReviewDTO));
}
}
public async Task Throw_When_PhotoIsAlreadyReviewedApi()
{
var options = Utils.GetOptions(nameof(Throw_When_PhotoIsAlreadyReviewedApi));
var userStore = new Mock <IUserStore <User> >();
var userManager = new Mock <UserManager <User> >(userStore.Object, null, null, null,
null, null, null, null, null);
var contextAccessor = new Mock <IHttpContextAccessor>();
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >().Object;
var signManager = new Mock <SignInManager <User> >(userManager.Object, contextAccessor.Object, userPrincipalFactory, null, null, null, null).Object;
var context = new Mock <HttpContext>();
contextAccessor.Setup(x => x.HttpContext).Returns(context.Object);
var userService = new Mock <IUserService>();
var photoService = new Mock <IPhotoService>();
var newReviewDTO = new Mock <NewReviewDTO>().Object;
newReviewDTO.PhotoId = Guid.Parse("e165b91f-03bf-414e-88b7-c51b87775683");
newReviewDTO.Comment = "new comment";
newReviewDTO.Score = 5;
newReviewDTO.WrongCategory = false;
using (var arrContext = new PhotoContestContext(options))
{
await arrContext.Contests.AddRangeAsync(Utils.SeedContests());
await arrContext.Ranks.AddRangeAsync(Utils.SeedRanks());
await arrContext.Categories.AddRangeAsync(Utils.SeedCategories());
await arrContext.Statuses.AddRangeAsync(Utils.SeedStatuses());
await arrContext.Photos.AddRangeAsync(Utils.SeedPhotos());
await arrContext.Juries.AddRangeAsync(Utils.SeedJuries());
await arrContext.Users.AddRangeAsync(Utils.SeedUsers());
await arrContext.SaveChangesAsync();
};
using (var actContext = new PhotoContestContext(options))
{
var userToGet = await actContext.Users.Include(u => u.Rank).Skip(1).FirstAsync();
var claims = new List <Claim>()
{
new Claim(ClaimTypes.NameIdentifier, userToGet.UserName.ToString()),
};
var identity = new ClaimsIdentity(claims);
var claimsPrincipal = new ClaimsPrincipal(identity);
contextAccessor.Setup(x => x.HttpContext.User).Returns(claimsPrincipal);
userService.Setup(x => x.GetUserByUsernameAsync(It.IsAny <string>())).Returns(Task.FromResult(userToGet));
var photo = await actContext.Photos
.Include(p => p.User)
.Include(p => p.Contest)
.ThenInclude(p => p.Category)
.Include(p => p.Contest)
.ThenInclude(c => c.Status)
.Where(p => p.IsDeleted == false)
.FirstOrDefaultAsync(p => p.Id == Guid.Parse("e165b91f-03bf-414e-88b7-c51b87775683"));
photoService.Setup(x => x.FindPhotoAsync(It.IsAny <Guid>())).Returns(Task.FromResult(photo));
var sut = new ReviewService(actContext, photoService.Object, userService.Object, contextAccessor.Object, userManager.Object, signManager);
await sut.CreateAsync(newReviewDTO);
await Assert.ThrowsExceptionAsync <ArgumentException>(() => sut.CreateApiAsync(newReviewDTO));
}
}
