def test__command_fail_all_attempts(self):
error = 'Connection Timeout'
method = 'standby.run_image'
image_info = {'image_id': 'test_image'}
params = {'image_info': image_info}
self.client.session.post.side_effect = [
requests.Timeout(error),
requests.Timeout(error),
requests.Timeout(error),
requests.Timeout(error)
]
self.client._get_command_url(self.node)
self.client._get_command_body(method, params)
e = self.assertRaises(exception.AgentConnectionFailed,
self.client._command, self.node, method, params)
self.assertEqual(
'Connection to agent failed: Failed to connect to '
'the agent running on node %(node)s for invoking '
'command %(method)s. Error: %(error)s' % {
'method': method,
'node': self.node.uuid,
'error': error
}, str(e))
self.assertEqual(3, self.client.session.post.call_count)
def test_timeout(self, httpretty):
exception = requests.Timeout('Request timed out')
httpretty.register_uri(httpretty.POST,
CHECK_ONE_URL,
body=exception_factory(exception))
res = self.checker.check(self.resource)
assert res is None
def request(self, method, url, *args, **kwargs):
"""
Does a request, but raises Timeout immediately if site is known to timeout, and records sites that timeout.
Also raises errors getting the content by default.
"""
# Raise Timeout right away if site is known to timeout
if is_unresponsive(url):
raise requests.Timeout(
'Requests to this site have timed out recently. Waiting before trying again.'
)
# Delay, if needed, before another request to this site
wait_for_domain(url, self.domain_delay)
kwargs.setdefault('timeout', self.timeout)
raise_status = kwargs.pop('raise_status', True)
# If we do not have an adapter for this url, pass it off to urllib
if not any(url.startswith(adapter) for adapter in self.adapters):
return _wrap_urlopen(url, timeout=kwargs['timeout'])
try:
result = requests.Session.request(self, method, url, *args,
**kwargs)
except (requests.Timeout, requests.ConnectionError):
# Mark this site in known unresponsive list
set_unresponsive(url)
raise
if raise_status:
result.raise_for_status()
return result
def test_app_fetch_manifest_timeout(staff_user, staff_api_client,
permission_manage_apps, monkeypatch):
mocked_request = Mock()
mocked_request.side_effect = requests.Timeout()
monkeypatch.setattr("saleor.graphql.app.mutations.requests.get",
mocked_request)
manifest_url = "http://localhost:3000/manifest-doesnt-exist"
query = APP_FETCH_MANIFEST_MUTATION
variables = {
"manifest_url": manifest_url,
}
staff_user.user_permissions.set([permission_manage_apps])
response = staff_api_client.post_graphql(
query,
variables=variables,
)
content = get_graphql_content(response)
errors = content["data"]["appFetchManifest"]["errors"]
assert len(errors) == 1
assert errors[0] == {
"field": "manifestUrl",
"message": "The request to fetch manifest data timed out.",
"code": "MANIFEST_URL_CANT_CONNECT",
}
def waitForCompletion(self, timeout=None):
end = time.time() + (timeout or self.timeout)
while self.status in self.nonterminal_states:
if time.time() >= end:
raise requests.Timeout()
time.sleep(1)
self.__on_completed()
class AppSpiderClass:
def SpiderA(self):
appList =[]
while True:
urls =['https://en.aptoide.com/apps/latest/more','https://en.aptoide.com/apps/latest/more?offset=45','https://en.aptoide.com/apps/latest/more?offset=84','https://en.aptoide.com/apps/latest/more?offset=126','https://en.aptoide.com/apps/latest/more?offset=161','https://en.aptoide.com/apps/latest/more?offset=200','https://en.aptoide.com/apps/latest/more?offset=235','https://en.aptoide.com/apps/latest/more?offset=276','https://en.aptoide.com/apps/latest/more?offset=324','https://en.aptoide.com/apps/latest/more?offset=367','https://en.aptoide.com/apps/latest/more?offset=411','https://en.aptoide.com/apps/latest/more?offset=456','https://en.aptoide.com/apps/latest/more?offset=500','https://en.aptoide.com/apps/latest/more?offset=535','https://en.aptoide.com/apps/latest/more?offset=573','https://en.aptoide.com/apps/latest/more?offset=614','https://en.aptoide.com/apps/latest/more?offset=660','https://en.aptoide.com/apps/latest/more?offset=692','https://en.aptoide.com/apps/latest/more?offset=734','https://en.aptoide.com/apps/latest/more?offset=772','https://en.aptoide.com/apps/latest/more?offset=805','https://en.aptoide.com/apps/latest/more?offset=839','https://en.aptoide.com/apps/latest/more?offset=872','https://en.aptoide.com/apps/latest/more?offset=906','https://en.aptoide.com/apps/latest/more?offset=940']
#try:
for pagelink in urls:
htmlPages = requests.get(pagelink)
text = htmlPages.text
soup = BeautifulSoup(text,"html.parser")
self.FetchAptoideLinks(soup,appList)
except requests.ConnectionError as connError:
logger.log("Connection Error while connecting to Play store: ", urls," Error: ", connError)
except requests.HTTPError as httpError:
logger.log("Invalid HTTP response to Play store: ", urls, " Error: ", httpError)
except requests.Timeout() as requestTimeoutError:
logger.log("Time-out to connect to Play store: ", urls, " Error: ", requestTimeoutError)
def test_read_metadata_when_password_server_unreachable(self, m_password):
"""The read_metadata function returns partial results in case the
password server (only) is unreachable."""
expected_id = "12345"
expected_hostname = "myname"
expected_userdata = "#cloud-config"
m_password.side_effect = requests.Timeout('Fake Connection Timeout')
httpretty.register_uri(httpretty.GET,
self.userdata_url,
body=expected_userdata)
httpretty.register_uri(httpretty.GET,
self.metadata_url,
body="instance-id\nlocal-hostname")
httpretty.register_uri(httpretty.GET,
"{}local-hostname".format(self.metadata_url),
body=expected_hostname)
httpretty.register_uri(httpretty.GET,
"{}instance-id".format(self.metadata_url),
body=expected_id)
result = read_metadata()
self.assertIsNone(result.get("password"))
self.assertEqual(
result.get("user-data").decode("utf-8"), expected_userdata)
def mock_catalog_contains_course_runs(
self,
course_run_ids,
enterprise_customer_uuid,
enterprise_customer_catalog_uuid=None,
contains_content=True,
raise_exception=False
):
self.mock_access_token_response()
query_params = urlencode({'course_run_ids': course_run_ids}, True)
body = (
requests.Timeout('Connection timed out.') if raise_exception else
json.dumps({'contains_content_items': contains_content})
)
responses.add(
method=responses.GET,
url='{api_url}{enterprise_customer_uuid}/contains_content_items/?{query_params}'.format(
api_url=self.ENTERPRISE_CATALOG_URL_CUSTOMER_RESOURCE,
enterprise_customer_uuid=enterprise_customer_uuid,
query_params=query_params
),
body=body,
content_type='application/json'
)
if enterprise_customer_catalog_uuid:
responses.add(
method=responses.GET,
url='{api_url}{customer_catalog_uuid}/contains_content_items/?{query_params}'.format(
api_url=self.ENTERPRISE_CATALOG_URL,
customer_catalog_uuid=enterprise_customer_catalog_uuid,
query_params=query_params
),
body=body,
content_type='application/json'
)
def stream(self, route):
""" Makes an http request and returns an iterator over the response.
Parameters
----------
route :
the http route (under this object's host) to request against.
"""
url = self._build_url(route)
start_time = time.perf_counter()
response = requests.get(url, stream=True)
response_b = None
if "Content-length" in response.headers:
response_b = float(response.headers["Content-length"])
size_message = f"{response_b / 1024 ** 2:3.3f}MiB" if response_b is not None else "potentially large"
logging.warning(f"downloading a {size_message} file from {url}")
progress = tqdm(unit="B",
total=response_b,
unit_scale=True,
desc="Downloading")
for chunk in response.iter_content(self.chunksize):
if chunk: # filter out keep-alive new chunks
progress.update(len(chunk))
yield chunk
elapsed = time.perf_counter() - start_time
if elapsed > self.timeout:
raise requests.Timeout(
f"Download took {elapsed} seconds, but timeout was set to {self.timeout}"
)
def post(self,
url,
data,
timeout=HTTP_CLIENT_TIME_OUT,
max_retries=HTTP_CLIENT_MAX_RETRIES,
referer=HTTP_CLIENT_REFERER,
**kw):
"""Post with headers.
"""
for attempt_counter in range(max_retries):
try:
post_response = self.session.post(
url,
headers=self.create_headers(referer),
data=data,
timeout=timeout,
**kw)
post_response.encoding = "utf-8"
return post_response
except requests.Timeout as identifier:
logging.warning(
f'HTTPClient: ({attempt_counter + 1} / {max_retries}) Failed to POST `{data}` to `{url}`: {identifier}'
)
attempt_counter += 1
raise requests.Timeout(
f'HTTPClient: Max POST retries exceeded with url: {url}')
class TestAPIMethodExecute(TestAPIMethod):
mock_response = mock.Mock()
mock_response.status_code = 200
mock_response.text = "{'status': 'success'}"
mock_response.json = lambda: {'status': 'success'}
mock_auth_error = mock.Mock()
mock_auth_error.status_code = 401
mock_invalid_json = "not-valid-json"
@mock.patch('synapsepay.apibits.requester.Requester.request',
side_effect=requests.Timeout())
def test_api_error_on_failed_request(self, request_mock):
with self.assertRaises(synapsepay.apibits.APIError):
self.api_method.execute()
@mock.patch('synapsepay.apibits.requester.Requester.request',
return_value=mock_response)
def test_response_parsed_as_json(self, request_mock):
self.assertEqual({'status': 'success'}, self.api_method.execute())
@mock.patch('synapsepay.apibits.requester.Requester.request',
return_value=mock_auth_error)
def test_401_status_authentication_error(self, request_mock):
with self.assertRaises(synapsepay.apibits.AuthenticationError):
self.api_method.execute()
@mock.patch('requests.Response.content', mock_invalid_json)
def test_invalid_json_api_error(self):
with self.assertRaises(synapsepay.apibits.APIError):
ret = self.api_method.execute()
def download_file(url: str, dest_dir: str, timeout: float = None) -> str:
"""Downloads a file from a web URL to a directory.
Args:
url: File url as a string.
dest_dir: Directory to download the file into, as a string.
timeout: Maximum time in seconds downloading the file can take,
as a float. The actual timeout will be a rough approximation to
this, likely several seconds larger.
Returns:
Path to the downloaded file of the form
<dest_dir>/<basename of the downloaded file>.
Raises:
requests.Timeout: Downloading timed out.
"""
# 9.05 is the connect timeout and 27 is the read timeout. See
# https://requests.readthedocs.io/en/master/user/advanced/#timeouts.
with requests.get(url, stream=True, timeout=(9.05, 27)) as response:
response.raise_for_status()
filename = _get_filename(response)
path = os.path.join(dest_dir, filename)
with open(path, 'wb') as out:
start = time.time()
for data in response.iter_content(chunk_size=4096):
out.write(data)
if timeout is not None and time.time() - start > timeout:
raise requests.Timeout(f'Downloading {url} timed out')
return path
def do_call_mqtt(self, payload, t):
n = eva.notify.get_notifier(self._notifier_id)
r = self.Response()
if not n: return r
if isinstance(payload, dict) and 'id' in payload:
request_id = payload['id']
else:
request_id = str(uuid.uuid4())
data = '{}|{}'.format(request_id, rapidjson.dumps(payload))
cb = self.MQTTCallback()
n.send_api_request(
request_id, self._product_code + '/' + self._uri,
'|{}|{}'.format(self._key_id,
self.ce.encrypt(data.encode()).decode()),
cb.data_handler)
if not cb.completed.wait(self._timeout):
n.finish_api_request(request_id)
raise requests.Timeout()
if cb.code:
try:
r.text = self.ce.decrypt(cb.body.encode()).decode()
if cb.code == 200:
r.ok = True
r.status_code = cb.code
except:
eva.core.log_traceback()
r.status_code = 403
return r
def stream(self, route):
""" Makes an http request and returns an iterator over the response.
Parameters
----------
route :
the http route (under this object's host) to request against.
"""
url = self._build_url(route)
start_time = time.perf_counter()
response = requests.get(url, stream=True)
response_mb = None
if "Content-length" in response.headers:
response_mb = float(response.headers["Content-length"]) / 1024 ** 2
for ii, chunk in enumerate(response.iter_content(self.chunksize)):
if ii == 0:
size_message = f"{response_mb:3.3}mb" if response_mb is not None else "potentially large"
logging.warning(f"downloading a {size_message} file from {url}")
yield chunk
elapsed = time.perf_counter() - start_time
if elapsed > self.timeout:
raise requests.Timeout(f"Download took {elapsed} seconds, but timeout was set to {self.timeout}")
def test_raises_unavailable_when_request_timeout(self, responses):
request_url = 'http://www.omdbapi.com/?apikey=my-api-key&t=Die+Hard'
responses.add(responses.GET, request_url, match_querystring=True,
body=requests.Timeout())
with pytest.raises(Unavailable):
OMDBClient().get_rating_for_movie(title='Die Hard')
def test_source_fetch_fails(self, mock_get, mock_post):
mock_get.side_effect = (requests_response(
self.reply_html.replace('http://orig/post', 'bad'),
content_type=CONTENT_TYPE_HTML), requests.Timeout('foo bar'))
got = self.client.post('/webmention', data={'source': 'http://a/post'})
self.assertEqual(502, got.status_code)
def search():
GREEN(f'[+] Searching for:\t{uname}')
match = True
FAILED = []
SUCCESS = []
try:
for url in WEBSITES:
requests.Timeout(0.5)
r = requests.get(url)
#r.close()
if r.status_code == 200:
GREEN(f"[+] {r.status_code}! {url} - Valid! ")
SUCCESS.append(url)
elif r.status_code != 200:
RED(f"[-] {r.status_code}! {url} - Failed! maybe this is a false positive"
)
FAILED.append(url)
except Exception as e:
RED(f'Error has occurred {e}')
YELLOW(f'[X] TOTAL = {len(WEBSITES)}')
YELLOW(f'[X] SUCCESS = {len(SUCCESS)}')
YELLOW(f'[X] FAILED = {len(FAILED)}')
if (input('Show "SUCCESS" websites?:[y\\n]\t')) == 'Y' or 'y':
x = 0
for i in SUCCESS:
x += 1
print(f'{x}) ', i)
def test_http_errors(monkeypatch):
resp = MagicMock()
resp.status_code = 404
resp.raise_for_status.side_effect = requests.HTTPError('Not Found')
get = MagicMock()
get.return_value = resp
monkeypatch.setattr('requests.get', get)
http = HttpWrapper('http://example.org')
# the code method will not raise an exception..
assert 404 == http.code()
for meth in ('time', 'json', 'cookies', 'headers'):
with pytest.raises(HttpError) as ex:
# ..but other methods will!
getattr(http, meth)()
assert 'Not Found' == ex.value.message
get.side_effect = requests.Timeout('timed out')
http = HttpWrapper('http://example.org')
with pytest.raises(HttpError) as ex:
http.time()
assert 'timeout' == ex.value.message
get.side_effect = requests.ConnectionError('connfail')
http = HttpWrapper('http://example.org')
with pytest.raises(HttpError) as ex:
http.code()
assert 'connection failed' == ex.value.message
get.side_effect = Exception('foofail')
http = HttpWrapper('http://example.org')
with pytest.raises(HttpError) as ex:
http.code()
assert 'foofail' == ex.value.message
def test_mocking():
url = "http://ti.ny"
# Multiple responses to the same url must be added before any request to it has been made
responses.add(responses.GET, url, body='{"title": "Test Deal"}', content_type="application/json")
responses.add(responses.GET, url, json=dict(a=10, b='foo'), status=401)
responses.add(responses.GET, url, body=requests.HTTPError('Some HttpError'), status=500)
responses.add(responses.GET, url, body=requests.Timeout('cannot do'), status=500)
r = requests.get(url)
assert r.json() == {"title": "Test Deal"}
r = requests.get(url)
assert r.json().get('a') == 10
assert r.json().get('b') == 'foo'
assert r.status_code == 401
with pytest.raises(requests.HTTPError):
requests.get(url)
with pytest.raises(ValueError):
try:
requests.get(url)
except requests.Timeout as e:
raise ValueError(e)
# Requests to url without a defined response will raise ConnectionError
responses.add(responses.GET, 'http://www.google.com', body='OK')
with pytest.raises(requests.ConnectionError):
requests.get('http://nrk.no')
def wait_for_completion(self, timeout=None):
""" Wait up to <timeout> seconds for the query to complete """
end = time.time() + (timeout or self.timeout)
while self.status in self.nonterminal_states:
if time.time() >= end:
raise requests.Timeout()
time.sleep(1)
self._on_completed()
def test_fb_with_timeout__timing_out(self):
with mock.patch.object(self.fb_timeout.client.session, 'request') as request:
request.side_effect = requests.Timeout('Timed out')
with self.assertRaisesRegexp(Timeout, 'Timed out'):
self.fb_timeout.make_request(self.test_url)
request.assert_called_once()
self.assertEqual(10, request.call_args[1]['timeout'])
def _func_raise_requests_exception_once(val, timeout=None):
if len(val) > 0:
response = MagicMock()
response.raise_for_status = lambda: None
return response
val.append(0)
ex = requests.Timeout()
raise ex
def setUp(self):
"""
Sets up simple exceptions to wrap
"""
super(NetworkErrorTests, self).setUp()
self.exc = requests.RequestException("exc_message")
self.timeout_exc = requests.Timeout("timeout_message")
self.connection_exc = requests.ConnectionError("connection_message")
def test_render_home_if_blog_timeout(self):
'''It should render the home page when blog time out'''
exception = requests.Timeout('Blog timed out')
httpretty.register_uri(httpretty.GET,
WP_ATOM_URL,
body=exception_factory(exception))
response = self.get(url_for('site.home'))
self.assert200(response)
def test_timeout(self):
url = faker.uri()
exception = requests.Timeout('Request timed out')
httpretty.register_uri(httpretty.POST, CHECK_ONE_URL,
body=exception_factory(exception))
response = self.get(url_for('api.checkurl'),
qs={'url': url, 'group': ''})
self.assertStatus(response, 503)
def test_timeout_exception(self):
with mock.patch('requests.get') as requests_get_mock:
requests_get_mock.side_effect = requests.Timeout()
with StdoutCapture() as output:
self.api_caller.get_resource("/resource", DiscoveryContainer())
self.assertIn(
"ERROR::Get url=http://1.2.3.4:567/resource Error <class 'requests.exceptions.Timeout'>:;",
output.raw)
def __init__(self):
self.__logger = Logger()
self._request_exceptions = [
type(item) for item in [
requests.ConnectionError(),
requests.HTTPError(),
requests.TooManyRedirects(),
requests.Timeout(),
requests.TooManyRedirects(),
requests.RequestException(),
requests.ConnectTimeout(),
requests.ReadTimeout()
]
]
self._system_errors = [
type(item) for item in [
KeyError(),
AttributeError(),
IndexError(),
ZeroDivisionError(),
SystemError(),
ValueError(),
AssertionError()
]
]
self._file_errors = [
type(item) for item in [FileExistsError(),
FileNotFoundError()]
]
self._database_errors = [
type(item) for item in [
sqlite3.Error(),
sqlite3.DataError(),
sqlite3.ProgrammingError(),
sqlite3.DatabaseError(),
sqlite3.NotSupportedError(),
sqlite3.IntegrityError(),
sqlite3.InterfaceError(),
sqlite3.InternalError(),
sqlite3.OperationalError()
]
]
self._speech_recognizer_errors = [
type(item) for item in [
sr.RequestError(),
sr.UnknownValueError(),
sr.WaitTimeoutError(),
sr.RequestError()
]
]
self.__logger.info('ExceptionsHandler was successfully initialized.',
__name__)
def test_timeout(self):
responses.get('https://ipapi.co/192.0.2.0/json',
body=requests.Timeout("too slow"))
with self.assertLogs(logger, level='ERROR') as logged:
tz = ip_to_timezone('192.0.2.0')
self.assertEqual(len(logged.output), 1)
self.assertRegex(logged.output[0],
f'^ERROR:{logger.name}:External query timed out')
self.assertEqual(tz, None)
def mock_enterprise_learner_api_raise_exception(self):
"""
Helper function to register enterprise learner API endpoint and raise an exception.
"""
self.mock_access_token_response()
responses.add(
method=responses.GET,
url=self.ENTERPRISE_LEARNER_URL,
body=requests.Timeout('Connection timed out.')
)
def test_get_lms_footer_timeout(self):
""" Verify proper logger message is displayed in case of a time out. """
with mock.patch('requests.get', side_effect=requests.Timeout()):
with LogCapture(LOGGER_NAME) as l:
response = get_lms_footer()
l.check((
LOGGER_NAME, 'ERROR',
u'Failed to retrieve data for {lms_url} provider, connection timeout'
.format(lms_url=settings.LMS_URL_ROOT)))
self.assertIsNone(response)
