def test_init(self):
director1 = Director("Taika Waititi")
assert repr(director1) == "<Director Taika Waititi>"
director2 = Director("")
assert director2.director_full_name is None
director3 = Director(42)
assert director3.director_full_name is None
def test_equal(self):
director1 = Director("Taika Waititi")
director2 = Director("Some Director")
assert director1.__eq__(director2) == False
assert director2.__eq__(director1) == False
director3 = Director(1)
assert director2.__eq__(director3) == False
director4 = Director("Taika Waititi")
assert director1.__eq__(director4) == True
def test_repository_can_retrieve_movie_by_index(in_memory_repo):
movie = in_memory_repo.get_movie_by_index(1)
# Check that the movie has expected attributes
assert movie.title == "Guardians of the Galaxy"
assert movie.release_year == 2014
assert movie.description == "A group of intergalactic criminals are forced to work together to stop a fanatical warrior from taking control of the universe."
assert movie.director == Director("James Gunn")
assert movie.runtime_minutes == 121
actors = iter(movie.actors)
assert next(actors) == Actor("Chris Pratt")
assert next(actors) == Actor("Vin Diesel")
assert next(actors) == Actor("Bradley Cooper")
assert next(actors) == Actor("Zoe Saldana")
# Check that the movie has the expected genre(s)
assert movie.is_classified_as(Genre("Action"))
assert movie.is_classified_as(Genre("Adventure"))
assert movie.is_classified_as(Genre("Sci-Fi"))
# Check that the movie has the correct reviews
assert movie.number_of_reviews == 3
review_1 = [
review for review in movie.reviews
if review.review_text == "This movie is great!"
][0]
review_2 = [
review for review in movie.reviews
if review.review_text == "This movie is awesome"
][0]
assert review_1.review_author.username == "fmercury"
assert review_2.review_author.username == "thorke"
def make_movie():
movie = Movie('Avengers: Endgame', 2019)
movie.set_director(Director("Anthony Russo"))
movie.set_description(
"After Thanos, an intergalactic warlord, disintegrates half of the universe, the Avengers must reunite and assemble again to reinvigorate their trounced allies and restore balance."
)
movie.set_runtime_minutes(181)
return movie
def load_movies_actors_directors_genre_description(data_path: str, repo: MemoryRepository):
genres = dict()
actors = dict()
directors = dict()
for data_row in read_csv_file(os.path.join(data_path, "movies.csv")):
movie_index = int(data_row[0])
title = data_row[1]
try:
movie_revenue = float(data_row[10])
except ValueError:
movie_revenue = 0
list_of_genre_names = data_row[2].split(",")
list_of_genres = [Genre(genre_name) for genre_name in list_of_genre_names] # can have duplicate
movie_description = data_row[3]
director = Director(data_row[4]) # can have duplicate
list_of_actor_names = data_row[5].split(",")
list_of_actor_names = [name.strip() for name in list_of_actor_names]
list_of_actors = [Actor(actor_full_name) for actor_full_name in list_of_actor_names] # can have duplicate
release_year = int(data_row[6])
runtime = int(data_row[7])
# Create Movie object
movie = Movie(
title=title,
release_year=release_year,
id=movie_index
)
movie.set_revenue(revenue=movie_revenue)
# Add movie to repo
repo.add_movie(movie)
# Add any new genres to repo
for genre in list_of_genres:
if genre not in genres.keys():
genres[genre] = list()
genres[genre].append(movie_index)
for actor in list_of_actors:
if actor not in actors.keys():
actors[actor] = list()
actors[actor].append(movie_index)
# Add any new directors to dict
if director not in directors:
directors[director] = list()
directors[director].append(movie_index)
# Connect the current movie with its attributes
add_movie_attributes(movie=movie,
list_of_genres=list_of_genres,
description=movie_description,
list_of_actors=list_of_actors,
director=director,
runtime=runtime)
# Associate Genres with Movies and add them to the repository
for genre in genres.keys():
for current_movie_index in genres[genre]:
movie = repo.get_movie_by_index(current_movie_index)
movie.add_genre(genre)
genre.add_Movie(movie)
repo.add_genre(genre)
# Associate Actors with Movies and add them to the repository
for actor in actors.keys():
for current_movie_index in actors[actor]:
movie = repo.get_movie_by_index(current_movie_index)
movie.add_actor(actor)
actor.add_played_movies(movie)
repo.add_actor(actor)
# Associate Directors with Movies and add them to the repositor
for director in directors.keys():
for current_movie_index in directors[director]:
movie = repo.get_movie_by_index(current_movie_index)
movie.set_director(director)
director.add_directed_movies(movie)
repo.add_director(director)
def test_repository_can_check_existence_of_director(in_memory_repo):
assert in_memory_repo.check_director_existence_in_repo(
Director("Fake Director")) is False
assert in_memory_repo.check_director_existence_in_repo(
Director("Sean Foley")) is True
def test_repository_can_add_an_director(in_memory_repo):
director = Director("Chad Stahelski")
in_memory_repo.add_director(director)
assert in_memory_repo.get_director("Chad Stahelski") == director
def read_csv_file(self):
duplicated_genre = []
duplicated_actors = []
with open(self.__file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
for row in movie_file_reader:
# Append to the movie data set
title = row['Title']
year = int(row['Year'])
movie = Movie(title, year, 4)
if (movie not in self.__dataset_of_movies):
self.__dataset_of_movies.append(movie)
# Store potential duplicated actors
duplicated_actors.append(
row['Actors'].split(',')) # This is a list of list
# Store unique directors
director = Director(row['Director'])
if director not in self.__dataset_of_directors:
self.__dataset_of_directors.append(director)
# Store potential duplicated genres
duplicated_genre.append(row['Genre'].split(','))
#Store description
description = row['Description']
self.__dataset_of_description.append(description)
# Store runtime
runtime = row['Runtime (Minutes)']
try:
runtime = int(runtime)
self.__dataset_of_runtime.append(runtime)
except ValueError:
continue
# Store ratings
rating = row['Rating']
try:
rating = float(rating)
self.__dataset_of_ratings.append(rating)
except ValueError:
continue
# Store votes
vote = row['Votes']
try:
vote = int(vote)
self.__dataset_of_votes.append(vote)
except ValueError:
continue
# Store revenue
revenue = row["Revenue (Millions)"]
try:
revenue = float(revenue)
self.__dataset_of_revenue.append(revenue)
except ValueError:
continue
# Store Metascore
meta_score = row["Metascore"]
try:
meta_score = float(meta_score)
self.__dataset_of_metadata.append(meta_score)
except ValueError:
continue
for actor_list in duplicated_actors:
for current_actor in actor_list:
current_actor = Actor(current_actor)
if current_actor not in self.__dataset_of_actors:
self.__dataset_of_actors.append(current_actor)
for genre_list in duplicated_genre:
for current_genre in genre_list:
current_genre = Genre(current_genre)
if current_genre not in self.__dataset_of_genres:
self.__dataset_of_genres.append(current_genre)
def test_director(self):
movie1 = Movie("Moana", 2016, 1)
movie1.set_director(Director("Ron Clements"))
assert repr(movie1.director) == "<Director Ron Clements>"
def test_hash(self):
director1 = Director("Taika Waititi")
assert director1.__hash__() == hash("Taika Waititi")
def test_lt(self):
director1 = Director("Taika Waititi")
director2 = Director("Some Director")
assert director2.__lt__(director1) == True
def test_repository_can_retrieve_a_director(session_factory):
repo = SqlAlchemyRepository(session_factory)
director = repo.get_director('Sean Foley')
assert director == Director('Sean Foley')
assert Movie('Mindhorn', 2016) in director.directed_movies
def test_repository_can_add_a_director(session_factory):
repo = SqlAlchemyRepository(session_factory)
director = Director("Chad Stahelski")
repo.add_director(director)
assert repo.get_director("Chad Stahelski") == director and repo.get_director("Chad Stahelski") is director
