def setUp(self):
"""Set up data for use in unit tests."""
self.cmd = TableValidator()
self.min_sparse_otu = json.loads(min_sparse_otu)
self.rich_sparse_otu = json.loads(rich_sparse_otu)
self.rich_dense_otu = json.loads(rich_dense_otu)
self.min_dense_otu = json.loads(min_dense_otu)
self.to_remove = []
cur_path = os.path.split(os.path.abspath(__file__))[0]
examples_path = os.path.join(cur_path.rsplit('/', 3)[0], 'examples')
self.hdf5_file_valid = os.path.join(examples_path,
'min_sparse_otu_table_hdf5.biom')
self.hdf5_file_valid_md = os.path.join(examples_path,
('rich_sparse_otu_table_hdf5'
'.biom'))
def setUp(self):
"""Set up data for use in unit tests."""
self.cmd = TableValidator()
self.min_sparse_otu = json.loads(min_sparse_otu)
self.rich_sparse_otu = json.loads(rich_sparse_otu)
self.rich_dense_otu = json.loads(rich_dense_otu)
self.min_dense_otu = json.loads(min_dense_otu)
self.to_remove = []
cur_path = os.path.split(os.path.abspath(__file__))[0]
examples_path = os.path.join(cur_path.rsplit('/', 2)[0], 'examples')
self.hdf5_file_valid = os.path.join(examples_path,
'min_sparse_otu_table_hdf5.biom')
self.hdf5_file_valid_md = os.path.join(examples_path,
('rich_sparse_otu_table_hdf5'
'.biom'))
class TableValidatorTests(TestCase):
def setUp(self):
"""Set up data for use in unit tests."""
self.cmd = TableValidator()
self.min_sparse_otu = json.loads(min_sparse_otu)
self.rich_sparse_otu = json.loads(rich_sparse_otu)
self.rich_dense_otu = json.loads(rich_dense_otu)
self.min_dense_otu = json.loads(min_dense_otu)
self.to_remove = []
cur_path = os.path.split(os.path.abspath(__file__))[0]
examples_path = os.path.join(cur_path.rsplit('/', 2)[0], 'examples')
self.hdf5_file_valid = os.path.join(examples_path,
'min_sparse_otu_table_hdf5.biom')
self.hdf5_file_valid_md = os.path.join(examples_path,
('rich_sparse_otu_table_hdf5'
'.biom'))
def tearDown(self):
for f in self.to_remove:
os.remove(f)
@npt.dec.skipif(HAVE_H5PY == False, msg='H5PY is not installed')
def test_valid_hdf5_metadata_v210(self):
exp = {'valid_table': True, 'report_lines': []}
obs = self.cmd(table=self.hdf5_file_valid,
format_version='2.1')
self.assertEqual(obs, exp)
obs = self.cmd(table=self.hdf5_file_valid_md,
format_version='2.1')
self.assertEqual(obs, exp)
@npt.dec.skipif(HAVE_H5PY == False, msg='H5PY is not installed')
def test_valid_hdf5_metadata_v200(self):
pass # omitting, not a direct way to test at this time using the repo
@npt.dec.skipif(HAVE_H5PY == False, msg='H5PY is not installed')
def test_valid_hdf5(self):
"""Test a valid HDF5 table"""
exp = {'valid_table': True,
'report_lines': []}
obs = self.cmd(table=self.hdf5_file_valid)
self.assertEqual(obs, exp)
@npt.dec.skipif(HAVE_H5PY == False, msg='H5PY is not installed')
def test_invalid_hdf5(self):
"""Test an invalid HDF5 table"""
exp = {'valid_table': False,
'report_lines': ["Missing attribute: 'creation-date'"]}
copy(self.hdf5_file_valid, 'invalid.hdf5')
self.to_remove.append('invalid.hdf5')
f = h5py.File('invalid.hdf5', 'a')
del f.attrs['creation-date']
f.close()
obs = self.cmd(table='invalid.hdf5')
self.assertEqual(obs, exp)
def test_valid(self):
"""Correctly validates a table that is indeed... valid."""
exp = {'valid_table': True, 'report_lines': []}
f = open('valid_test1', 'w')
f.write(json.dumps(self.min_sparse_otu))
f.close()
self.to_remove.append('valid_test1')
obs = self.cmd(table='valid_test1')
self.assertEqual(obs, exp)
f = open('valid_test2', 'w')
f.write(json.dumps(self.rich_sparse_otu))
f.close()
self.to_remove.append('valid_test2')
obs = self.cmd(table='valid_test2')
self.assertEqual(obs, exp)
# Soldier, report!!
f = open('valid_test3', 'w')
f.write(json.dumps(self.rich_sparse_otu))
f.close()
self.to_remove.append('valid_test3')
obs = self.cmd(table='valid_test3', detailed_report=True)
self.assertTrue(obs['valid_table'])
self.assertTrue(len(obs['report_lines']) > 0)
def test_invalid(self):
"""Correctly invalidates a table that is... invalid."""
del self.min_sparse_otu['date']
exp = {'valid_table': False, 'report_lines': ["Missing field: 'date'"]}
f = open('invalid_test1', 'w')
f.write(json.dumps(self.min_sparse_otu))
f.close()
self.to_remove.append('invalid_test1')
obs = self.cmd(table='invalid_test1')
self.assertEqual(obs, exp)
self.rich_dense_otu['shape'][1] = 42
exp = {'valid_table': False,
'report_lines': ['Incorrect number of cols: [0, 0, 1, 0, 0, 0]',
"Number of columns in 'columns' is not equal "
"to 'shape'"]}
f = open('invalid_test2', 'w')
f.write(json.dumps(self.rich_dense_otu))
f.close()
self.to_remove.append('invalid_test2')
obs = self.cmd(table='invalid_test2')
self.assertEqual(obs, exp)
def test_valid_format_url(self):
"""validates format url"""
table = self.min_sparse_otu
obs = self.cmd._valid_format_url(table)
self.assertTrue(len(obs) == 0)
table['format_url'] = 'foo'
obs = self.cmd._valid_format_url(table)
self.assertTrue(len(obs) > 0)
def test_is_int(self):
self.assertTrue(self.cmd._is_int(3))
self.assertFalse(self.cmd._is_int(3.5))
# checking with numpy dtypes
self.assertFalse(self.cmd._is_int(np.float64(3)))
self.assertFalse(self.cmd._is_int(np.float32(3)))
self.assertTrue(self.cmd._is_int(np.int64(3)))
self.assertTrue(self.cmd._is_int(np.int32(3)))
self.assertTrue(self.cmd._is_int(np.int16(3)))
def test_valid_format(self):
"""Should match format string"""
table = self.min_sparse_otu
self.cmd._format_version = '1.0.0'
obs = self.cmd._valid_format(table)
self.assertTrue(len(obs) == 0)
table['format'] = 'foo'
obs = self.cmd._valid_format(table)
self.assertTrue(len(obs) > 0)
def test_valid_type(self):
"""Should be valid table type"""
table = self.min_sparse_otu
table['type'] = 'otu table' # should not be case sensitive
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) == 0)
table['type'] = 'Pathway table'
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) == 0)
table['type'] = 'Function table'
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) == 0)
table['type'] = 'Ortholog table'
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) == 0)
table['type'] = 'Gene table'
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) == 0)
table['type'] = 'Metabolite table'
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) == 0)
table['type'] = 'OTU table'
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) == 0)
table['type'] = 'Taxon table'
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) == 0)
table['type'] = 'foo'
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) > 0)
def test_valid_generated_by(self):
"""Should have some string for generated by"""
table = self.min_sparse_otu
obs = self.cmd._valid_generated_by(table)
self.assertTrue(len(obs) == 0)
table['generated_by'] = None
obs = self.cmd._valid_generated_by(table)
self.assertTrue(len(obs) > 0)
def test_valid_nullable_id(self):
"""Should just work."""
pass
def test_valid_metadata(self):
"""Can be nullable or an object"""
table = self.min_sparse_otu
table['rows'][2]['metadata'] = None
obs = self.cmd._valid_metadata(table['rows'][2])
self.assertTrue(len(obs) == 0)
table['rows'][2]['metadata'] = {10: 20}
obs = self.cmd._valid_metadata(table['rows'][2])
self.assertTrue(len(obs) == 0)
table['rows'][2]['metadata'] = ""
obs = self.cmd._valid_metadata(table['rows'][2])
self.assertTrue(len(obs) > 0)
table['rows'][2]['metadata'] = "asdasda"
obs = self.cmd._valid_metadata(table['rows'][2])
self.assertTrue(len(obs) > 0)
table['rows'][2]['metadata'] = [{'a': 'b'}, {'c': 'd'}]
obs = self.cmd._valid_metadata(table['rows'][2])
self.assertTrue(len(obs) > 0)
def test_valid_matrix_type(self):
"""Make sure we have a valid matrix type"""
obs = self.cmd._valid_matrix_type(self.min_dense_otu)
self.assertTrue(len(obs) == 0)
obs = self.cmd._valid_matrix_type(self.min_sparse_otu)
self.assertTrue(len(obs) == 0)
table = self.min_dense_otu
table['matrix_type'] = 'spARSe'
obs = self.cmd._valid_matrix_type(table)
self.assertTrue(len(obs) > 0)
table['matrix_type'] = 'sparse_asdasd'
obs = self.cmd._valid_matrix_type(table)
self.assertTrue(len(obs) > 0)
def test_valid_matrix_element_type(self):
"""Make sure we have a valid matrix type"""
table = self.min_sparse_otu
obs = self.cmd._valid_matrix_element_type(table)
self.assertTrue(len(obs) == 0)
table['matrix_element_type'] = u'int'
obs = self.cmd._valid_matrix_element_type(table)
self.assertTrue(len(obs) == 0)
table['matrix_element_type'] = 'float'
obs = self.cmd._valid_matrix_element_type(table)
self.assertTrue(len(obs) == 0)
table['matrix_element_type'] = u'float'
obs = self.cmd._valid_matrix_element_type(table)
self.assertTrue(len(obs) == 0)
table['matrix_element_type'] = 'str'
obs = self.cmd._valid_matrix_element_type(table)
self.assertTrue(len(obs) == 0)
table['matrix_element_type'] = u'str'
obs = self.cmd._valid_matrix_element_type(table)
self.assertTrue(len(obs) == 0)
table['matrix_element_type'] = 'obj'
obs = self.cmd._valid_matrix_element_type(table)
self.assertTrue(len(obs) > 0)
table['matrix_element_type'] = u'asd'
obs = self.cmd._valid_matrix_element_type(table)
self.assertTrue(len(obs) > 0)
def test_valid_datetime(self):
"""Make sure we have a datetime stamp"""
table = self.min_sparse_otu
obs = self.cmd._valid_datetime(table)
self.assertTrue(len(obs) == 0)
table['date'] = "1999-11-11T10:11:12"
obs = self.cmd._valid_datetime(table)
self.assertTrue(len(obs) == 0)
def test_valid_sparse_data(self):
"""Takes a sparse matrix field and validates"""
table = self.min_sparse_otu
obs = self.cmd._valid_sparse_data(table)
self.assertTrue(len(obs) == 0)
# incorrect type
table['matrix_element_type'] = 'float'
obs = self.cmd._valid_sparse_data(table)
self.assertTrue(len(obs) > 0)
# not balanced
table['matrix_element_type'] = 'int'
table['data'][5] = [0, 10]
obs = self.cmd._valid_sparse_data(table)
self.assertTrue(len(obs) > 0)
# odd type for index
table['data'][5] = [1.2, 5, 10]
obs = self.cmd._valid_sparse_data(table)
self.assertTrue(len(obs) > 0)
def test_valid_dense_data(self):
"""Takes a dense matrix field and validates"""
table = self.min_dense_otu
obs = self.cmd._valid_dense_data(table)
self.assertTrue(len(obs) == 0)
# incorrect type
table['matrix_element_type'] = 'float'
obs = self.cmd._valid_dense_data(table)
self.assertTrue(len(obs) > 0)
# not balanced
table['matrix_element_type'] = 'int'
table['data'][1] = [0, 10]
obs = self.cmd._valid_dense_data(table)
self.assertTrue(len(obs) > 0)
# bad type in a field
table['data'][1] = [5, 1, 0, 2.3, 3, 1]
obs = self.cmd._valid_dense_data(table)
self.assertTrue(len(obs) > 0)
def test_valid_shape(self):
"""validates shape information"""
obs = self.cmd._valid_shape(self.min_sparse_otu)
self.assertTrue(len(obs) == 0)
obs = self.cmd._valid_shape(self.rich_sparse_otu)
self.assertTrue(len(obs) == 0)
bad_shape = self.min_sparse_otu.copy()
bad_shape['shape'] = ['asd', 10]
obs = self.cmd._valid_shape(bad_shape)
self.assertTrue(len(obs) > 0)
def test_valid_rows(self):
"""validates rows: field"""
table = self.rich_dense_otu
obs = self.cmd._valid_rows(table)
self.assertTrue(len(obs) == 0)
table['rows'][0]['id'] = ""
obs = self.cmd._valid_rows(table)
self.assertTrue(len(obs) > 0)
table['rows'][0]['id'] = None
obs = self.cmd._valid_rows(table)
self.assertTrue(len(obs) > 0)
del table['rows'][0]['id']
obs = self.cmd._valid_rows(table)
self.assertTrue(len(obs) > 0)
table['rows'][0]['id'] = 'asd'
table['rows'][0]['metadata'] = None
obs = self.cmd._valid_rows(table)
self.assertTrue(len(obs) == 0)
# since this is an OTU table, metadata is a required key
del table['rows'][0]['metadata']
obs = self.cmd._valid_rows(table)
self.assertTrue(len(obs) > 0)
def test_valid_columns(self):
"""validates table:columns: fields"""
table = self.rich_dense_otu
obs = self.cmd._valid_columns(table)
self.assertTrue(len(obs) == 0)
table['columns'][0]['id'] = ""
obs = self.cmd._valid_columns(table)
self.assertTrue(len(obs) > 0)
table['columns'][0]['id'] = None
obs = self.cmd._valid_columns(table)
self.assertTrue(len(obs) > 0)
del table['columns'][0]['id']
obs = self.cmd._valid_columns(table)
self.assertTrue(len(obs) > 0)
table['columns'][0]['id'] = 'asd'
table['columns'][0]['metadata'] = None
obs = self.cmd._valid_columns(table)
self.assertTrue(len(obs) == 0)
# since this is an OTU table, metadata is a required key
del table['columns'][0]['metadata']
obs = self.cmd._valid_columns(table)
self.assertTrue(len(obs) > 0)
def test_valid_data(self):
"""validates data: fields"""
# the burden of validating data is passed on to valid_sparse_data
# and valid_dense_data
table = self.rich_sparse_otu
obs = self.cmd._valid_data(table)
self.assertTrue(len(obs) == 0)
table['matrix_type'] = 'foo'
obs = self.cmd._valid_data(table)
self.assertTrue(len(obs) > 0)
class TableValidatorTests(TestCase):
def setUp(self):
"""Set up data for use in unit tests."""
self.cmd = TableValidator()
self.min_sparse_otu = json.loads(min_sparse_otu)
self.rich_sparse_otu = json.loads(rich_sparse_otu)
self.rich_dense_otu = json.loads(rich_dense_otu)
self.min_dense_otu = json.loads(min_dense_otu)
self.to_remove = []
cur_path = os.path.split(os.path.abspath(__file__))[0]
examples_path = os.path.join(cur_path.rsplit('/', 3)[0], 'examples')
self.hdf5_file_valid = os.path.join(examples_path,
'min_sparse_otu_table_hdf5.biom')
self.hdf5_file_valid_md = os.path.join(examples_path,
('rich_sparse_otu_table_hdf5'
'.biom'))
def tearDown(self):
for f in self.to_remove:
os.remove(f)
@npt.dec.skipif(HAVE_H5PY is False, msg='H5PY is not installed')
def test_valid_hdf5_metadata_v210(self):
exp = {'valid_table': True, 'report_lines': []}
obs = self.cmd(table=self.hdf5_file_valid, format_version='2.1')
self.assertEqual(obs, exp)
obs = self.cmd(table=self.hdf5_file_valid_md, format_version='2.1')
self.assertEqual(obs, exp)
@npt.dec.skipif(HAVE_H5PY is False, msg='H5PY is not installed')
def test_valid_hdf5_metadata_v200(self):
pass # omitting, not a direct way to test at this time using the repo
@npt.dec.skipif(HAVE_H5PY is False, msg='H5PY is not installed')
def test_valid_hdf5(self):
"""Test a valid HDF5 table"""
exp = {'valid_table': True, 'report_lines': []}
obs = self.cmd(table=self.hdf5_file_valid)
self.assertEqual(obs, exp)
@npt.dec.skipif(HAVE_H5PY is False, msg='H5PY is not installed')
def test_invalid_hdf5(self):
"""Test an invalid HDF5 table"""
exp = {
'valid_table': False,
'report_lines': ["Missing attribute: 'creation-date'"]
}
copy(self.hdf5_file_valid, 'invalid.hdf5')
self.to_remove.append('invalid.hdf5')
f = h5py.File('invalid.hdf5', 'a')
del f.attrs['creation-date']
f.close()
obs = self.cmd(table='invalid.hdf5')
self.assertEqual(obs, exp)
def test_valid(self):
"""Correctly validates a table that is indeed... valid."""
exp = {'valid_table': True, 'report_lines': []}
f = open('valid_test1', 'w')
f.write(json.dumps(self.min_sparse_otu))
f.close()
self.to_remove.append('valid_test1')
obs = self.cmd(table='valid_test1')
self.assertEqual(obs, exp)
f = open('valid_test2', 'w')
f.write(json.dumps(self.rich_sparse_otu))
f.close()
self.to_remove.append('valid_test2')
obs = self.cmd(table='valid_test2')
self.assertEqual(obs, exp)
# Soldier, report!!
f = open('valid_test3', 'w')
f.write(json.dumps(self.rich_sparse_otu))
f.close()
self.to_remove.append('valid_test3')
obs = self.cmd(table='valid_test3')
self.assertTrue(obs['valid_table'])
def test_invalid(self):
"""Correctly invalidates a table that is... invalid."""
del self.min_sparse_otu['date']
exp = {'valid_table': False, 'report_lines': ["Missing field: 'date'"]}
f = open('invalid_test1', 'w')
f.write(json.dumps(self.min_sparse_otu))
f.close()
self.to_remove.append('invalid_test1')
obs = self.cmd(table='invalid_test1')
self.assertEqual(obs, exp)
self.rich_dense_otu['shape'][1] = 42
exp = {
'valid_table':
False,
'report_lines': [
'Incorrect number of cols: [0, 0, 1, 0, 0, 0]',
"Number of columns in 'columns' is not equal "
"to 'shape'"
]
}
f = open('invalid_test2', 'w')
f.write(json.dumps(self.rich_dense_otu))
f.close()
self.to_remove.append('invalid_test2')
obs = self.cmd(table='invalid_test2')
self.assertEqual(obs, exp)
def test_valid_format_url(self):
"""validates format url"""
table = self.min_sparse_otu
obs = self.cmd._valid_format_url(table)
self.assertTrue(len(obs) == 0)
table['format_url'] = 'foo'
obs = self.cmd._valid_format_url(table)
self.assertTrue(len(obs) > 0)
def test_is_int(self):
self.assertTrue(self.cmd._is_int(3))
self.assertFalse(self.cmd._is_int(3.5))
# checking with numpy dtypes
self.assertFalse(self.cmd._is_int(np.float64(3)))
self.assertFalse(self.cmd._is_int(np.float32(3)))
self.assertTrue(self.cmd._is_int(np.int64(3)))
self.assertTrue(self.cmd._is_int(np.int32(3)))
self.assertTrue(self.cmd._is_int(np.int16(3)))
def test_valid_format(self):
"""Should match format string"""
table = self.min_sparse_otu
self.cmd._format_version = '1.0.0'
obs = self.cmd._valid_format(table)
self.assertTrue(len(obs) == 0)
table['format'] = 'foo'
obs = self.cmd._valid_format(table)
self.assertTrue(len(obs) > 0)
def test_valid_type(self):
"""Should be valid table type"""
table = self.min_sparse_otu
table['type'] = 'otu table' # should not be case sensitive
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) == 0)
table['type'] = 'Pathway table'
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) == 0)
table['type'] = 'Function table'
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) == 0)
table['type'] = 'Ortholog table'
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) == 0)
table['type'] = 'Gene table'
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) == 0)
table['type'] = 'Metabolite table'
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) == 0)
table['type'] = 'OTU table'
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) == 0)
table['type'] = 'Taxon table'
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) == 0)
table['type'] = 'foo'
obs = self.cmd._valid_type(table)
self.assertTrue(len(obs) > 0)
def test_valid_generated_by(self):
"""Should have some string for generated by"""
table = self.min_sparse_otu
obs = self.cmd._valid_generated_by(table)
self.assertTrue(len(obs) == 0)
table['generated_by'] = None
obs = self.cmd._valid_generated_by(table)
self.assertTrue(len(obs) > 0)
def test_valid_nullable_id(self):
"""Should just work."""
pass
def test_valid_metadata(self):
"""Can be nullable or an object"""
table = self.min_sparse_otu
table['rows'][2]['metadata'] = None
obs = self.cmd._valid_metadata(table['rows'][2])
self.assertTrue(len(obs) == 0)
table['rows'][2]['metadata'] = {10: 20}
obs = self.cmd._valid_metadata(table['rows'][2])
self.assertTrue(len(obs) == 0)
table['rows'][2]['metadata'] = ""
obs = self.cmd._valid_metadata(table['rows'][2])
self.assertTrue(len(obs) > 0)
table['rows'][2]['metadata'] = "asdasda"
obs = self.cmd._valid_metadata(table['rows'][2])
self.assertTrue(len(obs) > 0)
table['rows'][2]['metadata'] = [{'a': 'b'}, {'c': 'd'}]
obs = self.cmd._valid_metadata(table['rows'][2])
self.assertTrue(len(obs) > 0)
def test_valid_matrix_type(self):
"""Make sure we have a valid matrix type"""
obs = self.cmd._valid_matrix_type(self.min_dense_otu)
self.assertTrue(len(obs) == 0)
obs = self.cmd._valid_matrix_type(self.min_sparse_otu)
self.assertTrue(len(obs) == 0)
table = self.min_dense_otu
table['matrix_type'] = 'spARSe'
obs = self.cmd._valid_matrix_type(table)
self.assertTrue(len(obs) > 0)
table['matrix_type'] = 'sparse_asdasd'
obs = self.cmd._valid_matrix_type(table)
self.assertTrue(len(obs) > 0)
def test_valid_matrix_element_type(self):
"""Make sure we have a valid matrix type"""
table = self.min_sparse_otu
obs = self.cmd._valid_matrix_element_type(table)
self.assertTrue(len(obs) == 0)
table['matrix_element_type'] = u'int'
obs = self.cmd._valid_matrix_element_type(table)
self.assertTrue(len(obs) == 0)
table['matrix_element_type'] = 'float'
obs = self.cmd._valid_matrix_element_type(table)
self.assertTrue(len(obs) == 0)
table['matrix_element_type'] = u'float'
obs = self.cmd._valid_matrix_element_type(table)
self.assertTrue(len(obs) == 0)
table['matrix_element_type'] = 'str'
obs = self.cmd._valid_matrix_element_type(table)
self.assertTrue(len(obs) == 0)
table['matrix_element_type'] = u'str'
obs = self.cmd._valid_matrix_element_type(table)
self.assertTrue(len(obs) == 0)
table['matrix_element_type'] = 'obj'
obs = self.cmd._valid_matrix_element_type(table)
self.assertTrue(len(obs) > 0)
table['matrix_element_type'] = u'asd'
obs = self.cmd._valid_matrix_element_type(table)
self.assertTrue(len(obs) > 0)
def test_valid_datetime(self):
"""Make sure we have a datetime stamp"""
table = self.min_sparse_otu
obs = self.cmd._valid_datetime(table)
self.assertTrue(len(obs) == 0)
table['date'] = "1999-11-11T10:11:12"
obs = self.cmd._valid_datetime(table)
self.assertTrue(len(obs) == 0)
def test_valid_sparse_data(self):
"""Takes a sparse matrix field and validates"""
table = self.min_sparse_otu
obs = self.cmd._valid_sparse_data(table)
self.assertTrue(len(obs) == 0)
# incorrect type
table['matrix_element_type'] = 'float'
obs = self.cmd._valid_sparse_data(table)
self.assertTrue(len(obs) > 0)
# not balanced
table['matrix_element_type'] = 'int'
table['data'][5] = [0, 10]
obs = self.cmd._valid_sparse_data(table)
self.assertTrue(len(obs) > 0)
# odd type for index
table['data'][5] = [1.2, 5, 10]
obs = self.cmd._valid_sparse_data(table)
self.assertTrue(len(obs) > 0)
def test_valid_dense_data(self):
"""Takes a dense matrix field and validates"""
table = self.min_dense_otu
obs = self.cmd._valid_dense_data(table)
self.assertTrue(len(obs) == 0)
# incorrect type
table['matrix_element_type'] = 'float'
obs = self.cmd._valid_dense_data(table)
self.assertTrue(len(obs) > 0)
# not balanced
table['matrix_element_type'] = 'int'
table['data'][1] = [0, 10]
obs = self.cmd._valid_dense_data(table)
self.assertTrue(len(obs) > 0)
# bad type in a field
table['data'][1] = [5, 1, 0, 2.3, 3, 1]
obs = self.cmd._valid_dense_data(table)
self.assertTrue(len(obs) > 0)
def test_valid_shape(self):
"""validates shape information"""
obs = self.cmd._valid_shape(self.min_sparse_otu)
self.assertTrue(len(obs) == 0)
obs = self.cmd._valid_shape(self.rich_sparse_otu)
self.assertTrue(len(obs) == 0)
bad_shape = self.min_sparse_otu.copy()
bad_shape['shape'] = ['asd', 10]
obs = self.cmd._valid_shape(bad_shape)
self.assertTrue(len(obs) > 0)
def test_valid_rows(self):
"""validates rows: field"""
table = self.rich_dense_otu
obs = self.cmd._valid_rows(table)
self.assertTrue(len(obs) == 0)
table['rows'][0]['id'] = ""
obs = self.cmd._valid_rows(table)
self.assertTrue(len(obs) > 0)
table['rows'][0]['id'] = None
obs = self.cmd._valid_rows(table)
self.assertTrue(len(obs) > 0)
del table['rows'][0]['id']
obs = self.cmd._valid_rows(table)
self.assertTrue(len(obs) > 0)
table['rows'][0]['id'] = 'asd'
table['rows'][0]['metadata'] = None
obs = self.cmd._valid_rows(table)
self.assertTrue(len(obs) == 0)
# since this is an OTU table, metadata is a required key
del table['rows'][0]['metadata']
obs = self.cmd._valid_rows(table)
self.assertTrue(len(obs) > 0)
def test_valid_columns(self):
"""validates table:columns: fields"""
table = self.rich_dense_otu
obs = self.cmd._valid_columns(table)
self.assertTrue(len(obs) == 0)
table['columns'][0]['id'] = ""
obs = self.cmd._valid_columns(table)
self.assertTrue(len(obs) > 0)
table['columns'][0]['id'] = None
obs = self.cmd._valid_columns(table)
self.assertTrue(len(obs) > 0)
del table['columns'][0]['id']
obs = self.cmd._valid_columns(table)
self.assertTrue(len(obs) > 0)
table['columns'][0]['id'] = 'asd'
table['columns'][0]['metadata'] = None
obs = self.cmd._valid_columns(table)
self.assertTrue(len(obs) == 0)
# since this is an OTU table, metadata is a required key
del table['columns'][0]['metadata']
obs = self.cmd._valid_columns(table)
self.assertTrue(len(obs) > 0)
def test_valid_data(self):
"""validates data: fields"""
# the burden of validating data is passed on to valid_sparse_data
# and valid_dense_data
table = self.rich_sparse_otu
obs = self.cmd._valid_data(table)
self.assertTrue(len(obs) == 0)
table['matrix_type'] = 'foo'
obs = self.cmd._valid_data(table)
self.assertTrue(len(obs) > 0)