def test_last_submitting_user_recipient(self):
        with create_test_case(self.domain,
                              'person',
                              'Joe',
                              user_id=self.mobile_user.get_id) as case:
            instance = CaseTimedScheduleInstance(
                domain=self.domain,
                case_id=case.case_id,
                recipient_type=CaseScheduleInstanceMixin.
                RECIPIENT_TYPE_LAST_SUBMITTING_USER)
            self.assertTrue(isinstance(instance.recipient, CommCareUser))
            self.assertEqual(instance.recipient.get_id,
                             self.mobile_user.get_id)

        with create_test_case(self.domain,
                              'person',
                              'Joe',
                              user_id=self.web_user.get_id) as case:
            instance = CaseTimedScheduleInstance(
                domain=self.domain,
                case_id=case.case_id,
                recipient_type=CaseScheduleInstanceMixin.
                RECIPIENT_TYPE_LAST_SUBMITTING_USER)
            self.assertTrue(isinstance(instance.recipient, WebUser))
            self.assertEqual(instance.recipient.get_id, self.web_user.get_id)

        with create_test_case(self.domain, 'person', 'Joe',
                              user_id='system') as case:
            instance = CaseTimedScheduleInstance(
                domain=self.domain,
                case_id=case.case_id,
                recipient_type=CaseScheduleInstanceMixin.
                RECIPIENT_TYPE_LAST_SUBMITTING_USER)
            self.assertIsNone(instance.recipient)
Example #2
0
    def test_phone_number_already_in_use(self):
        self.assertEqual(PhoneNumber.count_by_domain(self.domain), 0)

        with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case1, \
                create_test_case(self.domain, 'participant', 'test2', drop_signals=False) as case2:
            case1 = self.set_case_property(case1, 'contact_phone_number',
                                           '99987658765')
            case1 = self.set_case_property(case1,
                                           'contact_phone_number_is_verified',
                                           '1')

            case2 = self.set_case_property(case2, 'contact_phone_number',
                                           '99987698769')
            case2 = self.set_case_property(case2,
                                           'contact_phone_number_is_verified',
                                           '1')

            self.assertIsNotNone(self.get_case_phone_number(case1))
            self.assertIsNotNone(self.get_case_phone_number(case2))
            self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2)

            case2 = self.set_case_property(case2, 'contact_phone_number',
                                           '99987658765')

            self.assertIsNotNone(self.get_case_phone_number(case1))
            self.assertIsNotNone(self.get_case_phone_number(case2))
            self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2)

            self.assertPhoneNumberDetails(case1, '99987658765', None, None,
                                          True, False, True)
            self.assertPhoneNumberDetails(case2, '99987658765', None, None,
                                          False, False, False)
    def test_host_case_owner_location(self):
        with create_test_case(self.domain, 'test-extension-case',
                              'name') as extension_case:
            with create_test_case(self.domain, 'test-host-case',
                                  'name') as host_case:

                update_case(self.domain,
                            host_case.case_id,
                            case_properties={
                                'owner_id': self.city_location.location_id
                            })
                set_parent_case(self.domain,
                                extension_case,
                                host_case,
                                relationship='extension')

                # Test the recipient is returned correctly
                instance = CaseTimedScheduleInstance(
                    domain=self.domain,
                    case_id=extension_case.case_id,
                    recipient_type=CaseScheduleInstanceMixin.
                    RECIPIENT_TYPE_CUSTOM,
                    recipient_id='HOST_CASE_OWNER_LOCATION',
                )
                self.assertIsInstance(instance.recipient, SQLLocation)
                self.assertEqual(instance.recipient.location_id,
                                 self.city_location.location_id)

                # Test location that does not exist
                update_case(self.domain,
                            host_case.case_id,
                            case_properties={'owner_id': 'does-not-exist'})
                instance = CaseTimedScheduleInstance(
                    domain=self.domain,
                    case_id=extension_case.case_id,
                    recipient_type=CaseScheduleInstanceMixin.
                    RECIPIENT_TYPE_CUSTOM,
                    recipient_id='HOST_CASE_OWNER_LOCATION',
                )
                self.assertIsNone(instance.recipient)

                # Test on a case that is not an extension case
                instance = CaseTimedScheduleInstance(
                    domain=self.domain,
                    case_id=host_case.case_id,
                    recipient_type=CaseScheduleInstanceMixin.
                    RECIPIENT_TYPE_CUSTOM,
                    recipient_id='HOST_CASE_OWNER_LOCATION',
                )
                self.assertIsNone(instance.recipient)

                # Test with case id that doesn't exist
                instance = CaseTimedScheduleInstance(
                    domain=self.domain,
                    case_id='does-not-exist',
                    recipient_type=CaseScheduleInstanceMixin.
                    RECIPIENT_TYPE_CUSTOM,
                    recipient_id='HOST_CASE_OWNER_LOCATION',
                )
                self.assertIsNone(instance.recipient)
Example #4
0
    def test_host_case_owner_location_parent(self):
        with create_test_case(self.domain, 'test-extension-case', 'name') as extension_case:
            with create_test_case(self.domain, 'test-host-case', 'name') as host_case:

                update_case(self.domain, host_case.case_id,
                    case_properties={'owner_id': self.city_location.location_id})
                set_parent_case(self.domain, extension_case, host_case, relationship='extension')

                # Test the recipient is returned correctly
                instance = CaseTimedScheduleInstance(
                    domain=self.domain,
                    case_id=extension_case.case_id,
                    recipient_type=CaseScheduleInstanceMixin.RECIPIENT_TYPE_CUSTOM,
                    recipient_id='HOST_CASE_OWNER_LOCATION_PARENT',
                )
                self.assertIsInstance(instance.recipient, SQLLocation)
                self.assertEqual(instance.recipient.location_id, self.state_location.location_id)

                # Test no parent location
                update_case(self.domain, host_case.case_id,
                    case_properties={'owner_id': self.country_location.location_id})
                instance = CaseTimedScheduleInstance(
                    domain=self.domain,
                    case_id=extension_case.case_id,
                    recipient_type=CaseScheduleInstanceMixin.RECIPIENT_TYPE_CUSTOM,
                    recipient_id='HOST_CASE_OWNER_LOCATION_PARENT',
                )
                self.assertIsNone(instance.recipient)

                # Test location that does not exist
                update_case(self.domain, host_case.case_id, case_properties={'owner_id': 'does-not-exist'})
                instance = CaseTimedScheduleInstance(
                    domain=self.domain,
                    case_id=extension_case.case_id,
                    recipient_type=CaseScheduleInstanceMixin.RECIPIENT_TYPE_CUSTOM,
                    recipient_id='HOST_CASE_OWNER_LOCATION_PARENT',
                )
                self.assertIsNone(instance.recipient)

                # Test on a case that is not an extension case
                instance = CaseTimedScheduleInstance(
                    domain=self.domain,
                    case_id=host_case.case_id,
                    recipient_type=CaseScheduleInstanceMixin.RECIPIENT_TYPE_CUSTOM,
                    recipient_id='HOST_CASE_OWNER_LOCATION_PARENT',
                )
                self.assertIsNone(instance.recipient)

                # Test with case id that doesn't exist
                instance = CaseTimedScheduleInstance(
                    domain=self.domain,
                    case_id='does-not-exist',
                    recipient_type=CaseScheduleInstanceMixin.RECIPIENT_TYPE_CUSTOM,
                    recipient_id='HOST_CASE_OWNER_LOCATION_PARENT',
                )
                self.assertIsNone(instance.recipient)
