def test_get_jenkins_obj_from_url(mocker, monkeypatch):
def fake_jenkins_poll(cls, tree=None): # pylint: disable=unused-argument
return TWO_JOBS_DATA
def fake_job_poll(cls, tree=None): # pylint: disable=unused-argument
return {}
monkeypatch.setattr(JenkinsBase, '_poll', fake_jenkins_poll)
monkeypatch.setattr(Jenkins, '_poll', fake_jenkins_poll)
monkeypatch.setattr(Job, '_poll', fake_job_poll)
mock_requester = Requester(username='******', password='******')
mock_requester.post_xml_and_confirm_status = mocker.MagicMock(
return_value='')
jenkins = Jenkins('http://localhost:8080/',
username='******',
password='******',
requester=mock_requester)
new_jenkins = jenkins.get_jenkins_obj_from_url('http://localhost:8080/')
assert new_jenkins == jenkins
new_jenkins = jenkins.get_jenkins_obj_from_url('http://localhost:8080/foo')
assert new_jenkins != jenkins
def test_get_jenkins_obj_from_url(mocker, monkeypatch):
def fake_jenkins_poll(cls, tree=None): # pylint: disable=unused-argument
return TWO_JOBS_DATA
def fake_job_poll(cls, tree=None): # pylint: disable=unused-argument
return {}
monkeypatch.setattr(JenkinsBase, '_poll', fake_jenkins_poll)
monkeypatch.setattr(Jenkins, '_poll', fake_jenkins_poll)
monkeypatch.setattr(Job, '_poll', fake_job_poll)
mock_requester = Requester(username='******', password='******')
mock_requester.post_xml_and_confirm_status = mocker.MagicMock(
return_value=''
)
jenkins = Jenkins('http://localhost:8080/',
username='******', password='******',
requester=mock_requester)
new_jenkins = jenkins.get_jenkins_obj_from_url('http://localhost:8080/')
assert new_jenkins == jenkins
new_jenkins = jenkins.get_jenkins_obj_from_url('http://localhost:8080/foo')
assert new_jenkins != jenkins
def test_get_jenkins_obj(self, _base_poll, _poll, _job_poll):
_job_poll.return_value = {}
_poll.return_value = {
'jobs': [
{
'name': 'job_one',
'url': 'http://localhost:8080/job_one',
'color': 'blue'
},
{
'name': 'job_one',
'url': 'http://localhost:8080/job_one',
'color': 'blue'
},
]
}
_base_poll.return_value = _poll.return_value
mock_requester = Requester(username='******', password='******')
mock_requester.post_xml_and_confirm_status = mock.MagicMock(
return_value='')
J = Jenkins('http://localhost:8080/',
username='******',
password='******',
requester=mock_requester)
new_jenkins = J.get_jenkins_obj()
self.assertEquals(new_jenkins, J)
def test_create_new_job_fail(self, _base_poll, _poll, _job_poll):
_job_poll.return_value = {}
_poll.return_value = {
'jobs': [
{
'name': 'job_one',
'url': 'http://localhost:8080/job_one',
'color': 'blue'
},
{
'name': 'job_one',
'url': 'http://localhost:8080/job_one',
'color': 'blue'
},
]
}
_base_poll.return_value = _poll.return_value
mock_requester = Requester(username='******', password='******')
mock_requester.post_xml_and_confirm_status = mock.MagicMock(
return_value='')
J = Jenkins('http://localhost:8080/',
username='******',
password='******',
requester=mock_requester)
with self.assertRaises(JenkinsAPIException) as ar:
J.create_job('job_new', None)
self.assertEquals(str(ar.exception), 'Cannot create job job_new')
def test_get_jenkins_obj_from_url(self, _base_poll, _poll, _job_poll):
_job_poll.return_value = {}
_poll.return_value = {
'jobs': [
{'name': 'job_one',
'url': 'http://localhost:8080/job_one',
'color': 'blue'},
{'name': 'job_one',
'url': 'http://localhost:8080/job_one',
'color': 'blue'},
]
}
_base_poll.return_value = _poll.return_value
mock_requester = Requester(username='******', password='******')
mock_requester.post_xml_and_confirm_status = mock.MagicMock(
return_value='')
J = Jenkins('http://localhost:8080/',
username='******', password='******',
requester=mock_requester)
new_jenkins = J.get_jenkins_obj_from_url('http://localhost:8080/')
self.assertEquals(new_jenkins, J)
new_jenkins = J.get_jenkins_obj_from_url('http://localhost:8080/foo')
self.assertNotEquals(new_jenkins, J)
def test_create_view(self, _poll, _base_poll):
mock_requester = Requester(username='******', password='******')
mock_requester.get_url = mock.MagicMock(return_value='<div/>')
mock_requester.post_url = mock.MagicMock(return_value='')
_poll.return_value = {
'views': [
{
'name': 'All',
'url': 'http://localhost:8080/views/All'
},
{
'name': 'NewView',
'url': 'http://localhost:8080/views/NewView'
},
]
}
_base_poll.return_value = _poll.return_value
J = Jenkins('http://localhost:8080/',
username='******',
password='******',
requester=mock_requester)
new_view = J.views.create('NewView')
self.assertTrue(isinstance(new_view, View))
self.assertEquals(new_view.baseurl,
'http://localhost:8080/views/NewView')
def test_create_new_job_fail(self, _base_poll, _poll, _job_poll):
_job_poll.return_value = {}
_poll.return_value = {
'jobs': [
{'name': 'job_one',
'url': 'http://localhost:8080/job_one',
'color': 'blue'},
{'name': 'job_one',
'url': 'http://localhost:8080/job_one',
'color': 'blue'},
]
}
_base_poll.return_value = _poll.return_value
mock_requester = Requester(username='******', password='******')
mock_requester.post_xml_and_confirm_status = mock.MagicMock(
return_value='')
J = Jenkins('http://localhost:8080/',
username='******', password='******',
requester=mock_requester)
with self.assertRaises(JenkinsAPIException) as ar:
J.create_job('job_new', None)
self.assertEquals(str(ar.exception), 'Cannot create job job_new')
def test_get_url(self, _get):
_get.return_value = 'SUCCESS'
req = Requester('foo', 'bar')
self.assertTrue(
req.get_url('http://dummy',
params={'param': 'value'},
headers=None) == 'SUCCESS')
def test_reload(self, _poll):
mock_requester = Requester(username='******', password='******')
mock_requester.get_url = mock.MagicMock(return_value='')
J = Jenkins('http://localhost:8080/',
username='******', password='******',
requester=mock_requester)
J.poll()
def test_get_and_confirm_status(self, _get):
response = requests.Response()
response.status_code = 200
_get.return_value = response
req = Requester('foo', 'bar')
ret = req.get_and_confirm_status(url='http://dummy',
params={'param': 'value'})
self.assertTrue(isinstance(ret, requests.Response))
def test_get_request_dict_auth(self):
req = Requester('foo', 'bar')
req_return = req.get_request_dict(url='http://', params={}, data=None,
headers=None)
self.assertTrue(isinstance(req_return, dict))
self.assertTrue(req_return.get('auth'))
self.assertTrue(req_return['auth']==('foo', 'bar'))
def test_reload(self, _poll):
mock_requester = Requester(username='******', password='******')
mock_requester.get_url = mock.MagicMock(return_value='')
J = Jenkins('http://localhost:8080/',
username='******',
password='******',
requester=mock_requester)
J.poll()
def test_get_request_dict_wrong_headers(self):
req = Requester('foo', 'bar')
with self.assertRaises(AssertionError) as na:
req_return = req.get_request_dict(url='http://', params={},
data=None, headers='wrong')
self.assertTrue(
na.exception.message=="headers must be a dict, got 'wrong'")
def test_get_and_confirm_status(self, _get):
response = requests.Response()
response.status_code = 200
_get.return_value = response
req = Requester('foo', 'bar')
ret = req.get_and_confirm_status(
url='http://dummy',
params={'param': 'value'})
self.assertTrue(isinstance(ret, requests.Response))
def test_get_request_dict_data_not_passed(self):
req = Requester('foo', 'bar')
req_return = req.get_request_dict(url='http://',
params={'param': 'value'},
data=None, headers={'header': 'value'})
self.assertTrue(isinstance(req_return, dict))
self.assertFalse(req_return.get('data'))
def test_post_and_confirm_status_some_data(self, _post):
response = requests.Response()
response.status_code = 200
_post.return_value = response
req = Requester('foo', 'bar')
ret = req.post_and_confirm_status(url='http://dummy',
params={'param': 'value'},
data='some data')
self.assertTrue(isinstance(ret, requests.Response))
def test_post_xml_and_confirm_status_empty_xml(self, _post):
_post.return_value = 'SUCCESS'
req = Requester('foo', 'bar')
with self.assertRaises(AssertionError) as ae:
req.post_xml_and_confirm_status(
url='http://dummy',
params={'param': 'value'},
data=None)
self.assertTrue(ae.exception.message=="Unexpected type of parameter 'data': <type 'NoneType'>. Expected (str, dict)")
def test_get_request_dict_wrong_headers(self):
req = Requester('foo', 'bar')
with self.assertRaises(AssertionError) as na:
req_return = req.get_request_dict(url='http://',
params={},
data=None,
headers='wrong')
self.assertTrue(
na.exception.message == "headers must be a dict, got 'wrong'")
def test_get_request_dict_correct_headers(self):
req = Requester('foo', 'bar')
req_return = req.get_request_dict(url='http://',
params={'param': 'value'},
data=None, headers={'header': 'value'})
self.assertTrue(isinstance(req_return, dict))
self.assertTrue(req_return.get('headers'))
self.assertTrue(req_return['headers']=={'header': 'value'})
def test_post_and_confirm_status_some_data(self, _post):
response = requests.Response()
response.status_code = 200
_post.return_value = response
req = Requester('foo', 'bar')
ret = req.post_and_confirm_status(
url='http://dummy',
params={'param': 'value'},
data='some data')
self.assertTrue(isinstance(ret, requests.Response))
def test_get_request_dict_auth(self):
req = Requester('foo', 'bar')
req_return = req.get_request_dict(url='http://',
params={},
data=None,
headers=None)
self.assertTrue(isinstance(req_return, dict))
self.assertTrue(req_return.get('auth'))
self.assertTrue(req_return['auth'] == ('foo', 'bar'))
def test_get_request_dict_data_not_passed(self):
req = Requester('foo', 'bar')
req_return = req.get_request_dict(url='http://',
params={'param': 'value'},
data=None,
headers={'header': 'value'})
self.assertTrue(isinstance(req_return, dict))
self.assertFalse(req_return.get('data'))
def test_get_version_nonexistent(self, _base_poll, _poll):
class MockResponse(object):
def __init__(self):
self.headers = {}
base_url = 'http://localhost:8080'
mock_requester = Requester(username='******', password='******')
mock_requester.get_and_confirm_status = mock.MagicMock(return_value=MockResponse())
J = Jenkins(base_url,
username='******', password='******',
requester=mock_requester)
self.assertEquals('0.0', J.version)
def test_get_request_dict_correct_headers(self):
req = Requester('foo', 'bar')
req_return = req.get_request_dict(url='http://',
params={'param': 'value'},
data=None,
headers={'header': 'value'})
self.assertTrue(isinstance(req_return, dict))
self.assertTrue(req_return.get('headers'))
self.assertTrue(req_return['headers'] == {'header': 'value'})
def test_get_request_dict_data_passed(self):
req = Requester('foo', 'bar')
req_return = req.get_request_dict(url='http://',
params={'param': 'value'},
data='some data', headers={'header': 'value'})
self.assertTrue(isinstance(req_return, dict))
print req_return.get('data')
self.assertTrue(req_return.get('data'))
self.assertTrue(req_return['data']=='some data')
def test_get_request_dict_data_passed(self):
req = Requester('foo', 'bar')
req_return = req.get_request_dict(url='http://',
params={'param': 'value'},
data='some data',
headers={'header': 'value'})
self.assertTrue(isinstance(req_return, dict))
print req_return.get('data')
self.assertTrue(req_return.get('data'))
self.assertTrue(req_return['data'] == 'some data')
def test_post_and_confirm_status_empty_data(self, _post):
_post.return_value = 'SUCCESS'
req = Requester('foo', 'bar')
with self.assertRaises(AssertionError) as ae:
req.post_and_confirm_status(url='http://dummy',
params={'param': 'value'},
data=None)
self.assertTrue(
ae.exception.message ==
"Unexpected type of parameter 'data': <type 'NoneType'>. Expected (str, dict)"
)
def test_get_and_confirm_status_bad_result(self, _get):
response = requests.Response()
response.status_code = 500
_get.return_value = response
req = Requester('foo', 'bar')
with self.assertRaises(JenkinsAPIException) as ae:
req.get_and_confirm_status(
url='http://dummy',
params={'param': 'value'})
print ae.exception.message
self.assertTrue(ae.exception.message=="Operation failed. url=None, headers=None, status=500, text=")
def test_get_version_nonexistent(mocker):
class MockResponse(object):
status_code = 200
headers = {}
text = '{}'
mock_requester = Requester(username='******', password='******')
mock_requester.get_url = mocker.MagicMock(return_value=MockResponse())
jenkins = Jenkins('http://localhost:8080',
username='******',
password='******',
requester=mock_requester)
assert jenkins.version == '0.0'
def test_get_and_confirm_status_bad_result(self, _get):
response = requests.Response()
response.status_code = 500
_get.return_value = response
req = Requester('foo', 'bar')
with self.assertRaises(JenkinsAPIException) as ae:
req.get_and_confirm_status(url='http://dummy',
params={'param': 'value'})
print ae.exception.message
self.assertTrue(
ae.exception.message ==
"Operation failed. url=None, headers=None, status=500, text=")
def test_create_new_job(self, _poll, _job_poll):
_job_poll.return_value = {}
mock_requester = Requester(username='******', password='******')
mock_requester.post_xml_and_confirm_status = mock.MagicMock(return_value='')
J = Jenkins('http://localhost:8080/',
username='******', password='******',
requester=mock_requester)
job = J.create_job('job_new', None)
self.assertTrue(isinstance(job, Job))
self.assertTrue(job.baseurl == 'http://localhost:8080/job_new')
self.assertTrue(job.name == 'job_new')
def test_get_version_nonexistent(mocker):
class MockResponse(object):
status_code = 200
headers = {}
text = '{}'
mock_requester = Requester(username='******', password='******')
mock_requester.get_url = mocker.MagicMock(
return_value=MockResponse()
)
jenkins = Jenkins('http://localhost:8080',
username='******', password='******',
requester=mock_requester)
assert jenkins.version == '0.0'
def test_get_version_nonexistent(self, _base_poll, _poll):
class MockResponse(object):
def __init__(self):
self.headers = {}
base_url = 'http://localhost:8080'
mock_requester = Requester(username='******', password='******')
mock_requester.get_and_confirm_status = mock.MagicMock(
return_value=MockResponse())
J = Jenkins(base_url,
username='******',
password='******',
requester=mock_requester)
self.assertEquals('0.0', J.version)
def test_post_and_confirm_status_bad_result(self, _post):
response = requests.Response()
response.status_code = 500
_post.return_value = response
req = Requester('foo', 'bar')
with self.assertRaises(JenkinsAPIException) as ae:
req.post_and_confirm_status(
url='http://dummy',
params={'param': 'value'},
data='some data')
print ae.exception.message
self.assertTrue(ae.exception.message=="Operation failed. url=None, data=some data, headers={'Content-Type': 'application/x-www-form-urlencoded'}, status=500, text=")
def test_post_and_confirm_status_bad_result(self, _post):
response = requests.Response()
response.status_code = 500
_post.return_value = response
req = Requester('foo', 'bar')
with self.assertRaises(JenkinsAPIException) as ae:
req.post_and_confirm_status(url='http://dummy',
params={'param': 'value'},
data='some data')
print ae.exception.message
self.assertTrue(
ae.exception.message ==
"Operation failed. url=None, data=some data, headers={'Content-Type': 'application/x-www-form-urlencoded'}, status=500, text="
)
def __init__(self,
baseurl,
username=None,
password=None,
requester=None,
lazy=False,
ssl_verify=True,
cert=None,
timeout=10,
use_baseurl=False):
"""
:param baseurl: baseurl for jenkins instance including port, str
:param username: username for jenkins auth, str
:param password: password for jenkins auth, str
:param requester: , Requester
:param lazy: delay polling of data, bool
:param ssl_verify: requests lib Verify SSL (See requests lib), bool.
:param cert: requests lib certificate (See requests lib), String or tuple.
:param timeout: requests lib timeout (See requests lib), float or tuple.
:param use_baseurl: If jenkins baseurl is diff from job url, use jenkins baseurl, bool.
:return: a Jenkins obj
"""
self.username = username
self.password = password
self.requester = requester or Requester(username,
password,
baseurl=baseurl,
ssl_verify=ssl_verify,
cert=cert,
timeout=timeout)
self.requester.timeout = timeout
self.lazy = lazy
self.jobs_container = None
self.use_baseurl = use_baseurl
JenkinsBase.__init__(self, baseurl, poll=not lazy)
def test_create_view(self, _poll, _base_poll):
mock_requester = Requester(username="******", password="******")
mock_requester.get_url = mock.MagicMock(return_value="<div/>")
mock_requester.post_url = mock.MagicMock(return_value="")
_poll.return_value = {
"views": [
{"name": "All", "url": "http://localhost:8080/views/All"},
{"name": "NewView", "url": "http://localhost:8080/views/NewView"},
]
}
_base_poll.return_value = _poll.return_value
J = Jenkins("http://localhost:8080/", username="******", password="******", requester=mock_requester)
new_view = J.views.create("NewView")
self.assertTrue(isinstance(new_view, View))
self.assertEquals(new_view.baseurl, "http://localhost:8080/views/NewView")
def test_create_new_job(self, _poll, _job_poll):
_job_poll.return_value = {}
mock_requester = Requester(username='******', password='******')
mock_requester.post_xml_and_confirm_status = mock.MagicMock(
return_value='')
J = Jenkins('http://localhost:8080/',
username='******',
password='******',
requester=mock_requester)
job = J.create_job('job_new', None)
self.assertTrue(isinstance(job, Job))
self.assertTrue(job.baseurl == 'http://localhost:8080/job_new')
self.assertTrue(job.name == 'job_new')
def __init__(self,
baseurl,
username=None,
password=None,
requester=None,
lazy=False,
ssl_verify=True,
timeout=10):
"""
:param baseurl: baseurl for jenkins instance including port, str
:param username: username for jenkins auth, str
:param password: password for jenkins auth, str
:return: a Jenkins obj
"""
self.username = username
self.password = password
self.requester = requester or Requester(username,
password,
baseurl=baseurl,
ssl_verify=ssl_verify,
timeout=timeout)
self.requester.timeout = timeout
self.lazy = lazy
self.jobs_container = None
JenkinsBase.__init__(self, baseurl, poll=not lazy)
def test_create_view(self, _poll, _base_poll):
mock_requester = Requester(username='******', password='******')
mock_requester.get_url = mock.MagicMock(return_value='<div/>')
mock_requester.post_url = mock.MagicMock(return_value='')
_poll.return_value = {'views': [
{'name': 'All',
'url': 'http://localhost:8080/views/All'},
{'name': 'NewView',
'url': 'http://localhost:8080/views/NewView'},
]}
_base_poll.return_value = _poll.return_value
J = Jenkins('http://localhost:8080/',
username='******', password='******',
requester=mock_requester)
new_view = J.views.create('NewView')
self.assertTrue(isinstance(new_view, View))
self.assertEquals(new_view.baseurl,
'http://localhost:8080/views/NewView')
def test_get_master_data(mocker):
class MockResponse(object):
status_code = 200
headers = {}
text = '{}'
mock_requester = Requester(username='******', password='******')
mock_requester.get_url = mocker.MagicMock(return_value=MockResponse())
jenkins = Jenkins('http://localhost:808',
username='******',
password='******',
requester=mock_requester)
jenkins.get_data = mocker.MagicMock(return_value={
"busyExecutors": 59,
"totalExecutors": 75
})
data = jenkins.get_master_data()
assert data['busyExecutors'] == 59
assert data['totalExecutors'] == 75
def __init__(self, baseurl, username=None, password=None, requester=None):
"""
:param baseurl: baseurl for jenkins instance including port, str
:param username: username for jenkins auth, str
:param password: password for jenkins auth, str
:return: a Jenkins obj
"""
self.username = username
self.password = password
self.requester = requester or Requester(username, password)
JenkinsBase.__init__(self, baseurl)
def get_instance():
global instance
if instance is None:
instance = jenkinsapi.jenkins.Jenkins(get_default_server(),
get_jenkins_user(),
get_jenkins_token(),
requester=Requester(
get_jenkins_user(),
get_jenkins_token(),
baseurl=get_default_server(),
ssl_verify=False))
return instance
def get_request_dict(self, url, params, data, headers):
req_dict = Requester(self,
url=url,
params=params,
data=data,
headers=headers)
if self.mutual_auth:
auth = HTTPKerberosAuth(self.mutual_auth)
else:
auth = HTTPKerberosAuth()
req_dict['auth'] = auth
return req_dict
def test_get_master_data(mocker):
class MockResponse(object):
status_code = 200
headers = {}
text = '{}'
mock_requester = Requester(username='******', password='******')
mock_requester.get_url = mocker.MagicMock(
return_value=MockResponse()
)
jenkins = Jenkins('http://localhost:808',
username='******', password='******',
requester=mock_requester)
jenkins.get_data = mocker.MagicMock(
return_value={
"busyExecutors": 59,
"totalExecutors": 75
}
)
data = jenkins.get_master_data()
assert data['busyExecutors'] == 59
assert data['totalExecutors'] == 75
def test_create_multibranch_pipeline_job(mocker, monkeypatch):
def fake_jenkins_poll(cls, tree=None): # pylint: disable=unused-argument
# return multibranch jobs and other jobs.
# create_multibranch_pipeline_job is supposed to filter out the MULTIBRANCH jobs
return {
'jobs': TWO_JOBS_DATA['jobs'] + MULTIBRANCH_JOBS_DATA['jobs']
}
def fake_job_poll(cls, tree=None): # pylint: disable=unused-argument
return {}
monkeypatch.setattr(JenkinsBase, '_poll', fake_jenkins_poll)
monkeypatch.setattr(Jenkins, '_poll', fake_jenkins_poll)
monkeypatch.setattr(Job, '_poll', fake_job_poll)
mock_requester = Requester(username='******', password='******')
mock_requester.post_xml_and_confirm_status = mocker.MagicMock(
return_value=''
)
mock_requester.post_and_confirm_status = mocker.MagicMock(
return_value=''
)
get_response = namedtuple('get_response', 'text')
mock_requester.get_url = mocker.MagicMock(
return_value=get_response(text=SCAN_MULTIBRANCH_PIPELINE_LOG)
)
jenkins = Jenkins('http://localhost:8080/',
username='******', password='******',
requester=mock_requester)
jobs = jenkins.create_multibranch_pipeline_job("multibranch-repo", "multibranch-xml-content")
for idx, job_instance in enumerate(jobs):
assert job_instance.name == MULTIBRANCH_JOBS_DATA['jobs'][idx]['name']
# make sure we didn't get more jobs.
assert len(MULTIBRANCH_JOBS_DATA['jobs']) == len(jobs)
def test_create_new_job_fail(mocker, monkeypatch):
def fake_jenkins_poll(cls, tree=None): # pylint: disable=unused-argument
return TWO_JOBS_DATA
def fake_job_poll(cls, tree=None): # pylint: disable=unused-argument
return {}
monkeypatch.setattr(JenkinsBase, '_poll', fake_jenkins_poll)
monkeypatch.setattr(Jenkins, '_poll', fake_jenkins_poll)
monkeypatch.setattr(Job, '_poll', fake_job_poll)
mock_requester = Requester(username='******', password='******')
mock_requester.post_xml_and_confirm_status = mocker.MagicMock(
return_value='')
jenkins = Jenkins('http://localhost:8080/',
username='******',
password='******',
requester=mock_requester)
with pytest.raises(JenkinsAPIException) as ar:
jenkins.create_job('job_new', None)
assert 'Job XML config cannot be empty' in str(ar.value)
def test_create_new_job_fail(mocker, monkeypatch):
def fake_jenkins_poll(cls, tree=None): # pylint: disable=unused-argument
return TWO_JOBS_DATA
def fake_job_poll(cls, tree=None): # pylint: disable=unused-argument
return {}
monkeypatch.setattr(JenkinsBase, '_poll', fake_jenkins_poll)
monkeypatch.setattr(Jenkins, '_poll', fake_jenkins_poll)
monkeypatch.setattr(Job, '_poll', fake_job_poll)
mock_requester = Requester(username='******', password='******')
mock_requester.post_xml_and_confirm_status = mocker.MagicMock(
return_value=''
)
jenkins = Jenkins('http://localhost:8080/',
username='******', password='******',
requester=mock_requester)
with pytest.raises(JenkinsAPIException) as ar:
jenkins.create_job('job_new', None)
assert 'Job XML config cannot be empty' in str(ar.value)
def test_reload(monkeypatch):
class FakeResponse(object):
status_code = 200
text = '{}'
def fake_get_url(
url, # pylint: disable=unused-argument
params=None, # pylint: disable=unused-argument
headers=None, # pylint: disable=unused-argument
allow_redirects=True, # pylint: disable=unused-argument
stream=False): # pylint: disable=unused-argument
return FakeResponse()
monkeypatch.setattr(Requester, 'get_url', fake_get_url)
mock_requester = Requester(username='******', password='******')
jenkins = Jenkins('http://localhost:8080/',
username='******',
password='******',
requester=mock_requester)
jenkins.poll()
import jenkinsapi
from jenkinsapi.jenkins import Jenkins
from jenkinsapi.utils.requester import Requester
import json
J = Jenkins('http://20.26.20.103:8800',
requester=Requester('devops103', 'devops103'))
# print J.version, J.keys()
# print dir(J['adcloud-coach-fe'])
job_name = 'adcloud-coach-fe'
build = J[job_name].get_last_build()
print '[%s] #%s: %s' % (job_name, build.get_number(), build.get_status())
def __init__(self, **kwargs):
self.opener = urllib2.build_opener(urllib2.HTTPCookieProcessor)
urllib2.install_opener(self.opener)
Requester.__init__(self, **kwargs)
import requests
from jenkinsapi.jenkins import Jenkins
from jenkinsapi.utils.requester import Requester
requests.packages.urllib3.disable_warnings()
log_level = getattr(logging, 'DEBUG')
logging.basicConfig(level=log_level)
logger = logging.getLogger()
jenkins_url = "http://localhost:8080/"
username = "******" # In case Jenkins requires authentication
password = "******"
jenkins = Jenkins(jenkins_url,
requester=Requester(username,
password,
baseurl=jenkins_url,
ssl_verify=False))
# Create JNLP(Java Webstart) slave
node_dict = {
'num_executors': 1, # Number of executors
'node_description': 'Test JNLP Node', # Just a user friendly text
'remote_fs': '/tmp', # Remote workspace location
'labels': 'my_new_node', # Space separated labels string
'exclusive': True # Only run jobs assigned to it
}
new_jnlp_node = jenkins.nodes.create_node('My new webstart node', node_dict)
node_dict = {
'num_executors':
1,
def test_get_url(self, _post):
_post.return_value = 'SUCCESS'
req = Requester('foo', 'bar')
self.assertTrue(req.post_url('http://dummy',
params={'param': 'value'},
headers=None)=='SUCCESS')
