def test_add_review():
repo = MemoryRepository(movies_mock, [], [], [])
u1, u2 = User("bob", "pass123"), User("bobb", "pass12")
assert repo.add_user("bob", "pass123")
assert repo.add_user("bobb", "pass12")
r1 = Review(
1, "Darth Plagueis was dumb, why couldn't he stop his apprentice??!!",
3)
r2 = Review(2, "The Sith did nothing wrong, Jedis just spread fake news",
7)
r3 = Review(2, "Star Wars is silly", 1)
r4 = Review(
2,
"Oops the previous review was written by my cat, Star Wars is wonderful",
9)
# user_id, review
repo.add_review(0, r1)
repo.add_review(0, r2)
repo.add_review(1, r3)
repo.add_review(1, r4)
# review for the movie m1 of id "1"
assert repo.get_reviews(1) == [(u1, [r1])]
assert repo.get_reviews(2) == [(u1, [r2]), (u2, [r3, r4])]
def test_equality_when_not_equal(review):
# Check not equal when reviews are partially equal
movie = Movie("Test", 2000)
review_text = review.review_text
rating = review.rating
other = Review(movie, review_text, rating)
assert review != other
movie = review.movie
review_text = "Test"
rating = review.rating
other = Review(movie, review_text, rating)
assert review != other
movie = review.movie
review_text = review.review_text
rating = 5
other = Review(movie, review_text, rating)
assert review != other
# Check not equal when reviews are completely different
movie = Movie("Test", 2000)
review_text = "Test"
rating = 5
other = Review(movie, review_text, rating)
assert review != other
def test_constructor(movie):
review_text = " Text with spaces \n"
review_text_expected = "Text with spaces"
rating = 1
review = Review(movie, review_text, rating)
assert review.movie == movie
assert review.review_text == review_text_expected
assert review.rating == rating
assert review.timestamp.timestamp() == pytest.approx(
datetime.utcnow().timestamp(), abs=_TIMESTAMP_TOLERANCE)
review_text = " Text with spaces \n"
review_text_expected = "Text with spaces"
rating = 10
review = Review(movie, review_text, rating)
assert review.movie == movie
assert review.review_text == review_text_expected
assert review.rating == rating
assert review.timestamp.timestamp() == pytest.approx(
datetime.utcnow().timestamp(), abs=_TIMESTAMP_TOLERANCE)
review_text = " Text with spaces \n"
review_text_expected = "Text with spaces"
rating = 10
timestamp = datetime(2020, 1, 1)
review = Review(movie, review_text, rating, timestamp)
assert review.movie == movie
assert review.review_text == review_text_expected
assert review.rating == rating
assert review.timestamp == timestamp
def load_reviews(data_path: str, repo: MemoryRepository, users):
for data_row in read_csv_file(os.path.join(data_path, 'reviews.csv')):
movie = repo.get_movie(int(data_row[2]))
review = Review(movie, data_row[3], int(data_row[4]))
review.user = users[data_row[1]]
review.user.add_review(review)
movie.add_review(review)
repo.add_review(review)
def test_rating_range():
movie = Movie("Shrek", 2010)
review_text = "Shrek good"
review = Review(movie, review_text, 11)
assert review.rating is None
review = Review(movie, review_text, 0)
assert review.rating is None
review = Review(movie, review_text, 3)
assert review.rating == 3
def test_compare_reviews():
movie = Movie("Moana", 2016)
review = Review(movie, "was pretty good", 9)
review2 = Review(movie, "was pretty good", 9)
assert review.timestamp == review2.timestamp
assert review.movie == review2.movie
assert review.review_text == review2.review_text
assert review.rating == review2.rating
assert (review == review2) is True
def test_repository_can_add_review_and_get_reviews(in_memory_repo):
user = in_memory_repo.get_user('fmercury')
movie = in_memory_repo.get_movie(320)
review = Review(in_memory_repo.get_movie(320), 'It is very exciting', 6)
review.user = user
review.user.add_review(review)
movie.add_review(review)
in_memory_repo.add_review(review)
reviews = in_memory_repo.get_reviews()
assert (review in reviews) == True
def test_review_ratings():
movie = Movie("Moana", 2016)
review = Review(movie, "was pretty good", -2)
assert review.rating == None
review = Review(movie, "was pretty good", 11)
assert review.rating == None
review = Review(movie, "was pretty good", 2)
assert review.rating == 2
review = Review(movie, "was pretty good", 0)
assert review.rating == None
def test_write_review(movie, user1, user2):
review_text = "This movie was very enjoyable."
rating = 8
review = Review(movie, review_text, rating)
review_text3 = "This movie was very enjoyable."
rating3 = 8
review3 = Review(movie, review_text3, rating3)
watch_together = MovieWatchingSimulation(movie)
watch_together.add_user(user1)
watch_together.add_user(user2)
watch_together.write_review(user1, review_text, rating)
watch_together.write_review(user2, review_text3, rating3)
assert (watch_together.review_dict[user1] == review) == True
assert (watch_together.review_dict[user2] == review3) == True
def test_review():
movie = Movie("Moana", 2016)
review_text = "This movie was very enjoyable."
rating = 8
review = Review(movie, review_text, rating)
current_time = datetime.now()
assert review.movie == movie
assert review.review_text == review_text
assert review.rating == rating
assert review.timestamp - current_time < timedelta(milliseconds=20)
review2 = Review(movie, review_text, rating)
assert review != review2
def test_user():
movie1 = Movie("Moana", 2016)
movie1.runtime_minutes = 107
movie2 = Movie("The Lion King", 1994)
movie2.runtime_minutes = 99
review_text = "This movie was very enjoyable."
rating = 8
review = Review(movie1, review_text, rating)
user = User("John", "Str0ngP4ssw0rd")
user.watch_movie(movie1)
user.watch_movie(movie2)
user.watch_movie(movie1)
user.add_review(review)
user2 = User("John", "c0pyc4t")
user3 = User("Andrew", "yep")
assert user == user2
assert user3 < user2
assert user3.user_name == "andrew"
assert user.time_spent_watching_movies_minutes == 313
assert len(user.watched_movies) == 2
assert len(user.reviews) == 1
def add_review(repository: Repository, movie_index, review_text, rating):
user_id = session['user']
#movie = repository.get_movie(movie_index)
review = Review(movie_index, review_text, rating) # TODO!!!
repository.add_review(user_id, review)
current_app.logger.info(f"Review (user_id {user_id})")
def test_construction_invalid_timestamp_type(movie):
review_text = " Text with spaces \n"
rating = 10
timestamp = 123
with pytest.raises(TypeError):
_ = Review(movie, review_text, rating, timestamp)
def test_init(self):
review = Review(Movie("Star Wars", 1999), "Great Movie", 10)
assert review.movie.title == "Star Wars"
assert review.review_text == "Great Movie"
assert review.rating == 10
assert repr(review) == "<Review Star Wars 1999, Great Movie, 10 (4-9-2020)>"
def test_constructor_invalid_movie_type():
movie = 42
review_text = " Text with spaces \n"
rating = 1
with pytest.raises(TypeError):
_ = Review(movie, review_text, rating)
def test_repr_no_rating(movie):
review_text = "Test"
rating = 1.0
review = Review(movie, review_text, rating)
expected = f'<Review <Movie TestMovie, 2020>, Test, None, {review.timestamp.isoformat()}>'
assert repr(review) == expected
def test_create_review():
movie = Movie("Moana", 2016)
review = Review(movie, "was pretty good", 9)
the_time = datetime.today()
assert str(review.movie) == f'<Movie Moana, 2016>'
assert review.rating == 9
assert review.review_text == 'was pretty good'
assert str(review) == '<Review <Movie Moana, 2016>, was pretty good, 9, {}>'.format(the_time)
def test_normal_review():
movie = Movie("Moana", 2016)
review_text = "This movie was very enjoyable."
rating = 10
review = Review(movie, review_text, rating)
assert repr(review.movie) == "<Movie Moana, 2016>"
assert review.review_text == "This movie was very enjoyable."
assert review.rating == 10
def add_to_group_review(self, rating: int, review_text: str):
self.__individual_ratings.append(rating)
new_review_text = f"{self.__group_review.review_text}. {review_text}"
new_rating = sum(self.__individual_ratings) / len(
self.__individual_ratings)
self.__group_review = Review(self.__movie, new_rating, new_review_text)
for user in self.__members:
user.update_last_review(self.__group_review)
def test_add_review(self):
user1 = User('user1', 'pw12345')
movie1 = Movie("Star War", 19879)
movie1.runtime_minutes = 120
user1.watch_movie(movie1)
review = Review(movie1, "This is a great movie!", 9)
user1.add_review(review)
assert user1.reviews == [review]
def test_add_review(self):
user = User('Martin', 'pw12345')
movie1 = Movie('Moana', 2016)
review1 = Review(movie1, 'I liked it', 10)
movie2 = Movie('Frozen', 2014)
review2 = Review(movie2, 'I did not like it', 1)
review3 = review1
user.add_review(review1)
assert len(user.reviews) == 1
assert user.reviews[0] == review1
user.add_review(review2)
assert len(user.reviews) == 2
assert user.reviews[1] == review2
user.add_review(review3)
assert len(user.reviews) == 2
def test_init(self):
movie = Movie("Moana", 2016)
review_text = "This movie was very enjoyable."
rating = 8
review = Review(movie, review_text, rating)
assert repr(review.movie) == "<Movie Moana, 2016>"
assert review.review_text == "This movie was very enjoyable."
assert review.rating == 8
def test_constructor_invalid_review_text_type(movie):
review_text = 42
rating = 1
review = Review(movie, review_text, rating)
assert review.movie == movie
assert review.review_text is None
assert review.rating == rating
assert review.timestamp.timestamp() == pytest.approx(
datetime.utcnow().timestamp(), abs=_TIMESTAMP_TOLERANCE)
def add_review(movie_id: int, review_text: str, username: str, rating: int,
repo: AbstractRepository):
# Check that the movie exists.
movie = repo.get_movie(movie_id)
if movie is None:
raise NonExistentArticleException
user = repo.get_user(username)
if user is None:
raise UnknownUserException
# Create review.
review = Review(movie, review_text, rating)
review.user = user
review.user.add_review(review)
movie.add_review(review)
# Update the repository.
repo.add_review(review)
def test_accessing_non_friend(user, friend):
thisisamovie = Movie("Garlic Bread", 2020)
thisisareview = Review(thisisamovie, "this is a review.", 9)
thisisamovie.runtime_minutes = 69
friend.watch_movie(Movie("Garlic Bread", 2020))
friend.add_review(thisisareview)
assert user.see_friend_watched_movies(friend) is None
assert user.see_friend_reviews(friend) is None
assert user.see_friend_minutes_watched(friend) is None
def test_add_review():
user1 = User('Me', 'pw12345')
movie2 = Movie("Star Wars", 1977)
review = Review(
movie2,
"My car turned into the Millennium Falcon after showing the movie to it",
10)
user1.add_review(review)
assert user1.reviews == [review]
def simulate(
self,
num_users: int = _DEFAULT_USER_COUNT,
min_num_movies: int = _DEFAULT_MIN_MOVIES_PER_USER,
max_num_movies: int = _DEFAULT_MAX_MOVIES_PER_USER) -> 'State':
self._validate_params(num_users, min_num_movies, max_num_movies)
users = []
reviews = []
num_movies = len(self._movies)
upper_bound = min(max_num_movies or num_movies, num_movies)
population = list(range(0, num_movies))
now = datetime.utcnow().timestamp()
for i in range(num_users):
username = _rand_string(4)
password = _rand_string()
user = User(username, password)
# Pick n distinct movies
movies = [
self._movies[idx] for idx in sample(
population, randint(min_num_movies, upper_bound))
]
# Add those movies to the user's watchlist
for movie in movies:
user.add_to_watchlist(movie)
# Watch a random number of movies on the user's watchlist
for j in range(randint(0, user.watchlist_size())):
user.watch_movie(movies[j])
# Review a random number of the movies the user watched
for j in range(randint(0, len(user.watched_movies))):
movie = movies[j]
review_text = _rand_string()
rating = randint(0, 10)
release_date = datetime(movie.release_date, 1, 1).timestamp()
delta = randint(
0, int(now - release_date)
) # float -> int will be lossy but not a big deal here
delta += random() # Add a random number of milliseconds
timestamp = datetime.fromtimestamp(now - delta)
review = Review(movie, review_text, rating, timestamp)
user.add_review(review)
reviews.append(review)
users.append(user)
return self.State(users, reviews)
def test_init(self):
movie = Movie("Moana", 2016)
user1 = User("terentiy8512", "12345")
user2 = User("xabib", "123")
user3 = User("undercop", "12345678")
review1 = Review(movie, "This movie was very enjoyable.", 8)
review2 = Review(movie, "Not really impressed", 4)
review3 = Review(movie, "Loved it", 10)
simulation = MovieWatchingSimulation(movie)
# test 1 # <Movie Moana, 2016> have 0 reviews and has been watched by 0 users.
simulation.add_review(user1, review1)
print(simulation)
# test 2 # <Movie Moana, 2016> have 0 reviews and has been watched by 0 users.
simulation.remove_review_from_the_movie(user1, review1)
print(simulation)
# test 3 # <Movie Moana, 2016> have 0 reviews and has been watched by 1 user.
simulation.watch_movie(user1)
print(simulation)
# test 4 # <Movie Moana, 2016> have 1 review and has been watched by 1 user.
simulation.add_review(user1, review1)
print(simulation)
# test 5 # <Movie Moana, 2016> have 1 review and has been watched by 1 user.
simulation.add_review(user2, review2)
print(simulation)
# test 6 # <Movie Moana, 2016> have 1 review and has been watched by 2 users.
simulation.watch_movie(user2)
print(simulation)
# test 7
simulation.watch_movie(user3)
simulation.add_review(user3, review2) # <Movie Moana, 2016> have 2 reviews and has been watched by 3 users.
print(simulation)
# test 8
simulation.remove_review_from_the_movie(user3, review2)
print(simulation) # <Movie Moana, 2016> have 1 review and has been watched by 3 users.
def create_and_add_review_movie_and_user_to_group_and_individual_list(
self, user: User, review_text: str, rating: int):
if type(user) is not User or type(review_text) is not str or type(
rating) is not int:
raise TypeError()
else:
self._users.append(user)
review = Review(self._movie_watched_together, review_text, rating)
self._reviews.append(review)
user.watch_movie(self._movie_watched_together)
user.add_review(review)
def record_user_and_review(self, user: User, review_text: str,
rating: int):
if type(user) is not User or type(review_text) is not str or type(
rating) is not int:
raise TypeError()
else:
self._users.append(user)
review = Review(self._movie_watched_together, review_text, rating)
self._reviews.append(review)
user.watch_movie(self._movie_watched_together)
user.add_review(review)
