def setUpClass(cls):
super().setUpClass()
billing_contact = accounting_generator.create_arbitrary_web_user_name()
dimagi_user = accounting_generator.create_arbitrary_web_user_name(is_dimagi=True)
plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.ADVANCED)
account_no_hubspot = accounting_generator.billing_account(
dimagi_user, billing_contact
)
account_no_hubspot.block_hubspot_data_for_all_users = True
account_no_hubspot.save()
cls.domain_no_hubspot = Domain.get_or_create_with_name(
"domain-no-hubspot-001",
is_active=True
)
cls.subscription_no_hubspot = Subscription.new_domain_subscription(
account=account_no_hubspot,
domain=cls.domain_no_hubspot.name,
plan_version=plan,
)
regular_account = accounting_generator.billing_account(
dimagi_user, billing_contact
)
cls.regular_domain = Domain.get_or_create_with_name(
"domain-with-analytics-001",
is_active=True
)
cls.regular_subscription = Subscription.new_domain_subscription(
account=regular_account,
domain=cls.regular_domain.name,
plan_version=plan,
)
def setUpClass(cls):
super().setUpClass()
cls.account = generator.get_billing_account_for_idp()
cls.domain = Domain.get_or_create_with_name("helping-earth-001",
is_active=True)
enterprise_plan = generator.get_enterprise_plan()
Subscription.new_domain_subscription(
account=cls.account,
domain=cls.domain.name,
plan_version=enterprise_plan,
)
cls.user = WebUser.create(cls.domain.name, '*****@*****.**',
'testpwd', None, None)
cls.idp = generator.create_idp('helping-earth', cls.account)
cls.idp.is_active = True
cls.idp.save()
AuthenticatedEmailDomain.objects.create(
email_domain='helpingearth.org',
identity_provider=cls.idp,
)
cls.domain_created_by_user = Domain.get_or_create_with_name(
"my-test-project", is_active=True)
cls.domain_created_by_user.creating_user = cls.user.username
cls.domain_created_by_user.save()
cls.external_domain = Domain.get_or_create_with_name("vaultwax-001",
is_active=True)
cls.user_without_idp = WebUser.create(cls.external_domain.name,
'*****@*****.**', 'testpwd',
None, None)
def setUpClass(cls):
super().setUpClass()
delete_all_users()
cls.domain_name = 'mydomain'
cls.domain = Domain.get_or_create_with_name(name=cls.domain_name)
cls.other_domain = Domain.get_or_create_with_name(name='other-domain')
permissions = Permissions(edit_apps=True, view_reports=True)
cls.role = UserRole.get_or_create_with_permissions(
cls.domain.name, permissions, 'edit-apps')
def setUpClass(cls):
super(APIResourceTest, cls).setUpClass()
Role.get_cache().clear()
cls.domain = Domain.get_or_create_with_name('qwerty', is_active=True)
cls.list_endpoint = cls._get_list_endpoint()
cls.username = '******'
cls.password = '******'
cls.user = WebUser.create(cls.domain.name,
cls.username,
cls.password,
None,
None,
email='*****@*****.**',
first_name='rudolph',
last_name='commcare')
cls.user.set_role(cls.domain.name, 'admin')
cls.user.save()
cls.account = BillingAccount.get_or_create_account_by_domain(
cls.domain.name, created_by="automated-test")[0]
plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.ADVANCED)
cls.subscription = Subscription.new_domain_subscription(
cls.account, cls.domain.name, plan)
cls.subscription.is_active = True
cls.subscription.save()
cls.api_key, _ = HQApiKey.objects.get_or_create(
user=WebUser.get_django_user(cls.user))
def setUpClass(cls):
super().setUpClass()
cls.domain2 = 'api-test-other'
cls.project2 = Domain.get_or_create_with_name(cls.domain2,
is_active=True)
cls.user.add_domain_membership(cls.domain2, is_admin=True)
cls.user.save()
def handle(self, *args, **options):
from corehq.apps.users.models import WebUser
if len(args) != 3:
raise CommandError('Usage: manage.py bootstrap <domain> <email> <password>')
domain_name, username, passwd = args
domain = Domain.get_or_create_with_name(domain_name, is_active=True, use_sql_backend=True)
couch_user = WebUser.get_by_username(username)
membership = None
if couch_user:
if not isinstance(couch_user, WebUser):
raise CommandError('Username already in use by a non-web user')
membership = couch_user.get_domain_membership(domain_name)
else:
couch_user = WebUser.create(domain_name, username, passwd)
if not membership:
couch_user.add_domain_membership(domain_name, is_admin=True)
couch_user.is_superuser = True
couch_user.is_staff = True
couch_user.save()
print("user %s created and added to domain %s" % (couch_user.username, domain))
if not getattr(settings, 'BASE_ADDRESS', None):
print ("Warning: You must set BASE_ADDRESS setting "
"in your localsettings.py file in order for commcare-hq "
"to be able to generate absolute urls. "
"This is necessary for a number of features.")
def setUp(self):
super(CaseObjectCacheTest, self).setUp()
self.domain = Domain.get_or_create_with_name(TEST_DOMAIN_NAME, is_active=True)
self.user = WebUser.create(TEST_DOMAIN_NAME, TEST_USER, TEST_PASSWORD, None, None)
self.user.set_role(self.domain.name, 'admin')
self.user.save()
self.interface = FormProcessorInterface(TEST_DOMAIN_NAME)
def setUp(self):
domain = Domain.get_or_create_with_name('test_domain')
filename = os.path.join(settings.BASE_DIR, 'custom', 'openclinica',
'tests', 'data', 'test_metadata.xml')
command = Command()
command.handle('test_domain', 'test_app', filename)
self.app = domain.full_applications(include_builds=False)[0]
def handle(self, *args, **options):
from corehq.apps.users.models import WebUser
if len(args) != 3:
raise CommandError('Usage: manage.py bootstrap <domain> <email> <password>')
domain_name, username, passwd = args
domain = Domain.get_or_create_with_name(domain_name, is_active=True)
couch_user = WebUser.get_by_username(username)
membership = None
if couch_user:
if not isinstance(couch_user, WebUser):
raise CommandError('Username already in use by a non-web user')
membership = couch_user.get_domain_membership(domain_name)
else:
couch_user = WebUser.create(domain_name, username, passwd)
if not membership:
couch_user.add_domain_membership(domain_name, is_admin=True)
couch_user.is_superuser = True
couch_user.is_staff = True
couch_user.save()
print "user %s created and added to domain %s" % (couch_user.username, domain)
if not getattr(settings, 'BASE_ADDRESS', None):
print ("Warning: You must set BASE_ADDRESS setting "
"in your localsettings.py file in order for commcare-hq "
"to be able to generate absolute urls. "
"This is necessary for a number of features.")
def create_sql_domain(name):
return Domain.get_or_create_with_name(
name,
is_active=True,
secure_submissions=False,
use_sql_backend=True,
)
def setUpClass(cls):
super(TestZapierIntegration, cls).setUpClass()
generator.instantiate_accounting()
cls.domain_object = Domain.get_or_create_with_name(TEST_DOMAIN,
is_active=True)
cls.domain = cls.domain_object.name
account = BillingAccount.get_or_create_account_by_domain(
cls.domain, created_by="automated-test")[0]
plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.STANDARD)
subscription = Subscription.new_domain_subscription(
account, cls.domain, plan)
subscription.is_active = True
subscription.save()
cls.web_user = WebUser.create(cls.domain, 'test', '******')
api_key_object, _ = ApiKey.objects.get_or_create(
user=cls.web_user.get_django_user())
cls.api_key = api_key_object.key
cls.application = Application.new_app(cls.domain, 'Test App')
cls.application.save()
module = cls.application.add_module(Module.new_module(
"Module 1", "en"))
cls.application.new_form(module.id,
name="Form1",
attachment=XFORM,
lang="en")
cls.application.save()
def test_login_with_wrong_domain(self):
project = Domain.get_or_create_with_name('api-test-fail',
is_active=True)
self.addCleanup(project.delete)
self.assertAuthenticationFail(
self.require_edit_data,
self._get_request_with_api_key(domain=project.name))
def test_cache_cleanup_when_domain_subscription_changes(self):
"""
Ensure that the cache for IdentityProvider.does_domain_trust_this_idp
is cleared when the status of a domain's subscription changes.
"""
domain = Domain.get_or_create_with_name("vaultwax-001", is_active=True)
self.addCleanup(lambda: domain.delete())
enterprise_plan = generator.get_enterprise_plan()
self.assertFalse(self.idp.does_domain_trust_this_idp(domain.name))
sub = Subscription.new_domain_subscription(
self.idp.owner,
domain.name,
enterprise_plan,
)
self.assertTrue(self.idp.does_domain_trust_this_idp(domain.name))
sub.is_active = False
sub.save()
self.assertFalse(self.idp.does_domain_trust_this_idp(domain.name))
sub.is_active = True
sub.save()
self.assertTrue(self.idp.does_domain_trust_this_idp(domain.name))
SubscriptionAdjustment.objects.all().delete()
Subscription.visible_and_suppressed_objects.all().delete()
self.assertFalse(self.idp.does_domain_trust_this_idp(domain.name))
def setUpClass(cls):
super(TestPaginateReleases, cls).setUpClass()
cls.client = Client()
cls.domain_name = "fandago"
cls.domain = Domain.get_or_create_with_name(cls.domain_name, is_active=True)
cls.username = '******'
cls.password = '******'
cls.user = WebUser.create(cls.domain.name, cls.username, cls.password, None, None, is_admin=True)
cls.user.eula.signed = True
cls.user.save()
factory = AppFactory(cls.domain_name, name="cheeto")
m0, f0 = factory.new_basic_module("register", "cheeto")
f0.source = get_simple_form(xmlns=f0.unique_id)
cls.app = factory.app
cls.app.target_commcare_flavor = 'commcare_lts'
cls.app.save()
cls.app_build = cls.app.make_build()
cls.app_build.is_released = True
cls.app_build.save()
# publish app and build to ES
es = get_es_new()
initialize_index_and_mapping(es, APP_INDEX_INFO)
send_to_elasticsearch('apps', cls.app.to_json())
send_to_elasticsearch('apps', cls.app_build.to_json())
es.indices.refresh(APP_INDEX_INFO.index)
def setUpClass(cls):
super(TestAppGetters, cls).setUpClass()
cls.project = Domain.get_or_create_with_name(cls.domain)
factory = AppFactory(cls.domain, name='foo')
m0, f0 = factory.new_basic_module("bar", "bar")
f0.source = get_simple_form(xmlns=f0.unique_id)
app = factory.app
app.version = 1
# Make builds v1 - v5. Builds v2 and v4 are released.
app.save() # app is v2
cls.v2_build = app.make_build()
cls.v2_build.is_released = True
cls.v2_build.save()
app.save() # app is v3
app.make_build().save()
app.save() # app is v4
cls.v4_build = app.make_build()
cls.v4_build.is_released = True
cls.v4_build.save()
app.save() # app is v5
cls.app_id = app._id
def setUpClass(cls):
super(TestUCLACustomHandler, cls).setUpClass()
cls.domain = Domain.get_or_create_with_name(cls.domain_name,
is_active=True)
email = '*****@*****.**'
cls.user = WebUser.create(cls.domain_name, email, '***', email=email)
cls.user.save()
def setUp(self):
self.domain = Domain.get_or_create_with_name('qwerty', is_active=True)
self.username = '******'
self.password = '******'
self.web_user = WebUser.create(self.domain.name, self.username,
self.password, None, None)
self.user = self.web_user.get_django_user()
def setUpClass(cls):
super().setUpClass()
cls.account = generator.get_billing_account_for_idp()
cls.domain = Domain.get_or_create_with_name(
"vaultwax-001",
is_active=True
)
# this Identity Provider will be the main subject of the test
cls.idp = IdentityProvider.objects.create(
owner=cls.account,
name='Azure AD for Vault Wax',
slug='vaultwax',
created_by='*****@*****.**',
last_modified_by='*****@*****.**',
)
cls.idp.create_service_provider_certificate()
# secondary Identity Provider to test some edge cases
cls.other_idp = IdentityProvider.objects.create(
owner=cls.account,
name='Azure AD for VWX',
slug='vwx',
created_by='*****@*****.**',
last_modified_by='*****@*****.**',
)
cls.other_idp.create_service_provider_certificate()
def test_wrong_domain(self):
'''
If correct credentials for a user in a different domain are submitted, the response is forbidden
'''
wrong_domain = Domain.get_or_create_with_name('dvorak', is_active=True)
self.addCleanup(wrong_domain.delete)
# have to set up subscription for the bad domain or it will fail on authorization
new_account = BillingAccount.get_or_create_account_by_domain(
wrong_domain.name, created_by="automated-test")[0]
plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.ADVANCED)
new_subscription = Subscription.new_domain_subscription(
new_account, wrong_domain.name, plan)
new_subscription.is_active = True
new_subscription.save()
wrong_list_endpoint = reverse(
'api_dispatch_list',
kwargs=dict(domain=wrong_domain.name,
api_name=self.api_name,
resource_name=self.resource.Meta.resource_name))
response = self.client.post(wrong_list_endpoint, {
'username': self.username,
'password': self.password
})
self.assertEqual(response.status_code, 403)
def setUp(self):
self.domain = Domain.get_or_create_with_name("qwerty", is_active=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()
def setUp(self):
self.domain = Domain.get_or_create_with_name('qwerty', is_active=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()
def setUpClass(cls):
cls.domain = Domain.get_or_create_with_name(DOMAIN, is_active=True)
cls.domain.commtrack_enabled = True
cls.domain.save()
cls.user = CommCareUser(domain=DOMAIN,
domain_membership=DomainMembership(
domain=DOMAIN, location_id='1'))
cls.restore_user = cls.user.to_ota_restore_user()
def setUpClass(cls):
super().setUpClass()
delete_all_users()
cls.domain_name = 'mydomain'
cls.domain = Domain.get_or_create_with_name(name=cls.domain_name)
cls.other_domain = Domain.get_or_create_with_name(name='other-domain')
cls.uploading_user = WebUser.create(cls.domain_name,
"*****@*****.**",
'password',
None,
None,
is_superuser=True)
permissions = Permissions(edit_apps=True,
view_apps=True,
view_reports=True)
cls.role = UserRole.get_or_create_with_permissions(
cls.domain.name, permissions, 'edit-apps')
cls.other_role = UserRole.get_or_create_with_permissions(
cls.domain.name, permissions, 'admin')
cls.patcher = patch('corehq.apps.user_importer.tasks.UserUploadRecord')
cls.patcher.start()
cls.definition = CustomDataFieldsDefinition(
domain=cls.domain_name, field_type=UserFieldsView.field_type)
cls.definition.save()
cls.definition.set_fields([
Field(
slug='key',
is_required=False,
label='Key',
regex='^[A-G]',
regex_msg='Starts with A-G',
),
Field(slug='mode',
is_required=False,
label='Mode',
choices=['major', 'minor']),
])
cls.definition.save()
cls.profile = CustomDataFieldsProfile(
name='melancholy',
fields={'mode': 'minor'},
definition=cls.definition,
)
cls.profile.save()
def setUp(self):
self.domain = Domain.get_or_create_with_name(TEST_DOMAIN_NAME, is_active=True)
self.user = WebUser.create(TEST_DOMAIN_NAME, TEST_USER, TEST_PASSWORD)
self.user.set_role(self.domain.name, 'admin')
self.user.save()
delete_all_cases()
delete_all_xforms()
time.sleep(1)
def setUpClass(cls):
super(TestEmailEnterpriseReport, cls).setUpClass()
cls.domain = Domain.get_or_create_with_name('test', is_active=True)
cls.couch_user = WebUser.create(cls.domain.name, "enterprise-tasks-tests", "*******", None, None,
is_admin=True)
cls.couch_user.save()
cls.billing_account = BillingAccount.get_or_create_account_by_domain(cls.domain.name,
created_by=cls.domain.name)[0]
def setUpClass(cls):
super().setUpClass()
delete_all_users()
cls.domain_name = 'mydomain'
cls.domain = Domain.get_or_create_with_name(name=cls.domain_name)
cls.other_domain = Domain.get_or_create_with_name(name='other-domain')
permissions = Permissions(edit_apps=True,
view_apps=True,
view_reports=True)
cls.role = UserRole.get_or_create_with_permissions(
cls.domain.name, permissions, 'edit-apps')
cls.other_role = UserRole.get_or_create_with_permissions(
cls.domain.name, permissions, 'admin')
cls.other_domain_role = UserRole.get_or_create_with_permissions(
cls.other_domain.name, permissions, 'view-apps')
cls.patcher = patch('corehq.apps.user_importer.tasks.UserUploadRecord')
cls.patcher.start()
def setUpClass(cls):
super().setUpClass()
cls.account = generator.get_billing_account_for_idp()
cls.domain = Domain.get_or_create_with_name("vaultwax-001",
is_active=True)
cls.accounting_admin = WebUser.create(cls.domain.name,
'*****@*****.**', 'testpwd',
None, None)
def setUpClass(cls):
cls.domain = Domain.get_or_create_with_name(DOMAIN, is_active=True)
cls.domain.commtrack_enabled = True
cls.domain.save()
cls.user = CommCareUser(
domain=DOMAIN,
domain_membership=DomainMembership(domain=DOMAIN, location_id="1", assigned_location_ids=["1"]),
)
cls.restore_user = cls.user.to_ota_restore_user()
def setUp(self):
self.domain = 'test-domain'
Domain.get_or_create_with_name(self.domain)
self.app = Application.new_app("test_domain", "TestApp", application_version=APP_V1)
for i in range(3):
module = self.app.new_module("Module%d" % i, "en")
for j in range(3):
self.app.new_form(module.id, name="Form%s-%s" % (i,j), attachment=self.xform_str, lang="en")
module = self.app.get_module(i)
detail = module.get_detail("ref_short")
detail.append_column(
DetailColumn(name={"en": "test"}, model="case", field="test", format="plain", enum={})
)
detail.append_column(
DetailColumn(name={"en": "age"}, model="case", field="age", format="years-ago", enum={})
)
self.app.save()
def setUpClass(cls):
delete_all_cases()
cls.project = Domain.get_or_create_with_name(cls.project_name,
is_active=True)
cls.project.save()
cls.elasticsearch = get_es_new()
reset_es_index(XFORM_INDEX_INFO)
reset_es_index(CASE_INDEX_INFO)
reset_es_index(CASE_SEARCH_INDEX_INFO)
def setUpClass(cls):
cls.project = Domain.get_or_create_with_name(
cls.project_name,
is_active=True,
use_sql_backend=cls.use_sql_backend)
cls.project.save()
cls.elasticsearch = get_es_new()
reset_es_index(XFORM_INDEX_INFO)
reset_es_index(CASE_INDEX_INFO)
def setUp(self):
self.domain = Domain.get_or_create_with_name(TEST_DOMAIN_NAME,
is_active=True)
self.user = WebUser.create(TEST_DOMAIN_NAME, TEST_USER, TEST_PASSWORD)
self.user.set_role(self.domain.name, 'admin')
self.user.save()
delete_all_cases()
delete_all_xforms()
time.sleep(1)
def setUp(self):
self.domain = Domain.get_or_create_with_name(TEST_DOMAIN, is_active=True)
self.user = WebUser.create(TEST_DOMAIN, TEST_USER, TEST_PASSWORD)
self.user.set_role(self.domain.name, 'admin')
self.user.save()
for item in CommCareCase.view("case/by_user", include_docs=True, reduce=False).all():
item.delete()
for item in get_all_forms_in_all_domains():
item.delete()
time.sleep(1)
def setUpClass(cls):
super().setUpClass()
cls.client = Client()
cls.forwarding_url = 'http://not-a-real-url-at-all'
cls.domain = 'bedazzled'
cls.domain_obj = Domain.get_or_create_with_name(cls.domain)
# DATA_FORWARDING is on PRO and above
cls.setup_subscription(cls.domain, SoftwarePlanEdition.PRO)
def test_auth(self):
wrong_domain = Domain.get_or_create_with_name('dvorak', is_active=True)
new_user = WebUser.create(wrong_domain.name, 'test', 'testpass')
new_user.save()
self.addCleanup(wrong_domain.delete)
self.addCleanup(new_user.delete)
response = self._assert_auth_get_resource(self.single_endpoint(self.report_configuration._id),
username='******', password='******')
self.assertEqual(response.status_code, 403) # 403 is "Forbidden"
def setUpClass(cls):
cls.domain = Domain.get_or_create_with_name('qwerty', is_active=True)
cls.list_endpoint = reverse('api_dispatch_list',
kwargs=dict(domain=cls.domain.name,
api_name=cls.api_name,
resource_name=cls.resource.Meta.resource_name))
cls.username = '******'
cls.password = '******'
cls.user = WebUser.create(cls.domain.name, cls.username, cls.password)
cls.user.set_role(cls.domain.name, 'admin')
cls.user.save()
def setUp(self):
self.maxDiff = None
self.domain = Domain.get_or_create_with_name('qwerty', is_active=True)
self.list_endpoint = reverse('api_dispatch_list', kwargs=dict(domain=self.domain.name,
api_name=self.api_name,
resource_name=self.resource.Meta.resource_name))
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 setUp(self):
self.domain = Domain.get_or_create_with_name('qwerty', is_active=True)
self.username = '******'
self.password = '******'
self.admin_user = WebUser.create(self.domain.name, self.username, self.password)
self.admin_user.set_role(self.domain.name, 'admin')
self.admin_user.save()
self.fake_user_es = FakeUserES()
v0_5.MOCK_BULK_USER_ES = self.mock_es_wrapper
self.make_users()
def setUpClass(cls):
cls.domain = Domain.get_or_create_with_name('qwerty', is_active=True)
cls.username = '******'
cls.password = '******'
cls.admin_user = WebUser.create(cls.domain.name, cls.username, cls.password)
cls.admin_user.set_role(cls.domain.name, 'admin')
cls.admin_user.save()
cls.fake_user_es = FakeUserES()
v0_5.MOCK_BULK_USER_ES = cls.mock_es_wrapper
cls.make_users()
def setUp(self):
self.domain = Domain.get_or_create_with_name('qwerty', is_active=True)
self.username = '******'
self.password = '******'
self.admin_user = WebUser.create(self.domain.name, self.username, self.password)
self.admin_user.set_role(self.domain.name, 'admin')
self.admin_user.save()
self.fake_user_es = FakeUserES()
v0_5.MOCK_BULK_USER_ES = self.mock_es_wrapper
self.make_users()
def setUpClass(cls):
domain = 'apptest'
cls.domain = Domain.get_or_create_with_name(domain, is_active=True)
cls.cc_2_build = add_build(version='2.7.0', build_number=20655)
with open(os.path.join(os.path.dirname(__file__), 'data', 'yesno.json')) as f:
source = json.load(f)
cls.app = Application.wrap(source)
cls.app.domain = domain
cls.app.save()
cls.build = cls.app.make_build()
cls.build.save(increment_version=False)
def setUpClass(cls):
super(TestUCLACustomHandler, cls).setUpClass()
cls.domain = Domain.get_or_create_with_name(cls.domain_name, is_active=True)
email = '*****@*****.**'
cls.user = WebUser.create(cls.domain_name, email, '***', email=email)
cls.user.save()
cls.schedule = TimedSchedule.create_simple_daily_schedule(
cls.domain_name,
TimedEvent(time=time(12, 0)),
CustomContent(custom_content_id='UCLA_GENERAL_HEALTH'),
)
def test_wrong_domain(self):
'''
If correct credentials for a user in a different domain are submitted, the response is forbidden
'''
wrong_domain = Domain.get_or_create_with_name('dvorak', is_active=True)
wrong_list_endpoint = reverse('api_dispatch_list', kwargs=dict(domain=wrong_domain.name,
api_name=self.api_name,
resource_name=self.resource.Meta.resource_name))
response = self.client.post(wrong_list_endpoint, {'username': self.username, 'password': self.password})
self.assertEqual(response.status_code, 403)
wrong_domain.delete()
def bootrap_domain_for_zapier(domain_name):
domain_object = Domain.get_or_create_with_name(domain_name, is_active=True)
account = BillingAccount.get_or_create_account_by_domain(domain_name, created_by="automated-test")[0]
plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.STANDARD)
subscription = Subscription.new_domain_subscription(account, domain_name, plan)
subscription.is_active = True
subscription.save()
web_user = WebUser.create(domain_name, 'test', '******')
api_key_object, _ = ApiKey.objects.get_or_create(user=web_user.get_django_user())
return ZapierDomainConfig(domain_object, web_user, api_key_object.key)
def test_user_does_not_have_access(self):
fake_domain = Domain.get_or_create_with_name('fake', is_active=True)
fake_user = WebUser.create('fake', 'faker2', '******')
self.addCleanup(fake_domain.delete)
self.addCleanup(fake_user.delete)
query_string = "?domain=fruit&case_type=fake&user_id=test_user&user=faker2&owner_id=test_user"
response = self.client.post(reverse(ZapierCreateCase.urlname,
kwargs={'domain': self.domain}) + query_string,
data=json.dumps(self.data),
content_type='application/json',
HTTP_AUTHORIZATION='ApiKey test:{}'.format(self.api_key))
self.assertEqual(response.status_code, 403)
def setUp(self):
self.factory = RequestFactory()
domain = Domain.get_or_create_with_name('champ-cameroon')
domain.is_active = True
domain.save()
self.domain = domain
user = WebUser.all().first()
if not user:
user = WebUser.create(domain.name, 'test', 'passwordtest')
user.is_authenticated = True
user.is_superuser = True
user.is_authenticated = True
user.is_active = True
self.user = user
def test_superuser(self):
"""
Tests superuser overrides authorization
:return:
"""
community_domain = Domain.get_or_create_with_name('dvorak', is_active=True)
new_user = WebUser.create(community_domain.name, 'test', 'testpass', is_superuser=True)
new_user.save()
self.addCleanup(new_user.delete)
self.addCleanup(community_domain.delete)
response = self._assert_auth_get_resource(self.list_endpoint, username='******', password='******')
self.assertEqual(response.status_code, 200)
def setUp(self):
self.factory = RequestFactory()
domain = Domain.get_or_create_with_name('test-pna')
domain.is_active = True
domain.save()
self.domain = domain
user = WebUser.get_by_username('test')
if not user:
user = WebUser.create(domain.name, 'test', 'passwordtest')
user.is_authenticated = True
user.is_superuser = True
user.is_authenticated = True
user.is_active = True
self.user = user
def setUp(self):
self.maxDiff = None
self.domain = Domain.get_or_create_with_name("qwerty", is_active=True)
self.list_endpoint = reverse(
"api_dispatch_list",
kwargs=dict(
domain=self.domain.name, api_name=self.api_name, resource_name=self.resource.Meta.resource_name
),
)
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 test_no_subscription(self):
"""
Tests authorization function properly blocks domains without proper subscription
:return:
"""
community_domain = Domain.get_or_create_with_name('dvorak', is_active=True)
new_user = WebUser.create(community_domain.name, 'test', 'testpass')
new_user.save()
self.addCleanup(new_user.delete)
self.addCleanup(community_domain.delete)
response = self._assert_auth_get_resource(self.list_endpoint, username='******', password='******')
self.assertEqual(response.status_code, 403)
def setUpClass(cls):
cls.domain = Domain.get_or_create_with_name(DOMAIN, is_active=True)
cls.user = CommCareUser.create(DOMAIN, 'bob', 'mechanic')
cls.group1 = Group(domain=DOMAIN, name='group1', case_sharing=True, users=[cls.user._id])
cls.group1.save()
cls.group2 = Group(domain=DOMAIN, name='group2', case_sharing=True, users=[cls.user._id])
cls.group2.save()
cls.item_lists = {
SA_PROVINCES: make_item_lists(SA_PROVINCES, 'western cape'),
FR_PROVINCES: make_item_lists(FR_PROVINCES, 'burgundy'),
}
cls.casexml_user = cls.user.to_casexml_user()
def test_superuser(self):
"""
Tests superuser overrides authorization
:return:
"""
community_domain = Domain.get_or_create_with_name("dvorak", is_active=True)
new_user = WebUser.create(community_domain.name, "test", "testpass", is_superuser=True)
new_user.save()
self.client.login(username="******", password="******")
response = self.client.get(self.list_endpoint)
self.assertEqual(response.status_code, 200)
community_domain.delete()
new_user.delete()
def test_no_subscription(self):
"""
Tests authorization function properly blocks domains without proper subscription
:return:
"""
community_domain = Domain.get_or_create_with_name("dvorak", is_active=True)
new_user = WebUser.create(community_domain.name, "test", "testpass")
new_user.save()
self.client.login(username="******", password="******")
response = self.client.get(self.list_endpoint)
self.assertEqual(response.status_code, 401)
community_domain.delete()
new_user.delete()
def setUpClass(cls):
Role.get_cache().clear()
generator.instantiate_accounting_for_tests()
cls.domain = Domain.get_or_create_with_name("qwerty", is_active=True)
cls.username = "******"
cls.password = "******"
cls.admin_user = WebUser.create(cls.domain.name, cls.username, cls.password)
cls.admin_user.set_role(cls.domain.name, "admin")
cls.admin_user.save()
cls.fake_user_es = FakeUserES()
v0_5.MOCK_BULK_USER_ES = cls.mock_es_wrapper
cls.make_users()
set_up_subscription(cls)
cls.domain = Domain.get(cls.domain._id)
def setUpClass(cls):
super(TestZapierCreateCaseAction, cls).setUpClass()
cls.domain_object = Domain.get_or_create_with_name('fruit', is_active=True)
cls.domain = cls.domain_object.name
account = BillingAccount.get_or_create_account_by_domain(cls.domain, created_by="automated-test")[0]
plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.STANDARD)
subscription = Subscription.new_domain_subscription(account, cls.domain, plan)
subscription.is_active = True
subscription.save()
cls.query_string = "?domain=fruit&case_type=watermelon&owner_id=test_user&user=test"
cls.data = {'case_name': 'test1', 'price': '11'}
cls.accessor = CaseAccessors(cls.domain)
cls.user = WebUser.create(cls.domain, 'test', '******')
api_key_object, _ = ApiKey.objects.get_or_create(user=cls.user.get_django_user())
cls.api_key = api_key_object.key
def setUpClass(cls):
Role.get_cache().clear()
generator.instantiate_accounting_for_tests()
cls.domain = Domain.get_or_create_with_name("qwerty", is_active=True)
cls.list_endpoint = reverse(
"api_dispatch_list",
kwargs=dict(domain=cls.domain.name, api_name=cls.api_name, resource_name=cls.resource.Meta.resource_name),
)
cls.username = "******"
cls.password = "******"
cls.user = WebUser.create(cls.domain.name, cls.username, cls.password)
cls.user.set_role(cls.domain.name, "admin")
cls.user.save()
set_up_subscription(cls)
cls.domain = Domain.get(cls.domain._id)
def test_no_subscription(self):
"""
Tests authorization function properly blocks domains without proper subscription
:return:
"""
community_domain = Domain.get_or_create_with_name('dvorak', is_active=True)
new_user = WebUser.create(community_domain.name, 'test2', 'testpass')
new_user.save()
c = Client()
c.login(**{'username': '******', 'password': '******'})
f = get_form()
_submit_form(f, community_domain.name)
resp = get_export_response(c, domain=community_domain.name)
self.assertEqual(401, resp.status_code)
community_domain.delete()
new_user.delete()
def setUpClass(cls):
super(BulkAsyncIndicatorProcessingTest, cls).setUpClass()
domain_name = "bulk_async_indicator_processing"
cls.domain = Domain.get_or_create_with_name(domain_name, is_active=True)
def _make_config(indicators):
return DataSourceConfiguration(
domain=domain_name,
display_name='foo',
referenced_doc_type='CommCareCase',
table_id=clean_table_name(domain_name, str(uuid.uuid4().hex)),
configured_indicators=indicators
)
cls.config1 = _make_config(
[{
"type": "expression",
"expression": {
"type": "property_name",
"property_name": 'name'
},
"column_id": 'name',
"display_name": 'name',
"datatype": "string"
}]
)
cls.config1.save()
cls.config2 = _make_config(
[{
"type": "expression",
"expression": {
"type": "property_name",
"property_name": 'color'
},
"column_id": 'color',
"display_name": 'color',
"datatype": "string"
}]
)
cls.config2.save()
cls.adapters = []
for config in [cls.config1, cls.config2]:
adapter = get_indicator_adapter(config, raise_errors=True)
adapter.build_table()
cls.adapters.append(adapter)
