Esempio n. 1
0
    def testFilterPending(self):
        opts = optparse.Values(
            dict(status_filter=constants.JOBS_PENDING, force=False,
                 kill=False))

        def _Query(qfilter):
            # Need to sort as constants.JOBS_PENDING has no stable order
            assert isinstance(constants.JOBS_PENDING, frozenset)
            self.assertEqual(
                sorted(qfilter),
                sorted(qlang.MakeSimpleFilter("status",
                                              constants.JOBS_PENDING)))

            return [
                [(constants.RS_UNAVAIL, None), (constants.RS_UNAVAIL, None),
                 (constants.RS_UNAVAIL, None)],
                [(constants.RS_NORMAL, 32532),
                 (constants.RS_NORMAL, constants.JOB_STATUS_QUEUED),
                 (constants.RS_NORMAL, ["op1", "op2", "op3"])],
            ]

        cl = _ClientForCancelJob(NotImplemented, _Query)

        result = gnt_job.CancelJobs(opts, [],
                                    cl=cl,
                                    _stdout_fn=self._ToStdout,
                                    _ask_fn=compat.partial(self._Ask, False))
        self.assertEqual(result, constants.EXIT_CONFIRMATION)
 def testStatusFilterAndArguments(self):
     opts = optparse.Values(dict(status_filter=frozenset()))
     try:
         gnt_job.CancelJobs(opts, ["a"],
                            cl=NotImplemented,
                            _stdout_fn=NotImplemented,
                            _ask_fn=NotImplemented)
     except errors.OpPrereqError, err:
         self.assertEqual(err.args[1], errors.ECODE_INVAL)
 def testStatusFilterAndArguments(self):
     opts = optparse.Values(
         dict(status_filter=frozenset(), force=False, kill=False))
     try:
         gnt_job.CancelJobs(opts, ["a"],
                            cl=NotImplemented,
                            _stdout_fn=NotImplemented,
                            _ask_fn=NotImplemented)
     except errors.OpPrereqError as err:
         self.assertEqual(err.args[1], errors.ECODE_INVAL)
     else:
         self.fail("Did not raise exception")
    def _TestArguments(self, force):
        opts = optparse.Values(dict(status_filter=None, force=force))

        def _CancelCb(job_id):
            self.assertTrue(job_id in ("24185", "3252"))
            return (True, "%s will be cancelled" % job_id)

        cl = _ClientForCancelJob(_CancelCb, NotImplemented)
        self.assertEqual(
            gnt_job.CancelJobs(opts, ["24185", "3252"],
                               cl=cl,
                               _stdout_fn=self._ToStdout,
                               _ask_fn=NotImplemented), constants.EXIT_SUCCESS)
        self.assertEqual(cl.cancelled, ["24185", "3252"])
        self.assertEqual(self.stdout, [
            "24185 will be cancelled",
            "3252 will be cancelled",
        ])
    def testArgumentsWithError(self):
        opts = optparse.Values(dict(status_filter=None, force=True))

        def _CancelCb(job_id):
            if job_id == "10788":
                return (False, "error %s" % job_id)
            else:
                return (True, "%s will be cancelled" % job_id)

        cl = _ClientForCancelJob(_CancelCb, NotImplemented)
        self.assertEqual(
            gnt_job.CancelJobs(opts, ["203", "10788", "30801"],
                               cl=cl,
                               _stdout_fn=self._ToStdout,
                               _ask_fn=NotImplemented), constants.EXIT_FAILURE)
        self.assertEqual(cl.cancelled, ["203", "10788", "30801"])
        self.assertEqual(self.stdout, [
            "203 will be cancelled",
            "error 10788",
            "30801 will be cancelled",
        ])