def test_send_staffing_request_priorities(self, mock_slack):
worker2 = WorkerFactory()
WorkerCertificationFactory(worker=worker2, staffing_priority=-1)
CommunicationPreferenceFactory(
worker=worker2,
communication_type=(CommunicationPreference.CommunicationType.
NEW_TASK_AVAILABLE.value))
worker3 = WorkerFactory()
WorkerCertificationFactory(worker=worker3, staffing_priority=1)
CommunicationPreferenceFactory(
worker=worker3,
communication_type=(CommunicationPreference.CommunicationType.
NEW_TASK_AVAILABLE.value))
request = StaffBotRequestFactory()
self.assertEqual(request.status,
StaffBotRequest.Status.PROCESSING.value)
# Workers should be contacted in priority order.
excluded = []
for worker in (worker3, self.worker, worker2):
send_staffing_requests(worker_batch_size=1,
frequency=timedelta(minutes=0))
inquiries = (StaffingRequestInquiry.objects.filter(
request=request).exclude(
communication_preference__worker__in=excluded))
for inquiry in inquiries:
self.assertEqual(worker.id,
inquiry.communication_preference.worker.id)
excluded.append(worker)
def test_is_reviewer(self):
worker = WorkerFactory()
WorkerCertificationFactory(worker=worker,
certification=self.cert,
role=WorkerCertification.Role.ENTRY_LEVEL)
WorkerCertificationFactory(worker=worker,
certification=self.cert,
role=WorkerCertification.Role.REVIEWER)
self.assertTrue(worker.is_reviewer(self.cert))
self.assertTrue(worker.is_entry_level(self.cert))
def test_certification_roles(self):
""" Ensure that workers can be certified at multiple roles. """
certification = CertificationFactory(slug='cat_herding',
name='Cat herding',
workflow=self.workflows['w1'])
WorkerCertificationFactory(certification=certification,
worker=self.workers[0],
role=WorkerCertification.Role.ENTRY_LEVEL)
WorkerCertificationFactory(certification=certification,
worker=self.workers[0],
role=WorkerCertification.Role.REVIEWER)
def test_address_staffing_requests_parameters(self, mock_slack):
for idx in range(5):
worker = WorkerFactory()
CommunicationPreferenceFactory(
worker=worker,
communication_type=(CommunicationPreference.CommunicationType.
NEW_TASK_AVAILABLE.value))
WorkerCertificationFactory(worker=worker,
certification=self.certification)
# Make a new request and turn off the global request, as the
# global one has an inquiry on it already.
request = StaffBotRequestFactory(task__step__is_human=True)
request.task.step.required_certifications.add(self.certification)
self.staffing_request_inquiry.request.status = (
StaffBotRequest.Status.DONE_SENDING_INQUIRIES)
address_staffing_requests(worker_batch_size=1,
frequency=timedelta(minutes=20))
# Inquiries increase by two because we send a Slack and an
# email notification. `last_inquiry_sent` is None on new
# tasks, so we send this batch regardless of frequency.
self.assertEqual(
StaffingRequestInquiry.objects.filter(request=request).count(), 2)
address_staffing_requests(worker_batch_size=2,
frequency=timedelta(minutes=20))
# Don't send more inquiries, since it hasn't been 20 minutes.
self.assertEqual(
StaffingRequestInquiry.objects.filter(request=request).count(), 2)
request.last_inquiry_sent = timezone.now() - timedelta(minutes=21)
request.save()
address_staffing_requests(worker_batch_size=2,
frequency=timedelta(minutes=20))
# Send two email and two slack inquiries since it's been 21 minutes.
self.assertEqual(
StaffingRequestInquiry.objects.filter(request=request).count(), 6)
address_staffing_requests(worker_batch_size=10,
frequency=timedelta(minutes=20))
# Don't send more inquiries, since it hasn't been 20 minutes.
self.assertEqual(
StaffingRequestInquiry.objects.filter(request=request).count(), 6)
request.last_inquiry_sent = timezone.now() - timedelta(minutes=21)
request.save()
address_staffing_requests(worker_batch_size=10,
frequency=timedelta(minutes=20))
# Send remaining inquiries, since enough time has passed.
self.assertEqual(
StaffingRequestInquiry.objects.filter(request=request).count(), 12)
request.last_inquiry_sent = timezone.now() - timedelta(minutes=21)
request.save()
address_staffing_requests(worker_batch_size=10,
frequency=timedelta(minutes=20))
# We're all out of workers to whom we'd like to send inquiries.
self.assertEqual(
StaffingRequestInquiry.objects.filter(request=request).count(), 12)
def setUp(self):
self.workflow_old = WorkflowFactory(
slug='workflow_old',
name='Old workflow',
description='Old workflow to migrate certifications from.',
code_directory='workflow_old')
self.workflow_new = WorkflowFactory(
slug='workflow_new',
name='New workflow',
description='New workflow to migrate certifications from.',
code_directory='workflow_new')
for workflow in (self.workflow_old, self.workflow_new):
# Certifications must exist in both workflows for certification
# to be migrated
CertificationFactory(
slug='certification1',
name='Certification 1',
description='First certification to migrate.',
workflow=workflow)
CertificationFactory(
slug='certification2',
name='Certification 2',
description='Second certification to migrate.',
workflow=workflow)
user = (UserFactory(username='******',
first_name='test',
last_name='test',
password='******',
email='*****@*****.**'))
self.worker = WorkerFactory(user=user)
for certification in self.workflow_old.certifications.all():
# Worker certifications exist only for old workflow
WorkerCertificationFactory(
worker=self.worker,
certification=certification,
role=WorkerCertification.Role.ENTRY_LEVEL)
WorkerCertificationFactory(
worker=self.worker,
certification=certification,
role=WorkerCertification.Role.REVIEWER)
super().setUp()
def test_reviewer_requires_entry_level(self):
""" Workers must have entry-level certification before they review. """
certification = CertificationFactory(slug='cat_herding',
name='Cat herding',
workflow=self.workflows['w1'])
with self.assertRaises(ModelSaveError):
WorkerCertificationFactory(certification=certification,
worker=self.workers[0],
role=WorkerCertification.Role.REVIEWER)
def _create_worker(self, staffing_priority):
worker = WorkerFactory()
WorkerCertificationFactory(worker=worker,
certification=self.certification,
staffing_priority=staffing_priority)
communication_preference = CommunicationPreferenceFactory(
worker=worker,
communication_type=(CommunicationPreference.CommunicationType.
NEW_TASK_AVAILABLE.value))
return worker, communication_preference
def test_send_staffing_requests(self, mock_slack):
worker2 = WorkerFactory()
CommunicationPreferenceFactory(
worker=worker2,
communication_type=(
CommunicationPreference.CommunicationType
.NEW_TASK_AVAILABLE.value))
WorkerCertificationFactory(
worker=worker2,
certification=self.certification
)
request = StaffBotRequestFactory()
request.task.step.required_certifications.add(self.certification)
self.assertEqual(request.status,
StaffBotRequest.Status.SENDING_INQUIRIES.value)
send_staffing_requests(worker_batch_size=1,
frequency=timedelta(minutes=0))
mock_slack.assert_not_called()
request.refresh_from_db()
self.assertEqual(request.status,
StaffBotRequest.Status.SENDING_INQUIRIES.value)
# Inquiries increase by two because we send a Slack and an
# email notification.
self.assertEqual(
StaffingRequestInquiry.objects.filter(request=request).count(),
2)
send_staffing_requests(worker_batch_size=1,
frequency=timedelta(minutes=0))
self.assertEqual(mock_slack.call_count, 1)
mock_slack.reset()
request.refresh_from_db()
self.assertEqual(request.status,
StaffBotRequest.Status.SENDING_INQUIRIES.value)
self.assertEqual(
StaffingRequestInquiry.objects.filter(request=request).count(),
4)
# marked as closed and no new request inquiries sent.
send_staffing_requests(worker_batch_size=1,
frequency=timedelta(minutes=0))
self.assertTrue(mock_slack.called)
request.refresh_from_db()
self.assertEqual(request.status,
StaffBotRequest.Status.DONE_SENDING_INQUIRIES.value)
self.assertEqual(
StaffingRequestInquiry.objects.filter(request=request).count(),
4)
def setUp(self):
self.worker = WorkerFactory()
self.certification = CertificationFactory()
WorkerCertificationFactory(worker=self.worker,
certification=self.certification)
self.staffing_request_inquiry = StaffingRequestInquiryFactory(
communication_preference__worker=self.worker,
communication_preference__communication_type=(
CommunicationPreference.CommunicationType.NEW_TASK_AVAILABLE.
value),
request__task__step__is_human=True)
self.staffing_request_inquiry \
.request.task.step.required_certifications.add(
self.certification)
super().setUp()
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)