def process_request(self, request):
self._call_before_execution_hooks(dict(request=request, status=None))
status_id = request.id
status = self.statuses_repo.delete(status_id)
self._call_after_execution_hooks(dict(request=request, status=status))
return ResponseSuccess(status)
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 process_request(self, request):
user_role_id = request.id
self._call_before_execution_hooks(dict(request=request, role=None))
role = self.repo.delete(user_role_id)
self._call_after_execution_hooks(dict(request=request, role=role))
return ResponseSuccess(role)
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 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 process_request(self, request):
role = self.repo.one(id=request.id)
self._call_before_execution_hooks(dict(request=request, role=role))
if request.name:
role.name = request.name
response = self.repo.update(role)
self._call_after_execution_hooks(dict(request=request, role=response))
return ResponseSuccess(response)
def process_request(self, request):
status = self.status_repo.one(Statuses.CANCELED)
task_id = request.task_id
task = self.task_repo.one(task_id)
task.status.id = status.id
self._call_before_execution_hooks(dict(request=request, task=task))
response = self.task_repo.update(task)
self._call_after_execution_hooks(dict(request=request, task=response))
return ResponseSuccess(response)
def process_request(self, request):
task = self.tasks_repository.one(request.id)
self._call_before_execution_hooks(dict(request=request, task=task))
if request.name:
task.name = request.name
if request.content:
task.content = request.content
response = self.tasks_repository.update(task)
self._call_after_execution_hooks(dict(request=request, task=response))
return ResponseSuccess(response)
def process_request(self, request):
task_id = request.task_id
user_id = request.user_id
user = self.users_repo.one(user_id)
task = self.tasks_repo.one(task_id)
self._call_before_execution_hooks(dict(request=request, task=task))
task.doer = user
response = self.tasks_repo.update(task)
self._call_after_execution_hooks(dict(request=request, task=response))
return ResponseSuccess(response)
def test_logout(mock_action, repo, client):
response = ResponseSuccess(users)
mock_action().execute.return_value = response
data = json.dumps(dict(name=user.name, password='******'))
client.post('/auth/login', data=data, content_type='application/json')
http_response = client.get('/auth/logout', content_type='application/json')
assert json.loads(http_response.data.decode('UTF-8')) == {
'message': 'Logged out'
}
assert http_response.status_code == 200
assert http_response.mimetype == 'application/json'
def process_request(self, request):
creator = self.users_repo.one(request.creator_id)
status = self.statuses_repo.one(Statuses.NEW)
task = Task(name=request.name,
content=request.content,
status=status,
creator=creator)
self._call_before_execution_hooks(dict(request=request, task=task))
response = self.tasks_repo.save(task)
self._call_after_execution_hooks(dict(request=request, task=response))
return ResponseSuccess(response)
def test_login_invalid_name(mock_action, repo, client):
response = ResponseSuccess([])
mock_action().execute.return_value = response
data = json.dumps(dict(name=user.name, password='******'))
http_response = client.post('/auth/login',
data=data,
content_type='application/json')
assert json.loads(http_response.data.decode('UTF-8')) == {
'message':
'Login failed. User with name {} not found.'.format(user.name)
}
assert http_response.status_code == 401
assert http_response.mimetype == 'application/json'
def process_request(self, request):
user_id = request.id
user = self.repo.one(user_id)
self._call_before_execution_hooks(dict(request=request, user=user))
if request.name:
user.name = request.name
if request.role_id:
user.role.id = request.role_id
response = self.repo.update(user)
self._call_after_execution_hooks(dict(request=request, user=response))
return ResponseSuccess(response)
def test_login(mock_action, repo, client):
response = ResponseSuccess(users)
mock_action().execute.return_value = response
data = json.dumps(dict(name=user.name, password='******'))
http_response = client.post('/auth/login',
data=data,
content_type='application/json')
assert json.loads(http_response.data.decode('UTF-8')) == {
'name': user.name,
'id': user.id,
'roles': [{
'id': user.roles[0].id,
'name': user.roles[0].name,
}]
}
assert http_response.status_code == 200
assert http_response.mimetype == 'application/json'
def test_response_success_is_true():
assert bool(ResponseSuccess(response_value)) is True
def test_response_success_contains_value(response_value):
response = ResponseSuccess(response_value)
assert response.value == response_value
def process_request(self, request):
self._call_before_execution_hooks(dict(request=request, role=None))
role = self.roles_repo.one(request.role_id)
self._call_after_execution_hooks(dict(request=request, role=role))
return ResponseSuccess(role)
def process_request(self, request):
self._call_before_execution_hooks(dict(request=request, task=None))
task = self.tasks_repo.one(request.task_id)
self._call_after_execution_hooks(dict(request=request, task=task))
return ResponseSuccess(task)
def process_request(self, request):
self._call_before_execution_hooks(dict(request=request, user=None))
user = self.users_repo.one(request.user_id)
self._call_after_execution_hooks(dict(request=request, user=user))
return ResponseSuccess(user)
def process_request(self, request):
self._call_before_execution_hooks(dict(request=request, tasks=None))
response = self.task_repo.list(filters=request.filters)
self._call_after_execution_hooks(dict(request=request, tasks=response))
return ResponseSuccess(response)
def process_request(self, request):
self._call_before_execution_hooks(dict(request=request, statuses=None))
statuses = self.statuses_repo.list(filters=request.filters)
self._call_after_execution_hooks(dict(request=request, statuses=statuses))
return ResponseSuccess(statuses)
