class BaseReminderTestCase(BaseAccountingTest): def setUp(self): super(BaseReminderTestCase, self).setUp() self.domain_obj = Domain(name="test") self.domain_obj.save() # Prevent resource conflict self.domain_obj = Domain.get(self.domain_obj._id) self.account, _ = BillingAccount.get_or_create_account_by_domain( self.domain_obj.name, created_by="tests" ) advanced_plan_version = DefaultProductPlan.get_default_plan_by_domain( self.domain_obj, edition=SoftwarePlanEdition.ADVANCED) self.subscription = Subscription.new_domain_subscription( self.account, self.domain_obj.name, advanced_plan_version ) self.subscription.is_active = True self.subscription.save() self.sms_backend = TestSMSBackend(named="MOBILE_BACKEND_TEST", is_global=True) self.sms_backend.save() self.sms_backend_mapping = BackendMapping(is_global=True,prefix="*",backend_id=self.sms_backend._id) self.sms_backend_mapping.save() def tearDown(self): self.sms_backend_mapping.delete() self.sms_backend.delete() SubscriptionAdjustment.objects.all().delete() self.subscription.delete() self.account.delete() self.domain_obj.delete()
def setUp(self): super(OptTestCase, self).setUp() self.domain = "opt-test" 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.backend = TestSMSBackend(is_global=True) self.backend.save() self.backend_mapping = BackendMapping( is_global=True, prefix="*", backend_id=self.backend._id, ) self.backend_mapping.save()
def setUp(self): super(OptTestCase, self).setUp() self.domain = "opt-test" 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.backend = TestSMSBackend(is_global=True) self.backend.save() self.backend_mapping = BackendMapping( is_global=True, prefix="*", backend_id=self.backend._id, ) self.backend_mapping.save()
def setUp(self): self.datapath = os.path.join(os.path.dirname(__file__), 'data') initial_bootstrap(TEST_DOMAIN) sms_backend = TestSMSBackend(name="MOBILE_BACKEND_TEST", is_global=True) sms_backend._id = sms_backend.name sms_backend.save() config = ILSGatewayConfig() config.domain = TEST_DOMAIN config.enabled = True config.password = '******' config.username = '******' config.url = 'http://test-api.com/' config.save() for product in Product.by_domain(TEST_DOMAIN): product.delete()
class BaseReminderTestCase(TestCase): def setUp(self): self.domain_obj = Domain(name="test") self.domain_obj.save() # Prevent resource conflict self.domain_obj = Domain.get(self.domain_obj._id) self.sms_backend = TestSMSBackend(named="MOBILE_BACKEND_TEST", is_global=True) self.sms_backend.save() self.sms_backend_mapping = BackendMapping(is_global=True,prefix="*",backend_id=self.sms_backend._id) self.sms_backend_mapping.save() def tearDown(self): self.sms_backend_mapping.delete() self.sms_backend.delete() self.domain_obj.delete()
class OptTestCase(TestCase): def setUp(self): self.domain = "opt-test" self.domain_obj = Domain(name=self.domain) self.domain_obj.save() self.backend = TestSMSBackend(is_global=True) self.backend.save() self.backend_mapping = BackendMapping( is_global=True, prefix="*", backend_id=self.backend._id, ) self.backend_mapping.save() def test_opt_out_and_opt_in(self): self.assertEqual(PhoneNumber.objects.count(), 0) incoming("99912345678", "stop", "GVI") self.assertEqual(PhoneNumber.objects.count(), 1) phone_number = PhoneNumber.objects.get(phone_number="99912345678") self.assertFalse(phone_number.send_sms) incoming("99912345678", "start", "GVI") self.assertEqual(PhoneNumber.objects.count(), 1) phone_number = PhoneNumber.objects.get(phone_number="99912345678") self.assertTrue(phone_number.send_sms) def test_sending_to_opted_out_number(self): self.assertEqual(PhoneNumber.objects.count(), 0) self.assertTrue(send_sms(self.domain, None, "999123456789", "hello")) incoming("999123456789", "stop", "GVI") self.assertEqual(PhoneNumber.objects.count(), 1) phone_number = PhoneNumber.objects.get(phone_number="999123456789") self.assertFalse(phone_number.send_sms) self.assertFalse(send_sms(self.domain, None, "999123456789", "hello")) def tearDown(self): self.backend_mapping.delete() self.backend.delete() self.domain_obj.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 == TestSMSBackend.get_api_id(): billable.is_valid = False billable.save() return billable
def setUp(self): self.domain = "opt-test" self.domain_obj = Domain(name=self.domain) self.domain_obj.save() self.backend = TestSMSBackend(is_global=True) self.backend.save() self.backend_mapping = BackendMapping( is_global=True, prefix="*", backend_id=self.backend._id, ) self.backend_mapping.save()
def bootstrap_test_gateway(orm): default_currency = (orm['accounting.Currency'] if orm else Currency).get_default() sms_gateway_fee_class = orm['smsbillables.SmsGatewayFee'] if orm else SmsGatewayFee sms_gateway_fee_criteria_class = orm['smsbillables.SmsGatewayFeeCriteria'] if orm else SmsGatewayFeeCriteria SmsGatewayFee.create_new( TestSMSBackend.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( TestSMSBackend.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 setUp(self): self.users = [] self.apps = [] self.keywords = [] self.groups = [] self.site = self.create_site() self.domain = "test-domain" self.domain_obj = self.create_domain(self.domain) self.create_web_user("touchforms_user", "123") self.backend = TestSMSBackend(name="TEST", is_global=True) self.backend.save() self.backend_mapping = BackendMapping(is_global=True, prefix="*", backend_id=self.backend._id) self.backend_mapping.save() settings.DEBUG = True
class TouchformsTestCase(LiveServerTestCase): """ For now, these test cases need to be run manually. Before running, the following dependencies must be met: 1. touchforms/backend/localsettings.py: URL_ROOT = "http://localhost:8081/a/{{DOMAIN}}" 2. Django localsettings.py: TOUCHFORMS_API_USER = "******" TOUCHFORMS_API_PASSWORD = "******" 3. Start touchforms """ users = None apps = None keywords = None groups = None def create_domain(self, domain): domain_obj = Domain(name=domain) domain_obj.use_default_sms_response = True domain_obj.default_sms_response = "Default SMS Response" domain_obj.save() generator.instantiate_accounting_for_tests() self.account = BillingAccount.get_or_create_account_by_domain( domain_obj.name, created_by="automated-test", )[0] plan = DefaultProductPlan.get_default_plan_by_domain( domain_obj, edition=SoftwarePlanEdition.ADVANCED ) self.subscription = Subscription.new_domain_subscription( self.account, domain_obj.name, plan ) self.subscription.is_active = True self.subscription.save() return domain_obj def create_mobile_worker(self, username, password, phone_number, save_vn=True): user = CommCareUser.create(self.domain, username, password, phone_number=phone_number) if save_vn: user.save_verified_number(self.domain, phone_number, True, None) self.users.append(user) return user def update_case_owner(self, case, owner): case_block = CaseBlock( create=False, case_id=case._id, case_type='participant', owner_id=owner._id, user_id=owner._id, version=V2 ).as_xml(format_datetime=json_format_datetime) post_case_blocks([case_block], {'domain': self.domain}) def add_parent_access(self, user, case): case_block = CaseBlock( create=True, case_id=uuid.uuid4().hex, case_type='magic_map', owner_id=user._id, version=V2, index={'parent': ('participant', case._id)} ).as_xml(format_datetime=json_format_datetime) post_case_blocks([case_block], {'domain': self.domain}) def create_web_user(self, username, password): user = WebUser.create(self.domain, username, password) self.users.append(user) return user def create_group(self, name, users): group = Group( domain=self.domain, name=name, users=[user._id for user in users], case_sharing=True, ) group.save() self.groups.append(group) return group def load_app(self, filename, dirname=None): dirname = dirname or os.path.dirname(os.path.abspath(__file__)) full_filename = "%s/%s" % (dirname, filename) with open(full_filename, "r") as f: app_source = f.read() app_source = json.loads(app_source) app = import_app(app_source, self.domain) self.apps.append(app) return app def create_sms_keyword(self, keyword, reply_sms, override_open_sessions=True, initiator_filter=None, recipient=RECIPIENT_SENDER, recipient_id=None): sk = SurveyKeyword( domain=self.domain, keyword=keyword, description=keyword, actions=[SurveyKeywordAction( recipient=recipient, recipient_id=recipient_id, action=METHOD_SMS, message_content=reply_sms, form_unique_id=None, use_named_args=False, named_args={}, named_args_separator=None, )], delimiter=None, override_open_sessions=override_open_sessions, initiator_doc_type_filter=initiator_filter or [], ) sk.save() self.keywords.append(sk) return sk def create_survey_keyword(self, keyword, form_unique_id, delimiter=None, override_open_sessions=True, initiator_filter=None): sk = SurveyKeyword( domain=self.domain, keyword=keyword, description=keyword, actions=[SurveyKeywordAction( recipient=RECIPIENT_SENDER, recipient_id=None, action=METHOD_SMS_SURVEY, message_content=None, form_unique_id=form_unique_id, use_named_args=False, named_args={}, named_args_separator=None, )], delimiter=delimiter, override_open_sessions=override_open_sessions, initiator_doc_type_filter=initiator_filter or [], ) sk.save() self.keywords.append(sk) return sk def create_structured_sms_keyword(self, keyword, form_unique_id, reply_sms, delimiter=None, named_args=None, named_args_separator=None, override_open_sessions=True, initiator_filter=None): sk = SurveyKeyword( domain=self.domain, keyword=keyword, description=keyword, actions=[ SurveyKeywordAction( recipient=RECIPIENT_SENDER, recipient_id=None, action=METHOD_SMS, message_content=reply_sms, form_unique_id=None, use_named_args=False, named_args={}, named_args_separator=None, ), SurveyKeywordAction( recipient=RECIPIENT_SENDER, recipient_id=None, action=METHOD_STRUCTURED_SMS, message_content=None, form_unique_id=form_unique_id, use_named_args=(named_args is not None), named_args=(named_args or {}), named_args_separator=named_args_separator, ) ], delimiter=delimiter, override_open_sessions=override_open_sessions, initiator_doc_type_filter=initiator_filter or [], ) sk.save() self.keywords.append(sk) return sk def create_site(self): site = Site(id=settings.SITE_ID, domain=self.live_server_url, name=self.live_server_url) site.save() return site def get_case(self, external_id): return get_one_case_in_domain_by_external_id(self.domain, external_id) def assertCasePropertyEquals(self, case, prop, value): self.assertEquals(case.get_case_property(prop), value) def get_last_form_submission(self): result = get_forms_by_type(self.domain, 'XFormInstance', recent_first=True, limit=1) return result[0] if len(result) > 0 else None def assertNoNewSubmission(self, last_submission): new_submission = self.get_last_form_submission() self.assertEquals(last_submission._id, new_submission._id) def assertFormQuestionEquals(self, form, question, value, cast=None): self.assertIn(question, form.form) form_value = form.form[question] if cast: form_value = cast(form_value) self.assertEquals(form_value, value) def get_last_outbound_sms(self, contact): # Not clear why this should be necessary, but without it the latest # sms may not be returned sleep(0.25) sms = SMSLog.view("sms/by_recipient", startkey=[contact.doc_type, contact._id, "SMSLog", "O", {}], endkey=[contact.doc_type, contact._id, "SMSLog", "O"], descending=True, include_docs=True, reduce=False, ).first() return sms def get_last_outbound_call(self, contact): # Not clear why this should be necessary, but without it the latest # call may not be returned sleep(0.25) call = CallLog.view("sms/by_recipient", startkey=[contact.doc_type, contact._id, "CallLog", "O", {}], endkey=[contact.doc_type, contact._id, "CallLog", "O"], descending=True, include_docs=True, reduce=False, ).first() return call def get_open_session(self, contact): return SQLXFormsSession.get_open_sms_session(self.domain, contact._id) def assertLastOutboundSMSEquals(self, contact, message): sms = self.get_last_outbound_sms(contact) self.assertIsNotNone(sms) self.assertEqual(sms.text, message) return sms def assertMetadataEqual(self, sms, xforms_session_couch_id=None, workflow=None): if xforms_session_couch_id: self.assertEqual(sms.xforms_session_couch_id, xforms_session_couch_id) if workflow: self.assertEqual(sms.workflow, workflow) def setUp(self): self.users = [] self.apps = [] self.keywords = [] self.groups = [] self.site = self.create_site() self.domain = "test-domain" self.domain_obj = self.create_domain(self.domain) self.create_web_user("touchforms_user", "123") self.backend = TestSMSBackend(name="TEST", is_global=True) self.backend.save() self.backend_mapping = BackendMapping(is_global=True, prefix="*", backend_id=self.backend._id) self.backend_mapping.save() settings.DEBUG = True def tearDown(self): for user in self.users: user.delete_verified_number() user.delete() for app in self.apps: app.delete() for keyword in self.keywords: keyword.delete() for group in self.groups: group.delete() self.domain_obj.delete() self.site.delete() self.backend.delete() self.backend_mapping.delete() SubscriptionAdjustment.objects.all().delete() self.subscription.delete() self.account.delete()
class OptTestCase(BaseAccountingTest): def setUp(self): super(OptTestCase, self).setUp() self.domain = "opt-test" 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.backend = TestSMSBackend(is_global=True) self.backend.save() self.backend_mapping = BackendMapping( is_global=True, prefix="*", backend_id=self.backend._id, ) self.backend_mapping.save() def test_opt_out_and_opt_in(self): self.assertEqual(PhoneNumber.objects.count(), 0) incoming("99912345678", "stop", "GVI") self.assertEqual(PhoneNumber.objects.count(), 1) phone_number = PhoneNumber.objects.get(phone_number="99912345678") self.assertFalse(phone_number.send_sms) incoming("99912345678", "start", "GVI") self.assertEqual(PhoneNumber.objects.count(), 1) phone_number = PhoneNumber.objects.get(phone_number="99912345678") self.assertTrue(phone_number.send_sms) def test_sending_to_opted_out_number(self): self.assertEqual(PhoneNumber.objects.count(), 0) self.assertTrue(send_sms(self.domain, None, "999123456789", "hello")) incoming("999123456789", "stop", "GVI") self.assertEqual(PhoneNumber.objects.count(), 1) phone_number = PhoneNumber.objects.get(phone_number="999123456789") self.assertFalse(phone_number.send_sms) self.assertFalse(send_sms(self.domain, None, "999123456789", "hello")) def tearDown(self): self.backend_mapping.delete() self.backend.delete() self.domain_obj.delete() SubscriptionAdjustment.objects.all().delete() self.subscription.delete() self.account.delete()
def handle(self, *args, **options): backends = MobileBackend.view("sms/old_mobile_backend", include_docs=True).all() for backend in backends: print "Processing backend %s" % backend._id if backend._id == "MOBILE_BACKEND_UNICEL": backend = UnicelBackend.wrap(backend.to_json()) backend.doc_type = "UnicelBackend" backend.domain = None backend.name = backend._id backend.authorized_domains = [] backend.is_global = True backend.username = settings.UNICEL_CONFIG.get("username") backend.password = settings.UNICEL_CONFIG.get("password") backend.sender = settings.UNICEL_CONFIG.get("sender") backend.reply_to_phone_number = settings.UNICEL_CONFIG.get("receive_phone", None) backend.outbound_module = None backend.outbound_params = None backend.save() elif backend._id == "MOBILE_BACKEND_MACH": backend = MachBackend.wrap(backend.to_json()) backend.doc_type = "MachBackend" backend.domain = None backend.name = backend._id backend.authorized_domains = [] backend.is_global = True backend.account_id = re.match(r".*id=(.+?)&", settings.SMS_GATEWAY_PARAMS).group(1) backend.password = re.match(r".*pw=(.+?)&", settings.SMS_GATEWAY_PARAMS).group(1) backend.sender_id = "DIMAGI" backend.outbound_module = None backend.outbound_params = None backend.save() elif backend.outbound_module == "corehq.apps.tropo.api": backend = TropoBackend.wrap(backend.to_json()) backend.doc_type = "TropoBackend" backend.domain = None backend.name = backend._id backend.authorized_domains = [] backend.is_global = True backend.messaging_token = backend.outbound_params.get("messaging_token") backend.outbound_module = None backend.outbound_params = None backend.save() elif backend.outbound_module == "corehq.apps.sms.backend.http_api": print "REMINDER: Need to set global / domain for backend %s" % backend._id backend = HttpBackend.wrap(backend.to_json()) backend.doc_type = "HttpBackend" backend.domain = None backend.name = backend._id backend.authorized_domains = [] backend.is_global = False backend.url = backend.outbound_params.get("url") backend.message_param = backend.outbound_params.get("message_param") backend.number_param = backend.outbound_params.get("number_param") backend.include_plus = backend.outbound_params.get("include_plus", False) backend.method = backend.outbound_params.get("method", "GET") backend.additional_params = backend.outbound_params.get("additional_params", {}) backend.outbound_module = None backend.outbound_params = None backend.save() elif backend.outbound_module == "corehq.apps.sms.test_backend": backend = TestSMSBackend.wrap(backend.to_json()) backend.doc_type = "TestSMSBackend" backend.domain = None backend.name = backend._id backend.authorized_domains = [] backend.is_global = True backend.outbound_module = None backend.outbound_params = None backend.save()
class Command(BaseCommand): args = "" help = "Migrate backends to support backend refactor." # Migrate all backends def handle(self, *args, **options): backends = MobileBackend.view("sms/old_mobile_backend", include_docs=True).all() for backend in backends: print "Processing backend %s" % backend._id if backend._id == "MOBILE_BACKEND_UNICEL": backend = UnicelBackend.wrap(backend.to_json()) backend.doc_type = "UnicelBackend" backend.domain = None backend.name = backend._id backend.authorized_domains = [] backend.is_global = True backend.username = settings.UNICEL_CONFIG.get("username") backend.password = settings.UNICEL_CONFIG.get("password") backend.sender = settings.UNICEL_CONFIG.get("sender") backend.reply_to_phone_number = settings.UNICEL_CONFIG.get("receive_phone", None) backend.outbound_module = None backend.outbound_params = None backend.save() elif backend._id == "MOBILE_BACKEND_MACH": backend = MachBackend.wrap(backend.to_json()) backend.doc_type = "MachBackend" backend.domain = None backend.name = backend._id backend.authorized_domains = [] backend.is_global = True backend.account_id = re.match(r".*id=(.+?)&", settings.SMS_GATEWAY_PARAMS).group(1) backend.password = re.match(r".*pw=(.+?)&", settings.SMS_GATEWAY_PARAMS).group(1) backend.sender_id = "DIMAGI" backend.outbound_module = None backend.outbound_params = None backend.save() elif backend.outbound_module == "corehq.apps.tropo.api": backend = TropoBackend.wrap(backend.to_json()) backend.doc_type = "TropoBackend" backend.domain = None backend.name = backend._id backend.authorized_domains = [] backend.is_global = True backend.messaging_token = backend.outbound_params.get("messaging_token") backend.outbound_module = None backend.outbound_params = None backend.save() elif backend.outbound_module == "corehq.apps.sms.backend.http_api": print "REMINDER: Need to set global / domain for backend %s" % backend._id backend = HttpBackend.wrap(backend.to_json()) backend.doc_type = "HttpBackend" backend.domain = None backend.name = backend._id backend.authorized_domains = [] backend.is_global = False backend.url = backend.outbound_params.get("url") backend.message_param = backend.outbound_params.get("message_param") backend.number_param = backend.outbound_params.get("number_param") backend.include_plus = backend.outbound_params.get("include_plus", False) backend.method = backend.outbound_params.get("method", "GET") backend.additional_params = backend.outbound_params.get("additional_params", {}) backend.outbound_module = None backend.outbound_params = None backend.save() elif backend.outbound_module == "corehq.apps.sms.test_backend": backend = TestSMSBackend.wrap(backend.to_json()) backend.doc_type = "TestSMSBackend" backend.domain = None backend.name = backend._id backend.authorized_domains = [] backend.is_global = True backend.outbound_module = None backend.outbound_params = None backend.save() # If no unicel backend was present, create one try: MobileBackend.get("MOBILE_BACKEND_UNICEL") except ResourceNotFound: backend = UnicelBackend( domain = None, name = "MOBILE_BACKEND_UNICEL", authorized_domains = [], is_global = True, username = settings.UNICEL_CONFIG.get("username"), password = settings.UNICEL_CONFIG.get("password"), sender = settings.UNICEL_CONFIG.get("sender"), reply_to_phone_number = settings.UNICEL_CONFIG.get("receive_phone", None), ) backend._id = backend.name backend.save() # If no mach backend was present, create one try: MobileBackend.get("MOBILE_BACKEND_MACH") except ResourceNotFound: backend = MachBackend( domain = None, name = "MOBILE_BACKEND_MACH", authorized_domains = [], is_global = True, account_id = re.match(r".*id=(.+?)&", settings.SMS_GATEWAY_PARAMS).group(1), password = re.match(r".*pw=(.+?)&", settings.SMS_GATEWAY_PARAMS).group(1), sender_id = "DIMAGI", ) backend._id = backend.name backend.save() # If no test backend was present, create one try: MobileBackend.get("MOBILE_BACKEND_TEST") except ResourceNotFound: backend = TestSMSBackend( domain = None, name = "MOBILE_BACKEND_TEST", authorized_domains = [], is_global = True, ) backend._id = backend.name backend.save()
class OptTestCase(BaseAccountingTest): def setUp(self): super(OptTestCase, self).setUp() self.domain = "opt-test" 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.backend = TestSMSBackend(is_global=True) self.backend.save() self.backend_mapping = BackendMapping( is_global=True, prefix="*", backend_id=self.backend._id, ) self.backend_mapping.save() def test_opt_out_and_opt_in(self): self.assertEqual(PhoneNumber.objects.count(), 0) incoming("99912345678", "stop", "GVI") self.assertEqual(PhoneNumber.objects.count(), 1) phone_number = PhoneNumber.objects.get(phone_number="99912345678") self.assertFalse(phone_number.send_sms) incoming("99912345678", "start", "GVI") self.assertEqual(PhoneNumber.objects.count(), 1) phone_number = PhoneNumber.objects.get(phone_number="99912345678") self.assertTrue(phone_number.send_sms) def test_sending_to_opted_out_number(self): self.assertEqual(PhoneNumber.objects.count(), 0) self.assertTrue(send_sms(self.domain, None, "999123456789", "hello")) incoming("999123456789", "stop", "GVI") self.assertEqual(PhoneNumber.objects.count(), 1) phone_number = PhoneNumber.objects.get(phone_number="999123456789") self.assertFalse(phone_number.send_sms) self.assertFalse(send_sms(self.domain, None, "999123456789", "hello")) def tearDown(self): self.backend_mapping.delete() self.backend.delete() self.domain_obj.delete() SubscriptionAdjustment.objects.all().delete() self.subscription.delete() self.account.delete()