Example #5
0
    def test_parent_case_property_criteria(self):
        reminder = (CaseReminderHandler
            .create(self.domain, 'test')
            .set_case_criteria_start_condition('participant', 'parent/status', MATCH_EXACT, 'green')
            .set_case_criteria_start_date()
            .set_case_recipient()
            .set_sms_content_type('en')
            .set_daily_schedule(fire_time=time(12, 0),
                message={'en': 'Hello {case.name}, your test result was normal.'})
            .set_stop_condition(max_iteration_count=REPEAT_SCHEDULE_INDEFINITELY)
            .set_advanced_options())
        reminder.active = False
        reminder.save()

        self.assertEqual(self.get_reminders(), [])

        with create_test_case(self.domain, 'participant', 'bob', drop_signals=False) as child_case, \
                create_test_case(self.domain, 'parent-case', 'jim', drop_signals=False) as parent_case, \
                patch('corehq.apps.reminders.models.CaseReminderHandler.get_now') as now_mock:
            process_handlers_for_case_changed(self.domain, child_case.case_id, [reminder._id])
            self.assertEqual(self.get_reminders(), [])

            set_parent_case(self.domain, child_case, parent_case)
            process_handlers_for_case_changed(self.domain, child_case.case_id, [reminder._id])
            self.assertEqual(self.get_reminders(), [])

            now_mock.return_value = datetime(2016, 1, 1, 10, 0)
            update_case(self.domain, child_case.case_id, case_properties={'status': 'green'})
            self.assertEqual(self.get_reminders(), [])

            update_case(self.domain, child_case.case_id, case_properties={'status': ''})
            self.assertEqual(self.get_reminders(), [])

            update_case(self.domain, parent_case.case_id, case_properties={'status': 'green'})
            process_handlers_for_case_changed(self.domain, child_case.case_id, [reminder._id])
            reminder_instance = self.assertOneReminder()
            self.assertEqual(reminder_instance.domain, self.domain)
            self.assertEqual(reminder_instance.handler_id, reminder.get_id)
            self.assertFalse(reminder_instance.active)
            self.assertEqual(reminder_instance.start_date, date(2016, 1, 1))
            self.assertIsNone(reminder_instance.start_condition_datetime)
            self.assertEqual(reminder_instance.next_fire, datetime(2016, 1, 1, 12, 0))
            self.assertEqual(reminder_instance.case_id, child_case.case_id)
            self.assertEqual(reminder_instance.schedule_iteration_num, 1)
            self.assertEqual(reminder_instance.current_event_sequence_num, 0)
            self.assertEqual(reminder_instance.callback_try_count, 0)

            update_case(self.domain, parent_case.case_id, case_properties={'status': 'red'})
            process_handlers_for_case_changed(self.domain, child_case.case_id, [reminder._id])
            self.assertEqual(self.get_reminders(), [])
    def test_modified_by_template_params(self):
        with self.create_parent_case(modified_by=self.mobile_user,
                                     owner=self.location) as case:
            expected_result = {'case': case.to_json()}
            expected_result['case'][
                'owner'] = self.get_expected_template_params_for_location()
            expected_result['case'][
                'last_modified_by'] = self.get_expected_template_params_for_mobile(
                )
            self.assertEqual(get_message_template_params(case),
                             expected_result)

        with self.create_parent_case(modified_by=self.web_user,
                                     owner=self.location) as case:
            expected_result = {'case': case.to_json()}
            expected_result['case'][
                'owner'] = self.get_expected_template_params_for_location()
            expected_result['case'][
                'last_modified_by'] = self.get_expected_template_params_for_web(
                )
            self.assertEqual(get_message_template_params(case),
                             expected_result)

        with create_test_case(self.domain,
                              'person',
                              'Joe',
                              owner_id=self.location.location_id,
                              user_id='system') as case:
            expected_result = {'case': case.to_json()}
            expected_result['case'][
                'owner'] = self.get_expected_template_params_for_location()
            expected_result['case'][
                'last_modified_by'] = _get_system_user_template_info()
            self.assertEqual(get_message_template_params(case),
                             expected_result)
    def test_phone_number_already_in_use(self):
        with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case1, \
                create_test_case(self.domain, 'participant', 'test2', drop_signals=False) as case2:
            case1 = self.set_case_property(case1, 'contact_phone_number', '99987658765')
            case1 = self.set_case_property(case1, 'contact_phone_number_is_verified', '1')

            case2 = self.set_case_property(case2, 'contact_phone_number', '99987698769')
            case2 = self.set_case_property(case2, 'contact_phone_number_is_verified', '1')

            self.assertIsNotNone(self.get_case_verified_number(case1))
            self.assertIsNotNone(self.get_case_verified_number(case2))

            case2 = self.set_case_property(case2, 'contact_phone_number', '99987658765')

            self.assertIsNotNone(self.get_case_verified_number(case1))
            self.assertIsNone(self.get_case_verified_number(case2))
    def test_case_phone_number_updates(self):
        with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case:
            self.assertIsNone(self.get_case_verified_number(case))

            case = self.set_case_property(case, 'contact_phone_number', '99987658765')
            self.assertIsNone(self.get_case_verified_number(case))

            case = self.set_case_property(case, 'contact_phone_number_is_verified', '1')
            self.assertPhoneNumberDetails(case, '99987658765', None, None)
            pk = self.get_case_verified_number(case).pk

            case = self.set_case_property(case, 'contact_phone_number', '99987698769')
            self.assertPhoneNumberDetails(case, '99987698769', None, None, pk=pk)

            case = self.set_case_property(case, 'contact_backend_id', 'sms-backend')
            self.assertPhoneNumberDetails(case, '99987698769', 'sms-backend', None, pk=pk)

            case = self.set_case_property(case, 'contact_ivr_backend_id', 'ivr-backend')
            self.assertPhoneNumberDetails(case, '99987698769', 'sms-backend', 'ivr-backend', pk=pk)

            # If nothing changes, the phone entry should not be saved
            with patch('corehq.apps.sms.models.PhoneNumber.save') as mock_save:
                case = self.set_case_property(case, 'abc', 'def')
                mock_save.assert_not_called()

            # If phone entry is ahead of the case in terms of contact_last_modified, no update should happen
            v = self.get_case_verified_number(case)
            v.contact_last_modified += timedelta(days=1)
            v.save()

            with patch('corehq.apps.sms.models.PhoneNumber.save') as mock_save:
                case = self.set_case_property(case, 'contact_phone_number', '99912341234')
                mock_save.assert_not_called()
Example #9
0
 def test_case_owner(self):
     with create_test_case(self.domain, 'participant', 'test') as case:
         number = PhoneNumber(owner_doc_type='CommCareCase',
                              owner_id=case.case_id)
         owner = number.owner
         self.assertTrue(is_commcarecase(owner))
         self.assertEqual(owner.case_id, case.case_id)
Example #10
0
 def test_correct_message(self):
     self._setup_fixture_type()
     with create_test_case(self.domain_name, self.case_type, 'test-case',
                           {'risk_profile': 'risk1'}) as case:
         self.assertEqual(
             ucla_message_bank_content(self._reminder(), self._handler(),
                                       case), 'message1')
Example #11
0
    def test_passing_case_without_risk_profile_new(self):
        self._setup_fixture_type()
        with create_test_case(self.domain_name, self.case_type, 'test-case') as case:
            with self.assertRaises(AssertionError) as e:
                self._get_current_event_messages(self._schedule_instance(case))

            self.assertIn('does not include risk_profile', str(e.exception))
Example #12
0
 def test_correct_message_new(self):
     self._setup_fixture_type()
     with create_test_case(self.domain_name, self.case_type, 'test-case', {'risk_profile': 'risk1'}) as case:
         self.assertEqual(
             self._get_current_event_messages(self._schedule_instance(case)),
             ['message1']
         )
Example #13
0
    def test_case_type_mismatch(self):
        reminder = (CaseReminderHandler
            .create(self.domain, 'test')
            .set_case_criteria_start_condition('participant', 'status', MATCH_EXACT, 'green')
            .set_case_criteria_start_date()
            .set_case_recipient()
            .set_sms_content_type('en')
            .set_daily_schedule(fire_time=time(12, 0),
                message={'en': 'Hello {case.name}, your test result was normal.'})
            .set_stop_condition(max_iteration_count=REPEAT_SCHEDULE_INDEFINITELY)
            .set_advanced_options())
        reminder.save()

        self.assertEqual(self.get_reminders(), [])

        with create_test_case(self.domain, 'ex-participant', 'bob', drop_signals=False) as case, \
                patch('corehq.apps.reminders.models.CaseReminderHandler.get_now') as now_mock:
            self.assertEqual(self.get_reminders(), [])

            now_mock.return_value = datetime(2016, 1, 1, 10, 0)
            update_case(self.domain, case.case_id, case_properties={'status': 'green'})
            self.assertEqual(self.get_reminders(), [])

            reminder.case_changed(case)
            self.assertEqual(self.get_reminders(), [])
