def test_equal():
user1 = User('Martin', 'pw12345')
user2 = User('Ian', 'pw67890')
user3 = User('Martin', 'pw12345')
assert (user1 == user2) == False
assert (user1 == user3) == True
def test_user_repr():
user1 = User("rsin774", "password")
user2 = User("", "pw")
user3 = User("user", "")
assert repr(user1) == "<User rsin774>"
assert repr(user2) == "<User None>"
assert repr(user3) == "<User user>"
def test_user_invalid_construction():
user1 = User('', 'pw67890')
assert user1.user_name is None
assert user1.password == 'pw67890'
user2 = User('Daniel', 12345)
assert user2.user_name == 'daniel'
assert user2.password is None
def test_repository_does_not_add_a_review_without_a_movie_properly_attached(in_memory_repo):
user = User('aidan', 'hi1234')
movie = Movie("asdsa", 2014)
review = Review(user, movie, "Wow good movie", 9, datetime.today())
user.add_review(review)
with pytest.raises(RepositoryException):
in_memory_repo.add_review(review)
def test_init():
user1 = User('Martin', 'pw12345')
user2 = User('Ian', 'pw67890')
user3 = User('Daniel', 'pw87465')
assert repr(user1) == "<User martin>"
assert repr(user2) == "<User ian>"
assert repr(user3) == "<User daniel>"
def test_user_equals_operator():
user1 = User("rsin774", "password")
user2 = User("rsin774", "")
user3 = User("", "password")
user4 = User("rsin774", "password")
assert (user1 == user2) is True
assert (user1 == user3) is False
assert (user1 == user4) is True
def test_add_review_without_movie_attached(in_memory_repo):
user = User("Martin", "pw12345")
review = Review(user, Movie("Guardians of the Galaxy", 2014), "Wow!", 9)
user.add_review(review)
with pytest.raises(RepositoryException):
in_memory_repo.add_review(
Review(None, Movie("Guardians of the Galaxy", 2014), "Wow!", 9))
def test_loading_of_users(empty_session):
users = list()
users.append(("Andrew", "1234"))
users.append(("Cindy", "1111"))
insert_users(empty_session, users)
expected = [User("Andrew", "1234"), User("Cindy", "999")]
assert empty_session.query(User).all() == expected
def test_password():
user1 = User('Martin', 'pw12345')
assert user1.password == "pw12345"
user2 = User('Ian', 1)
assert user2.password == None
user3 = User('Daniel', "")
assert user3.password == None
def test_repository_can_add_and_get_reviews(in_memory_repo):
review = Review(User("Bob12", "password888"), Movie("Ice Age", 2002),
"Great", 8)
in_memory_repo.add_review(review)
reviews = in_memory_repo.get_reviews()
assert reviews[0].user == User("Bob12", "password888")
assert reviews[0].movie == Movie("Ice Age", 2002)
assert reviews[0].review_text == "Great"
assert reviews[0].rating == 8
def test_repository_does_not_add_a_review_without_a_movie_properly_attached(
session_factory):
repo = SqlAlchemyRepository(session_factory)
user = User('aidan', 'hi1234')
review = Review(user, None, "Wow good movie", 9, datetime.today())
user.add_review(review)
repo.add_user(user)
with pytest.raises(RepositoryException):
repo.add_review(review)
def test_repository_can_add_a_user(session_factory):
repo = SqlAlchemyRepository(session_factory)
user = User('Dave', '123456789')
repo.add_user(user)
repo.add_user(User('Martin', '123456789'))
user2 = repo.get_user('dave')
assert user2 == user and user2 is user
def test_repository_can_add_a_user(session_factory):
repo = SqlAlchemyRepository(session_factory)
user = User('Liam', '123456789')
repo.add_user(user)
repo.add_user(User('Trevor', '123456789'))
user2 = repo.get_user('Liam')
assert user2 == user and user2 is user
def test_user_name():
user1 = User('Martin', 'pw12345')
assert user1.user_name == "martin"
user2 = User(' Ian ', 'pw67890')
assert user2.user_name == "ian"
user3 = User("", "pw87465")
assert user3.user_name == None
user4 = User(1, "pw87465")
assert user4.user_name == None
def in_memory_repo():
repo = MemoryRepository()
dirname = os.path.dirname(__file__)
filename = os.path.join(dirname, 'data')
populate(filename, repo)
repo.add_user(User("shaun", '12345'))
return repo
def review():
user = User("rsin774", "password")
movie = Movie("Moana", 2016)
review_text = "This movie was very enjoyable."
rating = 8
timestamp = datetime.now()
return Review(user, movie, review_text, rating, timestamp)
def test_review_repr():
user = User("rsin774", "password")
movie = Movie("Moana", 2016)
review_text = "This movie was very enjoyable."
rating = 8
timestamp = datetime.now()
review = Review(user, movie, review_text, rating, timestamp)
assert review.__repr__() == "User: rsin774\nReview: This movie was very enjoyable.\nRating: 8"
def test_repository_add_review(in_memory_repo):
user = User('rsin774', 'password')
movie = Movie('Guardians of the Galaxy', 2014)
review = make_review(user, movie, "Great!", 10, datetime.now())
in_memory_repo.add_review(review)
assert review in in_memory_repo.get_reviews()
def test_repository_can_add_a_review(in_memory_repo):
user = User('aidan', 'hi1234')
movie = Movie("asdsa", 2014)
review = make_review("Wow good movie", user, movie, 9)
in_memory_repo.add_review(review)
reviews = in_memory_repo.get_reviews()
assert len(reviews) == 1
assert review in reviews
def test_repository_get_user(in_memory_repo):
# Existing user
user = in_memory_repo.get_user('rsin774')
assert user == User('rsin774', 'password')
# Non-existent user
user = in_memory_repo.get_user('doesntexist')
assert user is None
def test_add_and_get_reviews(in_memory_repo):
assert len(in_memory_repo.get_reviews()) == 0
review = make_review("Great movie", User("Martin", "pw12345"),
Movie("Guardians of the Galaxy", 2014), 8)
in_memory_repo.add_review(review)
assert review in in_memory_repo.get_reviews()
def test_review_construction(review):
user = User("rsin774", "password")
movie = Movie("Moana", 2016)
assert review.user == user
assert review.movie == movie
assert review.review_text == "This movie was very enjoyable."
assert review.rating == 8
assert review.timestamp is not None
def load_users(data_path: str, repo: MemoryRepository):
users = dict()
for data_row in read_csv_file(os.path.join(data_path, 'users.csv')):
user = User(username=data_row[1],
password=generate_password_hash(data_row[2]))
repo.add_user(user)
users[data_row[0]] = user
return users
def add_user(username: str, password: str, repo: AbstractRepository):
# check that given username is available
user = repo.get_user(username)
if user is not None:
raise NameNotUniqueException
# if available generate password hash and store new user with hash
password_hash = generate_password_hash(password)
user = User(username, password_hash)
repo.add_user(user)
def set_rating(movie_id: int, rating: int, username: str,
repo: AbstractRepository):
user = repo.get_user(username)
if user is None:
user = User('Guest account', 'defaultpass')
movie = repo.get_movie(movie_id)
if movie is None:
raise NonExistentMovieException
repo.set_rating(rating, user, movie)
def add_user(username: str, password: str, repo: AbstractRepository):
# Check that the given username is available.
user = repo.get_user(username)
if user is not None:
raise NameNotUniqueException
# Encrypt password so that the database doesn't store passwords 'in the clear'.
password_hash = generate_password_hash(password)
# Create and store the new User, with password encrypted.
user = User(username, password_hash)
repo.add_user(user)
def test_can_get_reviews_for_movie(in_memory_repo):
movie_id = 1
# adding review to repo
user = User("shaun", '12345')
review = make_review("Wow", user, in_memory_repo.get_movie(1), 10)
in_memory_repo.add_review(review)
# testing retrieval of review
reviews = movies_services.get_reviews_for_movie(movie_id, in_memory_repo)
assert len(reviews) == 1
assert reviews[0]["review_text"] == "Wow"
def add_user(username: str, password: str, repo: AbstractRepository):
# Check that the username is not taken
user = repo.get_user(username)
if user is not None:
raise NameNotUniqueException
# Encrypt password
password_hash = generate_password_hash(password)
# Create and store the new User with encrypted password
user = User(username, password_hash)
repo.add_user(user)
def test_user_time_spent():
user1 = User('Martin', 'pw12345')
user1.time_spent_watching_movies_minutes = 100
assert user1.time_spent_watching_movies_minutes == 100
user2 = User('Ian', 'pw67890')
user2.time_spent_watching_movies_minutes = -100
assert user2.time_spent_watching_movies_minutes == 0
def client():
my_app = create_app({
'TESTING': True, # Set to True during testing.
'REPOSITORY':
'memory', # Set to 'memory' or 'database' depending on desired repository.
'TEST_DATA_PATH':
TEST_DATA_PATH_MEMORY, # Path for loading test data into the repository.
'WTF_CSRF_ENABLED':
False # test_client will not send a CSRF token, so disable validation.
})
repo1.repo_instance.add_user(User("shaun",
generate_password_hash("12345")))
return my_app.test_client()