Python job.Job类代码示例

    def test_nobuilds_get_last_build(self, _poll):
        # Bare minimum build dict, we only testing dissapearance of 'builds'
        _poll.return_value = {"name": "foo"}

        j = Job('http://halob:8080/job/foo/', 'foo', self.J)
        with self.assertRaises(NoBuildData):
            j.get_last_build()

def test_get_build_by_params_not_found(jenkins, monkeypatch, mocker):
    build_params = {
        'param1': 'value1'
    }
    fake_builds = (
        mocker.Mock(get_params=lambda: {}),
        mocker.Mock(get_params=lambda: {}),
        mocker.Mock(get_params=lambda: {})
    )

    build_call_count = [0]

    def fake_get_build(cls, number):  # pylint: disable=unused-argument
        build_call_count[0] += 1
        return fake_builds[number - 1]

    monkeypatch.setattr(Job, 'get_first_buildnumber', lambda x: 1)
    monkeypatch.setattr(Job, 'get_last_buildnumber', lambda x: 3)
    monkeypatch.setattr(Job, 'get_build', fake_get_build)
    mocker.spy(Build, 'get_params')
    mocker.spy(Job, 'get_build')

    job = Job('http://localhost/jobs/foo', 'foo', jenkins)

    with pytest.raises(NoBuildData):
        job.get_build_by_params(build_params)

    assert job.get_build.call_count == 3
    assert build_call_count[0] == 3

def test_nobuilds_get_revision_dict(jenkins, monkeypatch):
    def fake_poll(cls, tree=None):  # pylint: disable=unused-argument
        return {"name": "foo"}

    monkeypatch.setattr(Job, '_poll', fake_poll)
    job = Job('http://halob:8080/job/foo/', 'foo', jenkins)
    with pytest.raises(NoBuildData):
        job.get_revision_dict()

def disable(j, name):
  """
  disabled a job
  """
  job_url = "%s/job/%s" % (j.baseurl, name)
  job = Job(job_url, name, j)
  result = job.disable()  
  print("result: %s" % result.status_code)

    def test_nobuilds_get_build_dict(self):
        j = Job(
            'http://halob:8080/job/look_ma_no_builds/',
            'look_ma_no_builds',
            self.J)

        ret = j.get_build_dict()
        self.assertTrue(isinstance(ret, dict))
        self.assertEqual(len(ret), 0)

 def test_empty_field__add_missing_builds(self, get_data):
     url = "http://halob:8080/job/foo/%s" % config.JENKINS_API
     data = TestJob.URL_DATA[url].copy()
     data.update({"firstBuild": None})
     get_data.return_value = data
     j = Job("http://halob:8080/job/foo/", "foo", self.J)
     initial_call_count = get_data.call_count
     j._add_missing_builds(data)
     self.assertEquals(get_data.call_count, initial_call_count)

 def test__add_missing_builds_no_builds(self, get_data):
     url = 'http://halob:8080/job/foo/%s' % config.JENKINS_API
     data = TestJob.URL_DATA[url].copy()
     get_data.return_value = data
     j = Job('http://halob:8080/job/foo/', 'foo', self.J)
     initial_call_count = get_data.call_count
     mock_data = TestJob.URL_DATA[url].copy()
     mock_data['builds'] = None
     j._add_missing_builds(mock_data)
     self.assertEquals(initial_call_count, get_data.call_count)

    def test_get_params_list(self, get_data):
        url = 'http://halob:8080/job/foo/%s' % config.JENKINS_API
        get_data.return_value = TestJob.URL_DATA[url].copy()
        j = Job('http://halob:8080/job/foo/', 'foo', self.J)

        params = j.get_params_list()

        self.assertIsInstance(params, list)
        self.assertEquals(len(params), 2)
        self.assertEquals(params, ['param1', 'param2'])

 def test__add_missing_builds_no_first_build(self, get_data):
     url = "http://halob:8080/job/foo/%s" % config.JENKINS_API
     data = TestJob.URL_DATA[url].copy()
     get_data.return_value = data
     j = Job("http://halob:8080/job/foo/", "foo", self.J)
     initial_call_count = get_data.call_count
     mock_data = TestJob.URL_DATA[url].copy()
     mock_data["firstBuild"] = None
     j._add_missing_builds(mock_data)
     self.assertEquals(initial_call_count, get_data.call_count)

 def iterkeys(self):
     """
     Iterate over the names of all available jobs
     """
     if not self._data:
         self._data = self.poll().get('jobs', [])
     for row in self._data:
         yield row['name']
         if row['name'] != \
             Job.get_full_name_from_url_and_baseurl(row['url'],
                                                    self.jenkins.baseurl):
             yield Job.get_full_name_from_url_and_baseurl(
                 row['url'], self.jenkins.baseurl)

 def getLastBuildInfo(self,server):
     try: 
         job_obj=Job(server.baseurl+"/job/"+self.data['builddf']['Name'],self.data['builddf']['Name'],server)
         last_bd=job_obj.get_last_build_or_none()
         self.logger.debug("The last build at %s is %s" % (server.baseurl, last_bd.name))
     except Exception, details:
         #sys.stderr.write('ERROR: %s \n' % details)
         #sys.exit(1)
         #x=inspect.stack()
         if 'test_' in inspect.stack()[1][3] or 'test_' in inspect.stack()[2][3]:
             raise
         else:
             #print Exception,details
             self.logger.error('ERROR: %s \n' % details,exc_info=True)
             sys.exit(1)

    def aget_job(self, name):
        self.load()
        url = self.rest.job(name)
        try:
            data = yield from url.api.python.aget()
        except aiohttp.errors.HttpProcessingError as e:
            if 404 == e.code:
                raise UnknownJob()
            raise

        instance = JenkinsJob(data['url'], data['name'], self._instance)
        instance._data = data
        payload = yield from url('config.xml').aget()
        instance._config = payload.data
        return Job.factory(instance)

 def test_incomplete_builds_list_will_call_jenkins_twice(self):
     # The job data contains only one build, so we expect that the
     # remaining jobs will be fetched automatically, and to have two calls
     # to the Jenkins API
     TestJobGetAllBuilds.__get_data_call_count = 0
     self.j = Job('http://halob:8080/job/foo/', 'foo', self.J)
     self.assertEqual(TestJobGetAllBuilds.__get_data_call_count, 2)

 def test__add_missing_builds_not_all_loaded(self, get_data):
     url = 'http://halob:8080/job/foo/%s' % config.JENKINS_API
     data = TestJob.URL_DATA[url].copy()
     get_data.return_value = data
     j = Job('http://halob:8080/job/foo/', 'foo', self.J)
     # to test this function we change data to not have one build
     # and set it to mark that firstBuild was not loaded
     # in that condition function will call j.get_data
     # and will use syntetic field 'allBuilds' to
     # repopulate 'builds' field with all builds
     mock_data = TestJob.URL_DATA[url].copy()
     mock_data['firstBuild'] = {'number': 1}
     del mock_data['builds'][-1]
     self.assertEquals(len(mock_data['builds']), 2)
     new_data = j._add_missing_builds(mock_data)
     self.assertEquals(len(new_data['builds']), 3)

 def test_get_json_for_single_param(self):
     params = {"B": "one two three"}
     expected = '{"parameter": {"name": "B", "value": "one two three"}, "statusCode": "303", "redirectTo": "."}'
     self.assertJsonEqual(
         Job.mk_json_from_build_parameters(params),
         expected
     )