def setUp(self):
self.item = ExportItem(
path=[PathNode(name='data'),
PathNode(name='question1')],
label='Question One',
last_occurrences={self.app_id: 3},
)
def test_inferred_schema_merge(self):
schema = CaseExportDataSchema(
domain='my-domain',
group_schemas=[
ExportGroupSchema(
path=MAIN_TABLE,
items=[ExportItem(path=[PathNode(name='case_property')])],
)
])
inferred_schema = CaseExportDataSchema(
domain='my-domain',
group_schemas=[
ExportGroupSchema(
path=MAIN_TABLE,
items=[
ExportItem(
path=[PathNode(name='case_property')],
inferred=True,
)
],
inferred=True,
)
])
merged = ExportDataSchema._merge_schemas(schema, inferred_schema)
self.assertEqual(len(merged.group_schemas), 1)
self.assertTrue(merged.group_schemas[0].inferred)
group_schema = merged.group_schemas[0]
self.assertEqual(len(group_schema.items), 1)
self.assertTrue(group_schema.items[0].inferred)
def test_multiple_choice_merge(self):
"""Tests merging of a form that changes the options to a multiple choice question"""
merged = self._get_merged_schema('multiple_choice_form', 'multiple_choice_form_version2')
self.assertEqual(len(merged.group_schemas), 1)
group_schema = merged.group_schemas[0]
self.assertEqual(len(group_schema.items), 2)
v2items = filter(lambda item: item.last_occurrences[self.app_id] == 2, group_schema.items)
self.assertEqual(len(v2items), 2)
multichoice = filter(
lambda item: item.path == [PathNode(name='form'), PathNode(name='question2')],
group_schema.items
)[0]
self.assertEqual(len(multichoice.options), 3)
self.assertEqual(
len(filter(lambda o: o.last_occurrences[self.app_id] == 2, multichoice.options)),
2,
)
self.assertEqual(
len(filter(lambda o: o.last_occurrences[self.app_id] == 1, multichoice.options)),
1,
)
def test_partial_match_ordering(self):
schema = self._create_schema([
ExportItem(path=[PathNode(name='two')]),
ExportItem(path=[PathNode(name='one')]),
ExportItem(path=[PathNode(name='three')]),
])
ordered_schema = self._create_schema([
ExportItem(path=[PathNode(name='one')]),
ExportItem(path=[PathNode(name='four')]),
ExportItem(path=[PathNode(name='five')]),
ExportItem(path=[PathNode(name='six')]),
])
schema = CaseExportDataSchema._reorder_schema_from_schema(
schema,
ordered_schema,
)
self._assert_item_order(
schema,
[],
[
ExportItem(path=[PathNode(name='one')]),
ExportItem(path=[PathNode(name='two')]),
ExportItem(path=[PathNode(name='three')]),
],
)
def test_allow_non_data_nodes(self):
"""
Ensure that we allow non data nodes
"""
self.assertEqual(_question_path_to_path_nodes("/nodata/question", []),
[
PathNode(name='form', is_repeat=False),
PathNode(name='question', is_repeat=False),
])
def setUpClass(cls):
cls.current_app = Application.wrap(cls.get_json('basic_application'))
cls.first_build = Application.wrap(cls.get_json('basic_application'))
cls.first_build._id = '123'
cls.first_build.copy_of = cls.current_app.get_id
cls.first_build.version = 3
cls.advanced_app = Application.new_app('domain',
"Untitled Application")
module = cls.advanced_app.add_module(
AdvancedModule.new_module('Untitled Module', None))
form = module.new_form("Untitled Form",
cls.get_xml('repeat_group_form'))
form.xmlns = 'repeat-xmlns'
form.actions.open_cases = [
AdvancedOpenCaseAction(
case_type="advanced",
case_tag="open_case_0",
name_path="/data/question3/question4",
repeat_context="/data/question3",
)
]
cls.apps = [
cls.current_app,
cls.first_build,
cls.advanced_app,
]
with drop_connected_signals(app_post_save):
for app in cls.apps:
app.save()
cls.inferred_schema = InferredSchema(
domain=cls.domain,
case_type=cls.case_type,
group_schemas=[
InferredExportGroupSchema(
path=MAIN_TABLE,
items=[
ExportItem(path=[
PathNode(name='data'),
PathNode(name='case_property')
],
label='Inferred 1',
inferred=True),
ExportItem(path=[
PathNode(name='data'),
PathNode(name='case_property_2')
],
label='Inferred 1',
inferred=True),
],
inferred=True),
])
cls.inferred_schema.save()
def test_xform_parsing_with_repeat_group(self):
form_xml = self.get_xml('repeat_group_form')
schema = FormExportDataSchema._generate_schema_from_xform(
XForm(form_xml),
[],
['en'],
self.app_id,
1
)
self.assertEqual(len(schema.group_schemas), 2)
group_schema = schema.group_schemas[0]
self.assertEqual(len(group_schema.items), 2)
self.assertEqual(group_schema.path, MAIN_TABLE)
form_items = filter(lambda item: item.tag is None, group_schema.items)
self.assertEqual(form_items[0].path, [PathNode(name='form'), PathNode(name='question1')])
self.assertEqual(form_items[1].path, [PathNode(name='form'), PathNode(name='zendquestion')])
group_schema = schema.group_schemas[1]
self.assertEqual(len(group_schema.items), 1)
self.assertEqual(
group_schema.path,
[PathNode(name='form'), PathNode(name='question3', is_repeat=True)]
)
self.assertEqual(
group_schema.items[0].path,
[PathNode(name='form'), PathNode(name='question3', is_repeat=True), PathNode(name='question4')]
)
def test_labels_in_xform(self):
form_xml = self.get_xml('form_with_labels')
schema = FormExportDataSchema._generate_schema_from_xform(
XForm(form_xml), ['en'], self.app_id, 1)
self.assertEqual(len(schema.group_schemas), 1)
group_schema = schema.group_schemas[0]
self.assertEqual(len(group_schema.items), 1)
self.assertEqual(group_schema.items[0].path,
[PathNode(name='form'),
PathNode(name='label')])
self.assertIsInstance(group_schema.items[0], LabelItem)
def test_xform_parsing_with_stock_questions(self):
form_xml = self.get_xml('stock_form')
schema = FormExportDataSchema._generate_schema_from_xform(
XForm(form_xml),
[],
['en'],
self.app_id,
1
)
self.assertEqual(len(schema.group_schemas), 1)
group_schema = schema.group_schemas[0]
self.assertEqual(len(group_schema.items), 6)
self.assertTrue(all(map(lambda item: item.doc_type == 'StockItem', group_schema.items)))
for parent_attr in ['@type', '@entity-id', '@date', '@section-id']:
self.assertTrue(any(map(
lambda item: item.path == [
PathNode(name='form'),
PathNode(name='balance:balance_one'),
PathNode(name=parent_attr),
],
group_schema.items,
)))
for entry_attr in ['@id', '@quantity']:
self.assertTrue(any(map(
lambda item: item.path == [
PathNode(name='form'),
PathNode(name='balance:balance_one'),
PathNode(name='entry'),
PathNode(name=entry_attr),
],
group_schema.items,
)))
def _convert_index_to_path_nodes(index):
from corehq.apps.export.models.new import MAIN_TABLE
from corehq.apps.export.models.new import PathNode
if index == '#':
return MAIN_TABLE
elif _is_repeat(index):
split_index = index.split('.')[1:] # Remove first "#"
path = []
for part in split_index:
# If the part is "#" we know the previous piece in the path is a repeat group
if part == '#':
path[-1].is_repeat = True
else:
path.append(PathNode(name=part, is_repeat=False))
return path
else:
return [PathNode(name=n) for n in index.split('.')]
def test_basic_xform_parsing(self):
form_xml = self.get_xml('basic_form')
schema = FormExportDataSchema._generate_schema_from_xform(
XForm(form_xml), ['en'], self.app_id, 1)
self.assertEqual(len(schema.group_schemas), 1)
group_schema = schema.group_schemas[0]
self.assertEqual(len(group_schema.items), 2)
form_items = [item for item in group_schema.items if item.tag is None]
self.assertEqual(form_items[0].path,
[PathNode(name='form'),
PathNode(name='question1')])
self.assertEqual(form_items[1].path,
[PathNode(name='form'),
PathNode(name='question2')])
def test_xform_parsing_with_multiple_choice(self):
form_xml = self.get_xml('multiple_choice_form')
schema = FormExportDataSchema._generate_schema_from_xform(
XForm(form_xml), [], ['en'], self.app_id, 1)
self.assertEqual(len(schema.group_schemas), 1)
group_schema = schema.group_schemas[0]
self.assertEqual(len(group_schema.items), 2)
form_items = filter(lambda item: item.tag is None, group_schema.items)
self.assertEqual(form_items[0].path,
[PathNode(name='form'),
PathNode(name='question1')])
self.assertEqual(form_items[1].path,
[PathNode(name='form'),
PathNode(name='question2')])
self.assertEqual(form_items[1].options[0].value, 'choice1')
self.assertEqual(form_items[1].options[1].value, 'choice2')
def test_case_type_metadata_parsing(self):
case_property_mapping = {
'candy': ['my_case_property', 'my_second_case_property']
}
schema = CaseExportDataSchema._generate_schema_from_case_property_mapping(
case_property_mapping,
[],
self.app_id,
1,
)
self.assertEqual(len(schema.group_schemas), 1)
group_schema = schema.group_schemas[0]
my_case_property_item = group_schema.items[0]
my_second_case_property_item = group_schema.items[1]
self.assertEqual(my_case_property_item.path, [PathNode(name='my_case_property')])
self.assertEqual(my_case_property_item.last_occurrences[self.app_id], 1)
self.assertEqual(my_second_case_property_item.path, [PathNode(name='my_second_case_property')])
self.assertEqual(my_second_case_property_item.last_occurrences[self.app_id], 1)
def setUpClass(cls):
cls.current_app = Application.wrap(cls.get_json('basic_application'))
cls.first_build = Application.wrap(cls.get_json('basic_application'))
cls.first_build._id = '123'
cls.first_build.copy_of = cls.current_app.get_id
cls.first_build.version = 3
cls.apps = [
cls.current_app,
cls.first_build,
]
with drop_connected_signals(app_post_save):
for app in cls.apps:
app.save()
cls.inferred_schema = InferredSchema(
domain=cls.domain,
case_type=cls.case_type,
group_schemas=[
InferredExportGroupSchema(
path=MAIN_TABLE,
items=[
ExportItem(path=[
PathNode(name='data'),
PathNode(name='case_property')
],
label='Inferred 1',
inferred=True),
ExportItem(path=[
PathNode(name='data'),
PathNode(name='case_property_2')
],
label='Inferred 1',
inferred=True),
],
inferred=True),
])
cls.inferred_schema.save()
def test_multiple_choice_merge(self):
"""Tests merging of a form that changes the options to a multiple choice question"""
merged = self._get_merged_schema('multiple_choice_form',
'multiple_choice_form_version2')
self.assertEqual(len(merged.group_schemas), 1)
group_schema = merged.group_schemas[0]
self.assertEqual(len(group_schema.items), 2)
v2items = [
item for item in group_schema.items
if item.last_occurrences[self.app_id] == 2
]
self.assertEqual(len(v2items), 2)
multichoice = [
item for item in group_schema.items if item.path ==
[PathNode(name='form'),
PathNode(name='question2')]
][0]
self.assertEqual(len(multichoice.options), 3)
self.assertEqual(
len([
o for o in multichoice.options
if o.last_occurrences[self.app_id] == 2
]),
2,
)
self.assertEqual(
len([
o for o in multichoice.options
if o.last_occurrences[self.app_id] == 1
]),
1,
)
def _convert_stock_column(new_table, old_column):
from .models import PathNode
# Handle stock export column separately because it's a messy edge since
# it doesn't have a unique index (_id).
index, new_column = new_table.get_column(
[PathNode(name='stock')],
'ExportItem',
None,
)
if new_column:
new_column.selected = True
new_column.label = old_column.display
else:
raise SkipConversion('StockExportColumn not found in new export')
def setUp(self):
self.inferred_schema = CaseInferredSchema(
domain=self.domain,
case_type=self.case_type,
group_schemas=[
InferredExportGroupSchema(
path=MAIN_TABLE,
items=[
ExportItem(path=[
PathNode(name='data'),
PathNode(name='case_property')
],
label='Inferred 1',
inferred=True),
ExportItem(path=[
PathNode(name='data'),
PathNode(name='case_property_2')
],
label='Inferred 1',
inferred=True),
],
inferred=True),
])
self.inferred_schema.save()
def test_basic_ordering(self):
schema = self._create_schema([
ScalarItem(path=[PathNode(name='three')]),
ScalarItem(path=[PathNode(name='one')]),
ScalarItem(path=[PathNode(name='two')]),
ScalarItem(path=[PathNode(name='four')]),
])
ordered_schema = self._create_schema([
ScalarItem(path=[PathNode(name='one')]),
ScalarItem(path=[PathNode(name='two')]),
ScalarItem(path=[PathNode(name='three')]),
ScalarItem(path=[PathNode(name='four')]),
])
schema = CaseExportDataSchema._reorder_schema_from_schema(
schema,
ordered_schema,
)
self._assert_item_order(
schema,
[],
[
ScalarItem(path=[PathNode(name='one')]),
ScalarItem(path=[PathNode(name='two')]),
ScalarItem(path=[PathNode(name='three')]),
ScalarItem(path=[PathNode(name='four')]),
],
)
def test_different_doc_types_ordering(self):
schema = self._create_schema([
GeopointItem(path=[PathNode(name='one')]),
ScalarItem(path=[PathNode(name='two')]),
ScalarItem(path=[PathNode(name='three')]),
ScalarItem(path=[PathNode(name='one')]),
])
ordered_schema = self._create_schema([
ScalarItem(path=[PathNode(name='two')]),
ScalarItem(path=[PathNode(name='one')]),
ScalarItem(path=[PathNode(name='three')]),
GeopointItem(path=[PathNode(name='one')]),
])
schema = CaseExportDataSchema._reorder_schema_from_schema(
schema,
ordered_schema,
)
self._assert_item_order(
schema,
[],
[
ScalarItem(path=[PathNode(name='two')]),
ScalarItem(path=[PathNode(name='one')]),
ScalarItem(path=[PathNode(name='three')]),
GeopointItem(path=[PathNode(name='one')]),
],
)
def test_wrap_export_item(self, _):
path = [PathNode(name="foo"), PathNode(name="bar")]
item = ExportItem(path=path)
wrapped = ExportItem.wrap(item.to_json())
self.assertEqual(type(wrapped), type(item))
self.assertEqual(wrapped.to_json(), item.to_json())
def test_question_path_to_path_nodes(self):
"""
Confirm that _question_path_to_path_nodes() works as expected
"""
repeat_groups = [
"/data/repeat1",
"/data/group1/repeat2",
"/data/group1/repeat2/repeat3",
]
self.assertEqual(
_question_path_to_path_nodes("/data/repeat1", repeat_groups),
[PathNode(name='form', is_repeat=False), PathNode(name='repeat1', is_repeat=True)]
)
self.assertEqual(
_question_path_to_path_nodes("/data/group1", repeat_groups),
[PathNode(name='form', is_repeat=False), PathNode(name='group1', is_repeat=False)]
)
self.assertEqual(
_question_path_to_path_nodes("/data/group1/repeat2", repeat_groups),
[
PathNode(name='form', is_repeat=False),
PathNode(name='group1', is_repeat=False),
PathNode(name='repeat2', is_repeat=True),
]
)
self.assertEqual(
_question_path_to_path_nodes("/data/group1/repeat2/repeat3", repeat_groups),
[
PathNode(name='form', is_repeat=False),
PathNode(name='group1', is_repeat=False),
PathNode(name='repeat2', is_repeat=True),
PathNode(name='repeat3', is_repeat=True),
]
)
self.assertEqual(
_question_path_to_path_nodes("/data/group1/repeat2/repeat3/group2", repeat_groups),
[
PathNode(name='form', is_repeat=False),
PathNode(name='group1', is_repeat=False),
PathNode(name='repeat2', is_repeat=True),
PathNode(name='repeat3', is_repeat=True),
PathNode(name='group2', is_repeat=False),
]
)
def test_wrap_export_item_child(self, _):
path = [PathNode(name="foo"), PathNode(name="bar")]
item = MultipleChoiceItem(path=path, options=[Option(value="foo")])
wrapped = ExportItem.wrap(item.to_json())
self.assertEqual(type(wrapped), type(item))
self.assertEqual(wrapped.to_json(), item.to_json())
