def test_backend(self):
backend1 = SQLTestSMSBackend.objects.create(
hq_api_id=SQLTestSMSBackend.get_api_id(),
is_global=False,
domain=self.domain,
name='BACKEND1'
)
backend2 = SQLTestSMSBackend.objects.create(
hq_api_id=SQLTestSMSBackend.get_api_id(),
is_global=False,
domain=self.domain,
name='BACKEND2'
)
SQLMobileBackendMapping.set_default_domain_backend(self.domain, backend1)
number = PhoneNumber(domain=self.domain, phone_number='+999123')
self.assertEqual(number.backend, backend1)
number.backend_id = backend2.name
self.assertEqual(number.backend, backend2)
number.backend_id = ' '
self.assertEqual(number.backend, backend1)
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 tearDown(self):
delete_domain_phone_numbers(self.domain)
SQLMobileBackendMapping.unset_default_domain_backend(self.domain)
self.backend.delete()
self.domain_obj.delete()
super(RegistrationTestCase, self).tearDown()
def tearDown(self):
delete_domain_phone_numbers(self.domain)
SQLMobileBackendMapping.unset_default_domain_backend(self.domain)
self.backend.delete()
self.domain_obj.delete()
super(RegistrationTestCase, self).tearDown()
def test_backend(self):
backend1 = SQLTestSMSBackend.objects.create(
hq_api_id=SQLTestSMSBackend.get_api_id(),
is_global=False,
domain=self.domain,
name='BACKEND1'
)
backend2 = SQLTestSMSBackend.objects.create(
hq_api_id=SQLTestSMSBackend.get_api_id(),
is_global=False,
domain=self.domain,
name='BACKEND2'
)
SQLMobileBackendMapping.set_default_domain_backend(self.domain, backend1)
number = PhoneNumber(domain=self.domain, phone_number='+999123')
self.assertEqual(number.backend, backend1)
number.backend_id = backend2.name
self.assertEqual(number.backend, backend2)
number.backend_id = ' '
self.assertEqual(number.backend, backend1)
def set_domain_default_backend_to_test_backend(domain):
"""
Pass in the name of the domain to set the domain's default
sms backend to be the test backend.
"""
from corehq.apps.sms.models import SQLMobileBackend, SQLMobileBackendMapping
test_backend = SQLMobileBackend.get_global_backend_by_name(SQLMobileBackend.SMS, "MOBILE_BACKEND_TEST")
if not test_backend:
raise Exception("Expected MOBILE_BACKEND_TEST to be created")
SQLMobileBackendMapping.set_default_domain_backend(domain, test_backend)
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 set_domain_default_backend_to_test_backend(domain):
"""
Pass in the name of the domain to set the domain's default
sms backend to be the test backend.
"""
from corehq.apps.sms.models import SQLMobileBackend, SQLMobileBackendMapping
test_backend = SQLMobileBackend.get_global_backend_by_name(
SQLMobileBackend.SMS, 'MOBILE_BACKEND_TEST')
if not test_backend:
raise Exception("Expected MOBILE_BACKEND_TEST to be created")
SQLMobileBackendMapping.set_default_domain_backend(domain, test_backend)
def _test_outbound_backend(self, backend, msg_text, mock_send):
SQLMobileBackendMapping.set_default_domain_backend(self.domain_obj.name, backend)
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)
self.assertEqual(sms.backend_api, backend.hq_api_id)
self.assertEqual(sms.backend_id, backend.couch_id)
def create_backend(request, domain):
webhook_secret = TelerivetSetupView.get_cached_webhook_secret(
request.POST.get('request_token'))
values = {
'name': request.POST.get('name'),
'description': _("My Telerivet Gateway"),
'api_key': request.POST.get('api_key'),
'project_id': request.POST.get('project_id'),
'phone_id': request.POST.get('phone_id'),
'webhook_secret': webhook_secret,
}
form = TelerivetBackendForm(values, domain=domain, backend_id=None)
if form.is_valid():
with transaction.atomic():
backend = SQLTelerivetBackend(
backend_type=SQLMobileBackend.SMS,
inbound_api_key=webhook_secret,
hq_api_id=SQLTelerivetBackend.get_api_id(),
is_global=False,
domain=domain,
name=form.cleaned_data.get('name'),
description=form.cleaned_data.get('description'))
backend.set_extra_fields(
api_key=form.cleaned_data.get('api_key'),
project_id=form.cleaned_data.get('project_id'),
phone_id=form.cleaned_data.get('phone_id'),
webhook_secret=webhook_secret)
phone_number = backend.get_phone_number_or_none()
if phone_number:
backend.description += ' {}'.format(phone_number)
backend.reply_to_phone_number = phone_number
backend.save()
if request.POST.get(
'set_as_default') == FinalizeGatewaySetupForm.YES:
SQLMobileBackendMapping.set_default_domain_backend(
domain, backend)
return json_response({'success': True})
name_error = TelerivetSetupView.get_error_message(form, 'name')
return json_response({
'success':
False,
'name_error':
name_error,
'unexpected_error':
None if name_error else TelerivetSetupView.unexpected_error,
})
def setUp(self):
super(RegistrationTestCase, self).setUp()
self.domain = 'sms-reg-test-domain'
self.domain_obj = Domain(name=self.domain)
self.domain_obj.save()
self.create_account_and_subscription(self.domain)
self.domain_obj = Domain.get(self.domain_obj.get_id)
self.backend = SQLTestSMSBackend.objects.create(
name='BACKEND',
is_global=False,
domain=self.domain,
hq_api_id=SQLTestSMSBackend.get_api_id()
)
SQLMobileBackendMapping.set_default_domain_backend(self.domain, self.backend)
def create_backend(request, domain):
webhook_secret = TelerivetSetupView.get_cached_webhook_secret(request.POST.get('request_token'))
values = {
'name': request.POST.get('name'),
'description': _("My Telerivet Gateway"),
'api_key': request.POST.get('api_key'),
'project_id': request.POST.get('project_id'),
'phone_id': request.POST.get('phone_id'),
'webhook_secret': webhook_secret,
}
form = TelerivetBackendForm(values, domain=domain, backend_id=None)
if form.is_valid():
with transaction.atomic():
backend = SQLTelerivetBackend(
backend_type=SQLMobileBackend.SMS,
inbound_api_key=webhook_secret,
hq_api_id=SQLTelerivetBackend.get_api_id(),
is_global=False,
domain=domain,
name=form.cleaned_data.get('name'),
description=form.cleaned_data.get('description')
)
backend.set_extra_fields(
api_key=form.cleaned_data.get('api_key'),
project_id=form.cleaned_data.get('project_id'),
phone_id=form.cleaned_data.get('phone_id'),
webhook_secret=webhook_secret
)
phone_number = backend.get_phone_number_or_none()
if phone_number:
backend.description += ' {}'.format(phone_number)
backend.reply_to_phone_number = phone_number
backend.save()
if request.POST.get('set_as_default') == FinalizeGatewaySetupForm.YES:
SQLMobileBackendMapping.set_default_domain_backend(domain, backend)
return json_response({'success': True})
name_error = TelerivetSetupView.get_error_message(form, 'name')
return json_response({
'success': False,
'name_error': name_error,
'unexpected_error': None if name_error else TelerivetSetupView.unexpected_error,
})
def create_backend(self, data):
webhook_secret = self.get_cached_webhook_secret(data.get("request_token"))
values = {
"name": data.get("name"),
"description": _("My Telerivet Gateway"),
"api_key": data.get("api_key"),
"project_id": data.get("project_id"),
"phone_id": data.get("phone_id"),
"webhook_secret": webhook_secret,
}
form = TelerivetBackendForm(values, domain=self.domain, backend_id=None)
if form.is_valid():
with transaction.atomic():
backend = SQLTelerivetBackend(
backend_type=SQLMobileBackend.SMS,
inbound_api_key=webhook_secret,
hq_api_id=SQLTelerivetBackend.get_api_id(),
is_global=False,
domain=self.domain,
name=form.cleaned_data.get("name"),
description=form.cleaned_data.get("description"),
)
backend.set_extra_fields(
api_key=form.cleaned_data.get("api_key"),
project_id=form.cleaned_data.get("project_id"),
phone_id=form.cleaned_data.get("phone_id"),
webhook_secret=webhook_secret,
)
phone_number = backend.get_phone_number_or_none()
if phone_number:
backend.description += " {}".format(phone_number)
backend.reply_to_phone_number = phone_number
backend.save()
if data.get("set_as_default") == FinalizeGatewaySetupForm.YES:
SQLMobileBackendMapping.set_default_domain_backend(self.domain, backend)
return {"success": True}
name_error = self.get_error_message(form, "name")
return {
"success": False,
"name_error": name_error,
"unexpected_error": None if name_error else self.unexpected_error,
}
def setUp(self):
super(RegistrationTestCase, self).setUp()
self.domain = 'sms-reg-test-domain'
self.domain_obj = Domain(name=self.domain)
self.domain_obj.save()
self.create_account_and_subscription(self.domain)
self.domain_obj = Domain.get(self.domain_obj.get_id)
self.backend = SQLTestSMSBackend.objects.create(
name='BACKEND',
is_global=False,
domain=self.domain,
hq_api_id=SQLTestSMSBackend.get_api_id()
)
SQLMobileBackendMapping.set_default_domain_backend(self.domain, self.backend)
self.app_id = 'app_id'
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_set_default_domain_backend(self):
backend1 = SQLTestSMSBackend.objects.create(
name='BACKEND1',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend2 = SQLTestSMSBackend.objects.create(
name='BACKEND2',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
domain = 'domain-default-backend-test'
self.assertNoDomainDefaultBackend(domain)
SQLMobileBackendMapping.set_default_domain_backend(domain, backend1)
self.assertDomainDefaultBackend(domain, backend1)
SQLMobileBackendMapping.set_default_domain_backend(domain, backend2)
self.assertDomainDefaultBackend(domain, backend2)
SQLMobileBackendMapping.unset_default_domain_backend(domain)
self.assertNoDomainDefaultBackend(domain)
backend1.delete()
backend2.delete()
def create_backend(self, data):
webhook_secret = self.get_cached_webhook_secret(data.get('request_token'))
values = {
'name': data.get('name'),
'description': _("My Telerivet Gateway '{}'").format(data.get('name')),
'api_key': data.get('api_key'),
'project_id': data.get('project_id'),
'phone_id': data.get('phone_id'),
'webhook_secret': webhook_secret,
}
form = TelerivetBackendForm(values, domain=self.domain, backend_id=None)
if form.is_valid():
with transaction.atomic():
backend = SQLTelerivetBackend(
backend_type=SQLMobileBackend.SMS,
inbound_api_key=webhook_secret,
hq_api_id=SQLTelerivetBackend.get_api_id(),
is_global=False,
domain=self.domain,
name=form.cleaned_data.get('name'),
description=form.cleaned_data.get('description')
)
backend.set_extra_fields(
api_key=form.cleaned_data.get('api_key'),
project_id=form.cleaned_data.get('project_id'),
phone_id=form.cleaned_data.get('phone_id'),
webhook_secret=webhook_secret
)
backend.save()
if data.get('set_as_default') == FinalizeGatewaySetupForm.YES:
SQLMobileBackendMapping.set_default_domain_backend(self.domain, backend)
return {'success': True}
name_error = self.get_error_message(form, 'name')
return {
'success': False,
'name_error': name_error,
'unexpected_error': None if name_error else self.unexpected_error,
}
def test_get_prefix_to_backend_map(self):
backend1 = SQLTestSMSBackend.objects.create(
name='BACKEND1',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend2 = SQLTestSMSBackend.objects.create(
name='BACKEND2',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend3 = SQLTestSMSBackend.objects.create(
name='BACKEND3',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend4 = SQLTestSMSBackend.objects.create(
name='BACKEND4',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend5 = SQLTestSMSBackend.objects.create(
name='BACKEND5',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend6 = SQLTestSMSBackend.objects.create(
name='BACKEND6',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend_mapping1 = SQLMobileBackendMapping.objects.create(
is_global=True,
backend_type=SQLMobileBackend.SMS,
prefix='*',
backend=backend1
)
backend_mapping2 = SQLMobileBackendMapping.objects.create(
is_global=True,
backend_type=SQLMobileBackend.SMS,
prefix='27',
backend=backend2
)
backend_mapping3 = SQLMobileBackendMapping.objects.create(
is_global=True,
backend_type=SQLMobileBackend.SMS,
prefix='1',
backend=backend3
)
backend_mapping4 = SQLMobileBackendMapping.objects.create(
is_global=False,
domain='prefix-backend-map-test',
backend_type=SQLMobileBackend.SMS,
prefix='*',
backend=backend4
)
backend_mapping5 = SQLMobileBackendMapping.objects.create(
is_global=False,
domain='prefix-backend-map-test',
backend_type=SQLMobileBackend.SMS,
prefix='256',
backend=backend5
)
backend_mapping6 = SQLMobileBackendMapping.objects.create(
is_global=False,
domain='prefix-backend-map-test',
backend_type=SQLMobileBackend.SMS,
prefix='25670',
backend=backend6
)
global_backend_map = SQLMobileBackendMapping.get_prefix_to_backend_map(SQLMobileBackend.SMS)
self.assertEqual(global_backend_map.catchall_backend_id, backend1.pk)
self.assertEqual(global_backend_map.backend_map_dict, {
'27': backend2.pk,
'1': backend3.pk,
})
domain_backend_map = SQLMobileBackendMapping.get_prefix_to_backend_map(
SQLMobileBackend.SMS,
domain='prefix-backend-map-test'
)
self.assertEqual(domain_backend_map.catchall_backend_id, backend4.pk)
self.assertEqual(domain_backend_map.backend_map_dict, {
'256': backend5.pk,
'25670': backend6.pk,
})
backend_mapping1.delete()
backend_mapping2.delete()
backend_mapping3.delete()
backend_mapping4.delete()
backend_mapping5.delete()
backend_mapping6.delete()
backend1.delete()
backend2.delete()
backend3.delete()
backend4.delete()
backend5.delete()
backend6.delete()
