def test_equal():
genre1 = Genre("Horror")
genre2 = Genre("")
genre3 = Genre("Horror")
assert (genre1 == genre2) == False
assert (genre1 == genre3) == True
def test_repository_can_retrieve_movie(in_memory_repo):
movie = in_memory_repo.get_movie(1)
# Check that the Movie has the expected title.
assert movie.title == 'Guardians of the Galaxy'
assert movie.is_genreged_by(Genre('Action'))
assert movie.is_genreged_by(Genre('Adventure'))
def test_movie_genres():
# correct input
movie1 = Movie("Moana", 2016)
movie1.genres = [Genre("Animation"), Genre("Comedy")]
assert movie1.genres == [Genre("Animation"), Genre("Comedy")]
# incorrect input
movie2 = Movie("Frozen", 2014)
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"])
movie = Movie(title, release_year)
movie.description = row["Description"]
director = row["Director"]
movie.add_director(Director(director))
if Director(director) not in self.__dataset_of_directors:
self.__dataset_of_directors.append(Director(director))
actors = row["Actors"].split(",")
for actor in actors:
movie.add_actor(Actor(actor))
if Actor(actor) not in self.__dataset_of_actors:
self.__dataset_of_actors.append(Actor(actor))
genres = row["Genre"].split(",")
for genre in genres:
movie.add_genre(Genre(genre))
if Genre(genre) not in self.__dataset_of_genres:
self.__dataset_of_genres.append(Genre(genre))
movie.runtime_minutes = int(row["Runtime (Minutes)"])
try:
movie.external_rating = float(row["Rating"])
except ValueError:
pass
try:
movie.rating_votes = int(row["Votes"])
except ValueError:
pass
try:
movie.revenue_in_millions = float(
row["Revenue (Millions)"])
except ValueError:
pass
try:
movie.metascore = int(row["Metascore"])
except ValueError:
pass
self.__dataset_of_movies.append(movie)
# title = row['Title']
# release_year = int(row['Year'])
# print(f"Movie {index} with title: {title}, release year {release_year}")
index += 1
def browse_by_genre():
genreMovies = movieByGenre()
random_movies = repo.repo_instance.get_random_movies(4)
random_genres = repo.repo_instance.get_random_genres(3)
if genreMovies.validate_on_submit():
repo.repo_instance.genre_index = 0
post_genre = Genre(genreMovies.genre_name.data)
total_movies = repo.repo_instance.get_movies_in_genre(post_genre)
movies = [total_movies[x:x+45] for x in range(0, len(total_movies), 45)]
length = len(movies)-1
return render_template(
'movies/genres_movies.html',
movies = movies[repo.repo_instance.genre_index],
genre = post_genre,
length = length,
first_url = url_for('movies_bp.genre_view', index = 0, length = length, genre = post_genre.name),
prev_url = url_for('movies_bp.genre_view', index = repo.repo_instance.genre_index - 1, length = length, genre = post_genre.name),
next_url = url_for('movies_bp.genre_view', index = repo.repo_instance.genre_index + 1, length = length, genre = post_genre.name),
last_url = url_for('movies_bp.genre_view', index = length, length = length, genre = post_genre.name),
movieSearch = movieByTitle(),
genreSearch = genreMovies,
)
return render_template(
'movies/get_genre.html',
form = genreMovies,
random_movies = random_movies,
random_genres = random_genres,
movieSearch = movieByTitle(),
genreSearch = genreMovies,
)
def test_repository_can_add_and_get_genres(in_memory_repo):
genre = Genre("Horror")
in_memory_repo.add_genre(genre)
assert (genre in in_memory_repo.get_genres()) is True
assert len(in_memory_repo.get_genres()) == 19
def read_csv_file(self, file_name):
with open(file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
for row in movie_file_reader:
id = int(row['Rank'])
title = row['Title']
release_year = int(row['Year'])
movie = Movie(title, release_year, id)
self.add_movie(movie)
actors = row["Actors"]
actors = actors.split(",")
for actor in actors:
actor = Actor(actor)
self.add_actor(actor)
actor = self.get_actor(actor.actor_full_name)
movie.add_actor(actor)
actor.add_movie(movie)
director = Director(row["Director"])
self.add_director(director)
director = self.get_director(director.director_full_name)
movie.director = director
director.add_movie(movie)
genres = row["Genre"]
genres = genres.split(",")
for genre in genres:
genre = Genre(genre)
movie.add_genre(genre)
self.add_genre(genre)
movie.description = row["Description"]
movie.runtime_minutes = int(row["Runtime (Minutes)"])
def test_remove_genre():
movie = Movie("Moana", 2016)
genres = [
Genre("Animation"),
Genre("Action"),
Genre("Fantasy"),
Genre("Children's film"),
Genre("Adventure")
]
for genre in genres:
movie.add_genre(genre)
assert repr(
movie.genres
) == "[<Genre Animation>, <Genre Action>, <Genre Fantasy>, <Genre Children's film>, <Genre Adventure>]"
movie.remove_genre(Genre("Adventure"))
assert repr(
movie.genres
) == "[<Genre Animation>, <Genre Action>, <Genre Fantasy>, <Genre Children's film>]"
movie.remove_genre(Genre("Adventure"))
assert repr(
movie.genres
) == "[<Genre Animation>, <Genre Action>, <Genre Fantasy>, <Genre Children's film>]"
def test_repository_can_retrieve_movie(in_memory_repo):
movie = in_memory_repo.get_movie(1)
# Check that the Movie has the expected title.
assert movie.title == 'Guardians of the Galaxy'
# Check that the Movie is commented as expected.
comment_one = [
comment for comment in movie.comments
if comment.comment == 'This movie is okay.'
][0]
comment_two = [
comment for comment in movie.comments
if comment.comment == 'Yeah Freddie, it is good.'
][0]
assert comment_one.user.username == 'fmercury'
assert comment_two.user.username == "thorke"
# Check that the Movie is tagged as expected.
assert movie.is_of_genre(Genre('Action'))
assert movie.is_of_genre(Genre('Adventure'))
assert movie.is_of_genre(Genre('Sci-Fi'))
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'])
movie = Movie(title, release_year)
movie.description = row['Description']
movie.director = Director(row['Director'])
if Director(
row['Director']) not in self.__dataset_of_directors:
self.__dataset_of_directors.append(
Director(row['Director']))
for actor in row['Actors'].split(','):
movie.add_actor(Actor(actor))
if Actor(actor) not in self.dataset_of_actors:
self.dataset_of_actors.append(Actor(actor))
for genre in row['Genre'].split(','):
movie.add_genre(Genre(genre))
if Genre(genre) not in self.dataset_of_genres:
self.dataset_of_genres.append(Genre(genre))
movie.runtime_minutes = int(row['Runtime (Minutes)'])
try:
movie.revenue = float(row['Revenue (Millions)'])
except:
pass
self.__dataset_of_movies.append(movie)
def test_movie_add_genre():
# correct input
movie1 = Movie("Moana", 2016)
movie1.add_genre(Genre("Animation"))
assert movie1.genres == [Genre("Animation")]
# incorrect input
movie1.add_actor(Director("Ron Clements"))
assert movie1.genres == [Genre("Animation")]
# adding a genre twice
movie1.add_genre(Genre("Animation"))
assert movie1.genres == [Genre("Animation")]
# adding a second genre
movie1.add_genre(Genre("Comedy"))
assert movie1.genres == [Genre("Animation"), Genre("Comedy")]
def test_movie_remove_genre():
movie1 = Movie("Moana", 2016)
movie1.add_genre(Genre("Animation"))
# correct input
movie1.remove_genre(Genre("Animation"))
assert movie1.genres == []
# incorrect input
movie1.add_genre(Genre("Animation"))
movie1.remove_genre(Director("Animation"))
assert movie1.genres == [Genre("Animation")]
# removing a genre not in list
movie1.remove_genre(Genre("Comedy"))
assert movie1.genres == [Genre("Animation")]
def load_movies_and_genres(data_path: str, repo: MemoryRepository):
genres = dict()
for data_row in read_csv_file(os.path.join(data_path,
'Data1000Movies.csv')):
movie_key = int(data_row[0])
movie_genres = data_row[2].split(",")
# Add any new genres; associate the current movie with genres.
for genre in movie_genres:
if genre not in genres.keys():
genres[genre] = list()
genres[genre].append(movie_key)
# Create Movie object.
movie = Movie(date=date.fromisoformat(data_row[12]),
title=data_row[1],
first_para=data_row[3],
hyperlink="nan",
image_hyperlink=data_row[14],
id=movie_key,
rating=data_row[8],
back_hyperlink=data_row[13],
runtime=int(data_row[7]),
director=data_row[4],
actors=data_row[5].split(","))
# Add the Movie to the repository.
repo.add_movie(movie)
# Create Genre objects, associate them with Movies and add them to the repository.
for genre_name in genres.keys():
genre = Genre(genre_name)
for movie_id in genres[genre_name]:
movie = repo.get_movie(movie_id)
make_genre_association(movie, genre)
repo.add_genre(genre)
def genre_view():
index = int(request.args.get('index'))
genre = Genre(request.args.get('genre'))
length = int(request.args.get('length'))
total_movies = repo.repo_instance.get_movies_in_genre(genre)
movies = [total_movies[x:x+45] for x in range(0, len(total_movies), 45)]
if repo.repo_instance.genre_index == 0 and index <= -1 or repo.repo_instance.genre_index == length and index >= length:
pass
else:
repo.repo_instance.genre_index = index
return render_template(
'movies/genres_movies.html',
movies = movies[repo.repo_instance.genre_index],
genre = genre,
length = length,
first_url = url_for('movies_bp.genre_view', index = 0, length = length, genre = genre.name),
prev_url = url_for('movies_bp.genre_view', index = repo.repo_instance.genre_index - 1, length = length, genre = genre.name),
next_url = url_for('movies_bp.genre_view', index = repo.repo_instance.genre_index + 1, length = length, genre = genre.name),
last_url = url_for('movies_bp.genre_view', index = length, length = length, genre = genre.name),
movieSearch = movieByTitle(),
)
def test_repository_can_add_genre(in_memory_repo):
genre = Genre("Indie")
in_memory_repo.add_genre(genre)
assert genre in in_memory_repo.get_genres()
def test_repository_can_get_movies_from_genre(in_memory_repo):
movies = in_memory_repo.get_movies_from_genre(Genre("Action"))
assert len(movies) == 2
assert movies[0] == 1
assert movies[1] == 5
def test_repository_can_retrieve_genres(in_memory_repo):
genres = in_memory_repo.get_genres()
assert len(genres) == 10
assert Genre("Action") in genres
def test_repository_returns_an_empty_list_where_there_are_no_movies_in_a_genre(
session_factory):
repo = SqlAlchemyRepository(session_factory)
movies = repo.get_movies_from_genre(Genre('Giraffe'))
assert len(movies) == 0
def test_repository_can_get_movies_from_genre(session_factory):
repo = SqlAlchemyRepository(session_factory)
movies = repo.get_movies_from_genre(Genre('Comedy'))
assert len(movies) == 279
assert movies[0] == 4
assert movies[1] == 7
def test_repository_can_retrieve_genres(session_factory):
repo = SqlAlchemyRepository(session_factory)
genres = repo.get_genres()
assert len(genres) == 20
assert Genre("Action") in genres
def test_repository_can_add_genre(session_factory):
repo = SqlAlchemyRepository(session_factory)
genre = Genre('Indie')
repo.add_genre(genre)
assert genre in repo.get_genres()
def test_repository_add_genre(in_memory_repo):
genre = Genre("MEGAFUN")
in_memory_repo.add_genre(genre)
assert genre in in_memory_repo.get_genre()
def test_repository_can_get_movies_from_genre(in_memory_repo):
movies = in_memory_repo.get_movies_from_genre(Genre("Action"))
assert len(movies) == 2
assert movies[0].title == "Guardians of the Galaxy"
assert movies[1].title == "Suicide Squad"
def get_movies_from_genre(genre_name, repo: AbstractRepository):
genre = Genre(genre_name)
movies = repo.get_movies_from_genre(genre)
return [movie.id for movie in movies]
def genre():
return Genre("Horror")
def genre2():
return Genre("Thriller")
def test_repository_can_add_a_tag(in_memory_repo):
genre = Genre('Motoring')
in_memory_repo.add_genre(genre)
assert genre in in_memory_repo.get_genres()
def genre():
return Genre("Action")
def make_genre():
genre = Genre("Adventure")
return genre
def load_movies_and_genres(data_path: str, repo: MemoryRepository):
genres = dict()
directors = dict()
actors = dict()
for data_row in read_csv_file(os.path.join(data_path,
'Data1000Movies.csv')):
movie_key = int(data_row[0])
movie_genres = data_row[2].lower().split(",")
movie_directors = data_row[4].lower().split(",")
movie_actors = data_row[5].lower().split(",")
# Add any new genres; associate the current movie with genres.
for genre in movie_genres:
if genre not in genres.keys():
genres[genre] = list()
genres[genre].append(movie_key)
for director in movie_directors:
if director not in directors.keys():
directors[director] = list()
directors[director].append(movie_key)
for actor in movie_actors:
if actor not in actors.keys():
actors[actor] = list()
actors[actor].append(movie_key)
# Create Movie object.
movie = Movie(title=data_row[1].lower(),
year=int(data_row[6]),
movie_id=int(data_row[0]))
movie.description = data_row[3]
movie.runtime_minutes = int(data_row[7])
movie.rating = float(data_row[8])
movie.votes = float(data_row[9])
if data_row[10] != 'N/A':
movie.revenue = f"{data_row[10]}Millions"
if data_row[11] != 'N/A':
movie.metascore = data_row[11]
# Add the Movie to the repository.
repo.add_movie(movie)
# Create Genre objects, associate them with Movies and add them to the repository.
for genre_name in genres.keys():
genre = Genre(genre_name)
for movie_id in genres[genre_name]:
movie = repo.get_movie(movie_id)
make_genre_association(movie, genre)
repo.add_genre(genre)
for director_name in directors.keys():
director = Director(director_name)
for movie_id in directors[director_name]:
movie = repo.get_movie(movie_id)
make_director_association(movie, director)
repo.add_director(director)
for actor_name in actors.keys():
actor = Actor(actor_name)
for movie_id in actors[actor_name]:
movie = repo.get_movie(movie_id)
make_actor_association(movie, actor)
repo.add_actor(actor)
