def test_completed_attributes():
filename = 'datafiles/Data1000Movies.csv'
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
movie_name = "Guardians of the Galaxy"
movie = movie_file_reader.movie_object(movie_name)
# normal 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.actors == [
Actor("Chris Pratt"),
Actor("Vin Diesel"),
Actor("Bradley Cooper"),
Actor("Zoe Saldana")
]
assert movie.genres == [
Genre("Action"), Genre("Adventure"),
Genre("Sci-Fi")
]
assert movie.runtime_minutes == 121
# extra attributes
assert movie.rank == 1
assert movie.rating == 8.1
assert movie.revenue == 333.13
assert movie.votes == 757074
assert movie.metascore == 76
def load_data(data_path: str, repo: MemoryRepository):
reader = MovieFileCSVReader(os.path.join(data_path, 'data1000Movies.csv'))
reader.read_csv_file()
for actor in reader.dataset_of_actors:
repo.add_actor(actor)
for movie in reader.dataset_of_movies:
repo.add_movie(movie)
for actor in movie.actors:
for colleague in movie.actors:
if not actor.check_if_this_actor_worked_with(
colleague) and actor != colleague:
actor.add_actor_colleague(colleague)
for director in reader.dataset_of_directors:
repo.add_director(director)
for genre in reader.dataset_of_genres:
repo.add_genre(genre)
user = User(user_name="Myles Kennedy",
password=generate_password_hash("123"))
review = Review(repo.get_movie("Inception", 2010),
"Absolutely incredible movie!", 10)
repo.add_review(review)
user.add_review(review)
user.watchlist.add_movie(repo.get_movie("The Da Vinci Code", 2006))
user.watchlist.add_movie(repo.get_movie("Moana", 2016))
repo.add_user(user)
def test_movies():
movie_file_reader = MovieFileCSVReader('test.csv')
movie_file_reader.read_csv_file()
movie1 = Movie("Guardians of the Galaxy", 2014)
movie1.description = "A group of intergalactic criminals are forced to work together to stop a fanatical warrior from taking control of the universe."
movie1.runtime_minutes = 121
movie1.votes = 757074
movie1.rating = 8.1
movie1.add_genre(Genre("Action"))
movie1.add_genre(Genre("Adventure"))
movie1.add_genre(Genre("Sci-Fi"))
movie1.add_actor(Actor("Chris Pratt"))
movie1.add_actor(Actor("Vin Diesel"))
movie1.add_actor(Actor("Bradley Cooper"))
movie1.add_actor(Actor("Zoe Saldana"))
movie1.director = Director("James Gunn")
assert movie_file_reader.dataset_of_movies[0] == movie1
assert movie_file_reader.dataset_of_movies[0].runtime_minutes == movie1.runtime_minutes
assert movie_file_reader.dataset_of_movies[0].description == movie1.description
assert movie_file_reader.dataset_of_movies[0].votes == movie1.votes
assert movie_file_reader.dataset_of_movies[0].rating == movie1.rating
assert movie_file_reader.dataset_of_movies[0].actors == movie1.actors
assert movie_file_reader.dataset_of_movies[0].genres == movie1.genres
assert movie_file_reader.dataset_of_movies[0].director == movie1.director
assert movie_file_reader.dataset_of_actors[0] == Actor("Chris Pratt")
assert movie_file_reader.dataset_of_actors[1] == Actor("Vin Diesel")
assert movie_file_reader.dataset_of_actors[2] == Actor("Bradley Cooper")
assert movie_file_reader.dataset_of_actors[3] == Actor("Zoe Saldana")
assert repr(movie_file_reader.dataset_of_actors[0].actor_colleague_list) == "[<Actor Vin Diesel>, <Actor Bradley Cooper>, <Actor Zoe Saldana>, <Actor Jennifer Lawrence>, <Actor Michael Sheen>, <Actor Laurence Fishburne>, <Actor Denzel Washington>, <Actor Ethan Hawke>, <Actor Vincent D'Onofrio>, <Actor Bryce Dallas Howard>, <Actor Ty Simpkins>, <Actor Judy Greer>, <Actor Will Ferrell>, <Actor Elizabeth Banks>, <Actor Will Arnett>, <Actor Jessica Chastain>, <Actor Joel Edgerton>, <Actor Mark Strong>, <Actor Channing Tatum>, <Actor Rosario Dawson>, <Actor Jenna Dewan Tatum>]"
assert movie_file_reader.dataset_of_directors[0] == Director("James Gunn")
assert movie_file_reader.dataset_of_genres[0] == Genre("Action")
assert movie_file_reader.dataset_of_genres[1] == Genre("Adventure")
assert movie_file_reader.dataset_of_genres[2] == Genre("Sci-Fi")
def test_movie_file_csv_reader(self):
filename = '../datafiles/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 directors of sorted dataset: {all_movies_sorted[0:3]}'
)
all_actors_sorted = sorted(movie_file_reader.dataset_of_actors)
print(
f'first 3 unique directors of sorted dataset: {all_actors_sorted[0:3]}'
)
all_directors_sorted = sorted(movie_file_reader.dataset_of_directors)
print(
f'first 3 unique directors of sorted dataset: {all_directors_sorted[0:3]}'
)
all_genres_sorted = sorted(movie_file_reader.dataset_of_genres)
print(
f'first 3 unique directors of sorted dataset: {all_genres_sorted[0:3]}'
)
def test_five_random_movie_from_all_movies():
seed = 116
watchlist = WatchList()
filename = 'datafiles/Data1000Movies.csv'
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
movie_list = movie_file_reader.dataset_of_movies
random_movie_1 = watchlist.add_random(movie_list, seed)
assert random_movie_1 == movie_list[841]
random_movie_2 = watchlist.add_random(movie_list, seed)
assert random_movie_2 == movie_list[763]
random_movie_3 = watchlist.add_random(movie_list, seed)
assert random_movie_3 == movie_list[614]
random_movie_4 = watchlist.add_random(movie_list, seed)
assert random_movie_4 == movie_list[559]
random_movie_5 = watchlist.add_random(movie_list, seed)
assert random_movie_5 == movie_list[739]
assert watchlist.size() == 5
def test_dataset_of_movies_is_valid(reader: MovieFileCSVReader):
reader.read_csv_file()
movies = reader.dataset_of_movies
actors = reader.dataset_of_actors
directors = reader.dataset_of_directors
genres = reader.dataset_of_genres
actor_ids = set()
director_ids = set()
genre_ids = set()
for movie in movies:
assert movie.title is not None
# Check all of this movie's actors are in our dataset of actors
assert all(actor in actors for actor in movie.actors)
for actor in movie.actors:
actor_ids.add(id(actor))
# Check this movie's director is in our dataset of directors
assert movie.director in directors
director_ids.add(id(movie.director))
# Check all of this movie's genres are in our dataset of genres
assert all(genre in genres for genre in movie.genres)
for genre in movie.genres:
genre_ids.add(id(genre))
# Here we are checking that two movies with the same actor/director/genre both reference the same instance.
# Note that it is not enough to use the 'in' operator here, as that will look for an actor that is equal, but not
# necessarily the same instance
assert len(actor_ids) == len(actors)
assert len(director_ids) == len(directors)
assert len(genre_ids) == len(genres)
def main():
filename = 'datafiles/Data1000Movies.csv'
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
print(
f'number of unique movies: {len(movie_file_reader.dataset_of_movies)}')
print(
f'number of unique actors: {len(movie_file_reader.dataset_of_actors)}')
print(
f'number of unique directors: {len(movie_file_reader.dataset_of_directors)}'
)
print(
f'number of unique genres: {len(movie_file_reader.dataset_of_genres)}')
filename = 'datafiles/Data1000TVShows.csv'
tv_show_file_reader = TVShowFileCSVReader(filename)
tv_show_file_reader.read_csv_file()
print(
f'number of unique tv shows: {len(tv_show_file_reader.dataset_of_tv_shows)}'
)
print(
f'number of unique actors: {len(tv_show_file_reader.dataset_of_actors)}'
)
print(
f'number of unique directors: {len(tv_show_file_reader.dataset_of_directors)}'
)
print(
f'number of unique genres: {len(tv_show_file_reader.dataset_of_genres)}'
)
def test_rating_votes():
filename = "testfiles/Data1000Movies.csv"
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
assert len(movie_file_reader.dataset_of_movies) == 1000
assert movie_file_reader.dataset_of_movies[12].rating_votes == 323118
def test_revenue_in_millions():
filename = "testfiles/Data1000Movies.csv"
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
assert len(movie_file_reader.dataset_of_movies) == 1000
assert movie_file_reader.dataset_of_movies[20].revenue_in_millions == 7.22
def test_metascore():
filename = "testfiles/Data1000Movies.csv"
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
assert len(movie_file_reader.dataset_of_movies) == 1000
assert movie_file_reader.dataset_of_movies[28].metascore == 60
def test_incomplete_attributes():
filename = 'datafiles/Data1000Movies.csv'
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
movie_name = "Hounds of Love"
movie = movie_file_reader.movie_object(movie_name)
# normal attributes
assert movie.title == "Hounds of Love"
assert movie.release_year == 2016
assert movie.description == "A cold-blooded predatory couple while cruising the streets in search of their " \
"next victim, will stumble upon a 17-year-old high school girl, who will be sedated, " \
"abducted and chained in the strangers' guest room."
assert movie.director == Director("Ben Young")
assert movie.actors == [
Actor("Emma Booth"),
Actor("Ashleigh Cummings"),
Actor("Stephen Curry"),
Actor("Susie Porter")
]
assert movie.genres == [Genre("Crime"), Genre("Drama"), Genre("Horror")]
assert movie.runtime_minutes == 108
# extra attributes
assert movie.rank == 23
assert movie.rating == 6.7
assert movie.revenue is None
assert movie.votes == 1115
assert movie.metascore == 72
def test_external_rating():
filename = "testfiles/Data1000Movies.csv"
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
assert len(movie_file_reader.dataset_of_movies) == 1000
assert movie_file_reader.dataset_of_movies[9].external_rating == 7
def the_sim():
filename = 'datafiles/Data1000Movies.csv'
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
sim = MovieWatchingSimulation(movie_file_reader)
sim.add_user(User("Paul", "wellington"))
sim.add_user(User('jessica', 'piano'))
return sim
def test_read():
test = MovieFileCSVReader('datafiles\\Data1000Movies.csv')
test.read_csv_file()
assert len(test.dataset_of_movies) == 1000
assert len(test.dataset_of_actors) == 1985
assert len(test.dataset_of_directors) == 644
assert len(test.dataset_of_genres) == 20
def test_attribute(self):
filename = 'datafiles/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_directors) == 644
assert len(movie_file_reader.dataset_of_actors) == 1985
assert len(movie_file_reader.dataset_of_genres) == 20
def test_code_runner():
filename = pathlib.Path(__file__).parent.parent.joinpath('datafiles/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
def __init__(self, file_path: str):
movie_file_reader = MovieFileCSVReader(file_path)
movie_file_reader.read_csv_file()
self._actor = movie_file_reader.dataset_of_actors
self._director = movie_file_reader.dataset_of_directors
self._genre = movie_file_reader.dataset_of_genres
self._movie = movie_file_reader.dataset_of_movies
self._user = list()
self._review = list()
def test_recs(stats):
filename = 'test.csv'
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
assert stats.make_recommendations(movie_file_reader.dataset_of_movies,
-1) == [
Movie("Guardians of the Galaxy",
2014),
Movie("Split", 2016),
Movie("Sing", 2016),
Movie("Suicide Squad", 2016)
]
def populate_database(session_factory, database_engine, filename):
metadata.drop_all(database_engine)
metadata.create_all(
database_engine) # Conditionally create database tables.
# populate data
file_reader = MovieFileCSVReader(filename)
file_reader.read_csv_file()
session = session_factory()
session.add_all(file_reader.dataset_of_movies)
print(f"{len(file_reader.dataset_of_movies)} movies")
session.commit()
def test_read_csv_file(self):
movie_file_csv_reader_object = MovieFileCSVReader(r"C:\Users\Nathan Longhurst\OneDrive - The University of Auckland\b Comp235\Assignment\GitHub Clone (Current)\CS235FlixSkeleton\datafiles\Data1000Movies.csv")
movie_file_csv_reader_object.read_csv_file()
dataset_of_movies = movie_file_csv_reader_object.dataset_of_movies
dataset_of_actors = movie_file_csv_reader_object.dataset_of_actors
dataset_of_directors = movie_file_csv_reader_object.dataset_of_directors
dataset_of_genres = movie_file_csv_reader_object.dataset_of_genres
assert len(dataset_of_movies) == 1000
assert len(set(dataset_of_actors)) == len(dataset_of_actors) # check unique items only
assert len(set(dataset_of_directors)) == len(dataset_of_directors) # ^ ditto
assert len(set(dataset_of_genres)) == len(dataset_of_genres) # ^ ditto
def client_with_data():
filename = 'datafiles/Data100Movies.csv'
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
repository = MemoryRepository(movie_file_reader.dataset_of_movies,
movie_file_reader.dataset_of_actors,
movie_file_reader.dataset_of_directors,
movie_file_reader.dataset_of_genres)
return create_app(repository, {
'TESTING': True,
'WTF_CSRF_ENABLED': False,
'SECRET_KEY': 'test'
}).test_client(), repository
def test_filter_by_director_illeagal_inputs():
filename = 'datafiles/Data1000Movies.csv'
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
director = Director("Nier Automata")
movie_file_reader.filter_by_director(director)
assert movie_file_reader.movies_filtered_by_director == []
director_1 = "James Gunn"
movie_file_reader.filter_by_director(director_1)
assert movie_file_reader.movies_filtered_by_director == []
director_2 = 12345
movie_file_reader.filter_by_director(director_2)
assert movie_file_reader.movies_filtered_by_director == []
def main():
filename = 'datafiles/Data1000Movies.csv'
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
print(
f'number of unique movies: {len(movie_file_reader.dataset_of_movies)}')
print(
f'number of unique actors: {len(movie_file_reader.dataset_of_actors)}')
print(
f'number of unique directors: {len(movie_file_reader.dataset_of_directors)}'
)
print(
f'number of unique genres: {len(movie_file_reader.dataset_of_genres)}')
print(
f'first row of actors: {movie_file_reader.dataset_of_movies[2].actors}'
)
def test_filter_by_genres_illeage_inputs():
filename = 'datafiles/Data1000Movies.csv'
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
genre = Genre("Good")
movie_file_reader.filter_by_genre(genre)
assert movie_file_reader.movies_filtered_by_genre == []
genre = [Genre("Happy")]
movie_file_reader.filter_by_genre(genre)
assert movie_file_reader.movies_filtered_by_genre == []
genre = 123456
movie_file_reader.filter_by_genre(genre)
assert movie_file_reader.movies_filtered_by_genre == []
def test_csv_reader(self):
filename = 'C:\Bullshit\CS235FlixSkeleton\datafiles\Data1000Movies.csv'
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
print(movie_file_reader.dataset_of_movies)
print(
f'number of unique movies: {len(movie_file_reader.dataset_of_movies)}'
)
print(
f'number of unique actors: {len(movie_file_reader.dataset_of_actors)}'
)
print(
f'number of unique directors: {len(movie_file_reader.dataset_of_directors)}'
)
print(
f'number of unique genres: {len(movie_file_reader.dataset_of_genres)}'
)
def test_dataset_of_actors_is_valid(reader: MovieFileCSVReader):
reader.read_csv_file()
actors = reader.dataset_of_actors
actor_ids = set()
for actor in actors:
assert actor.actor_full_name is not None
# Check all of this actor's colleagues are in our dataset of actors
assert all(colleague in actors for colleague in actor.colleagues)
# Check colleagues are valid
actor_ids.add(id(actor))
for colleague in actor.colleagues:
actor_ids.add(id(colleague))
# Check that two actors with the same colleague both reference the same instance
assert len(actor_ids) == len(actors)
def client_with_db_data():
clear_mappers()
filename = 'datafiles/Data100Movies.csv'
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
database_engine = create_engine('sqlite:///')
map_model()
session_factory = sessionmaker(autocommit=False,
autoflush=True,
bind=database_engine)
populate_database(session_factory, database_engine, filename)
repository = DatabaseRepository(session_factory)
return create_app(repository, {
'TESTING': True,
'WTF_CSRF_ENABLED': False,
'SECRET_KEY': 'test'
}).test_client(), repository
def test_basic_csv():
reader = MovieFileCSVReader(pathlib.Path(__file__).parent.joinpath("test.csv"))
reader.read_csv_file()
m1 = reader.dataset_of_movies[0]
assert m1.title == "Darth"
assert m1.release_year == 2014
assert m1.genres == [Genre("Plagueis"), Genre("The W")]
assert m1.description == "ise"
assert m1.director == Director("Darth Vader")
assert m1.actors == [Actor("Luke"), Actor("R2-D2"), Actor("Leia")]
assert m1.rating == 8.1
assert m1.votes == 757074
assert m1.revenue == 333.13
assert m1.metascore == 76
assert m1.runtime_minutes == 121
m2 = reader.dataset_of_movies[1]
assert m2.metascore is None
assert m2.revenue is None
def main():
filename = 'datafiles/Data1000Movies.csv'
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
the_sim = MovieWatchingSimulation(movie_file_reader)
##the_sim.go()
the_sim.add_user(User("Paul", "wellington"))
if the_sim.user_login("paul", "wellington"):
print("User Paul logged in")
print('look at genre, Adventure.')
viewed_list = the_sim.look_at_genre("paul", 'Adventure')
print("pick some movies")
user_picks = create_movie_list(len(viewed_list), 15)
print(user_picks)
print(viewed_list[user_picks[1]])
for i in user_picks:
the_sim.add_to_watchlist("paul", viewed_list[i])
print("paul views his watchlist")
new_watchlist = the_sim.get_watchlist("paul")
assert new_watchlist[1]== viewed_list[user_picks[1]]
if the_sim.user_logout("Paul"):
print("Paul logged out")
def test_reader():
filename = 'datafiles/Data1000Movies.csv'
reader = MovieFileCSVReader(filename)
reader.read_csv_file()
assert len(reader.dataset_of_movies) == 1000
assert len(reader.dataset_of_actors) == 1985
assert len(reader.dataset_of_directors) == 644
assert len(reader.dataset_of_genres) == 20
movie = None
for item in reader.dataset_of_movies:
if item.title == "Moana" and item.year == 2016:
movie = item
break
assert movie.title == "Moana"
assert movie.year == 2016
assert movie.description == description
assert movie.director == Director("Ron Clements")
assert movie.runtime_minutes == 107
assert movie.external_rating == 7.7
assert movie.rating_votes == 118151
assert movie.revenue == 248.75
assert movie.metascore == 81
assert movie.genres == [
Genre("Animation"),
Genre("Adventure"),
Genre("Comedy")
]
assert movie.actors == [
Actor("Auli'i Cravalho"),
Actor("Dwayne Johnson"),
Actor("Rachel House"),
Actor("Temuera Morrison")
]
