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()