def test_check_size_of_nonempty_watchlist(self):
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016, 1))
watchlist.add_movie(Movie("Ice Age", 2002, 2))
watchlist.add_movie(Movie("Guardians of the Galaxy", 2012, 3))
print()
print(f"Size of watchlist is: {watchlist.size()}")
def test_select_movie_to_watch_index_out_of_bounds(self):
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016, 1))
watchlist.add_movie(Movie("Ice Age", 2002, 2))
watchlist.add_movie(Movie("Guardians of the Galaxy", 2012, 3))
print()
print(f"Selected movie: {watchlist.select_movie_to_watch(9)}")
def test_can_add_review():
mem_repo = MemoryRepository()
up_movie = Movie("Up", 2009, 1)
klaus_movie = Movie("Klaus", 2019, 2)
dolittle_movie = Movie("Dolittle", 2019, 3)
mem_repo.add_movie(up_movie)
mem_repo.add_movie(klaus_movie)
mem_repo.add_movie(dolittle_movie)
# ["Dolittle", "Klaus", "Up"]
movie_id = 3
review_text = "Very good!"
username = "******"
rating = 5
mem_repo.add_user(User(username, "CS235"))
# call the service layer to add the comment
movie_services.add_review(movie_id, review_text, rating, username,
mem_repo)
# retrieve the reviews for the movie from the repository
reviews_as_dict = movie_services.get_reviews_for_movie(movie_id, mem_repo)
# check that the reviews inclue 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_add_movie(self):
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016, 1))
watchlist.add_movie(Movie("Ice Age", 2002, 2))
watchlist.add_movie(Movie("Guardians of the Galaxy", 2012, 3))
print()
print(watchlist.first_movie_in_watchlist())
def load_movies(data_path, repo):
filename = os.path.join(data_path, "movies.csv")
with open(filename, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
for row in movie_file_reader:
media_id = row["Id"]
title = row['Title']
release_year = int(row['Year'])
description = row["Description"]
runtime_minutes = row["Runtime (Minutes)"]
director = Director(row["Director"])
genres = set([Genre(x) for x in row["Genre"].split(',')])
actors = set([Actor(x) for x in row["Actors"].split(',')])
movie = Movie(title, release_year)
movie.description = description
movie.runtime_minutes = runtime_minutes
movie.director = director
movie.media_id = media_id
for genre in genres:
movie.add_genre(genre)
for actor in actors:
movie.add_actor(actor)
repo.add_media(movie)
def test_director():
movie1 = Movie("Moana", 2000)
assert movie1.director == Director(None)
movie1.director = Director("Ron Clements")
assert movie1.director == Director("Ron Clements")
movie1.director = Director("Rob Clements")
assert movie1.director == Director("Rob Clements")
def test_iterator_used(self):
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016, 1))
watchlist.add_movie(Movie("Ice Age", 2002, 2))
watchlist.add_movie(Movie("Guardians of the Galaxy", 2012, 3))
print()
for movie in watchlist:
print(movie)
def test_sort():
movie1 = Movie("Moana", 2000)
movie2 = Movie("Moanb", 2000)
movie3 = Movie("Moanb", 2001)
assert movie1 < movie2
assert movie1 < movie3
assert movie2 < movie3
def test_cannot_add_movie_with_non_unique_id():
mem_repo = MemoryRepository()
up_movie = Movie("Up", 2009, 1)
klaus_movie = Movie("Klaus", 2019, 1)
mem_repo.add_movie(up_movie)
mem_repo.add_movie(klaus_movie)
assert mem_repo.get_number_of_movies() == 1
def test_equality():
movie1 = Movie("Moana", 2000)
movie2 = Movie("Moana", 2001)
movie3 = Movie("Moana", 2000)
movie4 = Movie("Moanb", 2000)
assert movie1 != movie2
assert movie1 == movie3
assert movie1 != movie4
def test_get_number_of_movies():
mem_repo = MemoryRepository()
up_movie = Movie("Up", 2009, 1)
klaus_movie = Movie("Klaus", 2019, 2)
dolittle_movie = Movie("Dolittle", 2019, 3)
mem_repo.add_movie(up_movie)
mem_repo.add_movie(klaus_movie)
mem_repo.add_movie(dolittle_movie)
assert mem_repo.get_number_of_movies() == 3
def test_hash():
movie1 = Movie("Moana", 2000)
movie2 = Movie("Moana", 2000)
movie3 = Movie("Moana", 2001)
movies = set([movie1, movie2, movie3])
assert len(movies) == 2
assert movie1 in movies
assert movie2 in movies
assert movie3 in movies
def test_hash(self):
movie1 = Movie("Moana1", 2016, 1)
movie2 = Movie("Moana2", 2016, 2)
movie3 = Movie("Moana3", 2016, 3)
test_set = set()
test_set.add(movie1)
test_set.add(movie2)
test_set.add(movie3)
print()
print(test_set)
def test_repository_returns_year_of_next_movie():
mem_repo = MemoryRepository()
up_movie = Movie("Up", 2009, 1)
klaus_movie = Movie("Klaus", 2019, 2)
dolittle_movie = Movie("Dolittle", 2019, 3)
mem_repo.add_movie(up_movie)
mem_repo.add_movie(klaus_movie)
mem_repo.add_movie(dolittle_movie)
# ["Dolittle", "Klaus", "Up"]
next_year = mem_repo.get_year_of_next_movie(klaus_movie)
assert next_year is None
def test_repository_does_not_retrieve_a_non_existent_title():
mem_repo = MemoryRepository()
up_movie = Movie("Up", 2009, 1)
klaus_movie = Movie("Klaus", 2019, 2)
dolittle_movie = Movie("Dolittle", 2019, 3)
mem_repo.add_movie(up_movie)
mem_repo.add_movie(klaus_movie)
mem_repo.add_movie(dolittle_movie)
movies_by_title = mem_repo.get_movies_by_title(["Up", "Klaus", "Frozen"])
assert len(movies_by_title) == 2
assert movies_by_title == [up_movie, klaus_movie]
def test_repository_does_not_retrieve_a_non_existent_id():
mem_repo = MemoryRepository()
up_movie = Movie("Up", 2009, 1)
klaus_movie = Movie("Klaus", 2019, 2)
dolittle_movie = Movie("Dolittle", 2019, 3)
mem_repo.add_movie(up_movie)
mem_repo.add_movie(klaus_movie)
mem_repo.add_movie(dolittle_movie)
movies_by_id = mem_repo.get_movies_by_id([1, 2, 4])
assert len(movies_by_id) == 2
assert movies_by_id == [up_movie, klaus_movie]
def test_get_last_movie():
mem_repo = MemoryRepository()
up_movie = Movie("Up", 2009, 1)
klaus_movie = Movie("Klaus", 2019, 2)
dolittle_movie = Movie("Dolittle", 2019, 3)
mem_repo.add_movie(up_movie)
mem_repo.add_movie(klaus_movie)
mem_repo.add_movie(dolittle_movie)
movie_as_dict = movie_services.get_last_movie(mem_repo)
# ["Dolittle", "Klaus", "Up"]
assert movie_as_dict["ID"] == 1
def test_repository_can_get_movies_by_id():
mem_repo = MemoryRepository()
up_movie = Movie("Up", 2009, 1)
klaus_movie = Movie("Klaus", 2019, 2)
dolittle_movie = Movie("Dolittle", 2019, 3)
mem_repo.add_movie(up_movie)
mem_repo.add_movie(klaus_movie)
mem_repo.add_movie(dolittle_movie)
# ["Dolittle", "Klaus", "Up"]
movies_by_id = mem_repo.get_movies_by_id([1, 2, 3])
assert len(movies_by_id) == 3
assert movies_by_id == [up_movie, klaus_movie, dolittle_movie]
def test_cannot_get_movie_with_non_existent_id():
mem_repo = MemoryRepository()
up_movie = Movie("Up", 2009, 1)
klaus_movie = Movie("Klaus", 2019, 2)
dolittle_movie = Movie("Dolittle", 2019, 3)
mem_repo.add_movie(up_movie)
mem_repo.add_movie(klaus_movie)
mem_repo.add_movie(dolittle_movie)
# ["Dolittle", "Klaus", "Up"]
movie_id = 7
with pytest.raises(movie_services.NonExistentMovieException):
movie_services.get_movie(movie_id, mem_repo)
def test_get_movies_by_year_with_non_existent_date():
mem_repo = MemoryRepository()
up_movie = Movie("Up", 2009, 1)
klaus_movie = Movie("Klaus", 2019, 2)
dolittle_movie = Movie("Dolittle", 2019, 3)
mem_repo.add_movie(up_movie)
mem_repo.add_movie(klaus_movie)
mem_repo.add_movie(dolittle_movie)
target_year = 2020
movies_as_dict, prev_date, next_date = movie_services.get_movies_by_year(
target_year, mem_repo)
assert len(movies_as_dict) == 0
def test_can_get_movie():
mem_repo = MemoryRepository()
up_movie = Movie("Up", 2009, 1)
klaus_movie = Movie("Klaus", 2019, 2)
dolittle_movie = Movie("Dolittle", 2019, 3)
mem_repo.add_movie(up_movie)
mem_repo.add_movie(klaus_movie)
mem_repo.add_movie(dolittle_movie)
# ["Dolittle", "Klaus", "Up"]
movie_id = 2
movie_as_dict = movie_services.get_movie(movie_id, mem_repo)
assert movie_as_dict["ID"] == movie_id
assert movie_as_dict["release_year"] == klaus_movie.release_year
assert movie_as_dict["title"] == "Klaus"
def test_add_review(self):
user1 = User('Martin', 'pw12345')
movie = Movie("Moana", 2016, 1)
user1.add_review(Review(movie, "Ahhh", 2))
print()
print(user1.reviews)
print(movie.external_rating)
def test_repository_can_retrieve_movie():
mem_repo = MemoryRepository()
movie = Movie("Up", 2009, 1)
mem_repo.add_movie(movie)
got_movie = mem_repo.get_movie(1)
assert got_movie == movie
def test_repository_does_not_retrieve_a_non_existent_movie():
mem_repo = MemoryRepository()
movie = Movie("Up", 2009, 1)
mem_repo.add_movie(movie)
got_movie = mem_repo.get_movie(7)
assert got_movie is None
def test_repr(self):
movie = Movie("Moana", 2016, 1)
review_text = "This movie was very enjoyable."
rating = 8
review = Review(movie, review_text, rating)
print()
print(review)
def test_watch_movie(self):
user1 = User('Martin', 'pw12345')
user1.watch_movie(Movie("Moana", 2016, 1))
print()
print(user1.watched_movies)
movies = [Movie("Moana", 2016, 1), Movie("Guardians of the Galaxy", 2014, 2)]
movies[0].runtime_minutes = 107
movies[1].runtime_minutes = 121
user = User("Martin", "pw12345")
print(user.watched_movies)
print(user.time_spent_watching_movies_minutes)
for movie in movies:
user.watch_movie(movie)
print(user.watched_movies)
print(user.time_spent_watching_movies_minutes)
def test_getters_setters(self):
movie = Movie("Moana", 2016, 1)
review_text = "This movie was very enjoyable."
rating = 8
review = Review(movie, review_text, rating)
assert review.rating == 8
assert review.movie == movie
assert review.review_text == "This movie was very enjoyable."
def test_runtime():
movie1 = Movie("Moana", 2000)
assert movie1.runtime_minutes == 0
movie1.runtime_minutes = "3"
assert movie1.runtime_minutes == 0
movie1.runtime_minutes = None
assert movie1.runtime_minutes == 0
try:
movie1.runtime_minutes = 0
except ValueError:
pass
else:
raise AssertionError
assert movie1.runtime_minutes == 0
try:
movie1.runtime_minutes = -4
except ValueError:
pass
else:
raise AssertionError
assert movie1.runtime_minutes == 0
movie1.runtime_minutes = 12
assert movie1.runtime_minutes == 12
def test_get_movies_by_year_with_one_year():
mem_repo = MemoryRepository()
up_movie = Movie("Up", 2009, 1)
klaus_movie = Movie("Klaus", 2019, 2)
dolittle_movie = Movie("Dolittle", 2019, 3)
mem_repo.add_movie(up_movie)
mem_repo.add_movie(klaus_movie)
mem_repo.add_movie(dolittle_movie)
target_year = 2009
movies_as_dict, prev_date, next_date = movie_services.get_movies_by_year(
target_year, mem_repo)
assert len(movies_as_dict) == 1
assert movies_as_dict[0]["ID"] == 1
assert prev_date is None
assert next_date == 2019
def test_repository_can_get_movies_by_rating_low_to_high():
mem_repo = MemoryRepository()
up_movie = Movie("Up", 2009, 1)
klaus_movie = Movie("Klaus", 2019, 2)
dolittle_movie = Movie("Dolittle", 2019, 3)
up_movie.external_rating = 89
klaus_movie.external_rating = 90
dolittle_movie.external_rating = 76
mem_repo.add_movie(up_movie)
mem_repo.add_movie(klaus_movie)
mem_repo.add_movie(dolittle_movie)
movies_by_low_to_high = mem_repo.get_movies_by_rating_low()
assert len(movies_by_low_to_high) == 3
assert movies_by_low_to_high == [dolittle_movie, up_movie, klaus_movie]
