示例#1
0
    def setUp(self):
        self.settings = {'jobfactory.root_dir': '/somedir',
                         'restricted': False,
                         'ncpus': 1}
        self.config = testing.setUp(settings=self.settings)
        self.config.add_route('status.json', '/status/{jobid}.json')

        self.jobid = '3ad25048-26f6-11e1-851e-00012e260790'
        self.post = {'key': 'value'}
        self.jq = Mock(JobQuery)
        self.jobquery = Mock(JobQuery)
        jobmeta = JobMeta(uuid.UUID(self.jobid), owner='bob')
        self.job = Job(jobmeta, '/mydir', Mock(JobDb))
        self.job.jobquery = Mock(return_value=self.jobquery)
        self.job.db.maxMSLevel.return_value = 1
        self.job.db.moleculesTotalCount.return_value = 1

        self.jobid2 = 'fe144547-cf16-44bb-8e97-e2ffe5675154'
        jobmeta2 = JobMeta(uuid.UUID(self.jobid2), owner='bob')
        self.job2 = Job(jobmeta2, '/mydir', Mock(JobDb))
        self.job2.jobquery = Mock(return_value=self.jobquery)
        self.job2.db.maxMSLevel.return_value = 1
        self.job2.db.moleculesTotalCount.return_value = 1

        self.rpc = RpcViews(self.job, testing.DummyRequest(post=self.post))
        self.rpc.new_job = Mock(return_value=self.job2)
        self.rpc.job_factory.submitQuery = Mock()
示例#2
0
文件: test_job.py 项目: wangjs/MAGMa
 def setUp(self):
     import tempfile
     self.parentjobid = uuid.UUID('22222222-2222-2222-2222-222222222222')
     self.jobid = uuid.UUID('11111111-1111-1111-1111-111111111111')
     self.created_at = datetime.datetime(2012, 11, 14, 10, 48, 26, 504478)
     self.meta = mu.JobMeta(jobid=self.jobid,
                            description=u"My desc",
                            state=u'STOPPED',
                            parentjobid=self.parentjobid,
                            owner=u'bob',
                            created_at=self.created_at,
                            ms_filename=u'F1234.mzxml',
                            is_public=False,
                            )
     self.db = Mock(JobDb)
     self.jobdir = tempfile.mkdtemp()
     stderr = open(os.path.join(self.jobdir, 'stderr.txt'), 'w')
     stderr.write('Error log')
     stderr.close()
     stdout = open(os.path.join(self.jobdir, 'stdout.txt'), 'w')
     stdout.write('Log')
     stdout.close()
     self.job = Job(self.meta, self.jobdir, self.db)
