def test__transform_synthesized_rows(self):
"""Test transform synthesized rows"""
# Setup
metadata_reverse_transform = pd.DataFrame({
'foo': [0, 1],
'bar': [2, 3],
'tar': [4, 5]
})
sampler = Mock(spec=Sampler)
sampler.metadata = Mock(spec=Metadata)
sampler.metadata.reverse_transform.return_value = metadata_reverse_transform
sampler.metadata.get_fields.return_value = {
'foo': 'some data',
'tar': 'some data'
}
# Run
synthesized = pd.DataFrame({'data': [1, 2, 3]})
result = Sampler._transform_synthesized_rows(sampler, synthesized,
'test')
# Asserts
expected = pd.DataFrame({'foo': [0, 1], 'tar': [4, 5]})
pd.testing.assert_frame_equal(result.sort_index(axis=1),
expected.sort_index(axis=1))
def test_transform_synthesized_rows_no_pk(self, get_table_meta_mock,
fill_mock):
"""transform_synthesized_rows will update internal state and reverse transform rows."""
# Setup - Class Instantiation
data_navigator = MagicMock()
modeler = MagicMock()
sampler = Sampler(data_navigator, modeler)
# Setup - Mock configuration
table_metadata = {
'fields': {
'column_A': {
'type': 'number',
'subtype': 'integer'
},
'column_B': {
'name': 'column',
'type': 'number'
}
},
'primary_key': None
}
table_data = pd.DataFrame(columns=['column_A', 'column_B'])
test_table = Table(table_data, table_metadata)
data_navigator.tables = {'table': test_table}
data_navigator.ht.transformers = {
('table', 'column_A'): None,
('table', 'column_B'): None
}
data_navigator.ht.reverse_transform_table.return_value = pd.DataFrame({
'column_A': ['some', 'transformed values'],
'column_B': ['another', 'transformed column']
})
get_table_meta_mock.return_value = {'original': 'meta', 'fields': []}
fill_mock.return_value = pd.DataFrame(
{
'column_A': ['filled', 'text_values'],
'column_B': ['nothing', 'numerical']
},
columns=[column[1] for column in data_navigator.ht.transformers])
# Setup - Method arguments / expected result
synthesized_rows = pd.DataFrame({
'column_A': [1.7, 2.5],
'column_B': [4.7, 5.1],
'model_parameters': ['some', 'parameters']
})
table_name = 'table'
expected_result = pd.DataFrame({
'column_A': ['some', 'transformed values'],
'column_B': ['another', 'transformed column']
})
# Run
result = sampler._transform_synthesized_rows(synthesized_rows,
table_name)
# Check - Result
assert result.equals(expected_result)
# Check - Mock calls
get_table_meta_mock.assert_called_once_with(sampler,
data_navigator.meta,
'table')
fill_mock.assert_called_once_with(sampler, synthesized_rows,
['column_A', 'column_B'], 'table')
call_args = data_navigator.ht.reverse_transform_table.call_args_list
assert len(call_args) == 1
assert len(call_args[0][0]) == 2
assert call_args[0][0][0].equals(fill_mock.return_value)
assert call_args[0][0][1] == get_table_meta_mock.return_value
assert call_args[0][1] == {}
def test__transform_synthesized_rows(self):
"""Reverse transform synthetized data."""
# Setup
ht_mock = Mock()
ht_mock.transformers = ['foo', 'bar']
ht_mock.reverse_transform_table.return_value = pd.DataFrame({
'foo': [1, 2, 3],
'bar': ['aaa', 'bbb', 'ccc']
})
dn_mock = Mock()
dn_mock.ht = ht_mock
dn_mock.get_meta_data.return_value = {
'fields': {
'foo': {
'subtype': 'integer'
},
'bar': {
'subtype': 'text'
},
}
}
fill_text_mock = Mock()
fill_text_mock.return_value = pd.DataFrame({
'foo': [1, 2, 3],
'bar': ['aaa', 'bbb', 'ccc']
})
# Run
sampler_mock = Mock()
sampler_mock.dn = dn_mock
sampler_mock._fill_text_columns = fill_text_mock
table_name = 'DEMO'
synthesized = pd.DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
columns=['foo', 'bar', 'tar'])
Sampler._transform_synthesized_rows(sampler_mock, synthesized,
table_name)
# Asserts
exp_called_synthesized = pd.DataFrame({
'foo': [1, 2, 3],
'bar': ['aaa', 'bbb', 'ccc'],
'tar': [3, 6, 9]
})
exp_called_labels = ['foo', 'bar']
exp_called_reverse_meta = {
'fields': [{
'subtype': 'integer',
'name': 'foo'
}, {
'subtype': 'text',
'name': 'bar'
}],
'name':
'DEMO'
}
dn_mock.get_meta_data.assert_called_once_with('DEMO')
fill_text_args, fill_text_kwargs = fill_text_mock.call_args
fill_text_data_frame, fill_text_labels, fill_text_table_name = fill_text_args
fill_text_data_frame.sort_index(axis=1, inplace=True)
exp_called_synthesized.sort_index(axis=1, inplace=True)
assert fill_text_mock.call_count == 1
assert sorted(fill_text_labels) == sorted(exp_called_labels)
assert fill_text_table_name == 'DEMO'
pd.testing.assert_frame_equal(fill_text_data_frame,
exp_called_synthesized)
rt_args, rt_kwargs = ht_mock.reverse_transform_table.call_args
rt_arg_text_filled, rt_arg_meta = rt_args
rt_arg_meta['fields'] = sorted(rt_arg_meta['fields'],
key=itemgetter('name'))
exp_called_reverse_meta['fields'] = sorted(
exp_called_reverse_meta['fields'], key=itemgetter('name'))
pd.testing.assert_frame_equal(rt_arg_text_filled,
pd.DataFrame(index=[0, 1, 2]))
assert rt_arg_meta == exp_called_reverse_meta
