public async Task <CocktailCommentDto> CreateAsync(CocktailCommentDto tempCocktailComment)
{
if (tempCocktailComment == null)
{
throw new BusinessLogicException(ExceptionMessages.CocktailCommentNull);
}
var cocktailComment = new CocktailComment
{
Id = tempCocktailComment.Id,
CocktailId = tempCocktailComment.CocktailId,
UserId = tempCocktailComment.UserId,
Body = tempCocktailComment.Body,
CreatedOn = tempCocktailComment.CreatedOn,
ModifiedOn = tempCocktailComment.ModifiedOn,
DeletedOn = tempCocktailComment.DeletedOn,
IsDeleted = tempCocktailComment.IsDeleted
};
await this.context.CocktailComments.AddAsync(cocktailComment);
await this.context.SaveChangesAsync();
var cocktailCommentDto = this.dtoMapper.MapFrom(cocktailComment);
return(cocktailCommentDto);
}
public void ReturnCorrectInstance_OfType_CocktailCommentDto()
{
//Arrange
var sut = new CocktailCommentDtoMapper();
var cocktail = new Cocktail
{
Id = 1,
Name = "TestCocktail",
};
var user = new User
{
Id = 1,
UserName = "******",
Email = "*****@*****.**",
};
var cocktailComment = new CocktailComment
{
CocktailId = cocktail.Id,
UserId = user.Id,
commentText = "TestComment",
User = user,
};
//Act
var result = sut.MapDto(cocktailComment);
//Assert
Assert.IsInstanceOfType(result, typeof(CocktailCommentDto));
Assert.AreEqual(result.CocktailId, cocktailComment.CocktailId);
Assert.AreEqual(result.UserId, cocktailComment.UserId);
Assert.AreEqual(result.commentText, cocktailComment.commentText);
}
public async Task <CocktailCommentDto> CreateCocktailCommentAsync(CocktailCommentDto cocktailCommentDto)
{
if (cocktailCommentDto == null)
{
throw new ArgumentNullException("No cocktail comment found.");
}
var cocktailComment = new CocktailComment
{
Id = cocktailCommentDto.Id,
commentText = cocktailCommentDto.commentText,
UserId = cocktailCommentDto.UserId,
CocktailId = cocktailCommentDto.CocktailId,
User = await this._context.Users
.FirstOrDefaultAsync(a => a.UserName == cocktailCommentDto.Username),
CreatedOn = this._dateTimeProvider.GetDateTime(),
ModifiedOn = cocktailCommentDto.ModifiedOn,
DeletedOn = cocktailCommentDto.DeletedOn,
IsDeleted = cocktailCommentDto.IsDeleted
};
await this._context.CocktailComments.AddAsync(cocktailComment);
await this._context.SaveChangesAsync();
return(this._cocktailCommentDtoMapper.MapDto(cocktailComment));
}
public async Task AddCocktailCommentAsync(int id, string createComment, int userId)
{
if (await dbContext.CocktailComment.AnyAsync(p => (p.UserId == userId && p.CocktailId == id)))
{
var existingComment = await dbContext.CocktailComment.FirstOrDefaultAsync(p => (p.UserId == userId && p.CocktailId == id));
existingComment.Comment = createComment;
existingComment.CreatedOn = DateTime.Now;
await dbContext.SaveChangesAsync();
}
else
{
var user = await FindUserByIdAsync(userId);
var cocktail = await cService.FindCocktailByIdAsync(id);
var cocktailComment = new CocktailComment()
{
User = user,
Cocktail = cocktail,
UserName = user.UserName,
CocktailName = cocktail.Name,
Comment = createComment,
CreatedOn = DateTime.Now
};
await dbContext.CocktailComment.AddAsync(cocktailComment);
await dbContext.SaveChangesAsync();
}
}
public void MapFrom_Should_ReturnCorrectInstanceOf_CocktailCommentDto()
{
//Arrange
var sut = new CocktailCommentDtoMapper();
var cocktailComment = new CocktailComment
{
Cocktail = new Cocktail
{
Id = Guid.NewGuid(),
Name = "testCocktail",
Info = "testInfo",
ImagePath = "testPath",
},
User = new User
{
Id = Guid.NewGuid(),
UserName = "******",
Email = "*****@*****.**"
},
Body = "testBody",
CreatedOn = DateTime.MinValue,
};
//Act
var result = sut.MapFrom(cocktailComment);
//Assert
Assert.IsInstanceOfType(result, typeof(CocktailCommentDto));
}
public void MapFrom_Should_CorrectlyMapFrom_CocktailComment_To_CocktailCommentDto()
{
//Arrange
var sut = new CocktailCommentDtoMapper();
var cocktailComment = new CocktailComment
{
Cocktail = new Cocktail
{
Id = Guid.NewGuid(),
Name = "testCocktail",
Info = "testInfo",
ImagePath = "testPath",
},
User = new User
{
Id = Guid.NewGuid(),
UserName = "******",
Email = "*****@*****.**"
},
Body = "testBody",
CreatedOn = DateTime.MinValue,
};
//Act
var result = sut.MapFrom(cocktailComment);
//Assert
Assert.AreEqual(result.CocktailId, cocktailComment.CocktailId);
Assert.AreEqual(result.UserId, cocktailComment.UserId);
Assert.AreEqual(result.Body, cocktailComment.Body);
Assert.AreEqual(result.CreatedOn, cocktailComment.CreatedOn);
}
public async Task CocktailCommentAsyncAddCorectly()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CocktailCommentAsyncAddCorectly));
var ingredientServiceMock = new Mock <ICocktailIngredientService>();
var cocktailMapperToDTOMock = new Mock <IDTOServiceMapper <CocktailDTO, Cocktail> >();
var cocktailMapperMock = new Mock <IDTOServiceMapper <Cocktail, CocktailDTO> >();
var commentMapperToDTOMock = new Mock <IDTOServiceMapper <CommentDTO, CocktailComment> >();
var commentMapperMock = new Mock <IDTOServiceMapper <CocktailComment, CommentDTO> >();
var addCocktailMapperMock = new Mock <IDTOServiceMapper <Cocktail, AddCocktailDTO> >();
var cocktailRatingToDTOMock = new Mock <IDTOServiceMapper <RatingDTO, CocktailRating> >();
//Act
var cocktailCommentDTO = new CocktailComment();
var CommentDTOMock = new Mock <CommentDTO>();
commentMapperToDTOMock.Setup(m => m.MapFrom(It.IsAny <CommentDTO>())).Returns(cocktailCommentDTO);
using (var actContext = new IriOnCocktailServiceDbContext(options))
{
var sut = new CocktailService(actContext, ingredientServiceMock.Object, cocktailMapperMock.Object, cocktailMapperToDTOMock.Object, commentMapperToDTOMock.Object, commentMapperMock.Object, addCocktailMapperMock.Object, cocktailRatingToDTOMock.Object);
await sut.CocktailCommentAsync(CommentDTOMock.Object);
}
using (var assertContext = new IriOnCocktailServiceDbContext(options))
{
Assert.AreEqual(1, assertContext.CocktailComments.Count());
}
}
public async Task DeleteComment_Throws_When_NoCommentFound()
{
//Arrange
var options = Utils.GetOptions(nameof(DeleteComment_Throws_When_NoCommentFound));
var user = new User {
Id = Guid.NewGuid(), UserName = "******"
};
var cocktail = new Cocktail {
Id = Guid.NewGuid(), Name = "Manhattan"
};
var cocktailComment = new CocktailComment {
CocktailId = cocktail.Id, UserId = user.Id
};
var commentId = Guid.NewGuid();
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.CocktailComments.AddAsync(cocktailComment);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new CocktailCommentServices(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.DeleteComment(commentId));
}
}
public async Task CorrectlyCreateCocktailComment()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CorrectlyCreateCocktailComment));
var mapperMock = new Mock <IDtoMapper <CocktailComment, CocktailCommentDto> >();
var id = Guid.NewGuid();
var cocktailId = Guid.NewGuid();
var userId = Guid.NewGuid();
var createdOn = DateTime.UtcNow;
var entityDto = new CocktailCommentDto
{
Id = id,
CocktailId = cocktailId,
UserId = userId,
UserName = "******",
Body = "testbody",
CreatedOn = createdOn
};
var entity = new CocktailComment
{
Id = id,
CocktailId = cocktailId,
UserId = userId,
Body = "testbody",
CreatedOn = createdOn
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <CocktailComment>())).Returns(entityDto);
using (var assertContext = new CWContext(options))
{
//Assert
var sut = new CocktailCommentService(assertContext, mapperMock.Object);
var result = await sut.CreateAsync(entityDto);
Assert.IsInstanceOfType(result, typeof(CocktailCommentDto));
Assert.AreEqual(id, result.Id);
Assert.AreEqual(cocktailId, result.CocktailId);
Assert.AreEqual(userId, result.UserId);
Assert.AreEqual("testbody", result.Body);
Assert.AreEqual("testusername", result.UserName);
Assert.AreEqual(entityDto.Id, result.Id);
Assert.AreEqual(entityDto.CocktailId, result.CocktailId);
Assert.AreEqual(entityDto.UserId, result.UserId);
Assert.AreEqual(entityDto.Body, result.Body);
Assert.AreEqual(entityDto.UserName, result.UserName);
}
}
public async Task GetAllCommentsForCocktailCorrectly()
{
var options = TestUtilities.GetOptions(nameof(GetAllCommentsForCocktailCorrectly));
var ingredientServiceMock = new Mock<ICocktailIngredientService>();
var cocktailMapperToDTOMock = new Mock<IDTOServiceMapper<CocktailDTO, Cocktail>>();
var cocktailMapperMock = new Mock<IDTOServiceMapper<Cocktail, CocktailDTO>>();
var commentMapperToDTOMock = new Mock<IDTOServiceMapper<CommentDTO, CocktailComment>>();
var commentMapperMock = new Mock<IDTOServiceMapper<CocktailComment, CommentDTO>>();
var addCocktailMapperMock = new Mock<IDTOServiceMapper<Cocktail, AddCocktailDTO>>();
var cocktailRatingToDTOMock = new Mock<IDTOServiceMapper<RatingDTO, CocktailRating>>();
var cocktail = new Cocktail()
{
Name = "Name",
Id = "1",
Motto = "Motto",
PicUrl = "Pic",
};
var cocktailComment = new CocktailComment
{
CocktailId = "1",
Description = "description",
CreatedOn = DateTime.Now,
};
var cocktailComment2 = new CocktailComment
{
CocktailId = "1",
Description = "description",
CreatedOn = DateTime.Now,
};
//Act
//cocktailMapperMock.Setup(m => m.MapFrom(It.IsAny<Cocktail>())).Returns(cocktailDTO);
using (var actContext = new IriOnCocktailServiceDbContext(options))
{
await actContext.Cocktails.AddAsync(cocktail);
await actContext.SaveChangesAsync();
await actContext.CocktailComments.AddAsync(cocktailComment);
await actContext.CocktailComments.AddAsync(cocktailComment2);
await actContext.SaveChangesAsync();
}
using (var assertContext = new IriOnCocktailServiceDbContext(options))
{
var sut = new CocktailService(assertContext, ingredientServiceMock.Object, cocktailMapperMock.Object, cocktailMapperToDTOMock.Object, commentMapperToDTOMock.Object, commentMapperMock.Object, addCocktailMapperMock.Object, cocktailRatingToDTOMock.Object);
var result = await sut.GetAllCommentsForCocktail("1");
Assert.AreEqual(2, result.Count);
}
}
public async Task ReturnCorrectTypeOfEntity()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCorrectTypeOfEntity));
var mapperMock = new Mock <IDtoMapper <CocktailComment, CocktailCommentDto> >();
var id = Guid.NewGuid();
var cocktailId = Guid.NewGuid();
var userId = Guid.NewGuid();
var createdOn = DateTime.UtcNow;
var entityDto = new CocktailCommentDto
{
Id = id,
CocktailId = cocktailId,
UserId = userId,
UserName = "******",
Body = "testbody",
CreatedOn = createdOn
};
var entity = new CocktailComment
{
Id = id,
CocktailId = cocktailId,
UserId = userId,
Body = "testbody",
CreatedOn = createdOn
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <CocktailComment>())).Returns(entityDto);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.CocktailComments.AddAsync(entity);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new CocktailCommentService(assertContext, mapperMock.Object);
var result = await sut.EditAsync(id, "newbody");
Assert.IsInstanceOfType(result, typeof(CocktailCommentDto));
}
}
public static CocktailCommentsDTO GetDTO(this CocktailComment item)
{
if (item == null)
{
throw new ArgumentNullException();
}
return(new CocktailCommentsDTO
{
Comments = item.Comments,
User = item.User,
UserId = item.UserId,
Cocktail = item.Cocktail,
CocktailId = item.CocktailId,
IsDeleted = item.IsDeleted,
});
}
public async Task GetAllCommentsForCocktail_Returns_Correct_WhenParam_IsValid()
{
//Arrange
var options = Utils.GetOptions(nameof(GetAllCommentsForCocktail_Returns_Correct_WhenParam_IsValid));
var user = new User {
Id = Guid.NewGuid(), UserName = "******"
};
var user2 = new User {
Id = Guid.NewGuid(), UserName = "******"
};
var cocktail = new Cocktail {
Id = Guid.NewGuid(), Name = "Manhattan"
};
var cocktailComment = new CocktailComment {
CocktailId = cocktail.Id, UserId = user.Id
};
var cocktailComment2 = new CocktailComment {
CocktailId = cocktail.Id, UserId = user2.Id
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.Users.AddRangeAsync(user, user2);
await arrangeContext.CocktailComments.AddRangeAsync(cocktailComment, cocktailComment2);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new CocktailCommentServices(assertContext);
var result = await sut.GetAllCommentsForCocktail(cocktail.Id);
Assert.AreEqual(2, result.Count());
Assert.AreEqual(result.ToList()[0].UserId, user.Id);
Assert.AreEqual(result.ToList()[1].UserId, user2.Id);
Assert.IsInstanceOfType(result, typeof(ICollection <CocktailCommentsDTO>));
}
}
public async Task GetAllCommentsOfUser_ShouldReturn_Correct()
{
//Arrange
var options = Utils.GetOptions(nameof(GetAllCommentsOfUser_ShouldReturn_Correct));
var user = new User {
Id = Guid.NewGuid(), UserName = "******"
};
var cocktail = new Cocktail {
Id = Guid.NewGuid(), Name = "Manhattan"
};
var cocktail2 = new Cocktail {
Id = Guid.NewGuid(), Name = "Cosmos"
};
var comment = new CocktailComment {
CocktailId = cocktail.Id, UserId = user.Id
};
var comment2 = new CocktailComment {
CocktailId = cocktail2.Id, UserId = user.Id, IsDeleted = true
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Cocktails.AddRangeAsync(cocktail, cocktail2);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.CocktailComments.AddRangeAsync(comment, comment2);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
//TODO: Replace USername with id
var sut = new CocktailCommentServices(assertContext);
var result = await sut.GetAllCommentsOfUser(user.Id, user.UserName);
Assert.AreEqual(1, result.Count);
Assert.IsInstanceOfType(result, typeof(ICollection <CocktailCommentsDTO>));
}
}
public async Task GetAllCommentsForCocktail_Returns_OnlyExistingEntities()
{
//Arrange
var options = Utils.GetOptions(nameof(GetAllCommentsForCocktail_Returns_OnlyExistingEntities));
var user = new User {
Id = Guid.NewGuid(), UserName = "******"
};
var user2 = new User {
Id = Guid.NewGuid(), UserName = "******"
};
var cocktail = new Cocktail {
Id = Guid.NewGuid(), Name = "Manhattan"
};
var cocktailComment = new CocktailComment {
CocktailId = cocktail.Id, UserId = user.Id
};
var cocktailComment2 = new CocktailComment {
CocktailId = cocktail.Id, UserId = user2.Id, IsDeleted = true
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.Users.AddRangeAsync(user, user2);
await arrangeContext.CocktailComments.AddRangeAsync(cocktailComment, cocktailComment2);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new CocktailCommentServices(assertContext);
var result = await sut.GetAllCommentsForCocktail(cocktail.Id);
Assert.AreEqual(1, result.Count());
}
}
public async Task CorrectlyUpdateEntity()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CorrectlyUpdateEntity));
var mapperMock = new Mock <IDtoMapper <CocktailComment, CocktailCommentDto> >();
var id = Guid.NewGuid();
var cocktailId = Guid.NewGuid();
var userId = Guid.NewGuid();
var createdOn = DateTime.UtcNow;
var entity = new CocktailComment
{
Id = id,
CocktailId = cocktailId,
UserId = userId,
Body = "testbody",
CreatedOn = createdOn
};
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.CocktailComments.AddAsync(entity);
await arrangeContext.SaveChangesAsync();
}
mapperMock.Setup(x => x.MapFrom(It.IsAny <CocktailComment>())).Returns(It.IsAny <CocktailCommentDto>);
using (var assertContext = new CWContext(options))
{
var sut = new CocktailCommentService(assertContext, mapperMock.Object);
var result = await sut.EditAsync(id, "newbody");
var modifiedComment = await assertContext.CocktailComments.FirstAsync();
Assert.AreEqual("newbody", modifiedComment.Body);
}
}
public async Task ThrowWhen_NoCommentFound()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ThrowWhen_NoCommentFound));
var mapperMock = new Mock <IDtoMapper <CocktailComment, CocktailCommentDto> >();
var id = Guid.NewGuid();
var cocktailId = Guid.NewGuid();
var userId = Guid.NewGuid();
var fakeId = Guid.NewGuid();
var createdOn = DateTime.UtcNow;
var entity = new CocktailComment
{
Id = id,
CocktailId = cocktailId,
UserId = userId,
Body = "testbody",
CreatedOn = createdOn
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <CocktailComment>())).Returns(It.IsAny <CocktailCommentDto>);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.CocktailComments.AddAsync(entity);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new CocktailCommentService(assertContext, mapperMock.Object);
await Assert.ThrowsExceptionAsync <BusinessLogicException>(() => sut.EditAsync(fakeId, "newbody"));
}
}
public async Task DeleteComment_ShouldDelete_Correct()
{
//Arrange
var options = Utils.GetOptions(nameof(DeleteComment_ShouldDelete_Correct));
var user = new User {
Id = Guid.NewGuid(), UserName = "******"
};
var cocktail = new Cocktail {
Id = Guid.NewGuid(), Name = "Manhattan"
};
var cocktailComment = new CocktailComment {
CocktailId = cocktail.Id, UserId = user.Id
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.CocktailComments.AddAsync(cocktailComment);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new CocktailCommentServices(assertContext);
var result = await sut.DeleteComment(cocktailComment.Id);
Assert.AreEqual(true, result.IsDeleted);
Assert.IsInstanceOfType(result, typeof(CocktailCommentsDTO));
}
}
public async Task Return_CorrectModelComment_When_ParamsAreValid()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(Return_CorrectModelComment_When_ParamsAreValid));
var mockDateTimeProvider = new Mock <IDateTimeProvider>();
var mapper = new Mock <IDtoMapper <CocktailComment, CocktailCommentDto> >();
var user = new User {
Id = 1
};
var cocktail = new Cocktail {
Id = 1
};
var comment1 = new CocktailComment
{
Id = 1,
UserId = 1,
CocktailId = 1,
commentText = "TestComment1",
};
var comment2 = new CocktailComment
{
Id = 2,
UserId = 1,
CocktailId = 1,
commentText = "TestComment2",
};
var list = new List <CocktailCommentDto>
{
new CocktailCommentDto
{
Id = 1,
UserId = 1,
CocktailId = 1,
commentText = "TestComment1",
},
new CocktailCommentDto
{
Id = 2,
UserId = 1,
CocktailId = 1,
commentText = "TestComment2",
}
};
mapper.Setup(x => x.MapDto(It.IsAny <ICollection <CocktailComment> >())).Returns(list);
using (var arrangeContext = new CocktailMagicianContext(options))
{
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.CocktailComments.AddAsync(comment1);
await arrangeContext.CocktailComments.AddAsync(comment2);
await arrangeContext.SaveChangesAsync();
}
//Act and Assert
using (var assertContext = new CocktailMagicianContext(options))
{
var sut = new CocktailCommentService(assertContext, mapper.Object, mockDateTimeProvider.Object);
var result = await sut.GetCocktailCommentsAsync(1);
Assert.IsInstanceOfType(result, typeof(ICollection <CocktailCommentDto>));
Assert.AreEqual(1, result.First().Id);
Assert.AreEqual(1, result.First().UserId);
Assert.AreEqual(1, result.First().CocktailId);
Assert.AreEqual("TestComment1", result.First().commentText);
Assert.AreEqual(2, result.Last().Id);
Assert.AreEqual(1, result.Last().UserId);
Assert.AreEqual(1, result.Last().CocktailId);
Assert.AreEqual("TestComment2", result.Last().commentText);
}
}
public async Task ReturnCorrectInstanceOfCollectionCocktailCommentDtos()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCorrectInstanceOfCollectionCocktailCommentDtos));
var mapperMock = new Mock <IDtoMapper <CocktailComment, CocktailCommentDto> >();
var id = Guid.NewGuid();
var idTwo = Guid.NewGuid();
var cocktailId = Guid.NewGuid();
var userId = Guid.NewGuid();
var entity = new CocktailComment
{
Id = id,
CocktailId = cocktailId,
UserId = userId,
Body = "testbody",
};
var entityTwo = new CocktailComment
{
Id = idTwo,
CocktailId = cocktailId,
UserId = userId,
Body = "testbodytwo",
};
var list = new List <CocktailCommentDto>()
{
new CocktailCommentDto {
Id = id, Body = "testbody"
},
new CocktailCommentDto {
Id = idTwo, Body = "testbodytwo"
},
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <ICollection <CocktailComment> >())).Returns(list);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.CocktailComments.AddAsync(entity);
await arrangeContext.CocktailComments.AddAsync(entityTwo);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new CocktailCommentService(assertContext, mapperMock.Object);
var result = await sut.GetCocktailCommentsAsync(cocktailId);
Assert.IsInstanceOfType(result, typeof(ICollection <CocktailCommentDto>));
Assert.AreEqual(2, result.Count());
Assert.AreEqual(entity.Body, result.First().Body);
Assert.AreEqual(entity.Id, result.First().Id);
Assert.AreEqual(entityTwo.Body, result.Last().Body);
Assert.AreEqual(entityTwo.Id, result.Last().Id);
}
}
