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_domain_is_authorized(self): backend1 = SQLTestSMSBackend.objects.create( name='BACKEND1', is_global=True, hq_api_id=SQLTestSMSBackend.get_api_id(), ) backend2 = SQLTestSMSBackend.objects.create( name='BACKEND2', domain='auth-test-1', is_global=False, hq_api_id=SQLTestSMSBackend.get_api_id(), ) self.assertTrue(backend1.domain_is_authorized('auth-test-1')) self.assertTrue(backend1.domain_is_authorized('auth-test-2')) self.assertTrue(backend1.domain_is_authorized('auth-test-3')) self.assertTrue(backend2.domain_is_authorized('auth-test-1')) self.assertFalse(backend2.domain_is_authorized('auth-test-2')) self.assertFalse(backend2.domain_is_authorized('auth-test-3')) backend2.set_shared_domains(['auth-test-2']) self.assertTrue(backend2.domain_is_authorized('auth-test-1')) self.assertTrue(backend2.domain_is_authorized('auth-test-2')) self.assertFalse(backend2.domain_is_authorized('auth-test-3')) backend1.delete() backend2.delete()
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 setUpClass(cls): super(TestEnterpriseSMSBillablesReport, cls).setUpClass() cls.domain = 'test-domain' cls.domain_obj = create_domain(cls.domain) cls.user = WebUser.create( cls.domain, "test-user", "123", None, None, ) cls.account = generator.billing_account(cls.user, "*****@*****.**") cls.subscription_length = 15 # months subscription_start_date = datetime(2021, 1, 1) cls.subscription = generator.generate_domain_subscription( cls.account, cls.domain_obj, date_start=subscription_start_date, date_end=None) cls.subscription.is_active = True cls.subscription.save() cls.backend = SQLTestSMSBackend( name="TEST", is_global=True, domain=cls.domain, hq_api_id=SQLTestSMSBackend.get_api_id()) cls.backend.save()
def bootstrap_test_gateway(apps): default_currency, _ = (apps.get_model('accounting', 'Currency') if apps else Currency).objects.get_or_create( code=settings.DEFAULT_CURRENCY) sms_gateway_fee_class = apps.get_model( 'smsbillables', 'SmsGatewayFee') if apps else SmsGatewayFee sms_gateway_fee_criteria_class = apps.get_model( 'smsbillables', 'SmsGatewayFeeCriteria') if apps else SmsGatewayFeeCriteria SmsGatewayFee.create_new( SQLTestSMSBackend.get_api_id(), INCOMING, Decimal('0.0'), currency=default_currency, fee_class=sms_gateway_fee_class, criteria_class=sms_gateway_fee_criteria_class, ) SmsGatewayFee.create_new( SQLTestSMSBackend.get_api_id(), OUTGOING, Decimal('0.0'), currency=default_currency, fee_class=sms_gateway_fee_class, criteria_class=sms_gateway_fee_criteria_class, ) log_smsbillables_info("Updated Test gateway fees.")
def test_get_backend_api_id(self): backend = SQLTestSMSBackend.objects.create( name='BACKEND', is_global=True, hq_api_id=SQLTestSMSBackend.get_api_id(), ) self.assertEquals( SQLMobileBackend.get_backend_api_id(backend.pk), SQLTestSMSBackend.get_api_id() ) self.assertEquals( SQLMobileBackend.get_backend_api_id(backend.couch_id, is_couch_id=True), SQLTestSMSBackend.get_api_id() ) backend.soft_delete() with self.assertRaises(SQLMobileBackend.DoesNotExist): SQLMobileBackend.get_backend_api_id(backend.pk) with self.assertRaises(SQLMobileBackend.DoesNotExist): SQLMobileBackend.get_backend_api_id(backend.couch_id, is_couch_id=True) backend.delete()
def setUpClass(cls): super(TestGatewayChargeWithNoAPISupport, cls).setUpClass() cls.domain = 'sms_test_domain' cls.backend = SQLTestSMSBackend( name="TEST BACKEND", is_global=True, domain=cls.domain, hq_api_id=SQLTestSMSBackend.get_api_id()) cls.backend.save()
def setUpClass(cls): super(TestBillableCreation, cls).setUpClass() cls.domain = 'sms_test_domain' cls.backend = SQLTestSMSBackend( name="TEST", is_global=True, domain=cls.domain, hq_api_id=SQLTestSMSBackend.get_api_id()) cls.backend.save()
def setUpTestData(cls): cls.domain_name = uuid.uuid4().hex cls.backend = SQLTestSMSBackend.objects.create( name='BACKEND', domain=cls.domain_name, is_global=False, hq_api_id=SQLTestSMSBackend.get_api_id()) cls.number1 = PhoneNumber.objects.create( domain=cls.domain_name, owner_doc_type='CommCareCase', owner_id='fake-owner-id1', phone_number='01112223333', backend_id='BACKEND', ivr_backend_id=None, verified=True, is_two_way=True, pending_verification=False, contact_last_modified=datetime.utcnow()) cls.number2 = PhoneNumber.objects.create( domain=cls.domain_name, owner_doc_type='CommCareCase', owner_id='fake-owner-id2', phone_number='01112223333', backend_id='BACKEND', ivr_backend_id=None, verified=True, is_two_way=True, pending_verification=False, contact_last_modified=datetime.utcnow())
def setUpClass(cls): super().setUpClass() cls.domain = Domain(name=uuid.uuid4().hex) cls.domain.save() cls.number = PhoneNumber(domain=cls.domain.name, owner_doc_type='CommCareCase', owner_id='fake-owner-id1', phone_number='01112223333', backend_id=None, ivr_backend_id=None, verified=True, is_two_way=True, pending_verification=False, contact_last_modified=datetime.utcnow()) cls.number.save() cls.session = SQLXFormsSession.create_session_object( cls.domain.name, Mock(get_id=cls.number.owner_id), cls.number.phone_number, Mock(get_id='app_id'), Mock(xmlns='xmlns'), expire_after=24 * 60, ) cls.session.save() cls.backend = SQLTestSMSBackend.objects.create( name='BACKEND', domain=cls.domain, is_global=False, hq_api_id=SQLTestSMSBackend.get_api_id())
def create(cls, message_log, multipart_count=1): phone_number = clean_phone_number(message_log.phone_number) direction = message_log.direction domain = message_log.domain log_id = message_log.couch_id billable = cls( log_id=log_id, phone_number=phone_number, direction=direction, date_sent=message_log.date, domain=domain, ) gateway_charge_info = cls._get_gateway_fee( message_log.backend_api, message_log.backend_id, phone_number, direction, log_id, message_log.backend_message_id, domain ) billable.gateway_fee = gateway_charge_info.gateway_fee billable.gateway_fee_conversion_rate = gateway_charge_info.conversion_rate billable.direct_gateway_fee = gateway_charge_info.direct_gateway_fee billable.multipart_count = cls._get_multipart_count( message_log.backend_api, message_log.backend_id, message_log.backend_message_id, multipart_count ) billable.usage_fee = cls._get_usage_fee(domain, direction) if message_log.backend_api == SQLTestSMSBackend.get_api_id(): billable.is_valid = False billable.save() return billable
def create(cls, message_log, multipart_count=1): phone_number = clean_phone_number(message_log.phone_number) direction = message_log.direction domain = message_log.domain log_id = message_log.couch_id billable = cls( log_id=log_id, phone_number=phone_number, direction=direction, date_sent=message_log.date, domain=domain, ) gateway_charge_info = cls._get_gateway_fee( message_log.backend_api, message_log.backend_id, phone_number, direction, log_id, message_log.backend_message_id ) billable.gateway_fee = gateway_charge_info.gateway_fee billable.gateway_fee_conversion_rate = gateway_charge_info.conversion_rate billable.direct_gateway_fee = gateway_charge_info.direct_gateway_fee billable.multipart_count = cls._get_multipart_count( message_log.backend_api, message_log.backend_id, message_log.backend_message_id, multipart_count ) billable.usage_fee = cls._get_usage_fee(domain, direction) if message_log.backend_api == SQLTestSMSBackend.get_api_id(): billable.is_valid = False billable.save() return billable
def test_load(self): backend = SQLTestSMSBackend.objects.create( name='BACKEND', is_global=True, hq_api_id=SQLTestSMSBackend.get_api_id(), ) self.assertBackendsEqual( SQLMobileBackend.load(backend.pk), backend ) self.assertBackendsEqual( SQLMobileBackend.load(backend.pk, api_id=SQLTestSMSBackend.get_api_id()), backend ) self.assertBackendsEqual( SQLMobileBackend.load(backend.couch_id, is_couch_id=True), backend ) self.assertBackendsEqual( SQLMobileBackend.load( backend.couch_id, api_id=SQLTestSMSBackend.get_api_id(), is_couch_id=True ), backend ) backend.soft_delete() with self.assertRaises(SQLMobileBackend.DoesNotExist): SQLMobileBackend.load(backend.pk, api_id=SQLTestSMSBackend.get_api_id()) with self.assertRaises(SQLMobileBackend.DoesNotExist): SQLMobileBackend.load( backend.couch_id, api_id=SQLTestSMSBackend.get_api_id(), is_couch_id=True ) with self.assertRaises(BadSMSConfigException): SQLMobileBackend.load(backend.pk, api_id='this-api-id-does-not-exist') backend.delete()
def create(cls, message_log, api_response=None): phone_number = clean_phone_number(message_log.phone_number) direction = message_log.direction billable = cls( log_id=message_log._id, phone_number=phone_number, direction=direction, date_sent=message_log.date, domain=message_log.domain, ) # Fetch gateway_fee backend_api_id = message_log.backend_api backend_instance = message_log.backend_id country_code, national_number = get_country_code_and_national_number(phone_number) if backend_instance is None or _sms_backend_is_global(backend_instance): billable.gateway_fee = SmsGatewayFee.get_by_criteria( backend_api_id, direction, backend_instance=backend_instance, country_code=country_code, national_number=national_number, ) if billable.gateway_fee is not None: conversion_rate = billable.gateway_fee.currency.rate_to_default if conversion_rate != 0: billable.gateway_fee_conversion_rate = conversion_rate else: smsbillables_logging.error( "Gateway fee conversion rate for currency %s is 0", billable.gateway_fee.currency.code ) else: smsbillables_logging.error("No matching gateway fee criteria for SMSLog %s" % message_log._id) # Fetch usage_fee todo domain = message_log.domain billable.usage_fee = SmsUsageFee.get_by_criteria(direction, domain=domain) if billable.usage_fee is None: smsbillables_logging.error("Did not find usage fee for direction %s and domain %s" % (direction, domain)) if api_response is not None: billable.api_response = api_response if backend_api_id == SQLTestSMSBackend.get_api_id(): billable.is_valid = False billable.save() return billable
def setup_default_sms_test_backend(): backend = SQLTestSMSBackend.objects.create( name='MOBILE_BACKEND_TEST', is_global=True, hq_api_id=SQLTestSMSBackend.get_api_id()) backend_mapping = SQLMobileBackendMapping.objects.create( is_global=True, backend_type=SQLMobileBackend.SMS, prefix='*', backend=backend, ) return (backend, backend_mapping)
def setup_default_sms_test_backend(): backend = SQLTestSMSBackend.objects.create( name='MOBILE_BACKEND_TEST', is_global=True, hq_api_id=SQLTestSMSBackend.get_api_id() ) backend_mapping = SQLMobileBackendMapping.objects.create( is_global=True, backend_type=SQLMobileBackend.SMS, prefix='*', backend=backend, ) return (backend, backend_mapping)
def bootstrap_test_gateway(apps): default_currency, _ = (apps.get_model('accounting', 'Currency') if apps else Currency).objects.get_or_create(code=settings.DEFAULT_CURRENCY) sms_gateway_fee_class = apps.get_model('smsbillables', 'SmsGatewayFee') if apps else SmsGatewayFee sms_gateway_fee_criteria_class = apps.get_model('smsbillables', 'SmsGatewayFeeCriteria') if apps else SmsGatewayFeeCriteria SmsGatewayFee.create_new( SQLTestSMSBackend.get_api_id(), INCOMING, Decimal('0.0'), currency=default_currency, fee_class=sms_gateway_fee_class, criteria_class=sms_gateway_fee_criteria_class, ) SmsGatewayFee.create_new( SQLTestSMSBackend.get_api_id(), OUTGOING, Decimal('0.0'), currency=default_currency, fee_class=sms_gateway_fee_class, criteria_class=sms_gateway_fee_criteria_class, ) logger.info("Updated Test gateway fees.")
def test_domain_is_shared(self): backend = SQLTestSMSBackend.objects.create( name='BACKEND', domain='shared-test-1', is_global=False, hq_api_id=SQLTestSMSBackend.get_api_id(), ) self.assertFalse(backend.domain_is_shared('shared-test-2')) backend.set_shared_domains(['shared-test-2']) self.assertTrue(backend.domain_is_shared('shared-test-2')) backend.soft_delete() self.assertFalse(backend.domain_is_shared('shared-test-2')) backend.delete()
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 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 setUpClass(cls): super(OptTestCase, cls).setUpClass() cls.domain = 'opt-test' cls.domain_obj = Domain(name=cls.domain) cls.domain_obj.sms_case_registration_enabled = True cls.domain_obj.save() cls.setup_subscription(cls.domain, SoftwarePlanEdition.ADVANCED) cls.backend, cls.backend_mapping = setup_default_sms_test_backend() cls.custom_backend = SQLTestSMSBackend.objects.create( name='MOBILE_BACKEND_CUSTOM_TEST', is_global=True, hq_api_id=SQLTestSMSBackend.get_api_id(), opt_in_keywords=['RESTART'], opt_out_keywords=['RESTOP']) cls.custom_backend_mapping = SQLMobileBackendMapping.objects.create( is_global=True, backend_type=SQLMobileBackend.SMS, prefix='1', backend=cls.custom_backend, )
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()
class AllBackendTest(BaseSMSTest): def setUp(self): super(AllBackendTest, self).setUp() 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 = SQLUnicelBackend( name='UNICEL', is_global=True, hq_api_id=SQLUnicelBackend.get_api_id() ) self.unicel_backend.save() self.mach_backend = SQLMachBackend( name='MACH', is_global=True, hq_api_id=SQLMachBackend.get_api_id() ) self.mach_backend.save() self.tropo_backend = SQLTropoBackend( name='TROPO', is_global=True, hq_api_id=SQLTropoBackend.get_api_id() ) self.tropo_backend.save() self.http_backend = SQLHttpBackend( name='HTTP', is_global=True, hq_api_id=SQLHttpBackend.get_api_id() ) self.http_backend.save() self.telerivet_backend = SQLTelerivetBackend( name='TELERIVET', is_global=True, hq_api_id=SQLTelerivetBackend.get_api_id() ) self.telerivet_backend.set_extra_fields( **dict( webhook_secret='telerivet-webhook-secret' ) ) self.telerivet_backend.save() self.test_backend = SQLTestSMSBackend( name='TEST', is_global=True, hq_api_id=SQLTestSMSBackend.get_api_id() ) self.test_backend.save() self.grapevine_backend = SQLGrapevineBackend( name='GRAPEVINE', is_global=True, hq_api_id=SQLGrapevineBackend.get_api_id() ) self.grapevine_backend.save() self.twilio_backend = SQLTwilioBackend( name='TWILIO', is_global=True, hq_api_id=SQLTwilioBackend.get_api_id() ) self.twilio_backend.save() self.megamobile_backend = SQLMegamobileBackend( name='MEGAMOBILE', is_global=True, hq_api_id=SQLMegamobileBackend.get_api_id() ) self.megamobile_backend.save() self.smsgh_backend = SQLSMSGHBackend( name='SMSGH', is_global=True, hq_api_id=SQLSMSGHBackend.get_api_id() ) self.smsgh_backend.save() self.apposit_backend = SQLAppositBackend( name='APPOSIT', is_global=True, hq_api_id=SQLAppositBackend.get_api_id() ) self.apposit_backend.save() self.sislog_backend = SQLSislogBackend( name='SISLOG', is_global=True, hq_api_id=SQLSislogBackend.get_api_id() ) self.sislog_backend.save() self.yo_backend = SQLYoBackend( name='YO', is_global=True, hq_api_id=SQLYoBackend.get_api_id() ) self.yo_backend.save() 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 _verify_inbound_request(self, backend_api_id, msg_text, backend_couch_id=None): sms = SMS.objects.get( domain=self.domain_obj.name, direction='I', text=msg_text ) self.assertEqual(sms.backend_api, backend_api_id) if backend_couch_id: self.assertEqual(sms.backend_id, backend_couch_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, expected_response_code=200): 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, expected_response_code) @patch('corehq.messaging.smsbackends.unicel.models.SQLUnicelBackend.send') @patch('corehq.messaging.smsbackends.mach.models.SQLMachBackend.send') @patch('corehq.messaging.smsbackends.tropo.models.SQLTropoBackend.send') @patch('corehq.messaging.smsbackends.http.models.SQLHttpBackend.send') @patch('corehq.messaging.smsbackends.telerivet.models.SQLTelerivetBackend.send') @patch('corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send') @patch('corehq.messaging.smsbackends.grapevine.models.SQLGrapevineBackend.send') @patch('corehq.messaging.smsbackends.twilio.models.SQLTwilioBackend.send') @patch('corehq.messaging.smsbackends.megamobile.models.SQLMegamobileBackend.send') @patch('corehq.messaging.smsbackends.smsgh.models.SQLSMSGHBackend.send') @patch('corehq.messaging.smsbackends.apposit.models.SQLAppositBackend.send') @patch('corehq.messaging.smsbackends.sislog.models.SQLSislogBackend.send') @patch('corehq.messaging.smsbackends.yo.models.SQLYoBackend.send') def test_outbound_sms( self, yo_send, sislog_send, 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) self._test_outbound_backend(self.sislog_backend, 'sislog test', sislog_send) self._test_outbound_backend(self.yo_backend, 'yo test', yo_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.config.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): url = '/twilio/sms/%s' % self.twilio_backend.inbound_api_key self._simulate_inbound_request(url, phone_param='From', msg_param='Body', msg_text='twilio test', post=True) self._verify_inbound_request(self.twilio_backend.get_api_id(), 'twilio test', backend_couch_id=self.twilio_backend.couch_id) def test_twilio_401_response(self): start_count = SMS.objects.count() self._simulate_inbound_request('/twilio/sms/xxxxx', phone_param='From', msg_param='Body', msg_text='twilio test', post=True, expected_response_code=401) end_count = SMS.objects.count() self.assertEqual(start_count, end_count) 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(self.sislog_backend.get_api_id(), '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(self.yo_backend.get_api_id(), '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): delete_domain_phone_numbers(self.domain_obj.name) self.contact1.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() self.sislog_backend.delete() self.yo_backend.delete() super(AllBackendTest, self).tearDown()
def setUp(self): super(AllBackendTest, self).setUp() 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 = SQLUnicelBackend( name='UNICEL', is_global=True, hq_api_id=SQLUnicelBackend.get_api_id() ) self.unicel_backend.save() self.mach_backend = SQLMachBackend( name='MACH', is_global=True, hq_api_id=SQLMachBackend.get_api_id() ) self.mach_backend.save() self.tropo_backend = SQLTropoBackend( name='TROPO', is_global=True, hq_api_id=SQLTropoBackend.get_api_id() ) self.tropo_backend.save() self.http_backend = SQLHttpBackend( name='HTTP', is_global=True, hq_api_id=SQLHttpBackend.get_api_id() ) self.http_backend.save() self.telerivet_backend = SQLTelerivetBackend( name='TELERIVET', is_global=True, hq_api_id=SQLTelerivetBackend.get_api_id() ) self.telerivet_backend.set_extra_fields( **dict( webhook_secret='telerivet-webhook-secret' ) ) self.telerivet_backend.save() self.test_backend = SQLTestSMSBackend( name='TEST', is_global=True, hq_api_id=SQLTestSMSBackend.get_api_id() ) self.test_backend.save() self.grapevine_backend = SQLGrapevineBackend( name='GRAPEVINE', is_global=True, hq_api_id=SQLGrapevineBackend.get_api_id() ) self.grapevine_backend.save() self.twilio_backend = SQLTwilioBackend( name='TWILIO', is_global=True, hq_api_id=SQLTwilioBackend.get_api_id() ) self.twilio_backend.save() self.megamobile_backend = SQLMegamobileBackend( name='MEGAMOBILE', is_global=True, hq_api_id=SQLMegamobileBackend.get_api_id() ) self.megamobile_backend.save() self.smsgh_backend = SQLSMSGHBackend( name='SMSGH', is_global=True, hq_api_id=SQLSMSGHBackend.get_api_id() ) self.smsgh_backend.save() self.apposit_backend = SQLAppositBackend( name='APPOSIT', is_global=True, hq_api_id=SQLAppositBackend.get_api_id() ) self.apposit_backend.save() self.sislog_backend = SQLSislogBackend( name='SISLOG', is_global=True, hq_api_id=SQLSislogBackend.get_api_id() ) self.sislog_backend.save() self.yo_backend = SQLYoBackend( name='YO', is_global=True, hq_api_id=SQLYoBackend.get_api_id() ) self.yo_backend.save()
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 setUpTestData(cls): cls.domain1_name = uuid.uuid4().hex cls.domain2_name = uuid.uuid4().hex cls.global_backend = SQLTestSMSBackend.objects.create( hq_api_id=SQLTestSMSBackend.get_api_id(), is_global=True, name='GLOBAL') cls.domain1_backend = SQLTestSMSBackend.objects.create( hq_api_id=SQLTestSMSBackend.get_api_id(), is_global=False, domain=cls.domain1_name, name='BACKEND1') MobileBackendInvitation.objects.create(domain=cls.domain2_name, backend=cls.domain1_backend, accepted=True) cls.domain2_backend = SQLTestSMSBackend.objects.create( hq_api_id=SQLTestSMSBackend.get_api_id(), is_global=False, domain=cls.domain2_name, name='BACKEND2') cls.phone_number = '01112223333' cls.number1_domain1 = PhoneNumber.objects.create( domain=cls.domain1_name, owner_doc_type='CommCareCase', owner_id='fake-owner-1', phone_number=cls.phone_number, verified=True, is_two_way=True, pending_verification=False) cls.number2_domain1 = PhoneNumber.objects.create( domain=cls.domain1_name, owner_doc_type='CommCareCase', owner_id='fake-owner-2', phone_number=cls.phone_number, verified=True, is_two_way=False, pending_verification=False) cls.number3_domain2 = PhoneNumber.objects.create( domain=cls.domain2_name, owner_doc_type='CommCareCase', owner_id='fake-owner-3', phone_number=cls.phone_number, verified=True, is_two_way=False, pending_verification=False) cls.number4_domain2 = PhoneNumber.objects.create( domain=cls.domain2_name, owner_doc_type='CommCareCase', owner_id='fake-owner-4', phone_number=cls.phone_number, verified=True, is_two_way=False, pending_verification=False) for number in [ cls.number1_domain1, cls.number2_domain1, cls.number3_domain2 ]: number._clear_caches() SQLMobileBackend.load.clear(SQLMobileBackend, cls.global_backend.couch_id, is_couch_id=True) SQLMobileBackend.load.clear(SQLMobileBackend, cls.domain1_backend.couch_id, is_couch_id=True) SQLMobileBackend.load.clear(SQLMobileBackend, cls.domain2_backend.couch_id, is_couch_id=True)
def test_load_by_name(self): backend1 = SQLTestSMSBackend.objects.create( name='BACKEND_BY_NAME_TEST', is_global=False, domain='backend-by-name-test-1', hq_api_id=SQLTestSMSBackend.get_api_id(), ) backend2 = SQLTestSMSBackend.objects.create( name='BACKEND_BY_NAME_TEST', is_global=False, domain='backend-by-name-test-2', hq_api_id=SQLTestSMSBackend.get_api_id(), ) backend2.set_shared_domains(['backend-by-name-test-1']) backend3 = SQLTestSMSBackend.objects.create( name='BACKEND_BY_NAME_TEST', is_global=True, hq_api_id=SQLTestSMSBackend.get_api_id(), ) self.assertBackendsEqual( SQLMobileBackend.load_by_name( SQLMobileBackend.SMS, 'backend-by-name-test-1', 'BACKEND_BY_NAME_TEST' ), backend1 ) self.assertBackendsEqual( SQLMobileBackend.load_by_name( SQLMobileBackend.SMS, 'backend-by-name-test-3', 'BACKEND_BY_NAME_TEST' ), backend3 ) backend1.soft_delete() self.assertBackendsEqual( SQLMobileBackend.load_by_name( SQLMobileBackend.SMS, 'backend-by-name-test-1', 'BACKEND_BY_NAME_TEST' ), backend2 ) backend2.set_shared_domains([]) self.assertBackendsEqual( SQLMobileBackend.load_by_name( SQLMobileBackend.SMS, 'backend-by-name-test-1', 'BACKEND_BY_NAME_TEST' ), backend3 ) self.assertBackendsEqual( SQLMobileBackend.load_by_name( SQLMobileBackend.SMS, 'backend-by-name-test-2', 'BACKEND_BY_NAME_TEST' ), backend2 ) backend2.soft_delete() self.assertBackendsEqual( SQLMobileBackend.load_by_name( SQLMobileBackend.SMS, 'backend-by-name-test-2', 'BACKEND_BY_NAME_TEST' ), backend3 ) backend3.soft_delete() with self.assertRaises(BadSMSConfigException): SQLMobileBackend.load_by_name( SQLMobileBackend.SMS, 'backend-by-name-test-1', 'BACKEND_BY_NAME_TEST' ) backend1.delete() backend2.delete() backend3.delete()
def test_load_default_by_phone_and_domain(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=False, domain='load-default-test', hq_api_id=SQLTestSMSBackend.get_api_id(), ) backend4 = SQLTestSMSBackend.objects.create( name='BACKEND4', is_global=False, domain='load-default-test', hq_api_id=SQLTestSMSBackend.get_api_id(), ) SQLMobileBackendMapping.objects.create( is_global=True, backend_type=SQLMobileBackend.SMS, prefix='*', backend=backend1 ) SQLMobileBackendMapping.objects.create( is_global=True, backend_type=SQLMobileBackend.SMS, prefix='27', backend=backend2 ) SQLMobileBackendMapping.objects.create( is_global=False, domain='load-default-test', backend_type=SQLMobileBackend.SMS, prefix='*', backend=backend3 ) SQLMobileBackendMapping.objects.create( is_global=False, domain='load-default-test', backend_type=SQLMobileBackend.SMS, prefix='27', backend=backend4 ) # Test global prefix map self.assertBackendsEqual( SQLMobileBackend.load_default_by_phone_and_domain( SQLMobileBackend.SMS, '2700000000', domain='load-default-test-2' ), backend2 ) # Test domain-level prefix map self.assertBackendsEqual( SQLMobileBackend.load_default_by_phone_and_domain( SQLMobileBackend.SMS, '2700000000', domain='load-default-test' ), backend4 ) # Test domain catch-all backend4.soft_delete() self.assertBackendsEqual( SQLMobileBackend.load_default_by_phone_and_domain( SQLMobileBackend.SMS, '2700000000', domain='load-default-test' ), backend3 ) # Test global prefix map backend3.soft_delete() self.assertBackendsEqual( SQLMobileBackend.load_default_by_phone_and_domain( SQLMobileBackend.SMS, '2700000000', domain='load-default-test' ), backend2 ) # Test global catch-all backend2.soft_delete() self.assertBackendsEqual( SQLMobileBackend.load_default_by_phone_and_domain( SQLMobileBackend.SMS, '2700000000', domain='load-default-test' ), backend1 ) # Test raising exception if nothing found backend1.soft_delete() with self.assertRaises(BadSMSConfigException): SQLMobileBackend.load_default_by_phone_and_domain( SQLMobileBackend.SMS, '2700000000', domain='load-default-test' ) backend1.delete() backend2.delete() backend3.delete() backend4.delete()