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()
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 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()