Example #14
0
    def test_recipient_case_owner_location_parent(self):
        with create_test_case(self.domain,
                              'test-case',
                              'test-name',
                              owner_id=self.user.get_id) as case:
            self.assertEqual(case.owner_id, self.user.get_id)

            def instance(case_id=''):
                # recipient is memoized
                return CaseTimedScheduleInstance(
                    domain=self.domain,
                    case_id=case_id or case.case_id,
                    recipient_type='CustomRecipient',
                    recipient_id='CASE_OWNER_LOCATION_PARENT')

            # Test the recipient is returned correctly
            self.assertTrue(isinstance(instance().recipient, SQLLocation))
            self.assertEqual(instance().recipient.pk, self.parent_location.pk)

            # Test when the user's location has no parent location
            self.user.set_location(self.parent_location)
            self.assertIsNone(instance().recipient)

            # Remove child location
            self.user.unset_location()
            self.assertIsNone(instance().recipient)

            # Remove case
            self.assertIsNone(instance(case_id='does-not-exist').recipient)
    def test_case_time_zone(self):
        reminder = (CaseReminderHandler
            .create(self.domain, 'test')
            .set_case_criteria_start_condition('participant', 'status', MATCH_EXACT, 'green')
            .set_case_criteria_start_date()
            .set_case_recipient()
            .set_sms_content_type('en')
            .set_daily_schedule(fire_time=time(12, 0),
                message={'en': 'Hello {case.name}, your test result was normal.'})
            .set_stop_condition(max_iteration_count=REPEAT_SCHEDULE_INDEFINITELY)
            .set_advanced_options())
        reminder.save()

        self.assertEqual(self.get_reminders(), [])

        with create_test_case(self.domain, 'participant', 'bob', drop_signals=False) as case, \
                patch('corehq.apps.reminders.models.CaseReminderHandler.get_now') as now_mock:
            self.assertEqual(self.get_reminders(), [])

            now_mock.return_value = datetime(2016, 1, 1, 10, 0)
            update_case(self.domain, case.case_id,
                case_properties={'status': 'green', 'time_zone': 'America/New_York'})

            reminder_instance = self.assertOneReminder()
            self.assertEqual(reminder_instance.domain, self.domain)
            self.assertEqual(reminder_instance.handler_id, reminder.get_id)
            self.assertTrue(reminder_instance.active)
            self.assertEqual(reminder_instance.start_date, date(2016, 1, 1))
            self.assertIsNone(reminder_instance.start_condition_datetime)
            self.assertEqual(reminder_instance.next_fire, datetime(2016, 1, 1, 17, 0))
            self.assertEqual(reminder_instance.case_id, case.case_id)
            self.assertEqual(reminder_instance.schedule_iteration_num, 1)
            self.assertEqual(reminder_instance.current_event_sequence_num, 0)
            self.assertEqual(reminder_instance.callback_try_count, 0)
Example #16
0
 def test_no_relevant_message_invalid_risk(self):
     self._setup_fixture_type()
     with create_test_case(self.domain_name, self.case_type, 'test-case',
                           {'risk_profile': 'risk2'}) as case:
         self.assertRaises(AssertionError,
                           general_health_message_bank_content,
                           self._reminder(), self._handler(), case)
Example #17
0
 def test_passing_case_without_risk_profile(self):
     self._setup_fixture_type()
     with create_test_case(self.domain_name, self.case_type,
                           'test-case') as case:
         self.assertRaises(AssertionError,
                           general_health_message_bank_content,
                           self._reminder(), self._handler(), case)
Example #18
0
    def test_no_relevant_message_invalid_seq_num_new(self):
        self._setup_fixture_type()
        with create_test_case(self.domain_name, self.case_type, 'test-case', {'risk_profile': 'risk1'}) as case:
            with self.assertRaises(AssertionError) as e:
                self._get_current_event_messages(self._schedule_instance(case, iteration_num=2))

            self.assertIn('No message for case', str(e.exception))
Example #19
0
    def test_multiple_entries(self):
        extra_number = PhoneNumber.objects.create(domain=self.domain,
                                                  owner_doc_type='X',
                                                  owner_id='X',
                                                  phone_number='999124',
                                                  verified=False,
                                                  pending_verification=False,
                                                  is_two_way=False)

        with create_test_case(self.domain,
                              'participant',
                              'test1',
                              drop_signals=False) as case:
            case = self.set_case_property(case, 'contact_phone_number',
                                          '999124')
            case = self.set_case_property(case,
                                          'contact_phone_number_is_verified',
                                          '1')
            case.create_phone_entry('999125')
            self.assertEqual(PhoneNumber.objects.count(), 3)

            sync_case_phone_number(case)
            self.assertEqual(PhoneNumber.objects.count(), 2)

            number1 = PhoneNumber.objects.get(pk=extra_number.pk)
            self.assertEqual(number1.owner_id, 'X')

            number2 = PhoneNumber.objects.get(owner_id=case.case_id)
            self.assertTrue(number2.verified)
            self.assertTrue(number2.is_two_way)
            self.assertFalse(number2.pending_verification)
Example #20
0
    def test_case_soft_delete(self):
        extra_number = PhoneNumber.objects.create(domain=self.domain,
                                                  owner_doc_type='X',
                                                  owner_id='X',
                                                  phone_number='999123',
                                                  verified=True,
                                                  pending_verification=False,
                                                  is_two_way=True)
        self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1)

        with create_test_case(self.domain,
                              'participant',
                              'test1',
                              drop_signals=False) as case:
            case = self.set_case_property(case, 'contact_phone_number',
                                          '99987658765')
            case = self.set_case_property(case,
                                          'contact_phone_number_is_verified',
                                          '1')
            self.assertIsNotNone(self.get_case_phone_number(case))
            self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2)

            tag_cases_as_deleted_and_remove_indices(self.domain,
                                                    [case.case_id], '123',
                                                    datetime.utcnow())
            self.assertIsNone(self.get_case_phone_number(case))
            self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1)
Example #21
0
 def test_is_contact_active_for_case(self):
     with create_test_case(self.domain, 'contact', 'test-case') as case:
         self.assertTrue(
             is_contact_active(self.domain, 'CommCareCase', case.case_id))
         update_case(self.domain, case.case_id, close=True)
         self.assertFalse(
             is_contact_active(self.domain, 'CommCareCase', case.case_id))
Example #22
0
 def test_no_relevant_message_invalid_seq_num(self):
     self._setup_fixture_type()
     with create_test_case(self.domain_name, self.case_type, 'test-case',
                           {'risk_profile': 'risk1'}) as case:
         self.assertRaises(AssertionError, ucla_message_bank_content,
                           self._reminder(iteration_num=2), self._handler(),
                           case)
Example #23
0
    def test_invalid_phone_format(self):
        extra_number = PhoneNumber.objects.create(domain=self.domain,
                                                  owner_doc_type='X',
                                                  owner_id='X',
                                                  phone_number='999123',
                                                  verified=True,
                                                  pending_verification=False,
                                                  is_two_way=True)
        self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1)

        with create_test_case(self.domain,
                              'participant',
                              'test1',
                              drop_signals=False) as case:
            case = self.set_case_property(case, 'contact_phone_number',
                                          '99987658765')
            case = self.set_case_property(case,
                                          'contact_phone_number_is_verified',
                                          '1')
            self.assertIsNotNone(self.get_case_phone_number(case))
            self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2)

            case = self.set_case_property(case, 'contact_phone_number', 'xyz')
            self.assertIsNone(self.get_case_phone_number(case))
            self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1)
