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