def test_create_nonqiita_portal(self):
qiita_config.portal = "EMP"
Study.create(User("*****@*****.**"), "NEW!", [1], self.info, Investigation(1))
# make sure portal is associated
obs = self.conn_handler.execute_fetchall("SELECT * from qiita.study_portal WHERE study_id = 2")
self.assertEqual(obs, [[2, 2], [2, 1]])
def test_build_study_info_empty_study(self):
info = {
'timeseries_type_id': 1,
'lab_person_id': None,
'principal_investigator_id': 3,
'metadata_complete': False,
'mixs_compliant': True,
'study_description': 'desc',
'study_alias': 'alias',
'study_abstract': 'abstract'}
Study.create(User('*****@*****.**'), "My study", efo=[1], info=info)
obs = _build_study_info(User('*****@*****.**'), 'user')
self.exp.append({
'metadata_complete': False,
'ebi_submission_status':
'not submitted',
'shared': [],
'publication_pid': [],
'pi': ('*****@*****.**', 'PIDude'),
'status': 'sandbox',
'proc_data_info': [],
'publication_doi': [],
'study_abstract': 'abstract',
'study_id': 2,
'ebi_study_accession': None,
'study_title': 'My study',
'number_samples_collected': 0})
self.assertItemsEqual(obs, self.exp)
# Now testing that admin also sees this study
obs = _build_study_info(User('*****@*****.**'), 'user')
self.assertEqual(obs, self.exp)
def test_build_study_info_empty_study(self):
info = {
'timeseries_type_id': 1,
'lab_person_id': None,
'principal_investigator_id': 3,
'metadata_complete': False,
'mixs_compliant': True,
'study_description': 'desc',
'study_alias': 'alias',
'study_abstract': 'abstract'
}
Study.create(User('*****@*****.**'), "My study", efo=[1], info=info)
obs = _build_study_info(User('*****@*****.**'), 'user')
self.exp.append({
'metadata_complete': False,
'ebi_submission_status': 'not submitted',
'shared': [],
'pmid': [],
'pi': ('*****@*****.**', 'PIDude'),
'status': 'private',
'proc_data_info': [],
'publication_doi': [],
'study_abstract': 'abstract',
'study_id': 2,
'ebi_study_accession': None,
'study_title': 'My study',
'number_samples_collected': 0
})
self.assertItemsEqual(obs, self.exp)
def test_build_study_info_new_study(self):
info = {
'timeseries_type_id': 1,
'lab_person_id': None,
'principal_investigator_id': 3,
'metadata_complete': False,
'mixs_compliant': True,
'study_description': 'desc',
'study_alias': 'alias',
'study_abstract': 'abstract'
}
user = User('*****@*****.**')
Study.create(user, 'test_study_1', efo=[1], info=info)
obs = _build_study_info(user)
self.exp.append({
'study_id': 2,
'status': 'sandbox',
'study_abstract': 'abstract',
'metadata_complete': False,
'study_title': 'test_study_1',
'num_raw_data': 0,
'number_samples_collected': 0,
'shared': '',
'pmid': '',
'publication_doi': '',
'pi':
'<a target="_blank" href="mailto:[email protected]">PIDude</a>',
'proc_data_info': []
})
self.assertEqual(obs, self.exp)
def test_get_accessible_filepath_ids(self):
self._set_processed_data_private()
# shared has access to all study files and analysis files
obs = get_accessible_filepath_ids(User('*****@*****.**'))
self.assertEqual(obs, set([1, 2, 5, 6, 7, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20]))
# Now shared should not have access to the study files
self._unshare_studies()
obs = get_accessible_filepath_ids(User('*****@*****.**'))
self.assertEqual(obs, set([12, 13, 14, 15]))
# Now shared should not have access to any files
self._unshare_analyses()
obs = get_accessible_filepath_ids(User('*****@*****.**'))
self.assertEqual(obs, set())
# Now shared has access to public study files
self._set_processed_data_public()
obs = get_accessible_filepath_ids(User('*****@*****.**'))
self.assertEqual(obs, set([1, 2, 5, 6, 7, 11, 16, 19, 20]))
# Test that it doesn't break: if the SampleTemplate hasn't been added
exp = set([1, 2, 5, 6, 7, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])
obs = get_accessible_filepath_ids(User('*****@*****.**'))
self.assertEqual(obs, exp)
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"number_samples_collected": 4,
"number_samples_promised": 4,
"portal_type_id": 3,
"study_alias": "TestStudy",
"study_description": "Description of a test study",
"study_abstract": "No abstract right now...",
"emp_person_id": 1,
"principal_investigator_id": 1,
"lab_person_id": 1
}
Study.create(User('*****@*****.**'), "Test study", [1], info)
obs = get_accessible_filepath_ids(User('*****@*****.**'))
self.assertEqual(obs, exp)
# test in case there is a prep template that failed
self.conn_handler.execute(
"INSERT INTO qiita.prep_template (data_type_id, raw_data_id) "
"VALUES (2,1)")
obs = get_accessible_filepath_ids(User('*****@*****.**'))
self.assertEqual(obs, exp)
# admin should have access to everything
count = self.conn_handler.execute_fetchone("SELECT count(*) FROM "
"qiita.filepath")[0]
exp = set(range(1, count + 1))
obs = get_accessible_filepath_ids(User('*****@*****.**'))
self.assertEqual(obs, exp)
def test_build_study_info_new_study(self):
ProcessedData(1).status = 'public'
info = {
'timeseries_type_id': 1,
'portal_type_id': 1,
'lab_person_id': None,
'principal_investigator_id': 3,
'metadata_complete': False,
'mixs_compliant': True,
'study_description': 'desc',
'study_alias': 'alias',
'study_abstract': 'abstract'}
user = User('*****@*****.**')
Study.create(user, 'test_study_1', efo=[1], info=info)
obs = _build_study_info(user)
self.exp.append({
'status': 'sandbox',
'checkbox': "<input type='checkbox' value='2' />",
'abstract': 'abstract',
'meta_complete': "<span class='glyphicon glyphicon-remove'>"
"</span>",
'title': '<a href=\'#\' data-toggle=\'modal\' data-target=\'#study'
'-abstract-modal\' onclick=\'fillAbstract("studies-table"'
', 1)\'><span class=\'glyphicon glyphicon-file\' aria-hidden=\''
'true\'></span></a> | <a href=\'/study/description/2\' id=\''
'study1-title\'>test_study_1</a>',
'num_raw_data': 0, 'id': 2, 'num_samples': '0',
'shared': "<span id='shared_html_2'></span><br/><a class='btn "
"btn-primary btn-xs' data-toggle='modal' data-target='#share-study"
"-modal-view' onclick='modify_sharing(2);'>Modify</a>",
'pmid': '', 'pi':
'<a target="_blank" href="mailto:[email protected]">PIDude</a>'})
self.assertEqual(obs, self.exp)
def test_build_study_info_new_study(self):
info = {
'timeseries_type_id': 1,
'lab_person_id': None,
'principal_investigator_id': 3,
'metadata_complete': False,
'mixs_compliant': True,
'study_description': 'desc',
'study_alias': 'alias',
'study_abstract': 'abstract'}
user = User('*****@*****.**')
Study.create(user, 'test_study_1', efo=[1], info=info)
obs = _build_study_info(user)
self.exp.append({
'study_id': 2,
'status': 'sandbox',
'study_abstract': 'abstract',
'metadata_complete': False,
'study_title': 'test_study_1',
'num_raw_data': 0,
'number_samples_collected': 0,
'shared': '',
'pmid': '',
'publication_doi': '',
'pi':
'<a target="_blank" href="mailto:[email protected]">PIDude</a>',
'proc_data_info': []})
self.assertEqual(obs, self.exp)
def setUp(self):
fd, self.seqs_fp = mkstemp(suffix='_seqs.fastq')
close(fd)
fd, self.barcodes_fp = mkstemp(suffix='_barcodes.fastq')
close(fd)
self.filetype = 2
self.filepaths = [(self.seqs_fp, 1), (self.barcodes_fp, 2)]
self.studies = [Study(1)]
_, self.db_test_raw_dir = get_mountpoint('raw_data')[0]
with open(self.seqs_fp, "w") as f:
f.write("\n")
with open(self.barcodes_fp, "w") as f:
f.write("\n")
self._clean_up_files = []
# Create a new study
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"number_samples_collected": 25,
"number_samples_promised": 28,
"portal_type_id": 3,
"study_alias": "FCM",
"study_description": "Microbiome of people who eat nothing but "
"fried chicken",
"study_abstract": "Exploring how a high fat diet changes the "
"gut microbiome",
"emp_person_id": StudyPerson(2),
"principal_investigator_id": StudyPerson(3),
"lab_person_id": StudyPerson(1)
}
Study.create(User("*****@*****.**"), "Test study 2", [1], info)
def test_build_study_info_new_study(self):
info = {
'timeseries_type_id': 1,
'portal_type_id': 1,
'lab_person_id': None,
'principal_investigator_id': 3,
'metadata_complete': False,
'mixs_compliant': True,
'study_description': 'desc',
'study_alias': 'alias',
'study_abstract': 'abstract'}
user = User('*****@*****.**')
Study.create(user, 'test_study_1', efo=[1], info=info)
obs = _build_study_info('private', user)
StudyTuple = namedtuple('StudyInfo', 'id title meta_complete '
'num_samples_collected shared num_raw_data pi '
'pmids owner status')
exp = [
StudyTuple(
id=2,
title='test_study_1',
meta_complete=False, num_samples_collected=None,
shared='',
num_raw_data=0,
pi='<a target="_blank" href="mailto:[email protected]">'
'PIDude</a>',
pmids='',
owner='<a target="_blank" href="mailto:[email protected]">'
'[email protected]</a>',
status='sandbox')]
self.assertEqual(obs, exp)
def setUp(self):
fd, self.seqs_fp = mkstemp(suffix='_seqs.fastq')
close(fd)
fd, self.barcodes_fp = mkstemp(suffix='_barcodes.fastq')
close(fd)
self.filetype = 2
self.filepaths = [(self.seqs_fp, 1), (self.barcodes_fp, 2)]
self.studies = [Study(1)]
_, self.db_test_raw_dir = get_mountpoint('raw_data')[0]
with open(self.seqs_fp, "w") as f:
f.write("\n")
with open(self.barcodes_fp, "w") as f:
f.write("\n")
self._clean_up_files = []
# Create a new study
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"number_samples_collected": 25,
"number_samples_promised": 28,
"portal_type_id": 3,
"study_alias": "FCM",
"study_description": "Microbiome of people who eat nothing but "
"fried chicken",
"study_abstract": "Exploring how a high fat diet changes the "
"gut microbiome",
"emp_person_id": StudyPerson(2),
"principal_investigator_id": StudyPerson(3),
"lab_person_id": StudyPerson(1)
}
Study.create(User("*****@*****.**"), "Test study 2", [1], info)
def test_remove_portal(self):
Portal.create("NEWPORTAL", "SOMEDESC")
# Select some samples on a default analysis
qiita_config.portal = "NEWPORTAL"
a = Analysis(User("*****@*****.**").default_analysis)
a.add_samples({1: ['1.SKB8.640193', '1.SKD5.640186']})
Portal.delete("NEWPORTAL")
obs = self.conn_handler.execute_fetchall(
"SELECT * FROM qiita.portal_type")
exp = [[1, 'QIITA', 'QIITA portal. Access to all data stored '
'in database.'],
[2, 'EMP', 'EMP portal']]
self.assertItemsEqual(obs, exp)
obs = self.conn_handler.execute_fetchall(
"SELECT * FROM qiita.analysis_portal")
exp = [[1, 1], [2, 1], [3, 1], [4, 1], [5, 1], [6, 1], [7, 2], [8, 2],
[9, 2], [10, 2]]
self.assertItemsEqual(obs, exp)
with self.assertRaises(QiitaDBLookupError):
Portal.delete("NOEXISTPORTAL")
with self.assertRaises(QiitaDBError):
Portal.delete("QIITA")
Portal.create("NEWPORTAL2", "SOMEDESC")
# Add analysis to this new portal and make sure error raised
qiita_config.portal = "NEWPORTAL2"
Analysis.create(User("*****@*****.**"), "newportal analysis", "desc")
qiita_config.portal = "QIITA"
with self.assertRaises(QiitaDBError):
Portal.delete("NEWPORTAL2")
# Add study to this new portal and make sure error raised
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"number_samples_collected": 25,
"number_samples_promised": 28,
"study_alias": "FCM",
"study_description": "Microbiome of people who eat nothing but "
"fried chicken",
"study_abstract": "Exploring how a high fat diet changes the "
"gut microbiome",
"emp_person_id": StudyPerson(2),
"principal_investigator_id": StudyPerson(3),
"lab_person_id": StudyPerson(1)
}
Portal.create("NEWPORTAL3", "SOMEDESC")
qiita_config.portal = "NEWPORTAL3"
Study.create(User('*****@*****.**'), "Fried chicken microbiome",
[1], info)
qiita_config.portal = "QIITA"
with self.assertRaises(QiitaDBError):
Portal.delete("NEWPORTAL3")
def test_get_accessible_filepath_ids(self):
self._set_studies_private()
# shared has access to all study files and analysis files
obs = get_accessible_filepath_ids(User('*****@*****.**'))
self.assertEqual(obs,
set([1, 2, 5, 6, 7, 11, 12, 13, 14, 15, 16, 17, 18]))
# Now shared should not have access to the study files
self._unshare_studies()
obs = get_accessible_filepath_ids(User('*****@*****.**'))
self.assertEqual(obs, set([12, 13, 14, 15]))
# Now shared should not have access to any files
self._unshare_analyses()
obs = get_accessible_filepath_ids(User('*****@*****.**'))
self.assertEqual(obs, set())
# Test that it doesn't break: if the SampleTemplate hasn't been added
exp = set([1, 2, 5, 6, 7, 11, 12, 13, 14, 15, 16, 17, 18])
obs = get_accessible_filepath_ids(User('*****@*****.**'))
self.assertEqual(obs, exp)
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"number_samples_collected": 4,
"number_samples_promised": 4,
"portal_type_id": 3,
"study_alias": "TestStudy",
"study_description": "Description of a test study",
"study_abstract": "No abstract right now...",
"emp_person_id": 1,
"principal_investigator_id": 1,
"lab_person_id": 1
}
Study.create(User('*****@*****.**'), "Test study", [1], info)
obs = get_accessible_filepath_ids(User('*****@*****.**'))
self.assertEqual(obs, exp)
# test in case there is a prep template that failed
self.conn_handler.execute(
"INSERT INTO qiita.prep_template (data_type_id, raw_data_id) "
"VALUES (2,1)")
obs = get_accessible_filepath_ids(User('*****@*****.**'))
self.assertEqual(obs, exp)
# admin should have access to everything
count = self.conn_handler.execute_fetchone("SELECT count(*) FROM "
"qiita.filepath")[0]
exp = set(range(1, count + 1))
obs = get_accessible_filepath_ids(User('*****@*****.**'))
self.assertEqual(obs, exp)
def test_get_no_samples(self):
# /api/v1/study/%d/samples/info -> {'number-of-samples':<int>,
# 'categories': [<str>]}
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"number_samples_collected": 25,
"number_samples_promised": 28,
"study_alias": "FCM",
"study_description": "DESC",
"study_abstract": "ABS",
"principal_investigator_id": StudyPerson(3),
'first_contact': datetime(2015, 5, 19, 16, 10),
'most_recent_contact': datetime(2015, 5, 19, 16, 11),
}
new_study = Study.create(User('*****@*****.**'),
"Some New Study for test", info)
exp = {'message': 'Study does not have sample information'}
response = self.get('/api/v1/study/%d/samples/categories=foo' %
new_study.id,
headers=self.headers)
self.assertEqual(response.code, 404)
obs = json_decode(response.body)
self.assertEqual(obs, exp)
def test_create_sample_template(self):
# Test error
job = self._create_job('create_sample_template', {
'fp': self.fp, 'study_id': 1, 'is_mapping_file': False,
'data_type': None})
private_task(job.id)
self.assertEqual(job.status, 'error')
self.assertIn("The 'SampleTemplate' object with attributes (id: 1) "
"already exists.", job.log.msg)
# Test success with a warning
info = {"timeseries_type_id": '1',
"metadata_complete": 'true',
"mixs_compliant": 'true',
"study_alias": "TDST",
"study_description": "Test create sample template",
"study_abstract": "Test create sample template",
"principal_investigator_id": StudyPerson(1)}
study = Study.create(User('*****@*****.**'),
"Create Sample Template test", info)
job = self._create_job('create_sample_template',
{'fp': self.fp, 'study_id': study.id,
'is_mapping_file': False, 'data_type': None})
private_task(job.id)
self.assertEqual(job.status, 'success')
obs = r_client.get("sample_template_%d" % study.id)
self.assertIsNotNone(obs)
obs = loads(obs)
self.assertCountEqual(obs, ['job_id', 'alert_type', 'alert_msg'])
self.assertEqual(obs['job_id'], job.id)
self.assertEqual(obs['alert_type'], 'warning')
self.assertIn(
'Some functionality will be disabled due to missing columns:',
obs['alert_msg'])
def test_get_no_samples(self):
# /api/v1/study/%d/samples/info -> {'number-of-samples':<int>,
# 'categories': [<str>]}
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"number_samples_collected": 25,
"number_samples_promised": 28,
"study_alias": "FCM",
"study_description": "DESC",
"study_abstract": "ABS",
"principal_investigator_id": StudyPerson(3),
'first_contact': datetime(2015, 5, 19, 16, 10),
'most_recent_contact': datetime(2015, 5, 19, 16, 11),
}
new_study = Study.create(User('*****@*****.**'),
"Some New Study for test", info)
exp = {'message': 'Study does not have sample information'}
response = self.get('/api/v1/study/%d/samples/categories=foo' %
new_study.id, headers=self.headers)
self.assertEqual(response.code, 404)
obs = json_decode(response.body)
self.assertEqual(obs, exp)
def test_patch_no_sample_template(self):
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"number_samples_collected": 25,
"number_samples_promised": 28,
"study_alias": "FCM",
"study_description": "DESC",
"study_abstract": "ABS",
"principal_investigator_id": StudyPerson(3),
'first_contact': datetime(2015, 5, 19, 16, 10),
'most_recent_contact': datetime(2015, 5, 19, 16, 11),
}
new_study = Study.create(User('*****@*****.**'),
"Some New Study for test jr", info)
body = {
'sampleid1': {
'category_a': 'value_a'
},
'sampleid2': {
'category_b': 'value_b'
}
}
exp = {'message': 'No sample information found'}
response = self.patch('/api/v1/study/%d/samples' % new_study.id,
headers=self.headers,
data=body,
asjson=True)
self.assertEqual(response.code, 404)
obs = json_decode(response.body)
self.assertEqual(obs, exp)
def test_set_info_disallowed_keys(self):
"""Tests for fail if sending non-info keys in info dict"""
new = Study.create(
User("*****@*****.**"), "NOT Identification of the " "Microbiomes for Cannabis Soils", [1], self.info
)
with self.assertRaises(QiitaDBColumnError):
new.info = {"email": "*****@*****.**"}
def test_set_efo_empty(self):
"""Set efo with list efo_id"""
new = Study.create(
User("*****@*****.**"), "NOT Identification of the " "Microbiomes for Cannabis Soils", [1], self.info
)
with self.assertRaises(IncompetentQiitaDeveloperError):
new.efo = []
def test_set_efo(self):
"""Set efo with list efo_id"""
new = Study.create(
User("*****@*****.**"), "NOT Identification of the " "Microbiomes for Cannabis Soils", [1], self.info
)
new.efo = [3, 4]
self.assertEqual(new.efo, [3, 4])
def test_create_study_with_investigation(self):
"""Insert a study into the database with an investigation"""
obs = Study.create(User("*****@*****.**"), "Fried chicken microbiome", [1], self.info, Investigation(1))
self.assertEqual(obs.id, 2)
# check the investigation was assigned
obs = self.conn_handler.execute_fetchall("SELECT * from qiita.investigation_study WHERE study_id = 2")
self.assertEqual(obs, [[1, 2]])
def _create_study(self, study_title):
"""Creates a new study
Parameters
----------
study_title: str
The title of the new study
Returns
-------
qiita_db.study.Study
The newly created study
"""
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"number_samples_collected": 25,
"number_samples_promised": 28,
"study_alias": "ALIAS",
"study_description": "DESC",
"study_abstract": "ABS",
"principal_investigator_id": StudyPerson(3),
"lab_person_id": StudyPerson(1)
}
return Study.create(User('*****@*****.**'), study_title, info)
def test_set_efo(self):
"""Set efo with list efo_id"""
new = Study.create(
User('*****@*****.**'), 'NOT Identification of the '
'Microbiomes for Cannabis Soils', [1], self.info)
new.efo = [3, 4]
self.assertEqual(new.efo, [3, 4])
def test_add_raw_data_private(self):
new = Study.create(
User('*****@*****.**'), 'NOT Identification of the '
'Microbiomes for Cannabis Soils', [1], self.info)
new.status = 'private'
with self.assertRaises(QiitaDBStatusError):
new.add_raw_data([RawData(2)])
def test_set_info_disallowed_keys(self):
"""Tests for fail if sending non-info keys in info dict"""
new = Study.create(
User('*****@*****.**'), 'NOT Identification of the '
'Microbiomes for Cannabis Soils', [1], self.info)
with self.assertRaises(QiitaDBColumnError):
new.info = {"email": "*****@*****.**"}
def test_status_error(self):
# Let's create a new study, so we can check that the error is raised
# because the new study does not have access to the raw data
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"number_samples_collected": 25,
"number_samples_promised": 28,
"portal_type_id": 3,
"study_alias": "FCM",
"study_description": "Microbiome of people who eat nothing but "
"fried chicken",
"study_abstract": "Exploring how a high fat diet changes the "
"gut microbiome",
"emp_person_id": StudyPerson(2),
"principal_investigator_id": StudyPerson(3),
"lab_person_id": StudyPerson(1)
}
s = Study.create(User('*****@*****.**'), "Fried chicken microbiome",
[1], info)
rd = RawData(1)
with self.assertRaises(QiitaDBStatusError):
rd.status(s)
def test_patch_no_sample_template(self):
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"study_alias": "FCM",
"study_description": "DESC",
"study_abstract": "ABS",
"principal_investigator_id": StudyPerson(3),
'first_contact': datetime(2015, 5, 19, 16, 10),
'most_recent_contact': datetime(2015, 5, 19, 16, 11),
}
new_study = Study.create(User('*****@*****.**'),
"Some New Study for test jr", info)
body = {'sampleid1': {'category_a': 'value_a'},
'sampleid2': {'category_b': 'value_b'}}
exp = {'message': 'No sample information found'}
response = self.patch('/api/v1/study/%d/samples' % new_study.id,
headers=self.headers, data=body, asjson=True)
self.assertEqual(response.code, 404)
obs = json_decode(response.body)
self.assertEqual(obs, exp)
def setUp(self):
# Create a directory with the test split libraries output
self.test_slo = mkdtemp(prefix='test_slo_')
path_builder = partial(join, self.test_slo)
fna_fp = path_builder('seqs.fna')
fastq_fp = path_builder('seqs.fastq')
log_fp = path_builder('split_library_log.txt')
demux_fp = path_builder('seqs.demux')
with open(fna_fp, 'w') as f:
f.write(FASTA_SEQS)
with open(fastq_fp, 'w') as f:
f.write(FASTQ_SEQS)
with open(log_fp, 'w') as f:
f.write("Test log\n")
generate_demux_file(self.test_slo)
self._filepaths_to_remove = [fna_fp, fastq_fp, demux_fp, log_fp]
self._dirpaths_to_remove = [self.test_slo]
# Generate a directory with test split libraries output missing files
self.missing_slo = mkdtemp(prefix='test_missing_')
path_builder = partial(join, self.test_slo)
fna_fp = path_builder('seqs.fna')
fastq_fp = path_builder('seqs.fastq')
with open(fna_fp, 'w') as f:
f.write(FASTA_SEQS)
with open(fastq_fp, 'w') as f:
f.write(FASTQ_SEQS)
self._filepaths_to_remove.append(fna_fp)
self._filepaths_to_remove.append(fastq_fp)
self._dirpaths_to_remove.append(self.missing_slo)
# Create a study with no preprocessed data
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"number_samples_collected": 25,
"number_samples_promised": 28,
"study_alias": "FCM",
"study_description": "Microbiome of people who eat nothing but "
"fried chicken",
"study_abstract": "Exploring how a high fat diet changes the "
"gut microbiome",
"emp_person_id": StudyPerson(2),
"principal_investigator_id": StudyPerson(3),
"lab_person_id": StudyPerson(1)
}
self.no_ppd_study = Study.create(
User('*****@*****.**'), "Test study", [1], info)
# Get the directory where the preprocessed data is usually copied.
_, self.db_ppd_dir = get_mountpoint('preprocessed_data')[0]
def _create_study(self, study_title):
"""Creates a new study
Parameters
----------
study_title: str
The title of the new study
Returns
-------
qiita_db.study.Study
The newly created study
"""
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"number_samples_collected": 25,
"number_samples_promised": 28,
"study_alias": "ALIAS",
"study_description": "DESC",
"study_abstract": "ABS",
"principal_investigator_id": StudyPerson(3),
"lab_person_id": StudyPerson(1)
}
return Study.create(User('*****@*****.**'), study_title, info)
def test_create_study_min_data(self):
"""Insert a study into the database"""
obs = Study.create(User('*****@*****.**'), "Fried chicken microbiome",
[1], self.info)
self.assertEqual(obs.id, 2)
exp = {'mixs_compliant': True, 'metadata_complete': True,
'reprocess': False, 'study_status_id': 1,
'number_samples_promised': 28, 'emp_person_id': 2,
'funding': None, 'vamps_id': None,
'first_contact': date.today().isoformat(),
'principal_investigator_id': 3,
'timeseries_type_id': 1,
'study_abstract': 'Exploring how a high fat diet changes the '
'gut microbiome',
'email': '*****@*****.**', 'spatial_series': None,
'study_description': 'Microbiome of people who eat nothing but'
' fried chicken',
'portal_type_id': 3, 'study_alias': 'FCM', 'study_id': 2,
'most_recent_contact': None, 'lab_person_id': 1,
'study_title': 'Fried chicken microbiome',
'number_samples_collected': 25}
obsins = self.conn_handler.execute_fetchall(
"SELECT * FROM qiita.study WHERE study_id = 2")
self.assertEqual(len(obsins), 1)
obsins = dict(obsins[0])
self.assertEqual(obsins, exp)
# make sure EFO went in to table correctly
efo = self.conn_handler.execute_fetchall(
"SELECT efo_id FROM qiita.study_experimental_factor "
"WHERE study_id = 2")
self.assertEqual(efo, [[1]])
def test_delete_study_empty_study(self):
info = {
"timeseries_type_id": '1',
"metadata_complete": 'true',
"mixs_compliant": 'true',
"number_samples_collected": 25,
"number_samples_promised": 28,
"study_alias": "FCM",
"study_description": "Microbiome of people who eat nothing but "
"fried chicken",
"study_abstract": "Exploring how a high fat diet changes the "
"gut microbiome",
"emp_person_id": StudyPerson(2),
"principal_investigator_id": StudyPerson(3),
"lab_person_id": StudyPerson(1)
}
new_study = Study.create(User('*****@*****.**'),
"Fried Chicken Microbiome %s" % time(), info)
job = self._create_job('delete_study', {'study': new_study.id})
private_task(job.id)
self.assertEqual(job.status, 'success')
# making sure the study doesn't exist
with self.assertRaises(QiitaDBUnknownIDError):
Study(new_study.id)
def test_set_efo_empty(self):
"""Set efo with list efo_id"""
new = Study.create(
User('*****@*****.**'), 'NOT Identification of the '
'Microbiomes for Cannabis Soils', [1], self.info)
with self.assertRaises(IncompetentQiitaDeveloperError):
new.efo = []
def test_get_by_status(self):
obs = Study.get_by_status('sandbox')
self.assertEqual(obs, set())
Study.create(User('*****@*****.**'), 'NOT Identification of the '
'Microbiomes for Cannabis Soils', [1], self.info)
obs = Study.get_by_status('private')
self.assertEqual(obs, {1})
obs = Study.get_by_status('sandbox')
self.assertEqual(obs, {2})
obs = Study.get_by_status('public')
self.assertEqual(obs, set())
obs = Study.get_by_status('awaiting_approval')
self.assertEqual(obs, set())
def test_add_raw_data(self):
self._make_sandbox()
new = Study.create(User('*****@*****.**'), 'NOT Identification of the '
'Microbiomes for Cannabis Soils', [1], self.info)
new.add_raw_data([RawData(1), RawData(2)])
obs = self.conn_handler.execute_fetchall(
"SELECT * FROM qiita.study_raw_data WHERE study_id=%s",
(new.id,))
self.assertEqual(obs, [[new.id, 1], [new.id, 2]])
def test_create_study_with_investigation(self):
"""Insert a study into the database with an investigation"""
obs = Study.create(User('*****@*****.**'), "Fried chicken microbiome",
[1], self.info, Investigation(1))
self.assertEqual(obs.id, 2)
# check the investigation was assigned
obs = self.conn_handler.execute_fetchall(
"SELECT * from qiita.investigation_study WHERE study_id = 2")
self.assertEqual(obs, [[1, 2]])
def test_ebi_study_accession_setter(self):
new = Study.create(User('*****@*****.**'), 'Test', [1], self.info)
self.assertEqual(new.ebi_study_accession, None)
new.ebi_study_accession = 'EBI654321-BB'
self.assertEqual(new.ebi_study_accession, 'EBI654321-BB')
# Raises an error if the study already has an EBI study accession
with self.assertRaises(QiitaDBError):
self.study.ebi_study_accession = 'EBI654321-BB'
def test_add_raw_data(self):
self._make_sandbox()
new = Study.create(
User('*****@*****.**'), 'NOT Identification of the '
'Microbiomes for Cannabis Soils', [1], self.info)
new.add_raw_data([RawData(1), RawData(2)])
obs = self.conn_handler.execute_fetchall(
"SELECT * FROM qiita.study_raw_data WHERE study_id=%s", (new.id, ))
self.assertEqual(obs, [[new.id, 1], [new.id, 2]])
def test_get_by_status(self):
obs = Study.get_by_status("sandbox")
self.assertEqual(obs, set())
Study.create(
User("*****@*****.**"), "NOT Identification of the " "Microbiomes for Cannabis Soils", [1], self.info
)
obs = Study.get_by_status("private")
self.assertEqual(obs, {1})
obs = Study.get_by_status("sandbox")
self.assertEqual(obs, {2})
obs = Study.get_by_status("public")
self.assertEqual(obs, set())
obs = Study.get_by_status("awaiting_approval")
self.assertEqual(obs, set())
def test_delete(self):
title = "Fried chicken microbiome"
study = Study.create(User('*****@*****.**'), title, [1], self.info)
study.delete(study.id)
self.assertFalse(study.exists(title))
with self.assertRaises(QiitaDBError):
Study.delete(1)
with self.assertRaises(QiitaDBUnknownIDError):
Study.delete(41)
def test_environmental_packages_setter(self):
new = Study.create(User('*****@*****.**'), 'NOT Identification of the '
'Microbiomes for Cannabis Soils', [1], self.info)
obs = new.environmental_packages
exp = []
self.assertEqual(obs, exp)
new_values = ['air', 'human-oral']
new.environmental_packages = new_values
obs = new.environmental_packages
self.assertEqual(sorted(obs), sorted(new_values))
def test_environmental_packages_setter(self):
new = Study.create(
User("*****@*****.**"), "NOT Identification of the " "Microbiomes for Cannabis Soils", [1], self.info
)
obs = new.environmental_packages
exp = []
self.assertEqual(obs, exp)
new_values = ["air", "human-oral"]
new.environmental_packages = new_values
obs = new.environmental_packages
self.assertEqual(sorted(obs), sorted(new_values))
def test_environmental_packages_setter(self):
new = Study.create(
User('*****@*****.**'), 'NOT Identification of the '
'Microbiomes for Cannabis Soils', [1], self.info)
obs = new.environmental_packages
exp = []
self.assertEqual(obs, exp)
new_values = ['air', 'human-oral']
new.environmental_packages = new_values
obs = new.environmental_packages
self.assertEqual(sorted(obs), sorted(new_values))
def test_ebi_submission_status_setter(self):
new = Study.create(User('*****@*****.**'), 'Test', [1], self.info)
self.assertEqual(new.ebi_submission_status, "not submitted")
new.ebi_submission_status = 'submitting'
self.assertEqual(new.ebi_submission_status, 'submitting')
new.ebi_submission_status = 'failed: something horrible happened'
self.assertEqual(new.ebi_submission_status,
'failed: something horrible happened')
new.ebi_submission_status = 'submitted'
self.assertEqual(new.ebi_submission_status, 'submitted')
with self.assertRaises(ValueError):
new.ebi_submission_status = "unknown"
def test_create_study_all_data(self):
"""Insert a study into the database with every info field"""
self.info.update({
'vamps_id': 'MBE_1111111',
'funding': 'FundAgency',
'spatial_series': True,
'metadata_complete': False,
'reprocess': True,
'first_contact': "10/24/2014 12:47PM",
'study_id': 3827
})
obs = Study.create(User('*****@*****.**'), "Fried chicken microbiome",
[1], self.info)
self.assertEqual(obs.id, 3827)
exp = {
'mixs_compliant': True,
'metadata_complete': False,
'reprocess': True,
'study_status_id': 4,
'number_samples_promised': 28,
'emp_person_id': 2,
'funding': 'FundAgency',
'vamps_id': 'MBE_1111111',
'first_contact': datetime(2014, 10, 24, 12, 47),
'principal_investigator_id': 3,
'timeseries_type_id': 1,
'study_abstract': 'Exploring how a high fat diet changes the '
'gut microbiome',
'email': '*****@*****.**',
'spatial_series': True,
'study_description': 'Microbiome of people who eat nothing '
'but fried chicken',
'portal_type_id': 3,
'study_alias': 'FCM',
'study_id': 3827,
'most_recent_contact': None,
'lab_person_id': 1,
'study_title': 'Fried chicken microbiome',
'number_samples_collected': 25
}
obsins = self.conn_handler.execute_fetchall(
"SELECT * FROM qiita.study WHERE study_id = 3827")
self.assertEqual(len(obsins), 1)
obsins = dict(obsins[0])
self.assertEqual(obsins, exp)
# make sure EFO went in to table correctly
obsefo = self.conn_handler.execute_fetchall(
"SELECT efo_id FROM qiita.study_experimental_factor "
"WHERE study_id = 3827")
self.assertEqual(obsefo, [[1]])
def test_create_study_min_data(self):
"""Insert a study into the database"""
before = datetime.now()
obs = Study.create(User('*****@*****.**'), "Fried chicken microbiome",
[1], self.info)
after = datetime.now()
self.assertEqual(obs.id, 2)
exp = {
'mixs_compliant': True,
'metadata_complete': True,
'reprocess': False,
'study_status_id': 4,
'number_samples_promised': 28,
'emp_person_id': 2,
'funding': None,
'vamps_id': None,
'principal_investigator_id': 3,
'timeseries_type_id': 1,
'study_abstract': 'Exploring how a high fat diet changes the '
'gut microbiome',
'email': '*****@*****.**',
'spatial_series': None,
'study_description': 'Microbiome of people who eat nothing but'
' fried chicken',
'portal_type_id': 3,
'study_alias': 'FCM',
'study_id': 2,
'most_recent_contact': None,
'lab_person_id': 1,
'study_title': 'Fried chicken microbiome',
'number_samples_collected': 25
}
obsins = self.conn_handler.execute_fetchall(
"SELECT * FROM qiita.study WHERE study_id = 2")
self.assertEqual(len(obsins), 1)
obsins = dict(obsins[0])
# Check the timestamp separately, since it is set by the database
# to the microsecond, and we can't predict it a priori
ins_timestamp = obsins.pop('first_contact')
self.assertTrue(before < ins_timestamp < after)
self.assertEqual(obsins, exp)
# make sure EFO went in to table correctly
efo = self.conn_handler.execute_fetchall(
"SELECT efo_id FROM qiita.study_experimental_factor "
"WHERE study_id = 2")
self.assertEqual(efo, [[1]])
def test_delete(self):
title = "Fried chicken microbiome"
# the study is assigned to investigation 1
study = Study.create(User("*****@*****.**"), title, [1], self.info, Investigation(1))
# sharing with other user
study.share(User("*****@*****.**"))
study.delete(study.id)
self.assertFalse(study.exists(title))
with self.assertRaises(QiitaDBError):
Study.delete(1)
with self.assertRaises(QiitaDBUnknownIDError):
Study.delete(41)
def test_build_study_info_new_study(self):
info = {
'timeseries_type_id': 1,
'portal_type_id': 1,
'lab_person_id': None,
'principal_investigator_id': 3,
'metadata_complete': False,
'mixs_compliant': True,
'study_description': 'desc',
'study_alias': 'alias',
'study_abstract': 'abstract'
}
user = User('*****@*****.**')
Study.create(user, 'test_study_1', efo=[1], info=info)
obs = _build_study_info('private', user)
StudyTuple = namedtuple(
'StudyInfo', 'id title meta_complete '
'num_samples_collected shared num_raw_data pi '
'pmids owner status')
exp = [
StudyTuple(id=2,
title='test_study_1',
meta_complete=False,
num_samples_collected=None,
shared='',
num_raw_data=0,
pi='<a target="_blank" href="mailto:[email protected]">'
'PIDude</a>',
pmids='',
owner='<a target="_blank" href="mailto:[email protected]">'
'[email protected]</a>',
status='sandbox')
]
self.assertEqual(obs, exp)
def setUp(self):
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"study_alias": "FCM",
"study_description": "Microbiome of people who eat nothing but "
"fried chicken",
"study_abstract": "Exploring how a high fat diet changes the "
"gut microbiome",
"principal_investigator_id": StudyPerson(3),
"lab_person_id": StudyPerson(1)
}
self.new_study = Study.create(User('*****@*****.**'),
"Fried Chicken Microbiome", info)
self._clean_up_files = []
def setUp(self):
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"study_alias": "FCM",
"study_description": "Microbiome of people who eat nothing but "
"fried chicken",
"study_abstract": "Exploring how a high fat diet changes the "
"gut microbiome",
"principal_investigator_id": StudyPerson(3),
"lab_person_id": StudyPerson(1)
}
self.new_study = Study.create(
User('*****@*****.**'), "Fried Chicken Microbiome", info)
self._clean_up_files = []
def test_create_sample_template(self):
# Test error
job = self._create_job(
'create_sample_template', {
'fp': self.fp,
'study_id': 1,
'is_mapping_file': False,
'data_type': None
})
private_task(job.id)
self.assertEqual(job.status, 'error')
self.assertIn(
"The 'SampleTemplate' object with attributes (id: 1) "
"already exists.", job.log.msg)
# Test success with a warning
info = {
"timeseries_type_id": '1',
"metadata_complete": 'true',
"mixs_compliant": 'true',
"study_alias": "TDST",
"study_description": "Test create sample template",
"study_abstract": "Test create sample template",
"principal_investigator_id": StudyPerson(1)
}
study = Study.create(User('*****@*****.**'),
"Create Sample Template test", info)
job = self._create_job(
'create_sample_template', {
'fp': self.fp,
'study_id': study.id,
'is_mapping_file': False,
'data_type': None
})
private_task(job.id)
self.assertEqual(job.status, 'success')
obs = r_client.get("sample_template_%d" % study.id)
self.assertIsNotNone(obs)
obs = loads(obs)
self.assertCountEqual(obs, ['job_id', 'alert_type', 'alert_msg'])
self.assertEqual(obs['job_id'], job.id)
self.assertEqual(obs['alert_type'], 'warning')
self.assertIn(
'Some functionality will be disabled due to missing columns:',
obs['alert_msg'])
# making sure that the error name is not in the messages
self.assertNotIn('QiitaDBWarning', obs['alert_msg'])
def test_delete_sample_template(self):
# Error case
job = self._create_job('delete_sample_template', {'study': 1})
private_task(job.id)
self.assertEqual(job.status, 'error')
self.assertIn(
"Sample template cannot be erased because there are "
"prep templates associated", job.log.msg)
# Success case
info = {
"timeseries_type_id": '1',
"metadata_complete": 'true',
"mixs_compliant": 'true',
"number_samples_collected": 25,
"number_samples_promised": 28,
"study_alias": "TDST",
"study_description": "Test delete sample template",
"study_abstract": "Test delete sample template",
"principal_investigator_id": StudyPerson(1)
}
study = Study.create(User('*****@*****.**'),
"Delete Sample Template test", info)
metadata = pd.DataFrame.from_dict(
{
'Sample1': {
'physical_specimen_location': 'location1',
'physical_specimen_remaining': 'true',
'dna_extracted': 'true',
'sample_type': 'type1',
'collection_timestamp': '2014-05-29 12:24:15',
'host_subject_id': 'NotIdentified',
'Description': 'Test Sample 1',
'latitude': '42.42',
'longitude': '41.41',
'taxon_id': '9606',
'scientific_name': 'h**o sapiens'
}
},
orient='index',
dtype=str)
SampleTemplate.create(metadata, study)
job = self._create_job('delete_sample_template', {'study': study.id})
private_task(job.id)
self.assertEqual(job.status, 'success')
self.assertFalse(SampleTemplate.exists(study.id))
def test_create_study_all_data(self):
"""Insert a study into the database with every info field"""
self.info.update(
{
"vamps_id": "MBE_1111111",
"funding": "FundAgency",
"spatial_series": True,
"metadata_complete": False,
"reprocess": True,
"first_contact": "10/24/2014 12:47PM",
"study_id": 3827,
}
)
obs = Study.create(User("*****@*****.**"), "Fried chicken microbiome", [1], self.info)
self.assertEqual(obs.id, 3827)
exp = {
"mixs_compliant": True,
"metadata_complete": False,
"reprocess": True,
"number_samples_promised": 28,
"emp_person_id": 2,
"funding": "FundAgency",
"vamps_id": "MBE_1111111",
"first_contact": datetime(2014, 10, 24, 12, 47),
"principal_investigator_id": 3,
"timeseries_type_id": 1,
"study_abstract": "Exploring how a high fat diet changes the " "gut microbiome",
"email": "*****@*****.**",
"spatial_series": True,
"study_description": "Microbiome of people who eat nothing " "but fried chicken",
"study_alias": "FCM",
"study_id": 3827,
"most_recent_contact": None,
"lab_person_id": 1,
"study_title": "Fried chicken microbiome",
"number_samples_collected": 25,
}
obsins = self.conn_handler.execute_fetchall("SELECT * FROM qiita.study WHERE study_id = 3827")
self.assertEqual(len(obsins), 1)
obsins = dict(obsins[0])
self.assertEqual(obsins, exp)
# make sure EFO went in to table correctly
obsefo = self.conn_handler.execute_fetchall(
"SELECT efo_id FROM qiita.study_experimental_factor " "WHERE study_id = 3827"
)
self.assertEqual(obsefo, [[1]])
def setUp(self):
# Create a sample template file
self.st_contents = SAMPLE_TEMPLATE
# create a new study to attach the sample template
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"number_samples_collected": 4,
"number_samples_promised": 4,
"portal_type_id": 3,
"study_alias": "TestStudy",
"study_description": "Description of a test study",
"study_abstract": "No abstract right now...",
"emp_person_id": StudyPerson(2),
"principal_investigator_id": StudyPerson(3),
"lab_person_id": StudyPerson(1)
}
self.study = Study.create(User('*****@*****.**'),
"Test study", [1], info)
def test_get_no_access(self):
# Create a new study belonging to the 'shared' user, so 'test' doesn't
# have access
info = {
'timeseries_type_id': 1,
'lab_person_id': None,
'principal_investigator_id': 3,
'metadata_complete': False,
'mixs_compliant': True,
'study_description': 'desc',
'study_alias': 'alias',
'study_abstract': 'abstract'
}
u = User('*****@*****.**')
s = Study.create(u, 'test_study', efo=[1], info=info)
self.assertEqual(s.shared_with, [])
args = {'selected': '*****@*****.**', 'id': s.id}
response = self.get('/study/sharing/', args)
self.assertEqual(response.code, 403)
self.assertEqual(s.shared_with, [])
def test_set_info(self):
"""Set info in a study"""
newinfo = {
"timeseries_type_id": 2,
"metadata_complete": False,
"number_samples_collected": 28,
"lab_person_id": StudyPerson(2),
"vamps_id": 'MBE_111222',
"first_contact": "June 11, 2014"
}
new = Study.create(
User('*****@*****.**'), 'NOT Identification of the '
'Microbiomes for Cannabis Soils', [1], self.info)
self.infoexp.update(newinfo)
new.info = newinfo
# add missing table cols
self.infoexp["funding"] = None
self.infoexp["spatial_series"] = None
self.infoexp["most_recent_contact"] = None
self.infoexp["reprocess"] = False
self.infoexp["lab_person_id"] = 2
self.assertEqual(new.info, self.infoexp)
def test_get_study_no_samples(self):
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"study_alias": "FCM",
"study_description": "DESC",
"study_abstract": "ABS",
"principal_investigator_id": StudyPerson(3),
'first_contact': datetime(2015, 5, 19, 16, 10),
'most_recent_contact': datetime(2015, 5, 19, 16, 11),
}
new_study = Study.create(User('*****@*****.**'),
"Some New Study for test", info)
exp = []
response = self.get('/api/v1/study/%d/samples' % new_study.id,
headers=self.headers)
self.assertEqual(response.code, 200)
obs = json_decode(response.body)
self.assertEqual(obs, exp)
def test_retrieve_processed_data_none(self):
new = Study.create(
User('*****@*****.**'), 'NOT Identification of the '
'Microbiomes for Cannabis Soils', [1], self.info)
self.assertEqual(new.processed_data(), [])
def generate_new_study_with_preprocessed_data(self):
"""Creates a new study up to the processed data for testing"""
info = {
"timeseries_type_id": 1,
"metadata_complete": True,
"mixs_compliant": True,
"number_samples_collected": 3,
"number_samples_promised": 3,
"study_alias": "Test EBI",
"study_description": "Study for testing EBI",
"study_abstract": "Study for testing EBI",
"emp_person_id": StudyPerson(2),
"principal_investigator_id": StudyPerson(3),
"lab_person_id": StudyPerson(1)
}
study = Study.create(User('*****@*****.**'), "Test EBI study", info)
metadata_dict = {
'Sample1': {
'collection_timestamp': datetime(2015, 6, 1, 7, 0, 0),
'physical_specimen_location': 'location1',
'taxon_id': 9606,
'scientific_name': 'h**o sapiens',
'Description': 'Test Sample 1'
},
'Sample2': {
'collection_timestamp': datetime(2015, 6, 2, 7, 0, 0),
'physical_specimen_location': 'location1',
'taxon_id': 9606,
'scientific_name': 'h**o sapiens',
'Description': 'Test Sample 2'
},
'Sample3': {
'collection_timestamp': datetime(2015, 6, 3, 7, 0, 0),
'physical_specimen_location': 'location1',
'taxon_id': 9606,
'scientific_name': 'h**o sapiens',
'Description': 'Test Sample 3'
}
}
metadata = pd.DataFrame.from_dict(metadata_dict,
orient='index',
dtype=str)
SampleTemplate.create(metadata, study)
metadata_dict = {
'Sample1': {
'primer': 'GTGCCAGCMGCCGCGGTAA',
'barcode': 'CGTAGAGCTCTC',
'center_name': 'KnightLab',
'platform': 'ILLUMINA',
'instrument_model': 'Illumina MiSeq',
'library_construction_protocol': 'Protocol ABC',
'experiment_design_description': "Random value 1"
},
'Sample2': {
'primer': 'GTGCCAGCMGCCGCGGTAA',
'barcode': 'CGTAGAGCTCTA',
'center_name': 'KnightLab',
'platform': 'ILLUMINA',
'instrument_model': 'Illumina MiSeq',
'library_construction_protocol': 'Protocol ABC',
'experiment_design_description': "Random value 2"
},
'Sample3': {
'primer': 'GTGCCAGCMGCCGCGGTAA',
'barcode': 'CGTAGAGCTCTT',
'center_name': 'KnightLab',
'platform': 'ILLUMINA',
'instrument_model': 'Illumina MiSeq',
'library_construction_protocol': 'Protocol ABC',
'experiment_design_description': "Random value 3"
},
}
metadata = pd.DataFrame.from_dict(metadata_dict,
orient='index',
dtype=str)
pt = PrepTemplate.create(metadata, study, "16S", 'Metagenomics')
fna_fp = join(self.temp_dir, 'seqs.fna')
demux_fp = join(self.temp_dir, 'demux.seqs')
with open(fna_fp, 'w') as f:
f.write(FASTA_EXAMPLE_2.format(study.id))
with File(demux_fp, 'w') as f:
to_hdf5(fna_fp, f)
ppd = Artifact.create([(demux_fp, 6)],
"Demultiplexed",
prep_template=pt)
return ppd
def test_environmental_packages_setter_valueerror(self):
new = Study.create(
User('*****@*****.**'), 'NOT Identification of the '
'Microbiomes for Cannabis Soils', [1], self.info)
with self.assertRaises(ValueError):
new.environmental_packages = ['air', 'not a package']
def test_retrieve_investigation_empty(self):
new = Study.create(
User('*****@*****.**'), 'NOT Identification of the '
'Microbiomes for Cannabis Soils', [1], self.info)
self.assertEqual(new.investigation, None)
def post(self, study=None):
the_study = None
form_factory = StudyEditorExtendedForm
if study:
# Check study and user access
the_study = self._check_study_exists_and_user_access(study)
# If the study is not sandbox, we use the short version
if the_study.status != 'sandbox':
form_factory = StudyEditorForm
# Get the form data from the request arguments
form_data = form_factory()
form_data.process(data=self.request.arguments)
# Get information about new people that need to be added to the DB
# Phones and addresses are optional, so make sure that we have None
# values instead of empty strings
new_people_info = [(name, email, affiliation, phone or None, address
or None)
for name, email, affiliation, phone, address in zip(
self.get_arguments('new_people_names'),
self.get_arguments('new_people_emails'),
self.get_arguments('new_people_affiliations'),
self.get_arguments('new_people_phones'),
self.get_arguments('new_people_addresses'))]
# New people will be indexed with negative numbers, so we reverse
# the list here
new_people_info.reverse()
index = int(form_data.data['principal_investigator'][0])
PI = self._get_study_person_id(index, new_people_info)
if form_data.data['lab_person'][0]:
index = int(form_data.data['lab_person'][0])
lab_person = self._get_study_person_id(index, new_people_info)
else:
lab_person = None
# TODO: MIXS compliant? Always true, right?
info = {
'lab_person_id': lab_person,
'principal_investigator_id': PI,
'metadata_complete': False,
'mixs_compliant': True,
'study_description': form_data.data['study_description'][0],
'study_alias': form_data.data['study_alias'][0],
'study_abstract': form_data.data['study_abstract'][0]
}
if 'timeseries' in form_data.data and form_data.data['timeseries']:
info['timeseries_type_id'] = form_data.data['timeseries'][0]
study_title = form_data.data['study_title'][0]
if the_study:
# We are under editing, so just update the values
the_study.title = study_title
the_study.info = info
msg = ('Study <a href="/study/description/%d">%s</a> '
'successfully updated' %
(the_study.id, form_data.data['study_title'][0]))
else:
# create the study
# TODO: Fix this EFO once ontology stuff from emily is added
the_study = Study.create(self.current_user,
study_title,
efo=[1],
info=info)
msg = ('Study <a href="/study/description/%d">%s</a> '
'successfully created' %
(the_study.id, form_data.data['study_title'][0]))
# Add the environmental packages, this attribute can only be edited
# if the study is not public, otherwise this cannot be changed
if isinstance(form_data, StudyEditorExtendedForm):
the_study.environmental_packages = form_data.data[
'environmental_packages']
dois = form_data.data['publication_doi']
if dois and dois[0]:
# The user can provide a comma-seprated list
dois = dois[0].split(',')
# Make sure that we strip the spaces from the pubmed ids
the_study.publications = [(doi.strip(), None) for doi in dois]
self.render('index.html', message=msg, level='success')