Example #24
0
    def test_modified_by_template_params(self):
        r = MessagingTemplateRenderer()

        with self.create_parent_case(modified_by=self.mobile_user) as case:
            r.set_context_param('case', CaseMessagingTemplateParam(case))
            self.assertEqual(r.render("Name: {case.last_modified_by.name}"), "Name: mobile1")
            self.assertEqual(r.render("First Name: {case.last_modified_by.first_name}"), "First Name: Mobile")
            self.assertEqual(r.render("Last Name: {case.last_modified_by.last_name}"), "Last Name: User")
            self.assertEqual(r.render("Phone: {case.last_modified_by.phone_number}"), "Phone: 999123")
            self.assertEqual(r.render("Unknown: {case.last_modified_by.unknown}"), "Unknown: (?)")
            self.assertEqual(r.render("Unknown: {case.last_modified_by.unknown.unknown}"), "Unknown: (?)")

        with self.create_parent_case(modified_by=self.web_user) as case:
            r.set_context_param('case', CaseMessagingTemplateParam(case))
            self.assertEqual(r.render("Name: {case.last_modified_by.name}"), "Name: web1@templating-test")
            self.assertEqual(r.render("First Name: {case.last_modified_by.first_name}"), "First Name: Web")
            self.assertEqual(r.render("Last Name: {case.last_modified_by.last_name}"), "Last Name: User")
            self.assertEqual(r.render("Phone: {case.last_modified_by.phone_number}"), "Phone: 999456")
            self.assertEqual(r.render("Unknown: {case.last_modified_by.unknown}"), "Unknown: (?)")
            self.assertEqual(r.render("Unknown: {case.last_modified_by.unknown.unknown}"), "Unknown: (?)")

        with create_test_case(self.domain, 'person', 'Joe', user_id='system') as case:
            r.set_context_param('case', CaseMessagingTemplateParam(case))
            self.assertEqual(r.render("Name: {case.last_modified_by.name}"), "Name: System")
            self.assertEqual(r.render("First Name: {case.last_modified_by.first_name}"), "First Name: System")
            self.assertEqual(r.render("Last Name: {case.last_modified_by.last_name}"), "Last Name: ")
            self.assertEqual(r.render("Phone: {case.last_modified_by.phone_number}"), "Phone: ")
            self.assertEqual(r.render("Unknown: {case.last_modified_by.unknown}"), "Unknown: (?)")
            self.assertEqual(r.render("Unknown: {case.last_modified_by.unknown.unknown}"), "Unknown: (?)")
Example #25
0
 def test_multiple_relevant_messages(self):
     self._setup_fixture_type()
     self._setup_data_item('risk1', '1', 'message2')
     with create_test_case(self.domain_name, self.case_type, 'test-case',
                           {'risk_profile': 'risk1'}) as case:
         self.assertRaises(AssertionError, ucla_message_bank_content,
                           self._reminder(), self._handler(), case)
    def test_recipient_case_owner_location_parent(self):
        with create_test_case(self.domain, 'test-case', 'test-name', owner_id=self.user.get_id) as case:
            self.assertEqual(case.owner_id, self.user.get_id)

            def instance(case_id=''):
                # recipient is memoized
                return CaseTimedScheduleInstance(
                    domain=self.domain,
                    case_id=case_id or case.case_id,
                    recipient_type='CustomRecipient',
                    recipient_id='CASE_OWNER_LOCATION_PARENT'
                )

            # Test the recipient is returned correctly
            self.assertTrue(isinstance(instance().recipient, SQLLocation))
            self.assertEqual(instance().recipient.pk, self.parent_location.pk)

            # Test when the user's location has no parent location
            self.user.set_location(self.parent_location)
            self.assertIsNone(instance().recipient)

            # Remove child location
            self.user.unset_location()
            self.assertIsNone(instance().recipient)

            # Remove case
            self.assertIsNone(instance(case_id='does-not-exist').recipient)
Example #27
0
    def test_user_recipient(self):
        reminder = (CaseReminderHandler
            .create(self.domain, 'test')
            .set_case_criteria_start_condition('participant', 'status', MATCH_EXACT, 'green')
            .set_case_criteria_start_date()
            .set_last_submitting_user_recipient()
            .set_sms_content_type('en')
            .set_daily_schedule(fire_time=time(12, 0), message={'en': "{case.name}'s test result was normal."})
            .set_stop_condition(max_iteration_count=REPEAT_SCHEDULE_INDEFINITELY)
            .set_advanced_options())
        reminder.save()

        self.assertEqual(self.get_reminders(), [])

        with create_test_case(self.domain, 'participant', 'bob', drop_signals=False) as case, \
                patch('corehq.apps.reminders.models.CaseReminderHandler.get_now') as now_mock:
            self.assertEqual(self.get_reminders(), [])

            now_mock.return_value = datetime(2016, 1, 1, 10, 0)

            # There should still be no reminder instance since this is submitted by the system user
            update_case(self.domain, case.case_id, case_properties={'status': 'green'})
            self.assertEqual(self.get_reminders(), [])

            # Update the user id on the case
            CaseFactory(self.domain).create_or_update_case(
                CaseStructure(
                    case_id=case.case_id,
                    attrs={'user_id': self.user.get_id}
                )
            )

            reminder_instance = self.assertOneReminder()
Example #28
0
 def create_case(self):
     case_properties = {
         'contact_phone_number': self.phone_number,
         'contact_phone_number_is_verified': '1',
     }
     return create_test_case(self.domain, 'contact', 'test',
         case_properties=case_properties, drop_signals=False)
Example #29
0
    def test_case_property_reminder_time(self):
        reminder = (CaseReminderHandler
            .create(self.domain, 'test')
            .set_case_criteria_start_condition('participant', 'status', MATCH_EXACT, 'green')
            .set_case_criteria_start_date()
            .set_case_recipient()
            .set_sms_content_type('en')
            .set_daily_schedule(fire_time='preferred_time', fire_time_type=FIRE_TIME_CASE_PROPERTY,
                message={'en': 'Hello {case.name}, your test result was normal.'})
            .set_stop_condition(max_iteration_count=REPEAT_SCHEDULE_INDEFINITELY)
            .set_advanced_options())
        reminder.save()

        self.assertEqual(self.get_reminders(), [])

        with create_test_case(self.domain, 'participant', 'bob', drop_signals=False) as case, \
                patch('corehq.apps.reminders.models.CaseReminderHandler.get_now') as now_mock:
            self.assertEqual(self.get_reminders(), [])

            now_mock.return_value = datetime(2016, 1, 1, 10, 0)
            update_case(self.domain, case.case_id,
                case_properties={'status': 'green', 'preferred_time': '14:00:00'})

            reminder_instance = self.assertOneReminder()
            self.assertEqual(reminder_instance.domain, self.domain)
            self.assertEqual(reminder_instance.handler_id, reminder.get_id)
            self.assertTrue(reminder_instance.active)
            self.assertEqual(reminder_instance.start_date, date(2016, 1, 1))
            self.assertIsNone(reminder_instance.start_condition_datetime)
            self.assertEqual(reminder_instance.next_fire, datetime(2016, 1, 1, 14, 0))
            self.assertEqual(reminder_instance.case_id, case.case_id)
            self.assertEqual(reminder_instance.schedule_iteration_num, 1)
            self.assertEqual(reminder_instance.current_event_sequence_num, 0)
            self.assertEqual(reminder_instance.callback_try_count, 0)
