def test_tableau_get_repeat_data(self):
"""
Test that data received from repeats is flattened
and the tablau data endpoint returns accurate data
for this question type
"""
self.view = OpenDataViewSet.as_view({'get': 'data'})
repeat_data = [{
'children/childs_age': 12,
'children/childs_name': 'Tom'
}, {
'children/childs_age': 5,
'children/childs_name': 'Dick'
}]
inst = Instance.objects.filter(xform=self.xform).first()
self.assertEqual(inst.json['children'], repeat_data)
_open_data = get_or_create_opendata(self.xform)
uuid = _open_data[0].uuid
request = self.factory.get('/', **self.extra)
response = self.view(request, uuid=uuid)
self.assertEqual(response.status_code, 200)
# cast generator response to list for easy manipulation
row_data = streaming_data(response)
# Test that Tableau receives group data
self.assertEqual(row_data[0]['children_1__childs_name'], 'Tom')
self.assertEqual(row_data[0]['children_2__childs_age'], 5)
# Test that gps data is unpacked for Tableau appropriately.
self.assertEqual(row_data[0]['_gps_latitude'], '-1.2625621')
self.assertEqual(row_data[0]['_gps_longitude'], '36.7921711')
def test_tableau_data_fetch(self): # pylint: disable=invalid-name
"""
Test that the row headers generated
match the column headers for the same form
"""
self.view = OpenDataViewSet.as_view({
'get': 'schema'
})
_open_data = get_or_create_opendata(self.xform)
uuid = _open_data[0].uuid
request1 = self.factory.get('/', **self.extra)
response1 = self.view(request1, uuid=uuid)
self.assertEqual(response1.status_code, 200)
self.assertListEqual(
['column_headers', 'connection_name', 'table_alias'],
sorted(list(response1.data))
)
expected_column_headers = [
'_gps_altitude',
'_gps_latitude',
'_gps_longitude',
'_gps_precision',
'_id',
'age',
'children_1__childs_age',
'children_1__childs_name',
'children_2__childs_age',
'children_2__childs_name',
'children_3__childs_age',
'children_3__childs_name',
'children_4__childs_age',
'children_4__childs_name',
'gps',
'has_children',
'meta_instanceID',
'name',
'picture',
'web_browsers_chrome',
'web_browsers_firefox',
'web_browsers_ie',
'web_browsers_safari'
]
self.view = OpenDataViewSet.as_view({
'get': 'data'
})
request2 = self.factory.get('/', **self.extra)
response2 = self.view(request2, uuid=uuid)
self.assertEqual(response2.status_code, 200)
# cast generator response to list for easy manipulation
row_data = streaming_data(response2)
row_data_fields = [k for k in row_data[0].keys()]
row_data_fields.sort()
self.assertEqual(row_data_fields, expected_column_headers)
def test_open_data(self):
"""Test OpenDataViewSet data endpoint"""
merged_dataset = self._create_merged_dataset()
merged_xform = MergedXForm.objects.get(pk=merged_dataset['id'])
_make_submissions_merged_datasets(merged_xform)
xform = XForm.objects.get(pk=merged_dataset['id'])
view = OpenDataViewSet.as_view({'get': 'data'})
_open_data = get_or_create_opendata(xform)[0]
uuid = _open_data.uuid
request = self.factory.get('/', **self.extra)
response = view(request, uuid=uuid)
self.assertEqual(response.status_code, 200)
# cast generator response to list so that we can get the response count
self.assertEqual(len(streaming_data(response)), 2)
def test_open_data(self):
"""Test OpenDataViewSet data endpoint"""
merged_dataset = self._create_merged_dataset()
merged_xform = MergedXForm.objects.get(pk=merged_dataset['id'])
_make_submissions_merged_datasets(merged_xform)
xform = XForm.objects.get(pk=merged_dataset['id'])
view = OpenDataViewSet.as_view({'get': 'data'})
_open_data = get_or_create_opendata(xform)[0]
uuid = _open_data.uuid
request = self.factory.get('/', **self.extra)
response = view(request, uuid=uuid)
self.assertEqual(response.status_code, 200)
# cast generator response to list so that we can get the response count
self.assertEqual(len(streaming_data(response)), 2)
def test_tableau_get_nested_repeat_group_data(self):
"""
Test that data received from nested repeat groups
is flattened and the tablau data endpoint
returns accurate data for this question type
"""
# Create form with nested repeat groups
xls_file_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"../../../main/tests/fixtures/transportation/transportation.xlsx")
self._publish_xls_file_and_set_xform(xls_file_path)
# Create submission
xml_submission_file_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)), "../../..", "main",
"tests", "fixtures", "transportation",
"transportation_w_nested_repeat_groups.xml")
self._make_submission(xml_submission_file_path)
# Get Tableau UUID from transportation test form
self.view = OpenDataViewSet.as_view({'get': 'uuid'})
_open_data = get_or_create_opendata(self.xform)
uuid = _open_data[0].uuid
data = {
'object_id': self.xform.id,
'data_type': 'xform',
}
request = self.factory.get('/', data=data, **self.extra)
response = self.view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, {'uuid': uuid})
# Fetch submission data
self.view = OpenDataViewSet.as_view({'get': 'data'})
request = self.factory.get('/', **self.extra)
response = self.view(request, uuid=uuid)
self.assertEqual(response.status_code, 200)
# cast generator response to list for easy manipulation
row_data = streaming_data(response)
# Confirm nested repeat group data is available in tableau
self.assertEqual(
row_data[0]['hospital_hiv_medication_person'
'_repeat_1__person_first_name'], 'Timburt')
def get_open_data_object(self):
return get_or_create_opendata(self.xform)[0]
def get_open_data_object(self):
return get_or_create_opendata(self.xform)[0]
def test_tableau_data_and_fetch(self): # pylint: disable=invalid-name
"""
Test the schema and data endpoint and data returned by each.
"""
self.view = TableauViewSet.as_view({'get': 'schema'})
_open_data = get_or_create_opendata(self.xform)
uuid = _open_data[0].uuid
expected_schema = [
{
'table_alias':
'data',
'connection_name':
f'{self.xform.project_id}_{self.xform.id_string}', # noqa
'column_headers': [{
'id': '_id',
'dataType': 'int',
'alias': '_id'
}, {
'id': 'name',
'dataType': 'string',
'alias': 'name'
}, {
'id': 'age',
'dataType': 'int',
'alias': 'age'
}, {
'id': 'picture',
'dataType': 'string',
'alias': 'picture'
}, {
'id': 'has_children',
'dataType': 'string',
'alias': 'has_children'
}, {
'id': '_gps_latitude',
'dataType': 'string',
'alias': '_gps_latitude'
}, {
'id': '_gps_longitude',
'dataType': 'string',
'alias': '_gps_longitude'
}, {
'id': '_gps_altitude',
'dataType': 'string',
'alias': '_gps_altitude'
}, {
'id': '_gps_precision',
'dataType': 'string',
'alias': '_gps_precision'
}, {
'id': 'browsers_firefox',
'dataType': 'string',
'alias': 'browsers_firefox'
}, {
'id': 'browsers_chrome',
'dataType': 'string',
'alias': 'browsers_chrome'
}, {
'id': 'browsers_ie',
'dataType': 'string',
'alias': 'browsers_ie'
}, {
'id': 'browsers_safari',
'dataType': 'string',
'alias': 'browsers_safari'
}, {
'id': 'meta_instanceID',
'dataType': 'string',
'alias': 'meta_instanceID'
}]
},
{
'table_alias':
'children',
'connection_name':
f'{self.xform.project_id}_{self.xform.id_string}_children', # noqa
'column_headers': [{
'id': '_id',
'dataType': 'int',
'alias': '_id'
}, {
'id': '__parent_id',
'dataType': 'int',
'alias': '__parent_id'
}, {
'id': '__parent_table',
'dataType': 'string',
'alias': '__parent_table'
}, {
'id': 'childs_name',
'dataType': 'string',
'alias': 'childs_name'
}, {
'id': 'childs_age',
'dataType': 'int',
'alias': 'childs_age'
}]
}
]
request1 = self.factory.get('/', **self.extra)
response1 = self.view(request1, uuid=uuid)
self.assertEqual(response1.status_code, 200)
self.assertEqual(response1.data, expected_schema)
# Test that multiple schemas are generated for each repeat
self.assertEqual(len(response1.data), 2)
self.assertListEqual(
['column_headers', 'connection_name', 'table_alias'],
sorted(list(response1.data[0].keys())))
connection_name = f'{self.xform.project_id}_{self.xform.id_string}'
self.assertEqual(connection_name,
response1.data[0].get('connection_name'))
# Test that the table alias field being sent to Tableau
# for each schema contains the right table name
self.assertEqual(u'data', response1.data[0].get('table_alias'))
self.assertEqual(u'children', response1.data[1].get('table_alias'))
_id_datatype = [
a.get('dataType') for a in response1.data[0]['column_headers']
if a.get('id') == '_id'
][0]
self.assertEqual(_id_datatype, 'int')
self.view = TableauViewSet.as_view({'get': 'data'})
request2 = self.factory.get('/', **self.extra)
response2 = self.view(request2, uuid=uuid)
self.assertEqual(response2.status_code, 200)
# cast generator response to list for easy manipulation
row_data = streaming_data(response2)
expected_data = [{
'_gps_altitude':
'0',
'_gps_latitude':
'26.431228',
'_gps_longitude':
'58.157921',
'_gps_precision':
'0',
'_id':
self.xform.instances.first().id,
'age':
32,
'browsers_chrome':
'TRUE',
'browsers_firefox':
'TRUE',
'browsers_ie':
'TRUE',
'browsers_safari':
'TRUE',
'children': [{
'__parent_id':
self.xform.instances.first().id,
'__parent_table':
'data',
'_id':
int(pairing(self.xform.instances.first().id, 1)),
'childs_age':
2,
'childs_name':
'Harry'
}, {
'__parent_id':
self.xform.instances.first().id,
'__parent_table':
'data',
'_id':
int(pairing(self.xform.instances.first().id, 2)),
'childs_age':
5,
'childs_name':
'Potter'
}],
'has_children':
'1',
'name':
'Tom',
'picture':
'wotm_01_green_desktop-10_36_1.jpg'
}]
# Test to confirm that the repeat tables generated
# are related to the main table
self.assertEqual(row_data[0]['children'][0]['__parent_table'],
response1.data[0]['table_alias'])
self.assertEqual(row_data, expected_data)
