public async Task GetCommentToEditOrDelete_WithValidCommentId_ShouldReturnComment()
{
//Arrange
var db = this.SetDb();
var service = await this.Setup(db);
var postModel = new PostInputViewModel
{
Title = "Test Post",
Author = "*****@*****.**",
FullContent = "Some test post content",
Tags = "Baking, Cakes"
};
await service.CreatePost(postModel);
var commentModel = new CommentInputViewModel
{
AuthorName = "*****@*****.**",
Content = "Test comment",
PostId = 1
};
await service.CreateComment(commentModel);
//Act
var comment = service.GetCommentToEditOrDelete(1);
var expectedCommentId = 1;
var actualCommentId = comment.Id;
//Assert
Assert.Equal(expectedCommentId, actualCommentId);
}
public async Task GetCommentToEditOrDelete_WithInValidCommentId_ShouldThrow()
{
//Arrange
var db = this.SetDb();
var service = await this.Setup(db);
var postModel = new PostInputViewModel
{
Title = "Test Post",
Author = "*****@*****.**",
FullContent = "Some test post content",
Tags = "Baking, Cakes"
};
await service.CreatePost(postModel);
var commentModel = new CommentInputViewModel
{
AuthorName = "*****@*****.**",
Content = "Test comment",
PostId = 1
};
await service.CreateComment(commentModel);
//Act
//Assert
await Assert.ThrowsAsync <NullReferenceException>(async() => await service.GetCommentToEditOrDelete(2));
}
public async Task CreateComment_WithValidData_ShouldAddCommentPost()
{
//Arrange
var db = this.SetDb();
var service = await this.Setup(db);
var postModel = new PostInputViewModel
{
Title = "Test Post",
Author = "*****@*****.**",
FullContent = "Some test post content",
Tags = "Baking, Cakes"
};
await service.CreatePost(postModel);
var commentModel = new CommentInputViewModel
{
AuthorName = "*****@*****.**",
Content = "Test comment",
PostId = 1
};
//Act
await service.CreateComment(commentModel);
var comment = this.commentRepo.All().First();
//Assert
Assert.Contains <Comment>(comment, postRepo.All().First().Comments);
}
public async Task <IActionResult> Create(string id, CommentInputViewModel inputModel)
{
if (!this.ModelState.IsValid)
{
return(this.Redirect("Error404"));
}
var comment = await this.commentsService.CreateCommentAsync(id, inputModel);
if (comment.ProductId != null)
{
return(this.LocalRedirect($"/Products/Details?id={id}"));
}
if (comment.PostId != null)
{
return(this.LocalRedirect($"/Posts/Details?id={id}"));
}
if (comment.ProgramId != null)
{
return(this.LocalRedirect($"/Programs/Details?id={id}"));
}
return(this.LocalRedirect("/Home/Index"));
}
public async Task CreateCommentAsyncShouldThrowExceptionIfUserIsNull()
{
var options = new DbContextOptionsBuilder <MyCalisthenicAppDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var dbContext = new MyCalisthenicAppDbContext(options);
IHttpContextAccessor httpContextAccessor = new HttpContextAccessor();
var usersService = new UsersService(httpContextAccessor, dbContext, null);
var mockMapper = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new MyCalisthenicAppProfile());
});
var mapper = mockMapper.CreateMapper();
var commentsService = new CommentsService(dbContext, mapper, usersService);
var commentModel = new CommentInputViewModel
{
Text = CommentText,
};
var exception = await Assert.ThrowsAsync <NullReferenceException>(async() => await commentsService.CreateCommentAsync(PostId, commentModel));
Assert.IsType <NullReferenceException>(exception);
}
public async Task CreateComment(CommentInputViewModel model)
{
if (model == null)
{
throw new NullReferenceException("Sorry, couldn't process your comment.");
}
var content = model.Content;
model.AuthorId = this.userRepo.All().SingleOrDefault(u => u.UserName == model.AuthorName).Id;
var comment = this.mapper.Map <CommentInputViewModel, Comment>(model);
this.commentRepo.Add(comment);
try
{
await this.commentRepo.SaveChangesAsync();
}
catch (Exception e)
{
this.logger.LogDebug(e.Message);
throw new InvalidOperationException("Sorry, couldn't process your comment.");
}
}
public async Task GetAllMyComments_WithComments_ShouldReturnUserComment()
{
//Arrange
var db = this.SetDb();
var service = await this.Setup(db);
var postModel = new PostInputViewModel
{
Title = "Test Post",
Author = "*****@*****.**",
FullContent = "Some test post content",
Tags = "Baking, Cakes"
};
await service.CreatePost(postModel);
var commentModel = new CommentInputViewModel
{
AuthorName = "*****@*****.**",
Content = "Test comment",
PostId = 1
};
await service.CreateComment(commentModel);
//Act
var comments = service.GetAllMyComments("*****@*****.**");
//Assert
Assert.NotEmpty(comments);
}
public async Task GetAllCommentsPerPost_WithValidPost_ShouldReturnAllComments()
{
//Arrange
var db = this.SetDb();
var service = await this.Setup(db);
var postModel = new PostInputViewModel
{
Title = "Test Post",
Author = "*****@*****.**",
FullContent = "Some test post content",
Tags = "Baking, Cakes"
};
await service.CreatePost(postModel);
var commentModel = new CommentInputViewModel
{
AuthorName = "*****@*****.**",
Content = "Test comment",
PostId = 1
};
await service.CreateComment(commentModel);
//Act
var result = await service.GetAllCommentsPerPost(1);
var expectedCount = 1;
var actualCount = result.Comments.Count();
//Assert
Assert.Equal(expectedCount, actualCount);
}
public async Task <IActionResult> Create(CommentInputViewModel input)
{
var userId = this.userManager.GetUserId(this.User);
await this.commentsService.Create(input.PostId, userId, input.Content);
return(this.RedirectToAction("ById", "Posts", new { id = input.PostId }));
}
public async Task <Comment> CreateCommentAsync(string id, CommentInputViewModel commentModel)
{
var userId = this.usersService.GetLoggedUserId();
var userFromDb = await this.usersService.GetLoggedUserByIdAsync(userId);
if (userFromDb == null)
{
throw new NullReferenceException(string.Format(ServicesConstants.InvalidUserId, userId));
}
Comment comment = null;
if (this.dbContext.Products.Any(p => p.Id == id))
{
comment = new Comment
{
Text = commentModel.Text,
AuthorId = userId,
Author = userFromDb,
ProductId = id,
};
}
if (this.dbContext.Post.Any(p => p.Id == id))
{
comment = new Comment
{
Text = commentModel.Text,
AuthorId = userId,
Author = userFromDb,
PostId = id,
};
}
if (this.dbContext.Programs.Any(pc => pc.Id == id))
{
comment = new Comment
{
Text = commentModel.Text,
AuthorId = userId,
Author = userFromDb,
ProgramId = id,
};
}
await this.dbContext.Comments.AddAsync(comment);
await this.dbContext.SaveChangesAsync();
return(comment);
}
public async Task UpdateComment_WithValidModel_ShouldSaveUpdatedComment()
{
//Arrange
var db = this.SetDb();
var service = await this.Setup(db);
var postModel = new PostInputViewModel
{
Title = "Test Post",
Author = "*****@*****.**",
FullContent = "Some test post content",
Tags = "Baking, Cakes"
};
await service.CreatePost(postModel);
var commentModel = new CommentInputViewModel
{
AuthorName = "*****@*****.**",
Content = "Test comment content",
PostId = 1
};
await service.CreateComment(commentModel);
var comment = await this.commentRepo.GetByIdAsync(1);
db.Entry(comment).State = EntityState.Detached;
var model = this.Mapper.Map <Comment, EditCommentViewModel>(comment);
model.FullContent = model.FullContent;
model.Content = "Edit content.";
//Act
await service.UpdateComment(model);
var expectedCommentContent = "Edit content.";
var actualCommentContent = (await this.commentRepo.GetByIdAsync(1)).Content;
//Assert
Assert.Equal(expectedCommentContent, actualCommentContent);
}
public async Task MarkCommentAsDeleted_WithValidModel_ShouldMarkCommentAsDeleted()
{
//Arrange
var db = this.SetDb();
var service = await this.Setup(db);
var postModel = new PostInputViewModel
{
Title = "Test Post",
Author = "*****@*****.**",
FullContent = "Some test post content",
Tags = "Baking, Cakes"
};
await service.CreatePost(postModel);
var commentModel = new CommentInputViewModel
{
AuthorName = "*****@*****.**",
Content = "Test comment",
PostId = 1
};
await service.CreateComment(commentModel);
var comment = await this.commentRepo.GetByIdAsync(1);
var model = this.Mapper.Map <Comment, EditCommentViewModel>(comment);
model.FullContent = this.sanitizer.Sanitize(model.FullContent);
model.Content = this.sanitizer.Sanitize(model.Content);
//Act
await service.MarkCommentAsDeleted(model);
var expectedCommentIsDeleted = true;
var actualCommentIsDeleted = comment.IsDeleted;
//Assert
Assert.Equal(expectedCommentIsDeleted, actualCommentIsDeleted);
}
public async Task UpdateComment_WithEmptyContent_ShouldThrow()
{
//Arrange
var db = this.SetDb();
var service = await this.Setup(db);
var postModel = new PostInputViewModel
{
Title = "Test Post",
Author = "*****@*****.**",
FullContent = "Some test post content",
Tags = "Baking, Cakes"
};
await service.CreatePost(postModel);
var commentModel = new CommentInputViewModel
{
AuthorName = "*****@*****.**",
Content = "Test comment content",
PostId = 1
};
await service.CreateComment(commentModel);
var comment = await this.commentRepo.GetByIdAsync(1);
db.Entry(comment).State = EntityState.Detached;
var model = this.Mapper.Map <Comment, EditCommentViewModel>(comment);
model.Content = "";
//Act
//Assert
await Assert.ThrowsAsync <NullReferenceException>(async() => await service.UpdateComment(model));
}
public async Task <IActionResult> CommentOn(CommentInputViewModel viewModel)
{
var user = await _userManager.GetUserAsync(HttpContext.User);
if (user == null)
{
return(Json(new { success = false, message = "你未登录，正在为你跳转到登录页！", code = 403 }));
}
if (ModelState.IsValid)
{
if (_commentService.LoadEntity(m => m.Commentator.Id == user.Id && m.CloudProduct.Id == viewModel.ProductId) != null)
{
return(Json(new { success = false, message = "你已经点评过该产品了，不能重复点评，可以去补充您的点评！" }));
}
var product = _cloudProductService.LoadEntity(m => m.Id == viewModel.ProductId);
if (product != null)
{
var comment = _commentService.AddEntity(new Comment
{
Commentator = user,
Content = viewModel.Content,
Score = viewModel.Score,
CloudProduct = product
});
if (_commentService.SaveChanges())
{
return(Json(new { success = true, message = "点评成功！", data = comment.ToViewModel() }));
}
}
else
{
return(Json(new { success = false, message = "该服务商不存在，刷新后重试！" }));
}
}
return(Json(new { success = false, message = "请认真填写点评！" }));
}
public async Task GetPostDetailById_WithCommentValidId_ShouldReturnPostDetails()
{
//Arrange
var db = this.SetDb();
var service = await this.Setup(db);
var postModelA = new PostInputViewModel
{
Title = "Test Post A",
Author = "*****@*****.**",
FullContent = "Some test post content",
Tags = "Baking, Cakes"
};
await service.CreatePost(postModelA);
var commentModel = new CommentInputViewModel
{
AuthorName = "*****@*****.**",
Content = "Test comment",
PostId = 1
};
await service.CreateComment(commentModel);
//Act
var post = service.GetPostDetailById(1);
var expectedComments = 1;
var actualComments = post.Comments.Count();
//Assert
Assert.NotNull(post);
Assert.Equal(expectedComments, actualComments);
Assert.IsType <PostDetailsViewModel>(post);
}
public async Task GetCommentToEditOrDelete_WithDeletedPost_ShouldThrow()
{
//Arrange
var db = this.SetDb();
var service = await this.Setup(db);
var postModel = new PostInputViewModel
{
Title = "Test Post",
Author = "*****@*****.**",
FullContent = "Some test post content",
Tags = "Baking, Cakes"
};
await service.CreatePost(postModel);
var commentModel = new CommentInputViewModel
{
AuthorName = "*****@*****.**",
Content = "Test comment",
PostId = 1
};
await service.CreateComment(commentModel);
var post = await this.postRepo.GetByIdAsync(1);
post.IsDeleted = true;
await this.postRepo.SaveChangesAsync();
//Act
//Assert
await Assert.ThrowsAsync <InvalidOperationException
>(async() => await service.GetCommentToEditOrDelete(1));
}
public async Task CreateComment_WithNullComment_ShouldThrow()
{
//Arrange
var db = this.SetDb();
var service = await this.Setup(db);
var postModel = new PostInputViewModel
{
Title = "Test Post",
Author = "*****@*****.**",
FullContent = "Some test post content",
Tags = "Baking, Cakes"
};
await service.CreatePost(postModel);
CommentInputViewModel commentModel = null;
//Act
//Assert
await Assert.ThrowsAsync <NullReferenceException>(async() => await service.CreateComment(commentModel));
}
