public async Task GetMovieFailureTest(string movieId, Exception exception)
{
var mockMovieRepository = new Mock <IMovieRepository>();
mockMovieRepository.Setup(x => x.GetAsync(It.IsAny <Expression <Func <MovieEntity, bool> > >()))
.Returns(Task.FromResult(EntityCollection.Where(x => x.Id == movieId)));
var mockReviewRepository = new Mock <IReviewRepository>();
mockReviewRepository.Setup(x => x.GetAsync(It.IsAny <Expression <Func <ReviewEntity, bool> > >()))
.Returns(Task.FromResult(ReviewCollection.Where(x => x.MovieId == movieId)));
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.MovieRepository).Returns(mockMovieRepository.Object);
unitOfWork.SetupGet(x => x.UserProfileRepository).Returns(mockUserRepository.Object);
unitOfWork.SetupGet(x => x.ReviewRepository).Returns(mockReviewRepository.Object);
// Act
var movieService = new MovieService(unitOfWork.Object);
await Assert.ThrowsAsync(exception.GetType(), () => movieService.GetOne(movieId));
}
public async Task GetAllReviewsFailureTest(string movieId)
{
// 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(Enumerable.Empty <MovieEntity>()));
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.UserProfileRepository).Returns(mockUserRepository.Object);
unitOfWork.SetupGet(x => x.MovieRepository).Returns(mockMovieRepository.Object);
// Act
var reviewService = new ReviewService(unitOfWork.Object);
var response = await Assert.ThrowsAsync <ArgumentException>(() => reviewService.GetAllReviewsAsync(movieId));
}
public async Task <ObjectId> GetUserId(string userName)
{
IMongoQueryable <ObjectId> query = from user in UserCollection.AsQueryable()
where user.Name.Equals(userName)
select user._id;
return((await query.AnyAsync()) ? await query.FirstAsync() : ObjectId.Empty);
}
public override bool IsUserInRole(string username, string roleName)
{
SecUtility.CheckParameter(ref roleName, true, true, null, MAX_ROLE_LENGTH, ROLE_NAME);
var found = UserCollection.AsQueryable().Any(u => u.LowercaseUsername == username.ToLowerInvariant() &&
u.Roles.Contains(roleName.ToLowerInvariant()));
return(found);
}
public override string[] GetUsersInRole(string roleName)
{
SecUtility.CheckParameter(ref roleName, true, true, InvalidRoleCharacters, MAX_ROLE_LENGTH, ROLE_NAME);
var usernames = UserCollection.AsQueryable()
.Where(u => u.Roles.Contains(roleName.ToLowerInvariant()))
.Select(u => u.Username).ToArray();
return(usernames);
}
public override string[] GetRolesForUser(string username)
{
SecUtility.CheckParameter(ref username, true, true, InvalidUsernameCharacters, MAX_USERNAME_LENGTH, "username");
string[] roles = UserCollection.AsQueryable()
.Where(u => u.LowercaseUsername == username.ToLowerInvariant())
.Select(u => u.Roles.ToArray()).FirstOrDefault();
return(roles);
}
public async Task <List <User> > GetFriendList(ObjectId userId)
{
List <ObjectId> friendIds = await GetFriendIdList(userId);
IMongoQueryable <User> userQuery = from user in UserCollection.AsQueryable()
where friendIds.Contains(user._id)
select user;
return(await userQuery.ToListAsync());
}
public override bool DeleteRole(string roleName, bool throwOnPopulatedRole)
{
SecUtility.CheckParameter(ref roleName, true, true, InvalidRoleCharacters, MAX_ROLE_LENGTH, ROLE_NAME);
var rolePopulated = UserCollection.AsQueryable().Any(u => u.Roles.Contains(roleName.ToLowerInvariant()));
if (throwOnPopulatedRole && rolePopulated)
{
throw new ProviderException(Resources.Role_is_not_empty);
}
var result = RoleCollection.DeleteOne(Builders <BsonDocument> .Filter.Eq(DOCUMENT_ID_NAME, roleName.ToLowerInvariant()));
return(result.IsAcknowledged);
}
public override bool DeleteRole(string roleName, bool throwOnPopulatedRole)
{
SecUtility.CheckParameter(ref roleName, true, true, InvalidRoleCharacters, MAX_ROLE_LENGTH, "roleName");
var rolePopulated = UserCollection.AsQueryable().Any(u => u.Roles.Contains(roleName.ToLowerInvariant()));
if (throwOnPopulatedRole && rolePopulated)
{
throw new ProviderException(Resources.Role_is_not_empty);
}
var result = RoleCollection.Remove(Query.EQ("_id", roleName.ToLowerInvariant()), SafeMode.True);
return(result.Ok);
}
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 GetMovieSuccessTest(string movieId, MovieEntity expectedResult)
{
// Arrange
var mockMovieRepository = new Mock <IMovieRepository>();
mockMovieRepository.Setup(x => x.GetAsync(It.IsAny <Expression <Func <MovieEntity, bool> > >()))
.Returns(Task.FromResult(EntityCollection.Where(x => x.Id == movieId)));
var mockReviewRepository = new Mock <IReviewRepository>();
mockReviewRepository.Setup(x => x.GetAsync(It.IsAny <Expression <Func <ReviewEntity, bool> > >()))
.Returns(Task.FromResult(ReviewCollection.Where(x => x.MovieId == movieId)));
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.MovieRepository).Returns(mockMovieRepository.Object);
unitOfWork.SetupGet(x => x.UserProfileRepository).Returns(mockUserRepository.Object);
unitOfWork.SetupGet(x => x.ReviewRepository).Returns(mockReviewRepository.Object);
// Act
var movieService = new MovieService(unitOfWork.Object);
var result = await movieService.GetOne(movieId);
// Assert
Assert.Equal(expectedResult.Id, result.Id);
Assert.Equal(expectedResult.Title, result.Title);
Assert.Equal(expectedResult.PlotSummary, result.PlotSummary);
Assert.Equal(expectedResult.Director, result.Director);
Assert.Equal(expectedResult.CastAndCrew, result.CastAndCrew);
Assert.Equal(expectedResult.ReleaseDate, result.ReleaseDate);
Assert.Equal(expectedResult.Language, result.Language);
Assert.Equal(expectedResult.TotalReviews, result.TotalReviews);
Assert.Equal(expectedResult.Rating, result.Rating);
}