def test_check_credentials(self):
""" Test Api.method rest submission """
ret_val = RequestRet(200, content='"OK"')
patch('requests.request', return_value=ret_val).start()
ret_val.status_code = 200
self.assertTrue(self.api.check_credential())
ret_val.status_code = 401
self.assertFalse(self.api.check_credential())
ret_val.status_code = 500
self.assertRaises(HTTPError, self.api.check_credential)
patch.stopall()
def test_check_credentials(self):
""" Test Api.method rest submission """
ret_val = RequestRet(200, content='"OK"')
patch('requests.request', return_value=ret_val).start()
ret_val.status_code = 200
self.assertTrue(self.api.check_credential())
ret_val.status_code = 401
self.assertFalse(self.api.check_credential())
ret_val.status_code = 500
self.assertRaises(HTTPError, self.api.check_credential)
patch.stopall()
def test__method_raw(self):
""" Run as Raw mode """
ret_val = RequestRet(content='text_only'.encode('utf-8'),
status_code=200)
with patch('requests.get', return_value=ret_val):
ret = rest.Api._method(self._url, raw=True)
self.assertEquals(ret, 'text_only'.encode('utf-8'))
def test__method_errors(self):
""" Test Api._method rest submission error cases """
# invalid status code
ret_val = RequestRet(content='return_text'.encode('utf-8'),
status_code=404)
with patch('requests.get', return_value=ret_val):
self.assertRaises(RuntimeError, rest.Api._method, self._url)
def test_ssh_key(self):
""" Test ssh keys get/set """
test_ssh_keys = '{"sshkey": ["test"]}'
test_ssh_keys_json = json.loads(test_ssh_keys)
ret_val = RequestRet(200, content=test_ssh_keys)
patch('requests.request', return_value=ret_val).start()
assert self.api.get_ssh_keys() == test_ssh_keys_json
assert self.api.set_ssh_keys(test_ssh_keys_json) is None
patch.stopall()
def test_method_errors(self):
""" Test Api.method rest submission error cases """
# invalid status code
ret_val = RequestRet(404, content='return_text')
with patch('requests.request', return_value=ret_val):
self.assertRaises(HTTPError, self.api.method, self._url)
# using older requests version fail because of json argument
with patch('requests.request', side_effect=TypeError()):
self.assertRaises(RuntimeError, self.api.method, self._url)
def test_get_experiment(self, w_exp_archive):
""" Test experiment.get_experiment """
arch_content = '\x42\x69'
ret_val = RequestRet(content=arch_content, status_code=200)
patch('requests.get', return_value=ret_val).start()
api = rest.Api('user', 'password')
ret = experiment.get_experiment(api, 123, option='data')
self.assertEquals(ret, 'Written')
w_exp_archive.assert_called_with(123, arch_content)
def test_method(self):
""" Test Api.method rest submission """
ret = {'test': 'val'}
ret_val = RequestRet(200, content=json_dumps(ret))
m_req = patch('requests.request', return_value=ret_val).start()
# pylint:disable=protected-access
_auth = self.api.auth
# call get
ret = self.api.method('page')
m_req.assert_called_with('get',
self._url + 'page',
files=None,
json=None,
auth=_auth)
self.assertEqual(ret, ret)
ret = self.api.method('page?1', 'get')
m_req.assert_called_with('get',
self._url + 'page?1',
files=None,
json=None,
auth=_auth)
self.assertEqual(ret, ret)
# call delete
ret = self.api.method('deeel', 'delete')
m_req.assert_called_with('delete',
self._url + 'deeel',
files=None,
json=None,
auth=_auth)
self.assertEqual(ret, ret)
# call post
ret = self.api.method('post_page', 'post', json={})
m_req.assert_called_with('post',
self._url + 'post_page',
files=None,
json={},
auth=_auth)
self.assertEqual(ret, ret)
# call multipart
_files = {'entry': '{}'}
ret = self.api.method('multip', 'post', files=_files)
m_req.assert_called_with('post',
self._url + 'multip',
files=_files,
json=None,
auth=_auth)
self.assertEqual(ret, ret)
patch.stopall()
def test_method_no_content(self):
""" Test Api.method rest code 204 """
ret_val = RequestRet(204, content='')
m_req = patch('requests.request', return_value=ret_val).start()
_auth = self.api.auth
ret = self.api.method('resources/123', 'delete')
m_req.assert_called_with('delete',
self._url + 'resources/123',
files=None,
json=None,
auth=_auth)
self.assertIsNone(ret)
def test__method(self):
""" Test Api._method rest submission """
ret = {'test': 'val'}
ret_val = RequestRet(content=json_dumps(ret).encode('utf-8'),
status_code=200)
post = patch('requests.post', return_value=ret_val).start()
delete = patch('requests.delete', return_value=ret_val).start()
get = patch('requests.get', return_value=ret_val).start()
# pylint:disable=protected-access
_auth = Mock()
# call get
ret = rest.Api._method(self._url)
get.assert_called_with(self._url, auth=None)
self.assertEquals(ret, ret)
ret = rest.Api._method(self._url, method='GET', auth=_auth)
get.assert_called_with(self._url, auth=_auth)
self.assertEquals(ret, ret)
# call delete
ret = rest.Api._method(self._url, method='DELETE')
delete.assert_called_with(self._url, auth=None)
self.assertEquals(ret, ret)
# call post
ret = rest.Api._method(self._url, method='POST', data={})
post.assert_called_with(
self._url, data='{}'.encode('utf-8'),
headers={'content-type': 'application/json'},
auth=None)
self.assertEquals(ret, ret)
# call multipart
_files = {'entry': '{}'}
ret = rest.Api._method(self._url, method='MULTIPART', data=_files)
post.assert_called_with(self._url, files=_files, auth=None)
self.assertEquals(ret, ret)
patch.stopall()
def test_method_raw(self):
""" Run as Raw mode """
ret_val = RequestRet(200, content='text_only')
with patch('requests.request', return_value=ret_val):
ret = self.api.method(self._url, raw=True)
self.assertEqual(ret, 'text_only'.encode('utf-8'))
