def setUpClass(cls): super(GetRestoreUserTest, cls).setUpClass() cls.project = Domain(name=cls.domain) cls.project.save() cls.other_project = Domain(name=cls.other_domain) cls.other_project.save() cls.web_user = WebUser.create( username='******', domain=cls.domain, password='******', ) cls.commcare_user = CommCareUser.create( username=format_username('jane', cls.domain), domain=cls.domain, password='******', ) cls.other_commcare_user = CommCareUser.create( username=format_username('john', cls.domain), domain=cls.domain, password='******', ) cls.super_user = WebUser.create( username='******', domain=cls.other_domain, password='******', ) cls.super_user.is_superuser = True cls.super_user.save()
def setUpClass(cls): cls.domain = 'my-test-views' cls.username = '******' cls.regular_name = 'ron' cls.password = '******' cls.user = WebUser.create(cls.domain, cls.username, cls.password, is_active=True) cls.user.is_superuser = True cls.user.save() cls.mobile_worker = CommCareUser.create('potter', '*****@*****.**', '123') cls.regular = WebUser.create(cls.domain, cls.regular_name, cls.password, is_active=True)
def setUpClass(cls): super(RestorePermissionsTest, cls).setUpClass() cls.other_project = Domain(name=cls.other_domain) cls.other_project.save() cls.web_user = WebUser.create( username='******', domain=cls.domain, password='******', ) cls.super_user = WebUser.create( username='******', domain=cls.other_domain, password='******', ) cls.super_user.is_superuser = True cls.super_user.save() cls.commcare_user = CommCareUser.create( username=format_username('super', cls.domain), domain=cls.domain, password='******', ) cls.no_edit_commcare_user = CommCareUser.create( username=format_username('noedit', cls.domain), domain=cls.domain, password='******', ) cls.location_user = CommCareUser.create( username=format_username('location', cls.domain), domain=cls.domain, password='******', ) cls.wrong_location_user = CommCareUser.create( username=format_username('wrong-location', cls.domain), domain=cls.domain, password='******', ) cls.web_location_user = WebUser.create( username='******', domain=cls.domain, password='******', ) cls.commcare_user.set_location(cls.locations['usa']) cls.web_location_user.set_location(cls.domain, cls.locations['usa']) cls.no_edit_commcare_user.set_location(cls.locations['usa']) cls.location_user.set_location(cls.locations['ma']) cls.wrong_location_user.set_location(cls.locations['montreal']) cls.restrict_user_to_assigned_locations(cls.commcare_user) cls.restrict_user_to_assigned_locations(cls.web_location_user)
def setUpClass(cls): super(AuthenticateAsIntegrationTest, cls).setUpClass() cls.domain = Domain(name="my-test-views") cls.domain.save() cls.username = "******" cls.regular_name = "ron" cls.password = "******" cls.user = WebUser.create(cls.domain.name, cls.username, cls.password, is_active=True) cls.user.is_superuser = True cls.user.save() cls.mobile_worker = CommCareUser.create("potter", "*****@*****.**", "123") cls.regular = WebUser.create(cls.domain.name, cls.regular_name, cls.password, is_active=True)
def testDomainMemberships(self): w_username = "******" w_email = "*****@*****.**" w2_username = "******" w2_email = "*****@*****.**" cc_username = "******" password = "******" domain = "test-domain" # check that memberships are added on creation webuser = WebUser.create(domain, w_username, password, w_email) webuser2 = WebUser.create('nodomain', w2_username, password, w2_email) ccuser = CommCareUser.create(domain, cc_username, password) self.assertEquals(webuser.is_member_of('test-domain'), True) self.assertEquals(ccuser.is_member_of('test-domain'), True) # getting memberships self.assertEquals(webuser.get_domain_membership(domain).domain, domain) self.assertEquals(ccuser.get_domain_membership(domain).domain, domain) permission_to = 'view_reports' self.assertEquals(webuser.has_permission(domain, permission_to), False) self.assertEquals(ccuser.has_permission(domain, permission_to), False) webuser.set_role(domain, "field-implementer") ccuser.set_role(domain, "field-implementer") self.assertEquals( webuser.get_domain_membership(domain).role_id, ccuser.get_domain_membership(domain).role_id) self.assertEquals(webuser.role_label(), ccuser.role_label()) self.assertEquals(webuser.has_permission(domain, permission_to), True) self.assertEquals(ccuser.has_permission(domain, permission_to), True) self.assertEquals(webuser.is_domain_admin(domain), False) self.assertEquals(ccuser.is_domain_admin(domain), False) # deleting memberships webuser.delete_domain_membership(domain) with self.assertRaises(NotImplementedError): ccuser.delete_domain_membership(domain) self.assertEquals(webuser.is_member_of(domain), False) self.assertEquals(webuser2.is_member_of(domain), False) self.assertEquals(ccuser.is_member_of(domain), True) self.assertEquals(ccuser.get_domain_membership(domain).domain, domain) webuser.add_domain_membership(domain) webuser.transfer_domain_membership(domain, webuser2) self.assertEquals(webuser.is_member_of(domain), False) self.assertEquals(webuser2.is_member_of(domain), True)
def setUpClass(cls): super(SchedulingRecipientTest, cls).setUpClass() cls.domain_obj = create_domain(cls.domain) cls.location_types = setup_location_types(cls.domain, ['country', 'state', 'city']) cls.country_location = make_loc('usa', domain=cls.domain, type='country') cls.state_location = make_loc('ma', domain=cls.domain, type='state', parent=cls.country_location) cls.city_location = make_loc('boston', domain=cls.domain, type='city', parent=cls.state_location) cls.mobile_user = CommCareUser.create(cls.domain, 'mobile', 'abc') cls.mobile_user.set_location(cls.city_location) cls.mobile_user2 = CommCareUser.create(cls.domain, 'mobile2', 'abc') cls.mobile_user2.set_location(cls.state_location) cls.mobile_user3 = CommCareUser.create(cls.domain, 'mobile3', 'abc') cls.mobile_user3.user_data['role'] = 'pharmacist' cls.mobile_user3.save() cls.mobile_user4 = CommCareUser.create(cls.domain, 'mobile4', 'abc') cls.mobile_user4.user_data['role'] = 'nurse' cls.mobile_user4.save() cls.mobile_user5 = CommCareUser.create(cls.domain, 'mobile5', 'abc') cls.mobile_user5.user_data['role'] = ['nurse', 'pharmacist'] cls.mobile_user5.save() cls.web_user = WebUser.create(cls.domain, 'web', 'abc') cls.web_user2 = WebUser.create(cls.domain, 'web2', 'abc') cls.web_user2.user_data['role'] = 'nurse' cls.web_user2.save() cls.group = Group(domain=cls.domain, users=[cls.mobile_user.get_id]) cls.group.save() cls.group2 = Group( domain=cls.domain, users=[ cls.mobile_user.get_id, cls.mobile_user3.get_id, cls.mobile_user4.get_id, cls.mobile_user5.get_id, ] ) cls.group2.save() cls.case_group = CommCareCaseGroup(domain=cls.domain) cls.case_group.save()
def setUpClass(cls): super(FormEditRestrictionsMixin, cls).setUpClass() cls.middlesex_web_user = cls.make_web_user('Middlesex') cls.massachusetts_web_user = cls.make_web_user('Massachusetts') cambridge_user = cls.make_mobile_user('Cambridge') cls.cambridge_form = cls.make_form(cambridge_user) boston_user = cls.make_mobile_user('Boston') cls.boston_form = cls.make_form(boston_user) cls.locationless_web_user = WebUser.create(cls.domain, 'joeshmoe', 'password') cls.project_admin = WebUser.create(cls.domain, 'kennedy', 'password')
def setUpClass(cls): w_username = "******" w_email = "*****@*****.**" w2_username = "******" w2_email = "*****@*****.**" cc_username = "******" password = "******" cls.domain_obj = create_domain(cls.domain) cls.nodomain_obj = create_domain('nodomain') cls.project = Domain(name=cls.domain) cls.project.save() cls.webuser = WebUser.create(cls.domain, w_username, password, w_email) cls.webuser2 = WebUser.create('nodomain', w2_username, password, w2_email) cls.ccuser = CommCareUser.create(cls.domain, cc_username, password)
def test_get_scheduled_report_response(self): domain = 'test-scheduled-reports' user = WebUser.create( domain=domain, username='******', password='******', ) report_config = ReportConfig.wrap({ "date_range": "last30", "days": 30, "domain": domain, "report_slug": "worker_activity", "report_type": "project_report", "owner_id": user._id, }) report_config.save() report = ReportNotification( hour=12, minute=None, day=30, interval='monthly', config_ids=[report_config._id] ) report.save() response = get_scheduled_report_response( couch_user=user, domain=domain, scheduled_report_id=report._id )[0] self.assertEqual(200, response.status_code) self.assertTrue(user.username in response.serialize())
def test_update(self): self.client.login(username=self.username, password=self.password) user = WebUser.create(domain=self.domain.name, username="******", password="******") user_json = { "email":"*****@*****.**", "first_name":"Joe", "is_admin": True, "last_name":"Admin", "permissions":{ "edit_apps":True, "edit_commcare_users":True, "edit_data":True, "edit_web_users":True, "view_reports":True }, "phone_numbers":[ ], "role":"admin" } backend_id = user._id response = self.client.put(self.single_endpoint(backend_id), simplejson.dumps(user_json), content_type='application/json') self.assertEqual(response.status_code, 204, response.content) modified = WebUser.get(backend_id) self.assertEqual(modified.username, "test") self.assertEqual(modified.first_name, "Joe") self.assertEqual(modified.last_name, "Admin") self.assertEqual(modified.email, "*****@*****.**") modified.delete()
def test_get_list(self): self.client.login(username=self.username, password=self.password) response = self.client.get(self.list_endpoint) self.assertEqual(response.status_code, 200) api_users = json.loads(response.content)["objects"] self.assertEqual(len(api_users), 1) self._check_user_data(self.user, api_users[0]) another_user = WebUser.create(self.domain.name, "anotherguy", "***") another_user.set_role(self.domain.name, "field-implementer") another_user.save() response = self.client.get(self.list_endpoint) self.assertEqual(response.status_code, 200) api_users = json.loads(response.content)["objects"] self.assertEqual(len(api_users), 2) # username filter response = self.client.get("%s?username=%s" % (self.list_endpoint, "anotherguy")) self.assertEqual(response.status_code, 200) api_users = json.loads(response.content)["objects"] self.assertEqual(len(api_users), 1) self._check_user_data(another_user, api_users[0]) response = self.client.get("%s?username=%s" % (self.list_endpoint, "nomatch")) self.assertEqual(response.status_code, 200) api_users = json.loads(response.content)["objects"] self.assertEqual(len(api_users), 0)
def test_users(self): from corehq.apps.users.models import CommCareUser from corehq.apps.users.models import WebUser from django.contrib.auth.models import User expected_object_counts = Counter({User: 3}) ccuser_1 = CommCareUser.create( domain=self.domain_name, username='******', password='******', email='*****@*****.**', ) ccuser_2 = CommCareUser.create( domain=self.domain_name, username='******', password='******', email='*****@*****.**', ) web_user = WebUser.create( domain=self.domain_name, username='******', password='******', email='*****@*****.**', ) self.addCleanup(ccuser_1.delete) self.addCleanup(ccuser_2.delete) self.addCleanup(web_user.delete) self._dump_and_load(expected_object_counts)
def bootstrap_web_user( domain, username, password, email, location, user_data=None, phone_number="", first_name="", last_name="", program_id=None, ): web_user = WebUser.create(domain=domain, username=username, password=password, email=email) web_user.first_name = first_name web_user.last_name = last_name web_user.user_data = user_data or {} web_user.set_location(domain, location) dm = web_user.get_domain_membership(domain) dm.program_id = program_id if phone_number: web_user.phone_numbers = [phone_number] web_user.save() return web_user
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 activate_new_user(form, is_domain_admin=True, domain=None, ip=None): username = form.cleaned_data['email'] password = form.cleaned_data['password'] full_name = form.cleaned_data['full_name'] email_opt_out = form.cleaned_data['email_opt_out'] now = datetime.utcnow() new_user = WebUser.create(domain, username, password, is_admin=is_domain_admin) new_user.first_name = full_name[0] new_user.last_name = full_name[1] new_user.email = username new_user.email_opt_out = email_opt_out new_user.eula.signed = True new_user.eula.date = now new_user.eula.type = 'End User License Agreement' if ip: new_user.eula.user_ip = ip new_user.is_staff = False # Can't log in to admin site new_user.is_active = True new_user.is_superuser = False new_user.last_login = now new_user.date_joined = now new_user.save() return new_user
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 setUpClass(cls): super(UserAnalyticsTest, cls).setUpClass() delete_all_users() cls.domain = create_domain('test') cls.active_user = CommCareUser.create( domain='test', username='******', password='******', is_active=True, ) cls.active_user_2 = CommCareUser.create( domain='test', username='******', password='******', is_active=True, ) cls.inactive_user = CommCareUser.create( domain='test', username='******', password='******', is_active=False ) cls.web_user = WebUser.create( domain='test', username='******', password='******', ) update_analytics_indexes()
def setUp(self): domain = 'test' username = "******" password = "******" self.domain_obj = create_domain(domain) self.web_user = WebUser.create(domain, username, password) self.web_user.save()
def setUpClass(cls): cls.domain = 'test-domain' cls.domain_obj = create_domain(cls.domain) bootstrap_location_types(cls.domain) delete_all_locations() delete_all_users() def make_user(name, location): user = CommCareUser.create(cls.domain, name, 'password') user.set_location(location) return user cls.meereen = make_loc('meereen', type='outlet', domain=cls.domain) cls.pentos = make_loc('pentos', type='outlet', domain=cls.domain) cls.varys = make_user('Varys', cls.pentos) cls.tyrion = make_user('Tyrion', cls.meereen) cls.daenerys = make_user('Daenerys', cls.meereen) cls.george = WebUser.create( cls.domain, username="******", password='******' ) cls.george.set_location(cls.domain, cls.meereen)
def setUpClass(cls): cls.ccdomain = Domain(name='cc_user_domain') cls.ccdomain.save() cls.other_domain = Domain(name='other_domain') cls.other_domain.save() cls.ccuser_1 = CommCareUser.create( domain=cls.ccdomain.name, username='******', password='******', email='*****@*****.**', ) cls.ccuser_2 = CommCareUser.create( domain=cls.ccdomain.name, username='******', password='******', email='*****@*****.**', ) cls.web_user = WebUser.create( domain=cls.ccdomain.name, username='******', password='******', email='*****@*****.**', ) cls.ccuser_other_domain = CommCareUser.create( domain=cls.other_domain.name, username='******', password='******', email='*****@*****.**', )
def test_sync_log(self): from casexml.apps.phone.models import SyncLog, SimplifiedSyncLog from corehq.apps.users.models import WebUser, CommCareUser from casexml.apps.phone.models import get_sync_log_class_by_format web_user = WebUser.create( domain=self.domain_name, username='******', password='******', email='*****@*****.**', ) mobile_user = CommCareUser.create( self.domain_name, 'mobile_user1', 'secret' ) other_user = CommCareUser.create( 'other_domain', 'mobile_user2', 'secret' ) self.addCleanup(other_user.delete) l1 = SyncLog(user_id=web_user._id) l1.save() l2 = SimplifiedSyncLog(user_id=mobile_user._id) l2.save() other_log = SyncLog(user_id=other_user._id) other_log.save() def _synclog_to_class(doc): if doc['doc_type'] == 'SyncLog': return get_sync_log_class_by_format(doc.get('log_format')) expected_docs = [web_user, mobile_user, l1, l2] not_expected_docs = [other_user, other_log] self._dump_and_load(expected_docs, not_expected_docs, doc_to_doc_class=_synclog_to_class)
def setUpClass(cls): super(MessageLogReportTest, cls).setUpClass() cls.domain_obj = create_domain(cls.domain) cls.factory = RequestFactory() cls.couch_user = WebUser.create(None, "phone_report_test", "foobar") cls.couch_user.add_domain_membership(cls.domain, is_admin=True) cls.couch_user.save()
def test_get_list(self): response = self._assert_auth_get_resource(self.list_endpoint) self.assertEqual(response.status_code, 200) api_users = json.loads(response.content)['objects'] self.assertEqual(len(api_users), 1) self._check_user_data(self.user, api_users[0]) another_user = WebUser.create(self.domain.name, 'anotherguy', '***') another_user.set_role(self.domain.name, 'field-implementer') another_user.save() self.addCleanup(another_user.delete) response = self._assert_auth_get_resource(self.list_endpoint) self.assertEqual(response.status_code, 200) api_users = json.loads(response.content)['objects'] self.assertEqual(len(api_users), 2) # username filter response = self._assert_auth_get_resource('%s?web_username=%s' % (self.list_endpoint, 'anotherguy')) self.assertEqual(response.status_code, 200) api_users = json.loads(response.content)['objects'] self.assertEqual(len(api_users), 1) self._check_user_data(another_user, api_users[0]) response = self._assert_auth_get_resource('%s?web_username=%s' % (self.list_endpoint, 'nomatch')) self.assertEqual(response.status_code, 200) api_users = json.loads(response.content)['objects'] self.assertEqual(len(api_users), 0)
def setUp(self): self.domain_name = 'test' self.password = "******" username = "******" email = "*****@*****.**" self.client = Client() self.user = WebUser.create(self.domain_name, username, self.password, email, is_admin=True) self.url = '/a/{}/data/edit/archive_forms/'.format(self.domain_name) django_user = self.user.get_django_user() try: self.user_role = UserRole.objects.get(user=django_user) except UserRole.DoesNotExist: user_privs = Role.objects.get_or_create( name="Privileges for %s" % django_user.username, slug="%s_privileges" % django_user.username, )[0] self.user_role = UserRole.objects.create( user=django_user, role=user_privs, ) # Setup default roles and plans generator.instantiate_accounting_for_tests() self.bulk_role = Role.objects.filter(slug=privileges.BULK_CASE_MANAGEMENT)[0] Grant.objects.create(from_role=self.user_role.role, to_role=self.bulk_role) Role.get_cache().clear() self.client.login(username=self.user.username, password=self.password) toggles.BULK_ARCHIVE_FORMS.set(self.user.username, True)
def test_project_admin_can_edit_anything(self): project_admin = WebUser.create(self.domain, 'kennedy', 'password') project_admin.get_domain_membership(self.domain).is_admin = True project_admin.save() self.assertCanEdit(project_admin, self.cambridge_form) self.assertCanEdit(project_admin, self.boston_form)
def handle(self, username, **options): from corehq.apps.users.models import WebUser try: validate_email(username) except EmailSyntaxError: raise CommandError('Your username must be an email address') couch_user = WebUser.get_by_username(username) if couch_user: if not isinstance(couch_user, WebUser): raise CommandError('Username already in use by a non-web user') print("✓ User {} exists".format(couch_user.username)) else: password = self.get_password_from_user() couch_user = WebUser.create(None, username, password) print("→ User {} created".format(couch_user.username)) is_superuser_changed = not couch_user.is_superuser is_staff_changed = not couch_user.is_staff couch_user.is_superuser = True couch_user.is_staff = True if is_superuser_changed or is_staff_changed: couch_user.save() if is_superuser_changed: print("→ User {} is now a superuser".format(couch_user.username)) else: print("✓ User {} is a superuser".format(couch_user.username)) if is_staff_changed: print("→ User {} can now access django admin".format(couch_user.username)) else: print("✓ User {} can access django admin".format(couch_user.username))
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.mugglename = 'muggle' self.muggle = WebUser.create('anotherdomain', self.mugglename, self.password) self.muggle.save()
def arbitrary_web_user(save=True, is_dimagi=False): domain = data_gen.arbitrary_unique_name().lower()[:25] username = "******" % (data_gen.arbitrary_username(), 'dimagi' if is_dimagi else 'gmail') web_user = WebUser.create(domain, username, 'test123') if save: web_user.save() return web_user
def test_get_list(self): self.client.login(username=self.username, password=self.password) response = self.client.get(self.list_endpoint) self.assertEqual(response.status_code, 200) api_users = simplejson.loads(response.content)['objects'] self.assertEqual(len(api_users), 1) self._check_user_data(self.user, api_users[0]) another_user = WebUser.create(self.domain.name, 'anotherguy', '***') another_user.set_role(self.domain.name, 'field-implementer') another_user.save() response = self.client.get(self.list_endpoint) self.assertEqual(response.status_code, 200) api_users = simplejson.loads(response.content)['objects'] self.assertEqual(len(api_users), 2) # username filter response = self.client.get('%s?username=%s' % (self.list_endpoint, 'anotherguy')) self.assertEqual(response.status_code, 200) api_users = simplejson.loads(response.content)['objects'] self.assertEqual(len(api_users), 1) self._check_user_data(another_user, api_users[0]) response = self.client.get('%s?username=%s' % (self.list_endpoint, 'nomatch')) self.assertEqual(response.status_code, 200) api_users = simplejson.loads(response.content)['objects'] self.assertEqual(len(api_users), 0)
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): super(TestTreeValidator, self).setUp() self.domain_obj = create_domain(self.domain) self.user = WebUser.create(self.domain, 'username', 'password')
def setUp(self): super(TestLocationFilter, self).setUp() self.web_user = WebUser.create(self.domain, 'test', 'test')
def setup_webuser(cls, username, domain, role): user = WebUser.create(domain.name, username, '{}-password'.format(username), None, None) user.set_role(domain.name, role) user.save() return user
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, None, None)
def make_web_user(cls, location): username = ''.join(random.sample(string.ascii_letters, 8)) user = WebUser.create(cls.domain, username, 'password') user.set_location(cls.domain, cls.locations[location]) return user
def setUp(self): super(ReportCacheTest, self).setUp() self.test_domain = create_domain(self.domain) self.web_user1 = WebUser.create(self.domain, 'w1', 'secret') self.web_user2 = WebUser.create(self.domain, 'w2', 'secret')
def setUpClass(cls): super(AllCommCareUsersTest, cls).setUpClass() delete_all_users() hard_delete_deleted_users() cls.ccdomain = Domain(name='cc_user_domain') cls.ccdomain.save() cls.other_domain = Domain(name='other_domain') cls.other_domain.save() bootstrap_location_types(cls.ccdomain.name) initialize_domain_with_default_roles(cls.ccdomain.name) cls.user_roles = UserRole.objects.get_by_domain(cls.ccdomain.name) cls.custom_role = UserRole.create(cls.ccdomain.name, "Custom Role") cls.loc1 = make_loc('spain', domain=cls.ccdomain.name, type="district") cls.loc2 = make_loc('madagascar', domain=cls.ccdomain.name, type="district") cls.ccuser_1 = CommCareUser.create( domain=cls.ccdomain.name, username='******', password='******', created_by=None, created_via=None, email='*****@*****.**', ) cls.ccuser_1.set_location(cls.loc1) cls.ccuser_1.save() cls.ccuser_2 = CommCareUser.create( domain=cls.ccdomain.name, username='******', password='******', created_by=None, created_via=None, email='*****@*****.**', ) cls.ccuser_2.set_role(cls.ccdomain.name, cls.custom_role.get_qualified_id()) cls.ccuser_2.set_location(cls.loc2) cls.ccuser_2.save() cls.web_user = WebUser.create( domain=cls.ccdomain.name, username='******', password='******', created_by=None, created_via=None, email='*****@*****.**', ) cls.location_restricted_web_user = WebUser.create( domain=cls.ccdomain.name, username='******', password='******', created_by=None, created_via=None, email='*****@*****.**', ) cls.location_restricted_web_user.add_to_assigned_locations( domain=cls.ccdomain.name, location=cls.loc2) cls.ccuser_other_domain = CommCareUser.create( domain=cls.other_domain.name, username='******', password='******', created_by=None, created_via=None, email='*****@*****.**', ) cls.retired_user = CommCareUser.create( domain=cls.ccdomain.name, username='******', password='******', created_by=None, created_via=None, email='*****@*****.**', ) cls.retired_user.retire(cls.ccdomain.name, deleted_by=None) cls.ccuser_inactive = CommCareUser.create( domain=cls.ccdomain.name, username='******', password='******', created_by=None, created_via=None, email='*****@*****.**', ) cls.ccuser_inactive.is_active = False cls.ccuser_inactive.save() cls.ccuser_inactive.set_location(cls.loc2)
def setUpClass(cls): super(AllCommCareUsersTest, cls).setUpClass() delete_all_users() hard_delete_deleted_users() cls.ccdomain = Domain(name='cc_user_domain') cls.ccdomain.save() cls.other_domain = Domain(name='other_domain') cls.other_domain.save() bootstrap_location_types(cls.ccdomain.name) UserRole.init_domain_with_presets(cls.ccdomain.name) cls.user_roles = UserRole.by_domain(cls.ccdomain.name) cls.custom_role = UserRole.get_or_create_with_permissions( cls.ccdomain.name, Permissions( edit_apps=True, edit_web_users=True, view_web_users=True, view_roles=True, ), "Custom Role") cls.custom_role.save() cls.loc1 = make_loc('spain', domain=cls.ccdomain.name, type="district") cls.loc2 = make_loc('madagascar', domain=cls.ccdomain.name, type="district") cls.ccuser_1 = CommCareUser.create( domain=cls.ccdomain.name, username='******', password='******', email='*****@*****.**', ) cls.ccuser_1.set_location(cls.loc1) cls.ccuser_1.save() cls.ccuser_2 = CommCareUser.create( domain=cls.ccdomain.name, username='******', password='******', email='*****@*****.**', ) cls.ccuser_2.set_role(cls.ccdomain.name, cls.custom_role.get_qualified_id()) cls.ccuser_2.set_location(cls.loc2) cls.ccuser_2.save() cls.web_user = WebUser.create( domain=cls.ccdomain.name, username='******', password='******', email='*****@*****.**', ) cls.ccuser_other_domain = CommCareUser.create( domain=cls.other_domain.name, username='******', password='******', email='*****@*****.**', ) cls.retired_user = CommCareUser.create( domain=cls.ccdomain.name, username='******', password='******', email='*****@*****.**', ) cls.retired_user.retire()
def setUpClass(cls): super(SchedulingRecipientTest, cls).setUpClass() cls.domain_obj = create_domain(cls.domain) cls.location_types = setup_location_types(cls.domain, ['country', 'state', 'city']) cls.country_location = make_loc('usa', domain=cls.domain, type='country') cls.state_location = make_loc('ma', domain=cls.domain, type='state', parent=cls.country_location) cls.city_location = make_loc('boston', domain=cls.domain, type='city', parent=cls.state_location) cls.mobile_user = CommCareUser.create(cls.domain, 'mobile', 'abc', None, None) cls.mobile_user.set_location(cls.city_location) cls.mobile_user2 = CommCareUser.create(cls.domain, 'mobile2', 'abc', None, None) cls.mobile_user2.set_location(cls.state_location) cls.mobile_user3 = CommCareUser.create(cls.domain, 'mobile3', 'abc', None, None, metadata={ 'role': 'pharmacist', }) cls.mobile_user3.save() cls.mobile_user4 = CommCareUser.create(cls.domain, 'mobile4', 'abc', None, None, metadata={ 'role': 'nurse', }) cls.mobile_user4.save() cls.mobile_user5 = CommCareUser.create(cls.domain, 'mobile5', 'abc', None, None, metadata={ 'role': ['nurse', 'pharmacist'], }) cls.mobile_user5.save() full_username = normalize_username('mobile', cls.domain) cls.full_mobile_user = CommCareUser.create(cls.domain, full_username, 'abc', None, None) cls.definition = CustomDataFieldsDefinition( domain=cls.domain, field_type=UserFieldsView.field_type) cls.definition.save() cls.definition.set_fields([ Field( slug='role', label='Role', ), ]) cls.definition.save() cls.profile = CustomDataFieldsProfile( name='nurse_profile', fields={'role': ['nurse']}, definition=cls.definition, ) cls.profile.save() cls.mobile_user6 = CommCareUser.create(cls.domain, 'mobile6', 'abc', None, None, metadata={ PROFILE_SLUG: cls.profile.id, }) cls.mobile_user5.save() cls.web_user = WebUser.create(cls.domain, 'web', 'abc', None, None) cls.web_user2 = WebUser.create(cls.domain, 'web2', 'abc', None, None, metadata={ 'role': 'nurse', }) cls.web_user2.save() cls.group = Group(domain=cls.domain, users=[cls.mobile_user.get_id]) cls.group.save() cls.group2 = Group(domain=cls.domain, users=[ cls.mobile_user.get_id, cls.mobile_user3.get_id, cls.mobile_user4.get_id, cls.mobile_user5.get_id, cls.mobile_user6.get_id, ]) cls.group2.save() cls.case_group = CommCareCaseGroup(domain=cls.domain) cls.case_group.save() cls.process_pillow_changes = process_pillow_changes( 'DefaultChangeFeedPillow') cls.process_pillow_changes.add_pillow(get_case_messaging_sync_pillow())
def create_web_user(self, username, password): user = WebUser.create(self.domain, username, password, None, None) self.users.append(user) return user
def setUpClass(cls): super(TestLocationAncestorsView, cls).setUpClass() cls.domain = create_domain('icds-test') state = LocationType.objects.create(domain=cls.domain.name, name='state', parent_type=None) district = LocationType.objects.create(domain=cls.domain.name, name='district', parent_type=state) block = LocationType.objects.create(domain=cls.domain.name, name='block', parent_type=district) supervisor = LocationType.objects.create(domain=cls.domain.name, name='supervisor', parent_type=block) awc = LocationType.objects.create(domain=cls.domain.name, name='awc', parent_type=supervisor) cls.state = SQLLocation.objects.create(name='Test State', domain=cls.domain.name, location_type=state) cls.district = SQLLocation.objects.create( name='Test District', domain=cls.domain.name, location_type=district, parent=cls.state, ) cls.district_2 = SQLLocation.objects.create( name='Test District 2', domain=cls.domain.name, location_type=district, parent=cls.state, ) cls.block = SQLLocation.objects.create(name='Test Block', domain=cls.domain.name, location_type=block, parent=cls.district) cls.block_2 = SQLLocation.objects.create(name='Test Block 2', domain=cls.domain.name, location_type=block, parent=cls.district_2) cls.supervisor = SQLLocation.objects.create(name='Test Supervisor', domain=cls.domain.name, location_type=supervisor, parent=cls.block) cls.supervisor_2 = SQLLocation.objects.create(name='Test Supervisor 2', domain=cls.domain.name, location_type=supervisor, parent=cls.block_2) cls.awc = SQLLocation.objects.create(name='Test AWC', domain=cls.domain.name, location_type=awc, parent=cls.supervisor) cls.awc_2 = SQLLocation.objects.create(name='Test AWC 2', domain=cls.domain.name, location_type=awc, parent=cls.supervisor_2) cls.state_2 = SQLLocation.objects.create(name='Test State 2', domain=cls.domain.name, location_type=state) cls.state_3 = SQLLocation.objects.create(name='Test State 3', domain=cls.domain.name, location_type=state) cls.factory = RequestFactory() cls.user = WebUser.create(cls.domain.name, 'test', 'passwordtest') cls.user.is_authenticated = True cls.user.is_superuser = True cls.user.is_authenticated = True cls.user.is_active = True
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).get_django_user()
def setUpClass(cls): super(TestDecodePassword, cls).setUpClass() cls.domain = Domain(name="delhi", is_active=True) cls.domain.save() cls.username = "******" cls.web_user = WebUser.create(cls.domain.name, cls.username, "123456")
def test_web_user_reindexer_v2(self): username = '******' WebUser.create(DOMAIN, username, 'secret', None, None) reindex_and_clean('user') self._assert_user_in_es(username, is_webuser=True)
def setUpClass(cls): super().setUpClass() cls.domain = create_domain(cls.domain_name) cls.couch_user = WebUser.create(None, "test", "foobar", None, None) cls.couch_user.add_domain_membership(cls.domain_name, is_admin=True) cls.couch_user.save()
def create_web_user(self): # A Couch user is required for logout user = WebUser.create('', '*****@*****.**', 'mockmock', None, None) user.save() self.addCleanup(lambda: user.delete(None))
def setUpClass(cls): super(DigestOtaRestoreTest, cls).setUpClass() create_domain(cls.domain) create_domain(cls.wrong_domain) cls.commcare_user = CommCareUser.create(cls.domain, cls.username, cls.password) cls.web_user = WebUser.create(cls.domain, cls.web_username, cls.password)
def setUpClass(cls): cls.domain = create_domain('adomain') cls.user = WebUser.create('adomain', 'ben', '***')
def normal_user(): user = WebUser.create(DOMAIN_NAME, USERNAME, PASSWORD) try: yield finally: user.delete()
def superuser(): user = WebUser.create(DOMAIN_NAME, USERNAME, PASSWORD, is_superuser=True) try: yield finally: user.delete()
def setUpClass(cls): super(DropboxUploadHelperTest, cls).setUpClass() cls.domain = create_domain('adomain') cls.user = WebUser.create('adomain', 'ben', '***')
def setUp(self): super(TestBulkManagementNoInitialLocs, self).setUp() self.domain_obj = create_domain(self.domain) self.user = WebUser.create(self.domain, 'username', 'password', None, None)
def setUp(self): super(TestBulkManagementWithInitialLocs, self).setUp() self.user = WebUser.create(self.domain, 'username', 'password')
def setUp(self): create_domain(self.domain) self.web_user1 = WebUser.create(self.domain, 'w1', 'secret') self.web_user2 = WebUser.create(self.domain, 'w2', 'secret')
def setUpClass(cls): super(ReportTestCase, cls).setUpClass() cls.domain = create_domain('test-domain') cls.web_user = WebUser.get_by_username('test') if not cls.web_user: cls.web_user = WebUser.create('test-domain', 'test', 'test', None, None) SQLProduct.objects.create(domain=cls.domain.name, name='Product 2', code='p2', product_id='p2') SQLProduct.objects.create(domain=cls.domain.name, name='Product 3', code='p3', product_id='p3') SQLProduct.objects.create(domain=cls.domain.name, name='Product 1', code='p1', product_id='p1') region_location_type = LocationType.objects.create( domain=cls.domain.name, name='Region', ) SQLLocation.objects.create(domain=cls.domain.name, name='Region 1', location_id='r1', location_type=region_location_type) district_location_type = LocationType.objects.create( domain=cls.domain.name, name='District', ) SQLLocation.objects.create(domain=cls.domain.name, name='District 1', location_id='d1', location_type=district_location_type) cls.engine = connection_manager.get_engine(DEFAULT_ENGINE_ID) cls.intra_table = IntraHealthFluff._table cls.couverture_table = CouvertureFluff._table cls.taux_table = TauxDeRuptureFluff._table cls.taux_de_satisfaction_table = TauxDeSatisfactionFluff._table cls.livraison_table = LivraisonFluff._table cls.recouvrement_table = RecouvrementFluff._table with cls.engine.begin() as connection: cls.couverture_table.create(connection, checkfirst=True) cls.intra_table.create(connection, checkfirst=True) cls.taux_table.create(connection, checkfirst=True) cls.taux_de_satisfaction_table.create(connection, checkfirst=True) cls.recouvrement_table.create(connection, checkfirst=True) cls.livraison_table.create(connection, checkfirst=True) insert = cls.intra_table.insert().values([ dict(doc_id='1', date=datetime(2017, 11, 17), product_name='Product 1', product_id='p1', district_id='d1', district_name='District 1', location_id='pps1', region_id='r1', PPS_name='PPS 1', actual_consumption_total=10, billed_consumption_total=5, stock_total=33, total_stock_total=70, quantity_total=13, cmm_total=16), dict(doc_id='1', date=datetime(2017, 11, 17), product_name='Product 2', product_id='p2', district_id='d1', district_name='District 1', location_id='pps1', region_id='r1', PPS_name='PPS 1', actual_consumption_total=2, billed_consumption_total=2, stock_total=1, total_stock_total=2, quantity_total=3, cmm_total=4), dict(doc_id='1', date=datetime(2017, 11, 17), product_name='Product 3', product_id='p3', district_id='d1', district_name='District 1', location_id='pps1', region_id='r1', PPS_name='PPS 1', actual_consumption_total=6, billed_consumption_total=4, stock_total=14, total_stock_total=0, quantity_total=88, cmm_total=99), dict(doc_id='2', date=datetime(2017, 11, 17), product_name='Product 1', product_id='p1', district_id='d1', district_name='District 1', location_id='pps2', region_id='r1', PPS_name='PPS 2', actual_consumption_total=13, billed_consumption_total=11, stock_total=50, total_stock_total=100, quantity_total=1, cmm_total=8), dict(doc_id='2', date=datetime(2017, 11, 17), product_name='Product 2', product_id='p2', district_id='d1', district_name='District 1', location_id='pps2', region_id='r1', PPS_name='PPS 2', actual_consumption_total=0, billed_consumption_total=0, stock_total=2, total_stock_total=17, quantity_total=3, cmm_total=15), dict(doc_id='2', date=datetime(2017, 11, 17), product_name='Product 3', product_id='p3', district_id='d1', district_name='District 1', location_id='pps2', region_id='r1', PPS_name='PPS 2', actual_consumption_total=150, billed_consumption_total=11, stock_total=4, total_stock_total=0, quantity_total=11, cmm_total=12) ]) connection.execute(insert)
def setUpClass(cls): super().setUpClass() cls.user = WebUser.create(cls.domain, 'fiona', 'secret', None, None)
def _setup_web_user(cls): cls.web_user = WebUser.create(cls.DOMAIN_NAME, cls.WEB_USER, '*****') cls.web_user.save() cls.request.couch_user = cls.web_user
def setUp(self): super(GuidedTourTest, self).setUp() self.web_user = WebUser.create(self.domain, '*****@*****.**', 'test123') self.test_user = User.objects.get_by_natural_key( self.web_user.username)
def setUp(self): super(TestRestrictedUserUpload, self).setUp() self.user = WebUser.create(self.domain, 'username', 'password') self.user.set_location(self.domain, self.locations['Middlesex']) restrict_user_by_location(self.domain, self.user)
def test_web_user_reindexer_v2(self): username = '******' WebUser.create(DOMAIN, username, 'secret') call_command('ptop_reindexer_v2', 'user', cleanup=True, noinput=True) self._assert_user_in_es(username, is_webuser=True)