public async Task PromoteUserShouldReturnFalseIfUserIsNotInRegularUserRole()
{
var user = new MovieDatabaseUser
{
AvatarLink = "avatar",
Email = "*****@*****.**",
UserName = "******",
};
var adminRole = new IdentityRole {
Name = "Admin", NormalizedName = "ADMIN"
};
await dbContext.Users.AddAsync(user);
await dbContext.Roles.AddAsync(adminRole);
await dbContext.SaveChangesAsync();
var adminRoleId = adminRole.Id;
mockUserManager.Setup(x => x.IsInRoleAsync(user, "Admin")).ReturnsAsync(true);
var userService = new UserService(dbContext, mockUserManager.Object);
var result = await userService.PromoteUserAsync(new PromoteUserInputModel { Name = "user1" });
Assert.False(result);
}
public async Task DeleteSeasonReviewShouldReturnFalseIfReviewDoesntExist()
{
var user1 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar",
};
var season1 = new Season
{
SeasonNumber = 1,
Episodes = 10,
LengthPerEpisode = 29,
ReleaseDate = DateTime.Parse("28 October 2016"),
};
await dbContext.Seasons.AddAsync(season1);
await dbContext.SaveChangesAsync();
var seasonId = season1.Id;
var userId = user1.Id;
var reviewService = new ReviewService(dbContext, mapper);
var actualResult = await reviewService.DeleteSeasonReviewAsync(userId, seasonId);
Assert.False(actualResult);
Assert.True(dbContext.SeasonReviews.Count() == 0);
}
public async Task CreateMovieReviewShouldReturnFalseIfReviewAlreadyExists()
{
var user1 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar",
};
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var movie1 = new Movie
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = new Genre {
Name = "genre1"
},
Director = artist1,
CoverImageLink = "cover1",
TrailerLink = "trailer1",
};
var movieReview1 = new MovieReview
{
Movie = movie1,
User = user1,
Content = "content1",
Rating = 8,
Date = DateTime.Parse("27 July 2019"),
};
await dbContext.Movies.AddAsync(movie1);
await dbContext.MovieReviews.AddAsync(movieReview1);
await dbContext.SaveChangesAsync();
var movieId = movie1.Id;
var userId = user1.Id;
var reviewService = new ReviewService(dbContext, mapper);
var input = new CreateReviewInputModel
{
Id = movieId,
Content = "content1",
Rating = 8,
};
var actualResult = await reviewService.CreateMovieReviewAsync(userId, input);
Assert.False(actualResult);
Assert.True(dbContext.MovieReviews.Count() == 1);
}
public async Task MovieIsInUserWatchlistShouldReturnCorrectResult()
{
var user1 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar",
};
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var movie1 = new Movie
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = new Genre {
Name = "genre1"
},
Director = artist1,
CoverImageLink = "cover1",
TrailerLink = "trailer1",
};
var movieUser = new MovieUser
{
User = user1,
Movie = movie1,
};
await dbContext.Users.AddAsync(user1);
await dbContext.Movies.AddAsync(movie1);
await dbContext.MovieUsers.AddAsync(movieUser);
await dbContext.SaveChangesAsync();
var userId = user1.Id;
var movieId = movie1.Id;
var watchlistService = new WatchlistService(dbContext, mapper);
var movieResult = await watchlistService.MovieIsInUserWatchlistAsync(userId, movieId);
var invalid1 = await watchlistService.MovieIsInUserWatchlistAsync("invalidUserId", movieId);
var invalid2 = await watchlistService.MovieIsInUserWatchlistAsync(userId, "invalidMovieId");
Assert.True(movieResult);
Assert.False(invalid1);
Assert.False(invalid2);
}
public async Task TVShowIsInUserWatchlistShouldReturnCorrectResult()
{
var user1 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar",
};
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var tvShow1 = new TVShow
{
Name = "tvShow1",
Description = "description2",
Genre = new Genre {
Name = "genre2"
},
Creator = artist1,
CoverImageLink = "cover2",
TrailerLink = "trailer2",
};
var tvShowUser = new TVShowUser
{
User = user1,
TVShow = tvShow1,
};
await dbContext.Users.AddAsync(user1);
await dbContext.TVShows.AddAsync(tvShow1);
await dbContext.TVShowUsers.AddAsync(tvShowUser);
await dbContext.SaveChangesAsync();
var userId = user1.Id;
var tvShowId = tvShow1.Id;
var watchlistService = new WatchlistService(dbContext, mapper);
var tvShowResult = await watchlistService.TVShowIsInUserWatchlistAsync(userId, tvShowId);
var invalid1 = await watchlistService.TVShowIsInUserWatchlistAsync("invalidUserId", tvShowId);
var invalid2 = await watchlistService.TVShowIsInUserWatchlistAsync(userId, "invalidTvShowId");
Assert.True(tvShowResult);
Assert.False(invalid1);
Assert.False(invalid2);
}
public async Task RemoveMovieFromUserWatchlistShouldShouldRemoveMovieFromWatchlistProperly()
{
var user1 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar",
};
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var movie1 = new Movie
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = new Genre {
Name = "genre1"
},
Director = artist1,
CoverImageLink = "cover1",
TrailerLink = "trailer1",
};
var movieUser = new MovieUser
{
User = user1,
Movie = movie1,
};
await dbContext.Users.AddAsync(user1);
await dbContext.Movies.AddAsync(movie1);
await dbContext.MovieUsers.AddAsync(movieUser);
await dbContext.SaveChangesAsync();
var userId = user1.Id;
var movieId = movie1.Id;
var watchlistService = new WatchlistService(dbContext, mapper);
Assert.True(dbContext.MovieUsers.Count() == 1);
await watchlistService.RemoveMovieFromUserWatchlistAsync(userId, movieId);
Assert.True(dbContext.MovieUsers.Count() == 0);
}
public async Task UpdateSeasonReviewShouldUpdateReviewProperly()
{
var user1 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar",
};
var season1 = new Season
{
SeasonNumber = 1,
Episodes = 10,
LengthPerEpisode = 29,
ReleaseDate = DateTime.Parse("28 October 2016"),
};
var seasonReview1 = new SeasonReview
{
Season = season1,
User = user1,
Content = "content1",
Rating = 8,
Date = DateTime.Parse("27 July 2019"),
};
await dbContext.Seasons.AddAsync(season1);
await dbContext.SeasonReviews.AddAsync(seasonReview1);
await dbContext.SaveChangesAsync();
var seasonId = season1.Id;
var userId = user1.Id;
var reviewService = new ReviewService(dbContext, mapper);
var input = new CreateReviewInputModel
{
Id = seasonId,
Content = "content2",
Rating = 7,
};
var actualResult = await reviewService.UpdateSeasonReviewAsync(userId, input);
Assert.True(actualResult);
Assert.True(dbContext.SeasonReviews.Count() == 1);
Assert.Equal(7, dbContext.SeasonReviews.First().Rating);
Assert.Equal("content2", dbContext.SeasonReviews.First().Content);
Assert.Equal(userId, dbContext.SeasonReviews.First().UserId);
Assert.Equal(seasonId, dbContext.SeasonReviews.First().SeasonId);
}
public async Task GetSeasonReviewShouldReturnCorrectModel()
{
var user1 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar",
};
var season1 = new Season
{
SeasonNumber = 1,
Episodes = 10,
LengthPerEpisode = 29,
ReleaseDate = DateTime.Parse("28 October 2016"),
};
var seasonReview1 = new SeasonReview
{
Season = season1,
User = user1,
Content = "content1",
Rating = 8,
Date = DateTime.Parse("27 July 2019"),
};
await dbContext.Seasons.AddAsync(season1);
await dbContext.SeasonReviews.AddAsync(seasonReview1);
await dbContext.SaveChangesAsync();
var seasonId = season1.Id;
var userId = user1.Id;
var reviewService = new ReviewService(dbContext, mapper);
var expectedResult = new CreateReviewInputModel
{
Id = seasonId,
Content = "content1",
Rating = 8,
};
var actualResult = await reviewService.GetSeasonReviewAsync(userId, seasonId);
Assert.Equal(expectedResult.GetType(), actualResult.GetType());
Assert.Equal(expectedResult.Id, actualResult.Id);
Assert.Equal(expectedResult.Content, actualResult.Content);
Assert.Equal(expectedResult.Rating, actualResult.Rating);
}
public async Task AddTVShowToUserWatchlistShouldShouldAddMovieTouserWatchlistProperly()
{
var user1 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar",
};
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var tvShow1 = new TVShow
{
Name = "movie1",
Description = "description1",
Genre = new Genre {
Name = "genre1"
},
Creator = artist1,
CoverImageLink = "cover1",
TrailerLink = "trailer1",
};
await dbContext.Users.AddAsync(user1);
await dbContext.TVShows.AddAsync(tvShow1);
await dbContext.SaveChangesAsync();
var userId = user1.Id;
var tvShowId = tvShow1.Id;
var watchlistService = new WatchlistService(dbContext, mapper);
Assert.True(dbContext.TVShowUsers.Count() == 0);
await watchlistService.AddTVShowToUserWatchlistAsync(userId, tvShowId);
Assert.True(dbContext.TVShowUsers.Count() == 1);
Assert.Equal(dbContext.TVShowUsers.First().TVShow, tvShow1);
Assert.Equal(dbContext.TVShowUsers.First().User, user1);
}
public async Task GetUserAvatarLinkShouldReturnDefaultImageIfIdIsInvalid()
{
var user = new MovieDatabaseUser
{
AvatarLink = "avatar",
Email = "*****@*****.**",
UserName = "******",
};
await dbContext.Users.AddAsync(user);
await dbContext.SaveChangesAsync();
var avatarService = new AvatarService(dbContext);
var actualResult = await avatarService.GetUserAvatarLink("invalidId");
Assert.True(actualResult == GlobalConstants.avatarLinkPrefix + "no_avatar.jpg");
}
public async Task GetUserIdFromUsrnameShouldReturnNullIfInputIsInvalid()
{
var user = new MovieDatabaseUser
{
AvatarLink = "avatar",
Email = "*****@*****.**",
UserName = "******",
};
await dbContext.Users.AddAsync(user);
await dbContext.SaveChangesAsync();
var userService = new UserService(dbContext, mockUserManager.Object);
var actualResult = await userService.GetUserIdFromUserNameAsync("invalid");
Assert.True(actualResult == null);
}
public async Task GetUserIdFromUsrnameShouldReturnIdProperlyIfdataIsValid()
{
var user = new MovieDatabaseUser
{
AvatarLink = "avatar",
Email = "*****@*****.**",
UserName = "******",
};
await dbContext.Users.AddAsync(user);
await dbContext.SaveChangesAsync();
var expectedId = dbContext.Users.First().Id;
var userService = new UserService(dbContext, mockUserManager.Object);
var actualId = await userService.GetUserIdFromUserNameAsync("user1");
Assert.Equal(actualId, expectedId);
}
public async Task GetUserAvatarLinkShouldReturnImageProperly()
{
var user = new MovieDatabaseUser
{
AvatarLink = "avatar",
Email = "*****@*****.**",
UserName = "******",
};
await dbContext.Users.AddAsync(user);
await dbContext.SaveChangesAsync();
var id = dbContext.Users.First().Id;
var avatarService = new AvatarService(dbContext);
var actualResult = await avatarService.GetUserAvatarLink(id);
Assert.True(actualResult == "avatar");
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new MovieDatabaseUser {
UserName = Input.UserName, Email = Input.Email, AvatarLink = GlobalConstants.noUserAvatar
};
var result = await userManager.CreateAsync(user, Input.Password);
if (userManager.Users.Count() == 1)
{
await userManager.AddToRoleAsync(user, GlobalConstants.adminRoleName);
}
else
{
await userManager.AddToRoleAsync(user, GlobalConstants.userRoleName);
}
if (result.Succeeded)
{
logger.LogInformation("User created a new account with password.");
await signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task GetMovieAndDetailsByIdShouldReturnCorrectModel()
{
var user1 = new MovieDatabaseUser
{
UserName = "******",
AvatarLink = "img",
Email = "*****@*****.**",
};
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var movie1 = new Movie
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = new Genre {
Name = "genre1"
},
Director = artist1,
CoverImageLink = "cover1",
TrailerLink = "trailer1",
Cast = new List <MovieRole>
{
new MovieRole
{
Artist = artist1,
CharacterPlayed = "character1",
},
}
};
var movieReview = new MovieReview
{
User = user1,
Movie = movie1,
Content = "content",
Rating = 9,
Date = DateTime.Parse("26 July 2019"),
};
await dbContext.Users.AddAsync(user1);
await dbContext.Artists.AddAsync(artist1);
await dbContext.Movies.AddAsync(movie1);
await dbContext.MovieReviews.AddAsync(movieReview);
await dbContext.SaveChangesAsync();
var id = dbContext.Movies.First().Id;
reviewService.Setup(r => r.ReviewExistsAsync("", ""))
.ReturnsAsync(false);
var movieService = new MovieService(dbContext, reviewService.Object, watchlistService.Object, mapper);
var expectedResult = new MovieDetailsViewModel
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = "genre1",
Director = "name1",
CoverImageLink = "cover1",
TrailerLink = "trailer1",
IsReviewedByCurrentUser = false,
Rating = 9,
ReviewsCount = 1,
RandomReview = new MovieReviewViewModel
{
User = "******",
Movie = "movie1",
Content = "content",
Rating = 9,
Date = DateTime.Parse("26 July 2019"),
},
};
var actualResult = await movieService.GetMovieAndDetailsByIdAsync(id);
Assert.Equal(expectedResult.Name, actualResult.Name);
Assert.Equal(expectedResult.ReleaseDate, actualResult.ReleaseDate);
Assert.Equal(expectedResult.Description, actualResult.Description);
Assert.Equal(expectedResult.Length, actualResult.Length);
Assert.Equal(expectedResult.Genre, actualResult.Genre);
Assert.Equal(expectedResult.Director, actualResult.Director);
Assert.Equal(expectedResult.CoverImageLink, actualResult.CoverImageLink);
Assert.Equal(expectedResult.TrailerLink, actualResult.TrailerLink);
Assert.Equal(expectedResult.Rating, actualResult.Rating);
Assert.Equal(expectedResult.ReviewsCount, actualResult.ReviewsCount);
Assert.Equal(expectedResult.RandomReview.User, actualResult.RandomReview.User);
Assert.Equal(expectedResult.RandomReview.Movie, actualResult.RandomReview.Movie);
Assert.Equal(expectedResult.RandomReview.Content, actualResult.RandomReview.Content);
Assert.Equal(expectedResult.RandomReview.Rating, actualResult.RandomReview.Rating);
Assert.Equal(expectedResult.RandomReview.Date, actualResult.RandomReview.Date);
Assert.True(actualResult.Cast.Count() == 1);
Assert.True(actualResult.Cast.First().Actor == "name1");
Assert.True(actualResult.Cast.First().MovieCharacter == "character1");
}
public async Task GetItemsInUserWatchlistShouldReturnWatchlistProperly()
{
var user1 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar",
};
var user2 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar2",
};
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var movie1 = new Movie
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = new Genre {
Name = "genre1"
},
Director = artist1,
CoverImageLink = "cover1",
TrailerLink = "trailer1",
};
var tvShow1 = new TVShow
{
Name = "tvShow1",
Description = "description2",
Genre = new Genre {
Name = "genre2"
},
Creator = artist1,
CoverImageLink = "cover2",
TrailerLink = "trailer2",
};
var season1 = new Season
{
TVShow = tvShow1,
SeasonNumber = 1,
Episodes = 20,
LengthPerEpisode = 45,
ReleaseDate = DateTime.Parse("24 July 2019"),
};
var movieUser = new MovieUser
{
User = user1,
Movie = movie1,
};
var movieUser2 = new MovieUser
{
User = user2,
Movie = movie1,
};
var movieReview = new MovieReview
{
User = user1,
Movie = movie1,
Content = "content1",
Rating = 6,
Date = DateTime.UtcNow,
};
var tvShowUser = new TVShowUser
{
User = user1,
TVShow = tvShow1,
};
var seasonReview = new SeasonReview
{
User = user1,
Season = season1,
Content = "content2",
Rating = 5,
Date = DateTime.UtcNow,
};
await dbContext.Users.AddAsync(user1);
await dbContext.Movies.AddAsync(movie1);
await dbContext.TVShows.AddAsync(tvShow1);
await dbContext.Seasons.AddAsync(season1);
await dbContext.MovieUsers.AddAsync(movieUser);
await dbContext.MovieUsers.AddAsync(movieUser2);
await dbContext.TVShowUsers.AddAsync(tvShowUser);
await dbContext.MovieReviews.AddAsync(movieReview);
await dbContext.SeasonReviews.AddAsync(seasonReview);
await dbContext.SaveChangesAsync();
var userId = user1.Id;
var movie1Id = movie1.Id;
var tvShow1Id = tvShow1.Id;
var watchlistService = new WatchlistService(dbContext, mapper);
var expectedResult = new List <WatchlistAllViewModel>
{
new WatchlistAllViewModel
{
Id = movie1Id,
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1....",
CoverImageLink = "cover1",
Category = "Movies",
Rating = 6,
},
new WatchlistAllViewModel
{
Id = tvShow1Id,
Name = "tvShow1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description2....",
CoverImageLink = "cover2",
Category = "TVShows",
Rating = 5,
}
};
var actualResult = await watchlistService.GetItemsInUserWatchlistAsync(userId);
Assert.True(actualResult.Count() == 2);
Assert.Equal(expectedResult[0].Id, actualResult[0].Id);
Assert.Equal(expectedResult[0].Name, actualResult[0].Name);
Assert.Equal(expectedResult[0].ReleaseDate, actualResult[0].ReleaseDate);
Assert.Equal(expectedResult[0].Description, actualResult[0].Description);
Assert.Equal(expectedResult[0].CoverImageLink, actualResult[0].CoverImageLink);
Assert.Equal(expectedResult[0].Category, actualResult[0].Category);
Assert.Equal(expectedResult[0].Rating, actualResult[0].Rating);
Assert.Equal(expectedResult[1].Id, actualResult[1].Id);
Assert.Equal(expectedResult[1].Name, actualResult[1].Name);
Assert.Equal(expectedResult[1].ReleaseDate, actualResult[1].ReleaseDate);
Assert.Equal(expectedResult[1].Description, actualResult[1].Description);
Assert.Equal(expectedResult[1].CoverImageLink, actualResult[1].CoverImageLink);
Assert.Equal(expectedResult[1].Category, actualResult[1].Category);
Assert.Equal(expectedResult[1].Rating, actualResult[1].Rating);
}
public async Task ReviewExistsShouldReturnCorrectResult()
{
var user1 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar",
};
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var movie1 = new Movie
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = new Genre {
Name = "genre1"
},
Director = artist1,
CoverImageLink = "cover1",
TrailerLink = "trailer1",
};
var season1 = new Season
{
SeasonNumber = 1,
Episodes = 5,
ReleaseDate = DateTime.UtcNow,
LengthPerEpisode = 35,
};
var movieReview = new MovieReview
{
Movie = movie1,
User = user1,
Content = "content1",
Rating = 8,
Date = DateTime.UtcNow,
};
var seasonReview = new SeasonReview
{
Season = season1,
User = user1,
Content = "content2",
Rating = 7,
Date = DateTime.UtcNow,
};
await dbContext.Movies.AddAsync(movie1);
await dbContext.Seasons.AddAsync(season1);
await dbContext.MovieReviews.AddAsync(movieReview);
await dbContext.SeasonReviews.AddAsync(seasonReview);
await dbContext.SaveChangesAsync();
var userId = user1.Id;
var movieId = movie1.Id;
var seasonId = season1.Id;
var reviewService = new ReviewService(dbContext, mapper);
var movieResult = await reviewService.ReviewExistsAsync(userId, movieId);
var seasonResult = await reviewService.ReviewExistsAsync(userId, seasonId);
var invalid = await reviewService.ReviewExistsAsync(userId, "invalidId");
Assert.True(movieResult);
Assert.True(seasonResult);
Assert.False(invalid);
}
public async Task GetAllMovieReviewsShouldReturnAllReviewsProperly()
{
var user1 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar",
};
var user2 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar2",
};
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var movie1 = new Movie
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = new Genre {
Name = "genre1"
},
Director = artist1,
CoverImageLink = "cover1",
TrailerLink = "trailer1",
};
var movieReview1 = new MovieReview
{
Movie = movie1,
User = user1,
Content = "content1",
Rating = 8,
Date = DateTime.Parse("27 July 2019"),
};
var movieReview2 = new MovieReview
{
Movie = movie1,
User = user2,
Content = "content2",
Rating = 9,
Date = DateTime.Parse("27 July 2019"),
};
await dbContext.Movies.AddAsync(movie1);
await dbContext.MovieReviews.AddAsync(movieReview1);
await dbContext.MovieReviews.AddAsync(movieReview2);
await dbContext.SaveChangesAsync();
var movieId = movie1.Id;
var reviewService = new ReviewService(dbContext, mapper);
var expectedResult = new List <ReviewAllViewModel>
{
new ReviewAllViewModel
{
Item = "movie1",
User = "******",
Content = "content1",
Rating = 8,
Date = DateTime.Parse("27 July 2019"),
},
new ReviewAllViewModel
{
Item = "movie1",
User = "******",
Content = "content2",
Rating = 9,
Date = DateTime.Parse("27 July 2019"),
},
};
var actualResult = await reviewService.GetAllMovieReviewsAsync(movieId);
Assert.True(actualResult.Count() == 2);
Assert.Equal(expectedResult[0].Item, actualResult[0].Item);
Assert.Equal(expectedResult[0].User, actualResult[0].User);
Assert.Equal(expectedResult[0].Content, actualResult[0].Content);
Assert.Equal(expectedResult[0].Rating, actualResult[0].Rating);
Assert.Equal(expectedResult[0].Date, actualResult[0].Date);
Assert.Equal(expectedResult[1].Item, actualResult[1].Item);
Assert.Equal(expectedResult[1].User, actualResult[1].User);
Assert.Equal(expectedResult[1].Content, actualResult[1].Content);
Assert.Equal(expectedResult[1].Rating, actualResult[1].Rating);
Assert.Equal(expectedResult[1].Date, actualResult[1].Date);
}
public async Task GetAllSeasonReviewsShouldReturnAllReviewsProperly()
{
var user1 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar",
};
var user2 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar2",
};
var tvShow1 = new TVShow
{
Name = "tvshow1",
Description = "description",
};
var season1 = new Season
{
SeasonNumber = 1,
Episodes = 9,
LengthPerEpisode = 56,
ReleaseDate = DateTime.Parse("11 January 1998"),
TVShow = tvShow1,
};
var seasonReview1 = new SeasonReview
{
Season = season1,
User = user1,
Content = "content1",
Rating = 8,
Date = DateTime.Parse("27 July 2019"),
};
var seasonReview2 = new SeasonReview
{
Season = season1,
User = user2,
Content = "content2",
Rating = 9,
Date = DateTime.Parse("27 July 2019"),
};
await dbContext.TVShows.AddAsync(tvShow1);
await dbContext.Seasons.AddAsync(season1);
await dbContext.SeasonReviews.AddAsync(seasonReview1);
await dbContext.SeasonReviews.AddAsync(seasonReview2);
await dbContext.SaveChangesAsync();
var seasonId = season1.Id;
var reviewService = new ReviewService(dbContext, mapper);
var expectedResult = new List <ReviewAllViewModel>
{
new ReviewAllViewModel
{
Item = "tvshow1 Season 1",
User = "******",
Content = "content1",
Rating = 8,
Date = DateTime.Parse("27 July 2019"),
},
new ReviewAllViewModel
{
Item = "tvshow1 Season 1",
User = "******",
Content = "content2",
Rating = 9,
Date = DateTime.Parse("27 July 2019"),
},
};
var actualResult = await reviewService.GetAllSeasonReviewsAsync(seasonId);
Assert.True(actualResult.Count() == 2);
Assert.Equal(expectedResult[0].Item, actualResult[0].Item);
Assert.Equal(expectedResult[0].User, actualResult[0].User);
Assert.Equal(expectedResult[0].Content, actualResult[0].Content);
Assert.Equal(expectedResult[0].Rating, actualResult[0].Rating);
Assert.Equal(expectedResult[0].Date, actualResult[0].Date);
Assert.Equal(expectedResult[1].Item, actualResult[1].Item);
Assert.Equal(expectedResult[1].User, actualResult[1].User);
Assert.Equal(expectedResult[1].Content, actualResult[1].Content);
Assert.Equal(expectedResult[1].Rating, actualResult[1].Rating);
Assert.Equal(expectedResult[1].Date, actualResult[1].Date);
}