Example #30
0
    def test_modified_by_template_params(self):
        r = MessagingTemplateRenderer()

        with self.create_parent_case(modified_by=self.mobile_user) as case:
            r.set_context_param('case', CaseMessagingTemplateParam(case))
            self.assertEqual(r.render("Name: {case.last_modified_by.name}"), "Name: mobile1")
            self.assertEqual(r.render("First Name: {case.last_modified_by.first_name}"), "First Name: Mobile")
            self.assertEqual(r.render("Last Name: {case.last_modified_by.last_name}"), "Last Name: User")
            self.assertEqual(r.render("Phone: {case.last_modified_by.phone_number}"), "Phone: 999123")
            self.assertEqual(r.render("Unknown: {case.last_modified_by.unknown}"), "Unknown: (?)")
            self.assertEqual(r.render("Unknown: {case.last_modified_by.unknown.unknown}"), "Unknown: (?)")

        with self.create_parent_case(modified_by=self.web_user) as case:
            r.set_context_param('case', CaseMessagingTemplateParam(case))
            self.assertEqual(r.render("Name: {case.last_modified_by.name}"), "Name: web1@templating-test")
            self.assertEqual(r.render("First Name: {case.last_modified_by.first_name}"), "First Name: Web")
            self.assertEqual(r.render("Last Name: {case.last_modified_by.last_name}"), "Last Name: User")
            self.assertEqual(r.render("Phone: {case.last_modified_by.phone_number}"), "Phone: 999456")
            self.assertEqual(r.render("Unknown: {case.last_modified_by.unknown}"), "Unknown: (?)")
            self.assertEqual(r.render("Unknown: {case.last_modified_by.unknown.unknown}"), "Unknown: (?)")

        with create_test_case(self.domain, 'person', 'Joe', user_id='system') as case:
            r.set_context_param('case', CaseMessagingTemplateParam(case))
            self.assertEqual(r.render("Name: {case.last_modified_by.name}"), "Name: System")
            self.assertEqual(r.render("First Name: {case.last_modified_by.first_name}"), "First Name: System")
            self.assertEqual(r.render("Last Name: {case.last_modified_by.last_name}"), "Last Name: ")
            self.assertEqual(r.render("Phone: {case.last_modified_by.phone_number}"), "Phone: ")
            self.assertEqual(r.render("Unknown: {case.last_modified_by.unknown}"), "Unknown: (?)")
            self.assertEqual(r.render("Unknown: {case.last_modified_by.unknown.unknown}"), "Unknown: (?)")
Example #31
0
    def test_multiple_entries(self):
        extra_number = PhoneNumber.objects.create(
            domain=self.domain,
            owner_doc_type='X',
            owner_id='X',
            phone_number='999124',
            verified=False,
            pending_verification=False,
            is_two_way=False
        )

        with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case:
            case = self.set_case_property(case, 'contact_phone_number', '999124')
            case = self.set_case_property(case, 'contact_phone_number_is_verified', '1')
            case.create_phone_entry('999125')
            self.assertEqual(PhoneNumber.objects.count(), 3)

            sync_case_phone_number(case)
            self.assertEqual(PhoneNumber.objects.count(), 2)

            number1 = PhoneNumber.objects.get(pk=extra_number.pk)
            self.assertEqual(number1.owner_id, 'X')

            number2 = PhoneNumber.objects.get(owner_id=case.case_id)
            self.assertTrue(number2.verified)
            self.assertTrue(number2.is_two_way)
            self.assertFalse(number2.pending_verification)
Example #32
0
 def create_case(self):
     case_properties = {
         'contact_phone_number': self.phone_number,
         'contact_phone_number_is_verified': '1',
     }
     return create_test_case(self.domain, 'contact', 'test',
         case_properties=case_properties, drop_signals=False)
    def test_case_soft_delete(self):
        with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case:
            case = self.set_case_property(case, 'contact_phone_number', '99987658765')
            case = self.set_case_property(case, 'contact_phone_number_is_verified', '1')
            self.assertIsNotNone(self.get_case_verified_number(case))

            tag_cases_as_deleted_and_remove_indices(self.domain, [case.case_id], '123', datetime.utcnow())
            self.assertIsNone(self.get_case_verified_number(case))
    def test_invalid_phone_format(self):
        with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case:
            case = self.set_case_property(case, 'contact_phone_number', '99987658765')
            case = self.set_case_property(case, 'contact_phone_number_is_verified', '1')
            self.assertIsNotNone(self.get_case_verified_number(case))

            case = self.set_case_property(case, 'contact_phone_number', 'xyz')
            self.assertIsNone(self.get_case_verified_number(case))
Example #35
0
    def test_get_contact_for_case(self):
        with create_test_case(self.domain, "contact", "test-case") as case:
            contact = get_contact(self.domain, case.case_id)
            self.assertEqual(contact.case_id, case.case_id)
            self.assertTrue(is_commcarecase(contact))

            with self.assertRaises(ContactNotFoundException):
                get_contact(self.domain + "x", case.case_id)
    def test_get_contact_for_case(self):
        with create_test_case(self.domain, 'contact', 'test-case') as case:
            contact = get_contact(self.domain, case.case_id)
            self.assertEqual(contact.case_id, case.case_id)
            self.assertTrue(is_commcarecase(contact))

            with self.assertRaises(ContactNotFoundException):
                get_contact(self.domain + 'x', case.case_id)
Example #37
0
    def test_multiple_relevant_messages_new(self):
        self._setup_fixture_type()
        self._setup_data_item('risk1', '1', 'message2')
        with create_test_case(self.domain_name, self.case_type, 'test-case', {'risk_profile': 'risk1'}) as case:
            with self.assertRaises(AssertionError) as e:
                self._get_current_event_messages(self._schedule_instance(case))

            self.assertIn('Multiple messages for case', str(e.exception))
    def test_close_case(self):
        with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case:
            case = self.set_case_property(case, 'contact_phone_number', '99987658765')
            case = self.set_case_property(case, 'contact_phone_number_is_verified', '1')
            self.assertIsNotNone(self.get_case_verified_number(case))

            update_case(self.domain, case.case_id, close=True)
            self.assertIsNone(self.get_case_verified_number(case))
Example #39
0
    def test_last_submitting_user_recipient(self):
        with create_test_case(self.domain, 'person', 'Joe', user_id=self.mobile_user.get_id) as case:
            instance = CaseTimedScheduleInstance(domain=self.domain, case_id=case.case_id,
                recipient_type=CaseScheduleInstanceMixin.RECIPIENT_TYPE_LAST_SUBMITTING_USER)
            self.assertTrue(isinstance(instance.recipient, CommCareUser))
            self.assertEqual(instance.recipient.get_id, self.mobile_user.get_id)

        with create_test_case(self.domain, 'person', 'Joe', user_id=self.web_user.get_id) as case:
            instance = CaseTimedScheduleInstance(domain=self.domain, case_id=case.case_id,
                recipient_type=CaseScheduleInstanceMixin.RECIPIENT_TYPE_LAST_SUBMITTING_USER)
            self.assertTrue(isinstance(instance.recipient, WebUser))
            self.assertEqual(instance.recipient.get_id, self.web_user.get_id)

        with create_test_case(self.domain, 'person', 'Joe', user_id='system') as case:
            instance = CaseTimedScheduleInstance(domain=self.domain, case_id=case.case_id,
                recipient_type=CaseScheduleInstanceMixin.RECIPIENT_TYPE_LAST_SUBMITTING_USER)
            self.assertIsNone(instance.recipient)
    def test_calculate_start_date_with_today_option(self):
        now = datetime.utcnow()

        with create_test_case(self.domain, 'contact', 'test-case') as case:

            reminder = CaseReminderHandler(
                domain=self.domain, use_today_if_start_date_is_blank=True)

            self.assertEqual(
                reminder.get_case_criteria_reminder_start_date_info(case, now),
                (now, True, True))

            reminder.start_date = 'start_date_case_property'
            self.assertEqual(
                reminder.get_case_criteria_reminder_start_date_info(case, now),
                (now, True, True))

            update_case(self.domain, case.case_id,
                        {'start_date_case_property': ''})
            case = CaseAccessors(self.domain).get_case(case.case_id)
            self.assertEqual(
                reminder.get_case_criteria_reminder_start_date_info(case, now),
                (now, True, True))

            update_case(self.domain, case.case_id,
                        {'start_date_case_property': '   '})
            case = CaseAccessors(self.domain).get_case(case.case_id)
            self.assertEqual(
                reminder.get_case_criteria_reminder_start_date_info(case, now),
                (now, True, True))

            update_case(self.domain, case.case_id,
                        {'start_date_case_property': 'abcdefg'})
            case = CaseAccessors(self.domain).get_case(case.case_id)
            self.assertEqual(
                reminder.get_case_criteria_reminder_start_date_info(case, now),
                (now, True, True))

            update_case(self.domain, case.case_id,
                        {'start_date_case_property': '2016-01-32'})
            case = CaseAccessors(self.domain).get_case(case.case_id)
            self.assertEqual(
                reminder.get_case_criteria_reminder_start_date_info(case, now),
                (now, True, True))

            update_case(self.domain, case.case_id,
                        {'start_date_case_property': '2016-01-10'})
            case = CaseAccessors(self.domain).get_case(case.case_id)
            self.assertEqual(
                reminder.get_case_criteria_reminder_start_date_info(case, now),
                (datetime(2016, 1, 10), True, False))

            update_case(self.domain, case.case_id,
                        {'start_date_case_property': '2016-01-12T00:00:00Z'})
            case = CaseAccessors(self.domain).get_case(case.case_id)
            self.assertEqual(
                reminder.get_case_criteria_reminder_start_date_info(case, now),
                (datetime(2016, 1, 12), True, False))
