def test_get_reviews_for_movie(repository):
assert services.get_reviews_for_movie(Movie(
"Moana", 2016), repository)[0]['review_text'] == "very nice"
assert services.get_reviews_for_movie(Movie("Moana", 2016),
repository)[0]['rating'] == 9
assert services.get_reviews_for_movie(Movie("A Silent Voice", 2016),
repository) == []
def test_can_get_reviews_for_movie(in_memory_repo):
movie_id = 1
# adding review to repo
user = User("shaun", '12345')
review = make_review("Wow", user, in_memory_repo.get_movie(1), 10)
in_memory_repo.add_review(review)
# testing retrieval of review
reviews = movies_services.get_reviews_for_movie(movie_id, in_memory_repo)
assert len(reviews) == 1
assert reviews[0]["review_text"] == "Wow"
def test_get_reviews_for_movie(in_memory_repo):
new_username = '******'
new_password = '******'
auth_services.add_user(new_username, new_password, in_memory_repo)
movie_title = "Suicide Squad"
review_text = "Lots of carnage"
rating = 7
movies_services.add_review(movie_title, review_text, new_username, rating,
in_memory_repo)
reviews_as_dict = movies_services.get_reviews_for_movie(
movie_title, in_memory_repo)
reviews_as_dict = movies_services.get_reviews_for_movie(
"Suicide Squad", in_memory_repo)
assert len(reviews_as_dict) == 1
movies = [review['movie'].title for review in reviews_as_dict]
assert movie_title in movies and len(movies) == 1
def test_can_add_review(in_memory_repo):
movie_id = 1
review_text = "Wasn't a fan"
rating = 4
username = '******'
movies_services.add_review(movie_id, review_text, rating, username,
in_memory_repo)
comments_as_dict = movies_services.get_reviews_for_movie(
movie_id, in_memory_repo)
assert next((dictionary['review_text'] for dictionary in comments_as_dict
if dictionary["review_text"] == review_text),
None) is not None
def test_get_reviews_for_movie(in_memory_repo):
movie_id = 1
movie = in_memory_repo.get_movie_by_id(1)
review_text = "Hi this is my review"
rating = 9
username = "******"
password = "******"
user = User(username, password)
in_memory_repo.add_user(user)
movies_services.add_review(movie_id, review_text, rating, username,
in_memory_repo)
review_dict_list = movies_services.get_reviews_for_movie(
movie_id, in_memory_repo)
assert len(review_dict_list) == 1
assert review_dict_list[0]["movie"] == movie
def test_get_reviews_for_movie(in_memory_repo):
movie_id = 1
review_text = "Good as movie"
new_username = '******'
new_password = '******'
auth_services.add_user(new_username, new_password, in_memory_repo)
movie_library_services.add_review(movie_id, review_text, new_username,
in_memory_repo)
reviews_as_dict = movie_library_services.get_reviews_for_movie(
1, in_memory_repo)
assert len(reviews_as_dict) == 1
# Check that the review relates to the movie whose id is 1.
movie_ids = [review['movie_id'] for review in reviews_as_dict]
movie_ids = set(movie_ids)
assert 1 in movie_ids and len(movie_ids) == 1
def reviews():
target_title = request.args.get('title')
target_year = request.args.get('release_year')
if target_year is not None:
target_year = int(target_year)
target_movie = services.get_movie(target_title, target_year,
repo.repo_instance)
if target_movie is None:
return redirect(url_for('home_bp.home'))
review_list = services.get_reviews_for_movie(target_movie,
repo.repo_instance)
reviews_id = 0
if request.args.get('next_id') is not None:
reviews_id = int(request.args.get('next_id'))
next_id = min(reviews_id + 3, len(review_list))
prev_id = max(reviews_id - 3, 0)
next_reviews = False
prev_reviews = False
if len(review_list) - (reviews_id + 1) >= 3:
next_reviews = True
if reviews_id >= 3:
prev_reviews = True
target_movie = services.movie_to_dict(target_movie)
target_movie['url'] = url_for('movies_bp.movie',
title=target_title,
release_year=target_year)
target_movie['review_url'] = url_for('movies_bp.review_movie',
title=target_title,
release_year=target_year)
return render_template('movies/reviews.html',
movie=target_movie,
reviews=review_list[reviews_id:next_id],
prev_reviews=prev_reviews,
prev_reviews_url=url_for('movies_bp.reviews',
title=target_title,
release_year=target_year,
next_id=prev_id),
next_reviews=next_reviews,
next_reviews_url=url_for('movies_bp.reviews',
title=target_title,
release_year=target_year,
next_id=next_id),
watchlist_empty=utilities.get_watchlist_empty())
def test_can_add_comment(in_memory_repo):
new_username = '******'
new_password = '******'
auth_services.add_user(new_username, new_password, in_memory_repo)
movie_title = '21'
comment_text = 'The loonies are stripping the supermarkets bare!'
username = '******'
# Call the service layer to add the comment.
movs_services.add_review(movie_title, comment_text, username, in_memory_repo)
# Retrieve the comments for the article from the repository.
comments_as_dict = movs_services.get_reviews_for_movie(movie_title, in_memory_repo)
# Check that the comments include a comment with the new comment text.
assert comments_as_dict != []
def test_can_add_review(in_memory_repo):
new_username = '******'
new_password = '******'
auth_services.add_user(new_username, new_password, in_memory_repo)
movie_title = "Suicide Squad"
review_text = "Lots of carnage"
rating = 7
movies_services.add_review(movie_title, review_text, new_username, rating,
in_memory_repo)
reviews_as_dict = movies_services.get_reviews_for_movie(
movie_title, in_memory_repo)
assert next((dictionary['review_text'] for dictionary in reviews_as_dict
if dictionary['review_text'] == review_text),
None) is not None
def test_can_add_review(in_memory_repo):
new_username = '******'
new_password = '******'
auth_services.add_user(new_username, new_password, in_memory_repo)
movie_id = 3
review_text = 'Average movie'
# Call the service layer to add the review.
movie_library_services.add_review(movie_id, review_text, new_username,
in_memory_repo)
# Retrieve the review for the movie from the repository.
reviews_as_dict = movie_library_services.get_reviews_for_movie(
movie_id, in_memory_repo)
# Check that the review includes a review with the new review text.
assert next((dictionary['review_text'] for dictionary in reviews_as_dict
if dictionary['review_text'] == review_text),
None) is not None
def test_get_reviews_for_movie_without_reviews(in_memory_repo):
movies_as_dict = movies_services.get_reviews_for_movie(2, in_memory_repo)
assert len(movies_as_dict) == 0
def movies_by_genre():
movies_per_page = 15
gen_name = request.args.get('genre')
cursor = request.args.get('cursor')
movie_to_watchlst = request.args.get('movie')
get_movies_dict = mem_repo.get_movies_by("flix/datafiles", "genre")
chosen_movies = sorted(get_movies_dict[gen_name])
comments = request.args.get('view_comments_for')
if comments == None:
comments = "None"
if movie_to_watchlst == None:
movie_to_show_comments = "None"
else:
username = session['username']
for mov in chosen_movies:
if mov.title == movie_to_watchlst[movie_to_watchlst.find(" ") +
1:movie_to_watchlst.find(",")]:
mov.remove_url(url_for('movies_bp.my_watchlst', movie=mov))
services.add_to_watchlist(username, mov, repo.repo_instance)
if cursor is None:
# No cursor query parameter, so initialise cursor to start at the beginning.
cursor = 0
else:
# Convert cursor from string to int.
cursor = int(cursor)
movs_to_show = chosen_movies[cursor:cursor + movies_per_page]
next_mov_url = None
prev_mov_url = None
if cursor > 0:
prev_mov_url = url_for('movies_bp.movies_by_genre',
genre=gen_name,
cursor=cursor - movies_per_page)
if cursor + movies_per_page < len(chosen_movies):
# There are further articles, so generate URLs for the 'next' and 'last' navigation buttons.
next_mov_url = url_for('movies_bp.movies_by_genre',
genre=gen_name,
cursor=cursor + movies_per_page)
for movie in chosen_movies:
movie.view_url(
url_for('movies_bp.movies_by_genre',
genre=gen_name,
cursor=cursor,
view_comments_for=movie))
movie.add_url(url_for('movies_bp.comment_on_movies', movie=movie))
movie.add_watchlst_url(
url_for('movies_bp.movies_by_genre',
genre=gen_name,
cursor=cursor,
movie=movie))
reviews_for_mov = ""
if comments != None:
reviews_for_mov = services.get_reviews_for_movie(
comments[comments.find(" ") + 1:comments.find(",")],
repo.repo_instance)
return render_template('movies/movies.html',
movies_title='Movies with genre: ' + gen_name,
movies=movs_to_show,
prev_mov_url=prev_mov_url,
next_mov_url=next_mov_url,
mov_gen=utilities.get_movies_with_genre(),
genre_display=utilities.get_movies_with_genre(),
see_comments=comments[comments.find(" ") +
1:comments.find(",")],
mov_rev='Reviews for Movie: ' +
comments[comments.find(" ") + 1:comments.find(",")],
comment_for_movie=reviews_for_mov)
def test_get_reviews_for_movie_without_reviews(in_memory_repo):
reviews_as_dict = movies_services.get_reviews_for_movie(
"Suicide Squad", in_memory_repo)
assert len(reviews_as_dict) == 0
def test_get_comments_for_non_existent_movie(in_memory_repo):
assert movs_services.get_reviews_for_movie('abcsd', in_memory_repo) == []
def test_get_reviews_for_non_existent_movie(in_memory_repo):
with pytest.raises(NonExistentMovieException):
reviews_as_dict = movie_library_services.get_reviews_for_movie(
1001, in_memory_repo)
def test_get_review_for_movie_without_review(in_memory_repo):
reviews_as_dict = movie_library_services.get_reviews_for_movie(
1, in_memory_repo)
assert len(reviews_as_dict) == 0
def test_cannot_get_reviews_for_non_existent_movie(in_memory_repo):
with pytest.raises(movies_services.NonExistentMovieException):
reviews = movies_services.get_reviews_for_movie(12, in_memory_repo)
def test_can_get_reviews_for_movie_without_reviews(in_memory_repo):
reviews = movies_services.get_reviews_for_movie(2, in_memory_repo)
assert len(reviews) == 0
def test_get_comments_for_movie_without_comments(in_memory_repo):
comments_as_dict = movs_services.get_reviews_for_movie('21', in_memory_repo)
assert len(comments_as_dict) == 0
