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)
class CommunicationPreferenceTestCase(OrchestraModelTestCase):
__test__ = True
model = CommunicationPreferenceFactory
def setUp(self):
# Create a user
self.comm_pref = CommunicationPreferenceFactory()
def test_can_slack(self):
"""
Assert that the object respects the slack bit field settings.
"""
self.assertTrue(self.comm_pref.can_slack())
self.comm_pref.methods.slack = False
self.assertFalse(self.comm_pref.can_slack())
def test_can_email(self):
"""
Assert that the object respects the email bit field settings.
"""
self.assertTrue(self.comm_pref.can_email())
self.comm_pref.methods.email = False
self.assertFalse(self.comm_pref.can_email())
def test_communication_preference_autocreation(self):
"""
When new users register, CommunicationPreferences should be
automatically created .
"""
# Create a user
user = UserFactory(username='******',
password='******',
email='*****@*****.**')
# There should be no preferences yet
self.assertFalse(CommunicationPreference.objects.filter(
worker__user=user).exists())
# Fake registering the user
orchestra_user_registered.send(
sender=self.__class__, user=user, request=None)
# Expect the worker object to be created
self.assertTrue(
CommunicationPreference.objects.filter(worker__user=user).exists(),
'CommunicationPreference not autocreated on User registration'
)
comm_prefs = CommunicationPreference.objects.filter(worker__user=user)
self.assertEqual(comm_prefs.count(), len(
CommunicationPreference.CommunicationType.choices()))
for comm_pref in comm_prefs:
for label, flag in comm_pref.methods.iteritems():
self.assertTrue(flag)
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 _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 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_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 setUp(self):
# Create a user
self.comm_pref = CommunicationPreferenceFactory()