Example #41
0
 def create_parent_case(self, owner=None, modified_by=None):
     owner = owner or self.mobile_user
     modified_by = modified_by or self.mobile_user
     return create_test_case(self.domain,
                             'parent',
                             'P001',
                             case_properties={'parent_prop1': 'abc'},
                             owner_id=owner.get_id,
                             user_id=modified_by.get_id)
Example #42
0
 def create_case_contact(self, phone_number):
     return create_test_case(self.domain,
                             'participant',
                             'test',
                             case_properties={
                                 'contact_phone_number': phone_number,
                                 'contact_phone_number_is_verified': '1',
                             },
                             drop_signals=False)
Example #43
0
 def create_child_case(self, owner=None, modified_by=None):
     owner = owner or self.mobile_user
     modified_by = modified_by or self.mobile_user
     return create_test_case(self.domain,
                             'child',
                             'P002',
                             case_properties={'child_prop1': 'def'},
                             owner_id=owner.get_id,
                             user_id=modified_by.get_id)
Example #44
0
    def test_not_passing_case_new(self):
        self._setup_fixture_type()
        with create_test_case(self.domain_name, self.case_type, 'test-case', {'risk_profile': 'risk1'}) as case:
            schedule_instance = self._schedule_instance(case)
            schedule_instance.recipient_type = ScheduleInstance.RECIPIENT_TYPE_WEB_USER
            schedule_instance.recipient_id = self.user.get_id
            with self.assertRaises(AssertionError) as e:
                self._get_current_event_messages(schedule_instance)

            self.assertIn('must be a case', str(e.exception))
    def test_case_property_start_date_with_start_day_of_week(self):
        reminder = (CaseReminderHandler
            .create(self.domain, 'test')
            .set_case_criteria_start_condition('participant', 'status', MATCH_EXACT, 'green')
            .set_case_criteria_start_date(start_date='start_date', start_day_of_week=DAY_MON)
            .set_case_recipient()
            .set_sms_content_type('en')
            .set_daily_schedule(fire_time=time(12, 0),
                message={'en': 'Hello {case.name}, your test result was normal.'})
            .set_stop_condition(max_iteration_count=30)
            .set_advanced_options(use_today_if_start_date_is_blank=False))
        reminder.save()

        self.assertEqual(self.get_reminders(), [])

        with create_test_case(self.domain, 'participant', 'bob', drop_signals=False) as case, \
                patch('corehq.apps.reminders.models.CaseReminderHandler.get_now') as now_mock:
            self.assertEqual(self.get_reminders(), [])

            now_mock.return_value = datetime(2016, 1, 1, 10, 0)
            update_case(self.domain, case.case_id,
                case_properties={'status': 'green', 'start_date': '2016-01-08'})

            reminder_instance = self.assertOneReminder()
            self.assertEqual(reminder_instance.domain, self.domain)
            self.assertEqual(reminder_instance.case_id, case.case_id)
            self.assertEqual(reminder_instance.handler_id, reminder.get_id)
            self.assertIsNone(reminder_instance.user_id)
            self.assertEqual(reminder_instance.next_fire, datetime(2016, 1, 11, 12, 0))
            self.assertTrue(reminder_instance.active)
            self.assertEqual(reminder_instance.start_date, date(2016, 1, 8))
            self.assertEqual(reminder_instance.schedule_iteration_num, 1)
            self.assertEqual(reminder_instance.current_event_sequence_num, 0)
            self.assertEqual(reminder_instance.callback_try_count, 0)
            self.assertEqual(reminder_instance.start_condition_datetime, datetime(2016, 1, 8))
            self.assertEqual(reminder_instance.callback_try_count, 0)

            # update start day of week and the schedule should be recalculated
            prev_definition = reminder
            reminder.set_case_criteria_start_date(start_date='start_date', start_day_of_week=DAY_TUE)
            reminder.save(schedule_changed=True, prev_definition=prev_definition)

            reminder_instance = self.assertOneReminder()
            self.assertEqual(reminder_instance.domain, self.domain)
            self.assertEqual(reminder_instance.case_id, case.case_id)
            self.assertEqual(reminder_instance.handler_id, reminder.get_id)
            self.assertIsNone(reminder_instance.user_id)
            self.assertEqual(reminder_instance.next_fire, datetime(2016, 1, 12, 12, 0))
            self.assertTrue(reminder_instance.active)
            self.assertEqual(reminder_instance.start_date, date(2016, 1, 8))
            self.assertEqual(reminder_instance.schedule_iteration_num, 1)
            self.assertEqual(reminder_instance.current_event_sequence_num, 0)
            self.assertEqual(reminder_instance.callback_try_count, 0)
            self.assertEqual(reminder_instance.start_condition_datetime, datetime(2016, 1, 8))
            self.assertEqual(reminder_instance.callback_try_count, 0)
Example #46
0
    def test_case_phone_number_updates(self):
        with create_test_case(self.domain,
                              'participant',
                              'test1',
                              drop_signals=False) as case:
            self.assertIsNone(self.get_case_verified_number(case))

            case = self.set_case_property(case, 'contact_phone_number',
                                          '99987658765')
            self.assertIsNone(self.get_case_verified_number(case))

            case = self.set_case_property(case,
                                          'contact_phone_number_is_verified',
                                          '1')
            self.assertPhoneNumberDetails(case, '99987658765', None, None)
            pk = self.get_case_verified_number(case).pk

            case = self.set_case_property(case, 'contact_phone_number',
                                          '99987698769')
            self.assertPhoneNumberDetails(case,
                                          '99987698769',
                                          None,
                                          None,
                                          pk=pk)

            case = self.set_case_property(case, 'contact_backend_id',
                                          'sms-backend')
            self.assertPhoneNumberDetails(case,
                                          '99987698769',
                                          'sms-backend',
                                          None,
                                          pk=pk)

            case = self.set_case_property(case, 'contact_ivr_backend_id',
                                          'ivr-backend')
            self.assertPhoneNumberDetails(case,
                                          '99987698769',
                                          'sms-backend',
                                          'ivr-backend',
                                          pk=pk)

            # If nothing changes, the phone entry should not be saved
            with patch('corehq.apps.sms.models.PhoneNumber.save') as mock_save:
                case = self.set_case_property(case, 'abc', 'def')
                mock_save.assert_not_called()

            # If phone entry is ahead of the case in terms of contact_last_modified, no update should happen
            v = self.get_case_verified_number(case)
            v.contact_last_modified += timedelta(days=1)
            v.save()

            with patch('corehq.apps.sms.models.PhoneNumber.save') as mock_save:
                case = self.set_case_property(case, 'contact_phone_number',
                                              '99912341234')
                mock_save.assert_not_called()
