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 _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 one(self, id):
status = self.status_model.query.get(id)
if not status:
raise NoResultFound(id, TaskStatus.__name__)
return TaskStatus(id=status.id, name=status.name)
def test_task_status_serializer():
status_dict = dict(name='new', id=1)
status = TaskStatus(**status_dict)
expected_json = json.dumps(status_dict)
assert json.loads(json.dumps(status, cls=TaskStatusEncoder)) ==\
json.loads(expected_json)
def process_request(self, request):
new_status = TaskStatus(name=request.name)
self._call_before_execution_hooks(dict(request=request, status=new_status))
response = self.statuses_repo.save(new_status)
self._call_after_execution_hooks(dict(request=request, status=response))
return ResponseSuccess(response)
def test_task_status():
status_id = 1
status_name = 'canceled'
status = TaskStatus(name=status_name, id=status_id)
assert status.id == status_id
assert status.name == status_name
assert isinstance(status, DomainModel)
def test_statuses_repository_update():
id = 1
name = 'suspended'
result = repository.update(TaskStatus(id=id, name=name))
assert isinstance(result, DomainModel)
assert result.id == id
assert result.name == name
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_get_status_details_action():
status = mock.Mock()
status = TaskStatus(name='new', id=1)
statuses_repo = mock.Mock()
statuses_repo.one.return_value = status
request = GetTaskStatusDetailsRequest(status.id)
action = GetTaskStatusDetailsAction(statuses_repo)
response = action.execute(request)
assert bool(response) is True
statuses_repo.one.assert_called_once_with(status.id)
assert response.value == status
def list(self, filters=None):
if not filters:
result = self.status_model.query.all()
else:
filters = self._parse_filters(filters)
filters_expression = []
for filter in filters:
key = getattr(self.status_model, filter.key)
filters_expression.append(
getattr(key, filter.operator)(filter.value))
result = self.status_model.query.filter(*filters_expression).all()
return [TaskStatus(id=status.id, name=status.name) for status in result]
def test_get_status_details_action_handles_bad_request():
status = mock.Mock()
status = TaskStatus(name='new', id=1)
statuses_repo = mock.Mock()
statuses_repo.one.return_value = status
request = GetTaskStatusDetailsRequest(status_id=None)
action = GetTaskStatusDetailsAction(statuses_repo)
response = action.execute(request)
assert bool(response) is False
assert not statuses_repo.one.called
assert response.value == {
'type': ResponseFailure.PARAMETER_ERROR,
'message': 'status_id: is required'
}
def test_tasks_repository_save_with_not_existing_creator():
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=9,
name='creator',
roles=[UserRole(id=1, name='creator')]),
doer=None,
)
with pytest.raises(NoResultFound):
repository.save(task)
def save(self, status):
try:
new_status = self.status_model(name=status.name)
self.session.add(new_status)
self.session.commit()
except exc.IntegrityError as e:
self.session.rollback()
if 'unique' in str(e).lower():
raise NotUnique('Status already exist')
raise
except exc.SQLAlchemyError:
self.session.rollback()
raise DbError()
return TaskStatus(id=new_status.id, name=new_status.name)
def delete(self, id):
status = self.status_model.query.get(id)
if not status:
raise NoResultFound(id, TaskStatus.__name__)
try:
self.session.delete(status)
self.session.commit()
except exc.IntegrityError as e:
self.session.rollback()
if 'foreign' in str(e).lower():
raise CannotBeDeleted('Cannot delete status')
raise
except exc.SQLAlchemyError:
self.session.rollback()
raise DbError()
return TaskStatus(id=id, name=status.name)
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_get_status_details_action_with_hooks():
status = mock.Mock()
status = TaskStatus(name='new', id=1)
statuses_repo = mock.Mock()
statuses_repo.one.return_value = status
request = GetTaskStatusDetailsRequest(status.id)
action = GetTaskStatusDetailsAction(statuses_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
statuses_repo.one.assert_called_once_with(status.id)
assert response.value == status
def update(self, status):
status_to_update = self.status_model.query.get(status.id)
if not status_to_update:
raise NoResultFound(status.id, TaskStatus.__name__)
try:
status_to_update.name = status.name
self.session.add(status_to_update)
self.session.commit()
except exc.IntegrityError as e:
self.session.rollback()
if 'unique' in str(e).lower():
raise NotUnique('Status already exist')
raise
except exc.SQLAlchemyError:
self.session.rollback()
raise DbError()
return TaskStatus(id=status_to_update.id, name=status_to_update.name)
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_status_repository_non_unique_status():
with pytest.raises(NotUnique):
repository.update(TaskStatus(id=1, name='in progress'))
def statuses():
status1 = TaskStatus(name='new')
status2 = TaskStatus(name='canceled')
status3 = TaskStatus(name='completed')
return [status1, status2, status3]
def test_statuses_repository_save_non_unique_status():
with pytest.raises(NotUnique):
repository.save(TaskStatus(name='in progress'))
def test_statuses_repository_save():
status_name = 'suspended'
result = repository.save(TaskStatus(name=status_name))
assert isinstance(result, DomainModel)
assert result.name == status_name
def test_status_repository_update_not_existing_status():
with pytest.raises(NoResultFound):
repository.update(TaskStatus(id=9, name='in progress'))