def test_ignore_all_pending_requests(user, friend):
friend2 = User("Picroma", "shadow")
friend.send_friend_request(user)
friend2.send_friend_request(user)
user.ignore_all_pending_requests()
assert user.pending_friends == []
assert friend.pending_friends == []
assert friend2.pending_friends == []
def test_repository_does_not_add_a_review_without_a_movie_properly_attached(
in_memory_repo):
user = User('Ella', '123456789')
in_memory_repo.add_user(user)
user = in_memory_repo.get_user('Ella')
movie = in_memory_repo.get_movie(2)
review = Review(None, movie, "Could be better", 3, datetime.today())
user.add_review(review)
with pytest.raises(RepositoryException):
# Exception expected because the Movie doesn't refer to the Review.
in_memory_repo.add_review(review)
def test_construction(self):
user2 = User(1, 2)
assert user2.user_name is None
assert user2.password is None
assert user2.watched_movies == []
assert user2.time_spent_watching_movies_minutes == 0
assert user2.reviews == []
def test_repository_can_retrieve_a_user(session_factory):
repo = SqlAlchemyRepository(session_factory)
user = User('fmercury', '8734gfe2058v')
repo.add_user(user)
user = repo.get_user('fmercury')
assert user.user_name == user.user_name
def load_users(data_path):
"""
"""
users = dict()
for data_row in read_csv(os.path.join(data_path, 'Users.csv')):
user = User(data_row[0], generate_password_hash(data_row[1]))
users[data_row[0]] = user
return users
def test_repository_can_add_a_user(session_factory):
repo = SqlAlchemyRepository(session_factory)
user = User('Dave', '123456789')
repo.add_user(user)
user2 = repo.get_user('Dave')
assert user.user_name == user.user_name
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[0],
password=generate_password_hash(data_row[1]))
repo.add_user(user)
users[data_row[0]] = user
return users
def add_user(username: str, password: str, repo: AbstractRepository):
"""
"""
user = repo.get_user(username)
if user:
raise NameNotUnqiueException
password_hash = generate_password_hash(password)
repo.add_user(User(username, password_hash))
def test_remove_member(self, usergroup, user):
usergroup.add_member(User("Sophie", "abc"))
usergroup.add_member(User("Tim", "ab3"))
usergroup.remove_member(User("Sophie", "abc"))
assert usergroup.members == [user, User("Tim", "ab3")]
usergroup.remove_member(User("Sophie", "abc"))
assert usergroup.members == [user, User("Tim", "ab3")]
usergroup.remove_member('a')
assert usergroup.members == [user, User("Tim", "ab3")]
def test_repository_can_retrieve_reviews(in_memory_repo):
user = User('Ella', '123456789')
in_memory_repo.add_user(user)
user = in_memory_repo.get_user('Ella')
movie = in_memory_repo.get_movie(2)
review = make_review("Could be better", user, movie, 3)
in_memory_repo.add_review(review)
assert len(in_memory_repo.get_reviews()) == 1
def add_user(user_name: str, password: str, repo: AbstractRepository):
# Check that the given username is available.
user = repo.get_user(user_name)
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(user_name, password_hash)
repo.add_user(user)
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(
user_name=data_row[1],
password=generate_password_hash(data_row[2])
)
friends_ids = data_row[3].split(",")
if friends_ids == ['']:
pass
else:
user.friends_ids = friends_ids
pending_ids = data_row[4].split(",")
if pending_ids == ['']:
pass
else:
user.pending_friends_ids = pending_ids
user.id = int(data_row[0])
repo.add_user(user)
users[data_row[0]] = user
watched_ids = data_row[5].split(",")
if watched_ids == ['']:
pass
else:
int_ids = [int(x) for x in watched_ids]
user.watched_ids = int_ids
user.watched_movies = repo.get_movies_by_id(int_ids)
for key in users:
user = users[key]
friends = []
pending = []
for id in user.friends_ids:
friends.append(repo.get_user_by_id(int(id)))
for id2 in user.pending_friends_ids:
pending.append(repo.get_user_by_id(int(id2)))
user.friends = friends
user.pending_friends = pending
return users
def friend2():
return User("Picroma", "shadow")
def test_add_member(self, usergroup, user):
usergroup.add_member(User("Sophie", "abc"))
assert usergroup.members == [user, User("Sophie", "abc")]
usergroup.add_member(User("Sophie", "abc"))
usergroup.add_member("Hi")
assert usergroup.members == [user, User("Sophie", "abc")]
def user(self):
"""
"""
return User("tombrittenden", "123")
def test_lt(self, user):
assert user > User("Sophie", "")
assert user < User("VioletA12", "flowers1234!")
def test_eq(self, user):
assert user == User("Tombrittenden", "")
assert user == User("TomBrittenden", "")
assert user == User("TombrittendeN", "")
assert user == User("TOMBRITTENDEN", "")
assert user != User("Tim", " ")
def test_repository_can_retrieve_a_user(in_memory_repo):
user = in_memory_repo.get_user('thorke')
#print(user)
user2 = User("thorke", "cLQ^C#oFXloS")
#print(user2)
assert user == user2
def test_repository_can_add_a_user(in_memory_repo):
user = User('Picroma', '666666')
in_memory_repo.add_user(user)
assert in_memory_repo.get_user('picroma') is user
def test_repository_can_retrieve_a_user(in_memory_repo):
user = User('Ella', '123456789')
in_memory_repo.add_user(user)
user = in_memory_repo.get_user('Ella')
assert user == User('Ella', '8734gfe2058v')
def user():
user = User('Ella', '1234567890')
return User('Ella', '1234567890')
def user(self):
"""
"""
return User("Tom Brittenden", "123")
def test_repo_can_get_user(in_memory_repo):
user = in_memory_repo.get_user('admin')
assert user == User('admin', 'admin')
def friend():
return User("notemelg", "wdpass")
def user():
return User('dbowie', '1234567890')
def test_repository_can_add_a_user(in_memory_repo):
user = User('Ella', '123456789')
in_memory_repo.add_user(user)
assert in_memory_repo.get_user('Ella') is user
def user():
return User("emelg", "passwd")
def test_repo_can_add_user(in_memory_repo):
user = User('tom', '1234')
in_memory_repo.add_user(user)
assert in_memory_repo.get_user('tom') is user
