def _template_generator(study, full_access):
"""Generates tuples of prep template information
Parameters
----------
study : Study
The study to get all the prep templates
full_access : boolean
A boolean that indicates if the user has full access to the study
Returns
-------
Generator of tuples of (int, str, PrepTemplate, (str, str, str))
Each tuple contains the prep template id, the prep template data_type
the PrepTemplate object and a tuple with 3 strings for the style of
the prep template status icons
"""
for pt_id in sorted(study.prep_templates()):
pt = PrepTemplate(pt_id)
if full_access or pt.status == 'public':
yield (pt.id, pt.data_type(), pt, STATUS_STYLER[pt.status])
class PreprocessedDataTests(TestCase):
"""Tests the PreprocessedData class"""
def setUp(self):
self.prep_template = PrepTemplate(1)
self.study = Study(1)
self.params_table = "preprocessed_sequence_illumina_params"
self.params_id = 1
fd, self.fna_fp = mkstemp(suffix='_seqs.fna')
close(fd)
fd, self.qual_fp = mkstemp(suffix='_seqs.qual')
close(fd)
self.filepaths = [(self.fna_fp, 4), (self.qual_fp, 5)]
_, self.db_test_ppd_dir = get_mountpoint(
'preprocessed_data')[0]
self.ebi_submission_accession = "EBI123456-A"
self.ebi_study_accession = "EBI123456-B"
with open(self.fna_fp, "w") as f:
f.write("\n")
with open(self.qual_fp, "w") as f:
f.write("\n")
self._clean_up_files = []
def tearDown(self):
for f in self._clean_up_files:
remove(f)
def test_create(self):
"""Correctly creates the preprocessed data object"""
# Check that the returned object has the correct id
new_id = get_count('qiita.preprocessed_data') + 1
obs = PreprocessedData.create(
self.study, self.params_table,
self.params_id, self.filepaths, prep_template=self.prep_template)
self.assertEqual(obs.id, new_id)
# Check that all the information is initialized correctly
self.assertEqual(obs.processed_data, [])
self.assertEqual(obs.prep_template, self.prep_template.id)
self.assertEqual(obs.study, self.study.id)
self.assertEqual(obs.data_type(), self.prep_template.data_type())
self.assertEqual(obs.data_type(ret_id=True),
self.prep_template.data_type(ret_id=True))
self.assertEqual(obs.submitted_to_vamps_status(), "not submitted")
self.assertEqual(obs.processing_status, "not_processed")
self.assertEqual(obs.status, "sandbox")
self.assertEqual(obs.preprocessing_info,
(self.params_table, self.params_id))
def test_create_data_type_only(self):
# Check that the returned object has the correct id
new_id = get_count('qiita.preprocessed_data') + 1
obs = PreprocessedData.create(self.study, self.params_table,
self.params_id, self.filepaths,
data_type="18S")
self.assertEqual(obs.id, new_id)
# Check that all the information is initialized correctly
self.assertEqual(obs.processed_data, [])
self.assertEqual(obs.prep_template, [])
self.assertEqual(obs.study, self.study.id)
self.assertEqual(obs.data_type(), "18S")
self.assertEqual(obs.data_type(ret_id=True),
convert_to_id("18S", "data_type"))
self.assertEqual(obs.submitted_to_vamps_status(), "not submitted")
self.assertEqual(obs.processing_status, "not_processed")
self.assertEqual(obs.status, "sandbox")
self.assertEqual(obs.preprocessing_info,
(self.params_table, self.params_id))
def test_delete_basic(self):
"""Correctly deletes a preprocessed data"""
# testing regular delete
ppd = PreprocessedData.create(
self.study, self.params_table,
self.params_id, self.filepaths, prep_template=self.prep_template)
PreprocessedData.delete(ppd.id)
# testing that the deleted preprocessed data can't be instantiated
with self.assertRaises(QiitaDBUnknownIDError):
PreprocessedData(ppd.id)
# and for completeness testing that it raises an error if ID
# doesn't exist
with self.assertRaises(QiitaDBUnknownIDError):
PreprocessedData.delete(ppd.id)
# testing that we can not remove cause the preprocessed data != sandbox
with self.assertRaises(QiitaDBStatusError):
PreprocessedData.delete(1)
def test_delete_advanced(self):
# testing that we can not remove cause preprocessed data has been
# submitted to EBI or VAMPS
ppd = PreprocessedData.create(
self.study, self.params_table,
self.params_id, self.filepaths, prep_template=self.prep_template)
# fails due to VAMPS submission
ppd.update_vamps_status('success')
with self.assertRaises(QiitaDBStatusError):
PreprocessedData.delete(ppd.id)
ppd.update_vamps_status('failed')
ppd = PreprocessedData(1)
with self.assertRaises(QiitaDBStatusError):
PreprocessedData.delete(ppd.id)
def test_create_error_dynamic_table(self):
"""Raises an error if the preprocessed_params_table does not exist"""
with self.assertRaises(IncompetentQiitaDeveloperError):
PreprocessedData.create(self.study, "foo", self.params_id,
self.filepaths, data_type="18S")
with self.assertRaises(IncompetentQiitaDeveloperError):
PreprocessedData.create(self.study, "preprocessed_foo",
self.params_id, self.filepaths,
data_type="18S")
with self.assertRaises(IncompetentQiitaDeveloperError):
PreprocessedData.create(self.study, "foo_params", self.params_id,
self.filepaths, data_type="18S")
with self.assertRaises(IncompetentQiitaDeveloperError):
PreprocessedData.create(self.study, "preprocessed_foo_params",
self.params_id, self.filepaths,
data_type="18S")
def test_create_error_data_type(self):
with self.assertRaises(QiitaDBLookupError):
PreprocessedData.create(self.study,
"preprocessed_sequence_illumina_params",
self.params_id, self.filepaths,
data_type="Metabolomics")
with self.assertRaises(IncompetentQiitaDeveloperError):
PreprocessedData.create(self.study,
"preprocessed_sequence_illumina_params",
self.params_id, self.filepaths,
data_type="Metabolomics",
prep_template=self.prep_template)
def test_get_filepaths(self):
"""Correctly returns the filepaths to the preprocessed files"""
ppd = PreprocessedData(1)
obs = ppd.get_filepaths()
exp = [(3, join(self.db_test_ppd_dir, '1_seqs.fna'),
"preprocessed_fasta"),
(4, join(self.db_test_ppd_dir, '1_seqs.qual'),
"preprocessed_fastq"),
(5, join(self.db_test_ppd_dir, '1_seqs.demux'),
"preprocessed_demux")]
self.assertItemsEqual(obs, exp)
def test_processed_data(self):
"""Correctly returns the processed data id"""
ppd = PreprocessedData(1)
self.assertEqual(ppd.processed_data, [1])
def test_prep_template(self):
"""Correctly returns the prep template"""
ppd = PreprocessedData(1)
self.assertEqual(ppd.prep_template, 1)
def test_study(self):
"""Correctly returns the study"""
ppd = PreprocessedData(1)
self.assertEqual(ppd.study, 1)
def test_data_type(self):
"""Correctly returns the data_type of preprocessed_data"""
pd = ProcessedData(1)
self.assertEqual(pd.data_type(), "18S")
def test_data_type_id(self):
"""Correctly returns the data_type of preprocessed_data"""
pd = ProcessedData(1)
self.assertEqual(pd.data_type(ret_id=True), 2)
def test_link_filepaths_status(self):
ppd = PreprocessedData(1)
self.assertEqual(ppd.link_filepaths_status, 'idle')
def test_link_filepaths_status_setter(self):
ppd = PreprocessedData(1)
self.assertEqual(ppd.link_filepaths_status, 'idle')
ppd._set_link_filepaths_status('linking')
self.assertEqual(ppd.link_filepaths_status, 'linking')
ppd._set_link_filepaths_status('unlinking')
self.assertEqual(ppd.link_filepaths_status, 'unlinking')
ppd._set_link_filepaths_status('failed: error')
self.assertEqual(ppd.link_filepaths_status, 'failed: error')
def test_link_filepaths_status_setter_error(self):
ppd = PreprocessedData(1)
with self.assertRaises(ValueError):
ppd._set_link_filepaths_status('not a valid status')
def test_vamps_status(self):
ppd = PreprocessedData(1)
# verifying current value
self.assertEqual(ppd.submitted_to_vamps_status(), 'not submitted')
# changing value and then verifying new value
ppd.update_vamps_status('failed')
self.assertEqual(ppd.submitted_to_vamps_status(), 'failed')
# checking failure
with self.assertRaises(ValueError):
ppd.update_vamps_status('not a valid status')
def test_processing_status(self):
"""processing_status works correctly"""
# Processed case
ppd = PreprocessedData(1)
self.assertEqual(ppd.processing_status, 'not_processed')
# not processed case
ppd = PreprocessedData.create(self.study, self.params_table,
self.params_id, self.filepaths,
data_type="18S")
self.assertEqual(ppd.processing_status, 'not_processed')
def test_processing_status_setter(self):
"""Able to update the processing status"""
ppd = PreprocessedData.create(self.study, self.params_table,
self.params_id, self.filepaths,
data_type="18S")
self.assertEqual(ppd.processing_status, 'not_processed')
ppd.processing_status = 'processing'
self.assertEqual(ppd.processing_status, 'processing')
ppd.processing_status = 'processed'
self.assertEqual(ppd.processing_status, 'processed')
state = 'failed: some error message'
ppd.processing_status = state
self.assertEqual(ppd.processing_status, state)
def test_processing_status_setter_valueerror(self):
"""Raises an error if the processing status is not recognized"""
ppd = PreprocessedData.create(self.study, self.params_table,
self.params_id, self.filepaths,
data_type="18S")
with self.assertRaises(ValueError):
ppd.processing_status = 'not a valid state'
def test_exists(self):
self.assertTrue(PreprocessedData.exists(1))
self.assertFalse(PreprocessedData.exists(1000))
def test_status(self):
ppd = PreprocessedData(1)
self.assertEqual(ppd.status, 'private')
# Since the status is inferred from the processed data, change the
# status of the processed data so we can check how it changes in the
# preprocessed data
pd = ProcessedData(1)
pd.status = 'public'
self.assertEqual(ppd.status, 'public')
# Check that new preprocessed data has sandbox as status since no
# processed data exists for them
ppd = PreprocessedData.create(self.study, self.params_table,
self.params_id, self.filepaths,
data_type="16S")
self.assertEqual(ppd.status, 'sandbox')
def test_is_submitted_to_ebi(self):
self.assertTrue(PreprocessedData(1).is_submitted_to_ebi)
self.assertFalse(PreprocessedData(2).is_submitted_to_ebi)
def test_ebi_run_accessions(self):
exp = ['ERR0000001', 'ERR0000002', 'ERR0000003', 'ERR0000004',
'ERR0000005', 'ERR0000006', 'ERR0000007', 'ERR0000008',
'ERR0000009', 'ERR0000010', 'ERR0000011', 'ERR0000012',
'ERR0000013', 'ERR0000014', 'ERR0000015', 'ERR0000016',
'ERR0000017', 'ERR0000018', 'ERR0000019', 'ERR0000020',
'ERR0000021', 'ERR0000022', 'ERR0000023', 'ERR0000024',
'ERR0000025', 'ERR0000026', 'ERR0000027']
self.assertEqual(PreprocessedData(1).ebi_run_accessions, exp,)
self.assertEqual(PreprocessedData(2).ebi_run_accessions, [])
def test_ebi_run_accessions_setter(self):
new_vals = {
'1.SKB1.640202': 'ERR1000001',
'1.SKB2.640194': 'ERR1000002',
'1.SKB3.640195': 'ERR1000003',
'1.SKB4.640189': 'ERR1000004',
'1.SKB5.640181': 'ERR1000005',
'1.SKB6.640176': 'ERR1000006',
'1.SKB7.640196': 'ERR1000007',
'1.SKB8.640193': 'ERR1000008',
'1.SKB9.640200': 'ERR1000009',
'1.SKD1.640179': 'ERR1000010',
'1.SKD2.640178': 'ERR1000011',
'1.SKD3.640198': 'ERR1000012',
'1.SKD4.640185': 'ERR1000013',
'1.SKD5.640186': 'ERR1000014',
'1.SKD6.640190': 'ERR1000015',
'1.SKD7.640191': 'ERR1000016',
'1.SKD8.640184': 'ERR1000017',
'1.SKD9.640182': 'ERR1000018',
'1.SKM1.640183': 'ERR1000019',
'1.SKM2.640199': 'ERR1000020',
'1.SKM3.640197': 'ERR1000021',
'1.SKM4.640180': 'ERR1000022',
'1.SKM5.640177': 'ERR1000023',
'1.SKM6.640187': 'ERR1000024',
'1.SKM7.640188': 'ERR1000025',
'1.SKM8.640201': 'ERR1000026',
'1.SKM9.640192': 'ERR1000027'}
with self.assertRaises(QiitaDBError):
PreprocessedData(1).ebi_run_accessions = new_vals
ppd = PreprocessedData(2)
self.assertEqual(ppd.ebi_run_accessions, [])
ppd.ebi_run_accessions = new_vals
self.assertEqual(ppd.ebi_run_accessions, sorted(new_vals.values()))
