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