class _BaseTestAppDiffs(object): def setUp(self): super(_BaseTestAppDiffs, self).setUp() self.factory1 = AppFactory() self.app1 = self.factory1.app self.factory1.new_basic_module('module_1', 'case') self.factory2 = AppFactory() self.app2 = self.factory2.app self.factory2.new_basic_module('module_1', 'case') def _add_question(self, form, options=None): if options is None: options = {'name': 'name', 'label': "Name"} if 'name' not in options: options['name'] = 'name' if 'label' not in options: options['label'] = "Name" builder = XFormBuilder(form.name, form.source if form.source else None) builder.new_question(**options) form.source = builder.tostring(pretty_print=True).decode('utf-8') def _add_question_to_group(self, form, options): builder = XFormBuilder(form.name, form.source if form.source else None) group_name = options['group'] builder.new_group(group_name, group_name) builder.new_question(**options) form.source = builder.tostring(pretty_print=True).decode('utf-8')
def test_case_list_form_parent_child_basic(self): """ * Register house (case type = house, basic) * Register house form * Register person (case type = person, parent select = 'Register house', basic) * Register person form * Manager person (case type = person, case list form = 'Register person form', basic) * Manage person form """ factory = AppFactory(build_version='2.9') register_house_module, register_house_form = factory.new_basic_module('register_house', 'house') factory.form_opens_case(register_house_form) register_person_module, register_person_form = factory.new_basic_module('register_person', 'house') factory.form_updates_case(register_person_form) factory.form_opens_case(register_person_form, case_type='person', is_subcase=True) person_module, update_person_form = factory.new_basic_module( 'update_person', 'person', case_list_form=register_person_form ) factory.form_updates_case(update_person_form, parent_case_type='house') self.assertXmlEqual(self.get_xml('case-list-form-suite-parent-child-basic'), factory.app.create_suite())
def test_case_list_form_parent_child_basic(self): # * Register house (case type = house, basic) # * Register house form # * Register person (case type = person, parent select = 'Register house', basic) # * Register person form # * Manager person (case type = person, case list form = 'Register person form', basic) # * Manage person form factory = AppFactory(build_version='2.9.0') register_house_module, register_house_form = factory.new_basic_module('register_house', 'house') factory.form_opens_case(register_house_form) register_person_module, register_person_form = factory.new_basic_module('register_person', 'house') factory.form_requires_case(register_person_form) factory.form_opens_case(register_person_form, case_type='person', is_subcase=True) person_module, update_person_form = factory.new_basic_module( 'update_person', 'person', case_list_form=register_person_form ) factory.form_requires_case(update_person_form, parent_case_type='house') register_person_module.case_details.short.columns.append( DetailColumn( header={'en': 'a'}, model='case', field='parent/case_name', # Include a parent case property in the case list format='plain', ) ) self.assertXmlEqual(self.get_xml('case-list-form-suite-parent-child-basic'), factory.app.create_suite())
def setUpClass(cls): super(TestCaseDelayedSchema, cls).setUpClass() factory = AppFactory(domain=cls.domain) module1, form1 = factory.new_basic_module('update_case', cls.case_type) factory.form_requires_case(form1, cls.case_type, update={ 'age': '/data/age', 'height': '/data/height', }) cls.current_app = factory.app cls.current_app._id = '1234' factory = AppFactory(domain=cls.domain) module1, form1 = factory.new_basic_module('update_case', cls.case_type) factory.form_requires_case(form1, cls.case_type, update={ 'age': '/data/age', 'height': '/data/height', 'weight': '/data/weight', }) cls.build = factory.app cls.build.copy_of = cls.current_app._id cls.build.version = 5 cls.build.has_submissions = True cls.apps = [ cls.current_app, cls.build, ] with drop_connected_signals(app_post_save): for app in cls.apps: app.save()
def test_grid_menu_for_none(self): factory = AppFactory(build_version='2.24.3') factory.app.create_profile() factory.app.grid_form_menus = 'none' factory.new_basic_module('registration', 'patient') factory.app.get_module(0).display_style = 'grid' root_xpath = './menu[@id="root"]' m0_xpath = './menu[@id="m0"]' # with Modules Menu to be list should not render root menu and render module w/o style=grid factory.app.use_grid_menus = False suite = factory.app.create_suite() self.assertXmlDoesNotHaveXpath(suite, root_xpath) self.assertXmlPartialEqual( '<partial><menu id="m0"><text><locale id="modules.m0"/></text><command id="m0-f0"/></menu></partial>', suite, m0_xpath ) # with Modules Menu to be grid should render root menu w/ style=grid and render module w/o style=grid factory.app.use_grid_menus = True suite = factory.app.create_suite() self.assertXmlPartialEqual( '<partial><menu id="root" style="grid"><text/></menu></partial>', suite, root_xpath ) self.assertXmlPartialEqual( '<partial><menu id="m0"><text><locale id="modules.m0"/></text><command id="m0-f0"/></menu></partial>', suite, m0_xpath )
def _get_app(self): from corehq.apps.app_manager.tests.app_factory import AppFactory factory = AppFactory() factory.new_basic_module('m0', 'case1') factory.new_basic_module('m1', 'case2') factory.new_advanced_module('m2', 'case3') return factory.app
class FormFilterErrorTests(SimpleTestCase, TestXmlMixin): file_path = ('data', 'suite') def setUp(self): self.suite_xml_is_usercase_in_use_patch = patch( 'corehq.apps.app_manager.suite_xml.sections.menus.is_usercase_in_use' ) self.suite_xml_is_usercase_in_use_mock = self.suite_xml_is_usercase_in_use_patch.start() self.factory = AppFactory(build_version='2.9') def tearDown(self): self.suite_xml_is_usercase_in_use_patch.stop() def test_error_when_no_case(self): self.suite_xml_is_usercase_in_use_mock.return_value = True __, reg_form = self.factory.new_basic_module('reg_module', 'mother') self.factory.form_opens_case(reg_form) reg_form.form_filter = './due_date <= today()' with self.assertRaises(CaseXPathValidationError): self.factory.app.create_suite() def test_no_error_when_user_case(self): self.suite_xml_is_usercase_in_use_mock.return_value = True __, reg_form = self.factory.new_basic_module('reg_module', 'mother') self.factory.form_opens_case(reg_form) reg_form.form_filter = '#user/due_date <= today()' expected = """ <partial> <menu id="m0"> <text> <locale id="modules.m0"/> </text> <command id="m0-f0" relevant="instance('casedb')/casedb/case[@case_type='commcare-user'][hq_user_id=instance('commcaresession')/session/context/userid]/due_date <= today()"/> </menu> </partial> """ self.assertXmlPartialEqual(expected, self.factory.app.create_suite(), './menu') def test_no_error_when_case(self): self.suite_xml_is_usercase_in_use_mock.return_value = False __, update_form = self.factory.new_basic_module('update_mother', 'mother') self.factory.form_requires_case(update_form) update_form.form_filter = '#case/due_date <= today()' expected = """ <partial> <menu id="m0"> <text> <locale id="modules.m0"/> </text> <command id="m0-f0" relevant="instance('casedb')/casedb/case[@case_id=instance('commcaresession')/session/data/case_id]/due_date <= today()"/> </menu> </partial> """ self.assertXmlPartialEqual(expected, self.factory.app.create_suite(), './menu')
def test_manual_form_link(self): factory = AppFactory(build_version='2.9.0/latest') m0, m0f0 = factory.new_basic_module('enroll child', 'child') factory.form_opens_case(m0f0) m1, m1f0 = factory.new_basic_module('child visit', 'child') factory.form_requires_case(m1f0) factory.form_opens_case(m1f0, case_type='visit', is_subcase=True) m2, m2f0 = factory.new_advanced_module('visit history', 'visit', parent_module=m1) factory.form_requires_case(m2f0, 'child') factory.form_requires_case(m2f0, 'visit', parent_case_type='child') m0f0.post_form_workflow = WORKFLOW_FORM m0f0.form_links = [ FormLink(xpath="true()", form_id=m1f0.unique_id, datums=[ FormDatum(name='case_id', xpath="instance('commcaresession')/session/data/case_id_new_child_0") ]), ] m1f0.post_form_workflow = WORKFLOW_FORM m1f0.form_links = [ FormLink(xpath="true()", form_id=m2f0.unique_id, datums=[ FormDatum(name='case_id', xpath="instance('commcaresession')/session/data/case_id"), FormDatum(name='case_id_load_visit_0', xpath="instance('commcaresession')/session/data/case_id_new_visit_0"), ]), ] self.assertXmlPartialEqual(self.get_xml('form_link_tdh'), factory.app.create_suite(), "./entry")
def test_return_to_child_module(self): factory = AppFactory(build_version='2.9.0/latest') m0, m0f0 = factory.new_basic_module('enroll child', 'child') factory.form_opens_case(m0f0) m1, m1f0 = factory.new_basic_module('child visit', 'child') factory.form_requires_case(m1f0) factory.form_opens_case(m1f0, case_type='visit', is_subcase=True) m2, m2f0 = factory.new_advanced_module('visit history', 'visit', parent_module=m1) factory.form_requires_case(m2f0, 'child') factory.form_requires_case(m2f0, 'visit', parent_case_type='child') m2f0.post_form_workflow = WORKFLOW_MODULE expected = """ <partial> <stack> <create> <command value="'m1'"/> <datum id="case_id" value="instance('commcaresession')/session/data/case_id"/> <datum id="case_id_new_visit_0" value="uuid()"/> <command value="'m2'"/> </create> </stack> </partial> """ self.assertXmlPartialEqual(expected, factory.app.create_suite(), "./entry[3]/stack")
def test_case_list_form_parent_child_advanced(self): """ * Register house (case type = house, basic) * Register house form * Register person (case type = person, parent select = 'Register house', advanced) * Register person form * Manager person (case type = person, case list form = 'Register person form', basic) * Manage person form """ factory = AppFactory(build_version='2.9') register_house_module, register_house_form = factory.new_basic_module('register_house', 'house') factory.form_opens_case(register_house_form) register_person_module, register_person_form = factory.new_advanced_module('register_person', 'person') factory.form_requires_case(register_person_form, 'house') factory.form_opens_case(register_person_form, 'person', is_subcase=True) person_module, update_person_form = factory.new_basic_module( 'update_person', 'person', case_list_form=register_person_form ) person_module.parent_select.active = True person_module.parent_select.module_id = register_house_module.unique_id factory.form_requires_case(update_person_form) self.assertXmlEqual(self.get_xml('case-list-form-suite-parent-child-advanced'), factory.app.create_suite())
def test_case_list_form_parent_child_submodule_mixed(self): # * Register house (case type = house, basic) # * Register house form # * Register person (case type = person, parent select = 'Register house', advanced) # * Register person form # * Update house (case type = house, case list form = 'Register house') # * Update house form # * Update person (case type = person, case list form = 'Register person form', advanced, parent module = 'Update house') # * Update person form factory = AppFactory(build_version='2.9.0') register_house_module, register_house_form = factory.new_basic_module('register_house', 'house') factory.form_opens_case(register_house_form) register_person_module, register_person_form = factory.new_basic_module('register_person', 'house') factory.form_requires_case(register_person_form, 'house') factory.form_opens_case(register_person_form, 'person', is_subcase=True) house_module, update_house_form = factory.new_advanced_module( 'update_house', 'house', case_list_form=register_house_form ) factory.form_requires_case(update_house_form) person_module, update_person_form = factory.new_basic_module( 'update_person', 'person', parent_module=house_module, case_list_form=register_person_form ) factory.form_requires_case(update_person_form, 'person', parent_case_type='house') self.assertXmlEqual(self.get_xml('case-list-form-suite-parent-child-submodule-mixed'), factory.app.create_suite())
def test_that_grid_style_is_added(self): """ Confirms that style="grid" is added to the root menu """ factory = AppFactory(build_version='2.24.0') factory.app.use_grid_menus = True factory.new_basic_module('registration', 'patient registration') factory.app.get_module(0).put_in_root = True factory.new_basic_module('visit', 'patient visit') factory.app.get_module(1).put_in_root = True suite = factory.app.create_suite() root_xpath = './menu[@id="root"]' self.assertXmlHasXpath(suite, root_xpath) self.assertXmlPartialEqual( """ <partial> <menu id="root" style="grid"> <text><locale id="modules.m0"/></text> <command id="m0-f0"/> </menu> <menu id="root" style="grid"> <text><locale id="modules.m1"/></text> <command id="m1-f0"/> </menu> </partial> """, suite, root_xpath )
def _get_app(self): from corehq.apps.app_manager.tests.app_factory import AppFactory factory = AppFactory() factory.new_basic_module("m0", "case1") factory.new_basic_module("m1", "case2") factory.new_advanced_module("m2", "case3") return factory.app
def setUpClass(cls): super(UCRAggregationTest, cls).setUpClass() # cleanup any previous data cls._cleanup_data() # setup app factory = AppFactory(domain=cls.domain) # parent case module, incl opening child cases of main type m_parent, f_parent = factory.new_basic_module('Parent Module', cls.parent_case_type) factory.form_opens_case(f_parent, case_type=cls.parent_case_type) factory.form_opens_case(f_parent, case_type=cls.case_type, is_subcase=True) # main module m0, f0 = factory.new_basic_module('A Module', cls.case_type) f1 = factory.new_form(m0) f1.source = cls._get_xform() factory.form_requires_case(f1, case_type=cls.case_type, update={ cp[0]: '/data/{}'.format(cp[0]) for cp in cls.case_properties }) cls.followup_form = f1 cls.app = factory.app cls.app.save() # create form and case ucrs cls.form_data_source = get_form_data_source(cls.app, cls.followup_form) cls.case_data_source = get_case_data_source(cls.app, cls.case_type) cls.parent_case_data_source = get_case_data_source(cls.app, cls.parent_case_type) # create some data - first just create the case cls.parent_case_id = cls._create_parent_case(cls.parent_name) cls.case_id = cls._create_case(cls.parent_case_id) for fu_date in cls.fu_visit_dates: cls._submit_followup_form(cls.case_id, received_on=fu_date) # the closed case causes there to be some data with an end_column cls.closed_case_id = cls._create_closed_case() # populate the UCRs with the data we just created cls.form_adapter = get_indicator_adapter(cls.form_data_source) cls.case_adapter = get_indicator_adapter(cls.case_data_source) cls.parent_case_adapter = get_indicator_adapter(cls.parent_case_data_source) cls.form_adapter.rebuild_table() cls.case_adapter.rebuild_table() cls.parent_case_adapter.rebuild_table() _iteratively_build_table(cls.form_data_source) _iteratively_build_table(cls.case_data_source) _iteratively_build_table(cls.parent_case_data_source) # setup AggregateTableDefinition cls.monthly_aggregate_table_definition = cls._get_monthly_aggregate_table_definition() cls.weekly_aggregate_table_definition = cls._get_weekly_aggregate_table_definition() cls.basic_aggregate_table_definition = cls._get_basic_aggregate_table_definition() # and adapter cls.monthly_adapter = get_indicator_adapter(cls.monthly_aggregate_table_definition)
def test_grid_menu_for_all(self): factory = AppFactory(build_version='2.24.3') self.assertTrue(factory.app.grid_menu_toggle_enabled()) factory.app.create_profile() factory.app.grid_form_menus = 'all' factory.new_basic_module('registration', 'patient') suite = factory.app.create_suite() root_xpath = './menu[@id="root"]' grid_module_xpath = './menu[@id="m0"]' # with Modules Menu to be list should not render root menu and render module w/ style=grid factory.app.use_grid_menus = False self.assertXmlDoesNotHaveXpath(suite, root_xpath) self.assertXmlPartialEqual( '<partial><menu id="m0" style="grid"><text><locale id="modules.m0"/></text>\ <command id="m0-f0"/></menu></partial>', suite, grid_module_xpath ) # with Modules Menu to be grid should render root menu and module w/ style=grid factory.app.use_grid_menus = True suite = factory.app.create_suite() self.assertXmlPartialEqual( '<partial><menu id="root" style="grid"><text/></menu></partial>', suite, root_xpath ) self.assertXmlPartialEqual( '<partial><menu id="m0" style="grid"><text><locale id="modules.m0"/></text>\ <command id="m0-f0"/></menu></partial>', suite, grid_module_xpath ) # with Modules Menu to be list and module itself being the root should render root w/o style=grid with # module content factory.app.use_grid_menus = False factory.app.get_module(0).put_in_root = True suite = factory.app.create_suite() self.assertXmlPartialEqual( '<partial><menu id="root"><text><locale id="modules.m0"/></text>\ <command id="m0-f0"/></menu></partial>', suite, root_xpath ) # with Modules Menu to be grid and module itself being the root should render root w/ style=grid with # module content factory.app.get_module(0).put_in_root = True factory.app.use_grid_menus = True suite = factory.app.create_suite() self.assertXmlPartialEqual( '<partial><menu id="root" style="grid"><text><locale id="modules.m0"/></text>\ <command id="m0-f0"/></menu></partial>', suite, root_xpath )
def test_use_grid_menus_is_false(self): """ Confirms that style="grid" is not added to any menus when use_grid_menus is False. """ factory = AppFactory(build_version='2.24.0') factory.app.use_grid_menus = False factory.new_basic_module('registration', 'patient') suite = factory.app.create_suite() style_xpath = './menu[@style="grid"]' self.assertXmlDoesNotHaveXpath(suite, style_xpath)
def test_with_case_management_both_update(self): factory = AppFactory(build_version="2.9.0/latest") m0, m0f0 = factory.new_basic_module("m0", "frog") factory.form_updates_case(m0f0) m1, m1f0 = factory.new_basic_module("m1", "frog") factory.form_updates_case(m1f0) m0f0.post_form_workflow = WORKFLOW_FORM m0f0.form_links = [FormLink(xpath="(today() - dob) > 7", form_id=m1f0.unique_id)] self.assertXmlPartialEqual(self.get_xml("form_link_update_case"), factory.app.create_suite(), "./entry[1]")
def test_with_case_management_create_update(self): factory = AppFactory(build_version='2.9.0/latest') m0, m0f0 = factory.new_basic_module('m0', 'frog') factory.form_opens_case(m0f0) m1, m1f0 = factory.new_basic_module('m1', 'frog') factory.form_requires_case(m1f0) m0f0.post_form_workflow = WORKFLOW_FORM m0f0.form_links = [ FormLink(xpath='true()', form_id=m1f0.unique_id) ] self.assertXmlPartialEqual(self.get_xml('form_link_create_update_case'), factory.app.create_suite(), "./entry[1]")
def _prep_case_list_form_app(self): factory = AppFactory(build_version='2.9') case_module, update_case_form = factory.new_basic_module('case_module', 'suite_test') factory.form_updates_case(update_case_form) register_module, register_form = factory.new_basic_module('register_case', 'suite_test') factory.form_opens_case(register_form) case_module.case_list_form.form_id = register_form.get_unique_id() case_module.case_list_form.label = { 'en': 'New Case' } return factory
def test_link_to_form_in_parent_module(self): factory = AppFactory(build_version="2.9.0/latest") m0, m0f0 = factory.new_basic_module("enroll child", "child") factory.form_opens_case(m0f0) m1, m1f0 = factory.new_basic_module("child visit", "child") factory.form_updates_case(m1f0) m2, m2f0 = factory.new_advanced_module("visit history", "visit", parent_module=m1) factory.form_updates_case(m2f0, "child") # link to child -> edit child m2f0.post_form_workflow = WORKFLOW_FORM m2f0.form_links = [FormLink(xpath="true()", form_id=m1f0.unique_id)] self.assertXmlPartialEqual(self.get_xml("form_link_child_modules"), factory.app.create_suite(), "./entry[3]")
def test_default_app_strings_with_build_profiles(self): factory = AppFactory(build_version='2.40.0') factory.app.langs = ['en', 'es'] factory.app.build_profiles = OrderedDict({ 'en': BuildProfile(langs=['en'], name='en-profile'), 'es': BuildProfile(langs=['es'], name='es-profile'), }) module, form = factory.new_basic_module('my_module', 'cases') module.name = { 'en': 'Alive', 'es': 'Viva', } form.name = { 'en': 'Human', 'es': 'Humana', } all_default_strings = self._generate_app_strings(factory.app, 'default') self.assertEqual(all_default_strings['modules.m0'], module.name['en']) self.assertEqual(all_default_strings['forms.m0f0'], form.name['en']) en_default_strings = self._generate_app_strings(factory.app, 'default', build_profile_id='en') self.assertEqual(en_default_strings['modules.m0'], module.name['en']) self.assertEqual(en_default_strings['forms.m0f0'], form.name['en']) es_default_strings = self._generate_app_strings(factory.app, 'default', build_profile_id='es') self.assertEqual(es_default_strings['modules.m0'], module.name['es']) self.assertEqual(es_default_strings['forms.m0f0'], form.name['es'])
def test_form_links_submodule(self): """ Test that when linking between two forms in a submodule we match up the session variables between the source and target form correctly :return: """ factory = AppFactory(build_version='2.9.0/latest') m0, m0f0 = factory.new_basic_module('child visit', 'child') factory.form_requires_case(m0f0) factory.form_opens_case(m0f0, 'visit', is_subcase=True) m1, m1f0 = factory.new_advanced_module('visit histroy', 'visit', parent_module=m0) factory.form_requires_case(m1f0, 'child') factory.form_requires_case(m1f0, 'visit', parent_case_type='child') m1f1 = factory.new_form(m1) factory.form_requires_case(m1f1, 'child') factory.form_requires_case(m1f1, 'visit', parent_case_type='child') m1f0.post_form_workflow = WORKFLOW_FORM m1f0.form_links = [ FormLink(xpath="true()", form_id=m1f1.unique_id), ] self.assertXmlPartialEqual(self.get_xml('form_link_submodule'), factory.app.create_suite(), "./entry")
def test_scheduler_module(self): factory = AppFactory() m1, m1f1 = factory.new_basic_module('open_case', 'house') factory.form_opens_case(m1f1) m2, m2f1 = factory.new_advanced_module('scheduler_module', 'house') m2f2 = factory.new_form(m2) factory.form_requires_case(m2f1, case_type='house', update={ 'foo': '/data/question1', 'bar': '/data/question2', }) factory.form_requires_case(m2f2, case_type='house', update={ 'bleep': '/data/question1', 'bloop': '/data/question2', }) self._add_scheduler_to_module(m2) self._add_scheduler_to_form(m2f1, m2, 'form1') self._add_scheduler_to_form(m2f2, m2, 'form2') self.assertCaseProperties(factory.app, 'house', [ 'foo', 'bar', 'bleep', 'bloop', # Scheduler properties: 'last_visit_date_form1', 'last_visit_number_form1', 'last_visit_date_form2', 'last_visit_number_form2', 'current_schedule_phase', ])
def test_manual_form_link_with_fallback(self): factory = AppFactory(build_version='2.9.0') m0, m0f0 = factory.new_basic_module('enroll child', 'child') factory.form_opens_case(m0f0) m1, m1f0 = factory.new_basic_module('child visit', 'child') factory.form_requires_case(m1f0) factory.form_opens_case(m1f0, case_type='visit', is_subcase=True) m2, m2f0 = factory.new_advanced_module('visit history', 'visit', parent_module=m1) factory.form_requires_case(m2f0, 'child') factory.form_requires_case(m2f0, 'visit', parent_case_type='child') m0f0.post_form_workflow = WORKFLOW_FORM m0f0.form_links = [ FormLink(xpath="true()", form_id=m1f0.unique_id, datums=[ FormDatum(name='case_id', xpath="instance('commcaresession')/session/data/case_id_new_child_0") ]), ] m1f0.post_form_workflow = WORKFLOW_FORM condition_for_xpath = "instance('casedb')/casedb/case[@case_id = " \ "instance('commcaresession')/session/data/case_id]/prop = 'value'" m1f0.form_links = [ FormLink(xpath="true()", form_id=m2f0.unique_id, datums=[ FormDatum(name='case_id', xpath="instance('commcaresession')/session/data/case_id"), FormDatum(name='case_id_load_visit_0', xpath="instance('commcaresession')/session/data/case_id_new_visit_0"), ]), FormLink(xpath=condition_for_xpath, form_id=m2f0.unique_id, datums=[ FormDatum(name='case_id', xpath="instance('commcaresession')/session/data/case_id"), FormDatum(name='case_id_load_visit_0', xpath="instance('commcaresession')/session/data/case_id_new_visit_0"), ]), ] m1f0.post_form_workflow_fallback = WORKFLOW_PREVIOUS self.assertXmlPartialEqual(self.get_xml('form_link_tdh_with_fallback_previous'), factory.app.create_suite(), "./entry") m1f0.post_form_workflow_fallback = WORKFLOW_MODULE self.assertXmlPartialEqual(self.get_xml('form_link_tdh_with_fallback_module'), factory.app.create_suite(), "./entry") m1f0.post_form_workflow_fallback = WORKFLOW_ROOT self.assertXmlPartialEqual(self.get_xml('form_link_tdh_with_fallback_root'), factory.app.create_suite(), "./entry")
def test_grid_menu_for_some(self): factory = AppFactory(build_version='2.24.3') factory.app.create_profile() factory.app.grid_form_menus = 'some' factory.new_basic_module('registration', 'patient') factory.new_basic_module('visit', 'patient visit') factory.app.get_module(1).display_style = 'grid' root_xpath = './menu[@id="root"]' grid_module_xpath = './menu[@id="m1"]' # with Modules Menu to be list should not render root menu and render module w/ style=grid factory.app.use_grid_menus = False suite = factory.app.create_suite() self.assertXmlDoesNotHaveXpath(suite, root_xpath) self.assertXmlHasXpath(suite, grid_module_xpath) self.assertXmlPartialEqual( '<partial><menu id="m1" style="grid"><text><locale id="modules.m1"/></text>\ <command id="m1-f0"/></menu></partial>', suite, grid_module_xpath ) # with Modules Menu to be grid should render both root menu and module w/ style=grid factory.app.use_grid_menus = True suite = factory.app.create_suite() self.assertXmlHasXpath(suite, root_xpath) self.assertXmlPartialEqual( '<partial><menu id="root" style="grid"><text/></menu></partial>', suite, root_xpath ) self.assertXmlPartialEqual( '<partial><menu id="m1" style="grid"><text><locale id="modules.m1"/></text>\ <command id="m1-f0"/></menu></partial>', suite, grid_module_xpath ) # with module itself being the root should render root menu style=grid with module content factory.app.get_module(1).put_in_root = True suite = factory.app.create_suite() self.assertXmlPartialEqual( '<partial><menu id="root" style="grid"><text><locale id="modules.m1"/></text>\ <command id="m1-f0"/></menu></partial>', suite, root_xpath )
def test_case_list_form_reg_form_creates_child_case(self): factory = AppFactory(build_version='2.9.0') register_person_module, register_person_form = factory.new_basic_module('reg_person_and_stub', 'person') factory.form_opens_case(register_person_form) factory.form_opens_case(register_person_form, case_type='stub', is_subcase=True) person_module, update_person_form = factory.new_basic_module( 'update_person', 'person', case_list_form=register_person_form ) factory.form_requires_case(update_person_form) self.assertXmlPartialEqual( self.get_xml('case_list_form_reg_form_creates_child_case'), factory.app.create_suite(), './entry[1]' )
def _create_app(self, name): factory = AppFactory(domain=self.domain, name=name, build_version='2.11.0') module1, form1 = factory.new_basic_module('open_case', 'house') factory.form_opens_case(form1) app = factory.app app.save() self.addCleanup(app.delete) return app
def test_with_case_management_multiple_links(self): factory = AppFactory(build_version="2.9.0/latest") m0, m0f0 = factory.new_basic_module("m0", "frog") factory.form_opens_case(m0f0) m1, m1f0 = factory.new_basic_module("m1", "frog") factory.form_updates_case(m1f0) m1f1 = factory.new_form(m1) factory.form_opens_case(m1f1) m0f0.post_form_workflow = WORKFLOW_FORM m0f0.form_links = [ FormLink(xpath="a = 1", form_id=m1f0.unique_id), FormLink(xpath="a = 2", form_id=m1f1.unique_id), ] self.assertXmlPartialEqual(self.get_xml("form_link_multiple"), factory.app.create_suite(), "./entry[1]")
def test_that_root_menu_added(self): """ Confirms that a menu is added with id="root" and style="grid" when the app normally wouldn't have a menu with id="root". """ factory = AppFactory(build_version='2.24.0') factory.app.use_grid_menus = True factory.new_basic_module('registration', 'patient') suite = factory.app.create_suite() root_xpath = './menu[@id="root"]' self.assertXmlHasXpath(suite, root_xpath) self.assertXmlPartialEqual( '<partial><menu id="root" style="grid"><text/></menu></partial>', suite, root_xpath )
def test_link_to_form_in_parent_module(self): factory = AppFactory(build_version='2.9.0/latest') m0, m0f0 = factory.new_basic_module('enroll child', 'child') factory.form_opens_case(m0f0) m1, m1f0 = factory.new_basic_module('child visit', 'child') factory.form_requires_case(m1f0) m2, m2f0 = factory.new_advanced_module('visit history', 'visit', parent_module=m1) factory.form_requires_case(m2f0, 'child') # link to child -> edit child m2f0.post_form_workflow = WORKFLOW_FORM m2f0.form_links = [ FormLink(xpath="true()", form_id=m1f0.unique_id), ] self.assertXmlPartialEqual(self.get_xml('form_link_child_modules'), factory.app.create_suite(), "./entry[3]")
def _build_workflow_app(self, mode): factory = AppFactory(build_version='2.9.0/latest') m0, m0f0 = factory.new_basic_module('m0', '') factory.new_form(m0) m1, m1f0 = factory.new_basic_module('m1', 'patient') m1f1 = factory.new_form(m1) factory.form_opens_case(m1f0) factory.form_requires_case(m1f1) m2, m2f0 = factory.new_basic_module('m2', 'patient') m2f1 = factory.new_form(m2) factory.form_requires_case(m2f0) factory.form_requires_case(m2f1) m3, m3f0 = factory.new_basic_module('m3', 'child') m3f1 = factory.new_form(m3) factory.form_requires_case(m3f0, parent_case_type='patient') factory.form_requires_case(m3f1) m4, m4f0 = factory.new_advanced_module('m4', 'patient') factory.form_requires_case(m4f0, case_type='patient') factory.form_requires_case(m4f0, case_type='patient') m4f1 = factory.new_form(m4) factory.form_requires_case(m4f1, case_type='patient') factory.form_requires_case(m4f1, case_type='patient') factory.form_requires_case(m4f1, case_type='patient') m4f2 = factory.new_form(m4) factory.form_requires_case(m4f2, case_type='patient') factory.form_requires_case(m4f2, case_type='patient') factory.advanced_form_autoloads(m4f2, AUTO_SELECT_RAW, 'case_id') for module in factory.app.get_modules(): for form in module.get_forms(): form.post_form_workflow = mode return factory.app
def test_target_module_different_datums(self): # * Registration # * Register patient form # * open case (patient), update user_case # * Visits (case type = patient, case list form = 'Register patient') # * Visit form # * update case, open child case (visit), load from user_case # * Record notes # * update case, open child case (visit) # * Update patient # * update case factory = AppFactory(build_version='2.9') registration_module, registration_form = factory.new_basic_module('registration', 'patient') factory.form_opens_case(registration_form) factory.form_uses_usercase(registration_form, preload={'username': '******'}) visit_module, visit_form = factory.new_basic_module( 'visits', 'patient', case_list_form=registration_form ) factory.form_requires_case(visit_form) factory.form_opens_case(visit_form, 'visit', is_subcase=True) factory.form_uses_usercase(visit_form, preload={'username': '******'}) notes_form = factory.new_form(visit_module) factory.form_requires_case(notes_form) factory.form_opens_case(notes_form, 'visit', is_subcase=True) update_patient_form = factory.new_form(visit_module) factory.form_requires_case(update_patient_form) self.assertXmlPartialEqual( self.get_xml('target_module_different_datums'), factory.app.create_suite(), './entry')
def test_persistent_case_name_in_forms(self): """ Test that the detail-persistent attributes are set correctly when the module is configured to persist the case name at the top of the form. Also confirm that the appropriate <detail> element is added to the suite. """ factory = AppFactory() module, form = factory.new_basic_module("my_module", "person") factory.form_requires_case(form, "person") module.case_details.short.persist_case_context = True suite = factory.app.create_suite() self.assertXmlPartialEqual( """ <partial> <detail id="m0_persistent_case_context"> <title> <text/> </title> <field> <style font-size="large" horz-align="center"> <grid grid-height="1" grid-width="12" grid-x="0" grid-y="0"/> </style> <header> <text/> </header> <template> <text> <xpath function="case_name"/> </text> </template> </field> </detail> </partial> """, suite, "detail[@id='m0_persistent_case_context']") # The attribute we care about here is detail-persistent="m0_persistent_case_context" self.assertXmlPartialEqual( """ <partial> <datum detail-confirm="m0_case_long" detail-persistent="m0_persistent_case_context" detail-select="m0_case_short" id="case_id" nodeset="instance('casedb')/casedb/case[@case_type='person'][@status='open']" value="./@case_id" /> </partial> """, suite, "entry/session/datum")
class ReleaseFormsSetupMixin(object): def set_up_app(self): self.factory = AppFactory(build_version='2.30.0') training_module = self.factory.app.add_module( Module.new_training_module('training module', None)) self.releases_form = self.factory.app.new_form(training_module.id, "Untitled Form", None) self.releases_form.is_release_notes_form = True self.releases_form.xmlns = "http://openrosa.org/formdesigner/{}".format( uuid.uuid4().hex) basic_module, self.basic_form = self.factory.new_basic_module( "basic_module", "doctor", with_form=True) self.basic_form.xmlns = "http://openrosa.org/formdesigner/{}".format( uuid.uuid4().hex)
def test_fixture_to_case_selection(self): factory = AppFactory(build_version='2.9') module, form = factory.new_basic_module('my_module', 'cases') module.fixture_select.active = True module.fixture_select.fixture_type = 'days' module.fixture_select.display_column = 'my_display_column' module.fixture_select.variable_column = 'my_variable_column' module.fixture_select.xpath = 'date(scheduled_date) <= date(today() + $fixture_value)' factory.form_requires_case(form) self.assertXmlEqual(self.get_xml('fixture-to-case-selection'), factory.app.create_suite())
def test_case_list_lookup_display_results(self): factory = AppFactory(build_version='2.11.0') module, form = factory.new_basic_module('follow_up', 'case') case_list = module.case_details.short case_list.lookup_enabled = True case_list.lookup_action = "callout.commcarehq.org.dummycallout.LAUNCH" case_list.lookup_name = 'Scan fingerprint' case_list.lookup_extras = [ { 'key': 'deviceId', 'value': '123' }, { 'key': 'apiKey', 'value': '0000' }, { 'key': 'packageName', 'value': 'foo' }, ] case_list.lookup_responses = [{'key': 'fake'}] case_list.lookup_display_results = True case_list.lookup_field_header['en'] = 'Accuracy' case_list.lookup_field_template = '@case_id' expected = """ <partial> <lookup name="Scan fingerprint" action="callout.commcarehq.org.dummycallout.LAUNCH"> <extra key="deviceId" value="123"/> <extra key="apiKey" value="0000"/> <extra key="packageName" value="foo"/> <response key="fake"/> <field> <header> <text> <locale id="case_lists.m0.callout.header"/> </text> </header> <template> <text> <xpath function="@case_id"/> </text> </template> </field> </lookup> </partial> """ self.assertXmlPartialEqual(expected, factory.app.create_suite(), "./detail[@id='m0_case_short']/lookup")
def setUpClass(cls): super(AppManagerDataSourceConfigTest, cls).setUpClass() factory = AppFactory(domain=cls.domain) m0, f0 = factory.new_basic_module('A Module', cls.case_type) f0.source = get_simple_xform() cls.form = f0 factory.form_requires_case(f0, case_type=cls.case_type, update={ cp: '/data/{}'.format(cp) for cp in cls.case_properties.keys() }) cls.app = factory.app cls.app.save()
def class_setup(cls): cls.domain = uuid.uuid4().hex cls.f1_xmlns = 'xmlns1' cls.f2_xmlns = 'xmlns2' app_factory = AppFactory(domain=cls.domain) module1, form1 = app_factory.new_basic_module('m1', '_casetype') module2, form2 = app_factory.new_basic_module('m2', '_casetype2') form1.xmlns = cls.f1_xmlns form2.xmlns = cls.f2_xmlns app_factory.app.save() cls.app = app_factory.app deleted_app_factory = AppFactory(domain=cls.domain) deleted_module1, deleted_form1 = deleted_app_factory.new_basic_module( 'del-m1', '_casetype3') cls.deleted_xmlns = 'xmlns3' deleted_form1.xmlns = cls.deleted_xmlns deleted_app_factory.app.doc_type = 'Application-Deleted' # make sure the ID comes after the primary app deleted_app_factory.app._id = '{}z'.format(cls.app.id) deleted_app_factory.app.save() cls.deleted_app = deleted_app_factory.app cls.xmlnses = [cls.f1_xmlns, cls.f2_xmlns, cls.deleted_xmlns] update_reports_analytics_indexes()
def setUp(self): self.domain = "joto" self.case_type = 'teddiursa' app_factory = AppFactory(self.domain) m, f = app_factory.new_basic_module('m', self.case_type) app_factory.form_requires_case(f, case_type=self.case_type, update={ 'prop1': '/data/prop1', 'move_type': '/data/move_type', 'mood': '/data/mood', 'level': '/data/level' }) app_factory.app.save()
def test_training_module_as_child(self, *args): factory = AppFactory(build_version='2.43.0') app = factory.app parent_module = Module.new_module('parent', 'en') app.add_module(parent_module) training_module, _ = factory.new_basic_module('training', 'case_type', parent_module=parent_module) training_module.is_training_module = True self.assertIn({ 'type': 'training module child', 'module': {'id': 1, 'unique_id': 'training_module', 'name': {'en': 'training module'}} }, app.validate_app())
def test_case_list_form_parent_child_basic(self): # * Register house (case type = house, basic) # * Register house form # * Register person (case type = person, parent select = 'Register house', basic) # * Register person form # * Manager person (case type = person, case list form = 'Register person form', basic) # * Manage person form factory = AppFactory(build_version='2.9.0') register_house_module, register_house_form = factory.new_basic_module( 'register_house', 'house') factory.form_opens_case(register_house_form) register_person_module, register_person_form = factory.new_basic_module( 'register_person', 'house') factory.form_requires_case(register_person_form) factory.form_opens_case(register_person_form, case_type='person', is_subcase=True) person_module, update_person_form = factory.new_basic_module( 'update_person', 'person', case_list_form=register_person_form) factory.form_requires_case(update_person_form, parent_case_type='house') register_person_module.case_details.short.columns.append( DetailColumn( header={'en': 'a'}, model='case', field= 'parent/case_name', # Include a parent case property in the case list format='plain', )) self.assertXmlEqual( self.get_xml('case-list-form-suite-parent-child-basic'), factory.app.create_suite())
def test_grid_menu_for_some(self): factory = AppFactory(build_version='2.24.3') self.assertTrue(factory.app.grid_menu_toggle_enabled()) factory.app.create_profile() factory.app.grid_form_menus = 'some' factory.new_basic_module('registration', 'patient') factory.new_basic_module('visit', 'patient visit') factory.app.get_module(1).display_style = 'grid' root_xpath = './menu[@id="root"]' grid_module_xpath = './menu[@id="m1"]' # with Modules Menu to be list should not render root menu and render module w/ style=grid factory.app.use_grid_menus = False suite = factory.app.create_suite() self.assertXmlDoesNotHaveXpath(suite, root_xpath) self.assertXmlHasXpath(suite, grid_module_xpath) self.assertXmlPartialEqual( '<partial><menu id="m1" style="grid"><text><locale id="modules.m1"/></text>\ <command id="m1-f0"/></menu></partial>', suite, grid_module_xpath) # with Modules Menu to be grid should render both root menu and module w/ style=grid factory.app.use_grid_menus = True suite = factory.app.create_suite() self.assertXmlHasXpath(suite, root_xpath) self.assertXmlPartialEqual( '<partial><menu id="root" style="grid"><text/></menu></partial>', suite, root_xpath) self.assertXmlPartialEqual( '<partial><menu id="m1" style="grid"><text><locale id="modules.m1"/></text>\ <command id="m1-f0"/></menu></partial>', suite, grid_module_xpath) # with module itself being the root should render root menu style=grid with module content factory.app.get_module(1).put_in_root = True suite = factory.app.create_suite() self.assertXmlPartialEqual( '<partial><menu id="root" style="grid"><text><locale id="modules.m1"/></text>\ <command id="m1-f0"/></menu></partial>', suite, root_xpath)
def test_incorrect_case_var_for_case_update(self): # see http://manage.dimagi.com/default.asp?230013 factory = AppFactory(build_version='2.9.0') new_episode_module, new_episode_form = factory.new_basic_module( 'register_episode', 'episode') factory.form_opens_case(new_episode_form) lab_test_module, lab_test_form = factory.new_advanced_module( 'lab_test', 'episode') factory.form_requires_case(lab_test_form, 'episode') factory.form_opens_case(lab_test_form, 'lab_test', is_subcase=True, is_extension=True) factory.form_opens_case(lab_test_form, 'lab_referral', is_subcase=True, parent_tag='open_lab_test') lab_update_module, lab_update_form = factory.new_advanced_module( 'lab_update', 'lab_test', parent_module=lab_test_module) factory.form_requires_case(lab_update_form, 'episode', update={'episode_type': '/data/question1'}) factory.form_requires_case(lab_update_form, 'lab_test', parent_case_type='episode') lab_update_form.source = self.get_xml( 'original_form', override_path=('data', )).decode('utf-8') expected_suite_entry = """ <partial> <session> <datum id="case_id_load_episode_0" nodeset="instance('casedb')/casedb/case[@case_type='episode'][@status='open']" value="./@case_id" detail-select="m0_case_short"/> <datum id="case_id_new_lab_test_0" function="uuid()"/> <datum id="case_id_new_lab_referral_1" function="uuid()"/> <datum id="case_id_load_lab_test_0" nodeset="instance('casedb')/casedb/case[@case_type='lab_test'][@status='open'][index/parent=instance('commcaresession')/session/data/case_id_load_episode_0]" value="./@case_id" detail-select="m2_case_short" detail-confirm="m2_case_long"/> </session> </partial>""" suite_xml = factory.app.create_suite() self.assertXmlPartialEqual(expected_suite_entry, suite_xml, './entry[3]/session') form_xml = lab_update_form.render_xform().decode('utf-8') self.assertTrue( '<bind calculate="instance(\'commcaresession\')/session/data/case_id_new_lab_test_0" nodeset="/data/case_load_episode_0/case/@case_id"/>' not in form_xml) self.assertTrue( '<bind calculate="instance(\'commcaresession\')/session/data/case_id_load_episode_0" nodeset="/data/case_load_episode_0/case/@case_id"/>' in form_xml)
def test_form_linking_multiple_case_types_child_module(): factory = AppFactory(build_version='2.9.0') m0, m0f0 = factory.new_basic_module('register', 'jelly_baby') factory.form_opens_case(m0f0) m1, m1f0 = factory.new_basic_module('eat', 'jelly_baby') factory.form_requires_case(m1f0) factory.form_opens_case(m1f0, case_type='taste', is_subcase=True) m1.search_config.additional_case_types = ['liquorice'] m2, m2f0 = factory.new_basic_module('taste history', 'taste', parent_module=m1) factory.form_requires_case(m2f0, 'taste', parent_case_type='jelly_baby') m2.search_config.additional_case_types = ['smell'] m1f0.post_form_workflow = WORKFLOW_FORM m1f0.form_links = [ FormLink(form_id=m2f0.unique_id), ] suite = factory.app.create_suite() print(suite.decode('utf8')) expected_stack = """ <partial> <create> <command value="'m1'"/> <datum id="case_id" value="instance('commcaresession')/session/data/case_id"/> <datum id="case_id_new_taste_0" value="uuid()"/> <command value="'m2'"/> <datum id="case_id_taste" value="instance('commcaresession')/session/data/case_id_new_taste_0"/> <command value="'m2-f0'"/> </create> </partial>""" assert_xml_partial_equal(expected_stack, suite, "./entry[2]/stack/create")
def test_link_to_child_module(self): factory = AppFactory(build_version='2.9.0/latest') m0, m0f0 = factory.new_basic_module('enroll child', 'child') factory.form_opens_case(m0f0) m1, m1f0 = factory.new_basic_module('child visit', 'child') factory.form_requires_case(m1f0) factory.form_opens_case(m1f0, case_type='visit', is_subcase=True) m2, m2f0 = factory.new_advanced_module('visit history', 'visit', parent_module=m1) factory.form_requires_case(m2f0, 'child') factory.form_requires_case(m2f0, 'visit', parent_case_type='child') m0f0.post_form_workflow = WORKFLOW_FORM m0f0.form_links = [ FormLink(xpath="true()", form_id=m1f0.unique_id), ] m1f0.post_form_workflow = WORKFLOW_FORM m1f0.form_links = [ FormLink(xpath="true()", form_id=m2f0.unique_id), ] self.assertXmlPartialEqual(self.get_xml('form_link_tdh'), factory.app.create_suite(), "./entry")
def test_parent_preload(self): """ Test parent case is correctly set in preloads when first form of parent module updates a case """ factory = AppFactory(build_version='2.9.0') upd_goldfish_mod, upd_goldfish_form = factory.new_basic_module( 'upd_goldfish', 'gold-fish') factory.form_requires_case(upd_goldfish_form) guppy_mod, guppy_form = factory.new_basic_module( 'upd_guppy', 'guppy', parent_module=upd_goldfish_mod, ) guppy_form.source = self.get_xml( 'original_form', override_path=('data', )).decode('utf-8') factory.form_requires_case( guppy_form, 'guppy', parent_case_type='gold-fish', preload={'/data/question1': 'parent/question1'}) self.assertXmlEqual(self.get_xml('child-module-preload-parent-ref'), guppy_form.render_xform())
def test_update_from_specific_build(self, *args): factory = AppFactory(self.domain, "Upstream Application") m0, f0 = factory.new_basic_module("M1", None) f0.source = get_simple_form() master_app = factory.app master_app.save() self.addCleanup(master_app.delete) linked_app = LinkedApplication.new_app(self.linked_domain, "Linked Application") linked_app.save() self.addCleanup(linked_app.delete) copy1 = self._make_build(master_app, True) m1, f1 = factory.new_basic_module("M2", None) f1.source = get_simple_form() master_app.save() # increment version number self._make_build(master_app, True) update_linked_app(linked_app, copy1, 'test_update_from_specific_build') linked_app = LinkedApplication.get(linked_app._id) self.assertEqual(len(linked_app.modules), 1) self.assertEqual(linked_app.version, copy1.version)
def setUpClass(cls): super(ReportBuilderDBTest, cls).setUpClass() factory = AppFactory(domain=cls.domain) module, form = factory.new_basic_module('Untitled Module', cls.case_type) form.source = get_simple_xform() cls.form = form factory.form_requires_case(form, case_type=cls.case_type, update={ 'first_name': '/data/first_name', 'last_name': '/data/last_name', }) cls.app = factory.app cls.app.save()
def test_case_list_form_requires_parent_case_but_target_doesnt(self): factory = AppFactory(build_version='2.9.0') register_household_module, register_household_form = factory.new_basic_module( 'new_household', 'household') factory.form_opens_case(register_household_form) households, edit_household_form = factory.new_basic_module( 'households', 'household', case_list_form=register_household_form) factory.form_requires_case(edit_household_form) register_member_module, register_member_form = factory.new_advanced_module( 'new_member', 'member') factory.form_requires_case(register_member_form, 'household') factory.form_opens_case(register_member_form, 'member', is_subcase=True) members, edit_member_form = factory.new_basic_module( 'members', 'member', case_list_form=register_member_form) factory.form_requires_case(edit_member_form) suite = factory.app.create_suite() self.assertXmlEqual(self.get_xml('source_requires_case_target_doesnt'), suite)
def setUpClass(cls): super(AppManagerDataSourceConfigTest, cls).setUpClass() factory = AppFactory(domain=cls.domain) # create main form that defines case schema m0, f0 = factory.new_basic_module('Main Module', cls.case_type) f0.source = get_simple_xform() f0.name = {'en': 'Main Form'} factory.form_requires_case(f0, case_type=cls.case_type, update={ cp: '/data/{}'.format(cp) for cp in cls.case_properties.keys() }) cls.main_form = f0 # create another module/form to generate a parent case relationship # for the main case type m1, f1 = factory.new_basic_module('Parent Module', cls.parent_type) f1.source = get_simple_xform( ) # not used, just needs to be some valid XForm f1.name = {'en': 'Parent Form'} factory.form_opens_case(f1, case_type=cls.parent_type) factory.form_opens_case(f1, case_type=cls.case_type, is_subcase=True) cls.app = factory.app cls.app.save()
def test_empty_module_errors(self, *args): factory = AppFactory(build_version='2.24.0') app = factory.app m1 = factory.new_basic_module('register', 'case', with_form=False) factory.new_advanced_module('update', 'case', with_form=False) m2 = factory.new_basic_module('update', 'case', with_form=False) m2.case_list = CaseList(show=True, label={'en': "case_list"}) factory.new_shadow_module('update', m1, with_form=False) errors = app.validate_app() standard_module_error = { 'type': 'no forms or case list', 'module': {'id': 0, 'name': {'en': 'register module'}}, } advanced_module_error = { 'type': 'no forms or case list', 'module': {'id': 1, 'name': {'en': 'update module'}}, } self._clean_unique_id(errors) self.assertEqual(len(errors), 2) self.assertIn(standard_module_error, errors) self.assertIn(advanced_module_error, errors)
def test_fixture_to_case_selection_parent_child(self): factory = AppFactory(build_version='2.9') m0, m0f0 = factory.new_basic_module('parent', 'parent') m0.fixture_select.active = True m0.fixture_select.fixture_type = 'province' m0.fixture_select.display_column = 'display_name' m0.fixture_select.variable_column = 'var_name' m0.fixture_select.xpath = 'province = $fixture_value' factory.form_requires_case(m0f0) m1, m1f0 = factory.new_basic_module('child', 'child') m1.fixture_select.active = True m1.fixture_select.fixture_type = 'city' m1.fixture_select.display_column = 'display_name' m1.fixture_select.variable_column = 'var_name' m1.fixture_select.xpath = 'city = $fixture_value' factory.form_requires_case(m1f0, parent_case_type='parent') self.assertXmlEqual( self.get_xml('fixture-to-case-selection-parent-child'), factory.app.create_suite())
def get_app_with_case_search(domain): factory = AppFactory(domain=domain) for case_type, fields in [ ('person', ['name']), ('creative_work', ['name', 'parent/name']), ]: module, _ = factory.new_basic_module(case_type, case_type) module.search_config = CaseSearch( properties=[CaseSearchProperty(name=field) for field in fields]) module.case_details.short.columns = [ DetailColumn(format='plain', field=field, header={'en': field}, model=case_type) for field in fields ] return factory.app
def test_form_data_with_case_properties(self): factory = AppFactory() app = factory.app module1, form1 = factory.new_basic_module('open_case', 'household') form1_builder = XFormBuilder(form1.name) # question 0 form1_builder.new_question('name', 'Name') # question 1 (a group) form1_builder.new_group('demographics', 'Demographics') # question 2 (a question in a group) form1_builder.new_question('age', 'Age', group='demographics') # question 3 (a question that has a load property) form1_builder.new_question('polar_bears_seen', 'Number of polar bears seen') form1.source = form1_builder.tostring( pretty_print=True).decode('utf-8') factory.form_requires_case(form1, case_type='household', update={ 'name': '/data/name', 'age': '/data/demographics/age', }, preload={ '/data/polar_bears_seen': 'polar_bears_seen', }) app.save() modules, errors = get_app_summary_formdata(app.domain, app) q1_saves = modules[0]['forms'][0]['questions'][0]['save_properties'][0] self.assertEqual(q1_saves.case_type, 'household') self.assertEqual(q1_saves.property, 'name') group_saves = modules[0]['forms'][0]['questions'][2][ 'save_properties'][0] self.assertEqual(group_saves.case_type, 'household') self.assertEqual(group_saves.property, 'age') q3_loads = modules[0]['forms'][0]['questions'][3]['load_properties'][0] self.assertEqual(q3_loads.case_type, 'household') self.assertEqual(q3_loads.property, 'polar_bears_seen')
def test_case_list_form_parent_child_submodule_advanced_rename_case_var( self): """Test that the session vars in the entries for the submodule get updated to match the parent (and to avoid naming conflicts). m3-f0: 'case_id_load_house' -> 'case_id_load_house_renamed' m3-f0: 'case_id_load_house_renamed' -> 'case_id_load_house_renamed_person' """ factory = AppFactory(build_version='2.9') register_house_module, register_house_form = factory.new_basic_module( 'register_house', 'house') factory.form_opens_case(register_house_form) register_person_module, register_person_form = factory.new_advanced_module( 'register_person', 'person') factory.form_updates_case(register_person_form, 'house') factory.form_opens_case(register_person_form, 'person', is_subcase=True) house_module, update_house_form = factory.new_advanced_module( 'update_house', 'house', case_list_form=register_house_form) factory.form_updates_case(update_house_form) # changing this case tag should result in the session var in the submodule entry being updated to match it update_house_form.actions.load_update_cases[ 0].case_tag = 'load_house_renamed' person_module, update_person_form = factory.new_advanced_module( 'update_person', 'person', parent_module=house_module, case_list_form=register_person_form) factory.form_updates_case(update_person_form, 'house') factory.form_updates_case(update_person_form, 'person', parent_case_type='house') # making this case tag the same as the one in the parent module should mean that it will also # get changed to avoid conflicts update_person_form.actions.load_update_cases[ 1].case_tag = 'load_house_renamed' self.assertXmlEqual( self.get_xml( 'case-list-form-suite-parent-child-submodule-advanced-rename-var' ), factory.app.create_suite())
class TestCaseSearchLabelsMigration(TestCase): def setUp(self): self.domain = 'test-domain' self.factory = AppFactory(build_version='2.40.0', domain=self.domain) self.module, self.form = self.factory.new_basic_module('basic', 'patient') self.factory.app.save() @classmethod def tearDownClass(cls): delete_all_apps() super(TestCaseSearchLabelsMigration, cls).tearDownClass() def test_migration(self): # module with default case search labels self._remove_new_properties_from_doc(self.factory.app) call_command('migrate_case_search_labels', domain=self.domain) app, module = self._reload_app_and_module() self.assertEqual(self.module.search_config.search_label.label, {'en': 'Search All Cases'}) self.assertEqual(self.module.search_config.search_again_label.label, {'en': 'Search Again'}) # module with updated case search labels module.search_config.command_label = {'en': 'Find my cases'} module.search_config.again_label = {'en': 'Find Again', 'fr': 'trouve encore'} app.save() self._remove_new_properties_from_doc(app) call_command('migrate_case_search_labels', domain=self.domain) app, module = self._reload_app_and_module() self.assertEqual(module.search_config.search_label.label, {'en': 'Find my cases'}) self.assertEqual(module.search_config.search_again_label.label, {'en': 'Find Again', 'fr': 'trouve encore'}) @staticmethod def _remove_new_properties_from_doc(app): # remove the new properties from doc as how it would be during migration app_doc = app.to_json() module = app_doc["modules"][0] module["search_config"].pop("search_label") module["search_config"].pop("search_again_label") app.get_db().save_docs([app_doc]) def _reload_app_and_module(self): app = get_app(self.domain, self.factory.app.get_id) return app, list(app.get_modules())[0]
def test_tiered_select_with_advanced_module_as_parent_with_filters(self): factory = AppFactory(build_version='2.25') parent_module, parent_form = factory.new_advanced_module( 'parent', 'parent') parent_module.case_details.short.filter = 'parent_filter = 1' child_module, child_form = factory.new_basic_module('child', 'child') child_form.xmlns = 'http://id_m1-f0' child_module.case_details.short.filter = 'child_filter = 1' factory.form_requires_case(child_form) # make child module point to advanced module as parent child_module.parent_select.active = True child_module.parent_select.module_id = parent_module.unique_id self.assertXmlPartialEqual( self.get_xml('advanced_module_parent_filters'), factory.app.create_suite(), "./entry[2]")
def setUpClass(cls): super(TestAppCasePropertyReferences, cls).setUpClass() factory = AppFactory(domain=cls.domain) m0 = factory.new_basic_module('save_to_case', cls.case_type, with_form=False) m0f1 = m0.new_form('save to case', 'en', attachment=cls.get_xml('basic_form')) m0f1.case_references = CaseReferences.wrap({ 'save': { "/data/question1": { "case_type": cls.case_type, "properties": [ "save_to_case_p1", "save_to_case_p2" ], } } }) cls.current_app = factory.app cls.current_app.save()
def setUpClass(cls): super(TestTransifexBlacklist, cls).setUpClass() factory = AppFactory() app = factory.app app.langs = ['en', 'hin'] module, form = factory.new_basic_module('register', 'case') form.source = cls.get_xml('transifex_blacklist').decode('utf-8') with patch( 'corehq.apps.translations.generators.get_current_app') as mock: mock.return_value = app trans_gen = AppTranslationsGenerator('domain', 'app_id', 1, 'en', 'en', 'default_') translations = trans_gen.translations first_form_translations = translations['form_register_form_0_v1'] cls.labels_sent_to_transifex = [ trans.msgctxt for trans in first_form_translations ]
def test_case_list_form_parent_child_submodule_advanced(self): """ * Register house (case type = house, basic) * Register house form * Register person (case type = person, parent select = 'Register house', advanced) * Register person form * Update house (case type = house, case list form = 'Register house') * Update house form * Update person (case type = person, case list form = 'Register person form', advanced, parent module = 'Update house') * Update person form """ factory = AppFactory(build_version='2.9') register_house_module, register_house_form = factory.new_basic_module( 'register_house', 'house') factory.form_opens_case(register_house_form) register_person_module, register_person_form = factory.new_advanced_module( 'register_person', 'person') factory.form_updates_case(register_person_form, 'house') factory.form_opens_case(register_person_form, 'person', is_subcase=True) house_module, update_house_form = factory.new_advanced_module( 'update_house', 'house', case_list_form=register_house_form) factory.form_updates_case(update_house_form) person_module, update_person_form = factory.new_advanced_module( 'update_person', 'person', parent_module=house_module, case_list_form=register_person_form) factory.form_updates_case(update_person_form, 'house') factory.form_updates_case(update_person_form, 'person', parent_case_type='house') self.assertXmlEqual( self.get_xml( 'case-list-form-suite-parent-child-submodule-advanced'), factory.app.create_suite())