Example #1
0
    def test_operate_on_payloads_throws_exception_requeue(
        self,
        mock__validate_record,
        mock_DownloadBase,
    ):
        mock__validate_record.side_effect = [
            self.mock_payload_one, self.mock_payload_two
        ]
        self.mock_payload_two.requeue.side_effect = [Exception('Boom!')]

        response = operate_on_payloads(self.mock_payload_ids,
                                       'test_domain',
                                       'requeue',
                                       False,
                                       task=Mock(),
                                       from_excel=True)
        expected_response = {
            'errors': [
                'Could not perform action for repeat record '
                f'(id={self.mock_payload_two.id}): Boom!'
            ],
            'success': [
                'Successfully requeued repeat record '
                f'(id={self.mock_payload_one.id})'
            ],
        }

        self.assertEqual(mock_DownloadBase.set_progress.call_count, 3)
        self.assertEqual(self.mock_payload_one.requeue.call_count, 1)
        self.assertEqual(self.mock_payload_one.save.call_count, 1)
        self.assertEqual(self.mock_payload_two.requeue.call_count, 1)
        self.assertEqual(self.mock_payload_two.save.call_count, 0)
        self.assertEqual(response, expected_response)
Example #2
0
    def test_operate_on_payloads_throws_exception_requeue(
            self, mock__validate_record, mock_DownloadBase):
        mock__validate_record.side_effect = [
            self.mock_payload_one, self.mock_payload_two
        ]
        self.mock_payload_two.requeue.side_effect = [Exception]

        with patch('corehq.apps.data_interfaces.utils._') as _:
            response = operate_on_payloads(self.mock_payload_ids,
                                           'test_domain',
                                           'requeue',
                                           task=Mock(),
                                           from_excel=True)
            expected_response = {
                'errors': [
                    _("Could not perform action for payload (id={}): {}").
                    format(self.mock_payload_two.id, Exception)
                ],
                'success': [
                    _('Successfully requeue payload (id={})').format(
                        self.mock_payload_one.id)
                ],
            }

        self.assertEqual(mock_DownloadBase.set_progress.call_count, 3)
        self.assertEqual(self.mock_payload_one.requeue.call_count, 1)
        self.assertEqual(self.mock_payload_one.save.call_count, 1)
        self.assertEqual(self.mock_payload_two.requeue.call_count, 1)
        self.assertEqual(self.mock_payload_two.save.call_count, 0)
        self.assertEqual(response, expected_response)
Example #3
0
    def test_operate_on_payloads_with_task_from_excel_false_requeue(
        self,
        mock__validate_record,
        mock_DownloadBase,
    ):
        mock__validate_record.side_effect = [self.mock_payload_one, None]

        response = operate_on_payloads(self.mock_payload_ids,
                                       'test_domain',
                                       'requeue',
                                       False,
                                       task=Mock())
        expected_response = {
            'messages': {
                'errors': [],
                'success': [
                    'Successfully requeued repeat record '
                    f'(id={self.mock_payload_one.id})'
                ],
                'success_count_msg':
                'Successfully performed requeue action '
                'on 1 form(s)',
            }
        }

        self.assertEqual(mock_DownloadBase.set_progress.call_count, 2)
        self._check_requeue(self.mock_payload_one, self.mock_payload_two,
                            response, expected_response)
Example #4
0
def task_operate_on_payloads(payload_ids, domain, action=''):
    task = task_operate_on_payloads

    if not payload_ids:
        return {'messages': {'errors': [_('No Payloads are supplied')]}}

    if not action:
        return {'messages': {'errors': [_('No action specified')]}}

    response = operate_on_payloads(payload_ids, domain, action, task)

    return response
Example #5
0
    def test_operate_on_payloads_no_task_from_excel_true_cancel(
            self, mock__validate_record, mock_DownloadBase):
        mock__validate_record.side_effect = [self.mock_payload_one, None]

        with patch('corehq.apps.data_interfaces.utils._') as _:
            response = operate_on_payloads(self.mock_payload_ids,
                                           'test_domain',
                                           'cancel',
                                           from_excel=True)
            expected_response = {
                'errors': [],
                'success': [
                    _('Successfully cancelled payload (id={})').format(
                        self.mock_payload_one.id)
                ],
            }

        self.assertEqual(mock_DownloadBase.set_progress.call_count, 0)
        self._check_cancel(self.mock_payload_one, self.mock_payload_two,
                           response, expected_response)
Example #6
0
    def test_operate_on_payloads_no_task_from_excel_false_requeue(
            self, mock__validate_record, mock_DownloadBase):
        mock__validate_record.side_effect = [self.mock_payload_one, None]

        with patch('corehq.apps.data_interfaces.utils._') as _:
            response = operate_on_payloads(self.mock_payload_ids,
                                           'test_domain', 'requeue')
            expected_response = {
                'messages': {
                    'errors': [],
                    'success': [
                        _('Successfully requeue payload (id={})').format(
                            self.mock_payload_one.id)
                    ],
                    'success_count_msg':
                    _("Successfully requeue 1 form(s)")
                }
            }

        self.assertEqual(mock_DownloadBase.set_progress.call_count, 0)
        self._check_requeue(self.mock_payload_one, self.mock_payload_two,
                            response, expected_response)
Example #7
0
    def test_operate_on_payloads_no_task_from_excel_true_requeue(
        self,
        mock__validate_record,
        mock_DownloadBase,
    ):
        mock__validate_record.side_effect = [self.mock_payload_one, None]

        response = operate_on_payloads(self.mock_payload_ids,
                                       'test_domain',
                                       'requeue',
                                       False,
                                       from_excel=True)
        expected_response = {
            'errors': [],
            'success': [
                f'Successfully requeued repeat record '
                f'(id={self.mock_payload_one.id})'
            ],
        }

        self.assertEqual(mock_DownloadBase.set_progress.call_count, 0)
        self._check_requeue(self.mock_payload_one, self.mock_payload_two,
                            response, expected_response)