def test_handle_staffing_response_not_is_available(self):
# Test StaffingResponse object creation
old_count = StaffingResponse.objects.all().count()
response = handle_staffing_response(
self.worker, self.staffing_request_inquiry.id,
is_available=False)
self.assertFalse(response.is_winner)
self.assertEqual(StaffingResponse.objects.all().count(), old_count + 1)
# Replay of same request
response = handle_staffing_response(
self.worker, self.staffing_request_inquiry.id,
is_available=False)
self.assertFalse(response.is_winner)
self.assertEqual(StaffingResponse.objects.all().count(), old_count + 1)
# Change mind to `is_available=True`
response = handle_staffing_response(
self.worker, self.staffing_request_inquiry.id,
is_available=True)
self.assertTrue(response.is_winner)
self.assertEqual(StaffingResponse.objects.all().count(), old_count + 1)
# Task is not available to claim
new_request_inquiry = StaffingRequestInquiryFactory(
request=self.staffing_request_inquiry.request,
request__task__step__is_human=True)
new_worker = new_request_inquiry.communication_preference.worker
old_count = StaffingResponse.objects.all().count()
response = handle_staffing_response(
new_worker, new_request_inquiry.id, is_available=True)
self.assertFalse(response.is_winner)
self.assertEqual(StaffingResponse.objects.all().count(), old_count + 1)
def test_handle_staffing_response_invalid_request(self):
old_count = StaffingResponse.objects.all().count()
# Invalid staffing_request_inquiry_id
response = handle_staffing_response(
self.worker, None, is_available=True)
self.assertEqual(response, None)
self.assertEqual(StaffingResponse.objects.all().count(), old_count)
# Invalid worker
response = handle_staffing_response(
None, self.staffing_request_inquiry.id, is_available=True)
self.assertEqual(response, None)
self.assertEqual(StaffingResponse.objects.all().count(), old_count)
def test_handle_staffing_response_invalid_request(self):
old_count = StaffingResponse.objects.all().count()
# Invalid staffing_request_inquiry_id
response = handle_staffing_response(
self.worker, None, is_available=True)
self.assertEqual(response, None)
self.assertEqual(StaffingResponse.objects.all().count(), old_count)
# Invalid worker
response = handle_staffing_response(
None, self.staffing_request_inquiry.id, is_available=True)
self.assertEqual(response, None)
self.assertEqual(StaffingResponse.objects.all().count(), old_count)
def test_handle_staffing_response_not_is_available(self):
# Test StaffingResponse object creation
old_count = StaffingResponse.objects.all().count()
request = self.staffing_request_inquiry.request
new_request_inquiry = StaffingRequestInquiryFactory(request=request)
response = handle_staffing_response(self.worker,
self.staffing_request_inquiry.id,
is_available=False)
self.assertFalse(response.is_winner)
self.assertEqual(response.request_inquiry.request.status,
StaffBotRequest.Status.SENDING_INQUIRIES.value)
self.assertEqual(StaffingResponse.objects.all().count(), old_count + 1)
# Replay of same request
response = handle_staffing_response(self.worker,
self.staffing_request_inquiry.id,
is_available=False)
self.assertFalse(response.is_winner)
self.assertEqual(response.request_inquiry.request.status,
StaffBotRequest.Status.SENDING_INQUIRIES.value)
self.assertEqual(StaffingResponse.objects.all().count(), old_count + 1)
# Change mind to `is_available=True`
response = handle_staffing_response(self.worker,
self.staffing_request_inquiry.id,
is_available=True)
self.assertTrue(response.is_winner)
self.assertEqual(response.request_inquiry.request.status,
StaffBotRequest.Status.CLOSED.value)
self.assertEqual(StaffingResponse.objects.all().count(), old_count + 1)
# Task is not available to claim
new_request_inquiry = StaffingRequestInquiryFactory(
request=self.staffing_request_inquiry.request,
request__task__step__is_human=True)
new_worker = new_request_inquiry.communication_preference.worker
old_count = StaffingResponse.objects.all().count()
response = handle_staffing_response(new_worker,
new_request_inquiry.id,
is_available=True)
self.assertFalse(response.is_winner)
self.assertEqual(response.request_inquiry.request.status,
StaffBotRequest.Status.CLOSED.value)
self.assertEqual(StaffingResponse.objects.all().count(), old_count + 1)
def accept_staffing_request_inquiry(request, staffing_request_inquiry_id):
worker = Worker.objects.get(user=request.user)
response = handle_staffing_response(worker,
staffing_request_inquiry_id,
is_available=True)
if response is None:
raise Http404
return render(request, 'communication/staffing_request_accepted.html', {
'response': response,
})
def accept_staffing_request_inquiry(request,
staffing_request_inquiry_id):
worker = Worker.objects.get(user=request.user)
response = handle_staffing_response(
worker, staffing_request_inquiry_id, is_available=True)
if response is None:
raise Http404
return render(request, 'communication/staffing_request_accepted.html',
{
'response': response,
})
def test_handle_staffing_response_all_rejected(self, mock_slack):
worker2 = WorkerFactory()
CommunicationPreferenceFactory(
worker=worker2,
communication_type=(CommunicationPreference.CommunicationType.
NEW_TASK_AVAILABLE.value))
response = handle_staffing_response(self.worker,
self.staffing_request_inquiry.id,
is_available=False)
self.assertFalse(response.is_winner)
self.assertEqual(response.request_inquiry.request.status,
StaffBotRequest.Status.CLOSED.value)
self.assertEqual(mock_slack.call_count, 1)
mock_slack.reset()
handle_staffing_response(worker2,
self.staffing_request_inquiry.id,
is_available=False)
self.assertEqual(mock_slack.call_count, 1)
def test_handle_staffing_response_all_rejected(self, mock_slack):
worker2 = WorkerFactory()
CommunicationPreferenceFactory(
worker=worker2,
communication_type=(
CommunicationPreference.CommunicationType
.NEW_TASK_AVAILABLE.value))
response = handle_staffing_response(
self.worker, self.staffing_request_inquiry.id,
is_available=False)
self.assertFalse(response.is_winner)
self.assertEqual(response.request_inquiry.request.status,
StaffBotRequest.Status.PROCESSING.value)
mock_slack.assert_not_called()
handle_staffing_response(
worker2, self.staffing_request_inquiry.id,
is_available=False)
self.assertTrue(mock_slack.called)
def test_handle_staffing_response_all_rejected(self, mock_slack):
worker2 = WorkerFactory()
StaffingRequestInquiryFactory(
communication_preference__worker=worker2,
communication_preference__communication_type=(
CommunicationPreference.CommunicationType
.NEW_TASK_AVAILABLE.value),
request__task__step__is_human=True
)
response = handle_staffing_response(
self.worker, self.staffing_request_inquiry.id,
is_available=False)
self.assertFalse(response.is_winner)
mock_slack.assert_not_called()
handle_staffing_response(
worker2, self.staffing_request_inquiry.id,
is_available=False)
self.assertTrue(mock_slack.called)
def reject_staffing_request_inquiry(request,
staffing_request_inquiry_id):
worker = Worker.objects.get(user=request.user)
try:
response = handle_staffing_response(
worker, staffing_request_inquiry_id, is_available=False)
except StaffingResponseException:
return render(request,
'communication/staffing_response_not_permitted.html',
{})
if response is None:
raise Http404
return render(request, 'communication/staffing_request_rejected.html',
{})
def reject_staffing_request_inquiry(request, staffing_request_inquiry_id):
worker = Worker.objects.get(user=request.user)
try:
response = handle_staffing_response(worker,
staffing_request_inquiry_id,
is_available=False)
except StaffingResponseException:
return render(request,
'communication/staffing_response_not_permitted.html', {})
if response is None:
raise Http404
next_path = request.GET.get('next')
if next_path:
return HttpResponseRedirect(next_path)
else:
return render(request, 'communication/staffing_request_rejected.html',
{})
def test_handle_staffing_response_is_available(self):
# Test StaffingResponse object creation
old_count = StaffingResponse.objects.all().count()
# assign task is called
response = handle_staffing_response(self.worker,
self.staffing_request_inquiry.id,
is_available=True)
self.assertTrue(response.is_winner)
self.staffing_request_inquiry.refresh_from_db()
self.assertEqual(response.request_inquiry.request.status,
StaffBotRequest.Status.CLOSED.value)
self.assertEqual(StaffingResponse.objects.all().count(), old_count + 1)
task_assignment = (TaskAssignment.objects.get(
worker=self.worker,
task=self.staffing_request_inquiry.request.task))
self.assertEqual(task_assignment.status,
TaskAssignment.Status.PROCESSING)
self.staffing_request_inquiry.request.task.refresh_from_db()
# Replay of same request
response = handle_staffing_response(self.worker,
self.staffing_request_inquiry.id,
is_available=True)
self.assertTrue(response.is_winner)
self.assertEqual(response.request_inquiry.request.status,
StaffBotRequest.Status.CLOSED.value)
self.assertEqual(StaffingResponse.objects.all().count(), old_count + 1)
# Change mind to `is_available=False` does not do anything
with self.assertRaises(StaffingResponseException):
response = handle_staffing_response(
self.worker,
self.staffing_request_inquiry.id,
is_available=False)
new_request_inquiry = StaffingRequestInquiryFactory(
request__task__step__is_human=True)
new_worker = new_request_inquiry.communication_preference.worker
old_count = StaffingResponse.objects.all().count()
response = handle_staffing_response(new_worker,
new_request_inquiry.id,
is_available=True)
self.assertTrue(response.is_winner)
self.assertEqual(response.request_inquiry.request.status,
StaffBotRequest.Status.CLOSED.value)
self.assertEqual(StaffingResponse.objects.all().count(), old_count + 1)
task_assignment = (TaskAssignment.objects.get(
worker=new_worker, task=new_request_inquiry.request.task))
self.assertEqual(task_assignment.status,
TaskAssignment.Status.PROCESSING)
# restaff
response.is_winner = False
response.save()
worker2 = WorkerFactory()
staffing_request_inquiry2 = StaffingRequestInquiryFactory(
communication_preference__worker=worker2,
request__task=new_request_inquiry.request.task)
response = handle_staffing_response(worker2,
staffing_request_inquiry2.id,
is_available=True)
self.assertTrue(response.is_winner)
self.assertEqual(response.request_inquiry.request.status,
StaffBotRequest.Status.CLOSED.value)
task_assignment.refresh_from_db()
self.assertEqual(task_assignment.worker, worker2)
def test_get_available_request(self, mock_slack):
# Close all open requests so new worker doesn't receive them.
address_staffing_requests(worker_batch_size=2,
frequency=timedelta(minutes=0))
self.assertEqual(len(get_available_requests(self.worker)), 1)
worker2 = WorkerFactory()
CommunicationPreferenceFactory(
worker=worker2,
communication_type=(CommunicationPreference.CommunicationType.
NEW_TASK_AVAILABLE.value))
WorkerCertificationFactory(worker=worker2,
certification=self.certification)
request1 = StaffBotRequestFactory(task__step__is_human=True)
request1.task.step.required_certifications.add(self.certification)
request2 = StaffBotRequestFactory(task__step__is_human=True)
request2.task.step.required_certifications.add(self.certification)
address_staffing_requests(worker_batch_size=2,
frequency=timedelta(minutes=0))
inquiry1 = (StaffingRequestInquiry.objects.filter(
communication_preference__worker=self.worker).filter(
request=request1).first())
inquiry2 = (StaffingRequestInquiry.objects.filter(
communication_preference__worker=worker2).filter(
request=request2).first())
# `self.worker` now has three available tasks, whereas `worker2`
# just has access to the two new tasks.
available_requests = get_available_requests(self.worker)
self.assertEqual(len(available_requests), 3)
self.assertEqual(len(get_available_requests(worker2)), 2)
# Tasks should be sorted by start_datetime in ascending order.
first_available, second_available, third_available = (
available_requests[0]['available_datetime'],
available_requests[1]['available_datetime'],
available_requests[2]['available_datetime'])
self.assertLess(first_available, second_available)
self.assertLess(second_available, third_available)
# `self.worker` will lose an available task (they accept it),
# whereas `worker2` is unchanged.
handle_staffing_response(self.worker,
self.staffing_request_inquiry.id,
is_available=True)
self.assertEqual(len(get_available_requests(self.worker)), 2)
self.assertEqual(len(get_available_requests(worker2)), 2)
# `self.worker` will lose an available task (they ignore it),
# whereas `worker2` is unchanged.
handle_staffing_response(self.worker, inquiry1.id, is_available=False)
self.assertEqual(len(get_available_requests(self.worker)), 1)
self.assertEqual(len(get_available_requests(worker2)), 2)
# `worker2` takes a task.
handle_staffing_response(worker2, inquiry2.id, is_available=True)
self.assertEqual(len(get_available_requests(self.worker)), 0)
self.assertEqual(len(get_available_requests(worker2)), 1)
def test_handle_staffing_response_is_available(self):
# Test StaffingResponse object creation
old_count = StaffingResponse.objects.all().count()
# assign task is called
response = handle_staffing_response(
self.worker, self.staffing_request_inquiry.id,
is_available=True)
self.assertTrue(response.is_winner)
self.assertEqual(response.request_inquiry.request.status,
StaffBotRequest.Status.COMPLETE.value)
self.assertEqual(StaffingResponse.objects.all().count(), old_count + 1)
task_assignment = (
TaskAssignment.objects
.get(worker=self.worker,
task=self.staffing_request_inquiry.request.task))
self.assertEquals(task_assignment.status,
TaskAssignment.Status.PROCESSING)
self.staffing_request_inquiry.request.task.refresh_from_db()
# Replay of same request
response = handle_staffing_response(
self.worker, self.staffing_request_inquiry.id, is_available=True)
self.assertTrue(response.is_winner)
self.assertEqual(response.request_inquiry.request.status,
StaffBotRequest.Status.COMPLETE.value)
self.assertEqual(StaffingResponse.objects.all().count(), old_count + 1)
# Change mind to `is_available=False` does not do anything
with self.assertRaises(StaffingResponseException):
response = handle_staffing_response(
self.worker, self.staffing_request_inquiry.id,
is_available=False)
new_request_inquiry = StaffingRequestInquiryFactory(
request__task__step__is_human=True
)
new_worker = new_request_inquiry.communication_preference.worker
old_count = StaffingResponse.objects.all().count()
response = handle_staffing_response(
new_worker, new_request_inquiry.id, is_available=True)
self.assertTrue(response.is_winner)
self.assertEqual(response.request_inquiry.request.status,
StaffBotRequest.Status.COMPLETE.value)
self.assertEqual(StaffingResponse.objects.all().count(), old_count + 1)
task_assignment = (
TaskAssignment.objects
.get(worker=new_worker,
task=new_request_inquiry.request.task))
self.assertEquals(task_assignment.status,
TaskAssignment.Status.PROCESSING)
# restaff
response.is_winner = False
response.save()
worker2 = WorkerFactory()
staffing_request_inquiry2 = StaffingRequestInquiryFactory(
communication_preference__worker=worker2,
request__task=new_request_inquiry.request.task
)
response = handle_staffing_response(
worker2, staffing_request_inquiry2.id, is_available=True)
self.assertTrue(response.is_winner)
self.assertEqual(response.request_inquiry.request.status,
StaffBotRequest.Status.COMPLETE.value)
task_assignment.refresh_from_db()
self.assertEquals(task_assignment.worker, worker2)
def test_get_available_request(self, mock_slack):
# Complete all open requests so new worker doesn't receive them.
send_staffing_requests(worker_batch_size=2,
frequency=timedelta(minutes=0))
self.assertEquals(len(get_available_requests(self.worker)), 1)
worker2 = WorkerFactory()
CommunicationPreferenceFactory(
worker=worker2,
communication_type=(
CommunicationPreference.CommunicationType
.NEW_TASK_AVAILABLE.value))
request1 = StaffBotRequestFactory(task__step__is_human=True)
request2 = StaffBotRequestFactory(task__step__is_human=True)
send_staffing_requests(worker_batch_size=2,
frequency=timedelta(minutes=0))
inquiry1 = (
StaffingRequestInquiry.objects
.filter(communication_preference__worker=self.worker)
.filter(request=request1).first())
inquiry2 = (
StaffingRequestInquiry.objects
.filter(communication_preference__worker=worker2)
.filter(request=request2).first())
# `self.worker` now has three available tasks, whereas `worker2`
# just has access to the two new tasks.
available_requests = get_available_requests(self.worker)
self.assertEquals(len(available_requests), 3)
self.assertEquals(len(get_available_requests(worker2)), 2)
# Tasks should be sorted by start_datetime in ascending order.
first_task, second_task, third_task = (
available_requests[0]['task'], available_requests[1]['task'],
available_requests[2]['task'])
self.assertLess(
first_task.start_datetime, second_task.start_datetime)
self.assertLess(
second_task.start_datetime, third_task.start_datetime)
# `self.worker` will lose an available task (they accept it),
# whereas `worker2` is unchanged.
handle_staffing_response(
self.worker, self.staffing_request_inquiry.id,
is_available=True)
self.assertEquals(len(get_available_requests(self.worker)), 2)
self.assertEquals(len(get_available_requests(worker2)), 2)
# `self.worker` will lose an available task (they ignore it),
# whereas `worker2` is unchanged.
handle_staffing_response(
self.worker, inquiry1.id,
is_available=False)
self.assertEquals(len(get_available_requests(self.worker)), 1)
self.assertEquals(len(get_available_requests(worker2)), 2)
# `worker2` takes a task.
handle_staffing_response(
worker2, inquiry2.id,
is_available=True)
self.assertEquals(len(get_available_requests(self.worker)), 0)
self.assertEquals(len(get_available_requests(worker2)), 1)
