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)