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_create_nonqiita_portal(self):
new_id = get_count("qiita.analysis") + 1
qiita_config.portal = "EMP"
Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis")
# make sure portal is associated
obs = self.conn_handler.execute_fetchall(
"SELECT * from qiita.analysis_portal WHERE analysis_id = %s",
[new_id])
self.assertEqual(obs, [[new_id, 2], [new_id, 1]])
def test_create_exists_return_existing(self):
"""Makes sure creation doesn't duplicate a job by returning existing"""
Analysis.create(User("*****@*****.**"), "new", "desc")
self.conn_handler.execute(
"INSERT INTO qiita.analysis_sample (analysis_id, "
"processed_data_id, sample_id) VALUES (3,1,'SKB8.640193'), "
"(3,1,'SKD8.640184'), (3,1,'SKB7.640196'), (3,1,'SKM9.640192'),"
"(3,1,'SKM4.640180')")
new = Job.create("18S", "Beta Diversity",
{"--otu_table_fp": 1, "--mapping_fp": 1},
Analysis(3), return_existing=True)
self.assertEqual(new.id, 2)
def test_create_exists_return_existing(self):
"""Makes sure creation doesn't duplicate a job by returning existing"""
Analysis.create(User("*****@*****.**"), "new", "desc")
self.conn_handler.execute(
"INSERT INTO qiita.analysis_sample "
"(analysis_id, processed_data_id, sample_id) VALUES "
"(3, 1, '1.SKB8.640193'), (3, 1, '1.SKD8.640184'), "
"(3, 1, '1.SKB7.640196'), (3, 1, '1.SKM9.640192'), "
"(3, 1, '1.SKM4.640180')")
new = Job.create("18S", "Beta Diversity",
{"--otu_table_fp": 1, "--mapping_fp": 1},
Analysis(3), return_existing=True)
self.assertEqual(new.id, 2)
def test_lock_check(self):
for status in ["queued", "running", "public", "completed", "error"]:
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis")
new.status = status
with self.assertRaises(QiitaDBStatusError):
new._lock_check(self.conn_handler)
def test_set_step(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis", Analysis(1))
new.step = 2
sql = "SELECT * FROM qiita.analysis_workflow WHERE analysis_id = 3"
obs = self.conn_handler.execute_fetchall(sql)
self.assertEqual(obs, [[3, 2]])
def test_add_samples(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis")
new.add_samples({1: ['1.SKB8.640193', '1.SKD5.640186']})
obs = new.samples
self.assertEqual(obs.keys(), [1])
self.assertItemsEqual(obs[1], ['1.SKB8.640193', '1.SKD5.640186'])
def test_set_step(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis", Analysis(1))
new.step = 2
sql = "SELECT * FROM qiita.analysis_workflow WHERE analysis_id = 3"
obs = self.conn_handler.execute_fetchall(sql)
self.assertEqual(obs, [[3, 2]])
def test_create(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis")
self.assertEqual(new.id, 3)
sql = "SELECT * FROM qiita.analysis WHERE analysis_id = 3"
obs = self.conn_handler.execute_fetchall(sql)
self.assertEqual(obs, [[3, '*****@*****.**', 'newAnalysis',
'A New Analysis', 1, None]])
def post(self):
name = self.get_argument('name')
desc = self.get_argument('description')
analysis = Analysis.create(self.current_user, name, desc,
from_default=True)
self.redirect(u"%s/analysis/description/%s/"
% (qiita_config.portal_dir, analysis.id))
def post(self):
name = self.get_argument('name')
desc = self.get_argument('description')
analysis = Analysis.create(self.current_user, name, desc,
from_default=True)
self.redirect(u"%s/analysis/description/%s/"
% (qiita_config.portal_dir, analysis.id))
def test_lock_check(self):
for status in ["queued", "running", "public", "completed",
"error"]:
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis")
new.status = status
with self.assertRaises(QiitaDBStatusError):
new._lock_check(self.conn_handler)
def test_set_step_twice(self):
new_id = get_count("qiita.analysis") + 1
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis", Analysis(1))
new.step = 2
new.step = 4
sql = "SELECT * FROM qiita.analysis_workflow WHERE analysis_id = %s"
obs = self.conn_handler.execute_fetchall(sql, [new_id])
self.assertEqual(obs, [[new_id, 4]])
def post(self):
name = self.get_argument('name')
desc = self.get_argument('description')
analysis = Analysis.create(self.current_user, name, desc,
from_default=True)
# set to third step since this page is third step in workflow
analysis.step = SELECT_COMMANDS
data_types = analysis.data_types
commands = Command.get_commands_by_datatype()
self.render('select_commands.html',
commands=commands, data_types=data_types, aid=analysis.id)
def post(self):
name = self.get_argument('name')
desc = self.get_argument('description')
analysis = Analysis.create(self.current_user, name, desc,
from_default=True)
# set to third step since this page is third step in workflow
analysis.step = SELECT_COMMANDS
data_types = analysis.data_types
commands = Command.get_commands_by_datatype()
self.render('select_commands.html',
commands=commands, data_types=data_types, aid=analysis.id)
def post(self):
name = self.get_argument('name')
desc = self.get_argument('description')
mdsi = self.get_argument('merge_duplicated_sample_ids', False)
if mdsi in (b'on', 'on'):
mdsi = True
analysis = Analysis.create(
self.current_user, name, desc, merge_duplicated_sample_ids=mdsi,
from_default=True)
self.redirect(u"%s/analysis/description/%s/"
% (qiita_config.portal_dir, analysis.id))
def post(self):
name = self.get_argument('name')
desc = self.get_argument('description')
mdsi = self.get_argument('merge_duplicated_sample_ids', False)
if mdsi in (b'on', 'on'):
mdsi = True
analysis = Analysis.create(self.current_user,
name,
desc,
merge_duplicated_sample_ids=mdsi,
from_default=True)
self.redirect(u"%s/analysis/description/%s/" %
(qiita_config.portal_dir, analysis.id))
def test_create(self):
sql = "SELECT EXTRACT(EPOCH FROM NOW())"
time1 = float(self.conn_handler.execute_fetchall(sql)[0][0])
new_id = get_count("qiita.analysis") + 1
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis")
self.assertEqual(new.id, new_id)
sql = ("SELECT analysis_id, email, name, description, "
"analysis_status_id, pmid, EXTRACT(EPOCH FROM timestamp) "
"FROM qiita.analysis WHERE analysis_id = %s")
obs = self.conn_handler.execute_fetchall(sql, [new_id])
self.assertEqual(obs[0][:-1], [new_id, '*****@*****.**', 'newAnalysis',
'A New Analysis', 1, None])
self.assertTrue(time1 < float(obs[0][-1]))
def test_create(self):
sql = "SELECT EXTRACT(EPOCH FROM NOW())"
time1 = float(self.conn_handler.execute_fetchall(sql)[0][0])
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis")
self.assertEqual(new.id, 3)
sql = ("SELECT analysis_id, email, name, description, "
"analysis_status_id, pmid, EXTRACT(EPOCH FROM timestamp) "
"FROM qiita.analysis WHERE analysis_id = 3")
obs = self.conn_handler.execute_fetchall(sql)
self.assertEqual(
obs[0][:-1],
[3, '*****@*****.**', 'newAnalysis', 'A New Analysis', 1, None])
self.assertTrue(time1 < float(obs[0][-1]))
def test_select_samples(self):
newaid = Analysis.create(User("*****@*****.**"), "test1", "testdesc").id
post_args = {
'analysis-id': newaid,
'action': 'select',
'availstudies': "1#1",
'1#1': 1,
'1': 'SKD5.640186'}
response = self.post('/analysis/2', post_args)
# Make sure page response loaded sucessfully
self.assertEqual(response.code, 200)
# make sure sample added
self.assertTrue("SKD5.640186" in str(response.body))
def post(self):
name = self.get_argument('name')
description = self.get_argument('description')
user = self.get_current_user()
# create list of studies
study_ids = {s.id for s in Study.get_public()}
userobj = User(user)
[study_ids.add(x) for x in userobj.private_studies]
[study_ids.add(x) for x in userobj.shared_studies]
studies = [Study(i) for i in study_ids]
analysis = Analysis.create(User(user), name, description)
self.render('select_studies.html', user=user, aid=analysis.id,
studies=studies)
def test_get_analysis_jobs_handler(self):
user = User('*****@*****.**')
dflt_analysis = user.default_analysis
dflt_analysis.add_samples(
{4: ['1.SKB8.640193', '1.SKD8.640184', '1.SKB7.640196',
'1.SKM9.640192', '1.SKM4.640180']})
new = Analysis.create(user, "newAnalysis", "A New Analysis",
from_default=True)
response = self.get('/analysis/description/%s/jobs/' % new.id)
self.assertEqual(response.code, 200)
# There is only one job
job_id = new.jobs[0].id
obs = loads(response.body)
exp = {job_id: {'status': 'queued', 'step': None, 'error': ""}}
self.assertEqual(obs, exp)
def test_get_analysis_jobs_handler(self):
user = User('*****@*****.**')
dflt_analysis = user.default_analysis
dflt_analysis.add_samples(
{4: ['1.SKB8.640193', '1.SKD8.640184', '1.SKB7.640196',
'1.SKM9.640192', '1.SKM4.640180']})
new = Analysis.create(user, "newAnalysis", "A New Analysis",
from_default=True)
response = self.get('/analysis/description/%s/jobs/' % new.id)
self.assertEqual(response.code, 200)
# There is only one job
job_id = new.jobs[0].id
obs = loads(response.body)
exp = {job_id: {'status': 'queued', 'step': None, 'error': ""}}
self.assertEqual(obs, exp)
def test_select_samples(self):
newaid = Analysis.create(User("*****@*****.**"), "test1", "testdesc").id
post_args = {
'analysis-id': newaid,
'action': 'select',
'availstudies': "1#1",
'1#1': 1,
'1': 'SKD5.640186'
}
response = self.post('/analysis/2', post_args)
# Make sure page response loaded sucessfully
self.assertEqual(response.code, 200)
# make sure sample added
self.assertTrue("SKD5.640186" in str(response.body))
def test_create_parent(self):
sql = "SELECT EXTRACT(EPOCH FROM NOW())"
time1 = float(self.conn_handler.execute_fetchall(sql)[0][0])
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis", Analysis(1))
self.assertEqual(new.id, 3)
sql = ("SELECT analysis_id, email, name, description, "
"analysis_status_id, pmid, EXTRACT(EPOCH FROM timestamp) "
"FROM qiita.analysis WHERE analysis_id = 3")
obs = self.conn_handler.execute_fetchall(sql)
self.assertEqual(obs[0][:-1], [3, '*****@*****.**', 'newAnalysis',
'A New Analysis', 1, None])
self.assertTrue(time1 < float(obs[0][-1]))
sql = "SELECT * FROM qiita.analysis_chain WHERE child_id = 3"
obs = self.conn_handler.execute_fetchall(sql)
self.assertEqual(obs, [[1, 3]])
def test_create_from_default(self):
new_id = get_count("qiita.analysis") + 1
owner = User("*****@*****.**")
new = Analysis.create(owner, "newAnalysis",
"A New Analysis", from_default=True)
self.assertEqual(new.id, new_id)
self.assertEqual(new.step, 3)
# Make sure samples were transfered properly
sql = "SELECT * FROM qiita.analysis_sample WHERE analysis_id = %s"
obs = self.conn_handler.execute_fetchall(sql, [owner.default_analysis])
exp = []
self.assertEqual(obs, exp)
sql = "SELECT * FROM qiita.analysis_sample WHERE analysis_id = %s"
obs = self.conn_handler.execute_fetchall(sql, [new_id])
exp = [[new_id, 1, '1.SKD8.640184'],
[new_id, 1, '1.SKB7.640196'],
[new_id, 1, '1.SKM9.640192'],
[new_id, 1, '1.SKM4.640180']]
self.assertEqual(obs, exp)
def test_retrieve_mapping_file_none(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis", Analysis(1))
obs = new.mapping_file
self.assertEqual(obs, None)
def test_retrieve_pmid_none(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis", Analysis(1))
self.assertEqual(new.pmid, None)
def test_retrieve_step_new(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis", Analysis(1))
with self.assertRaises(ValueError):
new.step
def test_retrieve_step(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis", Analysis(1))
new.step = 2
self.assertEqual(new.step, 2)
def test_retrieve_pmid_none(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis", Analysis(1))
self.assertEqual(new.pmid, None)
def test_add_samples(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis")
new.add_samples([(1, 'SKB8.640193')])
def test_retrieve_step(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis", Analysis(1))
new.step = 2
self.assertEqual(new.step, 2)
def test_add_jobs(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis")
new.add_jobs([Job(1)])
self.assertEqual(new.jobs, [1])
def test_add_samples(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis")
new.add_samples([(1, '1.SKB8.640193'), (1, '1.SKD5.640186')])
exp = {1: ['1.SKB8.640193', '1.SKD5.640186']}
self.assertEqual(new.samples, exp)
def test_retrieve_mapping_file_none(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis", Analysis(1))
obs = new.mapping_file
self.assertEqual(obs, None)
def post(self):
user = self.current_user
action = self.get_argument("action")
# set required template variables
results = {}
meta_headers = []
counts = {}
fullcounts = {}
query = ""
searchmsg = ""
selsamples = {}
selproc_data = {}
# get analysis and selected samples if exists, or create if necessary
if action == "create":
name = self.get_argument('name')
description = self.get_argument('description')
analysis = Analysis.create(user, name, description)
analysis_id = analysis.id
# set to second step since this page is second step in workflow
analysis.step = SELECT_SAMPLES
# fill example studies by running query for specific studies
search = QiitaStudySearch()
def_query = 'study_id = 1 OR study_id = 2 OR study_id = 3'
results, meta_headers = search(def_query, user)
results, counts, fullcounts = self._parse_search_results(
results, selsamples, meta_headers)
else:
analysis_id = int(self.get_argument("analysis-id"))
analysis = Analysis(analysis_id)
check_analysis_access(user, analysis)
selproc_data, selsamples = self._selected_parser(analysis)
# run through action requested
if action == "search":
search = QiitaStudySearch()
query = str(self.get_argument("query"))
try:
results, meta_headers = search(query, user)
except ParseException:
searchmsg = "Malformed search query, please read search help."
except QiitaDBIncompatibleDatatypeError as e:
searchmsg = ''.join(e)
if not results and not searchmsg:
searchmsg = "No results found."
else:
results, counts, fullcounts = self._parse_search_results(
results, selsamples, meta_headers)
elif action == "select":
analysis.add_samples(self._parse_form_select())
# rebuild the selected from database to reflect changes
selproc_data, selsamples = self._selected_parser(analysis)
elif action == "deselect":
proc_data, samples = self._parse_form_deselect()
if proc_data:
analysis.remove_samples(proc_data=proc_data)
if samples:
analysis.remove_samples(samples=samples)
if not proc_data and not samples:
searchmsg = "Must select samples to remove from analysis!"
# rebuild the selected from database to reflect changes
selproc_data, selsamples = self._selected_parser(analysis)
self.render('search_studies.html', user=user, aid=analysis_id,
results=results, meta_headers=meta_headers,
selsamples=selsamples, selproc_data=selproc_data,
counts=counts, fullcounts=fullcounts, searchmsg=searchmsg,
query=query, availmeta=SampleTemplate.metadata_headers() +
get_table_cols("study"))
def test_add_samples(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis")
new.add_samples([(1, '1.SKB8.640193'), (1, '1.SKD5.640186')])
exp = {1: ['1.SKB8.640193', '1.SKD5.640186']}
self.assertEqual(new.samples, exp)
def test_add_biom_tables(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis")
new.add_biom_tables([ProcessedData(1)])
self.assertEqual(new.biom_tables, [7])
def test_retrieve_step_new(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis", Analysis(1))
with self.assertRaises(ValueError):
new.step
def test_retrieve_biom_tables_none(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis", Analysis(1))
self.assertEqual(new.biom_tables, None)
def test_retrieve_biom_tables_none(self):
new = Analysis.create(User("*****@*****.**"), "newAnalysis",
"A New Analysis", Analysis(1))
self.assertEqual(new.biom_tables, None)
def post(self):
user = self.current_user
action = self.get_argument("action")
# set required template variables
results = {}
meta_headers = []
counts = {}
fullcounts = {}
query = ""
searchmsg = ""
selsamples = {}
selproc_data = {}
# get analysis and selected samples if exists, or create if necessary
if action == "create":
name = self.get_argument('name')
description = self.get_argument('description')
analysis = Analysis.create(User(user), name, description)
analysis_id = analysis.id
# set to second step since this page is second step in workflow
analysis.step = SELECT_SAMPLES
# fill example studies by running query for specific studies
search = QiitaStudySearch()
def_query = 'study_id = 1 OR study_id = 2 OR study_id = 3'
results, meta_headers = search(def_query, user)
results, counts, fullcounts = self._parse_search_results(
results, selsamples, meta_headers)
else:
analysis_id = int(self.get_argument("analysis-id"))
check_analysis_access(User(user), analysis_id)
analysis = Analysis(analysis_id)
selproc_data, selsamples = self._selected_parser(analysis)
# run through action requested
if action == "search":
search = QiitaStudySearch()
query = str(self.get_argument("query"))
try:
results, meta_headers = search(query, user)
except ParseException:
searchmsg = "Malformed search query, please read search help."
except QiitaDBIncompatibleDatatypeError as e:
searchmsg = ''.join(e)
if not results and not searchmsg:
searchmsg = "No results found."
else:
results, counts, fullcounts = self._parse_search_results(
results, selsamples, meta_headers)
elif action == "select":
analysis.add_samples(self._parse_form_select())
# rebuild the selected from database to reflect changes
selproc_data, selsamples = self._selected_parser(analysis)
elif action == "deselect":
proc_data, samples = self._parse_form_deselect()
if proc_data:
analysis.remove_samples(proc_data=proc_data)
if samples:
analysis.remove_samples(samples=samples)
if not proc_data and not samples:
searchmsg = "Must select samples to remove from analysis!"
# rebuild the selected from database to reflect changes
selproc_data, selsamples = self._selected_parser(analysis)
self.render('search_studies.html',
user=user,
aid=analysis_id,
results=results,
meta_headers=meta_headers,
selsamples=selsamples,
selproc_data=selproc_data,
counts=counts,
fullcounts=fullcounts,
searchmsg=searchmsg,
query=query,
availmeta=SampleTemplate.metadata_headers() +
get_table_cols("study"))
