def setUp(self):
print("\n\rstarting live test binance.com-futures")
self.unicorn_fy = UnicornFy()
ubwa = BinanceWebSocketApiManager(exchange="binance.com-futures")
worker_thread = threading.Thread(
target=print_stream_data_from_stream_buffer_futures, args=(ubwa, ))
worker_thread.start()
channels = {
'aggTrade', 'trade', 'kline_1m', 'kline_5m', 'kline_15m',
'kline_30m', 'kline_1h', 'kline_2h', 'kline_4h', 'kline_6h',
'kline_8h', 'kline_12h', 'kline_1d', 'kline_3d', 'kline_1w',
'kline_1M', 'miniTicker', 'ticker', 'bookTicker', 'depth5',
'depth10', 'depth20', 'depth', 'depth@100ms'
}
arr_channels = {'!miniTicker', '!ticker', '!bookTicker'}
markets = {
'bnbbtc', 'ethbtc', 'btcusdt', 'bchabcusdt', 'xrpusdt', 'rvnbtc',
'ltcusdt', 'adausdt', 'eosusdt', 'wanbnb', 'zrxbnb', 'agibnb',
'funeth', 'arketh', 'engeth'
}
for channel in channels:
ubwa.create_stream(channel, markets, stream_label=channel)
ubwa.create_stream(arr_channels, "arr")
stream_id_trade = ubwa.get_stream_id_by_label("trade")
ubwa.get_stream_subscriptions(stream_id_trade)
time.sleep(70)
ubwa.stop_manager_with_all_streams()
except requests.exceptions.ConnectionError:
print("No internet connection?")
sys.exit(1)
worker_thread = threading.Thread(target=print_stream_data_from_stream_buffer,
args=(binance_websocket_api_manager, ))
worker_thread.start()
data = binance_rest_client.get_all_tickers()
for item in data:
markets.append(item['symbol'])
binance_websocket_api_manager.set_private_api_config(binance_api_key,
binance_api_secret)
userdata_stream_id = binance_websocket_api_manager.create_stream(["!userData"],
["arr"])
arr_stream_id = binance_websocket_api_manager.create_stream(
arr_channels, "arr")
for channel in channels:
binance_websocket_api_manager.create_stream(channel,
markets,
stream_label=channel)
stream_id_trade = binance_websocket_api_manager.get_stream_id_by_label("trade")
binance_websocket_api_manager.get_stream_subscriptions(stream_id_trade)
#while True:
# binance_websocket_api_manager.print_summary()
# time.sleep(1)
class TestBinanceComManager(unittest.TestCase):
# Test binance.com (Binance)
def setUp(self):
self.binance_com_api_key = BINANCE_COM_API_KEY
self.binance_com_api_secret = BINANCE_COM_API_SECRET
self.binance_com_websocket_api_manager = BinanceWebSocketApiManager(
exchange="binance.com", disable_colorama=True)
def test_create_uri_miniticker_regular_com(self):
self.assertEqual(
self.binance_com_websocket_api_manager.create_websocket_uri(
["!miniTicker"], ["arr"]),
'wss://stream.binance.com:9443/ws/!miniTicker@arr')
def test_create_uri_miniticker_reverse_com(self):
self.assertEqual(
self.binance_com_websocket_api_manager.create_websocket_uri(
["arr"], ["!miniTicker"]),
'wss://stream.binance.com:9443/ws/!miniTicker@arr')
def test_create_uri_ticker_regular_com(self):
self.assertEqual(
self.binance_com_websocket_api_manager.create_websocket_uri(
["!ticker"], ["arr"]),
'wss://stream.binance.com:9443/ws/!ticker@arr')
def test_create_uri_ticker_reverse_com(self):
self.assertEqual(
self.binance_com_websocket_api_manager.create_websocket_uri(
["arr"], ["!ticker"]),
'wss://stream.binance.com:9443/ws/!ticker@arr')
def test_create_uri_userdata_regular_false_com(self):
self.assertFalse(
self.binance_com_websocket_api_manager.create_websocket_uri(
["!userData"], ["arr"]))
def test_create_uri_userdata_reverse_false_com(self):
self.assertFalse(
self.binance_com_websocket_api_manager.create_websocket_uri(
["arr"], ["!userData"]))
def test_create_uri_userdata_regular_com(self):
if len(self.binance_com_api_key) == 0 or len(
self.binance_com_api_secret) == 0:
print(
"\r\nempty API key and/or secret: can not successfully test test_create_uri_userdata_regular_com() "
"for binance.com")
else:
stream_id = uuid.uuid4()
self.binance_com_websocket_api_manager._add_socket_to_socket_list(
stream_id, ["!userData"], ["arr"])
self.assertRegex(
self.binance_com_websocket_api_manager.create_websocket_uri(
["!userData"], ["arr"], stream_id,
self.binance_com_api_key, self.binance_com_api_secret),
r'wss://stream.binance.com:9443/ws/.')
def test_create_uri_userdata_reverse_com(self):
if len(self.binance_com_api_key) == 0 or len(
self.binance_com_api_secret) == 0:
print(
"\r\nempty API key and/or secret: can not successfully test test_create_uri_userdata_reverse_com() "
"for binance.com")
else:
stream_id = uuid.uuid4()
self.binance_com_websocket_api_manager._add_socket_to_socket_list(
stream_id, ["arr"], ["!userData"])
self.assertRegex(
self.binance_com_websocket_api_manager.create_websocket_uri(
["arr"], ["!userData"], stream_id,
self.binance_com_api_key, self.binance_com_api_secret),
r'wss://stream.binance.com:9443/ws/.')
def test_is_exchange_type_cex(self):
self.assertEqual(
self.binance_com_websocket_api_manager.is_exchange_type("cex"),
True)
def test_is_exchange_type_dex(self):
self.assertEqual(
self.binance_com_websocket_api_manager.is_exchange_type("dex"),
False)
def test_is_update_available(self):
self.assertEqual(
self.binance_com_websocket_api_manager.is_update_availabe(), False)
def test_is_manager_stopping(self):
self.assertEqual(
self.binance_com_websocket_api_manager.is_manager_stopping(),
False)
def test_get_human_uptime(self):
self.assertEqual(
self.binance_com_websocket_api_manager.get_human_uptime(
60 * 60 * 60 * 61), "152d:12h:0m:0s")
self.assertEqual(
self.binance_com_websocket_api_manager.get_human_uptime(
60 * 60 * 24), "24h:0m:0s")
self.assertEqual(
self.binance_com_websocket_api_manager.get_human_uptime(60 * 60),
"60m:0s")
self.assertEqual(
self.binance_com_websocket_api_manager.get_human_uptime(60),
"60 seconds")
def test_get_human_bytesize(self):
self.assertEqual(
self.binance_com_websocket_api_manager.get_human_bytesize(
1024 * 1024 * 1024 * 1024 * 1024), "1024.0 tB")
self.assertEqual(
self.binance_com_websocket_api_manager.get_human_bytesize(
1024 * 1024 * 1024 * 1024), "1024.0 gB")
self.assertEqual(
self.binance_com_websocket_api_manager.get_human_bytesize(
1024 * 1024 * 1024), "1024.0 mB")
self.assertEqual(
self.binance_com_websocket_api_manager.get_human_bytesize(
1024 * 1024), "1024.0 kB")
self.assertEqual(
self.binance_com_websocket_api_manager.get_human_bytesize(1024),
"1024 B")
self.assertEqual(
self.binance_com_websocket_api_manager.get_human_bytesize(1),
"1 B")
def test_get_exchange(self):
self.assertEqual(self.binance_com_websocket_api_manager.get_exchange(),
"binance.com")
def test_get_listenkey_from_restclient(self):
self.assertEqual(
self.binance_com_websocket_api_manager.
get_listen_key_from_restclient(), False)
def test_get_listenkey_from_restclient(self):
stream_id = uuid.uuid4()
self.assertEqual(
self.binance_com_websocket_api_manager.
delete_listen_key_by_stream_id(stream_id), False)
def test_keepalive_listen_key(self):
stream_id = uuid.uuid4()
binance_websocket_api_restclient = BinanceWebSocketApiRestclient(
self.binance_com_websocket_api_manager)
self.assertEqual(
str(
binance_websocket_api_restclient.keepalive_listen_key(
stream_id, listen_key="invalid_testkey")),
"{'code': -2014, 'msg': 'API-key format invalid.'}")
def test_delete_listen_key(self):
stream_id = uuid.uuid4()
binance_websocket_api_restclient = BinanceWebSocketApiRestclient(
self.binance_com_websocket_api_manager)
self.assertEqual(
str(
binance_websocket_api_restclient.delete_listen_key(
stream_id, listen_key="invalid_testkey")),
"{'code': -2014, 'msg': 'API-key format invalid.'}")
self.binance_com_websocket_api_manager.show_secrets_in_logs = True
self.assertEqual(
str(
binance_websocket_api_restclient.delete_listen_key(
stream_id, listen_key="invalid_testkey")),
"{'code': -2014, 'msg': 'API-key format invalid.'}")
def test_create_payload_subscribe(self):
result = "[{'method': 'SUBSCRIBE', 'params': ['bnbbtc@kline_1m'], 'id': 1}]"
stream_id = uuid.uuid4()
self.assertEqual(
str(
self.binance_com_websocket_api_manager.create_payload(
stream_id, "subscribe", ['kline_1m'], ['bnbbtc'])), result)
def test_fill_up_space_centered(self):
result = "==========test text=========="
self.assertEqual(
str(
self.binance_com_websocket_api_manager.fill_up_space_centered(
30, "test text", "=")), result)
def test_fill_up_space_right(self):
result = "|test text||||||||||||||||||||"
self.assertEqual(
str(
self.binance_com_websocket_api_manager.fill_up_space_right(
30, "test text", "|")), result)
def test_fill_up_space_left(self):
result = "||||||||||||||||||||test text|"
self.assertEqual(
str(
self.binance_com_websocket_api_manager.fill_up_space_left(
30, "test text", "|")), result)
def test_create_stream(self):
self.assertTrue(
bool(
self.binance_com_websocket_api_manager.create_stream(
'arr', '!userData', "userData", "key", "secret")))
self.assertTrue(
bool(
self.binance_com_websocket_api_manager.create_stream(
markets=['bnbbtc'],
channels="trade",
stream_label="test_stream")))
stream_id = self.binance_com_websocket_api_manager.get_stream_id_by_label(
"test_stream")
#time.sleep(5)
#self.binance_com_websocket_api_manager.unsubscribe_from_stream(stream_id, markets=['bnbbtc'])
#self.binance_com_websocket_api_manager.unsubscribe_from_stream(stream_id, channels=['trade'])
time.sleep(5)
self.assertTrue(
self.binance_com_websocket_api_manager.set_restart_request(
stream_id))
time.sleep(10)
self.binance_com_websocket_api_manager.get_monitoring_status_icinga()
self.binance_com_websocket_api_manager.print_summary()
self.binance_com_websocket_api_manager.print_stream_info(stream_id)
def test_restart_stream(self):
self.assertFalse(
bool(
self.binance_com_websocket_api_manager._restart_stream(
uuid.uuid4())))
def test_start_monitoring_api(self):
self.assertTrue(
self.binance_com_websocket_api_manager.start_monitoring_api())
time.sleep(5)
self.assertTrue(
self.binance_com_websocket_api_manager.stop_monitoring_api())
def tearDown(self):
self.binance_com_websocket_api_manager.stop_manager_with_all_streams()