示例#3
0
文件: test_job.py 项目: wangjs/MAGMa
class JobTestCase(unittest.TestCase):
    def setUp(self):
        import tempfile
        self.parentjobid = uuid.UUID('22222222-2222-2222-2222-222222222222')
        self.jobid = uuid.UUID('11111111-1111-1111-1111-111111111111')
        self.created_at = datetime.datetime(2012, 11, 14, 10, 48, 26, 504478)
        self.meta = mu.JobMeta(jobid=self.jobid,
                               description=u"My desc",
                               state=u'STOPPED',
                               parentjobid=self.parentjobid,
                               owner=u'bob',
                               created_at=self.created_at,
                               ms_filename=u'F1234.mzxml',
                               is_public=False,
                               )
        self.db = Mock(JobDb)
        self.jobdir = tempfile.mkdtemp()
        stderr = open(os.path.join(self.jobdir, 'stderr.txt'), 'w')
        stderr.write('Error log')
        stderr.close()
        stdout = open(os.path.join(self.jobdir, 'stdout.txt'), 'w')
        stdout.write('Log')
        stdout.close()
        self.job = Job(self.meta, self.jobdir, self.db)

    def tearDown(self):
        import shutil
        shutil.rmtree(self.jobdir)

    def test_construct(self):
        self.assertEqual(self.job.db, self.db)
        self.assertEqual(self.job.dir, self.jobdir)

    def test_id(self):
        self.assertEqual(self.job.id, self.jobid)

    def test_name(self):
        self.assertEqual(self.job.__name__, str(self.jobid))

    def test_get_description(self):
        self.assertEqual(self.job.description, u'My desc')

    def test_set_description(self):
        self.job.description = u'My second description'

        self.assertEqual(self.job.description, u'My second description')
        self.assertEqual(self.job.meta.description, u'My second description')
        self.assertEqual(self.job.db.runInfo().description,
                         u'My second description')

    def test_set_description_withoutruninfo(self):
        self.job.db.runInfo.return_value = None

        self.job.description = u'My second description'

        self.assertEqual(self.job.description, u'My second description')
        self.assertEqual(self.job.meta.description, u'My second description')

    def test_owner(self):
        self.assertEqual(self.job.owner, u'bob')

    def test_set_owner(self):
        self.job.owner = u'ed'
        self.assertEqual(self.job.owner, u'ed')

    def test_stderr(self):
        log = self.job.stderr()
        self.assertIsInstance(log, file)
        self.assertEqual(log.name, self.jobdir + '/stderr.txt')
        self.assertEqual(log.read(), 'Error log')

    def test_stderr_empty(self):
        open_stub = Mock(side_effect=IOError('File not found'))
        with patch('__builtin__.open', open_stub):
            log = self.job.stderr()
            self.assertEqual(log.read(), '')

    def test_stdout(self):
        log = self.job.stdout()
        self.assertIsInstance(log, file)
        self.assertEqual(log.name, self.jobdir + '/stdout.txt')
        self.assertEqual(log.read(), 'Log')

    def test_stdout_empty(self):
        open_stub = Mock(side_effect=IOError('File not found'))
        with patch('__builtin__.open', open_stub):
            log = self.job.stdout()
            self.assertEqual(log.read(), '')

    def test_jobquery(self):
        status_cb_url = 'http://example/status/{}.json'.format(self.job.id)
        jobquery = self.job.jobquery(status_cb_url, False, 1)

        ejobquery = JobQuery(self.jobdir,
                             status_callback_url=status_cb_url,
                             restricted=False,
                             )

        self.assertIsInstance(jobquery, JobQuery)
        self.assertEqual(jobquery, ejobquery)

    def test_jobquery_restricted(self):
        status_cb_url = 'http://example/status/{}.json'.format(self.job.id)
        jobquery = self.job.jobquery(status_cb_url, True, 1)

        ejobquery = JobQuery(self.jobdir,
                             status_callback_url=status_cb_url,
                             restricted=True,
                             )

        self.assertEqual(jobquery, ejobquery)

    def test_state(self):
        self.assertEquals(self.job.state, u'STOPPED')

    def test_set_state(self):
        self.job.state = u'RUNNING'

        self.assertEquals(self.job.state, u'RUNNING')

    def test_parent(self):
        self.assertEquals(self.job.parent, self.parentjobid)

    def test_set_parent(self):
        jid = uuid.UUID('3ad25048-26f6-11e1-851e-00012e260790')
        self.job.parent = jid

        self.assertEquals(self.job.parent, jid)

    def test_created_at(self):
        self.assertEqual(self.job.created_at, self.created_at)

    def test_ms_filename(self):
        self.assertEqual(self.job.ms_filename, u'F1234.mzxml')

    def test_set_ms_filename(self):
        self.job.ms_filename = u'F4567.mzxml'

        self.assertEqual(self.job.ms_filename, u'F4567.mzxml')
        self.assertEqual(self.job.meta.ms_filename, u'F4567.mzxml')
        self.assertEqual(self.job.db.runInfo().ms_filename, u'F4567.mzxml')

    def test_set_ms_filename_withoutruninfo(self):
        self.job.db.runInfo.return_value = None

        self.job.ms_filename = u'F4567.mzxml'

        self.assertEqual(self.job.ms_filename, u'F4567.mzxml')
        self.assertEqual(self.job.meta.ms_filename, u'F4567.mzxml')

    @patch('magmaweb.user.JobMeta')
    @patch('magmaweb.job.shutil')
    def test_delete(self, shutl, jm):
        self.job.db.session = Mock()

        self.job.delete()

        self.job.db.session.remove.assert_called_with()
        shutl.rmtree.assert_called_with(self.jobdir)
        jm.delete.assert_called_with(self.meta)

    def test_is_public(self):
        self.assertEquals(self.job.is_public, False)

    def test_set_is_public(self):
        self.job.is_public = True

        self.assertEquals(self.job.is_public, True)

    def test_is_complete(self):
        self.job.state = u'STOPPED'
        self.assertTrue(self.job.is_complete())

    def test_is_complete_running(self):
        running_states = (u'PENDING', u'PRE_STAGING', u'RUNNING',
                          u'POST_STAGING', u'Progress: 50%')
        for running_state in running_states:
            self.job.state = running_state
            with self.assertRaises(JobIncomplete) as e:
                self.job.is_complete()

            self.assertEqual(e.exception.job, self.job)

    def test_is_complete_error(self):
        self.job.state = u'ERROR'
        with self.assertRaises(JobError) as e:
            self.job.is_complete()

        self.assertEqual(e.exception.job, self.job)

    def test_is_complete_filled(self):
        self.job.db.hasMolecules.return_value = True
        self.job.db.hasMspectras.return_value = True
        self.job.db.hasFragments.return_value = True

        complete = self.job.is_complete(True)

        self.assertTrue(complete)

    def test_is_complete_unfilled_molecules(self):
        self.job.db.hasMolecules = Mock(return_value=False)
        self.job.db.hasMspectras = Mock(return_value=True)
        self.job.db.hasFragments = Mock(return_value=True)

        with self.assertRaises(MissingDataError) as e:
            self.job.is_complete(True)

        self.assertEqual(e.exception.job, self.job)
        self.assertEqual(e.exception.message, 'No molecules found')

    def test_is_complete_unfilled_mspectra(self):
        self.job.db.hasMolecules = Mock(return_value=True)
        self.job.db.hasMspectras = Mock(return_value=False)
        self.job.db.hasFragments = Mock(return_value=True)

        with self.assertRaises(MissingDataError) as e:
            self.job.is_complete(True)

        self.assertEqual(e.exception.job, self.job)
        self.assertEqual(e.exception.message, 'No mass spectras found')

    def test_is_complete_unfilled_fragments(self):
        self.job.db.hasMolecules = Mock(return_value=True)
        self.job.db.hasMspectras = Mock(return_value=True)
        self.job.db.hasFragments = Mock(return_value=False)

        with self.assertRaises(MissingDataError) as e:
            self.job.is_complete(True)

        self.assertEqual(e.exception.job, self.job)
        self.assertEqual(e.exception.message, 'No fragments found')

    def test_launcher_url(self):
        url = 'http://localhost:9998/job/70a00fe2-f698-41ed-b28c-b37c22f10440'
        self.job.launcher_url = url

        self.assertEqual(self.job.launcher_url, url)
        self.assertEqual(self.job.meta.launcher_url, url)