def test_post_notification_RequestException(self, mock_post): mock_post.return_value.raise_for_status.side_effect = req_exc.Timeout( 'hello') notification_status, notification_error = post_notification( None, None, None) self.assertEqual(notification_status, Constants.PENDING) self.assertEqual(notification_error, 'hello')
def test_non_exist_url(self): url = 'http://non-exist.com/template' requests.get(url, stream=True).AndRaise(exceptions.Timeout()) self.m.ReplayAll() self.assertRaises(urlfetch.URLFetchError, urlfetch.get, url) self.m.VerifyAll()
def _wait_until_timeout(self, events): stime = time.time() while (time.time() - stime) <= self._timeout: ongoing_events = [a for a in events if self.client.get_event(a).get('status') == "ongoing"] if len(ongoing_events) > 0: log.info("Waiting for {0}/{1} events to complete ... ".format(len(ongoing_events), len(events))) time.sleep(self._event_polling_interval) else: return raise exceptions.Timeout("Storage snapshot event(s) not finished in time ({} seconds)".format(self._timeout))
def __exit__(self, type, value, traceback): events = self.client.events try: self._wait_until_timeout(events) except exceptions.Timeout as e: ongoing_events = [str(a) for a in events if self.client.get_event(a)['status'] == "ongoing"] raise exceptions.Timeout("{}\nUnfinished events:\n{}".format(e, ", ".join(ongoing_events))) failed_events = [str(a) for a in events if self.client.get_event(a)['status'] == "failed"] done_events = [str(a) for a in events if self.client.get_event(a)['status'] == "done"] log.info("Failed events: {0}/{2}\nSuccessful events: {1}/{2}".format(len(failed_events), len(done_events), len(events))) if len(failed_events) > 0 and self._raise_for_failed_events: raise RuntimeError("Snapshot event(s) failed! Failed events: {}".format(", ".join(failed_events)))
def test_v2_get_user_by_name_timeout(self, get_mock, post_mock): get_mock.side_effect = [ self._valid_get_response(), req_ex.Timeout('Timeout') ] post_mock.return_value = self._valid_post_response() identity = v2.RackspaceIdentity.from_username( self.username, self.password, user_domain_id=self.domain_id) self.assertRaises(exception.BadGateway, identity.get_user_by_name, self.username)
def test_request_transport_timeout(): session = create_autospec(spec=requests.Session, instance=True) session.headers = {} session.post = Mock(side_effect=request_exceptions.Timeout()) transport = TRequestsTransport('http://localhost:12345', session_factory=lambda: session) protocol = TJSONProtocol.TJSONProtocol(transport) client = ReadOnlyScheduler.Client(protocol) with pytest.raises(TTransport.TTransportException) as execinfo: client.getRoleSummary() assert execinfo.value.message == 'Timed out talking to http://localhost:12345' transport.close()
def send(self, url, method='GET', params={}, data={}, files={}, headers={}, timeout=None): headers.update(self.headers) prepped = Request(method, url, params=params, data=data, files=files, headers=headers).prepare() try: resp = self.session.send(prepped, proxies=self.proxies, timeout=(self.connect_timeout, timeout), ) except exceptions.Timeout, e: raise exceptions.Timeout(e)
def test_analyze_exception_request(self): self.assertEqual(errors.SYSTEM_TRANSIENT, self.apic_handler.analyze_exception(rexc.Timeout())) self.assertEqual( errors.SYSTEM_TRANSIENT, self.apic_handler.analyze_exception(rexc.ConnectionError())) self.assertEqual( errors.OPERATION_CRITICAL, self.apic_handler.analyze_exception(rexc.InvalidURL())) self.assertEqual( errors.OPERATION_CRITICAL, self.apic_handler.analyze_exception(rexc.URLRequired())) self.assertEqual( errors.OPERATION_TRANSIENT, self.apic_handler.analyze_exception(rexc.RequestException())) self.assertEqual(errors.UNKNOWN, self.apic_handler.analyze_exception(Exception()))
def test_v2_authentication_with_intermittent_failures( self, get_mock, post_mock): # Requests timeout exception timeout_ex = req_ex.Timeout('Timeout') get_mock.return_value = self._valid_get_response() post_mock.side_effect = [ self._valid_post_response(), timeout_ex, timeout_ex, self._valid_post_response() ] identity = v2.RackspaceIdentity.from_username( self.username, self.password, user_domain_id=self.domain_id) self.assertRaises(exception.BadGateway, identity.authenticate) self.assertRaises(exception.BadGateway, identity.authenticate) self.assertIsNotNone(identity.authenticate())
def test_request_transport_timeout(): session = mock.MagicMock(spec=requests.Session) session.headers = {} session.post = mock.Mock(side_effect=request_exceptions.Timeout()) transport = TRequestsTransport('http://localhost:12345', session_factory=lambda: session) protocol = TJSONProtocol.TJSONProtocol(transport) client = ReadOnlyScheduler.Client(protocol) try: client.getRoleSummary() assert False, 'getRoleSummary should not succeed' except TTransport.TTransportException as e: assert e.message == 'Timed out talking to http://localhost:12345' except Exception as e: assert False, 'Only expected TTransportException, got %s' % e transport.close()
def test_non_exist_url(self): url = 'http://non-exist.com/template' mock_get = self.patchobject(requests, 'get') mock_get.side_effect = exceptions.Timeout() self.assertRaises(urlfetch.URLFetchError, urlfetch.get, url) mock_get.assert_called_once_with(url, stream=True)
def test_non_exist_url(self): url = 'http://non-exist.com/somedata' self.patchobject(requests, 'get', side_effect=exceptions.Timeout()) self.assertRaises(utils.URLFetchError, utils.url_fetch, url)
from requests import exceptions import pytest from rest_framework import status from rest_framework.reverse import reverse from company.data import CompaniesHouseException from core.tests.helpers import create_response expected_exceptions = ( exceptions.RequestException(), exceptions.HTTPError(), exceptions.ConnectionError(), exceptions.ProxyError(), exceptions.SSLError(), exceptions.Timeout(), exceptions.ConnectTimeout(), exceptions.ReadTimeout(), CompaniesHouseException(404), ) @pytest.fixture(autouse=True) def mock_client_get(): stub = mock.patch('company.data.CompaniesHouseClient.get') yield stub.start() stub.stop def test_company_search_view_missing_querystring(api_client): url = reverse('api:search-companies')
def _simulate_get_timeout(self, request): """Will raise exception for any host request to this resource.""" if URI_HOSTNAME in request.path_url: raise r_exc.Timeout()
def _simulate_timeout(self, request): if URI_HOSTNAME in request.path_uri: raise r_exc.Timeout()
def _simulate_token_timeout(self, request): raise r_exc.Timeout()
def token_timeout(url, request): raise r_exc.Timeout()
def timeout(url, request): """Simulated timeout of a normal request.""" if not request.headers.get('X-auth-token', None): return {'status_code': requests.codes.UNAUTHORIZED} raise r_exc.Timeout()