Пример #1
0
    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())
Пример #2
0
    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
Пример #3
0
    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_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'))