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')
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)
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')
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,
is_json=False,
format_version='2.1')
self.assertEqual(obs, exp)
obs = self.cmd(table=self.hdf5_file_valid_md,
is_json=False,
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, is_json=False)
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', is_json=False)
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', is_json=True)
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', is_json=True)
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, is_json=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', is_json=True)
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', is_json=True)
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_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)
def test_valid(self):
"""Correctly validates a table that is indeed... valid."""
exp = {'valid_table': True, 'report_lines': []}
obs = self.cmd(table_json=self.min_sparse_otu)
self.assertEqual(obs, exp)
obs = self.cmd(table_json=self.rich_sparse_otu)
self.assertEqual(obs, exp)
# Soldier, report!!
obs = self.cmd(table_json=self.min_sparse_otu, 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'"]}
obs = self.cmd(table_json=self.min_sparse_otu)
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'"]}
obs = self.cmd(table_json=self.rich_dense_otu)
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_valid_format(self):
"""Should match format string"""
table = self.min_sparse_otu
self.cmd._format_version = 'Biological Observation Matrix 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)
def test_valid(self):
"""Correctly validates a table that is indeed... valid."""
exp = {"valid_table": True, "report_lines": []}
obs = self.cmd(table_json=self.min_sparse_otu)
self.assertEqual(obs, exp)
obs = self.cmd(table_json=self.rich_sparse_otu)
self.assertEqual(obs, exp)
# Soldier, report!!
obs = self.cmd(table_json=self.min_sparse_otu, 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'"]}
obs = self.cmd(table_json=self.min_sparse_otu)
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'",
],
}
obs = self.cmd(table_json=self.rich_dense_otu)
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_valid_format(self):
"""Should match format string"""
table = self.min_sparse_otu
self.cmd._format_version = "Biological Observation Matrix 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)
table["date"] = "10-11-1999 10:11:12"
obs = self.cmd._valid_datetime(table)
self.assertTrue(len(obs) == 0)
table["date"] = "10-11-1asdfasd: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('/', 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_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)
