def test_watchlist_valid_select():
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist.add_movie(Movie("Guardians of the Galaxy", 2012))
#print(watchlist.select_movie_to_watch(1))
assert repr(watchlist.select_movie_to_watch(1)) == "<Movie Ice Age, 2002>"
def test_user(): # add movie
user1 = User(' Martin ', 'pw12345')
#print(user1.user_name)
assert user1.user_name == "martin"
user1 = User('Martin', 'pw12345')
user2 = User('Ian', 'pw67890')
user3 = User('Daniel', 'pw87465')
#print(user1)
#print(user2)
#print(user3)
assert repr(user1) == "<User martin>"
assert repr(user2) == "<User ian>"
assert repr(user3) == "<User daniel>"
movie1 = Movie("Up", 2009)
movie1.runtime_minutes = 150
user1.watch_movie(movie1)
user1.watch_movie(movie1)
#print("Watched Movies:", user1.watched_movies)
#print("Watching Time:", user1.time_spent_watching_movies_minutes)
assert repr(user1.watched_movies) == "[<Movie Up, 2009>]"
assert user1.time_spent_watching_movies_minutes == 150
review1 = Review(movie1, "test", 5)
user1.add_review(review1)
user1.add_review(review1)
#print(user1.reviews)
assert repr(user1.reviews) == "[<Review <Movie Up, 2009>, test, 5>]"
def test_watchlist_size():
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist.add_movie(Movie("Guardians of the Galaxy", 2012))
#print(watchlist.size())
assert watchlist.size() == 3
def test_movie_file_csv_reader():
filename = "tests/data/database/Data1000Movies.csv"
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
assert len(movie_file_reader.dataset_of_movies) == 1000
assert len(movie_file_reader.dataset_of_actors) == 1985
assert len(movie_file_reader.dataset_of_directors) == 644
assert len(movie_file_reader.dataset_of_genres) == 20
all_movies_sorted = sorted(movie_file_reader.dataset_of_movies)
#print(f'first 3 unique movies of sorted dataset: {all_movies_sorted[0:3]}')
assert all_movies_sorted[0:3] == [Movie("(500) Days of Summer", 2009), Movie("10 Cloverfield Lane", 2016), Movie("10 Years", 2011)]
all_actors_sorted = sorted(movie_file_reader.dataset_of_actors)
#print(f'first 3 unique actors of sorted dataset: {all_actors_sorted[0:3]}')
assert all_actors_sorted[0:3] == [Actor("50 Cent"), Actor("A.C. Peterson"), Actor("AJ Michalka")]
all_directors_sorted = sorted(movie_file_reader.dataset_of_directors)
#print(f'first 3 unique directors of sorted dataset: {all_directors_sorted[0:3]}')
assert all_directors_sorted[0:3] == [Director("Aamir Khan"), Director("Abdellatif Kechiche"), Director("Adam Leon")]
all_genres_sorted = sorted(movie_file_reader.dataset_of_genres)
#print(f'first 3 unique genres of sorted dataset: {all_genres_sorted[0:3]}')
assert all_genres_sorted[0:3] == [Genre("Action"), Genre("Adventure"), Genre("Animation")]
def test_watchlist_first_movie_valid():
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist.add_movie(Movie("Guardians of the Galaxy", 2012))
#print(watchlist.first_movie_in_watchlist())
assert repr(watchlist.first_movie_in_watchlist()) == "<Movie Moana, 2016>"
def test_watching_sim_add_review():
a = MovieWatchingSimulation()
movie1 = Movie("Moana", 2016)
movie2 = Movie("Ice Age", 2002)
movie3 = Movie("Guardians of the Galaxy", 2012)
user1 = User('Jack', 'pw12345')
user2 = User('James', 'pw67890')
user3 = User('Janice', 'pw87465')
review1 = Review(movie1, "Was good", 6)
review2 = Review(movie1, "Average", 5)
review3 = Review(movie1, "Very Great", 8)
review4 = Review(movie2, "Great", 7)
review5 = Review(movie2, "Excellent", 9)
review6 = Review(movie3, "Boring", 3)
a.add_movie_review(review1.movie, user1, review1.rating)
a.add_movie_review(review2.movie, user2, review2.rating)
a.add_movie_review(review3.movie, user3, review3.rating)
a.add_movie_review(review4.movie, user1, review4.rating)
a.add_movie_review(review5.movie, user2, review5.rating)
a.add_movie_review(review6.movie, user1, review6.rating)
a.add_movie_review(review4.movie, user1, review4.rating)
assert a.movie_dict == {
movie1: [[user1, 6], [user2, 5], [user3, 8]],
movie2: [[user1, 7], [user2, 9], [user1, 7]],
movie3: [[user1, 3]]
}
def test_watching_sim_review_average():
a = MovieWatchingSimulation()
movie1 = Movie("Moana", 2016)
movie2 = Movie("Ice Age", 2002)
movie3 = Movie("Guardians of the Galaxy", 2012)
user1 = User('Jack', 'pw12345')
user2 = User('James', 'pw67890')
user3 = User('Janice', 'pw87465')
review1 = Review(movie1, "Was good", 6)
review2 = Review(movie1, "Average", 5)
review3 = Review(movie1, "Very Great", 8)
review4 = Review(movie2, "Great", 7)
review5 = Review(movie2, "Excellent", 9)
review6 = Review(movie3, "Boring", 3)
a.add_movie_review(review1.movie, user1, review1.rating)
a.add_movie_review(review2.movie, user2, review2.rating)
a.add_movie_review(review3.movie, user3, review3.rating)
a.add_movie_review(review4.movie, user1, review4.rating)
a.add_movie_review(review5.movie, user2, review5.rating)
a.add_movie_review(review6.movie, user1, review6.rating)
#print(a.get_movie_rating_average(movie1))
#print(a.get_movie_rating_average(movie2))
#print(a.get_movie_rating_average(movie3))
assert a.get_movie_rating_average(movie1) == "Average Rating: 6.33"
assert a.get_movie_rating_average(movie2) == "Average Rating: 8.0"
assert a.get_movie_rating_average(movie3) == "Average Rating: 3.0"
def test_movie_set_director():
movie = Movie("Moana", 2016)
movie.description = " This is a movie "
assert movie.description == "This is a movie"
movie.director = Director("Ron Clements")
assert movie.director.director_full_name is "Ron Clements"
assert repr(movie.director) == "<Director Ron Clements>"
def test_watchlist_invalid_select():
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist.add_movie(Movie("Guardians of the Galaxy", 2012))
#print(watchlist.select_movie_to_watch(3))
assert watchlist.select_movie_to_watch(3) == None
def read_csv_file(self):
with open(self.__file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
index = 0
for row in movie_file_reader:
rank = row['Rank']
title = row['Title']
release_year = int(row['Year'])
self.__dataset_of_movies.append(Movie(title, release_year))
self.__rank_of_movies[rank] = Movie(title, release_year)
# add movie with same year into movies_with_given_year
if release_year not in self.__movies_with_given_year.keys():
self.__movies_with_given_year[release_year] = [Movie(title, release_year)]
else:
movie = Movie(title, release_year)
self.__movies_with_given_year[release_year].append(movie)
actors = row['Actors']
actors_list = actors.split(',')
for actor in actors_list:
if actor not in self.__dataset_of_actors:
self.__dataset_of_actors.add(Actor(actor))
# add movie with same actor into movies_with_given_actor
for actor in actors_list:
if actor not in self.__movies_with_given_actor:
self.__movies_with_given_actor[actor] = [Movie(title, release_year)]
else:
self.__movies_with_given_actor[actor].append(Movie(title, release_year))
director = row['Director']
if director not in self.__dataset_of_directors:
self.__dataset_of_directors.add(Director(director))
#add movie with same director into movies_with_given_director
if director not in self.__movies_with_given_director:
self.__movies_with_given_director[director] = [Movie(title, release_year)]
else:
self.__movies_with_given_director[director].append(Movie(title, release_year))
genres = row['Genre']
genres_list = genres.split(',')
for genre in genres_list:
if genre not in self.__dataset_of_genres:
self.__dataset_of_genres.add(Genre(genre))
#add movie with same genre into movies_with_given_genre
for genre in genres_list:
if genre not in self.__movies_with_given_genre:
self.__movies_with_given_genre[genre] = [Movie(title, release_year)]
else:
self.__movies_with_given_genre[genre].append(Movie(title, release_year))
if index > 1000:
break
index += 1
def make_article(): ###### !!!!!
movie = Movie(
6,
"new movie",
2020
)
movie.description = "like it"
return movie
def test_watchlist_add_several():
watchlist = WatchList()
#print(f"Size of watchlist: {watchlist.size()}")
assert watchlist.size() == 0
watchlist.add_movie(Movie("Moana", 2016))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist.add_movie(Movie("Guardians of the Galaxy", 2012))
#print(watchlist.first_movie_in_watchlist())
assert repr(watchlist.first_movie_in_watchlist()) == "<Movie Moana, 2016>"
def test_watchlist_remove_movie_not_in_watchlist():
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist.remove_movie(Movie("Guardians of the Galaxy", 2012))
watchlist_iter = iter(watchlist)
#print(next(watchlist_iter))
#print(next(watchlist_iter))
assert repr(next(watchlist_iter)) == "<Movie Moana, 2016>"
assert repr(next(watchlist_iter)) == "<Movie Ice Age, 2002>"
def test_user_construction(user):
assert user.user_name == 'martin'
assert user.password == 'pw12345'
assert repr(user) == '<User martin>'
for review in user.reviews:
assert False
movie = Movie("Moana", 2016)
movie.runtime_minutes = 107
user.watch_movie(movie)
assert user.time_spent_watching_movies_minutes == 107
def test_watchlist_iter_invalid():
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist.add_movie(Movie("Guardians of the Galaxy", 2012))
watchlist_iter = iter(watchlist)
while True:
try:
result = next(watchlist_iter)
except StopIteration:
assert True
break
def read_csv_file(self):
with open(self.__file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
index = 0
for row in movie_file_reader:
title = row['Title']
release_year = int(row['Year'])
#print(f"Movie {index} with title: {title}, release year {release_year}")
movie = Movie(title, release_year)
if movie not in self.dataset_of_movies:
self.dataset_of_movies.append(movie)
actors = row['Actors'].split(",")
#print("~~~~~")
for actor in range(len(actors)):
actors[actor] = Actor(actors[actor].strip())
#added
movie.actors.append(actors[actor].actor_full_name)
#print(actors[actor].actor_full_name)
#end added
if actors[actor] not in self.dataset_of_actors:
self.dataset_of_actors.add(actors[actor])
#if row['Title'] == "Fury":
#print("de", actors[actor])
#print(actors)
director = Director(row['Director'])
if director not in self.dataset_of_directors:
self.dataset_of_directors.add(director)
#self.subset_of_movie_directors[str(title)] = []
genres = row['Genre'].split(",")
for genre in range(len(genres)):
genres[genre] = Genre(genres[genre].strip())
# added
movie.genres.append(genres[genre].genre_name)
# end added
if genres[genre] not in self.dataset_of_genres:
self.dataset_of_genres.add(genres[genre])
#self.dataset_of_genres.append( Genre(genres[genre]) )
#print(genres)
# added
movie.director = row['Director']
movie.description = row['Description']
movie.runtime_minutes = int(row['Runtime (Minutes)'])
# end added
index += 1
def test_watchlist_construction(watchlist):
watchlist.add_movie(Movie("Moana", 2016))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist.add_movie(Movie("Guardians of the Galaxy", 2012))
watchlist.add_movie(Movie("Moana", 2016))
assert watchlist.size() == 3
watchlist.remove_movie(Movie("Moana", 2016))
assert watchlist.size() == 2
assert repr(
watchlist.first_movie_in_watchlist()) == '<Movie Ice Age, 2002>'
assert repr(watchlist.select_movie_to_watch(
1)) == '<Movie Guardians of the Galaxy, 2012>'
assert watchlist.select_movie_to_watch(3) == None
def test_watchlist_add_same_movie():
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist_iter = iter(watchlist)
#print(next(watchlist_iter))
#print(next(watchlist_iter))
assert repr(next(watchlist_iter)) == "<Movie Moana, 2016>"
assert repr(next(watchlist_iter)) == "<Movie Ice Age, 2002>"
try:
next(watchlist_iter)
except StopIteration:
assert True
def test_repository_can_delete_movie_in_user_watchlist(in_memory_repo):
user = User("Dave", '123456789')
movie = Movie("Moana", 2016)
in_memory_repo.add_user(user)
in_memory_repo.add_user_watch_list(user, movie)
in_memory_repo.delete_movie_from_watch_list(user, movie)
assert movie not in in_memory_repo.get_user_watch_list(user)
def test_temp_review():
movie = Movie("Moana", 2016)
review_text = "This movie was very enjoyable."
rating = 8
review1 = TempReview(movie, review_text, rating)
review2 = TempReview(movie, review_text, rating)
review3 = TempReview(movie, review_text, 0)
review4 = TempReview(movie, review_text, 11)
#print(review1.movie)
#print("Review: {}".format(review1.review_text))
#print("Rating: {}".format(review1.rating))
#print("Timestamp1: {}".format(review1.timestamp))
#print("Timestamp2: {}".format(review2.timestamp))
#print(review1)
#print(review2)
#print(review3)
#print(review4)
#print(review1 == review2)
assert repr(
review1
) == "<TempReview <Movie Moana, 2016>, This movie was very enjoyable., 8>"
assert repr(
review2
) == "<TempReview <Movie Moana, 2016>, This movie was very enjoyable., 8>"
assert repr(
review3
) == "<TempReview <Movie Moana, 2016>, This movie was very enjoyable., 0>"
assert repr(
review4
) == "<TempReview <Movie Moana, 2016>, This movie was very enjoyable., 11>"
assert review1 == review2
def read_csv_file(self):
with open(self.__file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
#index = 0
genre_dict = {}
director_dict = {}
actor_dict = {}
for row in movie_file_reader:
movie_id = int(row['id'])
movie_title = row['Title']
release_year = int(row['Year'])
movie = Movie(movie_id, movie_title, release_year)
self.__movies.add(movie)
genre = row["Genre"]
genres_list = genre.split(",")
for genre_name in genres_list:
if genre_name not in genre_dict:
genre_dict[genre_name] = [movie]
else:
genre_dict[genre_name] = genre_dict[genre_name] + [movie]
des = row['Description']
movie.set_des(des)
the_director = row["Director"]
if the_director not in director_dict:
director_dict[the_director] = [movie]
else:
director_dict[the_director] = director_dict[the_director] + [movie]
actor_list = row["Actors"]
for actor in actor_list.split(","):
actor = actor.strip()
if actor not in actor_dict:
actor_dict[actor] = [movie]
else:
actor_dict[actor] = actor_dict[actor] + [movie]
for genre_name in genre_dict:
genre = Genre(genre_name)
for movie in genre_dict[genre_name]:
genre.add_movie(movie)
movie.add_genre(genre)
self.__genres.add(genre)
for director_name in director_dict:
director = Director(director_name)
for movie in director_dict[director_name]:
director.add_dir_movie(movie)
movie.director = director
self.__directors.add(director)
for actor_name in actor_dict:
actor = Actor(actor_name)
for movie in actor_dict[actor_name]:
actor.add_joined_movie(movie)
movie.add_actor(actor)
self.__actors.add(actor)
def load_movies(data_path: str, repo: MemoryRepository):
index = 0
for row in read_csv_file(os.path.join(data_path, 'Data1000Movies.csv')):
rank = int(row[0])
title = row[1]
release_year = int(row[6])
description = row[3]
runtime = int(row[7])
movie = Movie(title, release_year)
movie.rank = rank
movie.description = description
movie.runtime_minutes = runtime
actors = row[5]
actors_list = actors.split(',')
for actor in actors_list:
movie.add_actor(actor)
director = row[4]
movie.director = director
genres = row[2]
genres_list = genres.split(',')
for genre in genres_list:
movie.add_genre(genre)
repo.add_movie(movie)
repo.add_movie_rank(rank, movie)
repo.add_release_year(release_year)
# add movie with same year into movies_with_given_year
repo.add_movie_with_release_year(movie, release_year)
# add movie with same actor into movies_with_given_actor
repo.add_movie_with_actor(movie, actors)
# add movie with same director into movies_with_given_director
repo.add_movie_with_director(movie, director)
# add movie with same genre into movies_with_given_genre
repo.add_movie_with_genre(movie, genres_list)
#repo.add_movie_details(movie,[description, genres_list, runtime, director, actors_list])
if index > 1000:
break
index += 1
def test_movie_set_actors():
movie = Movie("Moana", 2016)
movie.description = " This is a movie "
assert movie.description == "This is a movie"
movie.director = Director("Ron Clements")
assert movie.director.director_full_name is "Ron Clements"
assert repr(movie.director) == "<Director Ron Clements>"
actors = [Actor("Auli'i Cravalho"), Actor("Dwayne Johnson"), Actor("Rachel House"), Actor("Temuera Morrison")]
for actor in actors:
movie.add_actor(actor)
assert repr(movie.actors) == "[<Actor Auli\'i Cravalho>, <Actor Dwayne Johnson>, <Actor Rachel House>, <Actor Temuera Morrison>]"
def test_movie_init_full():
movie = Movie("Moana", 2016)
assert repr(movie) == "<Movie Moana, 2016>"
director = Director("Ron Clements")
movie.director = director
assert repr(movie.director) == "<Director Ron Clements>"
actors = [Actor("Auli'i Cravalho"), Actor("Dwayne Johnson"), Actor("Rachel House"), Actor("Temuera Morrison")]
for actor in actors:
movie.add_actor(actor)
assert repr(
movie.actors) == "[<Actor Auli\'i Cravalho>, <Actor Dwayne Johnson>, <Actor Rachel House>, <Actor Temuera Morrison>]"
movie.runtime_minutes = 107
assert ("Movie runtime: {} minutes".format(movie.runtime_minutes)) == "Movie runtime: 107 minutes"
def add_movie(self, title, year, description, director, actor, genre,
runtime, rating, revenue, meta, vote):
movie = Movie(title, year)
movie.description = description
movie.director = Director(director)
actors = actor.split(",")
for a in actors:
movie.add_actor(Actor(a.strip()))
genres = genre.split(",")
for g in genres:
movie.add_genre(Genre(g))
movie.runtime = runtime
movie.rating = rating
if revenue != "N/A":
movie.revenue = float(revenue)
if meta != "N/A":
movie.meta = int(meta)
movie.vote = vote
self.dataset_of_movies.append(movie)
def test_repository_can_retrieve_last_movie(in_memory_repo):
assert in_memory_repo.get_last_movie() == Movie("Nine Lives", 2016)
def test_repository_can_retrieve_first_movie(in_memory_repo):
assert in_memory_repo.get_first_movie() == Movie("Guardians of the Galaxy",
2014)
def test_repository_can_retrieve_movie(in_memory_repo):
assert in_memory_repo.get_movie(3) == Movie('Split', 2016)
def test_repository_does_not_retrieve_a_movie_in_empty_watchlist(
in_memory_repo):
user = User("Dave", '123456789')
movie = Movie("Moana", 2016)
in_memory_repo.add_user(user)
assert in_memory_repo.get_user_watch_list(user).size() == 0
def test_repository_can_retrieve_user_watchlist(in_memory_repo):
user = User("Dave", '123456789')
movie = Movie("Moana", 2016)
in_memory_repo.add_user(user)
in_memory_repo.add_user_watch_list(user, movie)
assert movie in in_memory_repo.get_user_watch_list(user)
