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_persistent_case_name_when_tiles_enabled(self): """ Confirm that the persistent case name context is not added when case tiles are configured to persist in forms """ factory = AppFactory() module, form = factory.new_advanced_module("my_module", "person") factory.form_requires_case(form, "person") module.case_details.short.custom_xml = '<detail id="m0_case_short"></detail>' module.case_details.short.persist_tile_on_forms = True module.case_details.short.persist_case_context = True suite = factory.app.create_suite() self.assertXmlDoesNotHaveXpath(suite, "detail[@id='m0_persistent_case_context']") self.assertXmlPartialEqual( """ <partial> <datum detail-confirm="m0_case_long" detail-persistent="m0_case_short" detail-select="m0_case_short" id="case_id_load_person_0" nodeset="instance('casedb')/casedb/case[@case_type='person'][@status='open']" value="./@case_id" /> </partial> """, suite, "entry/session/datum" )
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_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 )
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_persistent_case_tiles_in_advanced_module_case_lists(self): """ Test that the detail-persistent attributes is set correctly when persistent case tiles are used on advanced module case lists """ factory = AppFactory() module, form = factory.new_advanced_module("my_module", "person") factory.form_requires_case(form, "person") module.case_list.show = True module.case_details.short.custom_xml = '<detail id="m0_case_short"></detail>' module.case_details.short.persist_tile_on_forms = True suite = factory.app.create_suite() # The relevant check is really that detail-persistent="m0_case_short" # but assertXmlPartialEqual xpath implementation doesn't currently # support selecting attributes self.assertXmlPartialEqual( """ <partial> <datum detail-confirm="m0_case_long" detail-persistent="m0_case_short" detail-select="m0_case_short" id="case_id_case_person" nodeset="instance('casedb')/casedb/case[@case_type='person'][@status='open']" value="./@case_id" /> </partial> """, suite, 'entry/command[@id="m0-case-list"]/../session/datum', )
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 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 _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_basic(self): factory = AppFactory(build_version="2.9.0/latest") m0, m0f0 = factory.new_basic_module("m0", "frog") m1, m1f0 = factory.new_basic_module("m1", "frog") 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_basic"), factory.app.create_suite(), "./entry[1]")
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 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 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_circular_parent_case_ref(self): factory = AppFactory() m0, m0f0 = factory.new_basic_module('m0', 'case1') m1, m1f0 = factory.new_basic_module('m1', 'case2') factory.form_requires_case(m0f0, 'case1', parent_case_type='case2') factory.form_requires_case(m1f0, 'case2', parent_case_type='case1') with self.assertRaises(SuiteValidationError): factory.app.create_suite()
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" )
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 test_form_display_condition(self): """ case_id should be renamed in a basic submodule form """ factory = AppFactory(domain=DOMAIN) m0, m0f0 = factory.new_advanced_module('parent', 'gold-fish') factory.form_requires_case(m0f0) # changing this case tag should result in the session var in the submodule entry being updated to match it m0f0.actions.load_update_cases[0].case_tag = 'load_goldfish_renamed' m1, m1f0 = factory.new_advanced_module('child', 'guppy', parent_module=m0) factory.form_requires_case(m1f0, 'gold-fish', update={'question1': '/data/question1'}) factory.form_requires_case(m1f0, 'guppy', parent_case_type='gold-fish') # making this case tag the same as the one in the parent module should mean that it will also get changed # to avoid conflicts m1f0.actions.load_update_cases[1].case_tag = 'load_goldfish_renamed' m1f0.form_filter = "#case/age > 33" XML = """ <partial> <menu id="m1" root="m0"> <text> <locale id="modules.m1"/> </text> <command id="m1-f0" relevant="instance('casedb')/casedb/case[@case_id=instance('commcaresession')/session/data/case_id_load_goldfish_renamed_guppy]/age > 33"/> </menu> </partial> """ self.assertXmlPartialEqual(XML, factory.app.create_suite(), "./menu[@id='m1']")
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_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_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 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 setUp(self): update_toggle_cache(MODULE_FILTER.slug, DOMAIN, True, NAMESPACE_DOMAIN) self.factory = AppFactory(domain=DOMAIN) self.module_0, _ = self.factory.new_basic_module('parent', 'gold-fish') self.module_1, _ = self.factory.new_module(self.child_module_class, 'child', 'guppy', parent_module=self.module_0) self.app = self.factory.app
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_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_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_requires_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_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 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_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 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 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').decode('utf-8')) 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 test_that_grid_style_is_added(self, *args): """ 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 test_case_list_registration_form_advanced(self): factory = AppFactory(build_version='2.9') register_module, register_form = factory.new_advanced_module('register_dugong', 'dugong') factory.form_opens_case(register_form) case_module, update_form = factory.new_advanced_module('update_dugong', 'dugong') factory.form_requires_case(update_form) case_module.case_list_form.form_id = register_form.get_unique_id() case_module.case_list_form.label = { 'en': 'Register another Dugong' } self.assertXmlEqual(self.get_xml('case-list-form-advanced'), factory.app.create_suite())
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())
class BaseSchemaTest(SimpleTestCase): def setUp(self): self.factory = AppFactory() self.factory_2 = AppFactory() # -- helpers -- def assert_has_kv_pairs(self, test_dict, expected_dict): """Assert that test_dict contains all key/value pairs in expected_dict Key/value pairs in `test_dict` but not present in `expected_dict` will be ignored. """ for key, value in expected_dict.items(): self.assertEqual(test_dict[key], value) def add_form(self, case_type=None, case_updates=None): module_id = len(self.factory.app.modules) module, form = self.factory.new_basic_module(module_id, case_type) if case_type: self.factory.form_opens_case(form, case_type) if case_updates: assert case_type, 'case_type is required with case_updates' self.factory.form_requires_case(form, case_type=case_type, update=case_updates) return form def add_form_app_2(self, case_type=None, case_updates=None): module_id = len(self.factory_2.app.modules) module, form = self.factory_2.new_basic_module(module_id, case_type) if case_type: self.factory_2.form_opens_case(form, case_type) if case_updates: assert case_type, 'case_type is required with case_updates' self.factory_2.form_requires_case(form, case_type=case_type, update=case_updates) return form
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_inline_case_detail_from_another_module(self): factory = AppFactory() module0, form0 = factory.new_advanced_module("m0", "person") factory.form_requires_case(form0, "person") module0.case_details.short.use_case_tiles = True self._add_columns_for_case_details(module0) module1, form1 = factory.new_advanced_module("m1", "person") factory.form_requires_case(form1, "person") # not configured to use other module's persistent case tile so # has no detail-inline and detail-persistent attr self.ensure_module_session_datum_xml(factory, '', '') # configured to use other module's persistent case tile module1.case_details.short.persistent_case_tile_from_module = module0.unique_id self.ensure_module_session_datum_xml(factory, '', 'detail-persistent="m0_case_short"') # configured to use other module's persistent case tile that has custom xml module0.case_details.short.use_case_tiles = False module0.case_details.short.custom_xml = '<detail id="m0_case_short"></detail>' self.ensure_module_session_datum_xml(factory, '', 'detail-persistent="m0_case_short"') module0.case_details.short.custom_xml = '' module0.case_details.short.use_case_tiles = True # configured to use pull down tile from the other module module1.case_details.short.pull_down_tile = True self.ensure_module_session_datum_xml(factory, 'detail-inline="m0_case_long"', 'detail-persistent="m0_case_short"') # set to use persistent case tile of its own as well but it would still # persists case tiles and detail inline from another module module1.case_details.short.use_case_tiles = True module1.case_details.short.persist_tile_on_forms = True self._add_columns_for_case_details(module1) self.ensure_module_session_datum_xml(factory, 'detail-inline="m0_case_long"', 'detail-persistent="m0_case_short"') # set to use case tile from a module that does not support case tiles anymore # and has own persistent case tile as well # So now detail inline from its own details module0.case_details.short.use_case_tiles = False self.ensure_module_session_datum_xml(factory, 'detail-inline="m1_case_long"', 'detail-persistent="m1_case_short"') # set to use case tile from a module that does not support case tiles anymore # and does not have its own persistent case tile as well module1.case_details.short.use_case_tiles = False self.ensure_module_session_datum_xml(factory, '', '')
def setUpClass(cls): super(TestGlobalAppConfig, cls).setUpClass() cls.project = Domain.get_or_create_with_name(cls.domain) cls.build_profile_id = 'english' factory = AppFactory(cls.domain, 'foo') m0, f0 = factory.new_basic_module("bar", "bar") f0.source = get_simple_form(xmlns=f0.unique_id) app = factory.app app.build_profiles = { cls.build_profile_id: BuildProfile(langs=['en'], name='English only'), } app.langs = ["en"] app.version = 1 app.save() # app is now v2 cls.v2_build = app.make_build() cls.v2_build.is_released = True cls.v2_build.save() # v2 is starred app.save() # app is now v3 cls.v3_build = app.make_build() cls.v3_build.is_released = True cls.v3_build.save() # v3 is starred app.save() # app is v4 # Add a build-profile-specific release at v2 cls.latest_profile = LatestEnabledBuildProfiles( domain=cls.domain, app_id=app.get_id, build_profile_id=cls.build_profile_id, version=cls.v2_build.version, build_id=cls.v2_build.get_id, active=True, ) cls.latest_profile.save() cls.app = app
def testConvertToApplication(self): factory = AppFactory(build_version='2.40.0') m0, f0 = factory.new_basic_module('register', 'case') f0.source = get_simple_form(xmlns=f0.unique_id) factory.app.save() self.addCleanup(factory.app.delete) build = factory.app.make_build() build.is_released = True build.save() self.addCleanup(build.delete) linked_app = LinkedApplication() linked_app.domain = 'other-domain' linked_app.save() self.addCleanup(linked_app.delete) link_app(linked_app, factory.app.domain, factory.app.id) update_linked_app(linked_app, factory.app.id, 'system') unlinked_doc = linked_app.convert_to_application().to_json() self.assertEqual(unlinked_doc['doc_type'], 'Application') self.assertFalse(hasattr(unlinked_doc, 'linked_app_attrs'))
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_multi_select_module_errors(self, *args): factory = AppFactory() module, form = factory.new_basic_module('basic', 'person') factory.form_requires_case(form, 'person') module.case_details.short.multi_select = True module.search_config = CaseSearch( search_label=CaseSearchLabel(label={'en': 'Search'}), properties=[CaseSearchProperty(name=field) for field in ['name', 'greatest_fear']], data_registry="so_many_cases", data_registry_workflow=REGISTRY_WORKFLOW_LOAD_CASE, ) self.assertIn({ 'type': 'data registry multi select', 'module': {'id': 0, 'unique_id': 'basic_module', 'name': {'en': 'basic module'}} }, factory.app.validate_app()) module.search_config.data_registry_workflow = REGISTRY_WORKFLOW_SMART_LINK self.assertIn({ 'type': 'smart links multi select', 'module': {'id': 0, 'unique_id': 'basic_module', 'name': {'en': 'basic module'}} }, factory.app.validate_app())
def _get_app(self): factory = AppFactory(build_version='2.40.0') app = factory.app app.langs = ['en', 'fra'] module, form = factory.new_basic_module('register', 'case') ''' This form has two text questions, one with French audio present and one with it missing. It then has three select questions, each with two choices that share text and all have French audio specified. One set of choices has audio present for both, one has it missing for both, and one has it present for one choice and missing for the other. Lastly, it has two select questions, each with three choices that all have different text but use the same audio path. One of these two audio files is missing. ''' form.source = self.get_xml('duplicate_text_questions').decode('utf-8') for path in form.wrapped_xform().audio_references(): if 'present' in path or 'one_of_each1' in path: app.create_mapping(CommCareAudio(_id=uuid.uuid4().hex), path, save=False) return app
def setUp(self): self.factory = AppFactory() self.advanced_module, self.form0 = self.factory.new_advanced_module( 'advanced_module', 'patient') self.form0.xmlns = 'http://openrosa.org/formdesigner/firstform' self.form0.actions.open_cases = [ AdvancedOpenCaseAction( case_type="patient", case_tag="open__0", ) ] self.form0.actions.load_update_cases = [ LoadUpdateAction( case_type="patient", case_tag="load_0", case_properties={ "name": ConditionalCaseUpdate(question_path="/data/name") }, preload={"/data/name": "name"}, details_module=self.advanced_module.unique_id, ) ] self.shadow_form = self.factory.new_shadow_form(self.advanced_module) self.shadow_form.shadow_parent_form_id = self.form0.unique_id # Shadow form load_update_case actions should contain all case tags from the parent self.shadow_form.extra_actions.load_update_cases = [ LoadUpdateAction( case_type="patient", case_tag="load_0", details_module=self.advanced_module.unique_id, ) ] self.basic_module = self.factory.new_basic_module("basic_module", "doctor", with_form=False)
class FormPreparationV2TestMultiSelect(SimpleTestCase, TestXmlMixin): file_path = 'data', 'form_preparation_v2' def setUp(self): self.factory = AppFactory(domain="multiple-referrals") self.factory.app.version = 5 self.module, self.form = self.factory.new_basic_module( 'basic', 'person') self.form.source = self.get_xml( 'original_form', override_path=('data', )).decode('utf-8') self.module.case_details.short.multi_select = True def test_open_case(self): self.form.actions.open_case = OpenCaseAction( name_update=ConditionalCaseUpdate( question_path="/data/question1"), ) self.form.actions.open_case.condition.type = 'always' self.form.actions.update_case = UpdateCaseAction( update={ 'question1': ConditionalCaseUpdate( question_path='/data/question1') }) self.form.actions.update_case.condition.type = 'always' self.assertXmlEqual(self.get_xml('multi_open_update_case'), self.form.render_xform()) def test_update_case(self): self.factory.form_requires_case(self.form, 'person') self.form.actions.update_case = UpdateCaseAction( update={ 'question1': ConditionalCaseUpdate( question_path='/data/question1') }) self.form.actions.update_case.condition.type = 'always' self.assertXmlEqual(self.get_xml('multi_no_actions'), self.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(TestBuildingSchemaFromApplication, cls).setUpClass() cls.current_app = Application.wrap(cls.get_json('basic_application')) cls.first_build = Application.wrap(cls.get_json('basic_application')) cls.first_build._id = '123' cls.first_build.copy_of = cls.current_app.get_id cls.first_build.version = 3 cls.first_build.has_submissions = True factory = AppFactory(build_version='2.36.0') m0, f0 = factory.new_advanced_module('mod0', 'advanced') f0.source = cls.get_xml('repeat_group_form').decode('utf-8') f0.xmlns = 'repeat-xmlns' factory.form_requires_case(f0, 'case0') f0.actions.open_cases = [ AdvancedOpenCaseAction( case_type="advanced", case_tag="open_case_0", name_update=ConditionalCaseUpdate( question_path="/data/question3/question4"), repeat_context="/data/question3", case_indices=[CaseIndex(tag='load_case0_0')]) ] cls.advanced_app = factory.app cls.advanced_app.save() cls.apps = [ cls.current_app, cls.first_build, cls.advanced_app, ] with drop_connected_signals(app_post_save): for app in cls.apps: app.save()
def test_app_strings(self): factory = AppFactory(build_version='2.40.0') factory.app.langs = ['en', 'es'] module, form = factory.new_basic_module('my_module', 'cases') module.name = { 'en': 'Fascination Street', 'es': 'Calle de Fascinación', } form.name = { 'en': 'Prayers for Rain', 'es': 'Oraciones por la Lluvia', } en_strings = self._generate_app_strings(factory.app, 'en') self.assertEqual(en_strings['modules.m0'], module.name['en']) self.assertEqual(en_strings['forms.m0f0'], form.name['en']) es_strings = self._generate_app_strings(factory.app, 'es') self.assertEqual(es_strings['modules.m0'], module.name['es']) self.assertEqual(es_strings['forms.m0f0'], form.name['es']) default_strings = self._generate_app_strings(factory.app, 'default') self.assertEqual(default_strings['modules.m0'], module.name['en']) self.assertEqual(default_strings['forms.m0f0'], form.name['en'])
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_custom_variables(self, *args): factory = AppFactory() module, form = factory.new_basic_module('m0', 'case1') factory.form_requires_case(form, 'case') short_custom_variables = "<variable function='true()' /><foo function='bar'/>" long_custom_variables = ( '<bar function="true()" />' '<baz function="instance(\'locations\')/locations/location[0]"/>' ) module.case_details.short.custom_variables = short_custom_variables module.case_details.long.custom_variables = long_custom_variables suite = factory.app.create_suite() self.assertXmlPartialEqual( """ <partial> <variables> {short_variables} </variables> <variables> {long_variables} </variables> </partial> """.format(short_variables=short_custom_variables, long_variables=long_custom_variables), suite, "detail/variables" ) self.assertXmlPartialEqual( """ <partial> <instance id="casedb" src="jr://instance/casedb"/> <instance id="locations" src="jr://fixture/locations"/> </partial> """.format(short_variables=short_custom_variables, long_variables=long_custom_variables), suite, "entry[1]/instance" )
def test_form_data_with_case_properties(self): factory = AppFactory() self._build_app_with_groups(factory) app = factory.app 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'][1]['children'][0]['save_properties'][0] self.assertEqual(group_saves.case_type, 'household') self.assertEqual(group_saves.property, 'age') q3_loads = modules[0]['forms'][0]['questions'][2]['load_properties'][0] self.assertEqual(q3_loads.case_type, 'household') self.assertEqual(q3_loads.property, 'polar_bears_seen')
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_case_list_registration_form_advanced_autoload(self): factory = AppFactory(build_version='2.9.0') register_module, register_form = factory.new_advanced_module( 'register_dugong', 'dugong') factory.form_opens_case(register_form) register_form.actions.load_update_cases.append( LoadUpdateAction(case_tag='usercase', auto_select=AutoSelectCase( mode=AUTO_SELECT_USERCASE, ))) case_module, update_form = factory.new_advanced_module( 'update_dugong', 'dugong') factory.form_requires_case(update_form) case_module.case_list_form.form_id = register_form.get_unique_id() case_module.case_list_form.label = {'en': 'Register another Dugong'} self.assertXmlEqual(self.get_xml('case-list-form-advanced-autoload'), factory.app.create_suite())
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',)) 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_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 setUpClass(cls): cls.factory = AppFactory(domain=cls.domain) cls.app = cls.factory.app cls.module, cls.basic_form = cls.factory.new_basic_module( 'basic', 'patient') # necessary to render_xform builder = XFormBuilder(cls.basic_form.name) builder.new_question(name='name', label='Name') cls.basic_form.source = builder.tostring( pretty_print=True).decode('utf-8') cls.phone_number = "+919999999999" cls.case_id = uuid.uuid4().hex cls.recipient = None cls.case = CommCareCaseSQL(domain=cls.domain, case_id=cls.case_id, case_json={'language_code': 'fr'}) cls.web_user = WebUser(username='******', _id=uuid.uuid4().hex, language='hin')
def test_case_list_form_media(self): app = AppFactory.case_list_form_app_factory().app app.build_spec = self.min_spec no_media_xml = self.XML_without_media("case_list_form.m0", for_action_menu=True) self.assertXmlPartialEqual( no_media_xml, app.create_suite(), "./detail[@id='m0_case_short']/action/display" ) app.get_module(0).case_list_form.set_icon('en', self.image_path) app.get_module(0).case_list_form.set_audio('en', self.audio_path) XML = self.makeXML("case_list_form.m0", "case_list_form.m0.icon", "case_list_form.m0.audio") self.assertXmlPartialEqual(XML, app.create_suite(), "./detail[@id='m0_case_short']/action/display") self._assert_app_strings_available(app, 'en') icon_locale = id_strings.case_list_form_icon_locale(app.get_module(0)) audio_locale = id_strings.case_list_form_audio_locale(app.get_module(0)) self._test_correct_icon_translations(app, app.get_module(0).case_list_form, icon_locale) self._test_correct_audio_translations(app, app.get_module(0).case_list_form, audio_locale)
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_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 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()