class UtilTestCase(TestCase): def setUp(self): self.case = CommCareCase(domain='test-domain', name='test-case') self.case.save() self.user = CommCareUser.create('test-domain', 'test-user', '123') def tearDown(self): self.case.delete() self.user.delete() def testCleanPhoneNumber(self): phone_number = " 324 23-23421241" cleaned = clean_phone_number(phone_number) self.assertEquals(cleaned, "+3242323421241") def test_get_contact(self): contact = get_contact(self.case.get_id) self.assertEqual(contact.get_id, self.case.get_id) self.assertTrue(isinstance(contact, CommConnectCase)) contact = get_contact(self.user.get_id) self.assertEqual(contact.get_id, self.user.get_id) self.assertTrue(isinstance(contact, CommCareUser)) with self.assertRaises(ContactNotFoundException): get_contact('this-id-should-not-be-found') def test_apply_leniency(self): self.assertEqual('16175551234', apply_leniency(' 1 (617) 555-1234 ')) self.assertEqual('16175551234', apply_leniency(' 1.617.555.1234 ')) self.assertEqual('16175551234', apply_leniency(' +1 617 555 1234 '))
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_get_list(self): """ Any case in the appropriate domain should be in the list from the API. """ # The actual infrastructure involves saving to CouchDB, having PillowTop # read the changes and write it to ElasticSearch. #the pillow is set to offline mode - elasticsearch not needed to validate pillow = CasePillow(online=False) fake_case_es = FakeXFormES() v0_4.MOCK_CASE_ES = fake_case_es modify_date = datetime.utcnow() backend_case = CommCareCase(server_modified_on=modify_date, domain=self.domain.name) backend_case.save() translated_doc = pillow.change_transform(backend_case.to_json()) fake_case_es.add_doc(translated_doc['_id'], translated_doc) self.client.login(username=self.username, password=self.password) response = self.client.get(self.list_endpoint) self.assertEqual(response.status_code, 200) api_cases = simplejson.loads(response.content)['objects'] self.assertEqual(len(api_cases), 1) api_case = api_cases[0] self.assertEqual(dateutil.parser.parse(api_case['server_date_modified']), backend_case.server_modified_on) backend_case.delete()
class TestUtilFunctions(TestCase): def setUp(self): self.case = CommCareCase(domain='test-domain', name='test-case') self.case.save() self.user = CommCareUser.create('test-domain', 'test-user', '123') def test_get_contact(self): contact = get_contact(self.case.get_id) self.assertEqual(contact.get_id, self.case.get_id) self.assertTrue(isinstance(contact, CommConnectCase)) contact = get_contact(self.user.get_id) self.assertEqual(contact.get_id, self.user.get_id) self.assertTrue(isinstance(contact, CommCareUser)) try: get_contact('this-id-should-not-be-found') except Exception: pass else: self.assertTrue(False) def test_apply_leniency(self): self.assertEqual('16175551234', apply_leniency(' 1 (617) 555-1234 ')) self.assertEqual('16175551234', apply_leniency(' 1.617.555.1234 ')) self.assertEqual('16175551234', apply_leniency(' +1 617 555 1234 ')) def tearDown(self): self.case.delete() self.user.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_get_list(self): """ Any case in the appropriate domain should be in the list from the API. """ # The actual infrastructure involves saving to CouchDB, having PillowTop # read the changes and write it to ElasticSearch. #the pillow is set to offline mode - elasticsearch not needed to validate pillow = CasePillow(online=False) fake_case_es = FakeXFormES() v0_4.MOCK_CASE_ES = fake_case_es modify_date = datetime.utcnow() backend_case = CommCareCase(server_modified_on=modify_date, domain=self.domain.name) backend_case.type = CC_BIHAR_PREGNANCY backend_case.save() translated_doc = pillow.change_transform(backend_case.to_json()) fake_case_es.add_doc(translated_doc['_id'], translated_doc) self.client.login(username=self.username, password=self.password) response = self.client.get(self.list_endpoint) self.assertEqual(response.status_code, 200) api_cases = simplejson.loads(response.content)['objects'] self.assertEqual(len(api_cases), 2) api_case = api_cases['mother_lists'][0] self.assertEqual(dateutil.parser.parse(api_case['server_date_modified']), backend_case.server_modified_on) backend_case.delete()
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 saving(request): xform = XFormInstance(_attachments={'form.xml': {'data': '-'}}) xform.save() case = CommCareCase() case.save() xform.initial_processing_complete = True xform.save() case.delete() xform.delete() return HttpResponse('Thanks for submitting', status=201)
def test_case_zero_phone_number(self): case = CommCareCase( domain='case-phone-number-test', name='TEST1' ) set_case_property_directly(case, 'contact_phone_number', '99987658765') set_case_property_directly(case, 'contact_phone_number_is_verified', '1') case.save() self.assertIsNotNone(self.get_case_verified_number(case)) set_case_property_directly(case, 'contact_phone_number', '0') case.save() self.assertIsNone(self.get_case_verified_number(case)) 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_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_derived_properties(self): """ Smoke test that the HOPE properties do not crash on a pretty empty CommCareCase """ modify_date = datetime.utcnow() backend_case = CommCareCase(server_modified_on=modify_date, domain=self.domain.name) backend_case.save() # Rather than a re-fetch, this simulates the common case where it is pulled from ES hope_case = HOPECase.wrap(backend_case.to_json()) self.hit_every_HOPE_property(hope_case) backend_case.delete()
def testCaseAPIResultJSON(self): try: case = CommCareCase() # because of how setattr is overridden you have to set it to None in this wacky way case._doc['type'] = None case.save() self.assertEqual(None, CommCareCase.get(case._id).type) res_sanitized = CaseAPIResult(id=case._id, couch_doc=case, sanitize=True) res_unsanitized = CaseAPIResult(id=case._id, couch_doc=case, sanitize=False) json = res_sanitized.case_json self.assertEqual(json['properties']['case_type'], '') json = res_unsanitized.case_json self.assertEqual(json['properties']['case_type'], None) finally: case.delete()
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_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 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(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 TestGetInfoResourcesListSubCases(TestCase, DomainSubscriptionMixin): @classmethod def setUpClass(cls): super().setUpClass() cls.domain_obj = create_domain(DOMAIN) cls.setup_subscription(DOMAIN, SoftwarePlanEdition.PRO) cls.person_case_type = CaseType.objects.create(domain=DOMAIN, name='person') name = CaseProperty.objects.create(case_type=cls.person_case_type, name='name') resource_type_for_person = FHIRResourceType.objects.create( domain=DOMAIN, case_type=cls.person_case_type, name='Patient') FHIRResourceProperty.objects.create( resource_type=resource_type_for_person, case_property=name, jsonpath='$.name[0].text', ) FHIRResourceProperty.objects.create( resource_type=resource_type_for_person, value_source_config={ 'subcase_value_source': { 'case_property': 'given_names', # Use counter1 to skip the name set by the parent case 'jsonpath': '$.name[{counter1}].given', 'commcare_data_type': COMMCARE_DATA_TYPE_TEXT, 'external_data_type': FHIR_DATA_TYPE_LIST_OF_STRING, }, 'case_types': ['person_name'], }) FHIRResourceProperty.objects.create( resource_type=resource_type_for_person, value_source_config={ 'subcase_value_source': { 'case_property': 'family_name', 'jsonpath': '$.name[{counter1}].family', }, 'case_types': ['person_name'], }) @classmethod def tearDownClass(cls): cls.person_case_type.delete() cls.teardown_subscriptions() cls.domain_obj.delete() clear_plan_version_cache() super().tearDownClass() def setUp(self): now = datetime.utcnow() self.parent_case_id = str(uuid4()) self.parent_case = CommCareCase( _id=self.parent_case_id, domain=DOMAIN, type='person', name='Ted', owner_id=str(uuid4()), modified_on=now, server_modified_on=now, ) self.parent_case.save() self.child_case_1 = CommCareCase( case_id='111111111', domain=DOMAIN, type='person_name', name='Theodore', given_names='Theodore John', family_name='Kaczynski', indices=[ CommCareCaseIndex( identifier='parent', referenced_type='person', referenced_id=self.parent_case_id, ) ], owner_id=str(uuid4()), modified_on=now, server_modified_on=now, ) self.child_case_1.save() self.child_case_2 = CommCareCase( case_id='222222222', domain=DOMAIN, type='person_name', name='Unabomber', given_names='Unabomber', indices=[ CommCareCaseIndex( identifier='parent', referenced_type='person', referenced_id=self.parent_case_id, ) ], owner_id=str(uuid4()), modified_on=now, server_modified_on=now, ) self.child_case_2.save() def tearDown(self): self.child_case_1.delete() self.child_case_2.delete() self.parent_case.delete() def test_get_info_resource_list(self): rt = get_resource_type_or_none(self.parent_case, FHIR_VERSION_4_0_1) case_trigger_infos = [get_case_trigger_info(self.parent_case, rt)] resource_types_by_case_type = {'person': rt} [(info, resource)] = get_info_resource_list( case_trigger_infos, resource_types_by_case_type, ) self.assertEqual( resource, { 'id': self.parent_case_id, 'name': [ { 'text': 'Ted' }, { 'given': ['Theodore', 'John'], 'family': 'Kaczynski' }, { 'given': ['Unabomber'] }, ], 'resourceType': 'Patient', })
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 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()
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 TestGetInfoResourcesListResources(TestCase, DomainSubscriptionMixin): """ Demonstrates building multiple resources using subcases. """ @classmethod def setUpClass(cls): super().setUpClass() cls.domain_obj = create_domain(DOMAIN) cls.setup_subscription(DOMAIN, SoftwarePlanEdition.PRO) cls.person_case_type = CaseType.objects.create(domain=DOMAIN, name='person') name = CaseProperty.objects.create(case_type=cls.person_case_type, name='name') resource_type_for_person = FHIRResourceType.objects.create( domain=DOMAIN, case_type=cls.person_case_type, name='Patient') FHIRResourceProperty.objects.create( resource_type=resource_type_for_person, case_property=name, jsonpath='$.name[0].text', ) cls.vitals_case_type = CaseType.objects.create(domain=DOMAIN, name='vitals') CaseProperty.objects.create(case_type=cls.vitals_case_type, name='temperature') resource_type_for_vitals = FHIRResourceType.objects.create( domain=DOMAIN, case_type=cls.vitals_case_type, name='Observation', template={ 'code': { 'coding': [{ 'system': 'http://loinc.org', 'code': '8310-5', 'display': 'Body temperature', }], 'text': 'Temperature', }, 'valueQuantity': { 'unit': 'degrees Celsius', }, }) FHIRResourceProperty.objects.create( resource_type=resource_type_for_vitals, value_source_config={ 'case_property': 'temperature', 'jsonpath': '$.valueQuantity.value', 'external_data_type': COMMCARE_DATA_TYPE_DECIMAL, }) FHIRResourceProperty.objects.create( resource_type=resource_type_for_vitals, value_source_config={ 'supercase_value_source': { 'case_property': 'name', 'jsonpath': '$.subject.display', } }) FHIRResourceProperty.objects.create( resource_type=resource_type_for_vitals, value_source_config={ 'supercase_value_source': { 'case_property': 'case_id', 'jsonpath': '$.subject.reference', } }) @classmethod def tearDownClass(cls): cls.person_case_type.delete() cls.vitals_case_type.delete() cls.teardown_subscriptions() cls.domain_obj.delete() clear_plan_version_cache() super().tearDownClass() def setUp(self): now = datetime.utcnow() owner_id = str(uuid4()) self.parent_case_id = str(uuid4()) self.parent_case = CommCareCase( _id=self.parent_case_id, domain=DOMAIN, type='person', name='Beth', owner_id=owner_id, modified_on=now, server_modified_on=now, ) self.parent_case.save() self.child_case_id = str(uuid4()) self.child_case = CommCareCase( _id=self.child_case_id, domain=DOMAIN, type='vitals', temperature=36.1, indices=[ CommCareCaseIndex( identifier='parent', referenced_type='person', referenced_id=self.parent_case_id, ) ], owner_id=owner_id, modified_on=now, server_modified_on=now, ) self.child_case.save() def tearDown(self): self.child_case.delete() self.parent_case.delete() def test_get_info_resource_list(self): resource_type_for_person = get_resource_type_or_none( self.parent_case, FHIR_VERSION_4_0_1, ) resource_type_for_vitals = get_resource_type_or_none( self.child_case, FHIR_VERSION_4_0_1, ) case_trigger_infos = [ get_case_trigger_info(self.parent_case, resource_type_for_person), get_case_trigger_info(self.child_case, resource_type_for_vitals), ] resource_types_by_case_type = { 'person': resource_type_for_person, 'vitals': resource_type_for_vitals, } info_resource_list = get_info_resource_list( case_trigger_infos, resource_types_by_case_type, ) resources = [resource for info, resource in info_resource_list] self.assertEqual(resources, [{ 'id': self.parent_case_id, 'name': [{ 'text': 'Beth' }], 'resourceType': 'Patient', }, { 'id': self.child_case_id, 'code': { 'coding': [{ 'system': 'http://loinc.org', 'code': '8310-5', 'display': 'Body temperature', }], 'text': 'Temperature', }, 'valueQuantity': { 'value': 36.1, 'unit': 'degrees Celsius', }, 'subject': { 'reference': self.parent_case_id, 'display': 'Beth', }, 'resourceType': 'Observation', }])
class TestGetInfoResourcesListOneCase(TestCase, DomainSubscriptionMixin): @classmethod def setUpClass(cls): super().setUpClass() cls.domain_obj = create_domain(DOMAIN) cls.setup_subscription(DOMAIN, SoftwarePlanEdition.PRO) cls.case_type = CaseType.objects.create(domain=DOMAIN, name='person') name = CaseProperty.objects.create(case_type=cls.case_type, name='name') resource_type = FHIRResourceType.objects.create( domain=DOMAIN, case_type=cls.case_type, name='Patient') FHIRResourceProperty.objects.create( resource_type=resource_type, case_property=name, jsonpath='$.name[0].text', ) @classmethod def tearDownClass(cls): cls.case_type.delete() cls.teardown_subscriptions() cls.domain_obj.delete() clear_plan_version_cache() super().tearDownClass() def setUp(self): now = datetime.utcnow() self.case_id = str(uuid4()) self.case = CommCareCase( _id=self.case_id, domain=DOMAIN, type='person', name='Ted', owner_id=str(uuid4()), modified_on=now, server_modified_on=now, ) self.case.save() def tearDown(self): self.case.delete() def test_get_info_resource_list(self): resource_type = get_resource_type_or_none(self.case, FHIR_VERSION_4_0_1) case_trigger_infos = [get_case_trigger_info(self.case, resource_type)] resource_types_by_case_type = {'person': resource_type} [(info, resource)] = get_info_resource_list( case_trigger_infos, resource_types_by_case_type, ) self.assertEqual( resource, { 'id': self.case_id, 'name': [{ 'text': 'Ted' }], 'resourceType': 'Patient' })
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)