def test_rc_delete_with_failure(self, mock_literal_eval,
mock_rc_get_by_uuid,
mock_object_has_stack):
mock_rc = mock.MagicMock()
mock_rc.name = 'test-rc'
mock_rc.uuid = 'test-uuid'
mock_rc_get_by_uuid.return_value = mock_rc
mock_object_has_stack.return_value = True
with patch('magnum.conductor.k8s_api.create_k8s_api') as mock_kube_api:
err = error.HTTPError(url='fake',
msg='fake',
hdrs='fake',
fp=mock.MagicMock(),
code=500)
(mock_kube_api.return_value.deleteReplicationController.side_effect
) = err
mock_literal_eval.return_value = {'message': 'error'}
self.assertRaises(exception.KubernetesAPIFailed,
self.kube_handler.rc_delete, self.context,
mock_rc.uuid)
(mock_kube_api.return_value.deleteReplicationController.
assert_called_once_with(name=mock_rc.name, namespaces='default'))
self.assertFalse(mock_rc.destroy.called)
def test_rc_update_with_failure(self, mock_literal_eval):
expected_rc = self.mock_rc()
expected_rc.uuid = 'test-uuid'
expected_rc.name = 'test-name'
expected_rc.update = mock.MagicMock()
manifest = {"key": "value"}
expected_rc.manifest = '{"key": "value"}'
with patch('magnum.conductor.k8s_api.create_k8s_api') as mock_kube_api:
err = error.HTTPError(url='fake',
msg='fake',
hdrs='fake',
fp=mock.MagicMock(),
code=404)
(mock_kube_api.return_value.replaceReplicationController.
side_effect) = err
mock_literal_eval.return_value = {'message': 'error'}
self.assertRaises(exception.KubernetesAPIFailed,
self.kube_handler.rc_update, self.context,
expected_rc)
(mock_kube_api.return_value.replaceReplicationController.
assert_called_once_with(body=manifest,
name=expected_rc.name,
namespaces='default'))
self.assertFalse(expected_rc.update.called)
def test_request_with_general_exception(self):
hook = enas_utils.RequestSideEffect()
hook.append(ex=url_error.HTTPError(XML_CONN_TD.req_url(), 'error_code',
'fake_message', None, None))
self.XmlConnector.url_opener.open = mock.Mock(side_effect=hook)
self.assertRaises(exception.ManilaException, self.XmlConnector.request,
XML_CONN_TD.FAKE_BODY)
def test_get_csar_data_iter_unauthorised(self, mock_url_open):
mock_url_open.side_effect = urlerr.HTTPError(
url='',
code=401,
msg='HTTP Error 401 Unauthorized',
hdrs={},
fp=None)
self.assertRaises(exceptions.VNFPackageURLInvalid,
store.get_csar_data_iter, self.body)
def test_request_with_no_authorized_exception(self):
xml_socket = mock.Mock()
xml_socket.read = mock.Mock(return_value=XML_CONN_TD.FAKE_RESP)
hook = enas_utils.RequestSideEffect()
hook.append(ex=url_error.HTTPError(XML_CONN_TD.req_url(), '403',
'fake_message', None, None))
hook.append(xml_socket)
hook.append(xml_socket)
self.XmlConnector.url_opener.open = mock.Mock(side_effect=hook)
self.XmlConnector.request(XML_CONN_TD.FAKE_BODY)
def redirect_request(self, req, fp, code, msg, hdrs, newurl):
handler = maybe_add_ssl_handler(newurl, validate_certs)
if handler:
urllib_request._opener.add_handler(handler)
if follow_redirects == 'urllib2':
return urllib_request.HTTPRedirectHandler.redirect_request(
self, req, fp, code, msg, hdrs, newurl)
elif follow_redirects in ['no', 'none', False]:
raise urllib_error.HTTPError(newurl, code, msg, hdrs, fp)
do_redirect = False
if follow_redirects in ['all', 'yes', True]:
do_redirect = (code >= 300 and code < 400)
elif follow_redirects == 'safe':
m = req.get_method()
do_redirect = (code >= 300 and code < 400
and m in ('GET', 'HEAD'))
if do_redirect:
# be conciliant with URIs containing a space
newurl = newurl.replace(' ', '%20')
newheaders = dict(
(k, v) for k, v in req.headers.items()
if k.lower() not in ("content-length", "content-type"))
try:
# Python 2-3.3
origin_req_host = req.get_origin_req_host()
except AttributeError:
# Python 3.4+
origin_req_host = req.origin_req_host
return urllib_request.Request(newurl,
headers=newheaders,
origin_req_host=origin_req_host,
unverifiable=True)
else:
raise urllib_error.HTTPError(req.get_full_url(), code, msg,
hdrs, fp)
def test_upload_vnf_package_from_uri_with_invalid_auth(self,
mock_url_open):
address_information = "http://localhost/test.zip"
user_name = "username"
password = "******"
mock_url_open.side_effect = urlerr.HTTPError(
url='', code=401, msg='HTTP Error 401 Unauthorized', hdrs={},
fp=None)
self.assertRaises(exceptions.VNFPackageURLInvalid,
self.conductor.upload_vnf_package_from_uri,
self.context,
self.vnf_package,
address_information,
user_name=user_name,
password=password)
self.assertEqual('CREATED', self.vnf_package.onboarding_state)
def _request(self, uri, method="GET", *args, **kwargs):
""" Make a request and handle the return code.
Only accept 2XX HTTP Codes"""
client = self.get_client()
client.disable_ssl_certificate_validation = True
response, content = client.request(uri, method=method, *args, **kwargs)
if not response["status"].startswith("2"):
status = int(response["status"])
msg = "Request %s '%s' failed as (%s)" % (
method,
uri,
status,
)
raise error.HTTPError(uri, int(response["status"]), msg, response,
None)
return response, content
def http_error_401(self, req, fp, code, msg, headers):
logger.debug("INSIDE http_error_401")
try:
try:
krb_req = self._extract_krb_value(headers)
except ValueError:
# Negotiate header not found or a similar error
# we can't handle this, let the next handler have a go
return None
if not krb_req:
# First reply from server (no neg value)
self.tries = 0
krb_req = ""
else:
if self.tries > self.max_tries:
raise error.HTTPError(req.get_full_url(), 401,
"Negotiate auth failed", headers,
None)
self.tries += 1
try:
krb_resp = self._krb_response(req.get_host(), krb_req)
req.add_unredirected_header('Authorization',
"Negotiate %s" % krb_resp)
resp = self.parent.open(req, timeout=req.timeout)
self._authenticate_server(resp.headers)
return resp
except kerberos.GSSError as err:
try:
msg = err.args[1][0]
except Exception:
msg = "Negotiate auth failed"
logger.debug(msg)
return None # let the next handler (if any) have a go
finally:
if self.krb_context is not None:
kerberos.authGSSClientClean(self.krb_context)
self.krb_context = None
def test_pod_create_fail_on_existing_pod(self, mock_literal_eval):
expected_pod = self.mock_pod()
expected_pod.create = mock.MagicMock()
expected_pod.manifest = '{"key": "value"}'
with patch('magnum.conductor.k8s_api.create_k8s_api') as mock_kube_api:
err = error.HTTPError(url='fake',
msg='fake',
hdrs='fake',
fp=mock.MagicMock(),
code=409)
mock_kube_api.return_value.createPod.side_effect = err
mock_literal_eval.return_value = {'message': 'error'}
self.assertRaises(exception.KubernetesAPIFailed,
self.kube_handler.pod_create, self.context,
expected_pod)
self.assertEqual('failed', expected_pod.status)
self.assertFalse(expected_pod.create.called)
def test_service_create_with_failure(self, mock_literal_eval):
expected_service = self.mock_service()
expected_service.create = mock.MagicMock()
manifest = {"key": "value"}
expected_service.manifest = '{"key": "value"}'
with patch('magnum.conductor.k8s_api.create_k8s_api') as mock_kube_api:
err = error.HTTPError(url='fake',
msg='fake',
hdrs='fake',
fp=mock.MagicMock(),
code=404)
mock_kube_api.return_value.createService.side_effect = err
mock_literal_eval.return_value = {'message': 'error'}
self.assertRaises(exception.KubernetesAPIFailed,
self.kube_handler.service_create, self.context,
expected_service)
mock_kube_api.return_value.createService.assert_called_once_with(
body=manifest, namespaces='default')
self.assertFalse(expected_service.create.called)
def _test_provisioning_completed(self, mock_http_request,
mock_get_phone_url, mock_sleep,
fail=False):
fake_phone_url = 'fake_phone_url'
fake_response = 'fake_response'
if fail:
mock_http_request.side_effect = (
error.HTTPError(401, "invalid", {}, 0, 0))
with self.assertRaises(exception.MetadataEndpointException):
self._packet_service.provisioning_completed()
else:
mock_http_request.return_value = fake_response
mock_get_phone_url.return_value = fake_phone_url
response = self._packet_service.provisioning_completed()
mock_get_phone_url.assert_called_once()
mock_http_request.assert_called_once_with(
url=fake_phone_url,
method="post")
self.assertEqual(response, fake_response)
def test_service_delete_succeeds_when_not_found(self, mock_literal_eval,
mock_service_get_by_uuid,
mock_object_has_stack):
mock_service = mock.MagicMock()
mock_service.name = 'test-service'
mock_service.uuid = 'test-uuid'
mock_service_get_by_uuid.return_value = mock_service
mock_object_has_stack.return_value = True
with patch('magnum.conductor.k8s_api.create_k8s_api') as mock_kube_api:
err = error.HTTPError(url='fake',
msg='fake',
hdrs='fake',
fp=mock.MagicMock(),
code=404)
mock_kube_api.return_value.deleteService.side_effect = err
mock_literal_eval.return_value = {'message': 'error'}
self.kube_handler.service_delete(self.context, mock_service.uuid)
mock_kube_api.return_value.deleteService.assert_called_once_with(
name=mock_service.name, namespaces='default')
mock_service.destroy.assert_called_once_with(self.context)
def _test_post_password(self, mock_http_request,
mock_get_phone_url, mock_sleep, fail=False):
fake_phone_url = 'fake_phone_url'
fake_response = 'fake_response'
fake_encoded_password = b'fake_password'
if fail:
mock_http_request.side_effect = (
error.HTTPError(401, "invalid", {}, 0, 0))
with self.assertRaises(exception.MetadataEndpointException):
self._packet_service.post_password(fake_encoded_password)
else:
mock_http_request.return_value = fake_response
mock_get_phone_url.return_value = fake_phone_url
response = self._packet_service.post_password(
fake_encoded_password)
mock_get_phone_url.assert_called_once()
mock_http_request.assert_called_once_with(
data='{"password": "******"}',
url=fake_phone_url)
self.assertEqual(response, fake_response)
def test_get_response_fail_other_exception(self):
err = error.HTTPError("http://169.254.169.254/", 409, 'test error 409',
{}, None)
self._test_get_response(side_effect=err)
def test_get_response_fail_HTTPError(self):
err = error.HTTPError("http://169.254.169.254/", 404, 'test error 404',
{}, None)
self._test_get_response(side_effect=err)
def test_post_password_other_HTTPError(self):
err = error.HTTPError("http://169.254.169.254/", 404, 'test error 404',
{}, None)
self._test_post_password(ret_val=err)
def test_post_password_HTTPError_409(self):
err = error.HTTPError("http://169.254.169.254/", 409, 'test error 409',
{}, None)
self._test_post_password(ret_val=err)
def test_get_response_error_not_404(self):
err = error.HTTPError("http://169.254.169.254/", 409,
'test other error', {}, None)
self._test_get_response(ret_val=err)
def test_get_response_error_404(self):
err = error.HTTPError("http://169.254.169.254/", 404, 'test error 404',
{}, None)
self._test_get_response(ret_val=err)
def test_get_response_error_other(self):
err = error.HTTPError("http://169.254.169.254/", 409, 'test error 409',
{}, None)
self._test_get_response(ret_value=err)
def test_post_password_other_HTTPError(self):
err = error.HTTPError("https://api.service.softlayer.com/rest/v3.1/",
404, 'test error 404', {}, None)
self._test_post_password(ret_val=err)
