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
