internal static MovieReviewDto GetReviewsByUser(string userId)
{
var response = new MovieReviewDto();
var reviewCollection = ReviewCollection.Where(x => string.Equals(x.AuthorId, userId)).OrderBy(x => x.CreatedOn);
return(response);
}
internal static MovieReviewDto GetReviews(string movieId)
{
var response = new MovieReviewDto();
var reviewCollection = ReviewCollection.Where(x => string.Equals(x.MovieId, movieId));
var userCollection = UserCollection.Where(x => reviewCollection.Select(c => c.AuthorId).Contains(x.Id));
var movie = new MovieDto(movieId, string.Empty);
var reviews = reviewCollection.Select(x => new ReviewDto
{
Description = x.ReviewDescription,
DownvotedBy = x.DownVotedBy,
UpvotedBy = x.UpVotedBy,
Rating = x.Rating,
Id = x.Id,
Title = x.ReviewTitle,
Author = userCollection.Where(c => string.Equals(x.AuthorId, c.Id)).Select(c => new UserDto
{
DisplayName = c.DisplayName,
Id = c.Id,
UserName = c.UserName
}).Single(),
Movie = movie
});
response = response with
{
Reviews = reviews
};
return(response);
}
public async Task GetRecentReviews_200(string userName, int maxItems, MovieReviewDto expectedReviews)
{
// Arrange
// Arrange
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, userName),
}, "mock"));
var expectedResult = Mapper.Map <MovieReviewDto, GetRecentReviewsResponse>(expectedReviews);
var mockReviewService = new Mock <IReviewService>();
mockReviewService.Setup(x => x.GetRecentReviewsFromFollowedAsync(It.IsAny <string>(), It.IsAny <int>()))
.Returns((string mId, int maxItems) => {
var reviews = MockDataHelper.GetReviews(mId);
return(Task.FromResult(new MovieReviewDto
{
Reviews = reviews.Reviews.Take(maxItems)
}));
});
// Act
var reviewController = new ReviewController(Mapper, mockReviewService.Object);
var request = new GetRecentReviewsRequest
{
NumberOfItems = 10
};
reviewController.ControllerContext.HttpContext = new DefaultHttpContext {
User = user
};
MockModelState(request, reviewController);
var response = await reviewController.GetRecentReviews(request);
// Assert
var okResponse = Assert.IsType <OkObjectResult>(response.Result);
var result = Assert.IsAssignableFrom <GetRecentReviewsResponse>(okResponse.Value);
Assert.True(maxItems >= result.Reviews.Count());
foreach (var(actualReview, expectedReview) in result.Reviews.Zip(expectedResult.Reviews))
{
Assert.Equal(expectedReview.Author.DisplayName, actualReview.Author.DisplayName);
Assert.Equal(expectedReview.Author.UserName, actualReview.Author.UserName);
Assert.Equal(expectedReview.Author.Followers, actualReview.Author.Followers);
Assert.Equal(expectedReview.Author.Id, actualReview.Author.Id);
Assert.Equal(expectedReview.Description, actualReview.Description);
Assert.Equal(expectedReview.Rating, actualReview.Rating);
Assert.Equal(expectedReview.Title, actualReview.Title);
Assert.Equal(expectedReview.Movie.Id, actualReview.Movie.Id);
Assert.Equal(expectedReview.Movie.Title, actualReview.Movie.Title);
}
}
public async Task GetAllReviewsSuccessTest(string movieId, MovieReviewDto expectedResult)
{
// Arrange
var mockReviewRepository = new Mock <IReviewRepository>();
mockReviewRepository.Setup(x => x.GetAsync(It.IsAny <Expression <Func <ReviewEntity, bool> > >()))
.Returns(Task.FromResult(ReviewCollection.Where(x => string.Equals(x.MovieId, movieId, StringComparison.OrdinalIgnoreCase))));
var mockMovieRepository = new Mock <IMovieRepository>();
mockMovieRepository.Setup(x => x.GetAsync(It.IsAny <Expression <Func <MovieEntity, bool> > >()))
.Returns(Task.FromResult(MovieCollection.Where(x => string.Equals(x.Id, movieId, StringComparison.OrdinalIgnoreCase))));
var mockUserRepository = new Mock <IUserProfileRepository>();
mockUserRepository.Setup(x => x.GetAsync(It.IsAny <Expression <Func <UserProfileEntity, bool> > >()))
.Returns((Expression <Func <UserProfileEntity, bool> > x) =>
Task.FromResult(UserCollection.AsQueryable <UserProfileEntity>().Where(x).AsEnumerable()));
var unitOfWork = new Mock <IUnitOfWork>();
unitOfWork.SetupGet(x => x.ReviewRepository).Returns(mockReviewRepository.Object);
unitOfWork.SetupGet(x => x.MovieRepository).Returns(mockMovieRepository.Object);
unitOfWork.SetupGet(x => x.UserProfileRepository).Returns(mockUserRepository.Object);
// Act
var reviewService = new ReviewService(unitOfWork.Object);
var response = await reviewService.GetAllReviewsAsync(movieId);
// Assert
Assert.Equal(expectedResult.Reviews.Count(), response.Reviews.Count());
foreach (var(expected, actual) in expectedResult.Reviews.OrderBy(x => x.Id).Zip(response.Reviews.OrderBy(x => x.Id)))
{
Assert.Equal(expected.Title, actual.Title);
Assert.Equal(expected.Description, actual.Description);
Assert.Equal(expected.Id, actual.Id);
Assert.Equal(expected.Rating, actual.Rating);
Assert.Equal(expected.UpvotedBy.OrderBy(x => x), actual.UpvotedBy.OrderBy(x => x));
Assert.Equal(expected.DownvotedBy.OrderBy(x => x), actual.DownvotedBy.OrderBy(x => x));
Assert.Equal(expected.Movie.Id, actual.Movie.Id);
Assert.Equal(expected.Movie.Title, actual.Movie.Title);
}
}
public async Task <MovieReviewDto> GetRecentReviewsFromFollowedAsync(string currentUserName, int maxNumberOfItems)
{
if (string.IsNullOrEmpty(currentUserName))
{
throw new ArgumentException("Invalid UserName");
}
var currentUser = await UnitOfWork.UserProfileRepository.GetAsync(x => x.UserName.ToLower() == currentUserName.ToLower());
var followUsers = currentUser.Single().Follows ?? Enumerable.Empty <string>();
var reviews = await UnitOfWork.ReviewRepository.FilterReviews(followUsers);
var result = new MovieReviewDto();
var reviewResultDto = new List <ReviewDto>();
foreach (var review in reviews.OrderByDescending(x => x.CreatedOn).Take(maxNumberOfItems))
{
var author = (await UnitOfWork.UserProfileRepository.GetAsync(x => x.Id == review.AuthorId)).Single();
var movie = (await UnitOfWork.MovieRepository.GetAsync(x => x.Id == review.MovieId)).Single();
reviewResultDto.Add(new ReviewDto
{
Author = new UserDto
{
DisplayName = author.DisplayName,
UserName = author.UserName,
Id = author.Id,
Followers = author.Followers.Count()
},
Movie = new MovieDto(movie.Id, movie.Title),
Description = review.ReviewDescription,
Title = review.ReviewTitle,
Id = review.Id,
Rating = review.Rating
});
}
return(new MovieReviewDto
{
Reviews = reviewResultDto
});
}
public async Task <MovieReviewDto> GetAllReviewsAsync(string movieId)
{
if (string.IsNullOrEmpty(movieId) || !(await UnitOfWork.MovieRepository.GetAsync(x => movieId == x.Id)).Any())
{
throw new ArgumentException("Invalid MovieId");
}
var result = new MovieReviewDto();
var reviews = await UnitOfWork.ReviewRepository.GetAsync(x => x.MovieId == movieId);
var consolidatedReviews = new List <ReviewDto>();
foreach (var review in reviews)
{
var author = await UnitOfWork.UserProfileRepository.GetAsync(x => x.Id == review.AuthorId);
consolidatedReviews.Add(new ReviewDto
{
Id = review.Id,
Description = review.ReviewDescription,
Rating = review.Rating,
DownvotedBy = review.DownVotedBy,
UpvotedBy = review.UpVotedBy,
Title = review.ReviewTitle,
Author = author.Select(x => new UserDto
{
DisplayName = x.DisplayName,
UserName = x.UserName,
Id = x.Id
}).Single(),
Movie = new MovieDto(movieId, string.Empty)
});
}
result = result with {
Reviews = consolidatedReviews
};
return(result);
}
public async Task GetAllMovieReviews_400(string movieId, MovieReviewDto expectedReviews)
{
// Arrange
var expectedResult = Mapper.Map <MovieReviewDto, GetAllReviewsResponse>(expectedReviews);
var mockReviewService = new Mock <IReviewService>();
mockReviewService.Setup(x => x.GetAllReviewsAsync(It.IsAny <string>()))
.Returns((string mId) => Task.FromResult(MockDataHelper.GetReviews(mId)));
// Act
var reviewController = new ReviewController(Mapper, mockReviewService.Object);
var request = new GetAllReviewsRequest
{
MovieId = movieId
};
var response = await reviewController.GetAllMovieReviews(request);
// Assert
var okResponse = Assert.IsType <OkObjectResult>(response.Result);
var result = Assert.IsAssignableFrom <GetAllReviewsResponse>(okResponse.Value);
Assert.Equal(expectedResult.Reviews.Count(), result.Reviews.Count());
Assert.False(result.Reviews.Any());
}
public async Task GetAllMovieReviews_200(string movieId, MovieReviewDto expectedReviews)
{
// Arrange
var expectedResult = Mapper.Map <MovieReviewDto, GetAllReviewsResponse>(expectedReviews);
var mockReviewService = new Mock <IReviewService>();
mockReviewService.Setup(x => x.GetAllReviewsAsync(It.IsAny <string>()))
.Returns((string mId) => Task.FromResult(MockDataHelper.GetReviews(mId)));
// Act
var reviewController = new ReviewController(Mapper, mockReviewService.Object);
var request = new GetAllReviewsRequest
{
MovieId = movieId
};
var response = await reviewController.GetAllMovieReviews(request);
// Assert
var okResponse = Assert.IsType <OkObjectResult>(response.Result);
var result = Assert.IsAssignableFrom <GetAllReviewsResponse>(okResponse.Value);
foreach (var(actualReview, expectedReview) in result.Reviews.Zip(expectedResult.Reviews))
{
Assert.Equal(expectedReview.Author.DisplayName, actualReview.Author.DisplayName);
Assert.Equal(expectedReview.Author.Id, actualReview.Author.Id);
Assert.Equal(expectedReview.Author.Followers, actualReview.Author.Followers);
Assert.Equal(expectedReview.Author.UserName, actualReview.Author.UserName);
Assert.Equal(expectedReview.Movie.Id, actualReview.Movie.Id);
Assert.Equal(expectedReview.Movie.Title, actualReview.Movie.Title);
Assert.Equal(expectedReview.Description, actualReview.Description);
Assert.Equal(expectedReview.Rating, actualReview.Rating);
Assert.Equal(expectedReview.Title, actualReview.Title);
}
}
