Exemple #1
0
    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)
Exemple #2
0
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)
Exemple #3
0
    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)
Exemple #4
0
 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)
Exemple #6
0
    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)
Exemple #7
0
    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)
Exemple #8
0
    def setUp(self):
        # Create a user

        self.comm_pref = CommunicationPreferenceFactory()