def tearDownClass(cls):
delete_all_users()
delete_all_locations()
cls.ccdomain.delete()
cls.other_domain.delete()
ensure_index_deleted(USER_INDEX)
super(AllCommCareUsersTest, cls).tearDownClass()
def setUp(self):
self.domain = 'dummy-project'
self.project = Domain(name=self.domain)
self.project.save()
delete_all_cases()
delete_all_sync_logs()
delete_all_users()
def setUp(self):
super().setUp()
delete_all_users()
self.domain_obj = create_domain(self.domain)
enable_usercase(self.domain)
with trap_extra_setup(ConnectionError):
self.es = get_es_new()
initialize_index_and_mapping(self.es, CASE_SEARCH_INDEX_INFO)
username = normalize_username("mobile_worker_1", self.domain)
self.mobile_worker = CommCareUser.create(self.domain, username, "123",
None, None)
sync_usercases(self.mobile_worker)
self.checkin_case = CaseFactory(self.domain).create_case(
case_type="checkin",
owner_id=self.mobile_worker.get_id,
update={"username": self.mobile_worker.raw_username},
)
send_to_elasticsearch(
"case_search",
transform_case_for_elasticsearch(self.checkin_case.to_json()))
self.es.indices.refresh(CASE_SEARCH_INDEX_INFO.index)
self.case_accessor = CaseAccessors(self.domain)
def setUp(self):
super(UserPillowTestBase, self).setUp()
self.index_info = USER_INDEX_INFO
self.elasticsearch = get_es_new()
delete_all_users()
ensure_index_deleted(self.index_info.index)
initialize_index_and_mapping(self.elasticsearch, self.index_info)
def setUpClass(cls):
super(AppAwareSyncTests, cls).setUpClass()
delete_all_users()
cls.domain_obj = create_domain(cls.domain)
toggles.MOBILE_UCR.set(cls.domain, True, toggles.NAMESPACE_DOMAIN)
cls.user = create_restore_user(cls.domain)
cls.app1 = Application.new_app(cls.domain, 'Test App 1')
cls.report_config1 = get_sample_report_config()
cls.report_config1.domain = cls.domain
cls.report_config1.save()
report_app_config = {
'report_id': cls.report_config1.get_id,
'uuid': '123456'
}
module = cls.app1.add_module(ReportModule.new_module('Reports', None))
module.report_configs = [ReportAppConfig.wrap(report_app_config)]
cls.app1.save()
cls.app2 = Application.new_app(cls.domain, 'Test App 2')
cls.report_config2 = get_sample_report_config()
cls.report_config2.domain = cls.domain
cls.report_config2.save()
report_app_config = {
'report_id': cls.report_config2.get_id,
'uuid': 'abcdef'
}
module = cls.app2.add_module(ReportModule.new_module('Reports', None))
module.report_configs = [ReportAppConfig.wrap(report_app_config)]
cls.app2.save()
cls.app3 = Application.new_app(cls.domain, 'Test App 3')
cls.app3.save()
def setUpClass(cls):
super(UserAnalyticsTest, cls).setUpClass()
delete_all_users()
cls.domain = create_domain('test')
cls.active_user = CommCareUser.create(
domain='test',
username='******',
password='******',
created_by=None,
created_via=None,
is_active=True,
)
cls.active_user_2 = CommCareUser.create(
domain='test',
username='******',
password='******',
created_by=None,
created_via=None,
is_active=True,
)
cls.inactive_user = CommCareUser.create(domain='test',
username='******',
password='******',
created_by=None,
created_via=None,
is_active=False)
cls.web_user = WebUser.create(
domain='test',
username='******',
password='******',
created_by=None,
created_via=None,
)
reset_es_index(USER_INDEX_INFO)
update_analytics_indexes()
def setUpClass(cls):
delete_all_users()
cls.client = Client()
cls.domain = DOMAIN
cls.domain_object = Domain(name=cls.domain, is_active=True)
cls.domain_object.save()
cls.reports_role = UserRole(
domain=cls.domain,
name='reports-role',
default_landing_page='reports',
permissions=Permissions(view_reports=True),
)
cls.reports_role.save()
cls.webapps_role = UserRole(
domain=cls.domain,
name='webapps-role',
default_landing_page='webapps',
permissions=Permissions(access_web_apps=True),
)
cls.webapps_role.save()
cls.global_password = '******'
# make an app because not having one changes the default dashboard redirect to the apps page
app = Application.new_app(domain=cls.domain, name='sympathy')
app.save()
def setUp(self):
super(WebUserLocationFixturesTest, self).setUp()
delete_all_users()
self.user = create_restore_user(self.domain,
'web_user',
'123',
is_mobile_user=False)
def tearDown(self):
delete_domain_phone_numbers(self.domain)
SQLMobileBackendMapping.unset_default_domain_backend(self.domain)
self.backend.delete()
delete_all_users()
self.domain_obj.delete()
super(RegistrationTestCase, self).tearDown()
def setUpClass(cls):
super(TestDemoUser, cls).setUpClass()
delete_all_users()
cls.domain = 'main-domain'
cls.project = create_domain(cls.domain)
cls.user = CommCareUser.create(cls.domain, '*****@*****.**', 'secret', None, None)
factory = CaseFactory()
factory.create_case(owner_id=cls.user._id, update={'custom_prop': 'custom_value'})
def setUpClass(cls):
super(BaseAsyncRestoreTest, cls).setUpClass()
delete_all_cases()
delete_all_sync_logs()
delete_all_users()
cls.domain = 'dummy-project'
cls.project = Domain(name=cls.domain)
cls.project.save()
cls.user = create_restore_user(domain=cls.domain)
def tearDown(self):
self.data_type.delete()
self.data_item.delete()
self.user.delete(deleted_by=None)
self.fixture_ownership.delete()
delete_all_users()
delete_all_fixture_data_types()
get_fixture_data_types.clear(self.domain)
get_blob_db().delete(key=FIXTURE_BUCKET + '/' + self.domain)
super(FixtureDataTest, self).tearDown()
def setUpClass(cls):
super().setUpClass()
delete_all_users()
cls.domain_obj = create_domain(cls.domain)
enable_usercase(cls.domain)
cls.mobile_worker = CommCareUser.create(cls.domain, "username",
"p@ssword123", None, None)
cls.user_id = cls.mobile_worker.user_id
def tearDownClass(cls):
toggles.MOBILE_UCR.set(cls.domain, False, toggles.NAMESPACE_DOMAIN)
cls.app1.delete()
cls.report_config1.delete()
cls.app2.delete()
cls.report_config2.delete()
delete_all_users()
domain = Domain.get_by_name(cls.domain)
domain.delete()
super(AppAwareSyncTests, cls).tearDownClass()
def setUp(self):
delete_all_users()
self.username = '******'
self.password = '******'
self.domain = 'mockdomain'
Domain(name=self.domain).save()
self.couch_user = WebUser.create(self.domain, self.username,
self.password, None, None)
self.couch_user.language = 'en'
self.couch_user.save()
def setUp(self):
super(UpdateTestCase, self).setUp()
delete_all_users()
self.username = "******"
password = "******"
self.domain = Domain(name='my-domain')
self.domain.save()
self.couch_user = CommCareUser.create(self.domain.name, self.username,
password, None, None)
self.couch_user.save()
def setUpClass(cls):
super(AutoCloseExtensionsTest, cls).setUpClass()
delete_all_users()
cls.domain = "domain"
cls.project = Domain(name=cls.domain)
cls.user = create_restore_user(cls.domain, username='******', password="******")
cls.factory = CaseFactory(domain=cls.domain)
cls.extension_ids = ['1', '2', '3']
cls.host_id = 'host-{}'.format(uuid.uuid4().hex)
cls.parent_id = 'parent-{}'.format(uuid.uuid4().hex)
def setUp(self):
super(FixtureDataTest, self).setUp()
self.domain = 'qwerty'
self.tag = "district"
delete_all_users()
delete_all_fixture_data_types()
self.data_type = FixtureDataType(
domain=self.domain,
tag=self.tag,
name="Districts",
fields=[
FixtureTypeField(field_name="state_name", properties=[]),
FixtureTypeField(field_name="district_name",
properties=["lang"]),
FixtureTypeField(field_name="district_id", properties=[]),
],
item_attributes=[],
)
self.data_type.save()
self.data_item = FixtureDataItem(
domain=self.domain,
data_type_id=self.data_type.get_id,
fields={
"state_name":
FieldList(field_list=[
FixtureItemField(field_value="Delhi_state", properties={})
]),
"district_name":
FieldList(field_list=[
FixtureItemField(field_value="Delhi_in_HIN",
properties={"lang": "hin"}),
FixtureItemField(field_value="Delhi_in_ENG",
properties={"lang": "eng"})
]),
"district_id":
FieldList(field_list=[
FixtureItemField(field_value="Delhi_id", properties={})
])
},
item_attributes={},
)
self.data_item.save()
self.user = CommCareUser.create(self.domain, 'to_delete', '***', None,
None)
self.fixture_ownership = FixtureOwnership(
domain=self.domain,
owner_id=self.user.get_id,
owner_type='user',
data_item_id=self.data_item.get_id)
self.fixture_ownership.save()
get_fixture_data_types.clear(self.domain)
def setUp(self):
super(RetireUserTestCase, self).setUp()
delete_all_users()
self.username = "******"
self.other_username = '******'
self.password = "******"
self.commcare_user = CommCareUser.create(self.domain, self.username, self.password, None, None)
self.commcare_user.save()
self.other_user = CommCareUser.create(self.domain, self.other_username, self.password, None, None)
self.other_user.save()
def tearDownClass(cls):
for group in Group.by_domain(DOMAIN):
group.delete()
delete_all_users()
for _, item_list in cls.item_lists.items():
item_list[0].delete()
item_list[1].delete()
get_blob_db().delete(key=FIXTURE_BUCKET + "/" + DOMAIN)
cls.domain.delete()
super(OtaFixtureTest, cls).tearDownClass()
def setUp(self):
super(TestUserBulkUploadStrongPassword, self).setUp()
delete_all_users()
self.user_specs = [{
'username': '******',
'user_id': '1989',
'name': 'Taylor Swift',
'language': None,
'is_active': 'True',
'phone-number': '8675309',
'password': '******',
'email': None
}]
def setUp(self):
super().setUp()
delete_all_users()
self.domain_obj = create_domain(self.domain)
enable_usercase(self.domain)
with trap_extra_setup(ConnectionError):
self.es = get_es_new()
initialize_index_and_mapping(self.es, CASE_SEARCH_INDEX_INFO)
username = normalize_username("mobile_worker_1", self.domain)
self.mobile_worker = CommCareUser.create(self.domain, username, "123", None, None)
sync_usercases(self.mobile_worker, self.domain)
def setUpClass(cls):
super(ShouldSyncLocationFixturesTest, cls).setUpClass()
delete_all_users()
cls.domain = "Erebor"
cls.domain_obj = create_domain(cls.domain)
cls.username = "******"
cls.location_type = LocationType(
domain=cls.domain,
name="state",
code="state",
)
password = "******"
cls.user = CommCareUser.create(cls.domain, cls.username, password, None, None)
cls.user.save()
cls.location_type.save()
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.uploading_user = WebUser.create(cls.domain_name,
"*****@*****.**",
'password',
None,
None,
is_superuser=True)
cls.spec = {
'username': '******',
'name': 'Another One',
'password': 123,
}
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()
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 setUpClass(cls):
super().setUpClass()
delete_all_users()
# Set up domains
cls.domain = create_domain('test')
cls.mirror_domain = create_domain('mirror')
create_enterprise_permissions('*****@*****.**', 'test', ['mirror'])
# Set up user
cls.web_user = WebUser.create(
domain='test',
username='******',
password='******',
created_by=None,
created_via=None,
)
cls.today = datetime.today().date()
cls.last_week = cls.today - timedelta(days=7)
def setUpClass(cls):
super(TestBugReport, cls).setUpClass()
delete_all_users()
cls.project = create_domain(cls.domain)
cls.web_user = WebUser.create(
cls.domain,
'bug-dude',
password='******',
created_by=None,
created_via=None,
)
cls.web_user.is_superuser = True
cls.web_user.save()
cls.commcare_user = CommCareUser.create(
cls.domain,
'bug-kid',
password='******',
created_by=None,
created_via=None,
)
cls.url = reverse("bug_report")
def setUpClass(cls):
super().setUpClass()
delete_all_users()
# Set up domains
cls.domain = create_domain('test')
cls.mirror_domain = create_domain('mirror')
cls.mirror = DomainPermissionsMirror(source=cls.domain.name,
mirror=cls.mirror_domain.name)
cls.mirror.save()
# Set up user
cls.web_user = WebUser.create(
domain='test',
username='******',
password='******',
created_by=None,
created_via=None,
)
cls.today = datetime.today().date()
cls.last_week = cls.today - timedelta(days=7)
def test_date_opened_coercion(self):
delete_all_users()
clear_domain_names('some-domain')
self.project = Domain(name='some-domain')
self.project.save()
self.addCleanup(self.project.delete)
user = create_restore_user(self.project.name)
case_id = uuid.uuid4().hex
modified_on = datetime.utcnow()
case = CaseBlock(create=True,
case_id=case_id,
user_id=user.user_id,
owner_id=user.user_id,
case_type='demo',
case_name='create_case',
date_modified=modified_on,
date_opened=modified_on,
update={'dynamic': '123'})
post_case_blocks([case.as_xml()], domain='some-domain')
# update the date_opened to date type to check for value on restore
case.date_opened = case.date_opened.date()
deprecated_check_user_has_case(self, user, case.as_xml())
