def test_date_case_properties_for_equality(self): """ Date case properties are automatically converted from string to date when fetching from the db, so here we want to make sure this doesn't interfere with our ability to compare dates for equality. """ case = CommCareCase( domain=self.domain, type='test-case-type-2', ) self.rule2.automaticupdaterulecriteria_set = [ AutomaticUpdateRuleCriteria( property_name='property1', property_value='2016-02-24', match_type=AutomaticUpdateRuleCriteria.MATCH_EQUAL, ), ] case.set_case_property('property1', '2016-02-24') case.save() case = CommCareCase.get(case.get_id) case.server_modified_on = datetime(2015, 1, 1) self.assertTrue(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property('property1', '2016-02-25') case.save() case = CommCareCase.get(case.get_id) case.server_modified_on = datetime(2015, 1, 1) self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.delete()
def test_phone_number_already_in_use(self): case1 = CommCareCase( domain='case-phone-number-test', name='TEST1' ) case1.set_case_property('contact_phone_number', '99987658765') case1.set_case_property('contact_phone_number_is_verified', '1') case1.save() case2 = CommCareCase( domain='case-phone-number-test', name='TEST2' ) case2.set_case_property('contact_phone_number', '99987698769') case2.set_case_property('contact_phone_number_is_verified', '1') case2.save() self.assertIsNotNone(self.get_case_verified_number(case1)) self.assertIsNotNone(self.get_case_verified_number(case2)) case2.set_case_property('contact_phone_number', '99987658765') case2.save() self.assertIsNotNone(self.get_case_verified_number(case1)) self.assertIsNone(self.get_case_verified_number(case2)) case2.delete() self.get_case_verified_number(case1).delete() case1.delete()
def test_date_case_properties_for_inequality(self): case = CommCareCase( domain=self.domain, type='test-case-type-2', ) self.rule2.automaticupdaterulecriteria_set = [ AutomaticUpdateRuleCriteria( property_name='property1', property_value='2016-02-24', match_type=AutomaticUpdateRuleCriteria.MATCH_NOT_EQUAL, ), ] case.set_case_property('property1', '2016-02-24') case.save() case = CommCareCase.get(case.get_id) case.server_modified_on = datetime(2015, 1, 1) self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property('property1', '2016-02-25') case.save() case = CommCareCase.get(case.get_id) case.server_modified_on = datetime(2015, 1, 1) self.assertTrue(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.delete()
def test_case_soft_delete(self): case = CommCareCase( domain='case-phone-number-test', name='TEST1' ) case.set_case_property('contact_phone_number', '99987658765') case.set_case_property('contact_phone_number_is_verified', '1') case.save() self.assertIsNotNone(self.get_case_verified_number(case)) case.doc_type += '-Deleted' case.save() self.assertIsNone(self.get_case_verified_number(case)) case.delete()
def test_match_days_since(self): case = CommCareCase( domain=self.domain, type='test-case-type-2', server_modified_on=datetime(2015, 1, 1), ) self.rule2.automaticupdaterulecriteria_set = [ AutomaticUpdateRuleCriteria( property_name='last_visit_date', property_value='30', match_type=AutomaticUpdateRuleCriteria.MATCH_DAYS_SINCE, ), ] self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property('last_visit_date', '2015-12-30') self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property('last_visit_date', '2015-12-03') self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property('last_visit_date', '2015-12-02') self.assertTrue(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property('last_visit_date', '2015-11-01') self.assertTrue(self.rule2.rule_matches_case(case, datetime(2016, 1, 1)))
def test_match_has_value(self): case = CommCareCase(domain=self.domain, type="test-case-type-2", server_modified_on=datetime(2015, 1, 1)) self.rule2.automaticupdaterulecriteria_set = [ AutomaticUpdateRuleCriteria( property_name="property3", match_type=AutomaticUpdateRuleCriteria.MATCH_HAS_VALUE ) ] self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property("property3", "x") self.assertTrue(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property("property3", "") self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1)))
class MessageTestCase(BaseReminderTestCase): def setUp(self): self.domain = "test" self.parent_case = CommCareCase( domain=self.domain, type="parent", name="P001", ) self.parent_case.set_case_property("parent_prop1", "abc") self.parent_case.save() self.child_case = CommCareCase( domain=self.domain, type="child", name="P002", indices=[CommCareCaseIndex( identifier="parent", referenced_type="parent", referenced_id=self.parent_case._id, )], ) self.child_case.set_case_property("child_prop1", "def") self.child_case.save() def tearDown(self): self.child_case.delete() self.parent_case.delete() def test_message(self): message = 'The EDD for client with ID {case.external_id} is approaching in {case.edd.days_until} days.' case = {'external_id': 123, 'edd': datetime.utcnow() + timedelta(days=30)} outcome = 'The EDD for client with ID 123 is approaching in 30 days.' self.assertEqual(Message.render(message, case=case), outcome) def test_template_params(self): child_result = {"case": self.child_case.case_properties()} child_result["case"]["parent"] = self.parent_case.case_properties() self.assertEqual( get_message_template_params(self.child_case), child_result) parent_result = {"case": self.parent_case.case_properties()} parent_result["case"]["parent"] = {} self.assertEqual( get_message_template_params(self.parent_case), parent_result)
def test_match_not_equal(self): case = CommCareCase( domain=self.domain, type='test-case-type-2', server_modified_on=datetime(2015, 1, 1), ) self.rule2.automaticupdaterulecriteria_set = [ AutomaticUpdateRuleCriteria( property_name='property2', property_value='value2', match_type=AutomaticUpdateRuleCriteria.MATCH_NOT_EQUAL, ), ] self.assertTrue(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property('property2', 'value2') self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property('property2', 'x') self.assertTrue(self.rule2.rule_matches_case(case, datetime(2016, 1, 1)))
def test_invalid_phone_format(self): case = CommCareCase( domain='case-phone-number-test', name='TEST1' ) case.set_case_property('contact_phone_number', '99987658765') case.set_case_property('contact_phone_number_is_verified', '1') case.save() self.assertIsNotNone(self.get_case_verified_number(case)) case.set_case_property('contact_phone_number', 'xyz') case.save() self.assertIsNone(self.get_case_verified_number(case)) case.delete()
def test_match_days_since(self): case = CommCareCase(domain=self.domain, type="test-case-type-2", server_modified_on=datetime(2015, 1, 1)) self.rule2.automaticupdaterulecriteria_set = [ AutomaticUpdateRuleCriteria( property_name="last_visit_date", property_value="30", match_type=AutomaticUpdateRuleCriteria.MATCH_DAYS_SINCE, ) ] self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property("last_visit_date", "2015-12-30") self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property("last_visit_date", "2015-12-03") self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property("last_visit_date", "2015-12-02") self.assertTrue(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property("last_visit_date", "2015-11-01") self.assertTrue(self.rule2.rule_matches_case(case, datetime(2016, 1, 1)))
def test_and_criteria(self): case = CommCareCase(domain=self.domain, type="test-case-type-2", server_modified_on=datetime(2015, 1, 1)) self.rule2.automaticupdaterulecriteria_set = [ AutomaticUpdateRuleCriteria( property_name="last_visit_date", property_value="30", match_type=AutomaticUpdateRuleCriteria.MATCH_DAYS_SINCE, ), AutomaticUpdateRuleCriteria( property_name="property1", property_value="value1", match_type=AutomaticUpdateRuleCriteria.MATCH_EQUAL ), AutomaticUpdateRuleCriteria( property_name="property2", property_value="value2", match_type=AutomaticUpdateRuleCriteria.MATCH_NOT_EQUAL, ), AutomaticUpdateRuleCriteria( property_name="property3", match_type=AutomaticUpdateRuleCriteria.MATCH_HAS_VALUE ), ] case.set_case_property("last_visit_date", "2015-11-01") case.set_case_property("property1", "value1") case.set_case_property("property2", "x") case.set_case_property("property3", "x") self.assertTrue(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property("last_visit_date", "2015-12-30") self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property("last_visit_date", "2015-11-01") case.set_case_property("property1", "x") self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property("property1", "value1") case.set_case_property("property2", "value2") self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property("property2", "x") case.set_case_property("property3", "") self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property("property3", "x") self.assertTrue(self.rule2.rule_matches_case(case, datetime(2016, 1, 1)))
class KooKooTestCase(TouchformsTestCase): """ Must be run manually (see corehq.apps.sms.tests.util.TouchformsTestCase) """ def setUp(self): super(KooKooTestCase, self).setUp() self.ivr_backend = MobileBackend( _id="MOBILE_BACKEND_KOOKOO", outbound_module="corehq.apps.kookoo.api", outbound_params={"is_test": True, "api_key": "xyz"}, ) self.ivr_backend.save() self.user1 = self.create_mobile_worker("user1", "123", "91001", save_vn=False) self.user2 = self.create_mobile_worker("user2", "123", "91002", save_vn=False) self.create_group("group1", [self.user1, self.user2]) self.case = CommCareCase( domain=self.domain, type="participant", owner_id=self.groups[0]._id, ) self.case.set_case_property("contact_phone_number", "91000") self.case.set_case_property("contact_phone_number_is_verified", "1") self.case.set_case_property("contact_ivr_backend_id", "MOBILE_BACKEND_KOOKOO") self.case.save() dirname = os.path.dirname(os.path.abspath(__file__)) self.load_app("app1.json", dirname) self.load_app("app2.json", dirname) self.reminder1 = CaseReminderHandler( domain=self.domain, active=True, case_type="participant", method=METHOD_IVR_SURVEY, recipient=RECIPIENT_CASE, sample_id=None, user_group_id=None, user_id=None, case_id=None, reminder_type=REMINDER_TYPE_DEFAULT, submit_partial_forms=True, include_case_side_effects=False, max_question_retries=5, start_condition_type=CASE_CRITERIA, start_property="name", start_value="case1", start_date=None, start_offset=0, start_match_type=MATCH_EXACT, events=[ CaseReminderEvent( day_num=0, fire_time=time(12,0), fire_time_type=FIRE_TIME_DEFAULT, callback_timeout_intervals=[30], form_unique_id=self.apps[0].modules[0].forms[0].unique_id, ), CaseReminderEvent( day_num=0, fire_time=time(13,0), fire_time_type=FIRE_TIME_DEFAULT, callback_timeout_intervals=[30], form_unique_id=self.apps[0].modules[0].forms[1].unique_id, ), ], schedule_length=1, event_interpretation=EVENT_AS_SCHEDULE, max_iteration_count=7, until=None, force_surveys_to_use_triggered_case=False, ) self.reminder1.save() self.reminder2 = CaseReminderHandler( domain=self.domain, active=True, case_type="participant", method=METHOD_IVR_SURVEY, recipient=RECIPIENT_OWNER, sample_id=None, user_group_id=None, user_id=None, case_id=None, reminder_type=REMINDER_TYPE_DEFAULT, submit_partial_forms=True, include_case_side_effects=True, max_question_retries=5, start_condition_type=CASE_CRITERIA, start_property="name", start_value="case2", start_date=None, start_offset=0, start_match_type=MATCH_EXACT, events=[ CaseReminderEvent( day_num=0, fire_time=time(12,0), fire_time_type=FIRE_TIME_DEFAULT, callback_timeout_intervals=[30, 30], form_unique_id=self.apps[1].modules[0].forms[0].unique_id, ), ], schedule_length=1, event_interpretation=EVENT_AS_SCHEDULE, max_iteration_count=7, until=None, force_surveys_to_use_triggered_case=False, ) self.reminder2.save() def kookoo_in(self, params): """ params should be a dictionary containing: event, cid, sid, and (optionally) data """ params = urllib.urlencode(params) url = "%s/kookoo/ivr/" % self.live_server_url return urllib2.urlopen("%s?%s" % (url, params)).read() def kookoo_finished(self, params): """ params should be a dictionary containing: sid, status, and duration """ params = urllib.urlencode(params) url = "%s/kookoo/ivr_finished/" % self.live_server_url return urllib2.urlopen(url, params).read() def testOutbound(self): # Send an outbound call using self.reminder1 to self.case # and answer it CaseReminderHandler.now = datetime(2014, 6, 23, 10, 0) self.case.name = "case1" self.case.save() CaseReminderHandler.now = datetime(2014, 6, 23, 12, 0) CaseReminderHandler.fire_reminders() reminder = self.reminder1.get_reminder(self.case) self.assertEquals(reminder.next_fire, datetime(2014, 6, 23, 12, 30)) call = self.get_last_outbound_call(self.case) self.assertTrue(call.use_precached_first_response) kookoo_session_id = call.gateway_session_id[7:] resp = self.kookoo_in({ "cid": "0000", "sid": kookoo_session_id, "event": "NewCall", }) self.assertEqual(resp, '<response sid="%s"><collectdtmf l="1" o="3000">' '<playtext>How do you feel today? Press 1 for good, 2 for bad.' '</playtext></collectdtmf></response>' % kookoo_session_id) resp = self.kookoo_in({ "cid": "0000", "sid": kookoo_session_id, "event": "GotDTMF", "data": "1", }) self.assertEqual(resp, '<response sid="%s"><collectdtmf l="1" o="3000">' '<playtext>Did you remember to take your meds today? Press 1 for yes, 2 for no.' '</playtext></collectdtmf></response>' % kookoo_session_id) resp = self.kookoo_in({ "cid": "0000", "sid": kookoo_session_id, "event": "GotDTMF", "data": "2", }) self.assertEqual(resp, '<response sid="%s"><hangup/></response>' % kookoo_session_id) self.kookoo_finished({ "sid": kookoo_session_id, "status": "answered", "duration": "20", }) call = CallLog.get(call._id) self.assertTrue(call.answered) form = self.get_last_form_submission() self.assertFormQuestionEquals(form, "how_feel", "1") self.assertFormQuestionEquals(form, "take_meds", "2") case = CommCareCase.get(self.case._id) self.assertCasePropertyEquals(case, "how_feel", "1") self.assertCasePropertyEquals(case, "take_meds", "2") CaseReminderHandler.now = datetime(2014, 6, 23, 12, 30) CaseReminderHandler.fire_reminders() reminder = self.reminder1.get_reminder(self.case) self.assertEquals(reminder.next_fire, datetime(2014, 6, 23, 13, 0)) last_call = self.get_last_outbound_call(self.case) self.assertEqual(call._id, last_call._id) # Move on to the second event which now uses an all-label form and # should not precache the first ivr response CaseReminderHandler.now = datetime(2014, 6, 23, 13, 0) CaseReminderHandler.fire_reminders() reminder = self.reminder1.get_reminder(self.case) self.assertEquals(reminder.next_fire, datetime(2014, 6, 23, 13, 30)) call = self.get_last_outbound_call(self.case) self.assertFalse(call.use_precached_first_response) kookoo_session_id = call.gateway_session_id[7:] resp = self.kookoo_in({ "cid": "0000", "sid": kookoo_session_id, "event": "NewCall", }) self.assertEqual(resp, '<response sid="%s">' '<playtext>This is just a reminder to take your meds.' '</playtext><hangup/></response>' % kookoo_session_id) self.kookoo_finished({ "sid": kookoo_session_id, "status": "answered", "duration": "5", }) call = CallLog.get(call._id) self.assertTrue(call.answered) form = self.get_last_form_submission() self.assertFormQuestionEquals(form, "label", "ok") CaseReminderHandler.now = datetime(2014, 6, 23, 13, 30) CaseReminderHandler.fire_reminders() reminder = self.reminder1.get_reminder(self.case) self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 12, 0)) last_call = self.get_last_outbound_call(self.case) self.assertEqual(call._id, last_call._id) # Now test sending outbound calls to a group of users (the owners # of the case) # Allow sending to unverified numbers self.domain_obj = Domain.get(self.domain_obj._id) self.domain_obj.send_to_duplicated_case_numbers = True self.domain_obj.save() CaseReminderHandler.now = datetime(2014, 6, 24, 10, 0) self.case = CommCareCase.get(self.case._id) self.case.name = "case2" self.case.save() reminder = self.reminder2.get_reminder(self.case) self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 12, 0)) CaseReminderHandler.now = datetime(2014, 6, 24, 12, 0) CaseReminderHandler.fire_reminders() reminder = self.reminder2.get_reminder(self.case) self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 12, 30)) call1 = self.get_last_outbound_call(self.user1) self.assertTrue(call1.use_precached_first_response) self.assertFalse(call1.answered) call2 = self.get_last_outbound_call(self.user2) self.assertTrue(call2.use_precached_first_response) self.assertFalse(call2.answered) old_call1 = call1 old_call2 = call2 CaseReminderHandler.now = datetime(2014, 6, 24, 12, 30) CaseReminderHandler.fire_reminders() reminder = self.reminder2.get_reminder(self.case) self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 13, 0)) call1 = self.get_last_outbound_call(self.user1) self.assertTrue(call1.use_precached_first_response) self.assertNotEqual(call1._id, old_call1._id) call2 = self.get_last_outbound_call(self.user2) self.assertTrue(call2.use_precached_first_response) self.assertFalse(call2.answered) self.assertNotEqual(call2._id, old_call2._id) kookoo_session_id = call1.gateway_session_id[7:] resp = self.kookoo_in({ "cid": "0001", "sid": kookoo_session_id, "event": "NewCall", }) self.assertEqual(resp, '<response sid="%s"><collectdtmf l="1" o="3000">' '<playtext>How do you feel today? Press 1 for good, 2 for bad.' '</playtext></collectdtmf></response>' % kookoo_session_id) resp = self.kookoo_in({ "cid": "0001", "sid": kookoo_session_id, "event": "GotDTMF", "data": "2", }) self.assertEqual(resp, '<response sid="%s"><collectdtmf l="1" o="3000">' '<playtext>Did you remember to take your meds today? Press 1 for yes, 2 for no.' '</playtext></collectdtmf></response>' % kookoo_session_id) resp = self.kookoo_in({ "cid": "0001", "sid": kookoo_session_id, "event": "GotDTMF", "data": "1", }) self.assertEqual(resp, '<response sid="%s"><hangup/></response>' % kookoo_session_id) self.kookoo_finished({ "sid": kookoo_session_id, "status": "answered", "duration": "20", }) call1 = CallLog.get(call1._id) self.assertTrue(call.answered) form = self.get_last_form_submission() self.assertFormQuestionEquals(form, "how_feel", "2") self.assertFormQuestionEquals(form, "take_meds", "1") self.assertEqual(form.form["meta"]["userID"], self.user1._id) case = CommCareCase.get(self.case._id) self.assertCasePropertyEquals(case, "how_feel", "2") self.assertCasePropertyEquals(case, "take_meds", "1") self.assertEqual(case.user_id, self.user1._id) old_call1 = call1 old_call2 = call2 CaseReminderHandler.now = datetime(2014, 6, 24, 13, 0) CaseReminderHandler.fire_reminders() reminder = self.reminder2.get_reminder(self.case) self.assertEquals(reminder.next_fire, datetime(2014, 6, 25, 12, 0)) call1 = self.get_last_outbound_call(self.user1) # No new call for user1 since it was already answered self.assertEqual(call1._id, old_call1._id) call2 = self.get_last_outbound_call(self.user2) self.assertTrue(call2.use_precached_first_response) self.assertNotEqual(call2._id, old_call2._id) kookoo_session_id = call2.gateway_session_id[7:] resp = self.kookoo_in({ "cid": "0002", "sid": kookoo_session_id, "event": "NewCall", }) self.assertEqual(resp, '<response sid="%s"><collectdtmf l="1" o="3000">' '<playtext>How do you feel today? Press 1 for good, 2 for bad.' '</playtext></collectdtmf></response>' % kookoo_session_id) resp = self.kookoo_in({ "cid": "0002", "sid": kookoo_session_id, "event": "GotDTMF", "data": "1", }) self.assertEqual(resp, '<response sid="%s"><collectdtmf l="1" o="3000">' '<playtext>Did you remember to take your meds today? Press 1 for yes, 2 for no.' '</playtext></collectdtmf></response>' % kookoo_session_id) resp = self.kookoo_in({ "cid": "0002", "sid": kookoo_session_id, "event": "GotDTMF", "data": "2", }) self.assertEqual(resp, '<response sid="%s"><hangup/></response>' % kookoo_session_id) self.kookoo_finished({ "sid": kookoo_session_id, "status": "answered", "duration": "20", }) call2 = CallLog.get(call2._id) self.assertTrue(call.answered) form = self.get_last_form_submission() self.assertFormQuestionEquals(form, "how_feel", "1") self.assertFormQuestionEquals(form, "take_meds", "2") self.assertEqual(form.form["meta"]["userID"], self.user2._id) case = CommCareCase.get(self.case._id) self.assertCasePropertyEquals(case, "how_feel", "1") self.assertCasePropertyEquals(case, "take_meds", "2") self.assertEqual(case.user_id, self.user2._id) def tearDown(self): self.ivr_backend.delete() super(KooKooTestCase, self).tearDown()
class BackendTestCase(TestCase): def setUp(self): self.domain = "test-domain" self.domain2 = "test-domain2" self.domain_obj = Domain(name=self.domain) self.domain_obj.save() self.domain_obj = Domain.get( self.domain_obj._id) # Prevent resource conflict self.backend1 = TestCaseBackend(name="BACKEND1", is_global=True) self.backend1.save() self.backend2 = TestCaseBackend(name="BACKEND2", is_global=True) self.backend2.save() self.backend3 = TestCaseBackend(name="BACKEND3", is_global=True) self.backend3.save() self.backend4 = TestCaseBackend(name="BACKEND4", is_global=True) self.backend4.save() self.backend5 = TestCaseBackend(name="BACKEND5", domain=self.domain, is_global=False, authorized_domains=[]) self.backend5.save() self.backend6 = TestCaseBackend(name="BACKEND6", domain=self.domain2, is_global=False, authorized_domains=[self.domain]) self.backend6.save() self.backend7 = TestCaseBackend(name="BACKEND7", domain=self.domain2, is_global=False, authorized_domains=[]) self.backend7.save() self.backend8 = TestCaseBackend(name="BACKEND", domain=self.domain, is_global=False, authorized_domains=[]) self.backend8.save() self.backend9 = TestCaseBackend(name="BACKEND", domain=self.domain2, is_global=False, authorized_domains=[self.domain]) self.backend9.save() self.backend10 = TestCaseBackend(name="BACKEND", is_global=True) self.backend10.save() self.backend_mapping1 = BackendMapping(is_global=True, prefix="*", backend_id=self.backend1._id) self.backend_mapping1.save() self.backend_mapping2 = BackendMapping(is_global=True, prefix="1", backend_id=self.backend2._id) self.backend_mapping2.save() self.backend_mapping3 = BackendMapping(is_global=True, prefix="91", backend_id=self.backend3._id) self.backend_mapping3.save() self.backend_mapping4 = BackendMapping(is_global=True, prefix="265", backend_id=self.backend4._id) self.backend_mapping4.save() self.case = CommCareCase(domain=self.domain) self.case.set_case_property("contact_phone_number", "15551234567") self.case.set_case_property("contact_phone_number_is_verified", "1") self.case.save() self.contact = CommConnectCase.wrap(self.case.to_json()) settings.SMS_LOADED_BACKENDS.append( "corehq.apps.sms.tests.TestCaseBackend") def tearDown(self): self.backend1.delete_invoke_doc() self.backend1.delete() self.backend_mapping1.delete() self.backend2.delete_invoke_doc() self.backend2.delete() self.backend_mapping2.delete() self.backend3.delete_invoke_doc() self.backend3.delete() self.backend_mapping3.delete() self.backend4.delete_invoke_doc() self.backend4.delete() self.backend_mapping4.delete() self.backend5.delete_invoke_doc() self.backend5.delete() self.backend6.delete_invoke_doc() self.backend6.delete() self.backend7.delete_invoke_doc() self.backend7.delete() self.contact.delete_verified_number() self.case.delete() self.domain_obj.delete() settings.SMS_LOADED_BACKENDS.pop() def test_backend(self): # Test the backend map self.assertTrue( send_sms(self.domain, None, "15551234567", "Test for BACKEND2")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertTrue(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend2.delete_invoke_doc() self.assertFalse(self.backend2.invoke_doc_exists()) self.assertTrue( send_sms(self.domain, None, "9100000000", "Test for BACKEND3")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertTrue(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend3.delete_invoke_doc() self.assertFalse(self.backend3.invoke_doc_exists()) self.assertTrue( send_sms(self.domain, None, "26500000000", "Test for BACKEND4")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertTrue(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend4.delete_invoke_doc() self.assertFalse(self.backend4.invoke_doc_exists()) self.assertTrue( send_sms(self.domain, None, "25800000000", "Test for BACKEND1")) self.assertTrue(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend1.delete_invoke_doc() self.assertFalse(self.backend1.invoke_doc_exists()) # Test overriding with a domain-level backend self.domain_obj.default_sms_backend_id = self.backend5._id self.domain_obj.save() self.assertTrue( send_sms(self.domain, None, "15551234567", "Test for BACKEND5")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertTrue(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend5.delete_invoke_doc() self.assertFalse(self.backend5.invoke_doc_exists()) # Test use of backend that another domain owns but has granted access self.domain_obj.default_sms_backend_id = self.backend6._id self.domain_obj.save() self.assertTrue( send_sms(self.domain, None, "25800000000", "Test for BACKEND6")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertTrue(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend6.delete_invoke_doc() self.assertFalse(self.backend6.invoke_doc_exists()) # Test backend access control self.domain_obj.default_sms_backend_id = self.backend7._id self.domain_obj.save() self.assertFalse( send_sms(self.domain, None, "25800000000", "Test for BACKEND7")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) # Test sending to verified number with backend map self.domain_obj.default_sms_backend_id = None self.domain_obj.save() verified_number = self.contact.get_verified_number() self.assertTrue(verified_number is not None) self.assertTrue(verified_number.backend_id is None) self.assertEqual(verified_number.phone_number, "15551234567") self.assertTrue( send_sms_to_verified_number(verified_number, "Test for BACKEND2")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertTrue(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend2.delete_invoke_doc() self.assertFalse(self.backend2.invoke_doc_exists()) # Test sending to verified number with default domain backend self.domain_obj.default_sms_backend_id = self.backend5._id self.domain_obj.save() self.assertTrue( send_sms_to_verified_number(verified_number, "Test for BACKEND5")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertTrue(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend5.delete_invoke_doc() self.assertFalse(self.backend5.invoke_doc_exists()) # Test sending to verified number with a contact-level backend owned by the domain self.case.set_case_property("contact_backend_id", "BACKEND") self.case.save() self.contact = CommConnectCase.wrap(self.case.to_json()) verified_number = self.contact.get_verified_number() self.assertTrue(verified_number is not None) self.assertEqual(verified_number.backend_id, "BACKEND") self.assertEqual(verified_number.phone_number, "15551234567") self.assertTrue( send_sms_to_verified_number(verified_number, "Test for BACKEND")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertTrue(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend8.delete_invoke_doc() self.assertFalse(self.backend8.invoke_doc_exists()) # Test sending to verified number with a contact-level backend granted to the domain by another domain self.backend8.delete() self.assertTrue( send_sms_to_verified_number(verified_number, "Test for BACKEND")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertTrue(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend9.delete_invoke_doc() self.assertFalse(self.backend9.invoke_doc_exists()) # Test sending to verified number with a contact-level global backend self.backend9.delete() self.assertTrue( send_sms_to_verified_number(verified_number, "Test for BACKEND")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertTrue(self.backend10.invoke_doc_exists()) self.backend10.delete_invoke_doc() self.assertFalse(self.backend10.invoke_doc_exists()) # Test raising exception if contact-level backend is not found self.backend10.delete() try: self.assertTrue( send_sms_to_verified_number(verified_number, "Test for BACKEND")) except BadSMSConfigException: pass else: self.assertTrue(False) # Test send_sms_with_backend self.assertTrue( send_sms_with_backend(self.domain, "+15551234567", "Test for BACKEND3", self.backend3._id)) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertTrue(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.backend3.delete_invoke_doc() self.assertFalse(self.backend3.invoke_doc_exists()) # Test send_sms_with_backend_name self.assertTrue( send_sms_with_backend_name(self.domain, "+15551234567", "Test for BACKEND3", "BACKEND3")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertTrue(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.backend3.delete_invoke_doc() self.assertFalse(self.backend3.invoke_doc_exists())
class StartConditionReminderTestCase(BaseReminderTestCase): def setUp(self): super(StartConditionReminderTestCase, self).setUp() self.domain = "test" self.user_id = "USER-ID-109351" self.user = CommCareUser.create(self.domain, 'chw.bob5', '****', uuid=self.user_id, phone_number="99912345") self.handler1 = CaseReminderHandler( domain=self.domain, case_type="case_type_a", method=METHOD_SMS, start_property='start_sending1', start_value="^(ok|OK|\d\d\d\d-\d\d-\d\d)", start_date='start_sending1', start_offset=1, start_match_type=MATCH_REGEX, until='stop_sending1', default_lang='en', max_iteration_count=REPEAT_SCHEDULE_INDEFINITELY, schedule_length=3, event_interpretation=EVENT_AS_OFFSET, events = [ CaseReminderEvent( day_num = 0 ,fire_time = time(0,0,0) ,message={"en":"Message1"} ,callback_timeout_intervals=[] ) ] ) self.handler1.save() self.case1 = CommCareCase( domain=self.domain, type="case_type_a", user_id=self.user_id ) self.case1.save() def tearDown(self): self.user.delete() super(StartConditionReminderTestCase, self).tearDown() def test_ok(self): # # Test changing a start condition of "ok" # # Spawn the reminder with an "ok" start condition value CaseReminderHandler.now = datetime(year=2012, month=2, day=17, hour=12, minute=0) self.assertEqual(self.handler1.get_reminder(self.case1), None) self.case1.set_case_property("start_sending1", "ok") self.case1.save() reminder = self.handler1.get_reminder(self.case1) self.assertNotEqual(reminder, None) self.assertEqual( reminder.next_fire ,CaseReminderHandler.now + timedelta(days=self.handler1.start_offset) ) # Test that saving the case without changing the start condition has no effect old_reminder_id = reminder._id self.case1.set_case_property("case_property1", "abc") self.case1.save() reminder = self.handler1.get_reminder(self.case1) self.assertNotEqual(reminder, None) self.assertEqual(reminder._id, old_reminder_id) # Test retiring the reminder old_reminder_id = reminder._id self.case1.set_case_property("start_sending1", None) self.case1.save() self.assertEqual(self.handler1.get_reminder(self.case1), None) self.assertEqual(CaseReminder.get(old_reminder_id).doc_type, "CaseReminder-Deleted") # # Test changing a start condition which is a datetime value # # Spawn the reminder with datetime start condition value start = datetime(2012,2,20,9,0,0) self.case1.set_case_property("start_sending1", start) self.case1.save() reminder = self.handler1.get_reminder(self.case1) self.assertNotEqual(reminder, None) self.assertEqual( reminder.next_fire ,start + timedelta(days=self.handler1.start_offset) ) # Reset the datetime start condition old_reminder_id = reminder._id start = datetime(2012,2,22,10,15,0) self.case1.set_case_property("start_sending1", start) self.case1.save() reminder = self.handler1.get_reminder(self.case1) self.assertNotEqual(reminder, None) self.assertEqual( reminder.next_fire ,start + timedelta(days=self.handler1.start_offset) ) self.assertEqual(CaseReminder.get(old_reminder_id).doc_type, "CaseReminder-Deleted") # Test that saving the case without changing the start condition has no effect old_reminder_id = reminder._id self.case1.set_case_property("case_property1", "xyz") self.case1.save() reminder = self.handler1.get_reminder(self.case1) self.assertNotEqual(reminder, None) self.assertEqual(reminder._id, old_reminder_id) # Retire the reminder old_reminder_id = reminder._id self.case1.set_case_property("start_sending1", None) self.case1.save() reminder = self.handler1.get_reminder(self.case1) self.assertEqual(reminder, None) self.assertEqual(CaseReminder.get(old_reminder_id).doc_type, "CaseReminder-Deleted") # # Test changing a start condition which is a date value # # Spawn the reminder with date start condition value start = date(2012,2,20) self.case1.set_case_property("start_sending1", start) self.case1.save() reminder = self.handler1.get_reminder(self.case1) self.assertNotEqual(reminder, None) self.assertEqual( reminder.next_fire ,datetime(start.year, start.month, start.day) + timedelta(days=self.handler1.start_offset) ) # Reset the date start condition old_reminder_id = reminder._id start = date(2012,2,22) self.case1.set_case_property("start_sending1", start) self.case1.save() reminder = self.handler1.get_reminder(self.case1) self.assertNotEqual(reminder, None) self.assertEqual( reminder.next_fire ,datetime(start.year, start.month, start.day) + timedelta(days=self.handler1.start_offset) ) self.assertEqual(CaseReminder.get(old_reminder_id).doc_type, "CaseReminder-Deleted") # Test that saving the case without changing the start condition has no effect old_reminder_id = reminder._id self.case1.set_case_property("case_property1", "abc") self.case1.save() reminder = self.handler1.get_reminder(self.case1) self.assertNotEqual(reminder, None) self.assertEqual(reminder._id, old_reminder_id) # Retire the reminder old_reminder_id = reminder._id self.case1.set_case_property("start_sending1", None) self.case1.save() reminder = self.handler1.get_reminder(self.case1) self.assertEqual(reminder, None) self.assertEqual(CaseReminder.get(old_reminder_id).doc_type, "CaseReminder-Deleted") # # Test changing a start condition which is a string representation of a datetime value # # Spawn the reminder with datetime start condition value self.case1.set_case_property("start_sending1", "2012-02-25 11:15") self.case1.save() reminder = self.handler1.get_reminder(self.case1) self.assertNotEqual(reminder, None) self.assertEqual( reminder.next_fire ,datetime(2012,2,25,11,15) + timedelta(days=self.handler1.start_offset) ) # Reset the datetime start condition old_reminder_id = reminder._id self.case1.set_case_property("start_sending1", "2012-02-26 11:20") self.case1.save() reminder = self.handler1.get_reminder(self.case1) self.assertNotEqual(reminder, None) self.assertEqual( reminder.next_fire ,datetime(2012,2,26,11,20) + timedelta(days=self.handler1.start_offset) ) self.assertEqual(CaseReminder.get(old_reminder_id).doc_type, "CaseReminder-Deleted") # Test that saving the case without changing the start condition has no effect old_reminder_id = reminder._id self.case1.set_case_property("case_property1", "xyz") self.case1.save() reminder = self.handler1.get_reminder(self.case1) self.assertNotEqual(reminder, None) self.assertEqual(reminder._id, old_reminder_id) # Retire the reminder old_reminder_id = reminder._id self.case1.set_case_property("start_sending1", None) self.case1.save() reminder = self.handler1.get_reminder(self.case1) self.assertEqual(reminder, None) self.assertEqual(CaseReminder.get(old_reminder_id).doc_type, "CaseReminder-Deleted")
class CaseTypeReminderTestCase(BaseReminderTestCase): def setUp(self): super(CaseTypeReminderTestCase, self).setUp() self.domain = "test" self.user_id = "USER-ID-109350" self.user = CommCareUser.create(self.domain, 'chw.bob4', '****', uuid=self.user_id, phone_number="99912345") self.handler1 = CaseReminderHandler( domain=self.domain, case_type="case_type_a", method=METHOD_SMS, start_property='start_sending1', start_value=None, start_date=None, start_offset=1, start_match_type=MATCH_ANY_VALUE, until='stop_sending1', default_lang='en', max_iteration_count=REPEAT_SCHEDULE_INDEFINITELY, schedule_length=3, event_interpretation=EVENT_AS_OFFSET, events = [ CaseReminderEvent( day_num = 0 ,fire_time = time(0,0,0) ,message={"en":"Message1"} ,callback_timeout_intervals=[] ) ] ) self.handler1.save() self.handler2 = CaseReminderHandler( domain=self.domain, case_type="case_type_a", method=METHOD_SMS, start_property='start_sending2', start_value=None, start_date=None, start_offset=2, start_match_type=MATCH_ANY_VALUE, until='stop_sending2', default_lang='en', max_iteration_count=REPEAT_SCHEDULE_INDEFINITELY, schedule_length=3, event_interpretation=EVENT_AS_OFFSET, events = [ CaseReminderEvent( day_num = 0 ,fire_time = time(0,0,0) ,message={"en":"Message2"} ,callback_timeout_intervals=[] ) ] ) self.handler2.save() self.handler3 = CaseReminderHandler( domain=self.domain, case_type="case_type_a", method=METHOD_SMS, start_property='start_sending3', start_value=None, start_date=None, start_offset=3, start_match_type=MATCH_ANY_VALUE, until='stop_sending3', default_lang='en', max_iteration_count=REPEAT_SCHEDULE_INDEFINITELY, schedule_length=3, event_interpretation=EVENT_AS_OFFSET, events = [ CaseReminderEvent( day_num = 0 ,fire_time = time(0,0,0) ,message={"en":"Message3"} ,callback_timeout_intervals=[] ) ] ) self.handler3.save() self.case1 = CommCareCase( domain=self.domain, type="case_type_a", user_id=self.user_id ) self.case1.save() self.case2 = CommCareCase( domain=self.domain, type="case_type_b", user_id=self.user_id ) self.case2.save() def tearDown(self): self.user.delete() super(CaseTypeReminderTestCase, self).tearDown() def test_ok(self): # Initial condition CaseReminderHandler.now = datetime(year=2012, month=2, day=16, hour=11, minute=0) self.case1.set_case_property("start_sending1", "ok") self.case1.set_case_property("start_sending2", "ok") self.case2.set_case_property("start_sending1", "ok") self.case2.set_case_property("start_sending3", "ok") self.case1.save() self.case2.save() self.assertNotEqual(self.handler1.get_reminder(self.case1), None) self.assertEqual(self.handler1.get_reminder(self.case2), None) self.assertNotEqual(self.handler2.get_reminder(self.case1), None) self.assertEqual(self.handler2.get_reminder(self.case2), None) self.assertEqual(self.handler3.get_reminder(self.case1), None) self.assertEqual(self.handler3.get_reminder(self.case2), None) self.assertEqual( self.handler1.get_reminder(self.case1).next_fire ,CaseReminderHandler.now + timedelta(days=self.handler1.start_offset) ) self.assertEqual( self.handler2.get_reminder(self.case1).next_fire ,CaseReminderHandler.now + timedelta(days=self.handler2.start_offset) ) # Test deactivation and spawn on change of CaseReminderHandler.case_type CaseReminderHandler.now = datetime(year=2012, month=2, day=16, hour=11, minute=15) self.handler1.case_type = "case_type_b" self.handler1.save() self.handler2.case_type = "case_type_b" self.handler2.save() self.handler3.case_type = "case_type_b" self.handler3.save() self.assertEqual(self.handler1.get_reminder(self.case1), None) self.assertNotEqual(self.handler1.get_reminder(self.case2), None) self.assertEqual(self.handler2.get_reminder(self.case1), None) self.assertEqual(self.handler2.get_reminder(self.case2), None) self.assertEqual(self.handler3.get_reminder(self.case1), None) self.assertNotEqual(self.handler3.get_reminder(self.case2), None) self.assertEqual( self.handler1.get_reminder(self.case2).next_fire ,CaseReminderHandler.now + timedelta(days=self.handler1.start_offset) ) self.assertEqual( self.handler3.get_reminder(self.case2).next_fire ,CaseReminderHandler.now + timedelta(days=self.handler3.start_offset) ) # Test spawn on change of Case.type prev_now = CaseReminderHandler.now CaseReminderHandler.now = datetime(year=2012, month=2, day=16, hour=11, minute=30) self.case1.type = "case_type_b" self.case1.save() self.assertNotEqual(self.handler1.get_reminder(self.case1), None) self.assertNotEqual(self.handler1.get_reminder(self.case2), None) self.assertNotEqual(self.handler2.get_reminder(self.case1), None) self.assertEqual(self.handler2.get_reminder(self.case2), None) self.assertEqual(self.handler3.get_reminder(self.case1), None) self.assertNotEqual(self.handler3.get_reminder(self.case2), None) self.assertEqual( self.handler1.get_reminder(self.case1).next_fire ,CaseReminderHandler.now + timedelta(days=self.handler1.start_offset) ) self.assertEqual( self.handler2.get_reminder(self.case1).next_fire ,CaseReminderHandler.now + timedelta(days=self.handler2.start_offset) ) self.assertEqual( self.handler1.get_reminder(self.case2).next_fire ,prev_now + timedelta(days=self.handler1.start_offset) ) self.assertEqual( self.handler3.get_reminder(self.case2).next_fire ,prev_now + timedelta(days=self.handler3.start_offset) ) # Test deactivation on change of Case.type prev_now = CaseReminderHandler.now CaseReminderHandler.now = datetime(year=2012, month=2, day=16, hour=11, minute=45) self.case2.type = "case_type_a" self.case2.save() self.assertNotEqual(self.handler1.get_reminder(self.case1), None) self.assertEqual(self.handler1.get_reminder(self.case2), None) self.assertNotEqual(self.handler2.get_reminder(self.case1), None) self.assertEqual(self.handler2.get_reminder(self.case2), None) self.assertEqual(self.handler3.get_reminder(self.case1), None) self.assertEqual(self.handler3.get_reminder(self.case2), None) self.assertEqual( self.handler1.get_reminder(self.case1).next_fire ,prev_now + timedelta(days=self.handler1.start_offset) ) self.assertEqual( self.handler2.get_reminder(self.case1).next_fire ,prev_now + timedelta(days=self.handler2.start_offset) )
class ReminderTestCase(BaseReminderTestCase): """ This is the original use case and tests a fixed reminder schedule. """ def setUp(self): super(ReminderTestCase, self).setUp() self.domain = "test" self.case_type = "my_case_type" self.message = "Hey you're getting this message." self.handler = CaseReminderHandler( domain=self.domain, case_type=self.case_type, method=METHOD_SMS, start_property='start_sending', start_value="ok", start_date=None, start_offset=1, start_match_type=MATCH_EXACT, until='stop_sending', default_lang='en', max_iteration_count=REPEAT_SCHEDULE_INDEFINITELY, schedule_length=3, event_interpretation=EVENT_AS_OFFSET, events = [ CaseReminderEvent( day_num = 0 ,fire_time = time(0,0,0) ,message={"en":self.message} ,callback_timeout_intervals=[] ) ] ) self.handler.save() self.user_id = "USER-ID-109347" self.user = CommCareUser.create(self.domain, 'chw.bob', '****', uuid=self.user_id, phone_number="99912345") self.case = CommCareCase( domain=self.domain, type=self.case_type, user_id=self.user_id, ) self.case.save() def tearDown(self): self.user.delete() super(ReminderTestCase, self).tearDown() def test_ok(self): self.assertEqual(self.handler.events[0].message['en'], self.message) self.assertEqual(self.handler.get_reminder(self.case), None) # create reminder CaseReminderHandler.now = datetime(year=2011, month=7, day=7, hour=19, minute=8) self.case.set_case_property('start_sending', 'ok') self.case.save() CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual( reminder.next_fire, CaseReminderHandler.now + timedelta(days=self.handler.start_offset) ) self.assertEqual(reminder.last_fired, None) # fire a day after created CaseReminderHandler.now = datetime(year=2011, month=7, day=8, hour=19, minute=8) self.case.set_case_property('irrelevant_1', 'ok') self.case.save() CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual( reminder.next_fire, CaseReminderHandler.now + timedelta(days=self.handler.schedule_length) ) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) # Shouldn't fire until three days after created last_fired = CaseReminderHandler.now CaseReminderHandler.now = datetime(year=2011, month=7, day=9, hour=19, minute=8) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.last_fired, last_fired) self.assertEqual( reminder.next_fire, last_fired + timedelta(days=self.handler.schedule_length) ) # fire three days after last fired CaseReminderHandler.now = datetime(year=2011, month=7, day=11, hour=19, minute=8) self.case.set_case_property('irrelevant_2', 'ok') self.case.save() CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual( reminder.next_fire, CaseReminderHandler.now + timedelta(days=self.handler.schedule_length) ) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) # set stop_sending to 'ok' should make it stop sending and make the reminder inactive last_fired = CaseReminderHandler.now CaseReminderHandler.now = datetime(year=2011, month=7, day=14, hour=19, minute=8) self.case.set_case_property('stop_sending', 'ok') self.case.save() CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.last_fired, last_fired) self.assertEqual(reminder.active, False)
class ReminderCallbackTestCase(BaseReminderTestCase): """ This use case represents a reminder schedule with an expected callback: Day1: 10:00 Callback Message 1 [simple reminder] Day1: 11:00 Callback Message 2 [expects callback] Day1: 11:15 Callback Message 2 [15-minute timeout if callback is not received] Day1: 11:45 Callback Message 2 [30-minute timeout if callback is not received] Day2: (same as Day1) Day3: (same as Day1) This case also tests handling of time zones using the timezone of Africa/Nairobi (UTC+3). """ def setUp(self): super(ReminderCallbackTestCase, self).setUp() self.domain = "test" self.case_type = "my_case_type" self.message_1 = "Callback Message 1" self.message_2 = "Callback Message 2" self.handler = CaseReminderHandler( domain=self.domain, case_type=self.case_type, method=METHOD_SMS_CALLBACK, start_property='start_sending', start_value=None, start_date=None, start_offset=0, start_match_type=MATCH_ANY_VALUE, until='stop_sending', default_lang='en', max_iteration_count=3, schedule_length=1, event_interpretation=EVENT_AS_SCHEDULE, events = [ CaseReminderEvent( day_num = 0 ,fire_time = time(10,00,00) ,message={"en":self.message_1} ,callback_timeout_intervals=[] ) ,CaseReminderEvent( day_num = 0 ,fire_time = time(11,00,00) ,message={"en":self.message_2} ,callback_timeout_intervals=[15,30] ) ] ) self.handler.save() self.user_id = "USER-ID-109349" self.user = CommCareUser.create(self.domain, 'chw.bob3', '****', uuid=self.user_id, phone_number="99912345") self.user.user_data["time_zone"]="Africa/Nairobi" self.user.save() self.case = CommCareCase( domain=self.domain, type=self.case_type, user_id=self.user_id ) self.case.save() self.user.save_verified_number("test", "14445551234", True, None) def tearDown(self): self.user.delete() super(ReminderCallbackTestCase, self).tearDown() def test_ok(self): self.assertEqual(self.handler.get_reminder(self.case), None) # Spawn CaseReminder CaseReminderHandler.now = datetime(year=2011, month=12, day=31, hour=23, minute=0) self.case.set_case_property('start_sending', 'ok') self.case.save() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=1, hour=7, minute=0)) self.assertEqual(reminder.start_date, date(year=2012, month=1, day=1)) self.assertEqual(reminder.schedule_iteration_num, 1) self.assertEqual(reminder.current_event_sequence_num, 0) self.assertEqual(reminder.last_fired, None) ###################### # Day1, 10:00 reminder CaseReminderHandler.now = datetime(year=2012, month=1, day=1, hour=7, minute=0) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=1, hour=8, minute=0)) self.assertEqual(reminder.schedule_iteration_num, 1) self.assertEqual(reminder.current_event_sequence_num, 1) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) # Day1, 11:00 reminder CaseReminderHandler.now = datetime(year=2012, month=1, day=1, hour=8, minute=1) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=1, hour=8, minute=15)) self.assertEqual(reminder.schedule_iteration_num, 1) self.assertEqual(reminder.current_event_sequence_num, 1) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) event = ExpectedCallbackEventLog.view("sms/expected_callback_event", key=["test", json_format_datetime(datetime(year=2012, month=1, day=1, hour=8, minute=1)), self.user_id], include_docs=True).one() self.assertNotEqual(event, None) self.assertEqual(event.status, CALLBACK_PENDING) # Create a callback c = CallLog( couch_recipient_doc_type = "CommCareUser", couch_recipient = self.user_id, phone_number = "14445551234", direction = "I", date = datetime(year=2012, month=1, day=1, hour=8, minute=5) ) c.save() # Day1, 11:15 timeout (should move on to next event) CaseReminderHandler.now = datetime(year=2012, month=1, day=1, hour=8, minute=15) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=1, hour=8, minute=45)) self.assertEqual(reminder.schedule_iteration_num, 1) self.assertEqual(reminder.current_event_sequence_num, 1) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) # Day1, 11:45 timeout (should move on to next event) CaseReminderHandler.now = datetime(year=2012, month=1, day=1, hour=8, minute=45) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=2, hour=7, minute=0)) self.assertEqual(reminder.schedule_iteration_num, 2) self.assertEqual(reminder.current_event_sequence_num, 0) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) event = ExpectedCallbackEventLog.view("sms/expected_callback_event", key=["test", json_format_datetime(datetime(year=2012, month=1, day=1, hour=8, minute=1)), self.user_id], include_docs=True).one() self.assertNotEqual(event, None) self.assertEqual(event.status, CALLBACK_RECEIVED) ###################### # Day2, 10:00 reminder CaseReminderHandler.now = datetime(year=2012, month=1, day=2, hour=7, minute=0) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=2, hour=8, minute=0)) self.assertEqual(reminder.schedule_iteration_num, 2) self.assertEqual(reminder.current_event_sequence_num, 1) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) # Day2, 11:00 reminder CaseReminderHandler.now = datetime(year=2012, month=1, day=2, hour=8, minute=1) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=2, hour=8, minute=15)) self.assertEqual(reminder.schedule_iteration_num, 2) self.assertEqual(reminder.current_event_sequence_num, 1) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) event = ExpectedCallbackEventLog.view("sms/expected_callback_event", key=["test", json_format_datetime(datetime(year=2012, month=1, day=2, hour=8, minute=1)), self.user_id], include_docs=True).one() self.assertNotEqual(event, None) self.assertEqual(event.status, CALLBACK_PENDING) # Day2, 11:15 timeout (should move on to next timeout) CaseReminderHandler.now = datetime(year=2012, month=1, day=2, hour=8, minute=15) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=2, hour=8, minute=45)) self.assertEqual(reminder.schedule_iteration_num, 2) self.assertEqual(reminder.current_event_sequence_num, 1) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) event = ExpectedCallbackEventLog.view("sms/expected_callback_event", key=["test", json_format_datetime(datetime(year=2012, month=1, day=2, hour=8, minute=1)), self.user_id], include_docs=True).one() self.assertNotEqual(event, None) self.assertEqual(event.status, CALLBACK_PENDING) # Day2, 11:45 timeout (should move on to next day) CaseReminderHandler.now = datetime(year=2012, month=1, day=2, hour=8, minute=45) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=3, hour=7, minute=0)) self.assertEqual(reminder.schedule_iteration_num, 3) self.assertEqual(reminder.current_event_sequence_num, 0) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) event = ExpectedCallbackEventLog.view("sms/expected_callback_event", key=["test", json_format_datetime(datetime(year=2012, month=1, day=2, hour=8, minute=1)), self.user_id], include_docs=True).one() self.assertNotEqual(event, None) self.assertEqual(event.status, CALLBACK_MISSED) ###################### # Day3, 10:00 reminder CaseReminderHandler.now = datetime(year=2012, month=1, day=3, hour=7, minute=0) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=3, hour=8, minute=0)) self.assertEqual(reminder.schedule_iteration_num, 3) self.assertEqual(reminder.current_event_sequence_num, 1) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) # Day3, 11:00 reminder CaseReminderHandler.now = datetime(year=2012, month=1, day=3, hour=8, minute=1) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=3, hour=8, minute=15)) self.assertEqual(reminder.schedule_iteration_num, 3) self.assertEqual(reminder.current_event_sequence_num, 1) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) event = ExpectedCallbackEventLog.view("sms/expected_callback_event", key=["test", json_format_datetime(datetime(year=2012, month=1, day=3, hour=8, minute=1)), self.user_id], include_docs=True).one() self.assertNotEqual(event, None) self.assertEqual(event.status, CALLBACK_PENDING) # Day3, 11:15 timeout (should move on to next timeout) CaseReminderHandler.now = datetime(year=2012, month=1, day=3, hour=8, minute=15) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=3, hour=8, minute=45)) self.assertEqual(reminder.schedule_iteration_num, 3) self.assertEqual(reminder.current_event_sequence_num, 1) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) event = ExpectedCallbackEventLog.view("sms/expected_callback_event", key=["test", json_format_datetime(datetime(year=2012, month=1, day=3, hour=8, minute=1)), self.user_id], include_docs=True).one() self.assertNotEqual(event, None) self.assertEqual(event.status, CALLBACK_PENDING) # Create a callback (with phone_number missing country code) c = CallLog( couch_recipient_doc_type = "CommCareUser", couch_recipient = self.user_id, phone_number = "4445551234", direction = "I", date = datetime(year=2012, month=1, day=3, hour=8, minute=22) ) c.save() # Day3, 11:45 timeout (should deactivate the reminder) CaseReminderHandler.now = datetime(year=2012, month=1, day=3, hour=8, minute=45) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.schedule_iteration_num, 4) self.assertEqual(reminder.current_event_sequence_num, 0) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) self.assertEqual(reminder.active, False) event = ExpectedCallbackEventLog.view("sms/expected_callback_event", key=["test", json_format_datetime(datetime(year=2012, month=1, day=3, hour=8, minute=1)), self.user_id], include_docs=True).one() self.assertNotEqual(event, None) self.assertEqual(event.status, CALLBACK_RECEIVED)
class ReminderIrregularScheduleTestCase(BaseReminderTestCase): """ This use case represents an irregular reminder schedule which is repeated twice: Week1: Day1: 10:00 Message 1 Week1: Day4: 11:00 Message 2 Week1: Day4: 11:30 Message 3 Week2: Day1: 10:00 Message 1 Week2: Day4: 11:00 Message 2 Week2: Day4: 11:30 Message 3 """ def setUp(self): super(ReminderIrregularScheduleTestCase, self).setUp() self.domain = "test" self.case_type = "my_case_type" self.message_1 = "Message 1" self.message_2 = "Message 2" self.message_3 = "Message 3" self.handler = CaseReminderHandler( domain=self.domain, case_type=self.case_type, method=METHOD_SMS, start_property='start_sending', start_value=None, start_date=None, start_offset=1, start_match_type=MATCH_ANY_VALUE, until='stop_sending', default_lang='en', max_iteration_count=2, schedule_length=7, event_interpretation=EVENT_AS_SCHEDULE, events = [ CaseReminderEvent( day_num = 0 ,fire_time = time(10,00,00) ,message={"en":self.message_1} ,callback_timeout_intervals=[] ) ,CaseReminderEvent( day_num = 3 ,fire_time = time(11,00,00) ,message={"en":self.message_2} ,callback_timeout_intervals=[] ) ,CaseReminderEvent( day_num = 3 ,fire_time = time(11,30,00) ,message={"en":self.message_3} ,callback_timeout_intervals=[] ) ] ) self.handler.save() self.user_id = "USER-ID-109348" self.user = CommCareUser.create(self.domain, 'chw.bob2', '****', uuid=self.user_id, phone_number="99912345") self.case = CommCareCase( domain=self.domain, type=self.case_type, user_id=self.user_id, ) self.case.save() def tearDown(self): self.user.delete() super(ReminderIrregularScheduleTestCase, self).tearDown() def test_ok(self): self.assertEqual(self.handler.get_reminder(self.case), None) # Spawn CaseReminder CaseReminderHandler.now = datetime(year=2012, month=1, day=1, hour=4, minute=0) self.case.set_case_property('start_sending', 'ok') self.case.save() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=2, hour=10, minute=0)) self.assertEqual(reminder.start_date, date(year=2012, month=1, day=1)) self.assertEqual(reminder.schedule_iteration_num, 1) self.assertEqual(reminder.current_event_sequence_num, 0) self.assertEqual(reminder.last_fired, None) # Not yet the first fire time, nothing should happen CaseReminderHandler.now = datetime(year=2012, month=1, day=2, hour=9, minute=45) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=2, hour=10, minute=0)) self.assertEqual(reminder.schedule_iteration_num, 1) self.assertEqual(reminder.current_event_sequence_num, 0) self.assertEqual(reminder.last_fired, None) # Week1, Day1, 10:00 reminder CaseReminderHandler.now = datetime(year=2012, month=1, day=2, hour=10, minute=7) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=5, hour=11, minute=0)) self.assertEqual(reminder.schedule_iteration_num, 1) self.assertEqual(reminder.current_event_sequence_num, 1) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) # Week1, Day4, 11:00 reminder CaseReminderHandler.now = datetime(year=2012, month=1, day=5, hour=11, minute=3) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=5, hour=11, minute=30)) self.assertEqual(reminder.schedule_iteration_num, 1) self.assertEqual(reminder.current_event_sequence_num, 2) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) # Week1, Day4, 11:30 reminder CaseReminderHandler.now = datetime(year=2012, month=1, day=5, hour=11, minute=30) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=9, hour=10, minute=0)) self.assertEqual(reminder.schedule_iteration_num, 2) self.assertEqual(reminder.current_event_sequence_num, 0) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) # Week2, Day1, 10:00 reminder CaseReminderHandler.now = datetime(year=2012, month=1, day=9, hour=10, minute=0) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=12, hour=11, minute=0)) self.assertEqual(reminder.schedule_iteration_num, 2) self.assertEqual(reminder.current_event_sequence_num, 1) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) # Week2, Day4, 11:00 reminder CaseReminderHandler.now = datetime(year=2012, month=1, day=12, hour=11, minute=0) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.next_fire, datetime(year=2012, month=1, day=12, hour=11, minute=30)) self.assertEqual(reminder.schedule_iteration_num, 2) self.assertEqual(reminder.current_event_sequence_num, 2) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) # Week2, Day4, 11:30 reminder CaseReminderHandler.now = datetime(year=2012, month=1, day=12, hour=11, minute=31) CaseReminderHandler.fire_reminders() reminder = self.handler.get_reminder(self.case) self.assertNotEqual(reminder, None) self.assertEqual(reminder.schedule_iteration_num, 3) self.assertEqual(reminder.current_event_sequence_num, 0) self.assertEqual(reminder.last_fired, CaseReminderHandler.now) self.assertEqual(reminder.active, False)
class ReminderLockTestCase(BaseReminderTestCase): def setUp(self): super(ReminderLockTestCase, self).setUp() self.domain = "test" self.user_id = "USER-ID-109352" self.user = CommCareUser.create(self.domain, 'chw.bob6', '****', uuid=self.user_id, phone_number="99912345") self.handler1 = CaseReminderHandler( domain=self.domain, case_type="case_type_a", method=METHOD_SMS, start_property='start_sending1', start_value="^(ok|OK|\d\d\d\d-\d\d-\d\d)", start_date='start_sending1', start_offset=1, start_match_type=MATCH_REGEX, until='stop_sending1', default_lang='en', max_iteration_count=REPEAT_SCHEDULE_INDEFINITELY, schedule_length=3, event_interpretation=EVENT_AS_OFFSET, events = [ CaseReminderEvent( day_num = 0 ,fire_time = time(0,0,0) ,message={"en":"Testing the lock"} ,callback_timeout_intervals=[] ) ] ) self.handler1.save() self.case1 = CommCareCase( domain=self.domain, type="case_type_a", user_id=self.user_id ) self.case1.save() def tearDown(self): self.user.delete() super(ReminderLockTestCase, self).tearDown() def test_ok(self): # Spawn the reminder with an "ok" start condition value CaseReminderHandler.now = datetime(year=2012, month=2, day=17, hour=12, minute=0) self.assertEqual(self.handler1.get_reminder(self.case1), None) self.case1.set_case_property("start_sending1", "ok") self.case1.save() reminder = self.handler1.get_reminder(self.case1) old_reminder = self.handler1.get_reminder(self.case1) self.assertNotEqual(reminder, None) self.assertEqual( reminder.next_fire ,CaseReminderHandler.now + timedelta(days=self.handler1.start_offset) ) # Fire the reminder, testing that the locking process works CaseReminderHandler.now = datetime(year=2012, month=2, day=18, hour=12, minute=1) self.assertEqual(reminder.lock_date, None) self.assertEqual(reminder.acquire_lock(CaseReminderHandler.now), True) self.assertEqual(reminder.lock_date, CaseReminderHandler.now) self.assertEqual(reminder.acquire_lock(CaseReminderHandler.now), False) self.handler1.fire(reminder) self.handler1.set_next_fire(reminder, CaseReminderHandler.now) reminder.release_lock() self.assertEqual(reminder.lock_date, None) # Ensure old versions of the document cannot acquire the lock self.assertNotEqual(reminder._rev, old_reminder._rev) self.assertEqual(old_reminder.acquire_lock(CaseReminderHandler.now), False) # Test the lock timeout self.assertEqual(reminder.acquire_lock(CaseReminderHandler.now), True) self.assertEqual(reminder.acquire_lock(CaseReminderHandler.now), False) self.assertEqual(reminder.acquire_lock(CaseReminderHandler.now + LOCK_EXPIRATION + timedelta(minutes = 1)), True)
class BackendTestCase(BaseAccountingTest): def get_or_create_site(self): site, created = Site.objects.get_or_create(id=settings.SITE_ID) if created: site.domain = 'localhost' site.name = 'localhost' site.save() return (site, created) def setUp(self): super(BackendTestCase, self).setUp() self.domain = "test-domain" self.domain2 = "test-domain2" self.site, self.site_created = self.get_or_create_site() self.domain_obj = Domain(name=self.domain) self.domain_obj.save() generator.instantiate_accounting_for_tests() self.account = BillingAccount.get_or_create_account_by_domain( self.domain_obj.name, created_by="automated-test", )[0] plan = DefaultProductPlan.get_default_plan_by_domain( self.domain_obj, edition=SoftwarePlanEdition.ADVANCED) self.subscription = Subscription.new_domain_subscription( self.account, self.domain_obj.name, plan) self.subscription.is_active = True self.subscription.save() self.domain_obj = Domain.get( self.domain_obj._id) # Prevent resource conflict self.backend1 = TestCaseBackend(name="BACKEND1", is_global=True) self.backend1.save() self.backend2 = TestCaseBackend(name="BACKEND2", is_global=True) self.backend2.save() self.backend3 = TestCaseBackend(name="BACKEND3", is_global=True) self.backend3.save() self.backend4 = TestCaseBackend(name="BACKEND4", is_global=True) self.backend4.save() self.backend5 = TestCaseBackend(name="BACKEND5", domain=self.domain, is_global=False, authorized_domains=[]) self.backend5.save() self.backend6 = TestCaseBackend(name="BACKEND6", domain=self.domain2, is_global=False, authorized_domains=[self.domain]) self.backend6.save() self.backend7 = TestCaseBackend(name="BACKEND7", domain=self.domain2, is_global=False, authorized_domains=[]) self.backend7.save() self.backend8 = TestCaseBackend(name="BACKEND", domain=self.domain, is_global=False, authorized_domains=[]) self.backend8.save() self.backend9 = TestCaseBackend(name="BACKEND", domain=self.domain2, is_global=False, authorized_domains=[self.domain]) self.backend9.save() self.backend10 = TestCaseBackend(name="BACKEND", is_global=True) self.backend10.save() self.backend_mapping1 = BackendMapping(is_global=True, prefix="*", backend_id=self.backend1._id) self.backend_mapping1.save() self.backend_mapping2 = BackendMapping(is_global=True, prefix="1", backend_id=self.backend2._id) self.backend_mapping2.save() self.backend_mapping3 = BackendMapping(is_global=True, prefix="91", backend_id=self.backend3._id) self.backend_mapping3.save() self.backend_mapping4 = BackendMapping(is_global=True, prefix="265", backend_id=self.backend4._id) self.backend_mapping4.save() self.backend_mapping5 = BackendMapping(is_global=True, prefix="256", backend_id=self.backend5._id) self.backend_mapping5.save() self.backend_mapping6 = BackendMapping(is_global=True, prefix="25670", backend_id=self.backend6._id) self.backend_mapping6.save() self.backend_mapping7 = BackendMapping(is_global=True, prefix="25675", backend_id=self.backend7._id) self.backend_mapping7.save() self.case = CommCareCase(domain=self.domain) self.case.set_case_property("contact_phone_number", "15551234567") self.case.set_case_property("contact_phone_number_is_verified", "1") self.case.save() self.contact = CommConnectCase.wrap(self.case.to_json()) settings.SMS_LOADED_BACKENDS.append( "corehq.apps.sms.tests.TestCaseBackend") def tearDown(self): self.backend1.delete_invoke_doc() self.backend1.delete() self.backend_mapping1.delete() self.backend2.delete_invoke_doc() self.backend2.delete() self.backend_mapping2.delete() self.backend3.delete_invoke_doc() self.backend3.delete() self.backend_mapping3.delete() self.backend4.delete_invoke_doc() self.backend4.delete() self.backend_mapping4.delete() self.backend5.delete_invoke_doc() self.backend5.delete() self.backend_mapping5.delete() self.backend6.delete_invoke_doc() self.backend6.delete() self.backend_mapping6.delete() self.backend7.delete_invoke_doc() self.backend7.delete() self.backend_mapping7.delete() self.contact.delete_verified_number() self.case.delete() SubscriptionAdjustment.objects.all().delete() self.subscription.delete() self.account.delete() self.domain_obj.delete() if self.site_created: self.site.delete() settings.SMS_LOADED_BACKENDS.pop() def test_multiple_country_prefixes(self): self.assertEqual( MobileBackend.auto_load('256800000000')._id, self.backend5._id) self.assertEqual( MobileBackend.auto_load('256700000000')._id, self.backend6._id) self.assertEqual( MobileBackend.auto_load('256750000000')._id, self.backend7._id) def test_backend(self): # Test the backend map self.assertTrue( send_sms(self.domain, None, "15551234567", "Test for BACKEND2")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertTrue(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend2.delete_invoke_doc() self.assertFalse(self.backend2.invoke_doc_exists()) self.assertTrue( send_sms(self.domain, None, "9100000000", "Test for BACKEND3")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertTrue(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend3.delete_invoke_doc() self.assertFalse(self.backend3.invoke_doc_exists()) self.assertTrue( send_sms(self.domain, None, "26500000000", "Test for BACKEND4")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertTrue(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend4.delete_invoke_doc() self.assertFalse(self.backend4.invoke_doc_exists()) self.assertTrue( send_sms(self.domain, None, "25800000000", "Test for BACKEND1")) self.assertTrue(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend1.delete_invoke_doc() self.assertFalse(self.backend1.invoke_doc_exists()) # Test overriding with a domain-level backend self.domain_obj = Domain.get( self.domain_obj._id) # Prevent resource conflict self.domain_obj.default_sms_backend_id = self.backend5._id self.domain_obj.save() self.assertTrue( send_sms(self.domain, None, "15551234567", "Test for BACKEND5")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertTrue(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend5.delete_invoke_doc() self.assertFalse(self.backend5.invoke_doc_exists()) # Test use of backend that another domain owns but has granted access self.domain_obj.default_sms_backend_id = self.backend6._id self.domain_obj.save() self.assertTrue( send_sms(self.domain, None, "25800000000", "Test for BACKEND6")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertTrue(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend6.delete_invoke_doc() self.assertFalse(self.backend6.invoke_doc_exists()) # Test backend access control self.domain_obj.default_sms_backend_id = self.backend7._id self.domain_obj.save() self.assertFalse( send_sms(self.domain, None, "25800000000", "Test for BACKEND7")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) # Test sending to verified number with backend map self.domain_obj.default_sms_backend_id = None self.domain_obj.save() verified_number = self.contact.get_verified_number() self.assertTrue(verified_number is not None) self.assertTrue(verified_number.backend_id is None) self.assertEqual(verified_number.phone_number, "15551234567") self.assertTrue( send_sms_to_verified_number(verified_number, "Test for BACKEND2")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertTrue(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend2.delete_invoke_doc() self.assertFalse(self.backend2.invoke_doc_exists()) # Test sending to verified number with default domain backend self.domain_obj.default_sms_backend_id = self.backend5._id self.domain_obj.save() self.assertTrue( send_sms_to_verified_number(verified_number, "Test for BACKEND5")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertTrue(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend5.delete_invoke_doc() self.assertFalse(self.backend5.invoke_doc_exists()) # Test sending to verified number with a contact-level backend owned by the domain self.case.set_case_property("contact_backend_id", "BACKEND") self.case.save() self.contact = CommConnectCase.wrap(self.case.to_json()) verified_number = self.contact.get_verified_number() self.assertTrue(verified_number is not None) self.assertEqual(verified_number.backend_id, "BACKEND") self.assertEqual(verified_number.phone_number, "15551234567") self.assertTrue( send_sms_to_verified_number(verified_number, "Test for BACKEND")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertTrue(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend8.delete_invoke_doc() self.assertFalse(self.backend8.invoke_doc_exists()) # Test sending to verified number with a contact-level backend granted to the domain by another domain self.backend8.delete() self.assertTrue( send_sms_to_verified_number(verified_number, "Test for BACKEND")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertTrue(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend9.delete_invoke_doc() self.assertFalse(self.backend9.invoke_doc_exists()) # Test sending to verified number with a contact-level global backend self.backend9.delete() self.assertTrue( send_sms_to_verified_number(verified_number, "Test for BACKEND")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertTrue(self.backend10.invoke_doc_exists()) self.backend10.delete_invoke_doc() self.assertFalse(self.backend10.invoke_doc_exists()) # Test raising exception if contact-level backend is not found self.backend10.delete() try: self.assertTrue( send_sms_to_verified_number(verified_number, "Test for BACKEND")) except BadSMSConfigException: pass else: self.assertTrue(False) # Test send_sms_with_backend self.assertTrue( send_sms_with_backend(self.domain, "+15551234567", "Test for BACKEND3", self.backend3._id)) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertTrue(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.backend3.delete_invoke_doc() self.assertFalse(self.backend3.invoke_doc_exists()) # Test send_sms_with_backend_name self.assertTrue( send_sms_with_backend_name(self.domain, "+15551234567", "Test for BACKEND3", "BACKEND3")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertTrue(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.backend3.delete_invoke_doc() self.assertFalse(self.backend3.invoke_doc_exists()) def test_sms_registration(self): formatted_username = format_username("tester", self.domain) incoming("+9991234567", "JOIN {} WORKER tester".format(self.domain), "TEST_CASE_BACKEND") # Test without mobile worker registration enabled self.assertIsNone(CommCareUser.get_by_username(formatted_username)) # Enable mobile worker registration setattr(self.domain_obj, "sms_mobile_worker_registration_enabled", True) self.domain_obj.save() incoming("+9991234567", "JOIN {} WORKER tester".format(self.domain), "TEST_CASE_BACKEND") self.assertIsNotNone(CommCareUser.get_by_username(formatted_username)) # Test a duplicate registration prev_num_users = num_mobile_users(self.domain) incoming("+9991234568", "JOIN {} WORKER tester".format(self.domain), "TEST_CASE_BACKEND") current_num_users = num_mobile_users(self.domain) self.assertEqual(prev_num_users, current_num_users)
def test_and_criteria(self): case = CommCareCase( domain=self.domain, type='test-case-type-2', server_modified_on=datetime(2015, 1, 1), ) self.rule2.automaticupdaterulecriteria_set = [ AutomaticUpdateRuleCriteria( property_name='last_visit_date', property_value='30', match_type=AutomaticUpdateRuleCriteria.MATCH_DAYS_SINCE, ), AutomaticUpdateRuleCriteria( property_name='property1', property_value='value1', match_type=AutomaticUpdateRuleCriteria.MATCH_EQUAL, ), AutomaticUpdateRuleCriteria( property_name='property2', property_value='value2', match_type=AutomaticUpdateRuleCriteria.MATCH_NOT_EQUAL, ), AutomaticUpdateRuleCriteria( property_name='property3', match_type=AutomaticUpdateRuleCriteria.MATCH_HAS_VALUE, ), ] case.set_case_property('last_visit_date', '2015-11-01') case.set_case_property('property1', 'value1') case.set_case_property('property2', 'x') case.set_case_property('property3', 'x') self.assertTrue(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property('last_visit_date', '2015-12-30') self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property('last_visit_date', '2015-11-01') case.set_case_property('property1', 'x') self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property('property1', 'value1') case.set_case_property('property2', 'value2') self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property('property2', 'x') case.set_case_property('property3', '') self.assertFalse(self.rule2.rule_matches_case(case, datetime(2016, 1, 1))) case.set_case_property('property3', 'x') self.assertTrue(self.rule2.rule_matches_case(case, datetime(2016, 1, 1)))
class OutgoingFrameworkTestCase(BaseSMSTest): def setUp(self): super(OutgoingFrameworkTestCase, self).setUp() self.domain = "test-domain" self.domain2 = "test-domain2" self.domain_obj = Domain(name=self.domain) self.domain_obj.save() self.create_account_and_subscription(self.domain_obj.name) self.domain_obj = Domain.get(self.domain_obj._id) self.backend1 = SQLTestSMSBackend.objects.create( name='BACKEND1', is_global=True, hq_api_id=SQLTestSMSBackend.get_api_id() ) self.backend2 = SQLTestSMSBackend.objects.create( name='BACKEND2', is_global=True, hq_api_id=SQLTestSMSBackend.get_api_id() ) self.backend3 = SQLTestSMSBackend.objects.create( name='BACKEND3', is_global=True, hq_api_id=SQLTestSMSBackend.get_api_id() ) self.backend4 = SQLTestSMSBackend.objects.create( name='BACKEND4', is_global=True, hq_api_id=SQLTestSMSBackend.get_api_id() ) self.backend5 = SQLTestSMSBackend.objects.create( name='BACKEND5', domain=self.domain, is_global=False, hq_api_id=SQLTestSMSBackend.get_api_id() ) self.backend6 = SQLTestSMSBackend.objects.create( name='BACKEND6', domain=self.domain2, is_global=False, hq_api_id=SQLTestSMSBackend.get_api_id() ) self.backend6.set_shared_domains([self.domain]) self.backend7 = SQLTestSMSBackend.objects.create( name='BACKEND7', domain=self.domain2, is_global=False, hq_api_id=SQLTestSMSBackend.get_api_id() ) self.backend8 = SQLTestSMSBackend.objects.create( name='BACKEND', domain=self.domain, is_global=False, hq_api_id=SQLTestSMSBackend.get_api_id() ) self.backend9 = SQLTestSMSBackend.objects.create( name='BACKEND', domain=self.domain2, is_global=False, hq_api_id=SQLTestSMSBackend.get_api_id() ) self.backend9.set_shared_domains([self.domain]) self.backend10 = SQLTestSMSBackend.objects.create( name='BACKEND', is_global=True, hq_api_id=SQLTestSMSBackend.get_api_id() ) self.backend_mapping1 = SQLMobileBackendMapping.objects.create( is_global=True, backend_type=SQLMobileBackend.SMS, prefix='*', backend=self.backend1 ) self.backend_mapping2 = SQLMobileBackendMapping.objects.create( is_global=True, backend_type=SQLMobileBackend.SMS, prefix='1', backend=self.backend2 ) self.backend_mapping3 = SQLMobileBackendMapping.objects.create( is_global=True, backend_type=SQLMobileBackend.SMS, prefix='91', backend=self.backend3 ) self.backend_mapping4 = SQLMobileBackendMapping.objects.create( is_global=True, backend_type=SQLMobileBackend.SMS, prefix='265', backend=self.backend4 ) self.backend_mapping5 = SQLMobileBackendMapping.objects.create( is_global=True, backend_type=SQLMobileBackend.SMS, prefix='256', backend=self.backend5 ) self.backend_mapping6 = SQLMobileBackendMapping.objects.create( is_global=True, backend_type=SQLMobileBackend.SMS, prefix='25670', backend=self.backend6 ) self.backend_mapping7 = SQLMobileBackendMapping.objects.create( is_global=True, backend_type=SQLMobileBackend.SMS, prefix='25675', backend=self.backend7 ) self.case = CommCareCase(domain=self.domain) self.case.set_case_property('contact_phone_number', '15551234567') self.case.set_case_property('contact_phone_number_is_verified', '1') self.case.save() self.contact = CommConnectCase.wrap(self.case.to_json()) def tearDown(self): delete_domain_phone_numbers(self.domain) delete_domain_phone_numbers(self.domain2) for obj in ( list(MobileBackendInvitation.objects.all()) + list(SQLMobileBackendMapping.objects.all()) ): # For now we can't do bulk delete because we need to have the # delete sync with couch obj.delete() self.backend1.delete() self.backend2.delete() self.backend3.delete() self.backend4.delete() self.backend5.delete() self.backend6.delete() self.backend7.delete() self.backend8.delete() self.backend9.delete() self.backend10.delete() self.contact.delete_verified_number() self.case.delete() self.domain_obj.delete() super(OutgoingFrameworkTestCase, self).tearDown() def test_multiple_country_prefixes(self): self.assertEqual( SQLMobileBackend.load_default_by_phone_and_domain( SQLMobileBackend.SMS, '256800000000' ).pk, self.backend5.pk ) self.assertEqual( SQLMobileBackend.load_default_by_phone_and_domain( SQLMobileBackend.SMS, '256700000000' ).pk, self.backend6.pk ) self.assertEqual( SQLMobileBackend.load_default_by_phone_and_domain( SQLMobileBackend.SMS, '256750000000' ).pk, self.backend7.pk ) def __test_global_backend_map(self): with patch( 'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send', autospec=True ) as mock_send: self.assertTrue(send_sms(self.domain, None, '15551234567', 'Test for BACKEND2')) self.assertEqual(mock_send.call_count, 1) self.assertEqual(mock_send.call_args[0][0].pk, self.backend2.pk) with patch( 'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send', autospec=True ) as mock_send: self.assertTrue(send_sms(self.domain, None, '9100000000', 'Test for BACKEND3')) self.assertEqual(mock_send.call_count, 1) self.assertEqual(mock_send.call_args[0][0].pk, self.backend3.pk) with patch( 'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send', autospec=True ) as mock_send: self.assertTrue(send_sms(self.domain, None, '26500000000', 'Test for BACKEND4')) self.assertEqual(mock_send.call_count, 1) self.assertEqual(mock_send.call_args[0][0].pk, self.backend4.pk) with patch( 'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send', autospec=True ) as mock_send: self.assertTrue(send_sms(self.domain, None, '25800000000', 'Test for BACKEND1')) self.assertEqual(mock_send.call_count, 1) self.assertEqual(mock_send.call_args[0][0].pk, self.backend1.pk) def __test_domain_default(self): # Test overriding with domain-level backend SQLMobileBackendMapping.set_default_domain_backend(self.domain, self.backend5) with patch( 'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send', autospec=True ) as mock_send: self.assertTrue(send_sms(self.domain, None, '15551234567', 'Test for BACKEND5')) self.assertEqual(mock_send.call_count, 1) self.assertEqual(mock_send.call_args[0][0].pk, self.backend5.pk) def __test_shared_backend(self): # Test use of backend that another domain owns but has granted access SQLMobileBackendMapping.set_default_domain_backend(self.domain, self.backend6) with patch( 'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send', autospec=True ) as mock_send: self.assertTrue(send_sms(self.domain, None, '25800000000', 'Test for BACKEND6')) self.assertEqual(mock_send.call_count, 1) self.assertEqual(mock_send.call_args[0][0].pk, self.backend6.pk) # Test trying to use a backend that another domain owns but has not granted access SQLMobileBackendMapping.set_default_domain_backend(self.domain, self.backend7) with patch( 'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send', autospec=True ) as mock_send: self.assertFalse(send_sms(self.domain, None, '25800000000', 'Test Unauthorized')) self.assertEqual(mock_send.call_count, 0) def __test_verified_number_with_map(self): # Test sending to verified number with backend map SQLMobileBackendMapping.unset_default_domain_backend(self.domain) verified_number = self.contact.get_verified_number() self.assertTrue(verified_number is not None) self.assertTrue(verified_number.backend_id is None) self.assertEqual(verified_number.phone_number, '15551234567') with patch( 'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send', autospec=True ) as mock_send: self.assertTrue(send_sms_to_verified_number(verified_number, 'Test for BACKEND2')) self.assertEqual(mock_send.call_count, 1) self.assertEqual(mock_send.call_args[0][0].pk, self.backend2.pk) # Test sending to verified number with default domain backend SQLMobileBackendMapping.set_default_domain_backend(self.domain, self.backend5) with patch( 'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send', autospec=True ) as mock_send: self.assertTrue(send_sms_to_verified_number(verified_number, 'Test for BACKEND5')) self.assertEqual(mock_send.call_count, 1) self.assertEqual(mock_send.call_args[0][0].pk, self.backend5.pk) def __test_contact_level_backend(self): # Test sending to verified number with a contact-level backend owned by the domain self.case.set_case_property('contact_backend_id', 'BACKEND') self.case.save() self.contact = CommConnectCase.wrap(self.case.to_json()) verified_number = self.contact.get_verified_number() self.assertTrue(verified_number is not None) self.assertEqual(verified_number.backend_id, 'BACKEND') self.assertEqual(verified_number.phone_number, '15551234567') with patch( 'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send', autospec=True ) as mock_send: self.assertTrue(send_sms_to_verified_number(verified_number, 'Test for domain BACKEND')) self.assertEqual(mock_send.call_count, 1) self.assertEqual(mock_send.call_args[0][0].pk, self.backend8.pk) # Test sending to verified number with a contact-level backend granted to the domain by another domain self.backend8.name = 'BACKEND8' self.backend8.save() with patch( 'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send', autospec=True ) as mock_send: self.assertTrue(send_sms_to_verified_number(verified_number, 'Test for shared domain BACKEND')) self.assertEqual(mock_send.call_count, 1) self.assertEqual(mock_send.call_args[0][0].pk, self.backend9.pk) # Test sending to verified number with a contact-level global backend self.backend9.name = 'BACKEND9' self.backend9.save() with patch( 'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send', autospec=True ) as mock_send: self.assertTrue(send_sms_to_verified_number(verified_number, 'Test for global BACKEND')) self.assertEqual(mock_send.call_count, 1) self.assertEqual(mock_send.call_args[0][0].pk, self.backend10.pk) # Test raising exception if contact-level backend is not found self.backend10.name = 'BACKEND10' self.backend10.save() with self.assertRaises(BadSMSConfigException): send_sms_to_verified_number(verified_number, 'Test for unknown BACKEND') def __test_send_sms_with_backend(self): with patch( 'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send', autospec=True ) as mock_send: self.assertTrue( send_sms_with_backend(self.domain, '+15551234567', 'Test for BACKEND3', self.backend3.couch_id) ) self.assertEqual(mock_send.call_count, 1) self.assertEqual(mock_send.call_args[0][0].pk, self.backend3.pk) def __test_send_sms_with_backend_name(self): with patch( 'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send', autospec=True ) as mock_send: self.assertTrue( send_sms_with_backend_name(self.domain, '+15551234567', 'Test for BACKEND3', 'BACKEND3') ) self.assertEqual(mock_send.call_count, 1) self.assertEqual(mock_send.call_args[0][0].pk, self.backend3.pk) def test_choosing_appropriate_backend_for_outgoing(self): self.__test_global_backend_map() self.__test_domain_default() self.__test_shared_backend() self.__test_verified_number_with_map() self.__test_contact_level_backend() self.__test_send_sms_with_backend() self.__test_send_sms_with_backend_name()
def test_case_phone_number_updates(self): case = CommCareCase( domain='case-phone-number-test', name='TEST1' ) case.save() self.assertIsNone(self.get_case_verified_number(case)) case.set_case_property('contact_phone_number', '99987658765') case.save() self.assertIsNone(self.get_case_verified_number(case)) case.set_case_property('contact_phone_number_is_verified', '1') case.save() self.assertPhoneNumberDetails(case, '99987658765', None, None, _rev='1') _id = self.get_case_verified_number(case)._id case.set_case_property('contact_phone_number', '99987698769') case.save() self.assertPhoneNumberDetails(case, '99987698769', None, None, _id=_id, _rev='2') case.set_case_property('contact_backend_id', 'sms-backend') case.save() self.assertPhoneNumberDetails(case, '99987698769', 'sms-backend', None, _id=_id, _rev='3') case.set_case_property('contact_ivr_backend_id', 'ivr-backend') case.save() self.assertPhoneNumberDetails(case, '99987698769', 'sms-backend', 'ivr-backend', _id=_id, _rev='4') # If nothing changes, the phone entry should not be saved case.save() self.assertTrue(self.get_case_verified_number(case)._rev.startswith('4-')) # 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() self.assertTrue(v._rev.startswith('5-')) case.set_case_property('contact_phone_number', '99912341234') case.save() self.assertTrue(self.get_case_verified_number(case)._rev.startswith('5-')) self.get_case_verified_number(case).delete() case.delete()
class AllBackendTest(BaseSMSTest): def setUp(self): super(AllBackendTest, self).setUp() backend_api.TEST = True self.domain_obj = Domain(name='all-backend-test') self.domain_obj.save() self.create_account_and_subscription(self.domain_obj.name) self.domain_obj = Domain.get(self.domain_obj._id) self.test_phone_number = '99912345' self.contact1 = CommCareCase(domain=self.domain_obj.name) self.contact1.set_case_property('contact_phone_number', self.test_phone_number) self.contact1.set_case_property('contact_phone_number_is_verified', '1') self.contact1.save() self.contact1 = CommConnectCase.wrap(self.contact1.to_json()) # For use with megamobile only self.contact2 = CommCareCase(domain=self.domain_obj.name) self.contact2.set_case_property('contact_phone_number', '63%s' % self.test_phone_number) self.contact2.set_case_property('contact_phone_number_is_verified', '1') self.contact2.save() self.contact2 = CommConnectCase.wrap(self.contact2.to_json()) self.unicel_backend = UnicelBackend(name='UNICEL', is_global=True) self.unicel_backend.save() self.mach_backend = MachBackend(name='MACH', is_global=True) self.mach_backend.save() self.tropo_backend = TropoBackend(name='TROPO', is_global=True) self.tropo_backend.save() self.http_backend = HttpBackend(name='HTTP', is_global=True) self.http_backend.save() self.telerivet_backend = TelerivetBackend(name='TELERIVET', is_global=True, webhook_secret='telerivet-webhook-secret') self.telerivet_backend.save() self.test_backend = TestSMSBackend(name='TEST', is_global=True) self.test_backend.save() self.grapevine_backend = GrapevineBackend(name='GRAPEVINE', is_global=True) self.grapevine_backend.save() self.twilio_backend = TwilioBackend(name='TWILIO', is_global=True) self.twilio_backend.save() self.megamobile_backend = MegamobileBackend(name='MEGAMOBILE', is_global=True) self.megamobile_backend.save() self.smsgh_backend = SMSGHBackend(name='SMSGH', is_global=True) self.smsgh_backend.save() self.apposit_backend = AppositBackend(name='APPOSIT', is_global=True) self.apposit_backend.save() def _test_outbound_backend(self, backend, msg_text, mock_send): self.domain_obj.default_sms_backend_id = backend._id self.domain_obj.save() send_sms(self.domain_obj.name, None, self.test_phone_number, msg_text) sms = SMS.objects.get( domain=self.domain_obj.name, direction='O', text=msg_text ) self.assertTrue(mock_send.called) msg_arg = mock_send.call_args[0][0] self.assertEqual(msg_arg.date, sms.date) def _verify_inbound_request(self, backend_api_id, msg_text): sms = SMS.objects.get( domain=self.domain_obj.name, direction='I', text=msg_text ) self.assertEqual(sms.backend_api, backend_api_id) def _simulate_inbound_request_with_payload(self, url, content_type, payload): response = Client().post(url, payload, content_type=content_type) self.assertEqual(response.status_code, 200) def _simulate_inbound_request(self, url, phone_param, msg_param, msg_text, post=False, additional_params=None): fcn = Client().post if post else Client().get payload = { phone_param: self.test_phone_number, msg_param: msg_text, } if additional_params: payload.update(additional_params) response = fcn(url, payload) self.assertEqual(response.status_code, 200) @patch('corehq.messaging.smsbackends.unicel.api.UnicelBackend.send') @patch('corehq.messaging.smsbackends.mach.api.MachBackend.send') @patch('corehq.messaging.smsbackends.tropo.api.TropoBackend.send') @patch('corehq.messaging.smsbackends.http.api.HttpBackend.send') @patch('corehq.messaging.smsbackends.telerivet.models.TelerivetBackend.send') @patch('corehq.messaging.smsbackends.test.api.TestSMSBackend.send') @patch('corehq.messaging.smsbackends.grapevine.api.GrapevineBackend.send') @patch('corehq.messaging.smsbackends.twilio.models.TwilioBackend.send') @patch('corehq.messaging.smsbackends.megamobile.api.MegamobileBackend.send') @patch('corehq.messaging.smsbackends.smsgh.models.SMSGHBackend.send') @patch('corehq.messaging.smsbackends.apposit.models.AppositBackend.send') def test_outbound_sms( self, apposit_send, smsgh_send, megamobile_send, twilio_send, grapevine_send, test_send, telerivet_send, http_send, tropo_send, mach_send, unicel_send): self._test_outbound_backend(self.unicel_backend, 'unicel test', unicel_send) self._test_outbound_backend(self.mach_backend, 'mach test', mach_send) self._test_outbound_backend(self.tropo_backend, 'tropo test', tropo_send) self._test_outbound_backend(self.http_backend, 'http test', http_send) self._test_outbound_backend(self.telerivet_backend, 'telerivet test', telerivet_send) self._test_outbound_backend(self.test_backend, 'test test', test_send) self._test_outbound_backend(self.grapevine_backend, 'grapevine test', grapevine_send) self._test_outbound_backend(self.twilio_backend, 'twilio test', twilio_send) self._test_outbound_backend(self.megamobile_backend, 'megamobile test', megamobile_send) self._test_outbound_backend(self.smsgh_backend, 'smsgh test', smsgh_send) self._test_outbound_backend(self.apposit_backend, 'apposit test', apposit_send) def test_unicel_inbound_sms(self): self._simulate_inbound_request('/unicel/in/', phone_param=InboundParams.SENDER, msg_param=InboundParams.MESSAGE, msg_text='unicel test') self._verify_inbound_request(self.unicel_backend.get_api_id(), 'unicel test') def test_tropo_inbound_sms(self): tropo_data = {'session': {'from': {'id': self.test_phone_number}, 'initialText': 'tropo test'}} self._simulate_inbound_request_with_payload('/tropo/sms/', content_type='text/json', payload=json.dumps(tropo_data)) self._verify_inbound_request(self.tropo_backend.get_api_id(), 'tropo test') def test_telerivet_inbound_sms(self): additional_params = { 'event': 'incoming_message', 'message_type': 'sms', 'secret': self.telerivet_backend.webhook_secret } self._simulate_inbound_request('/telerivet/in/', phone_param='from_number_e164', msg_param='content', msg_text='telerivet test', post=True, additional_params=additional_params) self._verify_inbound_request(self.telerivet_backend.get_api_id(), 'telerivet test') @override_settings(SIMPLE_API_KEYS={'grapevine-test': 'grapevine-api-key'}) def test_grapevine_inbound_sms(self): xml = """ <gviSms> <smsDateTime>2015-10-12T12:00:00</smsDateTime> <cellNumber>99912345</cellNumber> <content>grapevine test</content> </gviSms> """ payload = urlencode({'XML': xml}) self._simulate_inbound_request_with_payload( '/gvi/api/sms/?apiuser=grapevine-test&apikey=grapevine-api-key', content_type='application/x-www-form-urlencoded', payload=payload) self._verify_inbound_request(self.grapevine_backend.get_api_id(), 'grapevine test') def test_twilio_inbound_sms(self): self._simulate_inbound_request('/twilio/sms/', phone_param='From', msg_param='Body', msg_text='twilio test', post=True) self._verify_inbound_request(self.twilio_backend.get_api_id(), 'twilio test') def test_megamobile_inbound_sms(self): self._simulate_inbound_request('/megamobile/sms/', phone_param='cel', msg_param='msg', msg_text='megamobile test') self._verify_inbound_request(self.megamobile_backend.get_api_id(), 'megamobile test') def test_sislog_inbound_sms(self): self._simulate_inbound_request('/sislog/in/', phone_param='sender', msg_param='msgdata', msg_text='sislog test') self._verify_inbound_request('SISLOG', 'sislog test') def test_yo_inbound_sms(self): self._simulate_inbound_request('/yo/sms/', phone_param='sender', msg_param='message', msg_text='yo test') self._verify_inbound_request('YO', 'yo test') def test_smsgh_inbound_sms(self): user = ApiUser.create('smsgh-api-key', 'smsgh-api-key', permissions=[PERMISSION_POST_SMS]) user.save() self._simulate_inbound_request('/smsgh/sms/smsgh-api-key/', phone_param='snr', msg_param='msg', msg_text='smsgh test') self._verify_inbound_request('SMSGH', 'smsgh test') user.delete() def test_apposit_inbound_sms(self): user = ApiUser.create('apposit-api-key', 'apposit-api-key', permissions=[PERMISSION_POST_SMS]) user.save() self._simulate_inbound_request( '/apposit/in/apposit-api-key/', phone_param='fromAddress', msg_param='content', msg_text='apposit test', post=True, additional_params={'channel': 'SMS'} ) self._verify_inbound_request('APPOSIT', 'apposit test') user.delete() def tearDown(self): backend_api.TEST = False self.contact1.get_verified_number().delete() self.contact1.delete() self.contact2.get_verified_number().delete() self.contact2.delete() self.domain_obj.delete() self.unicel_backend.delete() self.mach_backend.delete() self.tropo_backend.delete() self.http_backend.delete() self.telerivet_backend.delete() self.test_backend.delete() self.grapevine_backend.delete() self.twilio_backend.delete() self.megamobile_backend.delete() self.smsgh_backend.delete() self.apposit_backend.delete() super(AllBackendTest, self).tearDown()
class BackendTestCase(TestCase): def setUp(self): self.domain = "test-domain" self.domain2 = "test-domain2" self.domain_obj = Domain(name=self.domain) self.domain_obj.save() self.domain_obj = Domain.get(self.domain_obj._id) # Prevent resource conflict self.backend1 = TestCaseBackend(name="BACKEND1",is_global=True) self.backend1.save() self.backend2 = TestCaseBackend(name="BACKEND2",is_global=True) self.backend2.save() self.backend3 = TestCaseBackend(name="BACKEND3",is_global=True) self.backend3.save() self.backend4 = TestCaseBackend(name="BACKEND4",is_global=True) self.backend4.save() self.backend5 = TestCaseBackend(name="BACKEND5",domain=self.domain,is_global=False,authorized_domains=[]) self.backend5.save() self.backend6 = TestCaseBackend(name="BACKEND6",domain=self.domain2,is_global=False,authorized_domains=[self.domain]) self.backend6.save() self.backend7 = TestCaseBackend(name="BACKEND7",domain=self.domain2,is_global=False,authorized_domains=[]) self.backend7.save() self.backend8 = TestCaseBackend(name="BACKEND",domain=self.domain,is_global=False,authorized_domains=[]) self.backend8.save() self.backend9 = TestCaseBackend(name="BACKEND",domain=self.domain2,is_global=False,authorized_domains=[self.domain]) self.backend9.save() self.backend10 = TestCaseBackend(name="BACKEND",is_global=True) self.backend10.save() self.backend_mapping1 = BackendMapping(is_global=True,prefix="*",backend_id=self.backend1._id) self.backend_mapping1.save() self.backend_mapping2 = BackendMapping(is_global=True,prefix="1",backend_id=self.backend2._id) self.backend_mapping2.save() self.backend_mapping3 = BackendMapping(is_global=True,prefix="91",backend_id=self.backend3._id) self.backend_mapping3.save() self.backend_mapping4 = BackendMapping(is_global=True,prefix="265",backend_id=self.backend4._id) self.backend_mapping4.save() self.case = CommCareCase(domain=self.domain) self.case.set_case_property("contact_phone_number","15551234567") self.case.set_case_property("contact_phone_number_is_verified", "1") self.case.save() self.contact = CommConnectCase.wrap(self.case.to_json()) settings.SMS_LOADED_BACKENDS.append("corehq.apps.sms.tests.TestCaseBackend") def tearDown(self): self.backend1.delete_invoke_doc() self.backend1.delete() self.backend_mapping1.delete() self.backend2.delete_invoke_doc() self.backend2.delete() self.backend_mapping2.delete() self.backend3.delete_invoke_doc() self.backend3.delete() self.backend_mapping3.delete() self.backend4.delete_invoke_doc() self.backend4.delete() self.backend_mapping4.delete() self.backend5.delete_invoke_doc() self.backend5.delete() self.backend6.delete_invoke_doc() self.backend6.delete() self.backend7.delete_invoke_doc() self.backend7.delete() self.contact.delete_verified_number() self.case.delete() self.domain_obj.delete() settings.SMS_LOADED_BACKENDS.pop() def test_backend(self): # Test the backend map self.assertTrue(send_sms(self.domain, None, "15551234567", "Test for BACKEND2")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertTrue(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend2.delete_invoke_doc() self.assertFalse(self.backend2.invoke_doc_exists()) self.assertTrue(send_sms(self.domain, None, "9100000000", "Test for BACKEND3")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertTrue(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend3.delete_invoke_doc() self.assertFalse(self.backend3.invoke_doc_exists()) self.assertTrue(send_sms(self.domain, None, "26500000000", "Test for BACKEND4")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertTrue(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend4.delete_invoke_doc() self.assertFalse(self.backend4.invoke_doc_exists()) self.assertTrue(send_sms(self.domain, None, "25800000000", "Test for BACKEND1")) self.assertTrue(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend1.delete_invoke_doc() self.assertFalse(self.backend1.invoke_doc_exists()) # Test overriding with a domain-level backend self.domain_obj.default_sms_backend_id = self.backend5._id self.domain_obj.save() self.assertTrue(send_sms(self.domain, None, "15551234567", "Test for BACKEND5")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertTrue(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend5.delete_invoke_doc() self.assertFalse(self.backend5.invoke_doc_exists()) # Test use of backend that another domain owns but has granted access self.domain_obj.default_sms_backend_id = self.backend6._id self.domain_obj.save() self.assertTrue(send_sms(self.domain, None, "25800000000", "Test for BACKEND6")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertTrue(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend6.delete_invoke_doc() self.assertFalse(self.backend6.invoke_doc_exists()) # Test backend access control self.domain_obj.default_sms_backend_id = self.backend7._id self.domain_obj.save() self.assertFalse(send_sms(self.domain, None, "25800000000", "Test for BACKEND7")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) # Test sending to verified number with backend map self.domain_obj.default_sms_backend_id = None self.domain_obj.save() verified_number = self.contact.get_verified_number() self.assertTrue(verified_number is not None) self.assertTrue(verified_number.backend_id is None) self.assertEqual(verified_number.phone_number, "15551234567") self.assertTrue(send_sms_to_verified_number(verified_number, "Test for BACKEND2")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertTrue(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend2.delete_invoke_doc() self.assertFalse(self.backend2.invoke_doc_exists()) # Test sending to verified number with default domain backend self.domain_obj.default_sms_backend_id = self.backend5._id self.domain_obj.save() self.assertTrue(send_sms_to_verified_number(verified_number, "Test for BACKEND5")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertTrue(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend5.delete_invoke_doc() self.assertFalse(self.backend5.invoke_doc_exists()) # Test sending to verified number with a contact-level backend owned by the domain self.case.set_case_property("contact_backend_id", "BACKEND") self.case.save() self.contact = CommConnectCase.wrap(self.case.to_json()) verified_number = self.contact.get_verified_number() self.assertTrue(verified_number is not None) self.assertEqual(verified_number.backend_id, "BACKEND") self.assertEqual(verified_number.phone_number, "15551234567") self.assertTrue(send_sms_to_verified_number(verified_number, "Test for BACKEND")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertTrue(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend8.delete_invoke_doc() self.assertFalse(self.backend8.invoke_doc_exists()) # Test sending to verified number with a contact-level backend granted to the domain by another domain self.backend8.delete() self.assertTrue(send_sms_to_verified_number(verified_number, "Test for BACKEND")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertTrue(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend9.delete_invoke_doc() self.assertFalse(self.backend9.invoke_doc_exists()) # Test sending to verified number with a contact-level global backend self.backend9.delete() self.assertTrue(send_sms_to_verified_number(verified_number, "Test for BACKEND")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertTrue(self.backend10.invoke_doc_exists()) self.backend10.delete_invoke_doc() self.assertFalse(self.backend10.invoke_doc_exists()) # Test raising exception if contact-level backend is not found self.backend10.delete() try: self.assertTrue(send_sms_to_verified_number(verified_number, "Test for BACKEND")) except BadSMSConfigException: pass else: self.assertTrue(False) # Test send_sms_with_backend self.assertTrue(send_sms_with_backend(self.domain, "+15551234567", "Test for BACKEND3", self.backend3._id)) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertTrue(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.backend3.delete_invoke_doc() self.assertFalse(self.backend3.invoke_doc_exists()) # Test send_sms_with_backend_name self.assertTrue(send_sms_with_backend_name(self.domain, "+15551234567", "Test for BACKEND3", "BACKEND3")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertTrue(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.backend3.delete_invoke_doc() self.assertFalse(self.backend3.invoke_doc_exists())
class BackendTestCase(BaseSMSTest): def get_or_create_site(self): site, created = Site.objects.get_or_create(id=settings.SITE_ID) if created: site.domain = 'localhost' site.name = 'localhost' site.save() return (site, created) def setUp(self): super(BackendTestCase, self).setUp() self.domain = "test-domain" self.domain2 = "test-domain2" self.site, self.site_created = self.get_or_create_site() self.domain_obj = Domain(name=self.domain) self.domain_obj.save() self.create_account_and_subscription(self.domain_obj.name) self.domain_obj = Domain.get(self.domain_obj._id) # Prevent resource conflict self.backend1 = TestCaseBackend(name="BACKEND1",is_global=True) self.backend1.save() self.backend2 = TestCaseBackend(name="BACKEND2",is_global=True) self.backend2.save() self.backend3 = TestCaseBackend(name="BACKEND3",is_global=True) self.backend3.save() self.backend4 = TestCaseBackend(name="BACKEND4",is_global=True) self.backend4.save() self.backend5 = TestCaseBackend(name="BACKEND5",domain=self.domain,is_global=False,authorized_domains=[]) self.backend5.save() self.backend6 = TestCaseBackend(name="BACKEND6",domain=self.domain2,is_global=False,authorized_domains=[self.domain]) self.backend6.save() self.backend7 = TestCaseBackend(name="BACKEND7",domain=self.domain2,is_global=False,authorized_domains=[]) self.backend7.save() self.backend8 = TestCaseBackend(name="BACKEND",domain=self.domain,is_global=False,authorized_domains=[]) self.backend8.save() self.backend9 = TestCaseBackend(name="BACKEND",domain=self.domain2,is_global=False,authorized_domains=[self.domain]) self.backend9.save() self.backend10 = TestCaseBackend(name="BACKEND",is_global=True) self.backend10.save() self.backend_mapping1 = BackendMapping(is_global=True,prefix="*",backend_id=self.backend1._id) self.backend_mapping1.save() self.backend_mapping2 = BackendMapping(is_global=True,prefix="1",backend_id=self.backend2._id) self.backend_mapping2.save() self.backend_mapping3 = BackendMapping(is_global=True,prefix="91",backend_id=self.backend3._id) self.backend_mapping3.save() self.backend_mapping4 = BackendMapping(is_global=True,prefix="265",backend_id=self.backend4._id) self.backend_mapping4.save() self.backend_mapping5 = BackendMapping(is_global=True, prefix="256", backend_id=self.backend5._id) self.backend_mapping5.save() self.backend_mapping6 = BackendMapping(is_global=True, prefix="25670", backend_id=self.backend6._id) self.backend_mapping6.save() self.backend_mapping7 = BackendMapping(is_global=True, prefix="25675", backend_id=self.backend7._id) self.backend_mapping7.save() self.case = CommCareCase(domain=self.domain) self.case.set_case_property("contact_phone_number","15551234567") self.case.set_case_property("contact_phone_number_is_verified", "1") self.case.save() self.contact = CommConnectCase.wrap(self.case.to_json()) settings.SMS_LOADED_BACKENDS.append("corehq.apps.sms.tests.TestCaseBackend") def tearDown(self): self.backend1.delete_invoke_doc() self.backend1.delete() self.backend_mapping1.delete() self.backend2.delete_invoke_doc() self.backend2.delete() self.backend_mapping2.delete() self.backend3.delete_invoke_doc() self.backend3.delete() self.backend_mapping3.delete() self.backend4.delete_invoke_doc() self.backend4.delete() self.backend_mapping4.delete() self.backend5.delete_invoke_doc() self.backend5.delete() self.backend_mapping5.delete() self.backend6.delete_invoke_doc() self.backend6.delete() self.backend_mapping6.delete() self.backend7.delete_invoke_doc() self.backend7.delete() self.backend_mapping7.delete() self.contact.delete_verified_number() self.case.delete() self.domain_obj.delete() if self.site_created: self.site.delete() settings.SMS_LOADED_BACKENDS.pop() super(BackendTestCase, self).tearDown() def test_multiple_country_prefixes(self): self.assertEqual(MobileBackend.auto_load('256800000000')._id, self.backend5._id) self.assertEqual(MobileBackend.auto_load('256700000000')._id, self.backend6._id) self.assertEqual(MobileBackend.auto_load('256750000000')._id, self.backend7._id) def test_backend(self): # Test the backend map self.assertTrue(send_sms(self.domain, None, "15551234567", "Test for BACKEND2")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertTrue(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend2.delete_invoke_doc() self.assertFalse(self.backend2.invoke_doc_exists()) self.assertTrue(send_sms(self.domain, None, "9100000000", "Test for BACKEND3")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertTrue(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend3.delete_invoke_doc() self.assertFalse(self.backend3.invoke_doc_exists()) self.assertTrue(send_sms(self.domain, None, "26500000000", "Test for BACKEND4")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertTrue(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend4.delete_invoke_doc() self.assertFalse(self.backend4.invoke_doc_exists()) self.assertTrue(send_sms(self.domain, None, "25800000000", "Test for BACKEND1")) self.assertTrue(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend1.delete_invoke_doc() self.assertFalse(self.backend1.invoke_doc_exists()) # Test overriding with a domain-level backend self.domain_obj = Domain.get(self.domain_obj._id) # Prevent resource conflict self.domain_obj.default_sms_backend_id = self.backend5._id self.domain_obj.save() self.assertTrue(send_sms(self.domain, None, "15551234567", "Test for BACKEND5")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertTrue(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend5.delete_invoke_doc() self.assertFalse(self.backend5.invoke_doc_exists()) # Test use of backend that another domain owns but has granted access self.domain_obj.default_sms_backend_id = self.backend6._id self.domain_obj.save() self.assertTrue(send_sms(self.domain, None, "25800000000", "Test for BACKEND6")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertTrue(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend6.delete_invoke_doc() self.assertFalse(self.backend6.invoke_doc_exists()) # Test backend access control self.domain_obj.default_sms_backend_id = self.backend7._id self.domain_obj.save() self.assertFalse(send_sms(self.domain, None, "25800000000", "Test for BACKEND7")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) # Test sending to verified number with backend map self.domain_obj.default_sms_backend_id = None self.domain_obj.save() verified_number = self.contact.get_verified_number() self.assertTrue(verified_number is not None) self.assertTrue(verified_number.backend_id is None) self.assertEqual(verified_number.phone_number, "15551234567") self.assertTrue(send_sms_to_verified_number(verified_number, "Test for BACKEND2")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertTrue(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend2.delete_invoke_doc() self.assertFalse(self.backend2.invoke_doc_exists()) # Test sending to verified number with default domain backend self.domain_obj.default_sms_backend_id = self.backend5._id self.domain_obj.save() self.assertTrue(send_sms_to_verified_number(verified_number, "Test for BACKEND5")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertTrue(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertFalse(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend5.delete_invoke_doc() self.assertFalse(self.backend5.invoke_doc_exists()) # Test sending to verified number with a contact-level backend owned by the domain self.case.set_case_property("contact_backend_id", "BACKEND") self.case.save() self.contact = CommConnectCase.wrap(self.case.to_json()) verified_number = self.contact.get_verified_number() self.assertTrue(verified_number is not None) self.assertEqual(verified_number.backend_id, "BACKEND") self.assertEqual(verified_number.phone_number, "15551234567") self.assertTrue(send_sms_to_verified_number(verified_number, "Test for BACKEND")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertTrue(self.backend8.invoke_doc_exists()) self.assertFalse(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend8.delete_invoke_doc() self.assertFalse(self.backend8.invoke_doc_exists()) # Test sending to verified number with a contact-level backend granted to the domain by another domain self.backend8.delete() self.assertTrue(send_sms_to_verified_number(verified_number, "Test for BACKEND")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertTrue(self.backend9.invoke_doc_exists()) self.assertFalse(self.backend10.invoke_doc_exists()) self.backend9.delete_invoke_doc() self.assertFalse(self.backend9.invoke_doc_exists()) # Test sending to verified number with a contact-level global backend self.backend9.delete() self.assertTrue(send_sms_to_verified_number(verified_number, "Test for BACKEND")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertFalse(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.assertTrue(self.backend10.invoke_doc_exists()) self.backend10.delete_invoke_doc() self.assertFalse(self.backend10.invoke_doc_exists()) # Test raising exception if contact-level backend is not found self.backend10.delete() try: self.assertTrue(send_sms_to_verified_number(verified_number, "Test for BACKEND")) except BadSMSConfigException: pass else: self.assertTrue(False) # Test send_sms_with_backend self.assertTrue(send_sms_with_backend(self.domain, "+15551234567", "Test for BACKEND3", self.backend3._id)) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertTrue(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.backend3.delete_invoke_doc() self.assertFalse(self.backend3.invoke_doc_exists()) # Test send_sms_with_backend_name self.assertTrue(send_sms_with_backend_name(self.domain, "+15551234567", "Test for BACKEND3", "BACKEND3")) self.assertFalse(self.backend1.invoke_doc_exists()) self.assertFalse(self.backend2.invoke_doc_exists()) self.assertTrue(self.backend3.invoke_doc_exists()) self.assertFalse(self.backend4.invoke_doc_exists()) self.assertFalse(self.backend5.invoke_doc_exists()) self.assertFalse(self.backend6.invoke_doc_exists()) self.assertFalse(self.backend7.invoke_doc_exists()) self.backend3.delete_invoke_doc() self.assertFalse(self.backend3.invoke_doc_exists()) def test_sms_registration(self): formatted_username = format_username("tester", self.domain) incoming("+9991234567", "JOIN {} WORKER tester".format(self.domain), "TEST_CASE_BACKEND") # Test without mobile worker registration enabled self.assertIsNone(CommCareUser.get_by_username(formatted_username)) # Enable mobile worker registration setattr(self.domain_obj, "sms_mobile_worker_registration_enabled", True) self.domain_obj.save() incoming("+9991234567", "JOIN {} WORKER tester".format(self.domain), "TEST_CASE_BACKEND") self.assertIsNotNone(CommCareUser.get_by_username(formatted_username)) # Test a duplicate registration prev_num_users = num_mobile_users(self.domain) incoming("+9991234568", "JOIN {} WORKER tester".format(self.domain), "TEST_CASE_BACKEND") current_num_users = num_mobile_users(self.domain) self.assertEqual(prev_num_users, current_num_users)
class KooKooTestCase(TouchformsTestCase): """ Must be run manually (see corehq.apps.sms.tests.util.TouchformsTestCase) """ def setUp(self): super(KooKooTestCase, self).setUp() self.ivr_backend = MobileBackend( _id="MOBILE_BACKEND_KOOKOO", outbound_module="corehq.apps.kookoo.api", outbound_params={ "is_test": True, "api_key": "xyz" }, ) self.ivr_backend.save() self.user1 = self.create_mobile_worker("user1", "123", "91001", save_vn=False) self.user2 = self.create_mobile_worker("user2", "123", "91002", save_vn=False) self.create_group("group1", [self.user1, self.user2]) self.case = CommCareCase( domain=self.domain, type="participant", owner_id=self.groups[0]._id, ) self.case.set_case_property("contact_phone_number", "91000") self.case.set_case_property("contact_phone_number_is_verified", "1") self.case.set_case_property("contact_ivr_backend_id", "MOBILE_BACKEND_KOOKOO") self.case.save() dirname = os.path.dirname(os.path.abspath(__file__)) self.load_app("app1.json", dirname) self.load_app("app2.json", dirname) self.reminder1 = CaseReminderHandler( domain=self.domain, active=True, case_type="participant", method=METHOD_IVR_SURVEY, recipient=RECIPIENT_CASE, sample_id=None, user_group_id=None, user_id=None, case_id=None, reminder_type=REMINDER_TYPE_DEFAULT, submit_partial_forms=True, include_case_side_effects=False, max_question_retries=5, start_condition_type=CASE_CRITERIA, start_property="name", start_value="case1", start_date=None, start_offset=0, start_match_type=MATCH_EXACT, events=[ CaseReminderEvent( day_num=0, fire_time=time(12, 0), fire_time_type=FIRE_TIME_DEFAULT, callback_timeout_intervals=[30], form_unique_id=self.apps[0].modules[0].forms[0].unique_id, ), CaseReminderEvent( day_num=0, fire_time=time(13, 0), fire_time_type=FIRE_TIME_DEFAULT, callback_timeout_intervals=[30], form_unique_id=self.apps[0].modules[0].forms[1].unique_id, ), ], schedule_length=1, event_interpretation=EVENT_AS_SCHEDULE, max_iteration_count=7, until=None, force_surveys_to_use_triggered_case=False, ) self.reminder1.save() self.reminder2 = CaseReminderHandler( domain=self.domain, active=True, case_type="participant", method=METHOD_IVR_SURVEY, recipient=RECIPIENT_OWNER, sample_id=None, user_group_id=None, user_id=None, case_id=None, reminder_type=REMINDER_TYPE_DEFAULT, submit_partial_forms=True, include_case_side_effects=True, max_question_retries=5, start_condition_type=CASE_CRITERIA, start_property="name", start_value="case2", start_date=None, start_offset=0, start_match_type=MATCH_EXACT, events=[ CaseReminderEvent( day_num=0, fire_time=time(12, 0), fire_time_type=FIRE_TIME_DEFAULT, callback_timeout_intervals=[30, 30], form_unique_id=self.apps[1].modules[0].forms[0].unique_id, ), ], schedule_length=1, event_interpretation=EVENT_AS_SCHEDULE, max_iteration_count=7, until=None, force_surveys_to_use_triggered_case=False, ) self.reminder2.save() def kookoo_in(self, params): """ params should be a dictionary containing: event, cid, sid, and (optionally) data """ params = urllib.urlencode(params) url = "%s/kookoo/ivr/" % self.live_server_url return urllib2.urlopen("%s?%s" % (url, params)).read() def kookoo_finished(self, params): """ params should be a dictionary containing: sid, status, and duration """ params = urllib.urlencode(params) url = "%s/kookoo/ivr_finished/" % self.live_server_url return urllib2.urlopen(url, params).read() def testOutbound(self): # Send an outbound call using self.reminder1 to self.case # and answer it CaseReminderHandler.now = datetime(2014, 6, 23, 10, 0) self.case.name = "case1" self.case.save() CaseReminderHandler.now = datetime(2014, 6, 23, 12, 0) CaseReminderHandler.fire_reminders() reminder = self.reminder1.get_reminder(self.case) self.assertEquals(reminder.next_fire, datetime(2014, 6, 23, 12, 30)) call = self.get_last_outbound_call(self.case) self.assertTrue(call.use_precached_first_response) kookoo_session_id = call.gateway_session_id[7:] resp = self.kookoo_in({ "cid": "0000", "sid": kookoo_session_id, "event": "NewCall", }) self.assertEqual( resp, '<response sid="%s"><collectdtmf l="1" o="3000">' '<playtext>How do you feel today? Press 1 for good, 2 for bad.' '</playtext></collectdtmf></response>' % kookoo_session_id) resp = self.kookoo_in({ "cid": "0000", "sid": kookoo_session_id, "event": "GotDTMF", "data": "1", }) self.assertEqual( resp, '<response sid="%s"><collectdtmf l="1" o="3000">' '<playtext>Did you remember to take your meds today? Press 1 for yes, 2 for no.' '</playtext></collectdtmf></response>' % kookoo_session_id) resp = self.kookoo_in({ "cid": "0000", "sid": kookoo_session_id, "event": "GotDTMF", "data": "2", }) self.assertEqual( resp, '<response sid="%s"><hangup/></response>' % kookoo_session_id) self.kookoo_finished({ "sid": kookoo_session_id, "status": "answered", "duration": "20", }) call = CallLog.get(call._id) self.assertTrue(call.answered) self.assertEqual(call.duration, 20) form = self.get_last_form_submission() self.assertFormQuestionEquals(form, "how_feel", "1") self.assertFormQuestionEquals(form, "take_meds", "2") case = CommCareCase.get(self.case._id) self.assertCasePropertyEquals(case, "how_feel", "1") self.assertCasePropertyEquals(case, "take_meds", "2") CaseReminderHandler.now = datetime(2014, 6, 23, 12, 30) CaseReminderHandler.fire_reminders() reminder = self.reminder1.get_reminder(self.case) self.assertEquals(reminder.next_fire, datetime(2014, 6, 23, 13, 0)) last_call = self.get_last_outbound_call(self.case) self.assertEqual(call._id, last_call._id) # Move on to the second event which now uses an all-label form and # should not precache the first ivr response CaseReminderHandler.now = datetime(2014, 6, 23, 13, 0) CaseReminderHandler.fire_reminders() reminder = self.reminder1.get_reminder(self.case) self.assertEquals(reminder.next_fire, datetime(2014, 6, 23, 13, 30)) call = self.get_last_outbound_call(self.case) self.assertFalse(call.use_precached_first_response) kookoo_session_id = call.gateway_session_id[7:] resp = self.kookoo_in({ "cid": "0000", "sid": kookoo_session_id, "event": "NewCall", }) self.assertEqual( resp, '<response sid="%s">' '<playtext>This is just a reminder to take your meds.' '</playtext><hangup/></response>' % kookoo_session_id) self.kookoo_finished({ "sid": kookoo_session_id, "status": "answered", "duration": "5", }) call = CallLog.get(call._id) self.assertTrue(call.answered) self.assertEqual(call.duration, 5) form = self.get_last_form_submission() self.assertFormQuestionEquals(form, "label", "ok") CaseReminderHandler.now = datetime(2014, 6, 23, 13, 30) CaseReminderHandler.fire_reminders() reminder = self.reminder1.get_reminder(self.case) self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 12, 0)) last_call = self.get_last_outbound_call(self.case) self.assertEqual(call._id, last_call._id) # Now test sending outbound calls to a group of users (the owners # of the case) # Allow sending to unverified numbers self.domain_obj = Domain.get(self.domain_obj._id) self.domain_obj.send_to_duplicated_case_numbers = True self.domain_obj.save() CaseReminderHandler.now = datetime(2014, 6, 24, 10, 0) self.case = CommCareCase.get(self.case._id) self.case.name = "case2" self.case.save() reminder = self.reminder2.get_reminder(self.case) self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 12, 0)) CaseReminderHandler.now = datetime(2014, 6, 24, 12, 0) CaseReminderHandler.fire_reminders() reminder = self.reminder2.get_reminder(self.case) self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 12, 30)) call1 = self.get_last_outbound_call(self.user1) self.assertTrue(call1.use_precached_first_response) self.assertFalse(call1.answered) call2 = self.get_last_outbound_call(self.user2) self.assertTrue(call2.use_precached_first_response) self.assertFalse(call2.answered) old_call1 = call1 old_call2 = call2 CaseReminderHandler.now = datetime(2014, 6, 24, 12, 30) CaseReminderHandler.fire_reminders() reminder = self.reminder2.get_reminder(self.case) self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 13, 0)) call1 = self.get_last_outbound_call(self.user1) self.assertTrue(call1.use_precached_first_response) self.assertNotEqual(call1._id, old_call1._id) call2 = self.get_last_outbound_call(self.user2) self.assertTrue(call2.use_precached_first_response) self.assertFalse(call2.answered) self.assertNotEqual(call2._id, old_call2._id) kookoo_session_id = call1.gateway_session_id[7:] resp = self.kookoo_in({ "cid": "0001", "sid": kookoo_session_id, "event": "NewCall", }) self.assertEqual( resp, '<response sid="%s"><collectdtmf l="1" o="3000">' '<playtext>How do you feel today? Press 1 for good, 2 for bad.' '</playtext></collectdtmf></response>' % kookoo_session_id) resp = self.kookoo_in({ "cid": "0001", "sid": kookoo_session_id, "event": "GotDTMF", "data": "2", }) self.assertEqual( resp, '<response sid="%s"><collectdtmf l="1" o="3000">' '<playtext>Did you remember to take your meds today? Press 1 for yes, 2 for no.' '</playtext></collectdtmf></response>' % kookoo_session_id) resp = self.kookoo_in({ "cid": "0001", "sid": kookoo_session_id, "event": "GotDTMF", "data": "1", }) self.assertEqual( resp, '<response sid="%s"><hangup/></response>' % kookoo_session_id) self.kookoo_finished({ "sid": kookoo_session_id, "status": "answered", "duration": "20", }) call1 = CallLog.get(call1._id) self.assertTrue(call1.answered) self.assertEqual(call1.duration, 20) form = self.get_last_form_submission() self.assertFormQuestionEquals(form, "how_feel", "2") self.assertFormQuestionEquals(form, "take_meds", "1") self.assertEqual(form.form["meta"]["userID"], self.user1._id) case = CommCareCase.get(self.case._id) self.assertCasePropertyEquals(case, "how_feel", "2") self.assertCasePropertyEquals(case, "take_meds", "1") self.assertEqual(case.user_id, self.user1._id) old_call1 = call1 old_call2 = call2 CaseReminderHandler.now = datetime(2014, 6, 24, 13, 0) CaseReminderHandler.fire_reminders() reminder = self.reminder2.get_reminder(self.case) self.assertEquals(reminder.next_fire, datetime(2014, 6, 25, 12, 0)) call1 = self.get_last_outbound_call(self.user1) # No new call for user1 since it was already answered self.assertEqual(call1._id, old_call1._id) call2 = self.get_last_outbound_call(self.user2) self.assertTrue(call2.use_precached_first_response) self.assertNotEqual(call2._id, old_call2._id) kookoo_session_id = call2.gateway_session_id[7:] resp = self.kookoo_in({ "cid": "0002", "sid": kookoo_session_id, "event": "NewCall", }) self.assertEqual( resp, '<response sid="%s"><collectdtmf l="1" o="3000">' '<playtext>How do you feel today? Press 1 for good, 2 for bad.' '</playtext></collectdtmf></response>' % kookoo_session_id) resp = self.kookoo_in({ "cid": "0002", "sid": kookoo_session_id, "event": "GotDTMF", "data": "1", }) self.assertEqual( resp, '<response sid="%s"><collectdtmf l="1" o="3000">' '<playtext>Did you remember to take your meds today? Press 1 for yes, 2 for no.' '</playtext></collectdtmf></response>' % kookoo_session_id) resp = self.kookoo_in({ "cid": "0002", "sid": kookoo_session_id, "event": "GotDTMF", "data": "2", }) self.assertEqual( resp, '<response sid="%s"><hangup/></response>' % kookoo_session_id) self.kookoo_finished({ "sid": kookoo_session_id, "status": "answered", "duration": "20", }) call2 = CallLog.get(call2._id) self.assertTrue(call2.answered) self.assertEqual(call2.duration, 20) form = self.get_last_form_submission() self.assertFormQuestionEquals(form, "how_feel", "1") self.assertFormQuestionEquals(form, "take_meds", "2") self.assertEqual(form.form["meta"]["userID"], self.user2._id) case = CommCareCase.get(self.case._id) self.assertCasePropertyEquals(case, "how_feel", "1") self.assertCasePropertyEquals(case, "take_meds", "2") self.assertEqual(case.user_id, self.user2._id) def tearDown(self): self.ivr_backend.delete() super(KooKooTestCase, self).tearDown()