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)