class TestCaseListFilter(TestCase):
def setUp(self):
self.subject = CaseListFilter
self.domain = Domain(name='test', is_active=True)
self.domain.save()
self.location_type = LocationType.objects.create(domain=self.domain.name, name='testtype')
self.user_assigned_locations = [
make_loc('root', domain=self.domain.name, type=self.location_type).sql_location
]
self.request = RequestFactory()
self.request.couch_user = WebUser()
self.request.domain = self.domain
@patch('corehq.apps.users.models.WebUser.get_sql_locations')
def test_default_selections_for_full_access(self, assigned_locations_patch):
self.request.can_access_all_locations = True
self.request.project = self.domain
emwf = self.subject(self.request)
default_selections = emwf.get_default_selections()
self.assertEqual(default_selections, emwf.default_selections)
assert not assigned_locations_patch.called
@patch('corehq.apps.users.models.WebUser.get_sql_locations')
def test_default_selections_for_restricted_access(self, assigned_locations_patch):
self.request.can_access_all_locations = False
self.request.project = self.domain
emwf = self.subject(self.request)
emwf.get_default_selections()
assert assigned_locations_patch.called
def request_new_domain(request, form, org, domain_type=None, new_user=True):
now = datetime.utcnow()
current_user = CouchUser.from_django_user(request.user)
commtrack_enabled = domain_type == 'commtrack'
dom_req = RegistrationRequest()
if new_user:
dom_req.request_time = now
dom_req.request_ip = get_ip(request)
dom_req.activation_guid = uuid.uuid1().hex
new_domain = Domain(
name=form.cleaned_data['domain_name'],
is_active=False,
date_created=datetime.utcnow(),
commtrack_enabled=commtrack_enabled,
creating_user=current_user.username,
secure_submissions=True,
)
if form.cleaned_data.get('domain_timezone'):
new_domain.default_timezone = form.cleaned_data['domain_timezone']
if org:
new_domain.organization = org
new_domain.hr_name = request.POST.get('domain_hrname', None) or new_domain.name
if not new_user:
new_domain.is_active = True
# ensure no duplicate domain documents get created on cloudant
new_domain.save(**get_safe_write_kwargs())
if not new_domain.name:
new_domain.name = new_domain._id
new_domain.save() # we need to get the name from the _id
create_30_day_trial(new_domain)
dom_req.domain = new_domain.name
if request.user.is_authenticated():
if not current_user:
current_user = WebUser()
current_user.sync_from_django_user(request.user)
current_user.save()
current_user.add_domain_membership(new_domain.name, is_admin=True)
current_user.save()
dom_req.requesting_user_username = request.user.username
dom_req.new_user_username = request.user.username
if new_user:
dom_req.save()
send_domain_registration_email(request.user.email,
dom_req.domain,
dom_req.activation_guid)
else:
send_global_domain_registration_email(request.user, new_domain.name)
send_new_request_update_email(request.user, get_ip(request), new_domain.name, is_new_user=new_user)
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 create_user_and_domain(username='******',
password='******',
domain_name='mockdomain'):
"""Creates a domain 'mockdomain' and a web user with name/pw
'brian'/'test'. Returns these two objects in a tuple
as (domain, user). The parameters are configurable."""
try:
domain = Domain.get_by_name(domain_name)
print "WARNING: tried to create domain %s but it already exists!" % domain_name
print "Are all your tests cleaning up properly?"
except Domain.DoesNotExist:
# this is the normal case
domain = Domain(name=domain_name, is_active=True)
domain.save()
try:
user = User.objects.get(username=username)
print "WARNING: tried to create user %s but it already exists!" % username
print "Are all your tests cleaning up properly?"
# update the pw anyway
user.password = _get_salted_pw(password)
user.save()
except User.DoesNotExist:
user = User()
user.username = username
# here, we mimic what the django auth system does
# only we specify the salt to be 12345
user.password = _get_salted_pw(password)
user.save()
return (user, domain)
def run():
from django.contrib.sites.models import Site
django_site_1 = Site.objects.all()[0]
django_site_1.domain = u'localhost:8000'
django_site_1.name = u'localhost:8000'
django_site_1.save()
from corehq.apps.domain.models import Domain
domain_domain_1 = Domain()
domain_domain_1.name = u'test'
domain_domain_1.is_active = True
domain_domain_1.save()
from django.contrib.auth.models import User
auth_user_1 = User()
auth_user_1.username = u'admin'
auth_user_1.first_name = u''
auth_user_1.last_name = u''
auth_user_1.email = u'*****@*****.**'
auth_user_1.password = u'sha1$f8d4b$b6d2f6431c423687c227ad261caa46faaf16917d'
auth_user_1.is_staff = True
auth_user_1.is_active = True
auth_user_1.is_superuser = True
auth_user_1.last_login = datetime.datetime(2010, 9, 10, 14, 40, 30, 501416)
auth_user_1.date_joined = datetime.datetime(2010, 9, 10, 14, 37, 22, 677987)
auth_user_1.save()
auth_user_2 = User()
auth_user_2.username = u'test'
auth_user_2.first_name = u'test'
auth_user_2.last_name = u'test'
auth_user_2.email = u'*****@*****.**'
auth_user_2.password = u'sha1$f09cf$551ac80804020ad3e1d9943a583ee1ea52284797'
auth_user_2.is_staff = False
auth_user_2.is_active = True
auth_user_2.is_superuser = False
auth_user_2.last_login = datetime.datetime(2010, 9, 10, 14, 40, 53, 818764)
auth_user_2.date_joined = datetime.datetime(2010, 9, 10, 19, 40, 6, 159442)
auth_user_2.save()
couch_user = auth_user_2.get_profile().get_couch_user()
couch_user.add_domain_membership(domain_domain_1.name)
couch_user.save()
from corehq.apps.domain.models import RegistrationRequest
domain_registration_request_1 = RegistrationRequest()
domain_registration_request_1.tos_confirmed = True
domain_registration_request_1.request_time = datetime.datetime(2010, 9, 10, 19, 40, 6, 159442)
domain_registration_request_1.request_ip = '127.0.0.1'
domain_registration_request_1.activation_guid = u'368ce6b8bd1311df932c5cff350164a3'
domain_registration_request_1.confirm_time = datetime.datetime(2010, 9, 10, 14, 40, 25, 219783)
domain_registration_request_1.confirm_ip = '127.0.0.1'
domain_registration_request_1.domain = domain_domain_1
domain_registration_request_1.new_user = auth_user_2
domain_registration_request_1.requesting_user = None
domain_registration_request_1.save()
class DomainCopyTest(TestCase):
def setUp(self):
self.domain = Domain(name='test')
self.domain.save()
app = Application.new_app(
'test', "Test Application", lang='en',
application_version=APP_V2
)
module = Module.new_module("Untitled Module", 'en')
app.add_module(module)
app.new_form(0, "Untitled Form", 'en')
app.save()
def tearDown(self):
self.domain.delete()
def test_base(self):
new_domain = self.domain.save_copy()
new_domain.delete()
def test_usercase_enabled(self):
self.domain.usercase_enabled = True
self.domain.save()
new_domain = self.domain.save_copy()
new_domain.delete()
class TestSubscriptionChangeResourceConflict(BaseAccountingTest):
def setUp(self):
self.domain_name = 'test-domain-changes'
self.domain = Domain(
name=self.domain_name,
is_active=True,
description='spam',
)
self.domain.save()
def test_domain_changes(self):
role = Mock()
role.memberships_granted.all.return_value = []
version = Mock()
version.role.get_cached_role.return_value = role
handler = DomainDowngradeActionHandler(
self.domain, new_plan_version=version, changed_privs=REPORT_BUILDER_ADD_ON_PRIVS
)
conflicting_domain = Domain.get_by_name(self.domain_name)
conflicting_domain.description = 'eggs'
conflicting_domain.save()
get_by_name_func = Domain.get_by_name
with patch('corehq.apps.accounting.subscription_changes.Domain') as Domain_patch:
Domain_patch.get_by_name.side_effect = lambda name: get_by_name_func(name)
handler.get_response()
Domain_patch.get_by_name.assert_called_with(self.domain_name)
class UpdateTestCase(TestCase):
def setUp(self):
super(UpdateTestCase, self).setUp()
delete_all_users()
self.username = "******"
password = "******"
self.domain = Domain(name='my-domain')
self.domain.save()
self.couch_user = CommCareUser.create(self.domain.name, self.username, password)
self.couch_user.save()
def testAddRemovePhoneNumbers(self):
"""
test that a basic couch user gets created properly after
saving a django user programmatically
"""
self.couch_user.add_phone_number('123123123')
self.assertEqual(self.couch_user.phone_numbers, ['123123123'])
self.couch_user.add_phone_number('321321321')
self.assertEqual(self.couch_user.phone_numbers, ['123123123', '321321321'])
def testChangeUsername(self):
new_username = '******'
self.assertEqual(CouchUser.get_by_username(self.username).user_id, self.couch_user.user_id)
self.assertEqual(User.objects.filter(username=self.username).count(), 1)
self.couch_user.change_username(new_username)
self.assertEqual(CouchUser.get_by_username(self.username), None)
self.assertEqual(CouchUser.get_by_username(new_username).user_id, self.couch_user.user_id)
self.assertEqual(self.couch_user.get_django_user().username, new_username)
self.assertEqual(User.objects.filter(username=new_username).count(), 1)
self.assertEqual(User.objects.get(username=new_username).id, self.couch_user.get_django_user().id)
self.assertEqual(User.objects.filter(username=self.username).count(), 0)
class AllCommCareUsersTest(TestCase):
def setUp(self):
self.ccdomain = Domain(name="cc_user_domain")
self.ccdomain.save()
self.other_domain = Domain(name="other_domain")
self.other_domain.save()
self.ccuser_1 = CommCareUser.create(
domain=self.ccdomain.name, username="******", password="******", email="*****@*****.**"
)
self.ccuser_2 = CommCareUser.create(
domain=self.ccdomain.name, username="******", password="******", email="*****@*****.**"
)
self.web_user = WebUser.create(
domain=self.ccdomain.name, username="******", password="******", email="*****@*****.**"
)
self.ccuser_other_domain = CommCareUser.create(
domain=self.other_domain.name,
username="******",
password="******",
email="*****@*****.**",
)
def tearDown(self):
self.ccdomain.delete()
self.other_domain.delete()
def test_get_all_commcare_users_by_domain(self):
expected_users = [self.ccuser_2, self.ccuser_1]
expected_usernames = [user.username for user in expected_users]
actual_usernames = [user.username for user in get_all_commcare_users_by_domain(self.ccdomain.name)]
self.assertItemsEqual(actual_usernames, expected_usernames)
class TestSubscription(BaseAccountingTest):
def setUp(self):
super(TestSubscription, self).setUp()
self.billing_contact = generator.arbitrary_web_user()
self.dimagi_user = generator.arbitrary_web_user(is_dimagi=True)
self.domain = Domain(name='test')
self.domain.save()
self.currency = generator.init_default_currency()
self.account = generator.billing_account(self.dimagi_user, self.billing_contact)
self.subscription, self.subscription_length = generator.generate_domain_subscription_from_date(
datetime.date.today(), self.account, self.domain.name
)
def test_creation(self):
self.assertIsNotNone(self.subscription)
def test_no_activation(self):
tasks.activate_subscriptions(based_on_date=self.subscription.date_start - datetime.timedelta(30))
subscription = Subscription.objects.get(id=self.subscription.id)
self.assertFalse(subscription.is_active)
def test_activation(self):
tasks.activate_subscriptions(based_on_date=self.subscription.date_start)
subscription = Subscription.objects.get(id=self.subscription.id)
self.assertTrue(subscription.is_active)
def test_no_deactivation(self):
tasks.activate_subscriptions(based_on_date=self.subscription.date_start)
tasks.deactivate_subscriptions(based_on_date=self.subscription.date_end - datetime.timedelta(30))
subscription = Subscription.objects.get(id=self.subscription.id)
self.assertTrue(subscription.is_active)
def test_deactivation(self):
tasks.deactivate_subscriptions(based_on_date=self.subscription.date_end)
subscription = Subscription.objects.get(id=self.subscription.id)
self.assertFalse(subscription.is_active)
def test_deletions(self):
self.assertRaises(models.ProtectedError, self.account.delete)
self.assertRaises(models.ProtectedError, self.subscription.plan_version.delete)
self.assertRaises(models.ProtectedError, self.subscription.subscriber.delete)
def test_is_hidden_to_ops(self):
self.subscription.is_hidden_to_ops = True
self.subscription.save()
self.assertEqual(0, len(Subscription.objects.filter(id=self.subscription.id)))
self.subscription.is_hidden_to_ops = False
self.subscription.save()
self.assertEqual(1, len(Subscription.objects.filter(id=self.subscription.id)))
def tearDown(self):
self.billing_contact.delete()
self.dimagi_user.delete()
self.domain.delete()
generator.delete_all_subscriptions()
generator.delete_all_accounts()
super(TestSubscription, self).tearDown()
def arbitrary_domain():
domain = Domain(
name=data_gen.arbitrary_unique_name()[:20],
is_active=True,
)
domain.save()
return domain
class DomainCalculatedPropertiesTest(TestCase):
@classmethod
def setUpClass(cls):
super(DomainCalculatedPropertiesTest, cls).setUpClass()
cls.es = [{
'info': i,
'instance': get_es_new(),
} for i in [CASE_INDEX_INFO, SMS_INDEX_INFO, XFORM_INDEX_INFO]]
def setUp(self):
self.domain = Domain(name='test-b9289e19d819')
self.domain.save()
for es in self.es:
ensure_index_deleted(es['info'].index)
initialize_index_and_mapping(es['instance'], es['info'])
def tearDown(self):
self.domain.delete()
def test_sanity(self):
all_stats = all_domain_stats()
props = calced_props(self.domain, self.domain._id, all_stats)
self.assertFalse(props['cp_has_app'])
# ensure serializable
json.dumps(props)
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()
# I tried making this class inherit from BaseSMSTest, but somehow
# the multiple inheritance was causing the postgres connection to
# get in a weird state where it wasn't commiting any changes. So
# for now, keeping this subscription setup code as is.
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
class TestDeleteDomain(TestCase):
def _create_data(self, domain_name):
product = Product(domain=domain_name, name="test-product")
product.save()
location = Location(domain=domain_name, site_code="testcode", name="test1", location_type="facility")
location.save()
self.locations[domain_name] = location.sql_location
user = CommCareUser.create(domain=domain_name, username="******".format(domain_name), password="******")
FacilityInCharge.objects.create(user_id=user.get_id, location=location.sql_location)
def setUp(self):
self.domain = Domain(name="test", is_active=True)
self.domain.save()
self.domain2 = Domain(name="test2", is_active=True)
self.domain2.save()
self.locations = {}
LocationType.objects.create(domain="test", name="facility")
LocationType.objects.create(domain="test2", name="facility")
self._create_data("test")
self._create_data("test2")
def test_pre_delete_signal_receiver(self):
self.domain.delete()
self.assertEqual(FacilityInCharge.objects.filter(location=self.locations["test"]).count(), 0)
self.assertEqual(FacilityInCharge.objects.filter(location=self.locations["test2"]).count(), 1)
def tearDown(self):
self.domain2.delete()
class OtaV3RestoreTest(TestCase):
"""Tests OTA Restore v3"""
def setUp(self):
self.domain = 'dummy-project'
self.project = Domain(name=self.domain)
self.project.save()
delete_all_cases()
delete_all_sync_logs()
delete_all_users()
def tearDown(self):
self.project.delete()
def testUserRestoreWithCase(self):
restore_user = create_restore_user(domain=self.domain)
case_id = 'my-case-id'
device = MockDevice(self.project, restore_user)
device.change_cases(CaseBlock(
create=True,
case_id=case_id,
user_id=restore_user.user_id,
owner_id=restore_user.user_id,
case_type='test-case-type',
update={'external_id': 'someexternal'},
))
self.assertIn(case_id, device.sync().cases)
class OtaV3RestoreTest(TestCase):
"""Tests OTA Restore v3"""
def setUp(self):
self.domain = 'dummy-project'
self.project = Domain(name=self.domain)
self.project.save()
delete_all_cases()
delete_all_sync_logs()
delete_all_users()
def tearDown(self):
self.project.delete()
def testUserRestoreWithCase(self):
restore_user = create_restore_user(domain=self.domain)
expected_case_block = CaseBlock(
create=True,
case_id='my-case-id',
user_id=restore_user.user_id,
owner_id=restore_user.user_id,
case_type='test-case-type',
update={'external_id': 'someexternal'},
)
_, [case] = post_case_blocks([expected_case_block.as_xml()], {'domain': self.domain})
assert_user_has_case(self, restore_user, case.case_id)
class BaseDomainTest(TestCase):
def setUp(self):
self.client = Client()
self.domain = Domain(name="fandago", is_active=True)
self.domain.save()
toggles.TRANSFER_DOMAIN.set("domain:{domain}".format(domain=self.domain.name), True)
self.username = '******'
self.password = '******'
self.user = WebUser.create(self.domain.name, self.username, self.password)
self.user.set_role(self.domain.name, 'admin')
self.user.save()
self.another_domain = Domain(name='anotherdomain', is_active=True)
self.another_domain.save()
self.mugglename = 'muggle'
self.muggle = WebUser.create(self.another_domain.name, self.mugglename, self.password)
self.muggle.save()
def tearDown(self):
self.user.delete()
self.domain.delete()
self.muggle.delete()
self.another_domain.delete()
class TestDomainViews(TestCase):
def setUp(self):
self.client = Client()
self.domain = Domain(name="fandago", is_active=True)
self.domain.save()
self.username = '******'
self.password = '******'
self.user = WebUser.create(self.domain.name, self.username, self.password)
self.user.set_role(self.domain.name, 'admin')
self.user.save()
def tearDown(self):
self.user.delete()
self.domain.delete()
def test_add_repeater(self):
forwarding_url = 'https://example.com/forwarding'
self.client.login(username=self.username, password=self.password)
post_url = reverse('add_repeater', kwargs={'domain': self.domain.name, 'repeater_type': 'AppStructureRepeater'})
response = self.client.post(post_url, {'url': forwarding_url}, follow=True)
self.assertEqual(response.status_code, 200)
self.client.logout()
app_structure_repeaters = AppStructureRepeater.by_domain(self.domain.name)
self.assertEqual(len(app_structure_repeaters), 1)
for app_structure_repeater in app_structure_repeaters:
app_structure_repeater.delete()
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()
self.setup_subscription(domain_obj.name, SoftwarePlanEdition.ADVANCED)
return domain_obj
def test_should_sync_hierarchical_format_if_location_types_exist(self):
domain = uuid.uuid4().hex
project = Domain(name=domain)
project.save()
location_type = LocationType.objects.create(domain=domain, name='test-type')
self.assertEqual(True, should_sync_hierarchical_fixture(project))
self.addCleanup(project.delete)
self.addCleanup(location_type.delete)
class TestBillingRecord(BaseAccountingTest):
def setUp(self):
super(TestBillingRecord, self).setUp()
self.billing_contact = generator.create_arbitrary_web_user_name()
self.dimagi_user = generator.create_arbitrary_web_user_name(is_dimagi=True)
self.domain = Domain(name='test')
self.domain.save()
self.invoice_start, self.invoice_end = get_previous_month_date_range()
self.currency = generator.init_default_currency()
self.account = generator.billing_account(self.dimagi_user, self.billing_contact)
self.subscription_length = 4 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, self.subscription_length)
self.subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
self.invoice = Invoice(
subscription=self.subscription,
date_start=self.invoice_start,
date_end=self.invoice_end,
is_hidden=False,
)
self.billing_record = BillingRecord(invoice=self.invoice)
def tearDown(self):
self.domain.delete()
super(TestBillingRecord, self).tearDown()
def test_should_send_email(self):
self.assertTrue(self.billing_record.should_send_email)
def test_should_send_email_contracted(self):
self.subscription.service_type = SubscriptionType.IMPLEMENTATION
self.assertFalse(self.billing_record.should_send_email)
self.invoice.balance = Decimal(SMALL_INVOICE_THRESHOLD - 1)
self.assertFalse(self.billing_record.should_send_email)
self.invoice.balance = Decimal(SMALL_INVOICE_THRESHOLD + 1)
self.assertTrue(self.billing_record.should_send_email)
def test_should_send_email_autogenerate_credits(self):
self.subscription.auto_generate_credits = True
self.assertFalse(self.billing_record.should_send_email)
self.invoice.balance = Decimal(SMALL_INVOICE_THRESHOLD + 1)
self.assertTrue(self.billing_record.should_send_email)
def test_should_send_email_hidden(self):
self.assertTrue(self.billing_record.should_send_email)
self.invoice.is_hidden = True
self.assertFalse(self.billing_record.should_send_email)
class TestBillingRecord(BaseAccountingTest):
def setUp(self):
super(TestBillingRecord, self).setUp()
self.billing_contact = generator.create_arbitrary_web_user_name()
self.dimagi_user = generator.create_arbitrary_web_user_name(is_dimagi=True)
self.domain = Domain(name='test')
self.domain.save()
self.invoice_start, self.invoice_end = get_previous_month_date_range()
self.currency = generator.init_default_currency()
self.account = generator.billing_account(self.dimagi_user, self.billing_contact)
self.subscription_length = 4 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, self.subscription_length)
self.subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
self.invoice = Invoice(
subscription=self.subscription,
date_start=self.invoice_start,
date_end=self.invoice_end,
is_hidden=False,
)
self.billing_record = BillingRecord(invoice=self.invoice)
def tearDown(self):
self.domain.delete()
super(TestBillingRecord, self).tearDown()
def test_should_send_email(self):
self.assertTrue(self.billing_record.should_send_email)
def test_should_send_email_contracted(self):
self.subscription.service_type = SubscriptionType.IMPLEMENTATION
self.assertFalse(self.billing_record.should_send_email)
self.invoice.balance = Decimal(SMALL_INVOICE_THRESHOLD - 1)
self.assertFalse(self.billing_record.should_send_email)
self.invoice.balance = Decimal(SMALL_INVOICE_THRESHOLD + 1)
self.assertTrue(self.billing_record.should_send_email)
def test_should_send_email_autogenerate_credits(self):
self.subscription.auto_generate_credits = True
self.assertFalse(self.billing_record.should_send_email)
self.invoice.balance = Decimal(SMALL_INVOICE_THRESHOLD + 1)
self.assertTrue(self.billing_record.should_send_email)
def test_should_send_email_hidden(self):
self.assertTrue(self.billing_record.should_send_email)
self.invoice.is_hidden = True
self.assertFalse(self.billing_record.should_send_email)
def setUpClass(cls):
domain_foo = Domain(name='foo')
domain_foo.save()
domain_bar = Domain(name='bar')
domain_bar.save()
ReportConfiguration(domain=domain_foo.name, config_id='foo1').save()
ReportConfiguration(domain=domain_foo.name, config_id='foo2').save()
ReportConfiguration(domain=domain_bar.name, config_id='bar1').save()
def test_should_sync_hierarchical_format_if_location_types_exist(self):
domain = uuid.uuid4().hex
project = Domain(name=domain)
project.save()
location_type = LocationType.objects.create(domain=domain,
name='test-type')
self.assertEqual(True, should_sync_hierarchical_fixture(project))
self.addCleanup(project.delete)
self.addCleanup(location_type.delete)
class IncomingPostTest(TestCase):
INDIA_TZ_OFFSET = timedelta(hours=5.5)
@classmethod
def setUpClass(cls):
super(IncomingPostTest, cls).setUpClass()
cls.unicel_backend = SQLUnicelBackend.objects.create(
name='UNICEL',
is_global=True,
hq_api_id=SQLUnicelBackend.get_api_id()
)
@classmethod
def tearDownClass(cls):
cls.unicel_backend.delete()
super(IncomingPostTest, cls).tearDownClass()
def setUp(self):
self.domain = Domain(name='mockdomain')
self.domain.save()
SMS.by_domain(self.domain.name).delete()
self.user = '******'
self.password = '******'
self.number = 5555551234
self.couch_user = WebUser.create(self.domain.name, self.user, self.password)
self.couch_user.add_phone_number(self.number)
self.couch_user.save()
self.message_ascii = 'It Works'
self.message_utf_hex = '0939093F0928094D092609400020091509300924093E00200939094800200907093800200938092E092F00200915093E092E002009390948003F'
def tearDown(self):
self.couch_user.delete()
self.domain.delete()
def testPostToIncomingAscii(self):
fake_post = {InboundParams.SENDER: str(self.number),
InboundParams.MESSAGE: self.message_ascii,
InboundParams.MID: '00001',
InboundParams.DCS: '0'}
response, log = post(fake_post, self.unicel_backend)
self.assertEqual(200, response.status_code)
self.assertEqual(self.message_ascii, log.text)
self.assertEqual(INCOMING, log.direction)
self.assertEqual(log.backend_message_id, fake_post[InboundParams.MID])
def testPostToIncomingUtf(self):
fake_post = {InboundParams.SENDER: str(self.number),
InboundParams.MESSAGE: self.message_utf_hex,
InboundParams.MID: '00002',
InboundParams.DCS: '8'}
response, log = post(fake_post, self.unicel_backend)
self.assertEqual(200, response.status_code)
self.assertEqual(codecs.decode(codecs.decode(self.message_utf_hex, 'hex'), 'utf_16_be'),
log.text)
self.assertEqual(INCOMING, log.direction)
self.assertEqual(log.backend_message_id, fake_post[InboundParams.MID])
def dispatch(self, request, *args, **kwargs):
# HACK HACK HACK HACK HACK from Tim, just moving it over
# todo fix HACK HACK HACK HACK HACK
dummy = Domain.get_by_name("dumdum")
if not dummy:
dummy = Domain(name="dumdum", is_active=True, date_created=datetime.datetime.utcnow())
dummy.save()
kwargs["domain"] = "dumdum"
return super(AppstoreDispatcher, self).dispatch(request, *args, **kwargs)
def request_new_domain(request, form, org, domain_type=None, new_user=True):
now = datetime.utcnow()
current_user = CouchUser.from_django_user(request.user)
commtrack_enabled = domain_type == 'commtrack'
dom_req = RegistrationRequest()
if new_user:
dom_req.request_time = now
dom_req.request_ip = get_ip(request)
dom_req.activation_guid = uuid.uuid1().hex
new_domain = Domain(name=form.cleaned_data['domain_name'],
is_active=False,
date_created=datetime.utcnow(),
commtrack_enabled=commtrack_enabled,
creating_user=current_user.username)
bootstrap_default(new_domain)
if org:
new_domain.organization = org
new_domain.hr_name = request.POST.get('domain_hrname',
None) or new_domain.name
if not new_user:
new_domain.is_active = True
# ensure no duplicate domain documents get created on cloudant
new_domain.save(**get_safe_write_kwargs())
if not new_domain.name:
new_domain.name = new_domain._id
new_domain.save() # we need to get the name from the _id
dom_req.domain = new_domain.name
if request.user.is_authenticated():
if not current_user:
current_user = WebUser()
current_user.sync_from_django_user(request.user)
current_user.save()
current_user.add_domain_membership(new_domain.name, is_admin=True)
current_user.save()
dom_req.requesting_user_username = request.user.username
dom_req.new_user_username = request.user.username
if new_user:
dom_req.save()
send_domain_registration_email(request.user.email, dom_req.domain,
dom_req.activation_guid)
else:
send_global_domain_registration_email(request.user, new_domain.name)
send_new_domain_request_update_email(request.user,
get_ip(request),
new_domain.name,
is_new_user=new_user)
def domain_fixture(domain_name, allow_domain_requests=False):
domain = Domain(name=domain_name, is_active=True)
if allow_domain_requests:
domain.allow_domain_requests = True
domain.save()
try:
yield
finally:
domain.delete()
def setUpClass(cls):
super(ReportConfigurationDbTest, cls).setUpClass()
domain_foo = Domain(name='foo')
domain_foo.save()
domain_bar = Domain(name='bar')
domain_bar.save()
ReportConfiguration(domain=domain_foo.name, config_id='foo1').save()
ReportConfiguration(domain=domain_foo.name, config_id='foo2').save()
ReportConfiguration(domain=domain_bar.name, config_id='bar1').save()
def test_wrong_domain(self):
other_domain = Domain(name='other_domain')
other_domain.save()
self.addCleanup(other_domain.delete)
correct_credentials = self._get_correct_credentials()
response = self.client.get(
reverse(self.view_urlname, kwargs={'domain': other_domain.name}),
HTTP_AUTHORIZATION='Basic ' + correct_credentials,
)
self.assertEqual(response.status_code, 403)
def test_disallow_domain_requests(self):
self.client.login(username=self.username, password=self.password)
private_domain = Domain(name="private", is_active=True)
private_domain.save()
response = self.client.get(reverse("domain_homepage", args=[private_domain.name]), follow=True)
self.assertEqual(response.status_code, 404)
private_domain.delete()
def test_wrong_domain(self):
other_domain = Domain(name='other_domain')
other_domain.save()
self.addCleanup(other_domain.delete)
correct_credentials = self._get_correct_credentials()
response = self.client.get(
reverse(self.view_urlname, kwargs={'domain': other_domain.name}),
HTTP_AUTHORIZATION='Basic ' + correct_credentials,
)
self.assertEqual(response.status_code, 403)
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()
class TestUserBulkUploadStrongPassword(TestCase, DomainSubscriptionMixin):
def setUp(self):
super(TestUserBulkUploadStrongPassword, self).setUp()
delete_all_users()
self.domain_name = 'mydomain'
self.domain = Domain(name=self.domain_name)
self.domain.strong_mobile_passwords = True
self.domain.save()
self.user_specs = [{
'username': '******',
'user_id': '1989',
'name': 'Taylor Swift',
'language': None,
'is_active': 'True',
'phone-number': '8675309',
'password': '******',
'email': None
}]
def tearDown(self):
self.domain.delete()
super(TestUserBulkUploadStrongPassword, self).tearDown()
def test_duplicate_password(self):
user_spec = [{
'username': '******',
'user_id': '1990',
'name': 'Tom Hiddleston',
'language': None,
'is_active': 'True',
'phone-number': '8675309',
'password': '******',
'email': None
}]
rows = import_users_and_groups(
self.domain.name,
list(user_spec + self.user_specs),
[],
)['messages']['rows']
self.assertEqual(rows[0]['flag'], "'password' values must be unique")
def test_weak_password(self):
updated_user_spec = deepcopy(self.user_specs[0])
updated_user_spec["password"] = '******'
rows = import_users_and_groups(
self.domain.name,
list([updated_user_spec]),
[],
)['messages']['rows']
self.assertEqual(
rows[0]['flag'],
'Password is not strong enough. Try making your password more complex.'
)
class TestCreditStripePaymentHandler(TransactionTestCase):
def setUp(self):
super(TestCreditStripePaymentHandler, self).setUp()
generator.instantiate_accounting()
self.domain = Domain(name='test-domain')
self.domain.save()
self.payment_method = PaymentMethod()
self.payment_method.save()
self.account, _ = BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by='*****@*****.**')
def tearDown(self):
self.domain.delete()
PaymentRecord.objects.all().delete()
self.payment_method.delete()
self.account.delete()
super(TestCreditStripePaymentHandler, self).tearDown()
@patch.object(stripe.Charge, 'create')
def test_working_process_request(self, mock_create):
self._call_process_request()
self.assertEqual(PaymentRecord.objects.count(), 1)
self.assertEqual(mock_create.call_count, 1)
@patch.object(stripe.Charge, 'create')
def test_when_stripe_errors_no_payment_record_exists(self, mock_create):
mock_create.side_effect = Exception
self._call_process_request()
self.assertEqual(PaymentRecord.objects.count(), 0)
@patch.object(stripe.Charge, 'create')
@patch.object(PaymentRecord, 'create_record')
def test_when_create_record_fails_stripe_is_not_charged(
self, mock_create_record, mock_create):
mock_create_record.side_effect = Exception
try:
self._call_process_request()
except:
pass
self.assertEqual(PaymentRecord.objects.count(), 0)
self.assertEqual(mock_create.call_count, 0)
def _call_process_request(self):
CreditStripePaymentHandler(self.payment_method,
self.domain,
self.account,
post_data={}).process_request(
RequestFactory().post(
'', {'amount': 1}))
class TestRenewSubscriptions(BaseAccountingTest):
def setUp(self):
super(TestRenewSubscriptions, self).setUp()
self.domain = Domain(
name="test-domain-sub",
is_active=True,
)
self.domain.save()
self.admin_user = generator.arbitrary_web_user()
self.admin_user.add_domain_membership(self.domain.name, is_admin=True)
self.admin_user.save()
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by=self.admin_user.username)[0]
self.standard_plan = DefaultProductPlan.get_default_plan_by_domain(
self.domain.name, edition=SoftwarePlanEdition.STANDARD)
today = datetime.date.today()
yesterday = today + datetime.timedelta(days=-1)
tomorrow = today + datetime.timedelta(days=1)
self.subscription = Subscription.new_domain_subscription(
self.account,
self.domain.name,
self.standard_plan,
web_user=self.admin_user.username,
date_start=yesterday,
date_end=tomorrow,
)
self.subscription.save()
def test_simple_renewal(self):
today = datetime.date.today()
renewed_subscription = self.subscription.renew_subscription()
self.assertEqual(renewed_subscription.date_end, None)
self.assertEqual(renewed_subscription.date_start, self.subscription.date_end)
self.assertEqual(renewed_subscription.plan_version, self.subscription.plan_version)
def test_change_plan_on_renewal(self):
today = datetime.date.today()
new_edition = SoftwarePlanEdition.ADVANCED
new_plan = DefaultProductPlan.get_default_plan_by_domain(self.domain.name, new_edition)
renewed_subscription = self.subscription.renew_subscription(
new_version=new_plan
)
self.assertEqual(renewed_subscription.plan_version, new_plan)
def test_wrong_domain(self):
other_domain = Domain(name='other_domain')
other_domain.save()
self.addCleanup(other_domain.delete)
correct_credentials = self._get_correct_credentials()
response = self.client.get(
self._odata_feed_url_by_domain(other_domain.name),
HTTP_AUTHORIZATION='Basic ' + correct_credentials,
)
self.assertEqual(response.status_code, 404)
def test_wrong_domain(self):
other_domain = Domain(name='other_domain')
other_domain.save()
self.addCleanup(other_domain.delete)
correct_credentials = self._get_correct_credentials()
response = self.client.get(
self._odata_feed_url_by_domain(other_domain.name),
HTTP_AUTHORIZATION='Basic ' + correct_credentials,
)
self.assertEqual(response.status_code, 404)
def dispatch(self, request, *args, **kwargs):
# HACK HACK HACK HACK HACK from Tim, just moving it over
# todo fix HACK HACK HACK HACK HACK
dummy = Domain.get_by_name('dumdum')
if not dummy:
dummy = Domain(name='dumdum',
is_active=True,
date_created=datetime.datetime.utcnow())
dummy.save()
kwargs['domain'] = 'dumdum'
return super(AppstoreDispatcher,
self).dispatch(request, *args, **kwargs)
class TestUserBulkUploadStrongPassword(TestCase, DomainSubscriptionMixin):
def setUp(self):
super(TestUserBulkUploadStrongPassword, self).setUp()
delete_all_users()
self.domain_name = 'mydomain'
self.domain = Domain(name=self.domain_name)
self.domain.strong_mobile_passwords = True
self.domain.save()
self.user_specs = [{
'username': '******',
'user_id': '1989',
'name': 'Taylor Swift',
'language': None,
'is_active': 'True',
'phone-number': '8675309',
'password': '******',
'email': None
}]
def tearDown(self):
self.domain.delete()
super(TestUserBulkUploadStrongPassword, self).tearDown()
def test_duplicate_password(self):
user_spec = [{
'username': '******',
'user_id': '1990',
'name': 'Tom Hiddleston',
'language': None,
'is_active': 'True',
'phone-number': '8675309',
'password': '******',
'email': None
}]
rows = bulk_upload_async(
self.domain.name,
list(user_spec + self.user_specs),
list([]),
)['messages']['rows']
self.assertEqual(rows[0]['flag'],
'Provide a unique password for each mobile worker')
def test_weak_password(self):
updated_user_spec = deepcopy(self.user_specs[0])
updated_user_spec["password"] = '******'
rows = bulk_upload_async(
self.domain.name,
list([updated_user_spec]),
list([]),
)['messages']['rows']
self.assertEqual(rows[0]['flag'], 'Please provide a stronger password')
class TestDeleteDomain(TestCase):
def _create_data(self, domain_name):
product = Product(domain=domain_name, name='test-product')
product.save()
location = make_location(
domain=domain_name,
site_code='testcode',
name='test1',
location_type='facility'
)
location.save()
self.locations[domain_name] = location.sql_location
user = CommCareUser.create(
domain=domain_name,
username='******'.format(domain_name),
password='******'
)
FacilityInCharge.objects.create(
user_id=user.get_id,
location=location.sql_location
)
def setUp(self):
self.domain = Domain(name="test", is_active=True)
self.domain.save()
self.domain2 = Domain(name="test2", is_active=True)
self.domain2.save()
self.locations = {}
LocationType.objects.create(
domain='test',
name='facility',
)
LocationType.objects.create(
domain='test2',
name='facility',
)
self._create_data('test')
self._create_data('test2')
def test_pre_delete_signal_receiver(self):
self.domain.delete()
self.assertEqual(FacilityInCharge.objects.filter(location=self.locations['test']).count(), 0)
self.assertEqual(FacilityInCharge.objects.filter(location=self.locations['test2']).count(), 1)
def tearDown(self):
FacilityInCharge.objects.all().delete()
self.domain2.delete()
class TestDeleteDomain(TestCase):
def _create_data(self, domain_name):
product = Product(domain=domain_name, name='test-product')
product.save()
location = Location(
domain=domain_name,
site_code='testcode',
name='test1',
location_type='facility'
)
location.save()
self.locations[domain_name] = location.sql_location
user = CommCareUser.create(
domain=domain_name,
username='******'.format(domain_name),
password='******'
)
FacilityInCharge.objects.create(
user_id=user.get_id,
location=location.sql_location
)
def setUp(self):
self.domain = Domain(name="test", is_active=True)
self.domain.save()
self.domain2 = Domain(name="test2", is_active=True)
self.domain2.save()
self.locations = {}
LocationType.objects.create(
domain='test',
name='facility',
)
LocationType.objects.create(
domain='test2',
name='facility',
)
self._create_data('test')
self._create_data('test2')
def test_pre_delete_signal_receiver(self):
self.domain.delete()
self.assertEqual(FacilityInCharge.objects.filter(location=self.locations['test']).count(), 0)
self.assertEqual(FacilityInCharge.objects.filter(location=self.locations['test2']).count(), 1)
def tearDown(self):
FacilityInCharge.objects.all().delete()
self.domain2.delete()
class DomainCalculatedPropertiesTest(TestCase):
@classmethod
def setUpClass(cls):
super(DomainCalculatedPropertiesTest, cls).setUpClass()
cls.es = [{
'info': i,
'instance': get_es_new(),
} for i in [
CASE_INDEX_INFO, SMS_INDEX_INFO, XFORM_INDEX_INFO, USER_INDEX_INFO
]]
def setUp(self):
self.domain = Domain(name='test-b9289e19d819')
self.domain.save()
for es in self.es:
ensure_index_deleted(es['info'].index)
initialize_index_and_mapping(es['instance'], es['info'])
self._set_up_sms_es()
def _set_up_sms_es(self):
sms_doc = {
'_id': 'some_sms_id',
'domain': self.domain.name,
'direction': INCOMING,
'date': json_format_datetime(datetime.datetime.utcnow()),
'doc_type': SMS_INDEX_INFO.type,
}
send_to_elasticsearch(
index=SMS_INDEX_INFO.index,
doc_type=SMS_INDEX_INFO.type,
doc_id=sms_doc['_id'],
es_getter=get_es_new,
name='ElasticProcessor',
data=sms_doc,
update=False,
)
refresh_elasticsearch_index('sms')
def tearDown(self):
self.domain.delete()
def test_sanity(self):
all_stats = all_domain_stats()
props = calced_props(self.domain, self.domain._id, all_stats)
self.assertFalse(props['cp_has_app'])
# ensure serializable
json.dumps(props)
def test_sms(self):
self.assertEqual(SMSES().count(), 1)
self.assertEqual(sms(self.domain.name, INCOMING), 1)
self.assertEqual(sms(self.domain.name, OUTGOING), 0)
def arbitrary_web_user(save=True, is_dimagi=False):
domain = Domain(name=unique_name()[:25])
domain.save()
username = "******" % (unique_name(),
'dimagi' if is_dimagi else 'gmail')
try:
web_user = WebUser.create(domain.name, username, 'test123')
except Exception:
web_user = WebUser.get_by_username(username)
web_user.is_active = True
if save:
web_user.save()
return web_user
def setUp(self):
super(ReportConfigurationDbTest, self).setUp()
domain_foo = Domain(name='foo')
domain_foo.save()
domain_bar = Domain(name='bar')
domain_bar.save()
# TODO - handle cleanup appropriately so this isn't needed
delete_all_report_configs()
ReportConfiguration(domain=domain_foo.name, config_id='foo1').save()
ReportConfiguration(domain=domain_foo.name, config_id='foo2').save()
ReportConfiguration(domain=domain_bar.name, config_id='bar1').save()
def test_should_sync_hierarchical_format_disabled(self):
domain = uuid.uuid4().hex
project = Domain(name=domain)
project.save()
location_type = LocationType.objects.create(domain=domain,
name='test-type')
location_settings = LocationFixtureConfiguration.objects.create(
domain=domain, sync_hierarchical_fixture=False)
self.assertEqual(False, should_sync_hierarchical_fixture(project))
with flag_enabled('FLAT_LOCATION_FIXTURE'):
self.assertEqual(False, should_sync_hierarchical_fixture(project))
self.addCleanup(project.delete)
self.addCleanup(location_type.delete)
self.addCleanup(location_settings.delete)
def test_can_edit_report(self):
"""
Test whether ConfigurableReportView.page_context allows report editing
"""
domain = Domain(name='test_domain', is_active=True)
domain.save()
self.addCleanup(domain.delete)
def create_view(can_edit_reports):
rolename = 'edit_role' if can_edit_reports else 'view_role'
username = '******' if can_edit_reports else 'viewer'
toggles.USER_CONFIGURABLE_REPORTS.set(username, True, toggles.NAMESPACE_USER)
user_role = UserRole(
domain=domain.name,
name=rolename,
permissions=Permissions(edit_commcare_users=True,
view_commcare_users=True,
edit_groups=True,
view_groups=True,
edit_locations=True,
view_locations=True,
access_all_locations=False,
edit_data=True,
edit_reports=can_edit_reports,
view_reports=True
)
)
user_role.save()
# user_role should be deleted along with the domain.
web_user = WebUser.create(domain.name, username, '***', None, None)
web_user.set_role(domain.name, user_role.get_qualified_id())
web_user.current_domain = domain.name
web_user.save()
self.addCleanup(web_user.delete, deleted_by=None)
request = HttpRequest()
request.can_access_all_locations = True
request.user = web_user.get_django_user()
request.couch_user = web_user
request.session = {}
_, view = self._build_report_and_view(request=request)
return view
cannot_edit_view = create_view(False)
self.assertEqual(cannot_edit_view.page_context['can_edit_report'], False)
can_edit_view = create_view(True)
self.assertEqual(can_edit_view.page_context['can_edit_report'], True)
def setup_domain(cls, name):
domain_obj = Domain(name=name, sms_mobile_worker_registration_enabled=True)
domain_obj.save()
plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.ADVANCED)
account = BillingAccount.get_or_create_account_by_domain(
name, created_by="automated-test-" + cls.__name__
)[0]
subscription = Subscription.new_domain_subscription(account, name, plan)
subscription.is_active = True
subscription.save()
domain_obj = Domain.get(domain_obj.get_id)
return (domain_obj, account, subscription)
class BETSBeneficiaryRepeaterTest(ENikshayRepeaterTestBase):
def setUp(self):
super(BETSBeneficiaryRepeaterTest, self).setUp()
self.domain_obj = Domain(name=self.domain)
self.domain_obj.save()
self.repeater = BETSBeneficiaryRepeater(
domain=self.domain,
url='super-cool-url',
)
self.repeater.save()
loc_type = LocationType.objects.create(
domain=self.domain,
name="loc_type",
administrative=True,
)
self.real_location = SQLLocation.objects.create(
domain=self.domain,
name="real_location",
site_code="real_location",
location_type=loc_type,
metadata={
'is_test': 'no',
'nikshay_code': 'nikshay_code'
},
)
self.test_location = SQLLocation.objects.create(
domain=self.domain,
name="test_location",
site_code="test_location",
location_type=loc_type,
metadata={
'is_test': 'yes',
'nikshay_code': 'nikshay_code'
},
)
def tearDown(self):
super(BETSBeneficiaryRepeaterTest, self).tearDown()
self.domain_obj.delete()
def create_person_case(self, location_id, private=True):
case = get_person_case_structure(None, self.episode_id)
case.attrs['owner_id'] = location_id
case.attrs['update']['current_episode_type'] = 'confirmed_tb'
case.attrs['update']['contact_phone_number'] = '911234567890'
case.attrs['update'][
ENROLLED_IN_PRIVATE] = "true" if private else "false"
return self.factory.create_or_update_cases([case])[0]
class IncomingPostTest(TestCase):
INDIA_TZ_OFFSET = timedelta(hours=5.5)
def setUp(self):
self.domain = Domain(name='mockdomain')
self.domain.save()
SMS.by_domain(self.domain.name).delete()
self.user = '******'
self.password = '******'
self.number = 5555551234
self.couch_user = WebUser.create(self.domain.name, self.user,
self.password)
self.couch_user.add_phone_number(self.number)
self.couch_user.save()
self.message_ascii = 'It Works'
self.message_utf_hex = '0939093F0928094D092609400020091509300924093E00200939094800200907093800200938092E092F00200915093E092E002009390948003F'
def tearDown(self):
self.couch_user.delete()
self.domain.delete()
def testPostToIncomingAscii(self):
fake_post = {
InboundParams.SENDER: str(self.number),
InboundParams.MESSAGE: self.message_ascii,
InboundParams.MID: '00001',
InboundParams.DCS: '0'
}
response, log = post(fake_post)
self.assertEqual(200, response.status_code)
self.assertEqual(self.message_ascii, log.text)
self.assertEqual(INCOMING, log.direction)
self.assertEqual(log.backend_message_id, fake_post[InboundParams.MID])
def testPostToIncomingUtf(self):
fake_post = {
InboundParams.SENDER: str(self.number),
InboundParams.MESSAGE: self.message_utf_hex,
InboundParams.MID: '00002',
InboundParams.DCS: '8'
}
response, log = post(fake_post)
self.assertEqual(200, response.status_code)
self.assertEqual(
self.message_utf_hex.decode("hex").decode("utf_16_be"), log.text)
self.assertEqual(INCOMING, log.direction)
self.assertEqual(log.backend_message_id, fake_post[InboundParams.MID])
class BaseReminderTestCase(BaseAccountingTest, DomainSubscriptionMixin):
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.setup_subscription(self.domain_obj.name, SoftwarePlanEdition.ADVANCED)
self.sms_backend, self.sms_backend_mapping = setup_default_sms_test_backend()
def tearDown(self):
delete_domain_phone_numbers('test')
self.sms_backend_mapping.delete()
self.sms_backend.delete()
self.teardown_subscription()
self.domain_obj.delete()
class ENikshayLocationStructureMixin(object):
def setUp(self):
self.domain = getattr(self, 'domain', 'fake-domain-from-mixin')
self.project = Domain(name=self.domain)
self.project.save()
_, locations = setup_enikshay_locations(self.domain)
self.sto = locations['STO']
self.sto.metadata = {
'nikshay_code': 'MH',
}
self.sto.save()
self.dto = locations['DTO']
self.dto.metadata = {
'nikshay_code': 'ABD',
}
self.dto.save()
self.drtb_hiv = locations['DRTB-HIV']
self.drtb_hiv.save()
self.tu = locations['TU']
self.tu.metadata = {
'nikshay_code': '1',
}
self.tu.save()
self.phi = locations['PHI']
self.phi.metadata = {
'nikshay_code': '2',
'is_test': 'no',
}
self.phi.save()
super(ENikshayLocationStructureMixin, self).setUp()
def tearDown(self):
self.project.delete()
SQLLocation.objects.all().delete()
LocationType.objects.all().delete()
super(ENikshayLocationStructureMixin, self).tearDown()
def assign_person_to_location(self, location_id):
return self.create_case(
CaseStructure(case_id=self.person_id,
attrs={"update": dict(owner_id=location_id, )}))[0]
class UpdateTestCase(TestCase):
def setUp(self):
all_users = CouchUser.all()
for user in all_users:
user.delete()
User.objects.all().delete()
self.username = "******"
password = "******"
self.domain = Domain(name='my-domain')
self.domain.save()
self.couch_user = CommCareUser.create(self.domain.name, self.username,
password)
self.couch_user.save()
def testAddRemovePhoneNumbers(self):
"""
test that a basic couch user gets created properly after
saving a django user programmatically
"""
self.couch_user.add_phone_number('123123123')
self.assertEqual(self.couch_user.phone_numbers, ['123123123'])
self.couch_user.add_phone_number('321321321')
self.assertEqual(self.couch_user.phone_numbers,
['123123123', '321321321'])
def testChangeUsername(self):
new_username = '******'
self.assertEqual(
CouchUser.get_by_username(self.username).user_id,
self.couch_user.user_id)
self.assertEqual(
User.objects.filter(username=self.username).count(), 1)
self.couch_user.change_username(new_username)
self.assertEqual(CouchUser.get_by_username(self.username), None)
self.assertEqual(
CouchUser.get_by_username(new_username).user_id,
self.couch_user.user_id)
self.assertEqual(self.couch_user.get_django_user().username,
new_username)
self.assertEqual(User.objects.filter(username=new_username).count(), 1)
self.assertEqual(
User.objects.get(username=new_username).id,
self.couch_user.get_django_user().id)
self.assertEqual(
User.objects.filter(username=self.username).count(), 0)
class DeviceIdUpdateTest(ENikshayCaseStructureMixin, TestCase):
def setUp(self):
super(DeviceIdUpdateTest, self).setUp()
self.domain_obj = Domain(name=self.domain)
self.domain_obj.save()
self.web_user_username = "******"
self.web_user_password = "******"
self.web_user = WebUser.create(
self.domain,
username=self.web_user_username,
password=self.web_user_password,
)
def tearDown(self):
self.domain_obj.delete()
super(DeviceIdUpdateTest, self).tearDown()
def test_login_as(self):
self.web_user.is_superuser = True
self.web_user.save()
restore_uri = reverse('ota_restore', args=[self.domain])
auth_header = _get_auth_header(self.web_user_username,
self.web_user_password)
client = Client(HTTP_AUTHORIZATION=auth_header)
device_id = "foo"
# get the seq id before the change is published
kafka_seq = get_topic_offset(topics.SYNCLOG_SQL)
resp = client.get(restore_uri,
data={
'as': self.username,
"device_id": device_id
},
follow=True)
self.assertEqual(resp.status_code, 200)
pillow = get_user_sync_history_pillow()
pillow.process_changes(since=kafka_seq, forever=False)
restored_as_user = CommCareUser.get_by_username(self.username)
self.assertEqual(len(restored_as_user.devices), 1)
self.assertEqual(restored_as_user.devices[0].device_id, device_id)
def test_deleted_domain_exists(self):
x = Domain(name='x')
x.save()
y = Domain(name='y')
y.save()
y.delete(leave_tombstone=True)
self.addCleanup(x.delete)
self.addCleanup(y.delete)
self.assertTrue(domain_exists('x'))
self.assertFalse(deleted_domain_exists('x'))
self.assertTrue(domain_or_deleted_domain_exists('x'))
self.assertFalse(domain_exists('y'))
self.assertTrue(deleted_domain_exists('y'))
self.assertTrue(domain_or_deleted_domain_exists('y'))
self.assertTrue(len(list(iter_all_domains_and_deleted_domains_with_name('x'))), 1)
self.assertTrue(len(list(iter_all_domains_and_deleted_domains_with_name('y'))), 1)
class StateHashTest(TestCase):
def setUp(self):
delete_all_cases()
delete_all_xforms()
delete_all_sync_logs()
delete_all_users()
self.project = Domain(name='state-hash-tests-project')
self.project.save()
self.user = create_restore_user(domain=self.project.name)
# this creates the initial blank sync token in the database
generate_restore_payload(self.project, self.user)
self.sync_log = get_exactly_one_wrapped_sync_log()
@run_with_all_backends
def testEmpty(self):
empty_hash = CaseStateHash(EMPTY_HASH)
wrong_hash = CaseStateHash("thisisntright")
self.assertEqual(empty_hash, self.sync_log.get_state_hash())
response = generate_restore_response(self.project,
self.user,
self.sync_log.get_id,
version=V2)
self.assertEqual(200, response.status_code)
try:
generate_restore_payload(self.project,
self.user,
self.sync_log.get_id,
version=V2,
state_hash=str(wrong_hash))
self.fail(
"Call to generate a payload with a bad hash should fail!")
except BadStateException, e:
self.assertEqual(empty_hash, e.server_hash)
self.assertEqual(wrong_hash, e.phone_hash)
self.assertEqual(0, len(e.case_ids))
response = generate_restore_response(self.project,
self.user,
self.sync_log.get_id,
version=V2,
state_hash=str(wrong_hash))
self.assertEqual(412, response.status_code)
class TestCustomerBillingRecord(BaseAccountingTest):
def setUp(self):
super(TestCustomerBillingRecord, self).setUp()
self.billing_contact = generator.create_arbitrary_web_user_name()
self.dimagi_user = generator.create_arbitrary_web_user_name(
is_dimagi=True)
self.domain = Domain(name='test')
self.domain.save()
self.invoice_start, self.invoice_end = get_previous_month_date_range()
self.currency = generator.init_default_currency()
self.account = generator.billing_account(self.dimagi_user,
self.billing_contact)
self.account.is_customer_billing_account = True
self.account.save()
self.subscription_length = 4 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date,
self.subscription_length)
self.subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
self.invoice = CustomerInvoice(account=self.account,
date_start=self.invoice_start,
date_end=self.invoice_end,
is_hidden=False)
self.customer_billing_record = CustomerBillingRecord(
invoice=self.invoice)
def tearDown(self):
self.domain.delete()
super(TestCustomerBillingRecord, self).tearDown()
def test_should_send_email(self):
self.assertTrue(self.customer_billing_record.should_send_email)
def test_should_send_email_hidden(self):
self.assertTrue(self.customer_billing_record.should_send_email)
self.invoice.is_hidden = True
self.assertFalse(self.customer_billing_record.should_send_email)
def test_sync_format_with_disabled_toggle(self):
domain = uuid.uuid4().hex
project = Domain(name=domain)
project.save()
self.assertEqual(False, should_sync_hierarchical_fixture(project))
self.assertEqual(True, should_sync_flat_fixture(project))
# This should not happen ideally since the conf can not be set without having HIERARCHICAL_LOCATION_FIXTURE
# enabled. Considering that a domain has sync hierarchical fixture set to False without the FF
# HIERARCHICAL_LOCATION_FIXTURE. In such case the domain stays on flat fixture format
conf = LocationFixtureConfiguration.for_domain(domain)
conf.sync_hierarchical_fixture = False
conf.sync_flat_fixture = True # default value
conf.save()
self.assertEqual(False, should_sync_hierarchical_fixture(project))
self.assertEqual(True, should_sync_flat_fixture(project))
self.addCleanup(project.delete)
def test_web_user(self):
from corehq.apps.users.models import WebUser
other_domain = Domain(name='other-domain')
other_domain.save()
self.addCleanup(other_domain.delete)
web_user = WebUser.create(
domain=self.domain_name,
username='******',
password='******',
email='*****@*****.**',
)
other_user = WebUser.create(
domain='other-domain',
username='******',
password='******',
email='*****@*****.**',
)
self._dump_and_load([web_user], [other_user])
