def test_create_duplicate_password(database: Database) -> None: "can a user be created with a password that's the same as another user" example_user: user.Model = random_user() example_username: Username = random_username() assert example_user.username != example_username, "usernames need to be different" created_user = user.create(db=database, user=example_user) duplicate_user = created_user.copy(update={"username": example_username}) assert created_user.username != duplicate_user.username assert created_user.hashed_password == duplicate_user.hashed_password created_duplicate_user = user.create(db=database, user=duplicate_user) assert created_duplicate_user == duplicate_user
def test_update_user_same_username(database: Database) -> None: "can an existing user be modified" example_user: user.Model = random_user() example_hashed_password: HashedPassword = random_hashed_password() assert ( example_user.hashed_password != example_hashed_password ), "passwords need to be different" # NOTE:IMPLEMENTATION::USERS In the future, I may want to use something other than # the username of a user as the uniquely primary key in the database. # This would allow changing the username. # Currently, to change the username, a new user has to be created, and the old one deleted. # To facilitate a future where user ids may not be the username, the # interfce described in this test uses the username as the user id # explicitly, as opposed to expecting the user functions to implicitly look # at the username attribute of the passed in user. # It's also why the flow is: # - Get the current user model for the user # - Make a copy, updating the properties at the same time # - Update the user in the database, using the user id returned with the # first user model to identify which user the model should be applied to # The functions could implicitly look at the user id of a model that has one. I'll see about it when it's implemented created_user = user.create(db=database, user=example_user) updated_user = created_user.copy( update={"hashed_password": example_hashed_password} ) assert created_user.username == updated_user.username assert created_user.hashed_password != updated_user.hashed_password user.update(db=database, username=created_user.username, updated_user=updated_user) returned_updated_user = user.get(db=database, username=created_user.username) assert returned_updated_user == updated_user assert created_user.username == returned_updated_user.username assert type(created_user) == type(returned_updated_user)
def test_user_duplicate_deletion(database: Database) -> None: "is an error raised when a user is deleted a second time" example_user: user.Model = random_user() created_user = user.create(db=database, user=example_user) user.delete(db=database, user=created_user) with pytest.raises(UserNotFoundError) as err: user.delete(db=database, user=example_user) assert f"no user found with username '{example_user.username}'" in str(err.value)
def test_create_duplicate_username(database: Database) -> None: "is an error raised if a username is already taken" example_user: user.Model = random_user() example_hashed_password: HashedPassword = random_hashed_password() assert ( example_user.hashed_password != example_hashed_password ), "passwords need to be different" created_user = user.create(db=database, user=example_user) duplicate_user = created_user.copy( update={"hashed_password": example_hashed_password} ) assert created_user.username == duplicate_user.username assert created_user.hashed_password != duplicate_user.hashed_password with pytest.raises(UserAlreadyExistsError) as err: user.create(db=database, user=duplicate_user) assert f"a user with username '{duplicate_user.username}' already exists" in str( err.value )
def test_create_user(database: Database) -> None: "can a user be added and read back" example_user: user.Model = random_user() assert isinstance(example_user, user.Model) created_user = user.create(db=database, user=example_user) assert created_user.username == example_user.username assert created_user.hashed_password == example_user.hashed_password assert isinstance(created_user, user.Model) returned_user = user.get(db=database, username=created_user.username) assert returned_user == created_user
def test_list_and_delete_user(database: Database) -> None: """ if a user is deleted, are they removed from the list of users, and is an error raised when a unique id is used to retrieve it """ example_user: user.Model = random_user() number_of_sample_users: int = 10 for _ in range(number_of_sample_users): user.create(db=database, user=random_user()) created_user = user.create(db=database, user=example_user) user.delete(db=database, user=created_user) users = user.list(db=database) assert len(users) == number_of_sample_users for usr in users: assert isinstance(usr, user.Model) assert usr != created_user with pytest.raises(UserNotFoundError) as err: user.get(db=database, username=created_user.username) assert f"no user found with username '{created_user.username}'" in str(err.value)
def test_update_user_all_properties(database: Database) -> None: "can all of a user's attributes be updated at once" example_user: user.Model = random_user() different_user: user.Model = random_user() assert example_user.username != different_user.username assert example_user.hashed_password != different_user.hashed_password created_user = user.create(db=database, user=example_user) updated_user = user.update( db=database, username=created_user.username, updated_user=different_user ) assert created_user.username != updated_user.username assert created_user.hashed_password != updated_user.hashed_password
def test_update_deleted_user(database: Database) -> None: """ is an error raised when an update is performed on a user that doesn't exist """ example_user: user.Model = random_user() example_hashed_password: HashedPassword = random_hashed_password() assert ( example_user.hashed_password != example_hashed_password ), "passwords need to be different" created_user = user.create(db=database, user=example_user) user.delete(db=database, user=created_user) updated_user = created_user.copy( update={"hashed_password": example_hashed_password} ) with pytest.raises(UserNotFoundError) as err: user.update( db=database, username=updated_user.username, updated_user=updated_user ) assert f"no user found with username '{updated_user.username}'" in str(err.value)