def test_the_is_invalid_method_of_user_repository_with_corrent_data_of_existent_user(
app):
"""
GIVEN the UserRepository class
WHEN the method is_invalid(user) is called with a valid user
THEN check return True
"""
from app.model import UserRepository, User
user_repository = UserRepository()
user_repository.session = UnifiedAlchemyMagicMock()
user = User()
user.id = 1
user.username = '******'
user.password = '******'
user_repository.session.add(user)
user_repository.session.commit()
# update
user.username = '******'
user.password = '******'
is_invalid = user_repository.is_invalid(user)
assert not is_invalid
def register() -> Response:
"""Register a new user.
Returns:
response: flask.Response object with the application/json mimetype.
"""
if not request.is_json:
abort(400)
user_repository = UserRepository()
# creating a User object
user = User()
user.username = request.json.get('username')
user.password = request.json.get('password')
# validating the user
is_invalid = user_repository.is_invalid(user)
if not is_invalid:
user_repository.save(user)
return make_response(
jsonify({
'status': 'success',
'data': user.serialize()
}), 200)
else:
response = make_response(
jsonify({
'status': 'fail',
'data': is_invalid
}), 400)
return response
def test_the_update_method_of_user_repository(app):
"""
GIVEN the UserRepository class
WHEN the method update(user) is called
THEN check session method calls and user data
"""
from app.model import UserRepository, User
user_repository = UserRepository()
user_repository.session = UnifiedAlchemyMagicMock()
user = User(username=get_unique_username(), password="******")
user_repository.session.add(user)
user_repository.session.commit()
# updating
username_edited = get_unique_username()
user.password = "******"
user.username = username_edited
user_repository.update(user)
# user_repository.session.commit.assert_called_once_with()
assert check_password_hash(user.password, "1234")
assert user.username == username_edited
assert user.serialize() == {
'id': str(user.id),
'username': username_edited
}
assert str(user) == '<User %r>' % (username_edited)
def test_the_is_invalid_method_of_user_repository_with_username_already_in_use(
app):
"""
GIVEN the UserRepository class
WHEN the method is_invalid(user) is called with a invalid user
THEN check return True
"""
from app.model import UserRepository, User
user_repository = UserRepository()
user_repository.session = UnifiedAlchemyMagicMock()
user = User()
user.id = 1
user.username = '******'
user.password = '******'
user_repository.session.add(user)
user_repository.session.commit()
user = User()
user.username = '******'
is_invalid = user_repository.is_invalid(user)
assert is_invalid
assert {"username": "******"} in is_invalid
def test_the_is_invalid_method_of_user_repository_missing_username(app):
"""
GIVEN the UserRepository class
WHEN the method is_invalid(user) is called with a invalid user
THEN check return false
"""
from app.model import UserRepository, User
user_repository = UserRepository()
user_repository.session = UnifiedAlchemyMagicMock()
user = User(password="******")
is_invalid = user_repository.is_invalid(user)
assert is_invalid
assert {"username": "******"} in is_invalid
def test_the_is_invalid_method_of_user_repository_with_invalid_password(app):
"""
GIVEN the UserRepository class
WHEN the method is_invalid(user) is called with a invalid user
THEN check return false
"""
from app.model import UserRepository, User
user_repository = UserRepository()
user_repository.session = UnifiedAlchemyMagicMock()
user = User(password="******")
is_invalid = user_repository.is_invalid(user)
assert is_invalid
assert {"password": "******"} in is_invalid
def delete_account() -> Response:
"""Deletes the user account.
Returns:
response: flask.Response object with the application/json mimetype.
"""
user_identity = get_jwt_identity()
user_repository = UserRepository()
user = user_repository.get_by_username(user_identity)
if user:
user_repository.delete(user)
TokenRepository().revoke_all_tokens(user_identity)
return make_response('', 201)
abort(404)
def test_the_is_invalid_method_of_user_repository_with_corrent_data(app):
"""
GIVEN the UserRepository class
WHEN the method is_invalid(user) is called with a valid user
THEN check return True
"""
from app.model import UserRepository, User
user_repository = UserRepository()
user_repository.session = UnifiedAlchemyMagicMock()
username = get_unique_username()
password = '******'
user = User(username=username, password=password)
is_invalid = user_repository.is_invalid(user)
assert not is_invalid
def get_account():
"""Retrieves the user account.
Returns:
response: flask.Response object with the application/json mimetype.
"""
user_identity = get_jwt_identity()
user = UserRepository().get_by_username(user_identity)
if not user:
abort(404)
return make_response(
jsonify({
'status': 'success',
'data': user.serialize()
}), 200)
def test_the_authenticate_method_of_user_repository(app):
"""
GIVEN the UserRepository class
WHEN the method authenticate(username, password) is called
THEN check the method returning
"""
from app.model import UserRepository, User
user_repository = UserRepository()
user_repository.session = UnifiedAlchemyMagicMock()
user = User(username=get_unique_username(),
password=generate_password_hash("123"))
user_repository.session.add(user)
user_repository.session.commit()
# correct data
result = user_repository.authenticate(user.username, "123")
assert result
# wrong password
result = user_repository.authenticate(user.username, "1234")
assert not result
# wrong username
result = user_repository.authenticate("wrong_username", "123")
assert result
def test_create_new_user_repository(app):
"""
GIVEN the UserRepository class
WHEN a new UserRepository is created
THEN check the UserRepository and the SQLAlchemy session instances
"""
from app.model import UserRepository
user_repository = UserRepository()
assert isinstance(user_repository, UserRepository)
assert isinstance(user_repository.session,
sqlalchemy.orm.scoping.scoped_session)
def test_the_get_by_username_method_of_user_repository(app):
"""
GIVEN the UserRepository class
WHEN the method get_by_username(username) is called
THEN check the user object returned
"""
from app.model import UserRepository, User
user_repository = UserRepository()
user_repository.session = UnifiedAlchemyMagicMock()
username = get_unique_username()
password = '******'
user = User(username=username, password=password)
user_repository.session.add(user)
user_repository.session.commit()
result = user_repository.get_by_username(username)
assert result.username == username
assert result.password == password
assert result.serialize() == {'id': str(user.id), 'username': username}
assert str(result) == '<User %r>' % (username)
def add_user(username: str, password: str) -> None:
"""Create a new user.
Parameters:
username (str): The username of the user.
password (str): The password of the user.
"""
from app.model import User
from app.model import UserRepository
user_repository = UserRepository()
user = User(username=username, password=password)
is_invalid = user_repository.is_invalid(user)
if not is_invalid:
user_repository.save(user)
click.echo('User created.')
else:
click.echo('Could not validate the user:')
for i in is_invalid:
key = list(i.keys())[0]
click.echo("{}: {}".format(key, i[key]))
def test_the_save_method_of_user_repository(app):
"""
GIVEN the UserRepository class
WHEN the method get_by_username(username) is called
THEN check session method calls and user data
"""
from app.model import UserRepository, User
user_repository = UserRepository()
user_repository.session = UnifiedAlchemyMagicMock()
username = get_unique_username()
password = '******'
user = User(username=username, password=password)
user_repository.save(user)
user_repository.session.add.assert_called_once_with(user)
user_repository.session.commit.assert_called_once_with()
assert user.username == username
assert check_password_hash(user.password, password)
assert user.serialize() == {'id': str(user.id), 'username': username}
assert str(user) == '<User %r>' % (username)
def login() -> Response:
"""Login of the user by creating a valid token.
Returns:
response: flask.Response object with the application/json mimetype.
"""
data = request.json
# checkint the json data
if not request.is_json or not data.get('username') or not data.get(
'password'):
abort(400)
# authenticating the user
user = UserRepository().authenticate(data.get('username'),
data.get('password'))
if not user:
response = make_response(
jsonify({
'status': 'fail',
'message': 'Username or Password not valid'
}), 401)
else:
access_token_encoded = create_access_token(identity=user.username)
refresh_token_encoded = create_refresh_token(identity=user.username)
token_repository = TokenRepository()
token_repository.save(access_token_encoded,
current_app.config["JWT_IDENTITY_CLAIM"])
token_repository.save(refresh_token_encoded,
current_app.config["JWT_IDENTITY_CLAIM"])
response = make_response(
jsonify({
'status': 'success',
'data': {
'access_token': access_token_encoded,
'refresh_token': refresh_token_encoded
}
}), 200)
return response
def patch_account() -> Response:
"""Patches the user account.
Returns:
response: flask.Response object with the application/json mimetype.
"""
if not request.is_json:
abort(400)
user_identity = get_jwt_identity()
user_repository = UserRepository()
user = user_repository.get_by_username(user_identity)
if not user:
abort(404)
# update the object values
for key, value in request.json.items():
setattr(user, key, value)
user.username = user_identity
# validating the user
is_invalid = user_repository.is_invalid(user)
if not is_invalid:
user_repository.update(user)
response = make_response(
jsonify({
'status': 'success',
'data': user.serialize()
}), 200)
else:
response = make_response(
jsonify({
'status': 'fail',
'data': is_invalid
}), 400)
return response
def update_account() -> Response:
"""Updates the user account.
Returns:
response: flask.Response object with the application/json mimetype.
"""
if not request.is_json:
abort(400)
user_identity = get_jwt_identity()
user_repository = UserRepository()
user = user_repository.get_by_username(user_identity)
if not user:
abort(404)
# updating the user
user.username = user_identity
user.password = request.json.get('password')
# validating the user
is_invalid = user_repository.is_invalid(user)
if not is_invalid:
user_repository.update(user)
response = make_response(
jsonify({
'status': 'success',
'data': user.serialize()
}), 200)
else:
response = make_response(
jsonify({
'status': 'fail',
'data': is_invalid
}), 400)
return response
