def _to_domain_model(self, data):
status = TaskStatus(id=data.status.id, name=data.status.name)
creator = User(
id=data.creator.id,
name=data.creator.name,
roles=[UserRole(id=role.id, name=role.name)
for role in data.creator.roles]
)
doer = None
if data.doer:
doer = User(
id=data.doer.id,
name=data.doer.name,
roles=[UserRole(id=role.id, name=role.name)
for role in data.doer.roles]
)
return Task(
name=data.name,
content=data.content,
status=status,
creator=creator,
doer=doer,
id=data.id
)
def test_user():
name = 'name'
permissions = [Permission('AddUserAction')]
roles = [UserRole(name='role_name'), UserRole(name="role_name2")]
user = User(name=name, roles=roles, permissions=permissions)
assert user.name == name
assert user.roles == roles
assert user.permissions == permissions
def one(self, id):
result = self.role_model.query.get(id)
if not result:
raise NoResultFound(id, UserRole.__name__)
return UserRole(id=result.id, name=result.name)
def test_add_user_action_with_hooks():
name = 'name'
password = '******'
role_id = 1
roles_repo = mock.Mock()
roles_repo.one.return_value = UserRole(name='role_name')
users_repo = mock.Mock()
users_repo.save.return_value = User(name=name,
roles=[roles_repo.one.return_value])
request = AddUserRequest(name=name, password=password, roles=[role_id])
action = AddUserAction(users_repo, roles_repo)
before = mock.MagicMock()
after = mock.MagicMock()
action.add_before_execution_hook(before)
action.add_after_execution_hook(after)
response = action.execute(request)
assert before.called
assert after.called
assert users_repo.save.called
assert bool(response) is True
assert response.value == users_repo.save.return_value
def test_user_serializer():
role = UserRole(name='admin', id=1)
role2 = UserRole(name='creator', id=2)
user = User(name='user', roles=[role, role2])
expected_json = json.dumps(dict(
id=None,
name=user.name,
roles=[
dict(name=role.name, id=role.id),
dict(name=role2.name, id=role2.id)
],
))
assert json.loads(json.dumps(user, cls=UserEncoder)) ==\
json.loads(expected_json)
def test_user_serializer():
task_content = 'test content'
task_name = 'test name'
task_dict = dict(name=task_name,
content=task_content,
status=dict(id=1, name='new'),
creator=dict(id=1,
name='creator',
roles=[dict(id=1, name='creator')]),
doer=None,
id=1)
status = TaskStatus(**(task_dict['status']))
creator = User(id=task_dict['creator']['id'],
name=task_dict['creator']['name'],
roles=[
UserRole(name=role['name'], id=role['id'])
for role in task_dict['creator']['roles']
])
task = Task(
id=task_dict['id'],
name=task_dict['name'],
content=task_dict['content'],
status=status,
creator=creator,
doer=None,
)
expected_json = json.dumps(task_dict)
assert json.loads(json.dumps(task, cls=TaskEncoder)) ==\
json.loads(expected_json)
def test_update_not_existing_user():
creator_id, creator_name, creator_role_id, creator_role_name = creator_
user = User(name='asdasd',
roles=[UserRole(name=creator_role_name, id=creator_role_id)],
id=99)
with pytest.raises(NoResultFound):
repository.update(user)
def test_add_user_with_not_existing_role():
user = User(
name='asdasdasd',
roles=[UserRole(name='asdasd', id=99)],
)
with pytest.raises(NoResultFound):
repository.save(user, password='******')
def test_tasks_repository_save_with_not_existing_doer():
task_content = 'test content'
task_name = 'test name'
task = Task(
name=task_name,
content=task_content,
status=TaskStatus(id=1, name='new'),
creator=User(id=1,
name='creator',
roles=[UserRole(id=1, name='creator')]),
doer=User(id=9, name='creator', roles=[UserRole(id=1,
name='creator')]),
)
with pytest.raises(NoResultFound):
repository.save(task)
def process_request(self, request):
new_role = UserRole(name=request.name)
self._call_before_execution_hooks(dict(request=request, role=new_role))
response = self.roles_repo.save(new_role)
self._call_after_execution_hooks(dict(request=request, role=response))
return ResponseSuccess(response)
def test_update_non_unique_user():
creator_id, creator_name, creator_role_id, creator_role_name = creator_
doer_id, doer_name, doer_role_id, doer_role_name = doer_
user = User(name=creator_name,
roles=[UserRole(name=creator_role_name, id=creator_role_id)],
id=doer_id)
with pytest.raises(NotUnique):
repository.update(user)
def test_add_non_unique_user():
creator_id, creator_name, creator_role_id, creator_role_name = creator_
user = User(
name=creator_name,
roles=[UserRole(name=creator_role_name, id=creator_role_id)],
)
with pytest.raises(NotUnique):
repository.save(user, password='******')
def test_users_repository_save():
creator_id, creator_name, creator_role_id, creator_role_name = creator_
user = User(name='user',
roles=[UserRole(name=creator_role_name, id=creator_role_id)])
result = repository.save(user, password='******')
assert result.name == user.name
assert result.roles[0].id == user.roles[0].id
assert result.roles[0].name == user.roles[0].name
assert not hasattr(result, 'password')
assert isinstance(result, DomainModel)
def test_tasks_repository_update_not_existing_task():
task = Task(name='task_name',
content='task_content',
status=TaskStatus(id=1, name='new'),
creator=User(id=1,
name='creator',
roles=[UserRole(id=1, name='creator')]),
doer=None,
id=9)
with pytest.raises(NoResultFound):
repository.update(task)
def test_user_roles_repository_save():
role_name = 'test'
role = UserRole(name=role_name)
result = repository.save(role)
assert result.id == 3
assert result.name == role_name
assert isinstance(result, DomainModel)
result = repository.list()
assert len(result) == 3
def test_get_role_details_action():
role = mock.Mock()
role = UserRole(name='admin', id=1)
roles_repo = mock.Mock()
roles_repo.one.return_value = role
request = GetRoleDetailsRequest(role.id)
action = GetRoleDetailsAction(roles_repo)
response = action.execute(request)
assert bool(response) is True
roles_repo.one.assert_called_once_with(role.id)
assert response.value == role
def list(self, filters=None):
if not filters:
result = self.role_model.query.all()
else:
filters = self._parse_filters(filters)
filters_expression = []
for filter in filters:
key = getattr(self.role_model, filter.key)
filters_expression.append(
getattr(key, filter.operator)(filter.value))
result = self.role_model.query.filter(*filters_expression).all()
return [UserRole(id=role.id, name=role.name) for role in result]
def test_task():
role_creator = UserRole(name='creator')
role_doer = UserRole(name='doer')
task_name = 'example name'
task_content = 'lorem ipsum'
task_status = TaskStatus(name='new', id=1)
task_creator = User(name='creator', roles=[role_creator])
task_doer = User(name='doer', roles=[role_doer])
task_id = 1
task = Task(name=task_name,
content=task_content,
status=task_status,
creator=task_creator,
doer=task_doer,
id=task_id)
assert task.name == task_name
assert task.content == task_content
assert task.status == task_status
assert task.creator == task_creator
assert task.doer == task_doer
assert task.id == task_id
assert isinstance(task, DomainModel)
def test_user_roles_repository_update():
role_id = 1
role_name = 'test'
role_before_update = repository.one(role_id)
role = UserRole(id=role_id, name=role_name)
result = repository.update(role)
assert result.id == role_id
assert result.name == role_name
assert result.name != role_before_update.name
assert isinstance(result, DomainModel)
result = repository.list()
assert len(result) == 2
def test_get_role_details_action_handles_bad_request():
role = mock.Mock()
role = UserRole(name='admin', id=1)
roles_repo = mock.Mock()
roles_repo.one.return_value = role
request = GetRoleDetailsRequest(role_id=None)
action = GetRoleDetailsAction(roles_repo)
response = action.execute(request)
assert bool(response) is False
assert not roles_repo.one.called
assert response.value == {
'type': ResponseFailure.PARAMETER_ERROR,
'message': 'role_id: is required'
}
def save(self, role):
try:
new_role = self.role_model(name=role.name)
self.session.add(new_role)
self.session.commit()
except exc.IntegrityError as e:
self.session.rollback()
if 'unique' in str(e).lower():
raise NotUnique('Role already exist')
raise
except exc.SQLAlchemyError:
self.session.rollback()
raise DbError()
return UserRole(id=new_role.id, name=new_role.name)
def test_add_user_action():
name = 'name'
password = '******'
role_id = 1
roles_repo = mock.Mock()
roles_repo.one.return_value = UserRole(name='role_name')
users_repo = mock.Mock()
users_repo.save.return_value = User(name=name,
roles=[roles_repo.one.return_value])
request = AddUserRequest(name=name, password=password, roles=[role_id])
action = AddUserAction(users_repo, roles_repo)
response = action.execute(request)
assert users_repo.save.called
assert bool(response) is True
assert response.value == users_repo.save.return_value
def delete(self, id):
role_to_delete = self.role_model.query.get(id)
if not role_to_delete:
raise NoResultFound(id, UserRole.__name__)
try:
role = UserRole(id=role_to_delete.id, name=role_to_delete.name)
self.session.delete(role_to_delete)
self.session.commit()
except exc.IntegrityError as e:
self.session.rollback()
if 'foreign' in str(e).lower():
raise CannotBeDeleted('Cannot delete role')
raise
except exc.SQLAlchemyError:
self.session.rollback()
raise DbError()
return role
def update(self, role):
role_to_update = self.role_model.query.get(role.id)
if not role_to_update:
raise NoResultFound(role.id, UserRole.__name__)
try:
role_to_update.name = role.name
self.session.add(role_to_update)
self.session.commit()
except exc.IntegrityError as e:
self.session.rollback()
if 'unique' in str(e).lower():
raise NotUnique('Role already exist')
raise
except exc.SQLAlchemyError:
self.session.rollback()
raise DbError()
return UserRole(id=role_to_update.id, name=role_to_update.name)
def test_get_role_details_action_with_hooks():
role = mock.Mock()
role = UserRole(name='admin', id=1)
roles_repo = mock.Mock()
roles_repo.one.return_value = role
request = GetRoleDetailsRequest(role.id)
action = GetRoleDetailsAction(roles_repo)
before = mock.MagicMock()
after = mock.MagicMock()
action.add_before_execution_hook(before)
action.add_after_execution_hook(after)
response = action.execute(request)
assert before.called
assert after.called
assert bool(response) is True
roles_repo.one.assert_called_once_with(role.id)
assert response.value == role
def test_tasks_repository_save():
task_content = 'test content'
task_name = 'test name'
task = Task(
name=task_name,
content=task_content,
status=TaskStatus(id=1, name='new'),
creator=User(id=1,
name='creator',
roles=[UserRole(id=1, name='creator')]),
doer=None,
)
result = repository.save(task)
assert result.name == task_name
assert result.content == task_content
assert result.status.id == 1
assert result.creator.id == 1
assert result.doer is None
assert isinstance(result, DomainModel)
assert len(repository.list()) == 3
def test_add_user_action_handles_bad_request():
name = None
password = None
role_id = None
roles_repo = mock.Mock()
roles_repo.one.return_value = UserRole(name='role_name')
users_repo = mock.Mock()
users_repo.save.return_value = User(name='name',
roles=[roles_repo.one.return_value])
request = AddUserRequest(name=name, password=password, roles=role_id)
action = AddUserAction(users_repo, roles_repo)
response = action.execute(request)
assert not users_repo.save.called
assert bool(response) is False
assert response.value == {
'message':
'name: is required\npassword: is required\nroles: is required',
'type': ResponseFailure.PARAMETER_ERROR
}
def test_user_roles_repository_save_not_unique_role():
with pytest.raises(NotUnique):
repository.save(UserRole(name='creator_role'))
def test_user_roles_repository_update_not_unique_role():
with pytest.raises(NotUnique):
repository.update(UserRole(id=1, name='doer_role'))
def test_status_repository_update_not_existing_status():
with pytest.raises(NoResultFound):
repository.update(UserRole(id=9, name='asdas'))