Example #47
0
    def test_case_property_start_date_with_start_day_of_week(self):
        reminder = (CaseReminderHandler
            .create(self.domain, 'test')
            .set_case_criteria_start_condition('participant', 'status', MATCH_EXACT, 'green')
            .set_case_criteria_start_date(start_date='start_date', start_day_of_week=DAY_MON)
            .set_case_recipient()
            .set_sms_content_type('en')
            .set_daily_schedule(fire_time=time(12, 0),
                message={'en': 'Hello {case.name}, your test result was normal.'})
            .set_stop_condition(max_iteration_count=30)
            .set_advanced_options(use_today_if_start_date_is_blank=False))
        reminder.save()

        self.assertEqual(self.get_reminders(), [])

        with create_test_case(self.domain, 'participant', 'bob', drop_signals=False) as case, \
                patch('corehq.apps.reminders.models.CaseReminderHandler.get_now') as now_mock:
            self.assertEqual(self.get_reminders(), [])

            now_mock.return_value = datetime(2016, 1, 1, 10, 0)
            update_case(self.domain, case.case_id,
                case_properties={'status': 'green', 'start_date': '2016-01-08'})

            reminder_instance = self.assertOneReminder()
            self.assertEqual(reminder_instance.domain, self.domain)
            self.assertEqual(reminder_instance.case_id, case.case_id)
            self.assertEqual(reminder_instance.handler_id, reminder.get_id)
            self.assertIsNone(reminder_instance.user_id)
            self.assertEqual(reminder_instance.next_fire, datetime(2016, 1, 11, 12, 0))
            self.assertTrue(reminder_instance.active)
            self.assertEqual(reminder_instance.start_date, date(2016, 1, 8))
            self.assertEqual(reminder_instance.schedule_iteration_num, 1)
            self.assertEqual(reminder_instance.current_event_sequence_num, 0)
            self.assertEqual(reminder_instance.callback_try_count, 0)
            self.assertEqual(reminder_instance.start_condition_datetime, datetime(2016, 1, 8))
            self.assertEqual(reminder_instance.callback_try_count, 0)

            # update start day of week and the schedule should be recalculated
            prev_definition = reminder
            reminder.set_case_criteria_start_date(start_date='start_date', start_day_of_week=DAY_TUE)
            reminder.save(schedule_changed=True, prev_definition=prev_definition)

            reminder_instance = self.assertOneReminder()
            self.assertEqual(reminder_instance.domain, self.domain)
            self.assertEqual(reminder_instance.case_id, case.case_id)
            self.assertEqual(reminder_instance.handler_id, reminder.get_id)
            self.assertIsNone(reminder_instance.user_id)
            self.assertEqual(reminder_instance.next_fire, datetime(2016, 1, 12, 12, 0))
            self.assertTrue(reminder_instance.active)
            self.assertEqual(reminder_instance.start_date, date(2016, 1, 8))
            self.assertEqual(reminder_instance.schedule_iteration_num, 1)
            self.assertEqual(reminder_instance.current_event_sequence_num, 0)
            self.assertEqual(reminder_instance.callback_try_count, 0)
            self.assertEqual(reminder_instance.start_condition_datetime, datetime(2016, 1, 8))
            self.assertEqual(reminder_instance.callback_try_count, 0)
Example #48
0
 def create_case_contact(self, phone_number):
     return create_test_case(
         self.domain,
         'participant',
         'test',
         case_properties={
             'contact_phone_number': phone_number,
             'contact_phone_number_is_verified': '1',
         },
         drop_signals=False
     )
 def create_parent_case(self, owner=None, modified_by=None):
     owner = owner or self.mobile_user
     modified_by = modified_by or self.mobile_user
     return create_test_case(
         self.domain,
         "parent",
         "P001",
         case_properties={"parent_prop1": "abc"},
         owner_id=owner.get_id,
         user_id=modified_by.get_id,
     )
 def create_child_case(self, owner=None, modified_by=None):
     owner = owner or self.mobile_user
     modified_by = modified_by or self.mobile_user
     return create_test_case(
         self.domain,
         "child",
         "P002",
         case_properties={"child_prop1": "def"},
         owner_id=owner.get_id,
         user_id=modified_by.get_id,
     )
Example #51
0
 def test_message_bank_doesnt_have_correct_properties(self):
     data_type = FixtureDataType(domain=self.domain_name,
                                 tag=self.fixture_name,
                                 fields=[],
                                 item_attributes=[])
     data_type.save()
     self.addCleanup(data_type.delete)
     with create_test_case(self.domain_name, self.case_type,
                           'test-case') as case:
         self.assertRaises(AssertionError, ucla_message_bank_content,
                           self._reminder(), self._handler(), case)
    def test_user_recipient(self):
        reminder = (CaseReminderHandler
            .create(self.domain, 'test')
            .set_case_criteria_start_condition('participant', 'status', MATCH_EXACT, 'green')
            .set_case_criteria_start_date()
            .set_last_submitting_user_recipient()
            .set_sms_content_type('en')
            .set_daily_schedule(fire_time=time(12, 0), message={'en': "{case.name}'s test result was normal."})
            .set_stop_condition(max_iteration_count=REPEAT_SCHEDULE_INDEFINITELY)
            .set_advanced_options())
        reminder.save()

        self.assertEqual(self.get_reminders(), [])

        with create_test_case(self.domain, 'participant', 'bob', drop_signals=False) as case, \
                patch('corehq.apps.reminders.models.CaseReminderHandler.get_now') as now_mock:
            self.assertEqual(self.get_reminders(), [])

            now_mock.return_value = datetime(2016, 1, 1, 10, 0)

            # There should still be no reminder instance since this is submitted by the system user
            update_case(self.domain, case.case_id, case_properties={'status': 'green'})
            self.assertEqual(self.get_reminders(), [])

            # Update the user id on the case
            CaseFactory(self.domain).create_or_update_case(
                CaseStructure(
                    case_id=case.case_id,
                    attrs={'user_id': self.user.get_id}
                )
            )

            reminder_instance = self.assertOneReminder()
            self.assertEqual(reminder_instance.domain, self.domain)
            self.assertEqual(reminder_instance.handler_id, reminder.get_id)
            self.assertTrue(reminder_instance.active)
            self.assertEqual(reminder_instance.start_date, date(2016, 1, 1))
            self.assertIsNone(reminder_instance.start_condition_datetime)
            self.assertEqual(reminder_instance.next_fire, datetime(2016, 1, 1, 12, 0))
            self.assertEqual(reminder_instance.case_id, case.case_id)
            self.assertEqual(reminder_instance.schedule_iteration_num, 1)
            self.assertEqual(reminder_instance.current_event_sequence_num, 0)
            self.assertEqual(reminder_instance.user_id, self.user.get_id)
            self.assertEqual(reminder_instance.callback_try_count, 0)

            # Set a user_id that does not exist
            CaseFactory(self.domain).create_or_update_case(
                CaseStructure(
                    case_id=case.case_id,
                    attrs={'user_id': 'this-user-id-does-not-exist'}
                )
            )
            self.assertEqual(self.get_reminders(), [])
Example #53
0
 def test_message_bank_doesnt_have_correct_properties(self):
     data_type = FixtureDataType(
         domain=self.domain_name,
         tag=self.fixture_name,
         fields=[],
         item_attributes=[]
     )
     data_type.save()
     self.addCleanup(data_type.delete)
     with create_test_case(self.domain_name, self.case_type, 'test-case') as case:
         self.assertRaises(
             AssertionError, general_health_message_bank_content, self._reminder(), self._handler(), case)
