def test_staff_task(self, mock_staff, mock_restaff): # Staff a task with no assignment unassigned_task = self.tasks['awaiting_processing'] response = self.api_client.post( reverse( 'orchestra:orchestra:project_management:staff_task'), json.dumps({ 'task_id': unassigned_task.id }), content_type='application/json') self.assertTrue(mock_staff.called) self.assertEqual(response.status_code, 200) is_restaff = load_encoded_json(response.content)['is_restaff'] self.assertFalse(is_restaff) # Restaff a task with an assignment assigned_task = self.tasks['review_task'] response2 = self.api_client.post( reverse( 'orchestra:orchestra:project_management:staff_task'), json.dumps({ 'task_id': assigned_task.id }), content_type='application/json') self.assertTrue(mock_restaff.called) self.assertEqual(response2.status_code, 200) is_restaff2 = load_encoded_json(response2.content)['is_restaff'] self.assertTrue(is_restaff2)
def _test_reverted_task(self, task, iteration, num_iterations, task_status, latest_data, expected_audit, revert_before=False): response = self._revert_task( task, iteration, revert_before=revert_before, commit=False) self.assertEqual(response.status_code, 200) task.refresh_from_db() fake_audit = load_encoded_json(response.content) self.assertEqual(fake_audit, expected_audit) self.assertEqual(task.status, Task.Status.COMPLETE) self.assertEqual(task.assignments.count(), 2) for assignment in task.assignments.all(): self.assertEqual(assignment.iterations.count(), 2) response = self._revert_task( task, iteration, revert_before=revert_before, commit=True) self.assertEqual(response.status_code, 200) task.refresh_from_db() audit = load_encoded_json(response.content) self.assertEqual(audit, fake_audit) task.refresh_from_db() self.assertEqual(task.status, task_status) self.assertEqual( get_iteration_history(task).count(), num_iterations) verify_iterations(task.id) if num_iterations: self.assertEqual( current_assignment(task).in_progress_task_data, latest_data) verify_iterations(task.id)
def _test_reverted_task(self, task, iteration, num_iterations, task_status, latest_data, expected_audit, revert_before=False): response = self._revert_task( task, iteration, revert_before=revert_before, commit=False) self.assertEquals(response.status_code, 200) task.refresh_from_db() fake_audit = load_encoded_json(response.content) self.assertEqual(fake_audit, expected_audit) self.assertEquals(task.status, Task.Status.COMPLETE) self.assertEquals(task.assignments.count(), 2) for assignment in task.assignments.all(): self.assertEquals(assignment.iterations.count(), 2) response = self._revert_task( task, iteration, revert_before=revert_before, commit=True) self.assertEqual(response.status_code, 200) task.refresh_from_db() audit = load_encoded_json(response.content) self.assertEqual(audit, fake_audit) task.refresh_from_db() self.assertEqual(task.status, task_status) self.assertEqual( get_iteration_history(task).count(), num_iterations) verify_iterations(task.id) if num_iterations: self.assertEquals( current_assignment(task).in_progress_task_data, latest_data) verify_iterations(task.id)
def assign_task_api(request): worker_username = load_encoded_json(request.body)['worker_username'] try: worker = Worker.objects.get(user__username=worker_username) task_id = load_encoded_json(request.body)['task_id'] assign_task(worker.id, task_id) except (Worker.DoesNotExist, Task.DoesNotExist, WorkerCertificationError) as e: raise BadRequest(e)
def reassign_assignment_api(request): worker_username = load_encoded_json(request.body)['worker_username'] try: worker = Worker.objects.get(user__username=worker_username) except Worker.DoesNotExist: raise BadRequest('Worker not found for the given username.') assignment_id = load_encoded_json(request.body)['assignment_id'] try: reassign_assignment(worker.id, assignment_id) except (WorkerCertificationError, TaskAssignmentError) as e: raise BadRequest(e)
def test_entry_level_task_assignment(self): response = (self.clients[2].get( '/orchestra/api/interface/new_task_assignment/entry_level/')) # no task available for user3 because no entry-level certification self.assertEquals(response.status_code, 400) returned = load_encoded_json(response.content) self.assertEquals(returned['message'], 'No worker certificates') # user 0 only has certification for entry level tasks response = (self.clients[0].get( '/orchestra/api/interface/new_task_assignment/entry_level/')) self.assertEquals(response.status_code, 200) returned = load_encoded_json(response.content) task = Task.objects.get(id=returned['id']) self.assertEquals({ 'id': task.id, 'assignment_id': task.assignments.get(worker=self.workers[0]).id, 'step': task.step.slug, 'project': task.project.workflow_version.slug, 'detail': task.project.short_description }, returned) # task assignment for invalid id should give bad request self._verify_bad_task_assignment_information( self.clients[0], {'task_id': -1}, 'Task matching query does not exist.') # task assignment for user3 not assigned to a task self._verify_bad_task_assignment_information( self.clients[2], {'task_id': task.id}, 'Worker is not associated with task') # task assignment is assigned to user 0 self._verify_good_task_assignment_information( self.clients[0], {'task_id': task.id}, task.project.short_description, 'Processing', 'Processing', False, False, {}, self.workers[0]) # no more tasks for user 0 left response = (self.clients[0].get( '/orchestra/api/interface/new_task_assignment/entry_level/')) self.assertEquals(response.status_code, 400) returned = load_encoded_json(response.content) self.assertEquals(returned['message'], 'No task')
def test_save_entry_level_task_assignment(self): # user 0 only has certification for entry level tasks response = (self.clients[0].get( '/orchestra/api/interface/new_task_assignment/entry_level/')) self.assertEqual(response.status_code, 200) returned = load_encoded_json(response.content) task = Task.objects.get(id=returned['id']) # incorrect task id response = self.clients[0].post( '/orchestra/api/interface/save_task_assignment/', json.dumps({ 'task_id': -1, 'task_data': 'test' }), content_type='application/json') self.assertEqual(response.status_code, 400) returned = load_encoded_json(response.content) self.assertEqual(returned['message'], 'No task for given id') # user does not have a permission to save response = self.clients[1].post( '/orchestra/api/interface/save_task_assignment/', json.dumps({ 'task_id': task.id, 'task_data': 'test' }), content_type='application/json') self.assertEqual(response.status_code, 400) returned = load_encoded_json(response.content) self.assertEqual(returned['message'], 'Worker is not associated with task') # save new info new_data = {'new_test_key': 'new_test_value'} response = self.clients[0].post( '/orchestra/api/interface/save_task_assignment/', json.dumps({ 'task_id': task.id, 'task_data': new_data }), content_type='application/json') self.assertEqual(response.status_code, 200) self._verify_good_task_assignment_information( self.clients[0], {'task_id': task.id}, task.project.short_description, 'Processing', 'Processing', False, False, new_data, self.workers[0])
def test_entry_level_task_assignment(self): response = (self.clients[2].get( '/orchestra/api/interface/new_task_assignment/entry_level/')) # no task available for user3 because no entry-level certification self.assertEqual(response.status_code, 400) returned = load_encoded_json(response.content) self.assertEqual(returned['message'], 'No worker certificates') # user 0 only has certification for entry level tasks response = (self.clients[0].get( '/orchestra/api/interface/new_task_assignment/entry_level/')) self.assertEqual(response.status_code, 200) returned = load_encoded_json(response.content) task = Task.objects.get(id=returned['id']) self.assertEqual( { 'id': task.id, 'assignment_id': task.assignments.get(worker=self.workers[0]).id, 'step': task.step.slug, 'project': task.project.workflow_version.slug, 'detail': task.project.short_description }, returned) # task assignment for invalid id should give bad request self._verify_bad_task_assignment_information( self.clients[0], {'task_id': -1}, 'Task matching query does not exist.') # task assignment for user3 not assigned to a task self._verify_bad_task_assignment_information( self.clients[2], {'task_id': task.id}, 'Worker is not associated with task') # task assignment is assigned to user 0 self._verify_good_task_assignment_information( self.clients[0], {'task_id': task.id}, task.project.short_description, 'Processing', 'Processing', False, False, {}, self.workers[0]) # no more tasks for user 0 left response = (self.clients[0].get( '/orchestra/api/interface/new_task_assignment/entry_level/')) self.assertEqual(response.status_code, 400) returned = load_encoded_json(response.content) self.assertEqual(returned['message'], 'No task')
def submit_task_assignment(request): assignment_information = load_encoded_json(request.body) worker = Worker.objects.get(user=request.user) command_type = assignment_information['command_type'] if command_type in ('submit', 'accept'): iteration_status = Iteration.Status.REQUESTED_REVIEW elif command_type == 'reject': iteration_status = Iteration.Status.PROVIDED_REVIEW else: raise BadRequest('Illegal command') try: submit_task(assignment_information['task_id'], assignment_information['task_data'], iteration_status, worker) return {} except TaskStatusError: raise BadRequest('Task already completed') except Task.DoesNotExist: raise BadRequest('No task for given id') except IllegalTaskSubmission as e: raise BadRequest(e) except TaskAssignmentError as e: raise BadRequest(e)
def test_project_assignment_recorded_time(self): project = self.projects['base_test_project'] worker = self.workers[0] task = self.tasks['review_task'] assignment = TaskAssignment.objects.filter(worker=worker, task=task).first() other_assignment = get_new_task_assignment( worker, Task.Status.AWAITING_PROCESSING) # create 3 time entries TimeEntry.objects.create(worker=self.workers[0], date=datetime.datetime.now().date(), time_worked=datetime.timedelta(hours=1), assignment=assignment) TimeEntry.objects.create(worker=self.workers[0], date=datetime.datetime.now().date(), time_worked=datetime.timedelta(hours=1), assignment=other_assignment) TimeEntry.objects.create(worker=self.workers[0], date=datetime.datetime.now().date(), time_worked=datetime.timedelta(minutes=15), assignment=assignment) response = self.api_client.post( '/orchestra/api/project/project_information/', {'project_ids': [project.id]}, format='json') returned = load_encoded_json(response.content) returned_task = returned[str(project.id)]['tasks'] returned_assignment = returned_task['step1']['assignments'][0] recorded_time = returned_assignment['recorded_work_time'] self.assertEqual(recorded_time, 105 * 60) # 1:15 + 0:30
def create_subsequent_tasks_api(request): project_id = load_encoded_json(request.body)['project_id'] try: project = Project.objects.get(id=project_id) except Project.DoesNotExist: raise BadRequest('Project not found for the given id.') create_subsequent_tasks(project)
def message_project_team(request): """ Endpoint for sending arbitrary message to a project team. Payload example: {'message': 'Chat message', 'project_id': 'some-id-123'} """ data = load_encoded_json(request.body) try: message = data['message'] project_id = data['project_id'] project = Project.objects.get(id=project_id) except KeyError: text = ('An object with `message` and `project_id` attributes' ' should be supplied') raise BadRequest(text) except Project.DoesNotExist: raise BadRequest('No project for given id') if project.slack_group_id: message_experts_slack_group(project.slack_group_id, message) else: error_message = ( "The following project doesn't have slack_group_id: {}" ).format(project) raise BadRequest(error_message) return {'success': True}
def project_information(request): try: data = load_encoded_json(request.body) project_ids = data['project_ids'] return get_project_information(project_ids) except KeyError: raise BadRequest('project_ids is required')
def create_todos_from_template(request): """ Endpoint for creating todos in a project. Payload example: { 'todolist_template_slug': 'some-template-slug-123', 'step_slug': 'some-step-slug-123', 'project_id': 'some-project-id-123' 'additional_data': { 'some_key': 'some_value' } } """ data = load_encoded_json(request.body) try: todolist_template_slug = data.get('todolist_template_slug') step_slug = data.get('step_slug') project_id = data.get('project_id') additional_data = data.get('additional_data') if step_slug and project_id and todolist_template_slug: add_todolist_template(todolist_template_slug, project_id, step_slug, additional_data) todos = Todo.objects.filter( template__slug=todolist_template_slug, project__id=project_id, step__slug=step_slug).order_by('-created_at') serializer = BulkTodoSerializerWithoutQA(todos, many=True) return {'success': True, 'todos': serializer.data} else: text = ('An object with `template_slug`, `step_slug`,' ' and `project_id` attributes should be supplied') raise Exception(text) except Exception as e: return {'success': False, 'errors': {'error': str(e)}}
def edit_slack_membership_api(request): body = load_encoded_json(request.body) try: project_management.edit_slack_membership( body['project_id'], body['username'], body['action']) except slacker.Error as e: raise BadRequest(e)
def test_update_todos_from_todolist_template_success(self): num_todos = Todo.objects.all().count() update_todos_from_todolist_template_url = \ reverse('orchestra:todos:update_todos_from_todolist_template') todolist_template = TodoListTemplateFactory( slug=self.todolist_template_slug, name=self.todolist_template_name, description=self.todolist_template_description, todos={ 'items': [{ 'id': 1, 'description': 'todo parent', 'project': self.project.id, 'step': self.step.slug, 'items': [{ 'id': 2, 'project': self.project.id, 'step': self.step.slug, 'description': 'todo child', 'items': [] }] }] }, ) resp = self.request_client.post( update_todos_from_todolist_template_url, { 'todolist_template': todolist_template.slug, 'project': self.project.id, 'step': self.step.slug }) self.assertEqual(resp.status_code, 200) self.assertEqual(Todo.objects.all().count(), num_todos + 3) todos = load_encoded_json(resp.content) expected_todos = [ _todo_data('todo child', False, template=todolist_template.id, parent_todo=todos[1]['id'], project=self.project.id, step=self.step.slug), _todo_data('todo parent', False, template=todolist_template.id, parent_todo=todos[2]['id'], project=self.project.id, step=self.step.slug), _todo_data(self.todolist_template_name, False, template=todolist_template.id, project=self.project.id, step=self.step.slug), ] for todo, expected_todo in zip(todos, expected_todos): self._verify_todo_content(todo, expected_todo)
def ensure_response(self, response, expected_json_payload, expected_status_code): self.assertEquals(response.status_code, expected_status_code) returned = load_encoded_json(response.content) self.assertEquals(returned, expected_json_payload)
def _verify_todolist_template_list(self, expected_todolist_templates): resp = self.request_client.get(self.todolist_template_list_url) self.assertEqual(resp.status_code, 200) data = load_encoded_json(resp.content) for todolist_template, expected_todolist_template in \ zip(data, expected_todolist_templates): self._verify_todolist_template_content(todolist_template, expected_todolist_template)
def test_staff_command(self, mock_slack, mock_mail): task = TaskFactory(status=Task.Status.AWAITING_PROCESSING) data = get_mock_slack_data( text='staff {}'.format(task.id), user_id=self.worker.slack_user_id) response = self.request_client.post(self.url, data) self.assertEqual(load_encoded_json(response.content).get('text'), 'Staffed task {}!'.format(task.id)) task = TaskFactory(status=Task.Status.PENDING_REVIEW) data = get_mock_slack_data( text='staff {}'.format(task.id), user_id=self.worker.slack_user_id) response = self.request_client.post(self.url, data) self.assertEqual(load_encoded_json(response.content).get('text'), 'Staffed task {}!'.format(task.id))
def test_staff_command(self, mock_slack, mock_mail): task = TaskFactory(status=Task.Status.AWAITING_PROCESSING) data = get_mock_slack_data(text='staff {}'.format(task.id), user_id=self.worker.slack_user_id) response = self.request_client.post(self.url, data) self.assertEqual( load_encoded_json(response.content)['attachments'][0]['text'], self.staffbot.staffing_success.format(task.id)) task = TaskFactory(status=Task.Status.PENDING_REVIEW) data = get_mock_slack_data(text='staff {}'.format(task.id), user_id=self.worker.slack_user_id) response = self.request_client.post(self.url, data) self.assertEqual( load_encoded_json(response.content)['attachments'][0]['text'], self.staffbot.staffing_success.format(task.id))
def ensure_response(self, response, expected_json_payload, expected_status_code): self.assertEqual(response.status_code, expected_status_code) returned = load_encoded_json(response.content) self.assertEqual(returned, expected_json_payload)
def _check_client_dashboard_state(self, client, non_empty_status): response = client.get('/orchestra/api/interface/dashboard_tasks/') returned = load_encoded_json(response.content) for status, val in returned['tasks'].items(): if status == non_empty_status: self.assertTrue(len(val) > 0) else: self.assertTrue(len(val) == 0)
def test_just_args(self): body = b64encode(create_request_body('the_counter', 2).encode('ascii')) response = self.client.post(self.url, body, content_type='application/json') self.assertEqual(response.status_code, 200) self.assertEqual(load_encoded_json(response.content), {}) self.assertEqual(CALL_COUNTER, 2)
def project_information(request): try: data = load_encoded_json(request.body) project_id = data['project_id'] return get_project_information(project_id) except KeyError: raise BadRequest('project_id is required') except Project.DoesNotExist: raise BadRequest('No project for given id')
def revert_task_api(request): body = load_encoded_json(request.body) try: audit = revert_task_to_iteration(body['task_id'], body['iteration_id'], body.get('revert_before'), body.get('commit')) except Task.DoesNotExist as e: raise BadRequest(e) return audit
def revert_task_api(request): body = load_encoded_json(request.body) try: audit = revert_task_to_iteration( body['task_id'], body['iteration_id'], body.get('revert_before'), body.get('commit')) except Task.DoesNotExist as e: raise BadRequest(e) return audit
def _verify_bad_task_assignment_information(self, client, post_data, error_message): response = client.post( '/orchestra/api/interface/task_assignment_information/', json.dumps(post_data), content_type='application/json') self.assertEqual(response.status_code, 400) returned = load_encoded_json(response.content) self.assertEqual(returned['message'], error_message)
def task_assignment_information(request): try: worker = Worker.objects.get(user=request.user) return get_task_overview_for_worker( load_encoded_json(request.body)['task_id'], worker) except TaskAssignmentError as e: raise BadRequest(e) except Task.DoesNotExist as e: raise BadRequest(e)
def test_save_entry_level_task_assignment(self): # user 0 only has certification for entry level tasks response = (self.clients[0].get( '/orchestra/api/interface/new_task_assignment/entry_level/')) self.assertEquals(response.status_code, 200) returned = load_encoded_json(response.content) task = Task.objects.get(id=returned['id']) # incorrect task id response = self.clients[0].post( '/orchestra/api/interface/save_task_assignment/', json.dumps({'task_id': -1, 'task_data': 'test'}), content_type='application/json') self.assertEquals(response.status_code, 400) returned = load_encoded_json(response.content) self.assertEquals(returned['message'], 'No task for given id') # user does not have a permission to save response = self.clients[1].post( '/orchestra/api/interface/save_task_assignment/', json.dumps({'task_id': task.id, 'task_data': 'test'}), content_type='application/json') self.assertEquals(response.status_code, 400) returned = load_encoded_json(response.content) self.assertEquals(returned['message'], 'Worker is not associated with task') # save new info new_data = {'new_test_key': 'new_test_value'} response = self.clients[0].post( '/orchestra/api/interface/save_task_assignment/', json.dumps({'task_id': task.id, 'task_data': new_data}), content_type='application/json') self.assertEquals(response.status_code, 200) self._verify_good_task_assignment_information( self.clients[0], {'task_id': task.id}, task.project.short_description, 'Processing', 'Processing', False, False, new_data, self.workers[0])
def update_timer(request): worker = Worker.objects.get(user=request.user) try: if request.method == 'POST': data = load_encoded_json(request.body) time_tracking.update_timer( worker, data.get('description'), data.get('assignment')) except Exception as e: logger.error(e, exc_info=True) raise e
def _verify_todos_list(self, project_id, expected_todos, success): resp = self.request_client.get(self.list_create_url, {'project__id': project_id}) if success: self.assertEqual(resp.status_code, 200) data = load_encoded_json(resp.content) for todo, expected_todo in zip(data, expected_todos): self._verify_todo_content(todo, expected_todo) else: self.assertEqual(resp.status_code, 403)
def update_timer(request): worker = Worker.objects.get(user=request.user) try: if request.method == 'POST': data = load_encoded_json(request.body) time_tracking.update_timer(worker, data.get('description'), data.get('assignment')) except Exception as e: logger.error(e, exc_info=True) raise e
def test_no_dispatch(self): response = self.client.post( self.url, b64encode(create_request_body('some_func').encode('ascii')), content_type='application/json') self.assertEqual(response.status_code, 400) self.assertEqual(load_encoded_json(response.content), { 'message': 'No beanstalk dispatch table configured', 'error': 400 })
def test_get_timer(self, mock_get): timer = TaskTimer(worker=self.worker, start_time=timezone.now()) timer.save() resp = self.request_client.get( reverse('orchestra:orchestra:get_timer')) mock_get.assert_called_with(self.worker) data = load_encoded_json(resp.content) expected = TaskTimerSerializer(timer).data expected['time_worked'] = '1:00:00' self.assertEqual(data, expected)
def unarchive_slack_channel_api(request): body = load_encoded_json(request.body) try: project_id = body.get('project_id') project = Project.objects.get(id=project_id) unarchive_project_slack_group(project) except Project.DoesNotExist: raise BadRequest('Project not found for the given id.') except slacker.Error as e: raise BadRequest(e)
def upload_image(request): upload_data = load_encoded_json(request.body) image_type = upload_data['image_type'] image_data = base64.b64decode(upload_data['image_data']) prefix = upload_data.get('prefix') or '' if settings.PRODUCTION: prefix = os.path.join('production', prefix) else: prefix = os.path.join('development', prefix) return {'url': upload_editor_image(image_data, image_type, prefix)}
def test_staff_command(self, mock_slack, mock_mail): task = TaskFactory(status=Task.Status.AWAITING_PROCESSING) data = get_mock_slack_data( text='staff {}'.format(task.id), user_id=self.worker.slack_user_id) response = self.request_client.post(self.url, data) self.assertEqual( load_encoded_json(response.content)['attachments'][0]['text'], self.staffbot.staffing_success.format(task.id)) task = TaskFactory(status=Task.Status.PENDING_REVIEW) data = get_mock_slack_data( text='staff {}'.format(task.id), user_id=self.worker.slack_user_id) response = self.request_client.post(self.url, data) self.assertEqual( load_encoded_json(response.content)['attachments'][0]['text'], self.staffbot.staffing_success.format(task.id))
def _verify_bad_task_assignment_information( self, client, post_data, error_message): response = client.post( '/orchestra/api/interface/task_assignment_information/', json.dumps(post_data), content_type='application/json') self.assertEquals(response.status_code, 400) returned = load_encoded_json(response.content) self.assertEquals(returned['message'], error_message)
def save_task_assignment(request): assignment_information = load_encoded_json(request.body) worker = Worker.objects.get(user=request.user) try: save_task(assignment_information['task_id'], assignment_information['task_data'], worker) return {} except Task.DoesNotExist: raise BadRequest('No task for given id') except TaskAssignmentError as e: raise BadRequest(e)
def test_start_timer(self, mock_start): timer = TaskTimer(worker=self.worker, start_time=self.time) timer.save() mock_start.return_value = timer resp = self.request_client.post( reverse('orchestra:orchestra:start_timer'), data=json.dumps({'assignment': '11'}), content_type='application/json') mock_start.assert_called_with(self.worker, assignment_id='11') data = load_encoded_json(resp.content) serializer = TaskTimerSerializer(timer) self.assertEqual(data, serializer.data)
def test_get_timer(self, mock_get): timer = TaskTimer( worker=self.worker, start_time=timezone.now()) timer.save() resp = self.request_client.get( reverse('orchestra:orchestra:get_timer')) mock_get.assert_called_with(self.worker) data = load_encoded_json(resp.content) expected = TaskTimerSerializer(timer).data expected['time_worked'] = '1:00:00' self.assertEqual(data, expected)
def test_reviewer_task_assignment(self): # there is a review task for user 1 response = (self.clients[1].get( '/orchestra/api/interface/new_task_assignment/reviewer/')) self.assertEquals(response.status_code, 200) returned = load_encoded_json(response.content) self._verify_good_task_assignment_information( self.clients[1], {'task_id': returned['id']}, Task.objects.get(id=returned['id']).project.short_description, 'Processing', 'Reviewing', True, False, {'test_key': 'test_value'}, self.workers[1])
def test_permissions(self): self.api_client.force_authenticate(user=AnonymousUser()) response = self.api_client.post( '/orchestra/api/project/project_information/', {'project_id': 1}, format='json') self.assertEquals(response.status_code, 403) returned = load_encoded_json(response.content) self.assertEquals( returned, {'detail': 'You do not have permission to perform this action.'})
def test_stop_timer(self, mock_stop): time_entry = TimeEntry(worker=self.worker, date=self.time.date(), time_worked=datetime.timedelta(hours=1)) time_entry.save() mock_stop.return_value = time_entry resp = self.request_client.post( reverse('orchestra:orchestra:stop_timer'), data=json.dumps({}), content_type='application/json') mock_stop.assert_called_with(self.worker) data = load_encoded_json(resp.content) serializer = TimeEntrySerializer(time_entry) self.assertEqual(data, serializer.data)
def _make_assign_worker_task_request(self, worker_id, task_id, success=True): response = self.api_client.post( '/orchestra/api/project/assign_worker_to_task/', { 'worker_id': worker_id, 'task_id': task_id, }, format='json') self.assertEquals(response.status_code, 200) data = load_encoded_json(response.content) self.assertEqual(data['success'], success) return data
def test_save_reviewer_task_assignment(self): new_data = {'new_test_key': 'new_test_value'} # get a reviewer task response = (self.clients[1].get( '/orchestra/api/interface/new_task_assignment/reviewer/')) self.assertEquals(response.status_code, 200) returned = load_encoded_json(response.content) task = Task.objects.get(id=returned['id']) # entry level worker can't update the data response = self.clients[0].post( '/orchestra/api/interface/save_task_assignment/', json.dumps({'task_id': task.id, 'task_data': new_data}), content_type='application/json') self.assertEquals(response.status_code, 400) returned = load_encoded_json(response.content) self.assertEquals(returned['message'], 'Worker is not allowed to save') reviewer_data = {'reviewer_key': 'reviewer_value'} # reviewer can update the data response = self.clients[1].post( '/orchestra/api/interface/save_task_assignment/', json.dumps({'task_id': task.id, 'task_data': reviewer_data}), content_type='application/json') self.assertEquals(response.status_code, 200) self._verify_good_task_assignment_information( self.clients[1], {'task_id': task.id}, task.project.short_description, 'Processing', 'Reviewing', True, False, reviewer_data, self.workers[1])
def test_time_entries_post_cannot_set_worker(self): """ Worker is a read-only field and writes to it will be ignored by the serializer. """ worker = Worker.objects.exclude(id=self.worker.id).first() self.time_entry_data['worker'] = worker.id resp = self.request_client.post(self.url, data=json.dumps(self.time_entry_data), content_type='application/json') data = load_encoded_json(resp.content) time_entry = TimeEntry.objects.get(id=data['id']) self.assertNotEqual(time_entry.worker, worker) self.assertEqual(time_entry.worker, self.worker)
def project_details_url(request): project_details = load_encoded_json(request.body) project_id = project_details.get('project_id') if project_id is None: raise BadRequest('project_id parameter is missing') project_details_url = '{}/project/{}'.format( reverse('orchestra:index'), project_id) parsed_url = urlparse(request.build_absolute_uri()) url = urlunsplit((parsed_url.scheme, parsed_url.netloc, project_details_url, '', '')) return {'project_details_url': url}
def test_time_entries_post(self): resp = self.request_client.post(self.url, data=json.dumps(self.time_entry_data), content_type='application/json') data = load_encoded_json(resp.content) time_entry = TimeEntry.objects.get(id=data['id']) self.assertEqual(time_entry.worker, self.worker) self.assertIsNone(time_entry.assignment) self.assertIsNone(time_entry.timer_start_time) self.assertIsNone(time_entry.timer_stop_time) self.assertFalse(time_entry.is_deleted) self.assertEqual(time_entry.description, 'test description') self.assertEqual(time_entry.date, datetime.date(2016, 5, 1)) self.assertEqual(time_entry.time_worked, datetime.timedelta(minutes=30))
def assign_worker_to_task(request): data = load_encoded_json(request.body) errors = {} try: assign_task(data.get('worker_id'), data.get('task_id')) except WorkerCertificationError as e: errors['worker_certification_error'] = str(e) except TaskAssignmentError as e: errors['task_assignment_error'] = str(e) except Exception as e: errors['error'] = str(e) success = len(errors) == 0 return { 'success': success, 'errors': errors, }