def test_parse_response_500_failure(self): self._requests_response.raise_for_status.side_effect = HTTPError() self._requests_response.status_code = 500 with self.assertRaises(HTTPError): self._transport._parse_response(self._requests_response)
def raise_for_status(self): if self.status != 200: raise HTTPError('Not 200 Client Error')
def raise_http_error(): x = Response() x.status_code = 404 x.reason = err raise HTTPError(err, response=x)
def _push_loop(self): while True: msg = self._queue.get() LOG.debug('{} - push_loop dequeued first indicator {!r}'.format( self.name, msg)) artifacts = [] artifacts.append(msg) try: while len(artifacts) < MAX_BATCH_SIZE: m = self._queue.get_nowait() artifacts.append(m) LOG.debug( '{} - push_loop dequeued additional indicator {!r}'. format(self.name, m)) except Empty: pass # Determine which indicators must be added and which ones must be deleted indicatorsToDelete = deque() indicatorsToCreateUpdate = deque() for i in artifacts: if 'expirationDateTime' in i and i[ 'expirationDateTime'] == EXPIRED: indicatorsToDelete.append(i) else: indicatorsToCreateUpdate.append(i) LOG.info( '{} - _push_loop has a total of {} indicators to create/update and {} to delete' .format(self.name, len(indicatorsToCreateUpdate), len(indicatorsToDelete))) # Retry loop for pushing/deleting indicators while True: retries = 0 try: # Get authentication token first token = self._get_auth_token() LOG.debug('{} - token: {}'.format(self.name, token)) # Delete expired indicators before creating new ones if len(indicatorsToDelete) > 0: LOG.debug('{} - Deleting {} indicators'.format( self.name, len(indicatorsToDelete))) try: self._delete_indicators( token=token, indicators=indicatorsToDelete) # Indicators successfully deleted, empty the list indicatorsToDelete = [] # HTTP Error to track 4xx during the delete phase, with no retry except HTTPError as e: LOG.debug( '{} - error deleting indicators - {}'.format( self.name, str(e))) status_code = e.response.status_code # If it's a 4xx, don't retry, else throw it up and go in the retry loop if status_code >= 400 and status_code < 500: LOG.error( '{}: {} error in delete request - {}'. format(self.name, status_code, e.response.text)) self.statistics['error.invalid_request'] += 1 # this way it will continue to the create/update phase without retrying the delete in the next loop indicatorsToDelete = [] else: raise HTTPError(e) # SecurityGraph response error shouldn't trigger a retry except SecurityGraphResponseException as e: LOG.exception( '{} - Graph Security API error deleting indicators - {}' .format(self.name, str(e))) self.statistics['error.submit'] += 1 break if len(indicatorsToCreateUpdate) > 0: LOG.debug( '{} - Creating/Updating {} indicators'.format( self.name, len(indicatorsToCreateUpdate))) try: self._push_indicators( token=token, indicators=indicatorsToCreateUpdate) # HTTP Error to track 4xx during the delete phase, with no retry except HTTPError as e: LOG.debug( '{} - error creating/updating indicators - {}'. format(self.name, str(e))) status_code = e.response.status_code # If it's a 4xx, don't retry, else throw it up and go in the retry loop if status_code >= 400 and status_code < 500: LOG.error( '{}: {} error in create/update request - {}' .format(self.name, status_code, e.response.text)) self.statistics['error.invalid_request'] += 1 # this way it will continue to the delete phase without retrying the create in the next loop indicatorsToCreateUpdate = [] else: raise HTTPError(e) # SecurityGraph response error shouldn't trigger a retry except SecurityGraphResponseException as e: LOG.exception( '{} - Graph Securty API error creating/updating indicators - {}' .format(self.name, str(e))) self.statistics['error.submit'] += 1 break # Successful loop break # Graceful Exit except gevent.GreenletExit: return # Authentication error during token generation except AuthConfigException as e: LOG.exception( '{} - Error submitting indicators - {}'.format( self.name, str(e))) self.statistics['error.submit'] += 1 gevent.sleep(60.0) # Other error, implement a retry logic # Note that if this hits during the delete phase, the createUpdate is never triggered except Exception as e: LOG.exception( '{} - error submitting indicators - {}'.format( self.name, str(e))) self.statistics['error.submit'] += 1 retries += 1 if retries > 5: break gevent.sleep(120.0) gevent.sleep(0.1)
def get_text_from_url(url): res = requests.get(url) if res.status_code in (200, 304): return res.text raise HTTPError(res)
def __call__(self, query, *args, **kwargs): raise HTTPError(response=self.response)
def raise_for_status(): if not 200 <= response.status_code < 400: raise HTTPError(response.status_code)
def test_upload_large_file(self, mock_element_contains_error): """ Test the upload_large_file function """ mock_element_contains_error.return_value = False # Succeed when calling the upload_large_file function and the api call # gets a valid response with patch.object( UploadAPI, "http_post", return_value=test_constants. VALID_UPLOAD_API_UPLOADLARGEFILE_RESPONSE_XML["bytes"], ): # Policy scan upload_api = UploadAPI( app_id=test_constants.VALID_UPLOAD_API["app_id"]) valid_artifact = test_constants.VALID_FILE["Path"] with patch( "veracode.submit_artifacts.open", new=mock_open( read_data=test_constants.VALID_FILE["bytes"]), ): self.assertTrue( submit_artifacts.upload_large_file( upload_api=upload_api, artifact=valid_artifact)) # Sandbox scan upload_api = UploadAPI( app_id=test_constants.VALID_UPLOAD_API["app_id"]) upload_api.sandbox_id = "12345" valid_artifact = test_constants.VALID_FILE["Path"] with patch( "veracode.submit_artifacts.open", new=mock_open( read_data=test_constants.VALID_FILE["bytes"]), ): self.assertTrue( submit_artifacts.upload_large_file( upload_api=upload_api, artifact=valid_artifact)) # Fail when calling the upload_large_file function and the api call # raises a HTTPError with patch.object( UploadAPI, "http_post", return_value=test_constants. VALID_UPLOAD_API_UPLOADLARGEFILE_RESPONSE_XML["bytes"], side_effect=HTTPError(), ): # Policy scan upload_api = UploadAPI( app_id=test_constants.VALID_UPLOAD_API["app_id"]) valid_artifact = test_constants.VALID_FILE["Path"] with patch( "veracode.submit_artifacts.open", new=mock_open( read_data=test_constants.VALID_FILE["bytes"]), ): self.assertRaises( HTTPError, submit_artifacts.upload_large_file, upload_api=upload_api, artifact=valid_artifact, ) # Sandbox scan upload_api = UploadAPI( app_id=test_constants.VALID_UPLOAD_API["app_id"]) upload_api.sandbox_id = "12345" valid_artifact = test_constants.VALID_FILE["Path"] with patch( "veracode.submit_artifacts.open", new=mock_open( read_data=test_constants.VALID_FILE["bytes"]), ): self.assertRaises( HTTPError, submit_artifacts.upload_large_file, upload_api=upload_api, artifact=valid_artifact, )
def test_create_build(self): """ Test the create_build function """ # Test the create_build function when the api call gets a valid response with patch.object( UploadAPI, "http_post", return_value=test_constants. VALID_UPLOAD_API_CREATEBUILD_RESPONSE_XML["Element"], ): with patch("veracode.submit_artifacts.element_contains_error", return_value=False): # Policy scan, no error in response body upload_api = UploadAPI( app_id=test_constants.VALID_UPLOAD_API["app_id"]) self.assertTrue( submit_artifacts.create_build(upload_api=upload_api)) # Sandbox scan, no error in response body upload_api = UploadAPI( app_id=test_constants.VALID_UPLOAD_API["app_id"]) upload_api.sandbox_id = "12345" self.assertTrue( submit_artifacts.create_build(upload_api=upload_api)) # Fail when the create_build function gets a response containing an # error in the response body with patch("veracode.submit_artifacts.element_contains_error", return_value=True): # Policy scan, response body contains error upload_api = UploadAPI( app_id=test_constants.VALID_UPLOAD_API["app_id"]) self.assertFalse( submit_artifacts.create_build(upload_api=upload_api)) # Sandbox scan, response body contains error upload_api = UploadAPI( app_id=test_constants.VALID_UPLOAD_API["app_id"]) upload_api.sandbox_id = "12345" self.assertFalse( submit_artifacts.create_build(upload_api=upload_api)) # Fail when calling the create_build function and the api call gets a # mocked error message response and a mocked side effect of HTTPError with patch.object( UploadAPI, "http_post", return_value=test_constants. VERACODE_ERROR_RESPONSE_XML["Element"], side_effect=HTTPError(), ): with patch("veracode.submit_artifacts.element_contains_error", return_value=False): # Policy scan, no error in response body upload_api = UploadAPI( app_id=test_constants.VALID_UPLOAD_API["app_id"]) self.assertFalse( submit_artifacts.create_build(upload_api=upload_api)) # Sandbox scan, no error in response body upload_api = UploadAPI( app_id=test_constants.VALID_UPLOAD_API["app_id"]) upload_api.sandbox_id = "12345" self.assertFalse( submit_artifacts.create_build(upload_api=upload_api))
def reset_job(self, data): if data[api.JOBS_RESOURCE_JOB_ID] not in self.jobs_in_databricks: raise HTTPError('Job Not Found') self.jobs_in_databricks[data[api.JOBS_RESOURCE_JOB_ID]]['job_settings'] = \ data['new_settings']
def request(self, method, url, params=None, data=None, headers=None, cookies=None, files=None, auth=None, timeout=None, allow_redirects=True, proxies=None, hooks=None, stream=None, verify=None, cert=None, json=None, **kwargs): """Constructs a :class:`Request <Request>`, prepares it and sends it. Returns :class:`Response <Response>` object. :param method: method for the new :class:`Request` object. :param url: URL for the new :class:`Request` object. :param params: (optional) Dictionary or bytes to be sent in the query string for the :class:`Request`. :param data: (optional) Dictionary or bytes to send in the body of the :class:`Request`. :param json: (optional) json to send in the body of the :class:`Request`. :param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`. :param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`. :param files: (optional) Dictionary of ``'filename': file-like-objects`` for multipart encoding upload. :param auth: (optional) Auth tuple or callable to enable Basic/Digest/Custom HTTP Auth. :param timeout: (optional) How long to wait for the server to send data before giving up, as a float, or a (`connect timeout, read timeout <user/advanced.html#timeouts>`_) tuple. :type timeout: float or tuple :param allow_redirects: (optional) Set to True by default. :type allow_redirects: bool :param proxies: (optional) Dictionary mapping protocol to the URL of the proxy. :param stream: (optional) whether to immediately download the response content. Defaults to ``False``. :param verify: (optional) if ``True``, the SSL cert will be verified. A CA_BUNDLE path can also be provided. :param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair. """ #=============================================================================================================== # add by mz error_type = kwargs.get("error_type") if error_type: from requests.exceptions import InvalidURL, URLRequired, ConnectTimeout, ConnectionError, SSLError, ReadTimeout from requests.exceptions import InvalidSchema, MissingSchema, ChunkedEncodingError, ContentDecodingError from requests.exceptions import RequestException, HTTPError, ProxyError, Timeout, RetryError, StreamConsumedError get_error = { "InvalidURL": InvalidURL(), "URLRequired": URLRequired(), "ConnectTimeout": ConnectTimeout(), "ConnectionError": ConnectionError(), "SSLError": SSLError(), "ReadTimeout": ReadTimeout(), "InvalidSchema": InvalidSchema(), "MissingSchema": MissingSchema(), "ChunkedEncodingError": ChunkedEncodingError(), "ContentDecodingError": ContentDecodingError(), "StreamConsumedError": StreamConsumedError(), "TooManyRedirects": TooManyRedirects(), "RequestException": RequestException(), "HTTPError": HTTPError(), "ProxyError": ProxyError(), "Timeout": Timeout(), "RetryError": RetryError } error_ = get_error[error_type] raise error_ #=============================================================================================================== method = to_native_string(method) # Create the Request. req = Request( method=method.upper(), url=url, headers=headers, files=files, data=data or {}, json=json, params=params or {}, auth=auth, cookies=cookies, hooks=hooks, ) prep = self.prepare_request(req) proxies = proxies or {} settings = self.merge_environment_settings(prep.url, proxies, stream, verify, cert) # Send the request. send_kwargs = { 'timeout': timeout, 'allow_redirects': allow_redirects, } send_kwargs.update(settings) resp = self.send(prep, **send_kwargs) return resp
def get_job(self, job_id): if job_id not in self.jobs_in_databricks: # Job created is not found. raise HTTPError('Job not Found') else: return self.jobs_in_databricks[job_id]
def handler(method, url, *args, **kwargs): raise HTTPError('Bam!')
from requests.exceptions import HTTPError from requests.exceptions import Timeout from requests.exceptions import TooManyRedirects from requests.exceptions import InvalidURL @pytest.mark.parametrize("payload_a,payload_b,expected", [ ({ "foo": "bar"}, { "one": "two" }, { "foo": "bar", "one": "two" }), ]) def test_merge_payloads(core_client, payload_a, payload_b, expected): merged = core_client.merge_payloads(payload_a, payload_b) assert merged == expected @pytest.mark.parametrize("resource,caught,raised", [ ("foo", SSLError(), cpauto.SSLError), ("foo", ConnectionError(), cpauto.ConnectionError), ("foo", HTTPError(), cpauto.HTTPError), ("foo", Timeout(), cpauto.Timeout), ("foo", TooManyRedirects(), cpauto.TooManyRedirects), ("foo", InvalidURL(), cpauto.InvalidURL), ]) def test_http_post_exceptions(core_client, mgmt_server_base_uri, resource, caught, raised): endpoint = mgmt_server_base_uri + resource with responses.RequestsMock(assert_all_requests_are_fired=False) as rsps: rsps.add(responses.POST, endpoint, body=caught, status=200, content_type='application/json') with pytest.raises(raised): r = core_client.http_post(endpoint=resource, payload={}) @pytest.mark.parametrize("params", [
def raise_for_status(self): if self.status_code != 200: raise (HTTPError(response=self))
def test_build_exists(self): """ Test the build_exists function """ upload_api = UploadAPI( app_id=test_constants.VALID_UPLOAD_API["app_id"]) with patch.object( UploadAPI, "http_get", return_value=test_constants. VALID_UPLOAD_API_GETBUILDLIST_MISSING_BUILDID_IN_RESPONSE_XML[ "Element"], ): # Succeed when no existing build IDs are present with patch("veracode.submit_artifacts.element_contains_error", return_value=False): self.assertTrue( submit_artifacts.build_exists(upload_api=upload_api)) # Raise a RuntimeError when element_contains_error returns True with patch("veracode.submit_artifacts.element_contains_error", return_value=True): self.assertRaises( RuntimeError, submit_artifacts.build_exists, upload_api=upload_api, ) ## Create Sandbox Scan and have existing build ID upload_api.sandbox_id = "12345" with patch.object( UploadAPI, "http_get", return_value=test_constants. VALID_UPLOAD_API_GETBUILDLIST_BUILDID_IN_RESPONSE_XML[ "Element"], ): # Fail when build already exists with patch("veracode.submit_artifacts.element_contains_error", return_value=False): self.assertFalse( submit_artifacts.build_exists(upload_api=upload_api)) # Raise RuntimeError when HTTPError occurs with patch("veracode.api.VeracodeXMLAPI.http_get") as mock_http: with patch("veracode.submit_artifacts.element_contains_error", return_value=False): mock_http.side_effect = HTTPError() self.assertRaises( RuntimeError, submit_artifacts.build_exists, upload_api=upload_api, ) # Raise RuntimeError when HTTPError occurs with patch("veracode.api.VeracodeXMLAPI.http_get") as mock_http: with patch("veracode.submit_artifacts.element_contains_error", return_value=False): mock_http.side_effect = HTTPError() self.assertRaises( RuntimeError, submit_artifacts.build_exists, upload_api=upload_api, )
def user_not_found(): raise HTTPError(response=mock_response)
"""Tests for certbot_dns_aliyun.dns_aliyun.""" import os import unittest import mock from requests.exceptions import HTTPError, RequestException from certbot.plugins import dns_test_common from certbot.plugins import dns_test_common_lexicon from certbot.tests import util as test_util DOMAIN_NOT_FOUND = Exception('No domain found') GENERIC_ERROR = RequestException LOGIN_ERROR = HTTPError('400 Client Error: ...') ACCESS_KEY = '123' ACCESS_KEY_SECRET = 'bar' class AuthenticatorTest(test_util.TempDirTestCase, dns_test_common_lexicon.BaseLexiconAuthenticatorTest): def setUp(self): super(AuthenticatorTest, self).setUp() from certbot_dns_aliyun.dns_aliyun import Authenticator path = os.path.join(self.tempdir, 'file.ini') dns_test_common.write({ "aliyun_access_key": ACCESS_KEY,
def raise_for_status(self): raise HTTPError('error', response=self)
def p(self): raise HTTPError("foo")
class BaseLexiconClientTest: DOMAIN_NOT_FOUND = Exception('No domain found') GENERIC_ERROR = RequestException LOGIN_ERROR = HTTPError('400 Client Error: ...') UNKNOWN_LOGIN_ERROR = HTTPError('500 Surprise! Error: ...') record_prefix = "_acme-challenge" record_name = record_prefix + "." + DOMAIN record_content = "bar" def test_add_txt_record(self: _LexiconAwareTestCase): self.client.add_txt_record(DOMAIN, self.record_name, self.record_content) self.provider_mock.create_record.assert_called_with( rtype='TXT', name=self.record_name, content=self.record_content) def test_add_txt_record_try_twice_to_find_domain( self: _LexiconAwareTestCase): self.provider_mock.authenticate.side_effect = [ self.DOMAIN_NOT_FOUND, '' ] self.client.add_txt_record(DOMAIN, self.record_name, self.record_content) self.provider_mock.create_record.assert_called_with( rtype='TXT', name=self.record_name, content=self.record_content) def test_add_txt_record_fail_to_find_domain(self: _LexiconAwareTestCase): self.provider_mock.authenticate.side_effect = [ self.DOMAIN_NOT_FOUND, self.DOMAIN_NOT_FOUND, self.DOMAIN_NOT_FOUND, ] self.assertRaises(errors.PluginError, self.client.add_txt_record, DOMAIN, self.record_name, self.record_content) def test_add_txt_record_fail_to_authenticate(self: _LexiconAwareTestCase): self.provider_mock.authenticate.side_effect = self.LOGIN_ERROR self.assertRaises(errors.PluginError, self.client.add_txt_record, DOMAIN, self.record_name, self.record_content) def test_add_txt_record_fail_to_authenticate_with_unknown_error( self: _LexiconAwareTestCase): self.provider_mock.authenticate.side_effect = self.UNKNOWN_LOGIN_ERROR self.assertRaises(errors.PluginError, self.client.add_txt_record, DOMAIN, self.record_name, self.record_content) def test_add_txt_record_error_finding_domain(self: _LexiconAwareTestCase): self.provider_mock.authenticate.side_effect = self.GENERIC_ERROR self.assertRaises(errors.PluginError, self.client.add_txt_record, DOMAIN, self.record_name, self.record_content) def test_add_txt_record_error_adding_record(self: _LexiconAwareTestCase): self.provider_mock.create_record.side_effect = self.GENERIC_ERROR self.assertRaises(errors.PluginError, self.client.add_txt_record, DOMAIN, self.record_name, self.record_content) def test_del_txt_record(self: _LexiconAwareTestCase): self.client.del_txt_record(DOMAIN, self.record_name, self.record_content) self.provider_mock.delete_record.assert_called_with( rtype='TXT', name=self.record_name, content=self.record_content) def test_del_txt_record_fail_to_find_domain(self: _LexiconAwareTestCase): self.provider_mock.authenticate.side_effect = [ self.DOMAIN_NOT_FOUND, self.DOMAIN_NOT_FOUND, self.DOMAIN_NOT_FOUND, ] self.client.del_txt_record(DOMAIN, self.record_name, self.record_content) def test_del_txt_record_fail_to_authenticate(self: _LexiconAwareTestCase): self.provider_mock.authenticate.side_effect = self.LOGIN_ERROR self.client.del_txt_record(DOMAIN, self.record_name, self.record_content) def test_del_txt_record_fail_to_authenticate_with_unknown_error( self: _LexiconAwareTestCase): self.provider_mock.authenticate.side_effect = self.UNKNOWN_LOGIN_ERROR self.client.del_txt_record(DOMAIN, self.record_name, self.record_content) def test_del_txt_record_error_finding_domain(self: _LexiconAwareTestCase): self.provider_mock.authenticate.side_effect = self.GENERIC_ERROR self.client.del_txt_record(DOMAIN, self.record_name, self.record_content) def test_del_txt_record_error_deleting_record(self: _LexiconAwareTestCase): self.provider_mock.delete_record.side_effect = self.GENERIC_ERROR self.client.del_txt_record(DOMAIN, self.record_name, self.record_content)
class ConfirmPendingDisbursementTestCase(PendingDisbursementTestCase): def url(self, pk): return reverse('disbursements:pending_detail', args=[pk]) @mock_pending_detail @mock.patch( 'disbursements.views.nomis.create_transaction', return_value={'id': '12345-1'}, ) def test_confirm_disbursement(self, calls_mocker, mock_nomis_create_transaction): self.login(credentials={ 'username': '******', 'password': '******' }) disbursement = SAMPLE_DISBURSEMENTS[4] calls_mocker(disbursement) responses.add(responses.POST, api_url('/disbursements/actions/preconfirm/'), status=200) responses.add(responses.POST, api_url('/disbursements/actions/confirm/'), status=200) response = self.client.post(self.url(disbursement['id']), data={'confirmation': 'yes'}, follow=True) self.assertOnPage(response, 'disbursements:confirmed') self.assertContains(response, '12345-1') mock_nomis_create_transaction.assert_called_once_with( prison_id='BXI', prisoner_number='A1448AE', amount=3000, record_id='d660', description='Sent to Katy Hicks', transaction_type='RELA', retries=1, ) @mock_pending_detail @mock.patch( 'disbursements.views.nomis.create_transaction', side_effect=HTTPError(response=mock.Mock(status_code=500)), ) def test_confirm_disbursement_resets_on_failure(self, calls_mocker, _): self.login(credentials={ 'username': '******', 'password': '******' }) disbursement = SAMPLE_DISBURSEMENTS[4] calls_mocker(disbursement) responses.add(responses.POST, api_url('/disbursements/actions/preconfirm/'), status=200) responses.add(responses.POST, api_url('/disbursements/actions/reset/'), status=200) with silence_logger(): response = self.client.post(self.url(disbursement['id']), data={'confirmation': 'yes'}, follow=True) self.assertOnPage(response, 'disbursements:pending_detail') self.assertContains(response, 'Payment not confirmed due to technical error')
def notify_build(): """ An endpoint to trigger an update about a build event to be sent. This will usually be triggered by a webhook from Launchpad """ # Verify contents signature = hmac.new( flask.current_app.config["SECRET_KEY"].encode("utf-8"), flask.request.data, hashlib.sha1, ).hexdigest() if "X-Hub-Signature" not in flask.request.headers: return "No X-Hub-Signature provided\n", 403 if not hmac.compare_digest( signature, flask.request.headers["X-Hub-Signature"].split("=")[1]): try: raise HTTPError(400) except HTTPError: flask.current_app.extensions["sentry"].captureException( extra={ "request_headers": str(flask.request.headers.keys()), "message": "x-hub-signature did not match", "expected_signature": signature, "header_contents": flask.request.headers["X-Hub-Signature"], "extracted_signature": flask.request.headers["X-Hub-Signature"].split("=")[1], }) return "X-Hub-Signature does not match\n", 400 event_content = flask.request.json status = event_content["status"] build_url = ("https://api.launchpad.net/devel" + event_content["livefs_build"]) launchpad = Launchpad( username=os.environ["LAUNCHPAD_IMAGE_BUILD_USER"], token=os.environ["LAUNCHPAD_IMAGE_BUILD_TOKEN"], secret=os.environ["LAUNCHPAD_IMAGE_BUILD_SECRET"], session=session, auth_consumer=os.environ["LAUNCHPAD_IMAGE_BUILD_AUTH_CONSUMER"], ) build = launchpad.request(build_url).json() author_json = (gnupg.GPG().decrypt( build["metadata_override"]["_author_data"], passphrase=flask.current_app.config["SECRET_KEY"], ).data) if author_json: author = json.loads(author_json) else: return "_author_data could not be decoded\n", 400 email = author["email"] names = author["name"].split(" ") board = author["board"] snaps = ", ".join(build["metadata_override"]["extra_snaps"]) codename = build["distro_series_link"].split("/")[-1] version = Data().by_codename(codename).version arch = build["distro_arch_series_link"].split("/")[-1] build_link = build["web_link"] build_id = build_link.split("/")[-1] download_url = None if status == "Successfully built": download_url = launchpad.request( f"{build_url}?ws.op=getFileUrls").json()[0] session.post( "https://pages.ubuntu.com/index.php/leadCapture/save", data={ "FirstName": " ".join(names[:-1]), "LastName": names[-1] if len(names) > 1 else "", "Email": email, "formid": "3546", "lpId": "2154", "subId": "30", "munchkinId": "066-EOV-335", "imageBuilderVersion": version, "imageBuilderArchitecture": arch, "imageBuilderBoard": board, "imageBuilderSnaps": snaps, "imageBuilderID": build_id, "imageBuilderBuildlink": build_link, "imageBuilderStatus": status, "imageBuilderDownloadlink": download_url, }, ) return "Submitted\n", 202
def raise_detailed_error(request_object): try: request_object.raise_for_status() except HTTPError as e: # raise detailed error message raise HTTPError(e, request_object.text)
def _make_github_request(url, token): response = requests.get(url, headers={'Authorization': f"token {token}"}) if response.status_code != 200: raise HTTPError("There was an error retrieving data from GitHub: " + str(response.content)) return response.content
def _internal_request(self, request_obj, url, method, **kwargs): """ Internal handling of requests. Handles Exceptions. :param request_obj: a requests session. :param str url: url to send request to :param str method: type of request (get/put/post/patch/delete) :param kwargs: extra params to send to the request api :return: Response of the request :rtype: requests.Response """ method = method.lower() if method not in self._allowed_methods: raise ValueError('Method must be one of the allowed ones') if method == 'get': kwargs.setdefault('allow_redirects', True) elif method in ['post', 'put', 'patch']: if 'headers' not in kwargs: kwargs['headers'] = {} if kwargs.get('headers') is not None and kwargs['headers'].get( 'Content-type') is None: kwargs['headers']['Content-type'] = 'application/json' if 'data' in kwargs and kwargs['data'] is not None and kwargs['headers'].get( 'Content-type') == 'application/json': kwargs['data'] = json.dumps(kwargs['data']) # convert to json request_done = False token_refreshed = False while not request_done: self._check_delay() # sleeps if needed try: log.info('Requesting ({}) URL: {}'.format(method.upper(), url)) log.info('Request parameters: {}'.format(kwargs)) # auto_retry will occur inside this function call if enabled response = request_obj.request(method, url, **kwargs) response.raise_for_status() # raise 4XX and 5XX error codes. log.info('Received response ({}) from URL {}'.format( response.status_code, response.url)) request_done = True return response except TokenExpiredError as e: # Token has expired, try to refresh the token and try again on the next loop if not self.token_backend.token.is_long_lived: raise e if token_refreshed: # Refresh token done but still TokenExpiredError raise raise RuntimeError('Token Refresh Operation not working') log.info('Oauth Token is expired, fetching a new token') self.refresh_token() log.info('New oauth token fetched') token_refreshed = True except (ConnectionError, ProxyError, SSLError, Timeout) as e: # We couldn't connect to the target url, raise error log.debug('Connection Error calling: {}.{}' ''.format(url, ('Using proxy: {}'.format(self.proxy) if self.proxy else ''))) raise e # re-raise exception except HTTPError as e: # Server response with 4XX or 5XX error status codes # try to extract the error message: try: error = response.json() error_message = error.get('error', {}).get('message', '') except ValueError: error_message = '' status_code = int(e.response.status_code / 100) if status_code == 4: # Client Error # Logged as error. Could be a library error or Api changes log.error('Client Error: {} | Error Message: {}'.format(str(e), error_message)) else: # Server Error log.debug('Server Error: {}'.format(str(e))) if self.raise_http_errors: if error_message: raise HTTPError('{} | Error Message: {}'.format(e.args[0], error_message), response=response) from None else: raise e else: return e.response except RequestException as e: # catch any other exception raised by requests log.debug('Request Exception: {}'.format(str(e))) raise e
def mock_obs_creation_error(mocker, mock_obs_creation): mock_obs_creation.side_effect = HTTPError( response=mocker.Mock(response=mocker.Mock(text="eror")))
def test_function(): resp = Response() resp.status_code = 401 raise HTTPError(response=resp)
def raise_for_status(self): if self.status_code != 200: raise HTTPError(None)
def reset_job(self, data): if data['job_id'] not in self.jobs_in_databricks: raise HTTPError('Job Not Found') self.jobs_in_databricks[ data['job_id']]['job_settings'] = data['new_settings']