def QA_fetch_bitmex_kline(symbol="XBTUSD",
count=100,
startTime="",
endTime='',
binSize="1m",
partial='false',
reverse='false',
proxies=proxies):
body = ''
url = '%s/trade/bucketed?' \
'binSize=%s&partial=%s&symbol=%s&count=%d&reverse=%s&startTime=%s&endTime=%s' \
% (Bitmex_base_url, binSize, partial, symbol, count, reverse, startTime, endTime)
try:
req = requests.get(url, timeout=TIMEOUT, proxies=proxies)
remaining = int(req.headers['x-ratelimit-remaining'])
if remaining <20:
time.sleep(5)
elif remaining <10:
time.sleep(10)
elif remaining <3:
time.sleep(30)
except ConnectTimeout:
raise ConnectTimeout('Bitmex connect timeout when getting kline.')
except (ssl.SSLError, requests.exceptions.SSLError) as ex:
QA_util_log_info(ex)
except Exception as ex:
QA_util_log_expection(ex)
return json.loads(req.content)
def post(url,
data=None,
headers=None,
encoding='UTF-8',
files=None,
proxies=None,
tiemout=10):
"""POST请求发送包装"""
try:
html = requests.post(url,
data=data,
headers=headers,
proxies=proxies,
timeout=tiemout,
files=files)
html = html.content.decode(encoding)
return html.replace('\x00', '').strip()
except ChunkedEncodingError as e:
html = post_stream(url, data, headers, encoding, files)
return html
except ConnectionError as e:
raise ConnectionError("ERROR:" + "HTTP连接错误")
except ConnectTimeout as e:
raise ConnectTimeout("ERROR:" + "HTTP连接超时错误")
except Exception as e:
raise Exception('ERROR:' + str(e))
def QA_fetch_binance_kline(symbol, start_time, end_time, frequency):
datas = list()
start_time *= 1000
end_time *= 1000
while start_time < end_time:
url = urljoin(Binance_base_url, "/api/v1/klines")
try:
req = requests.get(url, params={"symbol": symbol, "interval": frequency,
"startTime": int(start_time),
"endTime": int(end_time)}, timeout=TIMEOUT, proxies=proxies)
# 防止频率过快被断连
time.sleep(1)
except ConnectTimeout:
raise ConnectTimeout(ILOVECHINA)
except (ssl.SSLError, requests.exceptions.SSLError) as ex:
QA_util_log_info(ex)
time.sleep(120)
req = requests.get(url, timeout=TIMEOUT, proxies=proxies)
except Exception as ex:
break
klines = json.loads(req.content)
if len(klines) == 0:
break
datas.extend(klines)
start_time = klines[-1][6]
if len(datas) == 0:
return None
frame = pd.DataFrame(datas)
frame.columns = columne_names
frame['symbol'] = symbol
return json.loads(frame.to_json(orient='records'))
def test_post_data_timeout():
"""Test post data with timeout."""
# Arrange
api_key = '12345'
resource_id = '1234-1234'
uri = '/blah'
expected_url = f'{BASE_URL}{uri}'
measurement_single = """{
"measurement": {
"period_end": "2018-02-02T03:30:00.0000000Z",
"period": "PT5M",
"total_power": 1.23456
}
}"""
responses.add(responses.POST,
expected_url,
body=ConnectTimeout(),
status=200,
content_type='applicaiton/json')
# Act
obj = PySolcast(api_key, resource_id)
with pytest.raises(ConnectTimeout):
obj._post_data(uri, measurement_single) # pylint: disable=protected-access
def test_get_failed_servers_with_connection_error(self):
servers = {
'The Rosalind server': {
'host': 'rosalind.info',
'schemes': ['http', 'https']
},
'My Digital Ocean': {
'host': 'vika.space',
'ports': [80, 443]
}
}
responses.add(responses.GET,
'https://rosalind.info',
body=ConnectionError('Not reachable'))
responses.add(responses.GET, 'http://rosalind.info', status=200)
responses.add(responses.GET,
'http://vika.space',
body=ConnectTimeout('Timeout'))
responses.add(responses.GET, 'https://vika.space', status=302)
results = list(get_failed_servers(servers))
expected_data = [('https://rosalind.info', 'Not reachable'),
('http://vika.space', 'Timeout')]
self.assertEqual(sorted(results), sorted(expected_data))
async def test_asserts(hass, test_api):
"""Test the _site_in_configuration_exists method."""
flow = init_config_flow(hass)
# test with inactive site
test_api.get_details.return_value = {"details": {"status": "NOK"}}
result = await flow.async_step_user(
{CONF_NAME: NAME, CONF_API_KEY: API_KEY, CONF_SITE_ID: SITE_ID}
)
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
assert result["errors"] == {CONF_SITE_ID: "site_not_active"}
# test with api_failure
test_api.get_details.return_value = {}
result = await flow.async_step_user(
{CONF_NAME: NAME, CONF_API_KEY: API_KEY, CONF_SITE_ID: SITE_ID}
)
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
assert result["errors"] == {CONF_SITE_ID: "invalid_api_key"}
# test with ConnectionTimeout
test_api.get_details.side_effect = ConnectTimeout()
result = await flow.async_step_user(
{CONF_NAME: NAME, CONF_API_KEY: API_KEY, CONF_SITE_ID: SITE_ID}
)
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
assert result["errors"] == {CONF_SITE_ID: "could_not_connect"}
# test with HTTPError
test_api.get_details.side_effect = HTTPError()
result = await flow.async_step_user(
{CONF_NAME: NAME, CONF_API_KEY: API_KEY, CONF_SITE_ID: SITE_ID}
)
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
assert result["errors"] == {CONF_SITE_ID: "could_not_connect"}
def test_create_payment_record_rollback_on_paybc_connection_error(
session, public_user_mock):
"""Assert that the payment records are not created."""
# Create a payment account
factory_payment_account()
# Mock here that the invoice update fails here to test the rollback scenario
with patch('pay_api.services.oauth_service.requests.post',
side_effect=ConnectionError('mocked error')):
with pytest.raises(ServiceUnavailableException) as excinfo:
PaymentService.create_invoice(get_payment_request(),
get_auth_basic_user())
assert excinfo.type == ServiceUnavailableException
with patch('pay_api.services.oauth_service.requests.post',
side_effect=ConnectTimeout('mocked error')):
with pytest.raises(ServiceUnavailableException) as excinfo:
PaymentService.create_invoice(get_payment_request(),
get_auth_basic_user())
assert excinfo.type == ServiceUnavailableException
with patch('pay_api.services.oauth_service.requests.post',
side_effect=HTTPError('mocked error')) as post_mock:
post_mock.status_Code = 503
with pytest.raises(HTTPError) as excinfo:
PaymentService.create_invoice(get_payment_request(),
get_auth_basic_user())
assert excinfo.type == HTTPError
def QA_fetch_kline(symbol, start_time, end_time, frequency):
datas = list()
start_time *= 1000
end_time *= 1000
while start_time < end_time:
url = urljoin(Binance_base_url, "/api/v1/klines")
try:
req = requests.get(url,
params={
"symbol": symbol,
"interval": frequency,
"startTime": int(start_time),
"endTime": int(end_time)
},
timeout=TIMEOUT)
except ConnectTimeout:
raise ConnectTimeout(MESSAGE_NOTICE)
klines = json.loads(req.content)
if len(klines) == 0:
break
datas.extend(klines)
start_time = klines[-1][6]
if len(datas) == 0:
return None
frame = pd.DataFrame(datas)
frame.columns = columne_names
frame['symbol'] = symbol
return json.loads(frame.to_json(orient='records'))
def test_create_payment_record_rollback_on_paybc_connection_error(session):
"""Assert that the payment records are not created."""
from unittest.mock import Mock
# Mock here that the invoice update fails here to test the rollback scenario
with patch('pay_api.services.oauth_service.requests.post',
side_effect=ConnectionError('mocked error')):
with pytest.raises(ServiceUnavailableException) as excinfo:
PaymentService.create_payment(get_payment_request(), 'test')
assert excinfo.type == ServiceUnavailableException
with patch('pay_api.services.oauth_service.requests.post',
side_effect=ConnectTimeout('mocked error')):
with pytest.raises(ServiceUnavailableException) as excinfo:
PaymentService.create_payment(get_payment_request(), 'test')
assert excinfo.type == ServiceUnavailableException
mock_create_site = patch('pay_api.services.oauth_service.requests.post')
mock_post = mock_create_site.start()
mock_post.return_value = Mock(status_code=503)
with patch('pay_api.services.oauth_service.requests.post',
side_effect=HTTPError('mocked error')) as post_mock:
post_mock.status_Code = 503
with pytest.raises(HTTPError) as excinfo:
PaymentService.create_payment(get_payment_request(), 'test')
assert excinfo.type == HTTPError
def post_stream(url,
data=None,
headers=None,
encoding='UTF-8',
files=None,
proxies=None,
tiemout=10):
"""分块接受数据"""
try:
lines = requests.post(url,
data=data,
headers=headers,
timeout=tiemout,
stream=True,
proxies=proxies,
files=None)
html = list()
for line in lines.iter_lines():
line = line.decode(encoding)
html.append(line.strip())
return '\r\n'.join(html).strip()
except ChunkedEncodingError as e:
return '\r\n'.join(html).strip()
except ConnectionError as e:
raise ConnectionError("ERROR:" + "HTTP连接错误")
except ConnectTimeout as e:
raise ConnectTimeout("ERROR:" + "HTTP连接超时错误")
except Exception as e:
raise Exception('ERROR:' + str(e))
async def test_asserts(hass: HomeAssistant, test_api: Mock) -> None:
"""Test the _site_in_configuration_exists method."""
# test with inactive site
test_api.get_details.return_value = {"details": {"status": "NOK"}}
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": SOURCE_USER},
data={
CONF_NAME: NAME,
CONF_API_KEY: API_KEY,
CONF_SITE_ID: SITE_ID
},
)
assert result.get("type") == data_entry_flow.FlowResultType.FORM
assert result.get("errors") == {CONF_SITE_ID: "site_not_active"}
# test with api_failure
test_api.get_details.return_value = {}
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": SOURCE_USER},
data={
CONF_NAME: NAME,
CONF_API_KEY: API_KEY,
CONF_SITE_ID: SITE_ID
},
)
assert result.get("type") == data_entry_flow.FlowResultType.FORM
assert result.get("errors") == {CONF_SITE_ID: "invalid_api_key"}
# test with ConnectionTimeout
test_api.get_details.side_effect = ConnectTimeout()
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": SOURCE_USER},
data={
CONF_NAME: NAME,
CONF_API_KEY: API_KEY,
CONF_SITE_ID: SITE_ID
},
)
assert result.get("type") == data_entry_flow.FlowResultType.FORM
assert result.get("errors") == {CONF_SITE_ID: "could_not_connect"}
# test with HTTPError
test_api.get_details.side_effect = HTTPError()
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": SOURCE_USER},
data={
CONF_NAME: NAME,
CONF_API_KEY: API_KEY,
CONF_SITE_ID: SITE_ID
},
)
assert result.get("type") == data_entry_flow.FlowResultType.FORM
assert result.get("errors") == {CONF_SITE_ID: "could_not_connect"}
def test_connect_timeout_exception(self, requests):
requests.post.side_effect = ConnectTimeout()
with self.assertRaises(TimeoutException):
self.http_client.post(url="http://test.com/",
headers=None,
payload=None,
timeout=1000)
def QA_fetch_symbol():
url = urljoin(Binance_base_url, "/api/v1/exchangeInfo")
try:
req = requests.get(url, timeout=TIMEOUT)
except ConnectTimeout:
raise ConnectTimeout(MESSAGE_NOTICE)
body = json.loads(req.content)
return body["symbols"]
def QA_fetch_binance_symbols():
url = urljoin(Binance_base_url, "/api/v1/exchangeInfo")
try:
req = requests.get(url, timeout=TIMEOUT, proxies=proxies)
except ConnectTimeout:
raise ConnectTimeout(ILOVECHINA)
body = json.loads(req.content)
return body["symbols"]
def test_wdsl_client_error(self, client_mock):
client_mock.side_effect = ConnectTimeout()
task = Mock(retry=RetryExc)
with patch(
"treasury.api_requests.get_exponential_request_retry_countdown",
Mock()):
with self.assertRaises(RetryExc):
get_wsdl_client(task)
def raise_detailed_error(request_object):
try:
request_object.raise_for_status()
except HTTPError as e:
# raise detailed error message
# TODO: Check if we get a { "error" : "Permission denied." } and handle automatically
raise HTTPError(e, request_object.text)
except ConnectTimeout as e:
raise ConnectTimeout(e, request_object.text)
def test_connect_timeout(self):
responses.add(responses.GET,
'https://api.invoiced.com/invoices',
body=ConnectTimeout('Something went wrong'))
client = invoiced.Client('test')
with self.assertRaises(invoiced.errors.ApiConnectionError):
client.request("GET", "/invoices")
def get_player_links(team: str):
url = "http://nfl.com/teams/roster"
load = {'team': team}
try:
response = requests.get(url, load, timeout=10)
player_links = extract_links(response.text)
return player_links
except ConnectTimeout:
raise ConnectTimeout(f"Connection to {response.url} timed out!")
def test_timeout_exception_is_not_propagated_for_create_or_update(self):
dm_mailchimp_client = DMMailChimpClient('username', DUMMY_MAILCHIMP_API_KEY, logging.getLogger('mailchimp'))
with mock.patch.object(
dm_mailchimp_client._client.lists.members, 'create_or_update', autospec=True) as create_or_update:
create_or_update.side_effect = ConnectTimeout()
assert dm_mailchimp_client.subscribe_new_email_to_list('a_list_id', '*****@*****.**') == \
{"status": "error", "error_type": "unexpected_error", "status_code": 500}
assert create_or_update.called is True
def test_raises_connection_timeout_on_request(self, requests_mock):
client = Viacep(ZIPCODE)
requests_mock._adapter.register_uri('GET',
TestViacep.FAKE_URL,
exc=ConnectTimeout('Timeout'))
error, info, res = client.call(TestViacep.FAKE_URL)
assert error is True
assert info == {'error': True, 'timeout': True, 'message': 'Timeout'}
assert res is None
def test_init_timeout(self, session_patch, request_patch, client_patch):
session = session_patch.return_value
session.send = Mock(side_effect=ConnectTimeout())
with self.assertRaises(TimedOutRequestError):
Connection('SERVICE', 'HOST', None, 'CLIENT', 'USER', 'PASSWORD',
False, True)
request_patch.assert_called_once()
client_patch.assert_not_called()
def QA_fetch_bitmex_symbols(active=False):
if active:
url = urljoin(Bitmex_base_url, "instrument/active")
else:
url = urljoin(Bitmex_base_url, "instrument")
try:
req = requests.get(url, params={"count": 500}, timeout=TIMEOUT)
except ConnectTimeout:
raise ConnectTimeout(ILOVECHINA)
body = json.loads(req.content)
return body
def monkeypatch_test_client_connect_timeout_exception(
self,
method=None,
url=None,
headers=None,
params=None,
stream=False,
proxies=None,
timeout=None,
):
raise ConnectTimeout("Test Connect Timeout Error")
def QA_fetch_bitmex_symbols(active=False):
if active:
url = '%s/instrument/active' % Bitmex_base_url
else:
url = '%s/instrument' % Bitmex_base_url
try:
req = requests.get(url, timeout=TIMEOUT, proxies=proxies)
except ConnectTimeout:
raise ConnectTimeout('Bitmex connect timeout when getting symbols.')
body = json.loads(req.content)
return body
def test_shutdown_gateway_error_on_connection_timeout(self):
responses.add(
responses.POST,
TEST_SUPERVISOR_SHUTDOWN_URL,
body=ConnectTimeout('Timout trying to make connection')
)
bs = BalenaSupervisor(TEST_SUPERVISOR_ADDRESS, TEST_SUPERVISOR_API_KEY)
with self.assertRaises(Exception) as exp:
bs.shutdown()
assert str(exp.exception) == 'supervisor API not accessible'
def test_device_status_error_on_connection_timeout(self):
responses.add(
responses.GET,
TEST_SUPERVISOR_DEVICE_STATUS_URL,
body=ConnectTimeout('Timout trying to make connection')
)
bs = BalenaSupervisor(TEST_SUPERVISOR_ADDRESS, TEST_SUPERVISOR_API_KEY)
with self.assertRaises(RuntimeError) as exp:
bs.get_device_status('appState')
assert str(exp.exception).startswith("Device status request failed")
def get_short(msg, key):
if len(msg) < 20:
return msg
try:
data = post('https://www.googleapis.com/urlshortener/v1/url', params={'key': key}, data=json.dumps({'longUrl': msg}),
headers={'Content-Type': 'application/json'}, timeout=10).json()
except ConnectTimeout as e:
# Sanitize the error before throwing it
raise ConnectTimeout(re.sub('key=.*', 'key=<removed>', str(e)))
if 'error' in data:
return msg
else:
return data['id']
def test_rapid_pro_api_server_down_is_logged(self, mock_requests):
sent_message_obj = SentMessage(**self.bulk_sms_to_post).save()
network_error = 'rapid-pro server not responding in time'
mock_requests.post.side_effect = ConnectTimeout(network_error)
send_bulk_sms(sent_message_obj)
self.assertTrue(
mock_requests.post.called_once_with(
API_URL, json.dumps(self.bulk_sms_to_post), self.headers))
retrieved_sms = SentMessage.objects(**self.bulk_sms_to_post)
self.assertEqual(1, retrieved_sms.count())
self.assertEqual("ConnectTimeout: %s" % network_error,
retrieved_sms[0].log)
def test_handle_exception(self):
tests = [(RequestException(), [''], "7", "7"),
(ConnectTimeout(), [''], "7", "7"),
(RequestsConnectionError(), [''], "7", "7"),
(Exception("Any other exception"),
["Any other exception"],
"8 Any other exception", "8"
),
]
for exception, exp_data, exp_english, exp_code in tests:
self.check_st_exception(ConnectionError,
exp_data, exp_english, exp_code,
self.http_client._handle_exception,
func_args=(exception,))
async def _open_connection(self, resource, timeout=None, **kwargs):
scheme, host, port = resource.key
sock_co = curio.open_connection(
host=host,
port=port,
**kwargs
)
if timeout is not None:
sock_co = curio.timeout_after(timeout, sock_co)
try:
sock = await sock_co
except curio.TaskTimeout as ex:
raise ConnectTimeout(str(ex)) from None
conn = Connection(self._pool, resource, sock)
resource.connection = conn # bind resource & connection
return conn
