def test_movie_less_than_operator():
movie_1 = Movie(
"Guardians of the Galaxy", 2014
)
movie_2 = Movie(
"Prometheus", 2012
)
assert movie_1 < movie_2
def test_repository_can_retrieve_reviews(in_memory_repo):
x = memory_repository.MemoryRepository()
user = User('dave', '123456789')
x.add_user(user)
movie = Movie(
"Prometheus",
2010,
)
another_movie = Movie("It Follows",2014)
review = make_review("Not good", user, movie, 4, datetime.today())
in_memory_repo.add_review(review)
another_review = make_review("awesome", user, another_movie, 10, datetime.today())
in_memory_repo.add_review(another_review)
assert len(in_memory_repo.get_reviews()) == 2
def test_repository_does_not_add_a_review_without_a_user():
movie = Movie(
"Prometheus",
2010,
)
with pytest.raises(ReviewException):
review = make_review("Not good", None, movie, 4, datetime.today())
def test_repository_can_add_movie():
movie = Movie(
"Prometheus",
2010,
)
x.add_movie(movie)
assert x.get_movie(movie) is movie
def test_repository_can_add_movie():
x = memory_repository.MemoryRepository()
movie = Movie(
"Prometheus",
2010,
)
x.add_movie(movie)
assert x.get_movie(movie) is movie
def test_repository_can_get_review_of_movie():
a_movie = Movie("Guardians of the Galaxy", 2014)
review_text = "not good"
rating = 2
user = User("daneln", "Dane1337")
review = Review(a_movie, "not good", 2)
a_review = make_review(review_text, user, a_movie, rating)
x.add_review(a_review)
a_reviewer = x.get_review_for_movie(a_movie)
assert a_reviewer[0] == review
def add_review(movie: Movie, comment_text: str, rating: int, username: str,
repo: AbstractRepository):
# Check that the movie exists.
movie = repo.get_movie(movie)
if movie is None:
raise NonExistentMovieException
user = repo.get_user(username)
if user is None:
raise UnknownUserException
# Create comment.
comment = Review(movie, comment_text, rating)
comment.user = user
user.add_review(comment)
movie.add_review(comment)
# Update the repository.
repo.add_review(comment)
def test_repository_can_add_a_review():
x = memory_repository.MemoryRepository()
user = User('dave', '123456789')
x.add_user(user)
movie = Movie(
"Prometheus",
2010,
)
review = make_review("Not good", user, movie, 4, datetime.today())
x.add_review(review)
assert review in x.get_reviews()
def test_repository_can_retrieve_movie():
a_movie = Movie("Guardians of the Galaxy", 2014)
a_genre = Genre("Action,Adventure,Sci-Fi")
movie = x.get_movie(a_movie)
# Check that the Movie has the expected title.
assert movie.title == "Guardians of the Galaxy"
assert movie.release == 2014
assert str(
movie.genres) == '[<Genre Action>, <Genre Adventure>, <Genre Sci-Fi>]'
def test_repository_does_not_add_a_review_without_an_movie_properly_attached(in_memory_repo):
user = User('dave', '123456789')
in_memory_repo.add_user(user)
movie = Movie(
"Prometheus",
2010,
)
review = Review(None,"yeah good", 10)
with pytest.raises(RepositoryException):
# Exception expected because the Article doesn't refer to the Comment.
in_memory_repo.add_review(review)
def test_cannot_add_comment_for_non_existent_movie(in_memory_repo):
movie = Movie("not real", 2020)
review_text = 'Super good movie!'
username = '******'
new_username = '******'
new_password = '******'
auth_services.add_user(new_username, new_password, in_memory_repo)
# Call the service layer to attempt to add the comment.
with pytest.raises(home_services.NonExistentMovieException):
home_services.add_review(movie, review_text, 10, new_username,
in_memory_repo)
def test_repository_can_retrieve_movie():
x = memory_repository.MemoryRepository()
data_path = os.path.join('website', 'datafilereaders', 'datafiles')
memory_repository.load_movies(data_path, x)
a_movie = Movie("Guardians of the Galaxy", 2014)
a_genre = Genre("Action,Adventure,Sci-Fi")
movie = x.get_movie(a_movie)
# Check that the Movie has the expected title.
assert movie.title == "Guardians of the Galaxy"
assert movie.release == 2014
assert str(movie.genres) == '[<Genre Action>, <Genre Adventure>, <Genre Sci-Fi>]'
def movie_read_csv_file(self):
with open(os.path.join(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)
# url = imdb_from_title(title, release_year)
# movie.image = str(url)
if movie not in self.__dataset_of_movies:
self.__dataset_of_movies.add(movie)
actors = row['Actors'].split(",")
for actor in actors:
a_actor = Actor(actor)
for s_actor in self.__dataset_of_actors:
if a_actor == s_actor:
movie.add_actor(s_actor)
metascore = row['Metascore']
movie.metascore = str(metascore)
num_of_ratings = row['Votes']
movie.num_of_ratings = float(num_of_ratings)
director = row["Director"]
director1 = Director(director)
for directors in self.__dataset_of_directors:
if director1 == directors:
movie.director = directors
description = row["Description"]
movie.description = description
rating = row["Rating"]
runtime = row["Runtime (Minutes)"]
movie.runtime_minutes = int(runtime)
movie.rating = float(rating)
genres = row["Genre"].split(",")
for genre in genres:
a_genre = Genre(genre)
for sgenre in self.__dataset_of_genres:
if sgenre == a_genre:
movie.add_genre(sgenre)
index += 1
def movie():
return Movie("Guardians of the Galaxy", 2014
)
def review():
movie = Movie("Guardians of the Galaxy", 2014
)
return Review(movie, "Terrible movie", 1)
def test_repository_does_not_retrieve_a_non_existent_movie():
a_movie = Movie("fake movie", 2014)
movie = x.get_movie(a_movie)
assert movie is None
def test_repository_movies_have_rating():
a_movie = Movie("Guardians of the Galaxy", 2014)
movie = x.get_movie(a_movie)
assert movie.rating == 8.1
