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)