def test_selected_false(self, export_save):
export_json = get_export_json(
CaseExportInstance(export_format=Format.JSON,
domain=DOMAIN,
case_type=DEFAULT_CASE_TYPE,
tables=[
TableConfiguration(label="My table",
selected=False,
path=[],
columns=[])
]))
self.assertEqual(export_json, {})
self.assertTrue(export_save.called)
def test_double_repeat(self):
table_configuration = TableConfiguration(
path=[
PathNode(name="form", is_repeat=False),
PathNode(name="repeat1", is_repeat=True),
PathNode(name="group1", is_repeat=False),
PathNode(name="repeat2", is_repeat=True),
],
columns=[
RowNumberColumn(selected=True),
ExportColumn(
item=ScalarItem(path=[
PathNode(name='form'),
PathNode(name='repeat1', is_repeat=True),
PathNode(name='group1'),
PathNode(name='repeat2', is_repeat=True),
PathNode(name='q1')
], ),
selected=True,
),
])
submission = {
'domain': 'my-domain',
'_id': '1234',
'form': {
'repeat1': [
{
'group1': {
'repeat2': [{
'q1': 'foo'
}, {
'q1': 'bar'
}]
}
},
{
'group1': {
'repeat2': [{
'q1': 'beep'
}, {
'q1': 'boop'
}]
}
},
]
}
}
self.assertEqual(
[row.data for row in table_configuration.get_rows(submission, 0)],
[["0.0.0", 0, 0, 0, 'foo'], ["0.0.1", 0, 0, 1, 'bar'],
["0.1.0", 0, 1, 0, 'beep'], ["0.1.1", 0, 1, 1, 'boop']])
def test_case_name_transform(self):
docs = [
{
'domain': 'my-domain',
'_id': '1234',
"form": {
"caseid": "robin",
},
},
{
'domain': 'my-domain',
'_id': '1234',
"form": {
"caseid": "i-do-not-exist",
},
}
]
export_instance = FormExportInstance(
export_format=Format.JSON,
tables=[
TableConfiguration(
label="My table",
selected=True,
columns=[
ExportColumn(
label="case_name",
item=ScalarItem(
path=[PathNode(name='form'), PathNode(name='caseid')],
transform=CASE_NAME_TRANSFORM,
),
selected=True
),
]
)
]
)
writer = _get_writer([export_instance])
with writer.open([export_instance]):
_write_export_instance(writer, export_instance, docs)
with ExportFile(writer.path, writer.format) as export:
self.assertEqual(
json.loads(export.read()),
{
u'My table': {
u'headers': [u'case_name'],
u'rows': [[u'batman'], [MISSING_VALUE]],
}
}
)
def test_get_export_properties(self):
export_instance = FormExportInstance(tables=[
TableConfiguration(label="My table",
selected=True,
path=[],
columns=[
ExportColumn(
label="Q3",
item=ScalarItem(path=[
PathNode(name='form'),
PathNode(name='q3')
], ),
selected=True,
),
]),
TableConfiguration(label="My other table",
selected=True,
path=[
PathNode(name='form', is_repeat=False),
PathNode(name="q2", is_repeat=False)
],
columns=[
ExportColumn(
label="Q4",
item=ScalarItem(path=[
PathNode(name='form'),
PathNode(name='q2'),
PathNode(name='q4')
], ),
selected=True,
),
])
])
with mock.patch('corehq.apps.export.models.new.FormExportInstance.get',
return_value=export_instance):
props = _get_export_properties("fake id for my export instance",
False)
self.assertEqual(props, set(['q2-q4', 'q3']))
def test_simple_repeat(self):
table = TableConfiguration(path=[PathNode(name="foo", is_repeat=True)])
self.assertEqual(
table._get_sub_documents({'foo': [
{
'bar': 'a'
},
{
'bar': 'b'
},
]}, 0), [
DocRow(row=(0, 0), doc={'bar': 'a'}),
DocRow(row=(0, 1), doc={'bar': 'b'})
])
def test_config_in_different_domain(self):
export_config_in_other_domain = FormExportInstance(
_id='config_id',
tables=[TableConfiguration(columns=[])],
domain='different_domain')
export_config_in_other_domain.save()
self.addCleanup(export_config_in_other_domain.delete)
correct_credentials = self._get_correct_credentials()
response = self.client.get(
self._odata_feed_url_by_domain_and_config_id(
self.domain.name, export_config_in_other_domain.get_id),
HTTP_AUTHORIZATION='Basic ' + correct_credentials,
)
self.assertEqual(response.status_code, 404)
def test_table_containing_duplicate_paths_with_differing_doc_types_can_find_either(self):
path = [PathNode(name='closed')]
prop1 = ScalarItem(path=path)
prop2 = ExportItem(path=path)
table_config = TableConfiguration(
columns=[
ExportColumn(item=prop1), ExportColumn(item=prop2)
]
)
scalarIndex, _ = table_config.get_column(path, 'ScalarItem', None)
exportIndex, _ = table_config.get_column(path, 'ExportItem', None)
self.assertEqual(scalarIndex, 0)
self.assertEqual(exportIndex, 1)
def test_missing_value_is_null(self):
self.assertEqual(
ODataFormSerializer.serialize_forms_using_config(
[{}],
FormExportInstance(tables=[
TableConfiguration(columns=[
ExportColumn(
label='user-id',
item=ExportItem(path=[PathNode(name='user_id')]),
selected=True,
)
])
])), [{
'user-id': '---'
}])
def test_unselected_column_excluded(self):
self.assertEqual(
ODataFormSerializer.serialize_forms_using_config(
[{
'user_id': 'the-user-id'
}],
FormExportInstance(tables=[
TableConfiguration(columns=[
ExportColumn(
label='user-id',
item=ExportItem(path=[PathNode(name='user_id')]),
selected=False,
)
])
])), [{}])
def test_get_export_file(self):
export_file = get_export_file(
[
CaseExportInstance(
export_format=Format.JSON,
domain=DOMAIN,
case_type=DEFAULT_CASE_TYPE,
tables=[TableConfiguration(
label="My table",
selected=True,
path=[],
columns=[
ExportColumn(
label="Foo column",
item=ExportItem(
path=[PathNode(name="foo")]
),
selected=True,
),
ExportColumn(
label="Bar column",
item=ExportItem(
path=[PathNode(name="bar")]
),
selected=True,
)
]
)]
),
],
[] # No filters
)
with export_file as export:
self.assertEqual(
json.loads(export.read()),
{
u'My table': {
u'headers': [
u'Foo column',
u'Bar column'],
u'rows': [
[u'apple', u'banana'],
[u'apple', u'banana'],
[u'apple', u'banana'],
],
}
}
)
def test_missing_value_is_null(self):
self.assertEqual(
ODataCaseSerializer.serialize_cases_using_config(
[{}],
CaseExportInstance(tables=[
TableConfiguration(columns=[
ExportColumn(
label='owner-name-label',
item=ExportItem(path=[PathNode(
name='owner_name')]),
selected=True,
)
])
])), [{
'owner-name-label': '---'
}])
def test_simple_table(self):
"""
Confirm that some simple documents and a simple FormExportInstance
are writtern with _write_export_file() correctly
"""
export_instance = FormExportInstance(
export_format=Format.JSON,
tables=[
TableConfiguration(
label="My table",
selected=True,
columns=[
ExportColumn(
label="Q3",
item=ScalarItem(
path=[PathNode(name='form'), PathNode(name='q3')],
),
selected=True
),
ExportColumn(
label="Q1",
item=ScalarItem(
path=[PathNode(name='form'), PathNode(name='q1')],
),
selected=True
),
]
)
]
)
writer = _get_writer([export_instance])
with writer.open([export_instance]):
_write_export_instance(writer, export_instance, self.docs)
with ExportFile(writer.path, writer.format) as export:
self.assertEqual(
json.loads(export.read()),
{
u'My table': {
u'headers': [u'Q3', u'Q1'],
u'rows': [[u'baz', u'foo'], [u'bop', u'bip']],
}
}
)
def test_empty_location(self):
export_instance = FormExportInstance(
export_format=Format.JSON,
tables=[
TableConfiguration(
label="My table",
selected=True,
columns=[
ExportColumn(
label="location",
item=ScalarItem(
path=[PathNode(name='form'), PathNode(name='meta'), PathNode(name='location')],
),
selected=True
),
]
)
]
)
docs = [
{
'domain': 'my-domain',
'_id': '1234',
'form': {
'meta': {
'location': {'xmlns': 'abc'},
}
}
}
]
writer = get_export_writer([export_instance])
with writer.open([export_instance]):
write_export_instance(writer, export_instance, docs)
with ExportFile(writer.path, writer.format) as export:
self.assertEqual(
json.loads(export.read()),
{
'My table': {
'headers': ['location'],
'rows': [[EMPTY_VALUE]],
}
}
)
def test_populated_metadata_document(self):
odata_config = CaseExportInstance(
_id='my_config_id',
domain=self.domain.name,
is_odata_config=True,
tables=[
TableConfiguration(
selected=True,
columns=[
ExportColumn(
label='closed',
selected=True,
# this is what exports generate for a base level property
item=ExportItem(path=[PathNode(name='closed')])),
ExportColumn(
label='date_modified',
selected=True,
item=ExportItem(
path=[PathNode(name='date_modified')])),
ExportColumn(label='selected_property_1',
selected=True),
ExportColumn(label='selected_property_2',
selected=True),
ExportColumn(label='unselected_property'),
],
),
])
odata_config.save()
self.addCleanup(odata_config.delete)
non_odata_config = CaseExportInstance(domain=self.domain.name)
non_odata_config.save()
self.addCleanup(non_odata_config.delete)
config_in_other_domain = CaseExportInstance(domain='other_domain',
is_odata_config=True)
config_in_other_domain.save()
self.addCleanup(config_in_other_domain.delete)
correct_credentials = self._get_correct_credentials()
response = self._execute_query(correct_credentials)
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'application/xml')
self.assertEqual(response['OData-Version'], '4.0')
self.assertXmlEqual(
self.get_xml('populated_case_odata_metadata_document_from_config',
override_path=PATH_TO_TEST_DATA), response.content)
def test_user_permissions(self):
self.web_user.set_role(self.domain.name, 'none')
self.web_user.save()
self.addCleanup(self._setup_user_permissions)
export_config = CaseExportInstance(
_id='config_id',
tables=[TableConfiguration(columns=[])],
case_type='my_case_type',
domain=self.domain.name,
)
export_config.save()
self.addCleanup(export_config.delete)
correct_credentials = self._get_correct_credentials()
response = self._execute_query(correct_credentials)
self.assertEqual(response.status_code, 403)
def test_unselected_column_excluded(self):
self.assertEqual(
ODataCaseSerializer.serialize_cases_using_config(
[{
'owner_name': 'owner-name-value',
'properties': {}
}],
CaseExportInstance(tables=[
TableConfiguration(columns=[
ExportColumn(
label='owner-name-label',
item=ExportItem(path=[PathNode(
name='owner_name')]),
selected=False,
)
])
])), [{}])
def test_column_label_containing_at_sign(self):
export_with_column_containing_at_sign = ExportInstance(
is_odata_config=True,
tables=[
TableConfiguration(columns=[
ExportColumn(
label='@label',
item=ExportItem(path=[PathNode(name='val')]),
selected=True,
)
])
])
export_with_column_containing_at_sign.save()
self.addCleanup(export_with_column_containing_at_sign.delete)
cleaned_export = ExportInstance.get(
export_with_column_containing_at_sign.get_id)
self.assertEqual(cleaned_export.tables[0].columns[0].label, 'label')
def test_caseid_column_label(self):
export_with_modified_caseid_column = CaseExportInstance(
is_odata_config=True,
tables=[
TableConfiguration(columns=[
ExportColumn(
label='modified_case_id_column',
item=ExportItem(path=[PathNode(name='_id')]),
selected=True,
)
])
])
export_with_modified_caseid_column.save()
self.addCleanup(export_with_modified_caseid_column.delete)
cleaned_export = CaseExportInstance.get(
export_with_modified_caseid_column.get_id)
self.assertEqual(cleaned_export.tables[0].columns[0].label, 'caseid')
def test_selected_false(self):
export_file = get_export_file(
[
CaseExportInstance(export_format=Format.JSON,
domain=DOMAIN,
case_type=DEFAULT_CASE_TYPE,
tables=[
TableConfiguration(label="My table",
selected=False,
path=[],
columns=[])
]),
],
[] # No filters
)
with export_file as export:
self.assertEqual(json.loads(export.read()), {})
def test_array_data_in_scalar_question(self):
'''
This test ensures that when a question id has array data
that we return still return a string for scalar data.
This happens rarely
'''
doc = {
'domain': 'my-domain',
'_id': '12345',
"form": {
"array": ["one", "two"],
}
}
export_instance = FormExportInstance(
export_format=Format.JSON,
domain=DOMAIN,
xmlns='xmlns',
tables=[TableConfiguration(
label="My table",
selected=True,
path=[],
columns=[
ExportColumn(
label="Scalar Array",
item=ScalarItem(path=[PathNode(name='form'), PathNode(name='array')]),
selected=True,
)
]
)]
)
writer = get_export_writer([export_instance])
with writer.open([export_instance]):
write_export_instance(writer, export_instance, [doc])
with ExportFile(writer.path, writer.format) as export:
self.assertEqual(
json.loads(export.read()),
{
'My table': {
'headers': ['Scalar Array'],
'rows': [['one two']],
}
}
)
def test_config_in_different_domain(self):
export_config_in_other_domain = CaseExportInstance(
_id='config_id',
tables=[TableConfiguration(columns=[])],
case_type='my_case_type',
domain='different_domain')
export_config_in_other_domain.save()
self.addCleanup(export_config_in_other_domain.delete)
correct_credentials = self._get_correct_credentials()
with flag_enabled('BI_INTEGRATION_PREVIEW', is_preview=True):
response = self.client.get(
self._odata_feed_url_by_domain_and_config_id(
self.domain.name, export_config_in_other_domain.get_id),
HTTP_AUTHORIZATION='Basic ' + correct_credentials,
)
self.assertEqual(response.status_code, 404)
def test_case_name(self):
self.assertEqual(
ODataCaseSerializer.serialize_cases_using_config(
[{
'name': 'case-name-value'
}],
CaseExportInstance(tables=[
TableConfiguration(columns=[
ExportColumn(
label='case-name-label',
item=ExportItem(path=[PathNode(name='name')]),
selected=True,
)
])
])), [{
'case-name-label': 'case-name-value'
}])
def test_get_export_file(self):
export_json = get_export_json(
CaseExportInstance(
export_format=Format.JSON,
domain=DOMAIN,
case_type=DEFAULT_CASE_TYPE,
tables=[TableConfiguration(
label="My table",
selected=True,
path=[],
columns=[
ExportColumn(
label="Foo column",
item=ExportItem(
path=[PathNode(name="foo")]
),
selected=True,
),
ExportColumn(
label="Bar column",
item=ExportItem(
path=[PathNode(name="bar")]
),
selected=True,
)
]
)]
),
)
self.assertEqual(
export_json,
{
'My table': {
'headers': [
'Foo column',
'Bar column'],
'rows': [
['apple', 'banana'],
['apple', 'banana'],
['apple', 'banana'],
],
}
}
)
def test_non_standard_case_property(self):
self.assertEqual(
ODataCaseSerializer.serialize_cases_using_config(
[{
'property_1': 'property-1-value'
}],
CaseExportInstance(tables=[
TableConfiguration(columns=[
ExportColumn(
label='property-1-label',
item=ExportItem(path=[PathNode(
name='property_1')]),
selected=True,
)
])
])), [{
'property-1-label': 'property-1-value'
}])
def test_paginated_table(self):
export_instance = FormExportInstance(
export_format=Format.JSON,
tables=[
TableConfiguration(
label="My table",
selected=True,
columns=[
ExportColumn(
label="Q3",
item=ScalarItem(
path=[PathNode(name='form'), PathNode(name='q3')],
),
selected=True
),
ExportColumn(
label="Q1",
item=ScalarItem(
path=[PathNode(name='form'), PathNode(name='q1')],
),
selected=True
),
]
)
]
)
writer = get_export_writer([export_instance])
with writer.open([export_instance]):
write_export_instance(writer, export_instance, self.docs + self.docs)
with ExportFile(writer.path, writer.format) as export:
self.assertEqual(
json.loads(export.read()),
{
'My table_000': {
'headers': ['Q3', 'Q1'],
'rows': [['baz', 'foo'], ['bop', 'bip']],
},
'My table_001': {
'headers': ['Q3', 'Q1'],
'rows': [['baz', 'foo'], ['bop', 'bip']],
}
}
)
def test_export_transforms(self, _):
export_file = get_export_file(
[
CaseExportInstance(
export_format=Format.JSON,
domain=DOMAIN,
case_type=DEFAULT_CASE_TYPE,
tables=[TableConfiguration(
label="My table",
selected=True,
path=[],
columns=[
ExportColumn(
label="DEID Date Transform column",
item=ExportItem(
path=[PathNode(name="date")]
),
selected=True,
deid_transform=DEID_DATE_TRANSFORM,
)
]
)]
),
],
[] # No filters
)
with export_file as export:
export_dict = json.loads(export.read())
export_dict['My table']['rows'].sort()
self.assertEqual(
export_dict,
{
u'My table': {
u'headers': [
u'DEID Date Transform column [sensitive]',
],
u'rows': [
[MISSING_VALUE],
[u'2016-04-07'],
[u'2016-04-27'], # offset by 3 since that's the mocked random offset
],
}
}
)
def test_single_iteration_repeat(self):
table = TableConfiguration(
path=[PathNode(name='group1', is_repeat=False), PathNode(name='repeat1', is_repeat=True)],
)
self.assertEqual(
table._get_sub_documents(
{
'group1': {
'repeat1': {
'baz': 'a'
},
}
},
0
),
[
DocRow(row=(0, 0), doc={'baz': 'a'}),
]
)
def test_case_name_transform(self):
docs = [
{
'domain': 'my-domain',
'_id': '1234',
"form": {
"caseid": "robin",
},
},
{
'domain': 'my-domain',
'_id': '1234',
"form": {
"caseid": "i-do-not-exist",
},
}
]
export_instance = FormExportInstance(
export_format=Format.JSON,
tables=[
TableConfiguration(
label="My table",
selected=True,
columns=[
ExportColumn(
label="case_name",
item=ScalarItem(
path=[PathNode(name='form'), PathNode(name='caseid')],
transform=CASE_NAME_TRANSFORM,
),
selected=True
),
]
)
]
)
assert_instance_gives_results(docs, export_instance, {
'My table': {
'headers': ['case_name'],
'rows': [['batman'], [MISSING_VALUE]],
}
})
def test_ignore_case_link_label(self):
export_with_case_link = CaseExportInstance(
is_odata_config=True,
tables=[
TableConfiguration(columns=[
ExportColumn(
label='my_case_link',
item=ExportItem(
path=[PathNode(name='_id')],
transform=CASE_ID_TO_LINK,
),
selected=True,
)
])
])
export_with_case_link.save()
self.addCleanup(export_with_case_link.delete)
cleaned_export = CaseExportInstance.get(export_with_case_link.get_id)
self.assertEqual(cleaned_export.tables[0].columns[0].label,
'my_case_link')
def test_split_questions_false(self):
"""Ensure multiselects are not split when `split_multiselects` is set to False"""
export_instance = FormExportInstance(
export_format=Format.JSON,
domain=DOMAIN,
case_type=DEFAULT_CASE_TYPE,
split_multiselects=False,
tables=[TableConfiguration(
label="My table",
selected=True,
path=[],
columns=[
SplitExportColumn(
label="MC",
item=MultipleChoiceItem(
path=[PathNode(name='form'), PathNode(name='mc')],
options=[
Option(value='one'),
Option(value='two'),
]
),
selected=True,
)
]
)]
)
writer = _get_writer([export_instance])
with writer.open([export_instance]):
_write_export_instance(writer, export_instance, self.docs)
with ExportFile(writer.path, writer.format) as export:
self.assertEqual(
json.loads(export.read()),
{
u'My table': {
u'headers': [u'MC'],
u'rows': [['two extra'], ['one two']],
}
}
)
