def test_matching_case_not_migrated(self):
call_command('create_enikshay_cases', self.domain, 'test_migration')
episode_case_ids = self.case_accessor.get_case_ids_in_domain(
type='episode')
CaseFactory(self.domain).update_case(
episode_case_ids[0], update={'migration_created_case': ''})
with self.assertRaises(MatchingNikshayIdCaseNotMigrated):
EnikshayCaseFactory(self.domain, 'test_migration',
self.patient_detail, {},
'test_phi').get_case_structures_to_create()
def test_form_extras_override_defaults(self):
domain = uuid.uuid4().hex
token_id = uuid.uuid4().hex
factory = CaseFactory(domain=domain,
form_extras={'last_sync_token': token_id})
[case] = factory.create_or_update_case(
CaseStructure(attrs={'create': True}),
form_extras={'last_sync_token': 'differenttoken'})
form = XFormInstance.objects.get_form(case.xform_ids[0], domain)
self.assertEqual('differenttoken', form.last_sync_token)
def test_excluded_case_types_are_not_forwarded(self):
self.repeater.white_listed_case_types = ['planet']
self.repeater.save()
white_listed_case = CaseBlock(
case_id="a_case_id",
create=True,
case_type="planet",
).as_xml()
CaseFactory(self.domain_name).post_case_blocks([white_listed_case])
self.assertEqual(1, len(self.repeat_records(self.domain_name).all()))
non_white_listed_case = CaseBlock(
case_id="b_case_id",
create=True,
case_type="cat",
).as_xml()
CaseFactory(self.domain_name).post_case_blocks([non_white_listed_case])
self.assertEqual(1, len(self.repeat_records(self.domain_name).all()))
def test_form_extras_default(self):
domain = uuid.uuid4().hex
# have to enable loose sync token validation for the domain or create actual SyncLog documents.
# this is the easier path.
token_id = uuid.uuid4().hex
factory = CaseFactory(domain=domain,
form_extras={'last_sync_token': token_id})
case = factory.create_case()
form = XFormInstance.objects.get_form(case.xform_ids[0], domain)
self.assertEqual(token_id, form.last_sync_token)
def setUpClass(cls):
super(LoadtestUserTest, cls).setUpClass()
cls.domain = Domain(name='foo')
cls.domain.save()
cls.user = CommCareUser.create(cls.domain.name, 'somebody', 'password',
None, None)
cls.user_id = cls.user._id
cls.factory = CaseFactory(domain='foo',
case_defaults={'owner_id': cls.user_id})
ENABLE_LOADTEST_USERS.set('foo', True, namespace='domain')
def handle(self, domain, log_path, log_errors, **options):
commit = options['commit']
accessor = CaseAccessors(domain)
factory = CaseFactory(domain)
headers = [
'case_id',
'diagnosis_test_result_date',
'diagnosis_lab_facility_name',
'diagnosis_test_lab_serial_number',
'diagnosis_test_summary',
'datamigration_diagnosis_test_information',
]
print("Starting {} migration on {} at {}".format(
"real" if commit else "fake", domain, datetime.datetime.utcnow()))
with open(log_errors, 'w') as log_errors_file:
error_logger = csv.writer(log_errors_file)
error_logger.writerow(['case_id'])
with open(log_path, "w") as log_file:
writer = csv.writer(log_file)
writer.writerow(headers)
for episode_case_id in accessor.get_case_ids_in_domain(
type='episode'):
print('Looking at {}'.format(episode_case_id))
episode_case = accessor.get_case(episode_case_id)
case_properties = episode_case.dynamic_case_properties()
if self.should_migrate_case(episode_case_id,
case_properties, domain):
test = self.get_relevant_test_case(
domain, episode_case, error_logger)
if test is not None:
update = self.get_updates(test)
print('Updating {}...'.format(episode_case_id))
writer.writerow(
[episode_case_id] +
[update[key] for key in headers[1:]])
if commit:
try:
factory.update_case(
case_id=episode_case_id, update=update)
except NikshayLocationNotFound:
pass
else:
print(
'No relevant test found for episode {}'.format(
episode_case_id))
else:
print('Do not migrate {}'.format(episode_case_id))
print('Migration complete at {}'.format(datetime.datetime.utcnow()))
def test_legacy_support_toggle(self):
restore_config = RestoreConfig(self.project, restore_user=self.user)
factory = CaseFactory(domain=self.project.name,
case_defaults={'owner_id': self.user_id})
# create a parent and child case (with index) from one user
parent_id, child_id = [uuid.uuid4().hex for i in range(2)]
factory.create_or_update_cases([
CaseStructure(
case_id=child_id,
attrs={'create': True},
indices=[
CaseIndex(
CaseStructure(case_id=parent_id,
attrs={'create': True}),
relationship='child',
related_type='parent',
)
],
)
])
restore_payload = restore_config.get_payload().as_string()
self.assertTrue(child_id in restore_payload)
self.assertTrue(parent_id in restore_payload)
sync_log = deprecated_synclog_from_restore_payload(restore_payload)
self.assertEqual(SimplifiedSyncLog, type(sync_log))
# make both cases irrelevant by changing the owner ids
factory.create_or_update_cases([
CaseStructure(case_id=parent_id, attrs={'owner_id': 'different'}),
CaseStructure(case_id=child_id, attrs={'owner_id': 'different'}),
],
form_extras={
'last_sync_token': sync_log._id
})
# doing it again should fail since they are no longer relevant
# todo: add this back in when we add the assertion back. see SimplifiedSyncLog.prune_case
# with self.assertRaises(SimplifiedSyncAssertionError):
# factory.create_or_update_cases([
# CaseStructure(case_id=child_id, attrs={'owner_id': 'different'}),
# CaseStructure(case_id=parent_id, attrs={'owner_id': 'different'}),
# ], form_extras={'last_sync_token': sync_log._id})
# enabling the toggle should prevent the failure the second time
# though we also need to hackily set the request object in the threadlocals
LEGACY_SYNC_SUPPORT.set(self.domain, True, namespace='domain')
request = JsonObject(domain=self.domain, path='testsubmit')
set_request(request)
factory.create_or_update_cases([
CaseStructure(case_id=child_id, attrs={'owner_id': 'different'}),
CaseStructure(case_id=parent_id, attrs={'owner_id': 'different'}),
],
form_extras={
'last_sync_token': sync_log._id
})
def setUp(self):
super(AutoCloseExtensionsTest, self).setUp()
FormProcessorTestUtils.delete_all_cases()
FormProcessorTestUtils.delete_all_xforms()
delete_all_users()
self.domain = "domain"
self.project = Domain(name=self.domain)
self.user = create_restore_user(self.domain, username='******', password="******")
self.factory = CaseFactory(domain=self.domain)
self.extension_ids = ['1', '2', '3']
self.host_id = 'host'
def create_case(domain, case_type, **kwargs):
"""Use corehq.form_processor.tests.utils.create_case() instead if possible
This submits a form to create the case. The form_procssor version
creates and saves the case directly, which is faster.
"""
case = CaseFactory(domain).create_case(case_type=case_type, **kwargs)
try:
yield case
finally:
CommCareCase.objects.hard_delete_cases(domain, [case.case_id])
def setUp(self):
self.domain = 'auto-update-test'
self.case_db = CaseAccessors(self.domain)
self.factory = CaseFactory(self.domain)
self.rule = AutomaticUpdateRule(
domain=self.domain,
name='test-rule',
case_type='test-case-type',
active=True,
server_modified_boundary=30,
)
self.rule.save()
self.rule.automaticupdaterulecriteria_set = [
AutomaticUpdateRuleCriteria(
property_name='last_visit_date',
property_value='30',
match_type=AutomaticUpdateRuleCriteria.MATCH_DAYS_SINCE,
),
]
self.rule.automaticupdateaction_set = [
AutomaticUpdateAction(
action=AutomaticUpdateAction.ACTION_UPDATE,
property_name='update_flag',
property_value='Y',
),
AutomaticUpdateAction(action=AutomaticUpdateAction.ACTION_CLOSE, ),
]
self.rule2 = AutomaticUpdateRule(
domain=self.domain,
name='test-rule-2',
case_type='test-case-type-2',
active=True,
server_modified_boundary=30,
)
self.rule2.save()
self.rule2.automaticupdateaction_set = [
AutomaticUpdateAction(action=AutomaticUpdateAction.ACTION_CLOSE, ),
]
self.rule3 = AutomaticUpdateRule(
domain=self.domain,
name='test-rule-3',
case_type='test-case-type-2',
active=True,
server_modified_boundary=50,
)
self.rule3.save()
self.rule3.automaticupdateaction_set = [
AutomaticUpdateAction(action=AutomaticUpdateAction.ACTION_CLOSE, ),
]
with drop_connected_signals(case_post_save):
case = self.factory.create_case(case_type='test-case-type')
def handle(self, domain, log_path, **options):
commit = options['commit']
factory = CaseFactory(domain)
logger.info("Starting {} migration on {} at {}".format(
"real" if commit else "fake", domain, datetime.datetime.utcnow()
))
cases = (CaseSearchES()
.domain(domain)
.case_type("episode")
.scroll())
with open(log_path, "w") as f:
for case in cases:
case_props = {prop['key']: prop['value'] for prop in case['case_properties']}
treatment_status = None
treatment_initiated = case_props.get('treatment_initiated')
diagnosing_facility_id = case_props.get('diagnosing_facility_id')
treatment_initiating_facility_id = case_props.get('treatment_initiating_facility_id')
if treatment_initiated == 'yes_phi' and \
diagnosing_facility_id and treatment_initiating_facility_id and \
diagnosing_facility_id != treatment_initiating_facility_id:
treatment_status = 'initiated_outside_facility'
elif treatment_initiated == 'yes_phi' and \
diagnosing_facility_id and treatment_initiating_facility_id:
treatment_status = 'initiated_first_line_treatment'
elif treatment_initiated == 'yes_private':
treatment_status = 'initiated_outside_rntcp'
if treatment_status:
case_id = case['_id']
f.write(case_id + "\n")
logger.info(case_id)
case_structure = CaseStructure(
case_id=case_id,
walk_related=False,
attrs={
"create": False,
"update": {
"treatment_status": treatment_status,
"updated_by_migration": "enikshay_2b_treatment_status_fix",
},
},
)
if commit:
try:
factory.create_or_update_case(case_structure)
except NikshayLocationNotFound:
pass
logger.info("Migration finished at {}".format(datetime.datetime.utcnow()))
def setUpClass(cls):
super(BaseEnikshayDatasourceTest, cls).setUpClass()
cls._call_center_domain_mock.start()
cls.static_datasource = StaticDataSourceConfiguration.wrap(
cls.get_json(cls.datasource_filename))
cls.domain = cls.static_datasource.domains[0]
cls.datasource = StaticDataSourceConfiguration._get_datasource_config(
cls.static_datasource,
cls.domain,
)
cls.factory = CaseFactory(domain=cls.domain)
def test_no_walk_related(self):
factory = CaseFactory()
parent = factory.create_case()
child_updates = factory.create_or_update_case(
CaseStructure(
attrs={'create': True},
walk_related=False,
indices=[CaseIndex(CaseStructure(case_id=parent.case_id))]), )
self.assertEqual(1, len(child_updates))
self.assertEqual(parent.case_id,
child_updates[0].indices[0].referenced_id)
def setUp(self):
super(TestReverseIndexedCases, self).setUp()
self.domain = 'domain'
self.factory = CaseFactory(self.domain)
self.indexed_case_id = uuid.uuid4().hex
self.index = CommCareCaseIndex(identifier="host",
referenced_type="host",
relationship=CASE_INDEX_EXTENSION,
referenced_id=self.indexed_case_id)
self.case = CommCareCase(domain=self.domain, indices=[self.index])
self.case.save()
def test_form_extras_override_defaults(self):
domain = uuid.uuid4().hex
LOOSE_SYNC_TOKEN_VALIDATION.set(domain, True, namespace='domain')
token_id = uuid.uuid4().hex
factory = CaseFactory(domain=domain,
form_extras={'last_sync_token': token_id})
[case] = factory.create_or_update_case(
CaseStructure(attrs={'create': True}),
form_extras={'last_sync_token': 'differenttoken'})
form = FormAccessors(domain).get_form(case.xform_ids[0])
self.assertEqual('differenttoken', form.last_sync_token)
def test_form_extras_default(self):
domain = uuid.uuid4().hex
# have to enable loose sync token validation for the domain or create actual SyncLog documents.
# this is the easier path.
LOOSE_SYNC_TOKEN_VALIDATION.set(domain, True, namespace='domain')
token_id = uuid.uuid4().hex
factory = CaseFactory(domain=domain,
form_extras={'last_sync_token': token_id})
case = factory.create_case()
form = FormAccessors(domain).get_form(case.xform_ids[0])
self.assertEqual(token_id, form.last_sync_token)
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 _test_case_deletion(self):
for domain_name in [self.domain.name, self.domain2.name]:
CaseFactory(domain_name).create_case()
self.assertEqual(
len(CaseAccessors(domain_name).get_case_ids_in_domain()), 1)
self.domain.delete()
self.assertEqual(
len(CaseAccessors(self.domain.name).get_case_ids_in_domain()), 0)
self.assertEqual(
len(CaseAccessors(self.domain2.name).get_case_ids_in_domain()), 1)
def test_associated_usercase_closed(self):
usercase_ids = self.case_accessor.get_case_ids_in_domain(type=USERCASE_TYPE)
for usercase_id in usercase_ids:
CaseFactory(self.domain).close_case(usercase_id)
usercase = self.case_accessor.get_case(usercase_id)
send_to_elasticsearch(
"case_search", transform_case_for_elasticsearch(usercase.to_json())
)
self.es.indices.refresh(CASE_SEARCH_INDEX_INFO.index)
self.assertTrue(associated_user_case_closed(self.checkin_case, None))
def make_checkin_case(self, properties=None):
properties = properties if properties is not None else {"username": self.mobile_worker.raw_username}
checkin_case = CaseFactory(self.domain).create_case(
case_type="checkin",
owner_id=self.mobile_worker.get_id,
update=properties,
)
send_to_elasticsearch(
"case_search", transform_case_for_elasticsearch(checkin_case.to_json())
)
self.es.indices.refresh(CASE_SEARCH_INDEX_INFO.index)
return checkin_case
def setUpClass(cls):
super().setUpClass()
delete_all_users()
cls.domain_obj = create_domain(cls.domain)
enable_usercase(cls.domain)
cls.factory = CaseFactory(domain=cls.domain)
cls.case_accessor = CaseAccessors(cls.domain)
cls.mobile_worker = CommCareUser.create(cls.domain, "username", "p@ssword123", None, None)
cls.user_id = cls.mobile_worker.user_id
def setUpClass(cls):
super(TestFormsExpressionSpecWithFilter, cls).setUpClass()
cls.domain = uuid.uuid4().hex
factory = CaseFactory(domain=cls.domain)
[cls.case] = factory.create_or_update_case(CaseStructure(attrs={'create': True}))
cls.forms = [f.to_json() for f in FormAccessors(cls.domain).get_forms(cls.case.xform_ids)]
# redundant case to create extra forms that shouldn't be in the results for cls.case
[cls.case_b] = factory.create_or_update_case(CaseStructure(attrs={'create': True}))
cls.forms_b = [f.to_json() for f in FormAccessors(cls.domain).get_forms(cls.case_b.xform_ids)]
cls._setup_es_for_data()
def test_recursive_indexes(self):
factory = CaseFactory()
[case] = factory.create_or_update_case(CaseStructure(
case_id='infinite-recursion',
attrs={'case_type': 'bug', 'create': True},
indices=[CaseIndex(CaseStructure(case_id='infinite-recursion', attrs={'create': True}), related_type='bug')],
walk_related=False
))
# this call used to fail with infinite recursion
hierarchy = get_case_hierarchy(case, {})
self.assertEqual(1, len(hierarchy['case_list']))
def test_case_close_format(self):
# create a case
self.post_xml(self.xform_xml, self.domain_name)
payload = self.repeat_records(self.domain_name).all()[0].get_payload()
self.assertXmlHasXpath(payload, '//*[local-name()="case"]')
self.assertXmlHasXpath(payload, '//*[local-name()="create"]')
# close the case
CaseFactory().close_case(CASE_ID)
close_payload = self.repeat_records(self.domain_name).all()[1].get_payload()
self.assertXmlHasXpath(close_payload, '//*[local-name()="case"]')
self.assertXmlHasXpath(close_payload, '//*[local-name()="close"]')
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(TestGetSubcasesExpression, self).setUp()
self.domain = uuid.uuid4().hex
self.factory = CaseFactory(domain=self.domain)
self.expression = ExpressionFactory.from_spec({
"type": "get_subcases",
"case_id_expression": {
"type": "property_name",
"property_name": "_id"
},
})
self.context = EvaluationContext({"domain": self.domain})
def handle(self, domain, num_root_items, owner_ids, **kwargs):
num_cases = 0
structures = []
for n in with_progress_bar(range(num_root_items)):
owner = random.choice(owner_ids)
# use a random locale for every 3 cases, otherwise use english
# remove hu_HU because: https://github.com/joke2k/faker/pull/756
locale = (random.choice(list(faker.config.AVAILABLE_LOCALES - set(['hu_HU'])))
if n % 3 == 0 else 'en_US')
structures.extend(self._create_case_structure(locale, owner))
if len(structures) >= 50:
num_cases += len(CaseFactory(domain).create_or_update_cases(structures, user_id=owner))
structures = []
num_cases += len(CaseFactory(domain).create_or_update_cases(structures, user_id=owner))
print("Created: {} cases".format(num_cases))
self._generate_data_dictionary(domain)
print("Generated data dictionary")
if(self._generate_sample_app(domain)):
print ("Generated Sample App")
def case_form_data():
from casexml.apps.case.mock import CaseFactory
factory = CaseFactory('domain')
cases = []
forms = []
for i in range(3):
case_id = uuid.uuid4().hex
case_block = factory.get_case_block(case_id, case_type='case_type')
form, [case] = factory.post_case_blocks([case_block])
cases.append(case)
forms.append(form)
case_ids = [case.case_id for case in cases]
def handle(self, domain, num_root_items, owner_ids, **kwargs):
num_cases = 0
for n in range(num_root_items):
owner = random.choice(owner_ids)
# use a random locale for every 3 cases, otherwise use english
locale = random.choice(list(
faker.config.AVAILABLE_LOCALES)) if n % 3 == 0 else 'en_US'
structures = self._create_case_structure(locale, owner)
num_cases += len(
CaseFactory(domain).create_or_update_cases(structures,
user_id=owner))
print("Created: {} cases".format(num_cases))
def test_nikshay_case_from_enikshay_not_duplicated(self):
call_command('create_enikshay_cases', self.domain, 'test_migration')
person_case_ids = self.case_accessor.get_case_ids_in_domain(
type='person')
assert len(person_case_ids) == 1
person_case = self.case_accessor.get_case(person_case_ids[0])
assert person_case.name == ORIGINAL_PERSON_NAME
assert len(
self.case_accessor.get_case_ids_in_domain(type='occurrence')) == 1
episode_case_ids = self.case_accessor.get_case_ids_in_domain(
type='episode')
assert len(episode_case_ids) == 1
episode_case_id = episode_case_ids[0]
assert len(
self.case_accessor.get_case_ids_in_domain(
type='drtb-hiv-referral')) == 0
new_nikshay_name = 'PERSON NAME SHOULD NOT BE CHANGED'
self.patient_detail.pname = new_nikshay_name
self.patient_detail.save()
CaseFactory(self.domain).create_or_update_cases([
CaseStructure(
attrs={
'create': False,
'update': {
'migration_created_case': 'false',
}
},
case_id=episode_case_id,
)
])
episode_case = self.case_accessor.get_case(episode_case_id)
assert episode_case.dynamic_case_properties(
)['migration_created_case'] == 'false'
call_command('create_enikshay_cases', self.domain, 'test_migration')
person_case_ids = self.case_accessor.get_case_ids_in_domain(
type='person')
self.assertEqual(len(person_case_ids), 1)
person_case = self.case_accessor.get_case(person_case_ids[0])
self.assertEqual(person_case.name, ORIGINAL_PERSON_NAME)
self.assertEqual(
len(self.case_accessor.get_case_ids_in_domain(type='occurrence')),
1)
self.assertEqual(
len(self.case_accessor.get_case_ids_in_domain(type='episode')), 1)
self.assertEqual(
len(
self.case_accessor.get_case_ids_in_domain(
type='drtb-hiv-referral')), 0)
