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 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 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_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')
def make_app(cls): factory = AppFactory(domain=cls.domain.name, name="API App", build_version='2.11.0') module1, form1 = factory.new_basic_module('open_case', 'house') form1.source = XFormBuilder().new_question("name", "name").form.tostring() factory.form_opens_case(form1) module2, form2 = factory.new_basic_module('update_case', 'person') form2.source = XFormBuilder().new_question("name", "name").form.tostring() factory.form_requires_case(form2, case_type='house') factory.form_opens_case(form2, case_type="person", is_subcase=True) app = factory.app app.save() return app
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 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 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') builder = XFormBuilder(self.form.name) builder.new_question(name='name', label='Name') self.form.source = builder.tostring(pretty_print=True).decode('utf-8') image_path = os.path.join('corehq', 'apps', 'hqwebapp', 'static', 'hqwebapp', 'images', 'favicon.png') with open(image_path, 'rb') as f: image_data = f.read() self.image = CommCareImage.get_by_data(image_data) self.image.attach_data(image_data, original_filename='icon.png') self.image.add_domain(self.domain) self.image.save() self.addCleanup(self.image.delete)
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_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())
def test_custom_assertions(self, *args): factory = AppFactory() module, form = factory.new_basic_module('m0', 'case1') tests = [ "foo = 'bar' and baz = 'buzz'", "count(instance('casedb')/casedb/case[@case_type='friend']) > 0" ] form.custom_assertions = [ CustomAssertion(test=test, text={ 'en': "en-{}".format(id), "fr": "fr-{}".format(id) }) for id, test in enumerate(tests) ] assertions_xml = [ """ <assert test="{test}"> <text> <locale id="custom_assertion.m0.f0.{id}"/> </text> </assert> """.format(test=test, id=id) for id, test in enumerate(tests) ] self.assertXmlPartialEqual( """ <partial> <assertions> {assertions} </assertions> </partial> """.format(assertions="".join(assertions_xml)), factory.app.create_suite(), "entry/assertions") en_app_strings = commcare_translations.loads( module.get_app().create_app_strings('en')) self.assertEqual(en_app_strings['custom_assertion.m0.f0.0'], "en-0") self.assertEqual(en_app_strings['custom_assertion.m0.f0.1'], "en-1") fr_app_strings = commcare_translations.loads( module.get_app().create_app_strings('fr')) self.assertEqual(fr_app_strings['custom_assertion.m0.f0.0'], "fr-0") self.assertEqual(fr_app_strings['custom_assertion.m0.f0.1'], "fr-1")
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_form_rename_session_vars(self): """ The session vars in the entries for the submodule should match the parent and avoid naming conflicts. """ factory = AppFactory(build_version='2.9.0') reg_goldfish_mod, reg_goldfish_form = factory.new_basic_module( 'reg_goldfish', 'gold-fish') factory.form_opens_case(reg_goldfish_form) reg_guppy_mod, reg_guppy_form = factory.new_advanced_module( 'reg_guppy', 'guppy') factory.form_requires_case(reg_guppy_form, 'gold-fish') factory.form_opens_case(reg_guppy_form, 'guppy', is_subcase=True) upd_goldfish_mod, upd_goldfish_form = factory.new_advanced_module( 'upd_goldfish', 'gold-fish', ) factory.form_requires_case(upd_goldfish_form) # changing this case tag should result in the session var in the submodule entry being updated to match it upd_goldfish_form.actions.load_update_cases[ 0].case_tag = 'load_goldfish_renamed' upd_guppy_mod, upd_guppy_form = factory.new_advanced_module( 'upd_guppy', 'guppy', parent_module=upd_goldfish_mod, ) upd_guppy_form.source = self.get_xml( 'original_form', override_path=('data', )).decode('utf-8') factory.form_requires_case(upd_guppy_form, 'gold-fish', update={'question1': '/data/question1'}) factory.form_requires_case(upd_guppy_form, 'guppy', parent_case_type='gold-fish', update={'question1': '/data/question1'}) # making this case tag the same as the one in the parent module should mean that it will also get changed # to avoid conflicts upd_guppy_form.actions.load_update_cases[ 1].case_tag = 'load_goldfish_renamed' self.assertXmlEqual(self.get_xml('child-module-rename-session-vars'), upd_guppy_form.render_xform())
def _build_workflow_app(self, mode): factory = AppFactory(build_version='2.9.0') 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') m5, m5f0 = factory.new_basic_module('m5', 'patient', parent_module=m1) factory.form_requires_case(m5f0) for module in factory.app.get_modules(): for form in module.get_forms(): form.post_form_workflow = mode return factory.app
def testConvertToApplication(self): factory = AppFactory(build_version='2.40.0') factory.new_basic_module('register', 'case', with_form=False) factory.app.save() build = factory.app.make_build() build.is_released = True build.save() linked_app = LinkedApplication() linked_app.domain = 'other-domain' linked_app.save() 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')) linked_app.delete()
def test_return_to_shadow_module(self, *args): factory = AppFactory(build_version='2.9.0') m0, m0f0 = factory.new_basic_module('enroll child', 'child') factory.form_requires_case(m0f0) m0f0.post_form_workflow = WORKFLOW_MODULE m1 = factory.new_shadow_module('shadow_module', m0, with_form=False) expected = """ <partial> <stack> <create> <command value="'m1'"/> </create> </stack> </partial> """ self.assertXmlPartialEqual(expected, factory.app.create_suite(), "./entry[2]/stack")
def test_custom_variables(self): factory = AppFactory() module, form = factory.new_basic_module('m0', 'case1') short_custom_variables = "<variable function='true()' /><foo function='bar'/>" long_custom_variables = "<bar function='true()' /><baz function='buzz'/>" module.case_details.short.custom_variables = short_custom_variables module.case_details.long.custom_variables = long_custom_variables self.assertXmlPartialEqual( u""" <partial> <variables> {short_variables} </variables> <variables> {long_variables} </variables> </partial> """.format(short_variables=short_custom_variables, long_variables=long_custom_variables), factory.app.create_suite(), "detail/variables")
def testGetLatestBuild(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) app = factory.app app.save() build1 = app.make_build() build1.save() # ensure that there was no previous version used during the build process self.assertEqual(app.get_latest_build.get_cache(app), {}) self.assertEqual(build1.get_latest_build.get_cache(build1), {(): None}) app.save() build2 = app.make_build() build2.save() # ensure that there was no previous version used during the build process self.assertEqual(app.get_latest_build.get_cache(app), {}) self.assertEqual( build2.get_latest_build.get_cache(build2)[()].id, build1.id)
def setUpClass(cls): super(TestConvertMissingAppID, cls).setUpClass() factory = AppFactory(cls.domain) m1, m1f1 = factory.new_basic_module('open_case', 'house') m1f1.xmlns = 'missing-xmlns' cls.app = factory.app cls.app.save() cls.project = create_domain(cls.domain) cls.schema = FormExportDataSchema( domain=cls.domain, app_id='123', xmlns='myxmlns', group_schemas=[ ExportGroupSchema( path=MAIN_TABLE, items=[], ), ], )
def test_persistent_case_tiles_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-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 # set to use persistent case tile of its own as well but it would still # persists case tiles 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-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 module0.case_details.short.use_case_tiles = False self.ensure_module_session_datum_xml(factory, '', '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 test_training_module_as_parent(self, *args): factory = AppFactory(build_version='2.43.0') app = factory.app training_module = Module.new_training_module('training', 'en') app.add_module(training_module) child_module, _ = factory.new_basic_module( 'child', 'case_type', parent_module=training_module) self.assertIn( { 'type': 'training module parent', 'module': { 'id': 1, 'unique_id': 'child_module', 'name': { 'en': 'child module' } } }, app.validate_app())
def _generate_sample_app(self, domain): name = 'Case Fixtures App' for app in all_apps_by_domain(domain): if app.name == name: return False factory = AppFactory(domain, name) factory.app.comment = "App auto generated with ./manage.py create_case_fixtures" adult, adult_form = factory.new_basic_module('adult', 'adult') child, child_form = factory.new_basic_module('child', 'child') factory.form_opens_case(child_form, 'child', is_subcase=True, parent_tag='parent') car, car_form = factory.new_basic_module('car', 'car') factory.form_opens_case(car_form, 'car', is_subcase=True, parent_tag='car') maintenance_record, maintenance_record_form = factory.new_basic_module( 'maintenance_record', 'maintenance_record') factory.form_opens_case(maintenance_record_form, 'maintenance_record', is_subcase=True, parent_tag='maintenance_record_of_car', is_extension=True) factory.app.save() return True
def test_case_list_form_advanced_module_different_case_config(self, *args): case_tile_error = { 'type': "all forms in case list module must load the same cases", 'module': {'id': 1, 'name': {'en': 'update module'}}, 'form': {'id': 1, 'name': {'en': 'update form 1'}}, } factory = AppFactory(build_version='2.11.0') m0, m0f0 = factory.new_basic_module('register', 'person') factory.form_opens_case(m0f0) m1, m1f0 = factory.new_advanced_module('update', 'person', case_list_form=m0f0) factory.form_requires_case(m1f0, case_type='house') factory.form_requires_case(m1f0, parent_case_type='house') m1f1 = factory.new_form(m1) factory.form_requires_case(m1f1) # only loads a person case and not a house case errors = factory.app.validate_app() self._clean_unique_id(errors) self.assertIn(case_tile_error, errors)
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_case_list_form_requires_parent_case_but_target_doesnt(self): factory = AppFactory(build_version='2.9.0/latest') 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 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_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 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 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_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): 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