def test_get_request_dict_wrong_headers(self):
req = Requester('foo', 'bar')
with self.assertRaises(AssertionError) as na:
req.get_request_dict(params={}, data=None, headers='wrong')
self.assertTrue(
str(na.exception) == "headers must be a dict, got 'wrong'")
def test_post_xml_and_confirm_status_empty_xml(self, _post):
_post.return_value = mock.Mock()
req = Requester('foo', 'bar')
with self.assertRaises(AssertionError) as ae:
req.post_xml_and_confirm_status(url='http://dummy',
params={'param': 'value'},
data=None)
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_get_request_dict_auth():
req = Requester('foo', 'bar')
req_return = req.get_request_dict(params={}, data=None, headers=None)
assert isinstance(req_return, dict)
assert req_return.get('auth')
assert req_return['auth'] == ('foo', 'bar')
def test_get_url_post(self, _post):
_post.return_value = 'SUCCESS'
req = Requester('foo', 'bar')
response = req.post_url('http://dummy',
params={'param': 'value'},
headers=None)
self.assertTrue(response == 'SUCCESS')
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_url_get(self, _get):
_get.return_value = 'SUCCESS'
req = Requester('foo', 'bar')
response = req.get_url(
'http://dummy',
params={'param': 'value'},
headers=None)
self.assertEqual(response, 'SUCCESS')
def test_get_url_post(self, _post):
_post.return_value = 'SUCCESS'
req = Requester('foo', 'bar')
response = req.post_url(
'http://dummy',
params={'param': 'value'},
headers=None)
self.assertTrue(response == 'SUCCESS')
def test_get_request_dict_cookie():
req = Requester('foo', 'bar')
req_return = req.get_request_dict(params={}, data=None, headers=None)
assert isinstance(req_return, dict)
assert req_return.get('headers')
assert req_return.get('headers').get('Cookie')
assert req_return.get('headers').get('Cookie') == 'FAKE'
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_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_data_not_passed():
req = Requester('foo', 'bar')
req_return = req.get_request_dict(params={'param': 'value'},
data=None,
headers={'header': 'value'})
assert isinstance(req_return, dict)
assert req_return.get('data') is None
def test_post_xml_and_confirm_status_empty_xml(self, _post):
_post.return_value = mock.Mock()
req = Requester('foo', 'bar')
with self.assertRaises(AssertionError) as ae:
req.post_xml_and_confirm_status(
url='http://dummy',
params={'param': 'value'},
data=None
)
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_get_request_dict_data_not_passed(self):
req = Requester('foo', 'bar')
req_return = req.get_request_dict(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_get_request_dict_wrong_params(self):
req = Requester('foo', 'bar')
with self.assertRaises(AssertionError) as na:
req.get_request_dict(
params='wrong',
data=None,
headers=None
)
self.assertTrue(na.exception.message == "Params must be a dict, got 'wrong'")
def test_get_request_dict_correct_params(self):
req = Requester('foo', 'bar')
req_return = req.get_request_dict(params={'param': 'value'},
data=None,
headers=None)
self.assertTrue(isinstance(req_return, dict))
self.assertTrue(req_return.get('params'))
self.assertTrue(req_return['params'] == {'param': 'value'})
def test_get_request_dict_wrong_headers():
req = Requester('foo', 'bar')
with pytest.raises(AssertionError) as na:
req.get_request_dict(
params={},
data=None,
headers='wrong'
)
assert "headers must be a dict, got 'wrong'" in str(na.value)
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 data type: None')
def test_get_request_dict_wrong_headers(self):
req = Requester('foo', 'bar')
with self.assertRaises(AssertionError) as na:
req.get_request_dict(
params={},
data=None,
headers='wrong'
)
self.assertTrue(str(na.exception) == "headers must be a dict, got 'wrong'")
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_nocookie():
req = Requester('foo', 'bar')
req_return = req.get_request_dict(
params={},
data=None,
headers=None
)
assert isinstance(req_return, dict)
assert not req_return.get('headers')
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_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_correct_headers():
req = Requester('foo', 'bar')
req_return = req.get_request_dict(params={'param': 'value'},
data=None,
headers={'header': 'value'})
assert isinstance(req_return, dict)
assert req_return.get('headers')
assert req_return['headers'] == {'header': 'value'}
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_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(str(ae.exception) == "Unexpected type of parameter 'data': %s. Expected (str, dict)" % type(None))
def test_get_request_dict_auth():
req = Requester('foo', 'bar')
req_return = req.get_request_dict(
params={},
data=None,
headers=None
)
assert isinstance(req_return, dict)
assert req_return.get('auth')
assert req_return['auth'] == ('foo', 'bar')
def test_get_request_dict_data_not_passed():
req = Requester('foo', 'bar')
req_return = req.get_request_dict(
params={'param': 'value'},
data=None,
headers={'header': 'value'}
)
assert isinstance(req_return, dict)
assert req_return.get('data') is None
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', baseurl='http://dummy')
with self.assertRaises(JenkinsAPIException) as ae:
req.get_and_confirm_status(url='http://dummy',
params={'param': 'value'})
self.assertIsInstance(ae.exception, JenkinsAPIException)
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(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(monkeypatch):
def fake_post(*args, **kwargs): # pylint: disable=unused-argument
return 'SUCCESS'
monkeypatch.setattr(requests, 'post', fake_post)
req = Requester('foo', 'bar')
with pytest.raises(AssertionError):
req.post_and_confirm_status(url='http://dummy',
params={'param': 'value'},
data=None)
def test_get_request_dict_correct_params(self):
req = Requester('foo', 'bar')
req_return = req.get_request_dict(
params={'param': 'value'},
data=None,
headers=None
)
self.assertTrue(isinstance(req_return, dict))
self.assertTrue(req_return.get('params'))
self.assertEqual(req_return['params'], {'param': 'value'})
def test_get_url_post(monkeypatch):
def fake_post(*args, **kwargs): # pylint: disable=unused-argument
return 'SUCCESS'
monkeypatch.setattr(requests, 'post', fake_post)
req = Requester('foo', 'bar')
response = req.post_url('http://dummy',
params={'param': 'value'},
headers=None)
assert response == 'SUCCESS'
def test_get_request_dict_correct_headers():
req = Requester('foo', 'bar')
req_return = req.get_request_dict(
params={'param': 'value'},
data=None,
headers={'header': 'value'}
)
assert isinstance(req_return, dict)
assert req_return.get('headers')
assert req_return['headers'] == {'header': 'value'}
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', baseurl='http://dummy')
with self.assertRaises(JenkinsAPIException) as ae:
req.get_and_confirm_status(
url='http://dummy',
params={'param': 'value'}
)
self.assertIsInstance(ae.exception, JenkinsAPIException)
def test_post_and_confirm_status_empty_data(monkeypatch):
def fake_post(*args, **kwargs): # pylint: disable=unused-argument
return 'SUCCESS'
monkeypatch.setattr(requests, 'post', fake_post)
req = Requester('foo', 'bar')
with pytest.raises(AssertionError):
req.post_and_confirm_status(
url='http://dummy',
params={'param': 'value'},
data=None
)
def test_get_url_get(monkeypatch):
def fake_get(*args, **kwargs): # pylint: disable=unused-argument
return 'SUCCESS'
monkeypatch.setattr(requests, 'get', fake_get)
req = Requester('foo', 'bar')
response = req.get_url(
'http://dummy',
params={'param': 'value'},
headers=None)
assert response == 'SUCCESS'
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_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_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_request_dict_updatecookie():
req = Requester('foo', 'bar')
req_return = req.get_request_dict(
params={},
data=None,
headers={'key': 'value'}
)
assert isinstance(req_return, dict)
assert req_return.get('headers')
assert req_return.get('headers').get('key')
assert req_return.get('headers').get('key') == 'value'
assert req_return.get('headers').get('Cookie')
assert req_return.get('headers').get('Cookie') == 'FAKE'
def test_get_and_confirm_status(monkeypatch):
class FakeResponse(requests.Response):
def __init__(self, *args, **kwargs): # pylint: disable=unused-argument
self.status_code = 200
def fake_get(*args, **kwargs): # pylint: disable=unused-argument
return FakeResponse()
monkeypatch.setattr(requests, 'get', fake_get)
req = Requester('foo', 'bar')
ret = req.get_and_confirm_status(url='http://dummy',
params={'param': 'value'})
assert isinstance(ret, requests.Response)
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_xml_and_confirm_status_some_xml(monkeypatch):
class FakeResponse(requests.Response):
def __init__(self, *args, **kwargs): # pylint: disable=unused-argument
self.status_code = 200
def fake_post(*args, **kwargs): # pylint: disable=unused-argument
return FakeResponse()
monkeypatch.setattr(requests.Session, 'post', fake_post)
req = Requester('foo', 'bar')
ret = req.post_xml_and_confirm_status(url='http://dummy',
params={'param': 'value'},
data='<xml/>')
assert isinstance(ret, requests.Response)
def test_get_and_confirm_status_bad_result(monkeypatch):
class FakeResponse(object):
def __init__(self, *args, **kwargs): # pylint: disable=unused-argument
self.status_code = 500
self.url = 'http://dummy'
self.text = 'something'
def fake_get(*args, **kwargs): # pylint: disable=unused-argument
return FakeResponse()
monkeypatch.setattr(requests, 'get', fake_get)
req = Requester('foo', 'bar', baseurl='http://dummy')
with pytest.raises(JenkinsAPIException):
req.get_and_confirm_status(url='http://dummy',
params={'param': 'value'})
def test_get_and_confirm_status(monkeypatch):
class FakeResponse(requests.Response):
def __init__(self, *args, **kwargs): # pylint: disable=unused-argument
self.status_code = 200
def fake_get(*args, **kwargs): # pylint: disable=unused-argument
return FakeResponse()
monkeypatch.setattr(requests, 'get', fake_get)
req = Requester('foo', 'bar')
ret = req.get_and_confirm_status(
url='http://dummy',
params={'param': 'value'}
)
assert isinstance(ret, requests.Response)
def test_mix_five_unnamed_named_parameters():
req = Requester('foo', 'bar', False, 'foobar', 'http://dummy', timeout=5)
assert isinstance(req, Requester)
assert req.username == 'foo'
assert req.password == 'bar'
assert not req.ssl_verify
assert req.cert == 'foobar'
assert req.base_scheme == 'http', 'dummy'
assert req.timeout == 5
def test_no_parameters_uses_default_values():
req = Requester()
assert isinstance(req, Requester)
assert req.username is None
assert req.password is None
assert req.ssl_verify
assert req.cert is None
assert req.base_scheme is None
assert req.timeout == 10
def test_get_and_confirm_status_bad_result(monkeypatch):
class FakeResponse(object):
def __init__(self, *args, **kwargs): # pylint: disable=unused-argument
self.status_code = 500
self.url = 'http://dummy'
self.text = 'something'
def fake_get(*args, **kwargs): # pylint: disable=unused-argument
return FakeResponse()
monkeypatch.setattr(requests, 'get', fake_get)
req = Requester('foo', 'bar', baseurl='http://dummy')
with pytest.raises(JenkinsAPIException):
req.get_and_confirm_status(
url='http://dummy',
params={'param': 'value'}
)
def test_all_named_parameters():
req = Requester(username='******',
password='******',
ssl_verify=False,
cert='foobar',
baseurl='http://dummy',
timeout=5)
assert isinstance(req, Requester)
assert req.username == 'foo'
assert req.password == 'bar'
assert not req.ssl_verify
assert req.cert == 'foobar'
assert req.base_scheme == 'http', 'dummy'
assert req.timeout == 5
def get_jenkins_instance(server):
try:
if server.get('baseurl', '').split('//')[1] in servers:
return servers[server.get('baseurl', '').split('//')[1]]
connection = Jenkins(server.get('baseurl', ''),
requester=Requester(
username=server.get('username', ''),
password=server.get('pass_or_token', ''),
**server.get('extra', None)))
servers[server.get('baseurl', '').split('//')[1]] = connection
return connection
except requests.HTTPError as hte:
logger.exception(hte)
logger.warn("Failed to connect to {}".format(server.get('url', '')))
raise
def test_get_request_dict_wrong_headers():
req = Requester('foo', 'bar')
with pytest.raises(AssertionError) as na:
req.get_request_dict(params={}, data=None, headers='wrong')
assert "headers must be a dict, got 'wrong'" in str(na.value)
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')
