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_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():
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):
roles = self.roles_repo.list(dict(id__in=request.roles))
user = User(name=request.name, roles=roles)
self._call_before_execution_hooks(dict(request=request, user=user))
response = self.users_repo.save(user, password=request.password)
self._call_after_execution_hooks(dict(request=request, user=response))
return ResponseSuccess(response)
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 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_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_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_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_get_user_details_action():
roles = mock.Mock()
user = User(name='admin', id=1, roles=roles)
users_repo = mock.Mock()
users_repo.one.return_value = user
request = GetUserDetailsRequest(user.id)
action = GetUserDetailsAction(users_repo)
response = action.execute(request)
assert bool(response) is True
users_repo.one.assert_called_once_with(user.id)
assert response.value == user
def test_update_user_action():
id, name = 1, 'name'
users_repo = mock.Mock()
users_repo.update.return_value = User(id=id, name=name, roles=mock.Mock())
request = UpdateUserRequest(id=id, name=name)
action = UpdateUserAction(repo=users_repo)
response = action.execute(request)
assert bool(response) is True
assert users_repo.update.called
assert response.value == users_repo.update.return_value
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_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_update_user_action_handles_bad_requst():
name = 'name'
users_repo = mock.Mock()
users_repo.update.return_value = User(id=id, name=name, roles=mock.Mock())
request = UpdateUserRequest(id=None)
action = UpdateUserAction(repo=users_repo)
response = action.execute(request)
assert bool(response) is False
assert not users_repo.update.called
assert response.value == {
'type': ResponseFailure.PARAMETER_ERROR,
'message': 'id: is required'
}
def test_get_user_details_action_handles_bad_request():
roles = mock.Mock()
user = User(name='admin', id=1, roles=roles)
users_repo = mock.Mock()
users_repo.one.return_value = user
request = GetUserDetailsRequest(user_id=None)
action = GetUserDetailsAction(users_repo)
response = action.execute(request)
assert bool(response) is False
assert not users_repo.one.called
assert response.value == {
'type': ResponseFailure.PARAMETER_ERROR,
'message': 'user_id: is required'
}
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 test_update_user_action_with_hooks():
id, name = 1, 'name'
users_repo = mock.Mock()
users_repo.update.return_value = User(id=id, name=name, roles=mock.Mock())
request = UpdateUserRequest(id=id, name=name)
action = UpdateUserAction(repo=users_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
assert users_repo.update.called
assert response.value == users_repo.update.return_value
def test_get_user_details_action_with_hooks():
roles = mock.Mock()
user = User(name='admin', id=1, roles=roles)
users_repo = mock.Mock()
users_repo.one.return_value = user
request = GetUserDetailsRequest(user.id)
action = GetUserDetailsAction(users_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
users_repo.one.assert_called_once_with(user.id)
assert response.value == user
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 users():
return [
User('name1', roles=mock.Mock()),
User('name2', roles=mock.Mock()),
]
def test_update_user_with_not_existing_role():
user = User(name='asdasdasd', roles=[UserRole(name='asdasd', id=99)], id=1)
with pytest.raises(NoResultFound):
repository.update(user)
import json
from unittest import mock
from sqlalchemy import event
from sqlalchemy.engine import Engine
from collections import namedtuple
from taskplus.core.shared.response import ResponseSuccess
from taskplus.core.domain import User, UserRole
from taskplus.apps.rest.database import Base, db_session, engine
user_name = 'admin'
user = User(name=user_name, id=1, roles=[UserRole(id=1, name='creator')])
users = [user]
def setup_function(function):
user_ = namedtuple('user_', ['id', 'name', 'role_id', 'role_name'])
creator_ = user_(id=1, name='creator', role_id=1, role_name='creator_role')
doer_ = user_(id=2, name='doer', role_id=2, role_name='doer_role')
if db_session.bind.driver == 'pysqlite':
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON")
cursor.close()
with mock.patch('taskplus.apps.rest.models.User._hash_password',
side_effect=lambda x: x):
from taskplus.apps.rest import models
def _to_domain_model(self, data):
permissions = []
for role in data.roles:
if role.name == 'creator':
permissions.append(Permission('ListTasksAction'))
permissions.append(Permission('ListTaskStatusesAction'))
permissions.append(Permission('ListUserRolesAction'))
permissions.append(Permission('AddTaskAction'))
permissions.append(Permission('CancelTaskAction', conditions=[
Condition('task.doer', 'eq', 'None')
]))
permissions.append(Permission('GetTaskDetailsAction'))
permissions.append(Permission('GetRoleDetailsAction'))
permissions.append(Permission('GetTaskStatusDetailsAction'))
permissions.append(Permission('GetUserDetailsAction', conditions=[
Condition('request.user_id', 'eq', 'user.id')
]))
permissions.append(Permission('GetNotCompletedTasksAction'))
permissions.append(
Permission('UpdateTaskAction', conditions=[
Condition('task.creator.id', 'eq', 'user.id')
]))
if role.name == 'doer':
permissions.append(
Permission('CancelTaskAction', conditions=[
Condition('task.doer.id', 'eq', 'user.id')
]))
permissions.append(
Permission('CompleteTaskAction', conditions=[
Condition('task.doer.id', 'eq', 'user.id')
]))
permissions.append(
Permission('AssignUserToTaskAction', conditions=[
Condition('request.user_id', 'eq', 'user.id'),
Condition('task.doer', 'eq', 'None')
]))
permissions.append(
Permission('UnassignUserFromTaskAction', conditions=[
Condition('task.doer.id', 'eq', 'user.id')
]))
permissions.append(Permission('GetUserDetailsAction', conditions=[
Condition('request.user_id', 'eq', 'user.id')
]))
permissions.append(Permission('GetTaskDetailsAction'))
permissions.append(Permission('GetRoleDetailsAction'))
permissions.append(Permission('GetTaskStatusDetailsAction'))
permissions.append(Permission('ListTasksAction'))
permissions.append(Permission('ListTaskStatusesAction'))
permissions.append(Permission('ListUserRolesAction'))
permissions.append(Permission('GetNotCompletedTasksAction'))
if role.name == 'admin':
permissions.append(Permission('AddUserRoleAction'))
permissions.append(Permission('DeleteUserRoleAction'))
permissions.append(Permission('ListUserRolesAction'))
permissions.append(Permission('UpdateUserRoleAction'))
permissions.append(Permission('AddUserAction'))
permissions.append(Permission('ListUsersAction'))
permissions.append(Permission('UpdateUserAction'))
permissions.append(Permission('DeleteUserAction'))
permissions.append(Permission('GetTaskDetailsAction'))
permissions.append(Permission('GetRoleDetailsAction'))
permissions.append(Permission('GetTaskStatusDetailsAction'))
permissions.append(Permission('GetUserDetailsAction'))
permissions.append(Permission('ListTasksAction'))
permissions.append(Permission('ListTaskStatusesAction'))
permissions.append(Permission('AddTaskStatusAction'))
permissions.append(Permission('DeleteTaskStatusAction'))
permissions.append(Permission('UpdateTaskStatusAction'))
permissions.append(Permission('GetNotCompletedTasksAction'))
permissions.append(Permission('UpdateTaskAction'))
return User(
id=data.id,
name=data.name,
roles=[UserRole(id=role.id, name=role.name)
for role in data.roles],
permissions=permissions
)
