def test_patch_biospecimen_genomic_file(self, mock):
"""
Test updating an existing biospecimen_genomic_file
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
response = self._make_biospecimen_genomic_file(mock)
orig = BiospecimenGenomicFile.query.count()
resp = json.loads(response.data.decode('utf-8'))
biospecimen_genomic_file = resp['results']
kf_id = biospecimen_genomic_file['kf_id']
body = {}
self.assertEqual(orig, BiospecimenGenomicFile.query.count())
response = self.client.patch(url_for(BS_GF_URL, kf_id=kf_id),
headers=self._api_headers(),
data=json.dumps(body))
resp = json.loads(response.data.decode('utf-8'))
# Status code
self.assertEqual(response.status_code, 200)
# Message
self.assertIn('biospecimen_genomic_file', resp['_status']['message'])
self.assertIn('updated', resp['_status']['message'])
# Content - check only patched fields are updated
bgf = BiospecimenGenomicFile.query.get(kf_id)
self.assertEqual(orig, BiospecimenGenomicFile.query.count())
def test_patch_cavatica_task_genomic_file(self, mock):
"""
Test updating an existing cavatica_task_genomic_file
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
response = self._make_cavatica_task_genomic_file(mock)
orig = CavaticaTaskGenomicFile.query.count()
resp = json.loads(response.data.decode('utf-8'))
cavatica_task_genomic_file = resp['results']
kf_id = cavatica_task_genomic_file['kf_id']
body = {
'is_input': not cavatica_task_genomic_file['is_input'],
}
self.assertEqual(orig, CavaticaTaskGenomicFile.query.count())
response = self.client.patch(url_for(CT_GF_URL, kf_id=kf_id),
headers=self._api_headers(),
data=json.dumps(body))
resp = json.loads(response.data.decode('utf-8'))
# Status code
self.assertEqual(response.status_code, 200)
# Message
self.assertIn('cavatica_task_genomic_file', resp['_status']['message'])
self.assertIn('updated', resp['_status']['message'])
# Content - check only patched fields are updated
task = CavaticaTaskGenomicFile.query.get(kf_id)
self.assertEqual(task.is_input, resp['results']['is_input'])
self.assertEqual(orig, CavaticaTaskGenomicFile.query.count())
def test_post_biospecimen_genomic_file(self, mock):
"""
Test creating a new biospecimen_genomic_file
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
response = self._make_biospecimen_genomic_file(mock)
resp = json.loads(response.data.decode('utf-8'))
self.assertEqual(response.status_code, 201)
self.assertIn('biospecimen_genomic_file', resp['_status']['message'])
self.assertIn('created', resp['_status']['message'])
# Content check
biospecimen_genomic_file = resp['results']
bsgf = BiospecimenGenomicFile.query.get(
biospecimen_genomic_file['kf_id'])
# Relations check
bs_kfid = resp['_links']['biospecimen'].split('/')[-1]
gf_kfid = resp['_links']['genomic_file'].split('/')[-1]
assert bsgf.biospecimen_id == bs_kfid
assert bsgf.genomic_file_id == gf_kfid
assert Biospecimen.query.get(bs_kfid) is not None
assert GenomicFile.query.get(gf_kfid) is not None
def test_not_null_constraint(self, mock):
"""
Test that a task and task genomic file cannot be
created without required parameters
task genomic file requires task_id,
genomic_file_id, is_input
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
# Create and save tasks and dependents
participants, tasks = self._create_and_save_tasks()
# Missing all required parameters
data = {}
tgf = TaskGenomicFile(**data)
db.session.add(tgf)
# Check database
with self.assertRaises(IntegrityError):
db.session.commit()
db.session.rollback()
# Missing 1 required param
data = {'task_id': tasks[0].kf_id}
tgf = TaskGenomicFile(**data)
db.session.add(tgf)
# Check database
with self.assertRaises(IntegrityError):
db.session.commit()
def test_update(self, mock):
"""
Test update task
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
# Create and save tasks and dependents
participants, tasks = self._create_and_save_tasks()
# Create new genomic_file
p0 = Participant.query.filter_by(external_id='Fred').one()
gf_new = GenomicFile(data_type='slide_image', file_name='slide_image1')
(p0.biospecimens[0].genomic_files.append(gf_new))
db.session.commit()
# Unlink task from a genomic file and link to a new one
tgf = TaskGenomicFile.query.first()
t_id = tgf.task_id
gf_id = tgf.genomic_file_id
tgf.genomic_file_id = gf_new.kf_id
db.session.commit()
# Check database
t = Task.query.get(t_id)
gf = GenomicFile.query.get(gf_id)
self.assertNotIn(gf, t.genomic_files)
self.assertIn(gf_new, t.genomic_files)
self.assertEqual(9, GenomicFile.query.count())
self.assertEqual(16, TaskGenomicFile.query.count())
def test_unique_constraint(self, mock):
"""
Test that duplicate tuples
(task_id, genomic_file_id, is_input)
cannot be created
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
# Create and save tasks and dependents
participants, tasks = self._create_and_save_tasks()
# Get existing TaskGenomicFile
tgf = TaskGenomicFile.query.first()
t_id = tgf.task_id
gf_id = tgf.genomic_file_id
is_input = tgf.is_input
new_tgf = TaskGenomicFile(task_id=t_id,
genomic_file_id=gf_id,
is_input=is_input)
db.session.add(new_tgf)
# Check database
with self.assertRaises(IntegrityError):
db.session.commit()
def test_post_cavatica_task_genomic_file(self, mock):
"""
Test creating a new cavatica_task_genomic_file
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
response = self._make_cavatica_task_genomic_file(mock)
resp = json.loads(response.data.decode('utf-8'))
self.assertEqual(response.status_code, 201)
self.assertIn('cavatica_task_genomic_file', resp['_status']['message'])
self.assertIn('created', resp['_status']['message'])
# Content check
cavatica_task_genomic_file = resp['results']
ctgf = CavaticaTaskGenomicFile.query.get(
cavatica_task_genomic_file['kf_id'])
self.assertEqual(ctgf.is_input, cavatica_task_genomic_file['is_input'])
# Relations check
ct_kfid = resp['_links']['cavatica_task'].split('/')[-1]
gf_kfid = resp['_links']['genomic_file'].split('/')[-1]
assert ctgf.cavatica_task_id == ct_kfid
assert ctgf.genomic_file_id == gf_kfid
assert CavaticaTask.query.get(ct_kfid) is not None
assert GenomicFile.query.get(gf_kfid) is not None
def test_delete_cavatica_task_genomic_file(self, mock):
"""
Test deleting a cavatica_task_genomic_file by id
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
resp = self._make_cavatica_task_genomic_file(mock)
resp = json.loads(resp.data.decode('utf-8'))
kf_id = resp['results']['kf_id']
response = self.client.delete(url_for(CT_GF_URL, kf_id=kf_id),
headers=self._api_headers())
resp = json.loads(response.data.decode('utf-8'))
self.assertEqual(response.status_code, 200)
self.assertEqual(CavaticaTaskGenomicFile.query.count(), 0)
response = self.client.get(url_for(CT_GF_URL, kf_id=kf_id),
headers=self._api_headers())
resp = json.loads(response.data.decode('utf-8'))
self.assertEqual(response.status_code, 404)
def test_update(self, mock):
"""
Test update cavatica_task
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
# Create and save cavatica_tasks and dependents
participants, cavatica_tasks = self._create_and_save_cavatica_tasks()
se = SequencingExperiment.query.all()[0]
# Create new genomic_file
p0 = Participant.query.filter_by(external_id='Fred').one()
gf_new = GenomicFile(data_type='slide_image',
file_name='slide_image1',
sequencing_experiment_id=se.kf_id)
(p0.biospecimens[0].genomic_files.append(gf_new))
db.session.commit()
# Unlink cavatica_task from a genomic file and link to a new one
ctgf = CavaticaTaskGenomicFile.query.first()
ct_id = ctgf.cavatica_task_id
gf_id = ctgf.genomic_file_id
ctgf.genomic_file_id = gf_new.kf_id
db.session.commit()
# Check database
ct = CavaticaTask.query.get(ct_id)
gf = GenomicFile.query.get(gf_id)
self.assertNotIn(gf, ct.genomic_files)
self.assertIn(gf_new, ct.genomic_files)
self.assertEqual(9, GenomicFile.query.count())
self.assertEqual(16, CavaticaTaskGenomicFile.query.count())
def client(app):
app_context = app.app_context()
app_context.push()
db.create_all()
mock = patch('dataservice.extensions.flask_indexd.requests')
mock = mock.start()
indexd_mock = MockIndexd()
mock.Session().get.side_effect = indexd_mock.get
mock.Session().post.side_effect = indexd_mock.post
mod = 'dataservice.api.study.models.requests'
mock_bs = patch(mod)
mock_bs = mock_bs.start()
mock_resp_get = MagicMock()
mock_resp_get.status_code = 200
mock_resp_post = MagicMock()
mock_resp_post.status_code = 201
mock_bs.Session().get.side_effect = mock_resp_get
mock_bs.Session().post.side_effect = mock_resp_post
yield app.test_client()
mock_bs.stop()
mock.stop()
# Need to make sure we close all connections so pg won't lock tables
db.session.close()
db.drop_all()
def test_delete_relations(self, mock):
"""
Test delete GenomicFile and TaskGenomicFile
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
# Create and save tasks and dependents
participants, tasks = self._create_and_save_tasks()
# Delete genomic file
p0 = Participant.query.filter_by(external_id='Fred').one()
gf = (p0.biospecimens[0].genomic_files[0])
# Save id and related tasks
kf_id = gf.kf_id
gf_tasks = [
tgf.task
for tgf in TaskGenomicFile.query.filter_by(genomic_file_id=kf_id)
]
db.session.delete(gf)
db.session.commit()
# Check database
# Genomic file deleted
self.assertEqual(7, GenomicFile.query.count())
self.assertEqual(14, TaskGenomicFile.query.count())
self.assertNotIn(gf, (p0.biospecimens[0].genomic_files))
for t in gf_tasks:
self.assertNotIn(gf, t.genomic_files)
# Delete TaskGenomicFile
tgf = TaskGenomicFile.query.first()
kf_id = tgf.kf_id
t_id = tgf.task_id
gf_id = tgf.genomic_file_id
db.session.delete(tgf)
db.session.commit()
# Check database
# No genomic files or tasks were deleted
self.assertEqual(7, GenomicFile.query.count())
self.assertEqual(2, Task.query.count())
# Association deleted
self.assertEqual(None, TaskGenomicFile.query.get(kf_id))
# Task unlinked from genomic_file
t = Task.query.get(t_id)
gf = GenomicFile.query.get(gf_id)
self.assertNotIn(gf, t.genomic_files)
def test_foreign_key_constraint(self, mock):
"""
Test that a task_genomic_file cannot be created without
existing reference Task and GenomicFile.
This checks foreign key constraint
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
# Create study_participant
data = {'is_input': True, 'task_id': 'none', 'genomic_file_id': 'none'}
tgf = TaskGenomicFile(**data)
db.session.add(tgf)
with self.assertRaises(IntegrityError):
db.session.commit()
def test_delete(self, mock):
"""
Test delete cavatica_app
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
# Create and save tasks and dependents
data = self._create_and_save_cavatica_app()
a = CavaticaApp.query.first()
db.session.delete(a)
# Check database
assert 0 == CavaticaApp.query.count()
assert 2 == Task.query.count()
def test_create_and_find(self, mock):
"""
Test create cavatica_app
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
# Create and save cavatica_app and dependents
data = self._create_and_save_cavatica_app()
# Check database
assert 1 == CavaticaApp.query.count()
a = CavaticaApp.query.first()
for k, v in data.items():
if k == '_obj':
continue
assert v == getattr(a, k)
assert 2 == len(a.tasks)
def test_get_all_cavatica_task_genomic_files(self, mock):
"""
Test retrieving all cavatica_task_genomic_files
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
self._make_cavatica_task_genomic_file(mock)
response = self.client.get(url_for(CT_GF_LIST_URL),
headers=self._api_headers())
status_code = response.status_code
response = json.loads(response.data.decode('utf-8'))
content = response.get('results')
self.assertEqual(status_code, 200)
self.assertIs(type(content), list)
self.assertEqual(len(content), 1)
def test_update(self, mock):
"""
Test update cavatica_app
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
# Create and save tasks and dependents
data = self._create_and_save_cavatica_app()
a = CavaticaApp.query.first()
a.tasks.pop()
a.name = 'app1'
db.session.commit()
# Check database
a = CavaticaApp.query.first()
assert 1 == len(a.tasks)
assert 'app1' == a.name
def test_get_biospecimen_genomic_file(self, mock):
"""
Test retrieving a biospecimen_genomic_file by id
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
resp = self._make_biospecimen_genomic_file(mock)
resp = json.loads(resp.data.decode('utf-8'))
kf_id = resp['results']['kf_id']
response = self.client.get(url_for(BS_GF_URL, kf_id=kf_id),
headers=self._api_headers())
resp = json.loads(response.data.decode('utf-8'))
self.assertEqual(response.status_code, 200)
biospecimen_genomic_file = resp['results']
bsgf = BiospecimenGenomicFile.query.get(kf_id)
self.assertEqual(kf_id, biospecimen_genomic_file['kf_id'])
self.assertEqual(kf_id, bsgf.kf_id)
def test_delete(self, mock):
"""
Test delete cavatica_task
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
# Create and save cavatica_tasks and dependents
participants, cavatica_tasks = self._create_and_save_cavatica_tasks()
kf_id = cavatica_tasks[0].kf_id
# Delete cavatica_task
ct = CavaticaTask.query.get(kf_id)
db.session.delete(ct)
db.session.commit()
# Check database
self.assertEqual(0, CavaticaTaskGenomicFile.query.
filter_by(cavatica_task_id=kf_id).count())
self.assertEqual(1, CavaticaTask.query.count())
self.assertNotIn(cavatica_tasks[0], CavaticaTask.query.all())
self.assertEqual(8, GenomicFile.query.count())
def test_get_cavatica_task_genomic_file(self, mock):
"""
Test retrieving a cavatica_task_genomic_file by id
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
resp = self._make_cavatica_task_genomic_file(mock)
resp = json.loads(resp.data.decode('utf-8'))
kf_id = resp['results']['kf_id']
response = self.client.get(url_for(CT_GF_URL, kf_id=kf_id),
headers=self._api_headers())
resp = json.loads(response.data.decode('utf-8'))
self.assertEqual(response.status_code, 200)
cavatica_task_genomic_file = resp['results']
ctgf = CavaticaTaskGenomicFile.query.get(kf_id)
self.assertEqual(kf_id, cavatica_task_genomic_file['kf_id'])
self.assertEqual(kf_id, ctgf.kf_id)
self.assertEqual(ctgf.is_input, cavatica_task_genomic_file['is_input'])
def test_create_and_find(self, mock):
"""
Test create cavatica_task
"""
indexd = MockIndexd()
mock.Session().post = indexd.post
mock.Session().get = indexd.get
mock.Session().put = indexd.put
# Create and save cavatica_tasks and dependents
participants, cavatica_tasks = self._create_and_save_cavatica_tasks()
GenomicFile.query.limit(5).all()
# Check database
# Count checks
# 4 participants, 2 genomic files per participant
# 2 cavatica_tasks, all genomic files are in both cavatica_tasks
self.assertEqual(8, GenomicFile.query.count())
self.assertEqual(2, CavaticaTask.query.count())
self.assertEqual(16, CavaticaTaskGenomicFile.query.count())
self.assertEqual(8, CavaticaTaskGenomicFile.query.filter_by(
is_input=False).count())
self.assertEqual(8, CavaticaTaskGenomicFile.query.filter_by(
is_input=True).count())
# CavaticaTask content checks
for p in participants:
gfs = (p.biospecimens[0].genomic_files)
for gf in gfs:
gf_cavatica_tasks = [
ctgf.cavatica_task
for ctgf in gf.cavatica_task_genomic_files]
for gf_cavatica_task in gf_cavatica_tasks:
self.assertIn(gf_cavatica_task, cavatica_tasks)
self.assertEqual(
True,
(gf_cavatica_task.name == 'kf-alignment1'
or gf_cavatica_task.name == 'kf-alignment2'))
