def _get_inbound_phone_entry__backend_domain_2(self):
"""The utilities main objective is to ensure consistency between the various
test methods that are testing `get_inbound_phone_entry` under different conditions
"""
sms = SMS(phone_number=self.phone_number,
backend_id=self.domain2_backend.couch_id)
return get_inbound_phone_entry_from_sms(sms)
def test_get_inbound_phone_entry__no_backend_id(self):
sms = SMS(phone_number=self.phone_number)
phone_number, has_domain_two_way_scope = get_inbound_phone_entry_from_sms(
sms)
self.assertEqual(phone_number.owner_id, "fake-owner-1")
self.assertFalse(has_domain_two_way_scope)
def testSMSSync(self):
prev_couch_count = self.getSMSLogCount()
prev_sql_count = self.getSMSCount()
# Test Create
sms = SMS()
self.setRandomSMSValues(sms)
sms.save()
sleep(1)
self.assertEqual(self.getSMSLogCount(), prev_couch_count + 1)
self.assertEqual(self.getSMSCount(), prev_sql_count + 1)
smslog = FRISMSLog.get(sms.couch_id)
self.checkFieldValues(smslog, sms, SMS._migration_get_fields())
self.assertTrue(FRISMSLog.get_db().get_rev(
smslog._id).startswith('2-'))
# Test Update
self.setRandomSMSValues(sms)
sms.save()
sleep(1)
self.assertEqual(self.getSMSLogCount(), prev_couch_count + 1)
self.assertEqual(self.getSMSCount(), prev_sql_count + 1)
smslog = FRISMSLog.get(sms.couch_id)
self.checkFieldValues(smslog, sms, SMS._migration_get_fields())
self.assertTrue(FRISMSLog.get_db().get_rev(
smslog._id).startswith('3-'))
def _get_fake_sms(self, text):
msg = SMS(domain=self.domain,
phone_number='+16175555454',
direction=OUTGOING,
date=datetime.utcnow(),
backend_id=self.mobile_backend.couch_id,
text=text)
msg.save()
return msg
def test_get_inbound_phone_entry__global_backend(self):
sms = SMS(phone_number=self.phone_number,
backend_id=self.global_backend.couch_id)
phone_number, has_domain_two_way_scope = get_inbound_phone_entry_from_sms(
sms)
self.assertEqual(phone_number.owner_id, "fake-owner-1")
self.assertFalse(has_domain_two_way_scope)
self.assertTrue(
self.global_backend.domain_is_authorized(phone_number.domain))
def _test_unicel_send(self, text, expected_msg):
message = SMS(text=text, phone_number='+15555555555')
with patch('corehq.messaging.smsbackends.unicel.models.urlopen') as patch_urlopen:
self.backend.send(message)
self.assertEqual(len(patch_urlopen.call_args_list), 1)
called_args = patch_urlopen.call_args_list[0]
url, = called_args[0]
parsed_url = urlparse(url)
url_params = parse_qs(parsed_url.query)
self.assertEqual(url_params['msg'], [expected_msg])
def send_sample_sms(request, domain):
request_token = request.POST.get('request_token')
if not TelerivetSetupView.get_cached_webhook_secret(request_token):
return {
'success': False,
'unexpected_error': TelerivetSetupView.unexpected_error,
}
outgoing_sms_form = TelerivetOutgoingSMSForm({
'api_key':
request.POST.get('api_key'),
'project_id':
request.POST.get('project_id'),
'phone_id':
request.POST.get('phone_id'),
})
test_sms_form = TelerivetPhoneNumberForm({
'test_phone_number':
request.POST.get('test_phone_number'),
})
# Be sure to call .is_valid() on both
outgoing_sms_form_valid = outgoing_sms_form.is_valid()
test_sms_form_valid = test_sms_form.is_valid()
if not outgoing_sms_form_valid or not test_sms_form_valid:
return json_response({
'success':
False,
'api_key_error':
TelerivetSetupView.get_error_message(outgoing_sms_form, 'api_key'),
'project_id_error':
TelerivetSetupView.get_error_message(outgoing_sms_form,
'project_id'),
'phone_id_error':
TelerivetSetupView.get_error_message(outgoing_sms_form,
'phone_id'),
'test_phone_number_error':
TelerivetSetupView.get_error_message(test_sms_form,
'test_phone_number'),
})
tmp_backend = SQLTelerivetBackend()
tmp_backend.set_extra_fields(
api_key=outgoing_sms_form.cleaned_data.get('api_key'),
project_id=outgoing_sms_form.cleaned_data.get('project_id'),
phone_id=outgoing_sms_form.cleaned_data.get('phone_id'),
)
sms = SMS(phone_number=clean_phone_number(
test_sms_form.cleaned_data.get('test_phone_number')),
text="This is a test SMS from CommCareHQ.")
tmp_backend.send(sms)
return json_response({
'success': True,
})
def get_fake_sms(domain, backend_api_id, backend_couch_id, text):
msg = SMS(domain=domain,
phone_number='+12223334444',
direction=OUTGOING,
date=datetime.utcnow(),
backend_api=backend_api_id,
backend_id=backend_couch_id,
backend_message_id=uuid.uuid4().hex,
text=text)
msg.save()
return msg
def create_fake_sms(self, backend_api_id, backend_couch_id, text, date):
msg = SMS(domain=self.domain,
phone_number='+12223334444',
direction=OUTGOING,
date=date,
backend_api=backend_api_id,
backend_id=backend_couch_id,
backend_message_id=uuid.uuid4().hex,
text=text)
msg.save()
return msg
def setUp(self):
self.backend = SQLTelerivetBackend(
name='TELERIVET',
is_global=True,
hq_api_id=SQLTelerivetBackend.get_api_id())
self.backend.set_extra_fields(
webhook_secret='The chamber of webhook secrets')
self.backend.save()
self.sms = SMS(phone_number='27845698785', text="Fame is fickle")
self.sms.save()
def _get_sms(self):
msg = SMS(
phone_number=self.number1.phone_number,
direction=INCOMING,
date=datetime.utcnow(),
text="test message",
domain_scope=None,
backend_api=None,
backend_id=None,
backend_message_id=None,
raw_text=None,
)
return msg
def _create_message(self,
domain='test_domain',
phone_number='2511234567',
direction=OUTGOING,
date=None,
text='Hello World'):
if not date:
date = datetime(2021, 5, 15)
return SMS(domain=domain,
phone_number=phone_number,
direction=direction,
date=date,
text=text)
def remove_from_queue(queued_sms):
with transaction.atomic():
sms = SMS()
for field in sms._meta.fields:
if field.name != 'id':
setattr(sms, field.name, getattr(queued_sms, field.name))
queued_sms.delete()
sms.save()
sms.publish_change()
if sms.direction == OUTGOING and sms.processed and not sms.error:
create_billable_for_sms(sms)
elif sms.direction == INCOMING and sms.domain and domain_has_privilege(sms.domain, privileges.INBOUND_SMS):
create_billable_for_sms(sms)
def setUp(self):
super(TestProcessMessageStatus, self).setUp()
self.backend = SQLTelerivetBackend(
name='TELERIVET',
is_global=True,
hq_api_id=SQLTelerivetBackend.get_api_id())
self.backend.set_extra_fields(
webhook_secret='The chamber of webhook secrets')
self.backend.save()
self.sms = SMS(
text='I am testy',
custom_metadata={'case_id': '123'},
)
self.sms.save()
def test_incoming_sms_linked_form_session(self):
event, expected_subevent = self._create_message_event_and_subevent()
msg = SMS(
phone_number=self.number.phone_number,
direction=INCOMING,
date=datetime.utcnow(),
text="test message",
domain_scope=None,
backend_api=None,
backend_id=None,
backend_message_id=None,
raw_text=None,
)
self.addCleanup(msg.delete)
form_session_handler(self.number, msg.text, msg)
self.assertEqual(expected_subevent, msg.messaging_subevent)
def test_correctly_handles_ssrf(self, mock_save, mock_metrics_counter):
# SSRF needs to:
# - set the error on the message and save, so the message isn't re-queued
# - generate a metric
# - raise a PossibleSSRFAttempt exception
message = SMS(domain='test-domain')
# raise exception
with self.assertRaises(PossibleSSRFAttempt):
verify_sms_url('https://malicious.address', message, self.backend)
# setting error message and saving
self.assertTrue(message.error)
self.assertEqual(message.system_error_message, 'FAULTY_GATEWAY_CONFIGURATION')
mock_save.assert_called()
# generating the metric
mock_metrics_counter.assert_called_with('commcare.sms.ssrf_attempt',
tags={'domain': 'test-domain', 'src': 'SQLHttpBackend', 'reason': 'is_loopback'})
def arbitrary_messages_by_backend_and_direction(backend_ids,
phone_number=None,
domain=None,
directions=None):
phone_number = phone_number or TEST_NUMBER
domain = domain or TEST_DOMAIN
directions = directions or DIRECTIONS
messages = []
for api_id, instance_id in backend_ids.items():
for direction in directions:
sms_log = SMS(direction=direction,
phone_number=phone_number,
domain=domain,
backend_api=api_id,
backend_id=instance_id,
backend_message_id=uuid.uuid4().hex,
text=arbitrary_message(),
date=datetime.datetime.utcnow())
sms_log.save()
messages.append(sms_log)
return messages
def remove_from_queue(queued_sms):
with transaction.atomic():
sms = SMS()
for field in sms._meta.fields:
if field.name != 'id':
setattr(sms, field.name, getattr(queued_sms, field.name))
queued_sms.delete()
sms.save()
sms.publish_change()
tags = {'backend': sms.backend_api, 'icds_indicator': ''}
if isinstance(sms.custom_metadata,
dict) and 'icds_indicator' in sms.custom_metadata:
tags.update({'icds_indicator': sms.custom_metadata['icds_indicator']})
if sms.direction == OUTGOING and sms.processed and not sms.error:
create_billable_for_sms(sms)
metrics_counter('commcare.sms.outbound_succeeded', tags=tags)
elif sms.direction == OUTGOING:
metrics_counter('commcare.sms.outbound_failed', tags=tags)
elif sms.direction == INCOMING and sms.domain and domain_has_privilege(
sms.domain, privileges.INBOUND_SMS):
create_billable_for_sms(sms)
def test_incoming_sms_multiple_subevents_for_session(self):
first_event, first_subevent = self._create_message_event_and_subevent()
second_event, second_subevent = self._create_message_event_and_subevent(
)
# no message event or subevent exist
msg = SMS(
phone_number=self.number.phone_number,
direction=INCOMING,
date=datetime.utcnow(),
text="test message",
domain_scope=None,
backend_api=None,
backend_id=None,
backend_message_id=None,
raw_text=None,
)
self.addCleanup(msg.delete)
form_session_handler(self.number, msg.text, msg)
# assert that the most recent subevent is used
self.assertNotEqual(first_subevent, msg.messaging_subevent)
self.assertEqual(second_subevent, msg.messaging_subevent)
def get_sms_from_queued_sms(queued_sms):
sms = SMS()
for field in _get_sms_fields_to_copy():
setattr(sms, field, getattr(queued_sms, field))
return sms
def setUp(self):
self.message = SMS()
self.backend = SQLHttpBackend()
