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'))