Example #54
0
    def test_recipient_case_owner_location_parent(self):
        parent_location = SQLLocation.objects.create(
            domain=self.domain,
            name='parent test',
            site_code='parent',
            location_type=self.parent_location_type)

        child_location = SQLLocation.objects.create(
            domain=self.domain,
            name='child test',
            site_code='child',
            location_type=self.child_location_type,
            parent=parent_location)

        self.user.set_location(child_location.couch_location)

        with create_test_case(self.domain,
                              'test-case',
                              'test-name',
                              owner_id=self.user.get_id) as case:
            self.assertEqual(case.owner_id, self.user.get_id)
            handler = CaseReminderHandler(
                domain=self.domain,
                recipient=RECIPIENT_CASE_OWNER_LOCATION_PARENT)
            reminder = CaseReminder(domain=self.domain, case_id=case.case_id)

            # Test the recipient is returned correctly
            with patch('corehq.apps.reminders.models.CaseReminder.handler',
                       new=handler):
                self.assertEqual(reminder.recipient, [parent_location])

            # Remove parent location
            parent_location.delete()
            child_location.parent = None
            child_location.save()
            with patch('corehq.apps.reminders.models.CaseReminder.handler',
                       new=handler):
                self.assertIsNone(reminder.recipient)

            # Remove child location
            self.user.unset_location()
            child_location.delete()
            with patch('corehq.apps.reminders.models.CaseReminder.handler',
                       new=handler):
                self.assertIsNone(reminder.recipient)

            # Remove case
            reminder.case_id = None
            with patch('corehq.apps.reminders.models.CaseReminder.handler',
                       new=handler):
                self.assertIsNone(reminder.recipient)
Example #55
0
    def test_phone_number_already_in_use(self):
        self.assertEqual(PhoneNumber.count_by_domain(self.domain), 0)

        with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case1, \
                create_test_case(self.domain, 'participant', 'test2', drop_signals=False) as case2:
            case1 = self.set_case_property(case1, 'contact_phone_number', '99987658765')
            case1 = self.set_case_property(case1, 'contact_phone_number_is_verified', '1')

            case2 = self.set_case_property(case2, 'contact_phone_number', '99987698769')
            case2 = self.set_case_property(case2, 'contact_phone_number_is_verified', '1')

            self.assertIsNotNone(self.get_case_phone_number(case1))
            self.assertIsNotNone(self.get_case_phone_number(case2))
            self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2)

            case2 = self.set_case_property(case2, 'contact_phone_number', '99987658765')

            self.assertIsNotNone(self.get_case_phone_number(case1))
            self.assertIsNotNone(self.get_case_phone_number(case2))
            self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2)

            self.assertPhoneNumberDetails(case1, '99987658765', None, None, True, False, True)
            self.assertPhoneNumberDetails(case2, '99987658765', None, None, False, False, False)
Example #56
0
    def test_message_bank_doesnt_have_correct_properties_new(self):
        data_type = FixtureDataType(
            domain=self.domain_name,
            tag=self.fixture_name,
            fields=[],
            item_attributes=[]
        )
        data_type.save()
        self.addCleanup(data_type.delete)
        with create_test_case(self.domain_name, self.case_type, 'test-case') as case:
            with self.assertRaises(AssertionError) as e:
                self._get_current_event_messages(self._schedule_instance(case))

            self.assertIn('must have', str(e.exception))
Example #57
0
    def test_case_phone_number_updates(self):
        extra_number = PhoneNumber.objects.create(
            domain=self.domain,
            owner_doc_type='X',
            owner_id='X',
            phone_number='999123',
            verified=True,
            pending_verification=False,
            is_two_way=True
        )
        self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1)

        with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case:
            self.assertIsNone(self.get_case_phone_number(case))

            case = self.set_case_property(case, 'contact_phone_number', '99987658765')
            self.assertPhoneNumberDetails(case, '99987658765', None, None, False, False, False)
            pk = self.get_case_phone_number(case).pk
            self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2)

            case = self.set_case_property(case, 'contact_phone_number_is_verified', '1')
            self.assertPhoneNumberDetails(case, '99987658765', None, None, True, False, True, pk=pk)
            self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2)

            case = self.set_case_property(case, 'contact_phone_number', '99987698769')
            self.assertPhoneNumberDetails(case, '99987698769', None, None, True, False, True)
            pk = self.get_case_phone_number(case).pk
            self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2)

            case = self.set_case_property(case, 'contact_backend_id', 'sms-backend')
            self.assertPhoneNumberDetails(case, '99987698769', 'sms-backend', None, True, False, True, pk=pk)
            self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2)

            case = self.set_case_property(case, 'contact_ivr_backend_id', 'ivr-backend')
            self.assertPhoneNumberDetails(case, '99987698769', 'sms-backend', 'ivr-backend', True, False, True,
                pk=pk)
            self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2)

            # If phone entry is ahead of the case in terms of contact_last_modified, no update should happen
            v = self.get_case_phone_number(case)
            v.contact_last_modified += timedelta(days=1)
            v.save()

            with patch('corehq.apps.sms.models.PhoneNumber.save') as mock_save:
                case = self.set_case_property(case, 'contact_phone_number', '99912341234')
                self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2)
                mock_save.assert_not_called()

        self.assertEqual(PhoneNumber.get_two_way_number('999123'), extra_number)
Example #58
0
    def test_recipient_case_owner_location_parent(self):
        parent_location = SQLLocation.objects.create(
            domain=self.domain,
            name='parent test',
            site_code='parent',
            location_type=self.parent_location_type
        )

        child_location = SQLLocation.objects.create(
            domain=self.domain,
            name='child test',
            site_code='child',
            location_type=self.child_location_type,
            parent=parent_location
        )

        self.user.set_location(child_location.couch_location)

        with create_test_case(self.domain, 'test-case', 'test-name', owner_id=self.user.get_id) as case:
            self.assertEqual(case.owner_id, self.user.get_id)
            handler = CaseReminderHandler(domain=self.domain, recipient=RECIPIENT_CASE_OWNER_LOCATION_PARENT)
            reminder = CaseReminder(domain=self.domain, case_id=case.case_id)

            # Test the recipient is returned correctly
            with patch('corehq.apps.reminders.models.CaseReminder.handler', new=handler):
                self.assertEqual(reminder.recipient, [parent_location])

            # Remove parent location
            parent_location.delete()
            child_location.parent = None
            child_location.save()
            with patch('corehq.apps.reminders.models.CaseReminder.handler', new=handler):
                self.assertIsNone(reminder.recipient)

            # Remove child location
            self.user.unset_location()
            child_location.delete()
            with patch('corehq.apps.reminders.models.CaseReminder.handler', new=handler):
                self.assertIsNone(reminder.recipient)

            # Remove case
            reminder.case_id = None
            with patch('corehq.apps.reminders.models.CaseReminder.handler', new=handler):
                self.assertIsNone(reminder.recipient)
Example #59
0
    def test_get_contact(self):
        with create_test_case(self.domain, 'contact', 'test-case') as case:
            user = CommCareUser.create(self.domain, 'test-user', '123')
            self.addCleanup(user.delete)

            contact = get_contact(self.domain, case.case_id)
            self.assertEqual(contact.case_id, case.case_id)
            self.assertTrue(is_commcarecase(contact))

            contact = get_contact(self.domain, user.get_id)
            self.assertEqual(contact.get_id, user.get_id)
            self.assertTrue(isinstance(contact, CommCareUser))

            with self.assertRaises(ContactNotFoundException):
                get_contact(self.domain, 'this-id-should-not-be-found')

            with self.assertRaises(ContactNotFoundException):
                get_contact(self.domain + 'x', case.case_id)

            with self.assertRaises(ContactNotFoundException):
                get_contact(self.domain + 'x', user.get_id)
Example #60
0
    def test_invalid_phone_format(self):
        extra_number = PhoneNumber.objects.create(
            domain=self.domain,
            owner_doc_type='X',
            owner_id='X',
            phone_number='999123',
            verified=True,
            pending_verification=False,
            is_two_way=True
        )
        self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1)

        with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case:
            case = self.set_case_property(case, 'contact_phone_number', '99987658765')
            case = self.set_case_property(case, 'contact_phone_number_is_verified', '1')
            self.assertIsNotNone(self.get_case_phone_number(case))
            self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2)

            case = self.set_case_property(case, 'contact_phone_number', 'xyz')
            self.assertIsNone(self.get_case_phone_number(case))
            self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1)

        self.assertEqual(PhoneNumber.get_two_way_number('999123'), extra_number)