def test_user_stream_tracker(self, mock_ws):
user_stream_tracker = CoinflexUserStreamTracker(
auth=CoinflexAuth(api_key="TEST_API_KEY", secret_key="TEST_SECRET"),
domain=self.domain,
throttler=self.throttler
)
msg_queue: asyncio.Queue = asyncio.Queue()
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
mock_ws.return_value.receive.side_effect = (lambda *args, **kwargs:
self._create_exception_and_unlock_test_with_event(
Exception("TEST ERROR")))
mock_ws.close.return_value = None
user_stream_tracker._ev_loop = self.ev_loop
user_stream_tracker._user_stream = msg_queue
self.listening_task = self.ev_loop.create_task(
user_stream_tracker.start()
)
self.async_run_with_timeout(self.resume_test_event.wait())
self.assertTrue(
self._is_logged(
"ERROR",
"Unexpected error while listening to user stream. Retrying after 5 seconds..."))
def setUpClass(cls):
cls.ev_loop: asyncio.BaseEventLoop = asyncio.get_event_loop()
cls._throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
cls._domain = os.getenv("COINFLEX_DOMAIN", "live")
cls._test_order_id = os.getenv("TEST_ORDER_STATUS_ID")
cls._logger = logging.getLogger(__name__)
api_key = conf.coinflex_api_key
secret_key = conf.coinflex_api_secret
cls._auth = CoinflexAuth(api_key=api_key, secret_key=secret_key)
cls._api_factory = build_api_factory(auth=cls._auth)
def test_rest_authenticate(self, time_mock):
now = 1234567890.000
time_mock.return_value = now
params = {
"symbol": "LTCBTC",
"side": "BUY",
"type": "LIMIT",
"timeInForce": "GTC",
"quantity": 1,
"price": "0.1",
}
full_params = copy(params)
auth = CoinflexAuth(api_key=self._api_key, secret_key=self._secret)
request = CoinflexRESTRequest(method=RESTMethod.GET,
endpoint="",
params=params,
is_auth_required=True)
configured_request = self.async_run_with_timeout(
auth.rest_authenticate(request))
str_timestamp = datetime.fromtimestamp(now).isoformat()
nonce = int(now * 1e3)
encoded_params = "&".join(
[f"{key}={value}" for key, value in full_params.items()])
payload = '{}\n{}\n{}\n{}\n{}\n{}'.format(str_timestamp, nonce,
str(RESTMethod.GET),
request.auth_url,
request.auth_path,
encoded_params)
expected_signature = b64encode(
hmac.new(self._secret.encode("utf-8"), payload.encode("utf-8"),
hashlib.sha256).digest()).decode().strip()
expected_headers = {
"AccessKey": self._api_key,
"Timestamp": str_timestamp,
"Signature": expected_signature,
"Nonce": str(nonce),
}
self.assertEqual(expected_headers, configured_request.headers)
def setUpClass(cls):
cls.ev_loop: asyncio.BaseEventLoop = asyncio.get_event_loop()
cls.trading_pairs = ["BTC-USD"]
cls.user_stream_tracker: CoinflexUserStreamTracker = CoinflexUserStreamTracker(
domain=os.getenv("COINFLEX_DOMAIN", "live"),
auth=CoinflexAuth(api_key=cls.api_key,
secret_key=cls.api_secret,
time_provider=TimeSynchronizer()))
cls.user_stream_tracker_task: asyncio.Task = safe_ensure_future(
cls.user_stream_tracker.start())
def setUp(self) -> None:
super().setUp()
self.log_records = []
self.listening_task: Optional[asyncio.Task] = None
self.mocking_assistant = NetworkMockingAssistant()
self.throttler = AsyncThrottler(rate_limits=CONSTANTS.RATE_LIMITS)
self.data_source = CoinflexAPIUserStreamDataSource(
auth=CoinflexAuth(api_key="TEST_API_KEY", secret_key="TEST_SECRET"),
domain=self.domain,
throttler=self.throttler
)
self.data_source.logger().setLevel(1)
self.data_source.logger().addHandler(self)
self.resume_test_event = asyncio.Event()
def __init__(self,
coinflex_api_key: str,
coinflex_api_secret: str,
trading_pairs: Optional[List[str]] = None,
trading_required: bool = True,
domain: str = CONSTANTS.DEFAULT_DOMAIN):
self._domain = domain
super().__init__()
self._trading_required = trading_required
self._auth = CoinflexAuth(api_key=coinflex_api_key,
secret_key=coinflex_api_secret)
self._throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS)
self._api_factory = web_utils.build_api_factory(auth=self._auth)
self._order_book_tracker = CoinflexOrderBookTracker(
trading_pairs=trading_pairs,
domain=domain,
api_factory=self._api_factory,
throttler=self._throttler)
self._user_stream_tracker = CoinflexUserStreamTracker(
auth=self._auth,
domain=domain,
throttler=self._throttler,
api_factory=self._api_factory)
self._ev_loop = asyncio.get_event_loop()
self._poll_notifier = asyncio.Event()
self._last_timestamp = 0
self._order_not_found_records = {
} # Dict[client_order_id:str, count:int]
self._trading_rules = {} # Dict[trading_pair:str, TradingRule]
self._trade_fees = {
} # Dict[trading_pair:str, (maker_fee_percent:Decimal, taken_fee_percent:Decimal)]
self._last_update_trade_fees_timestamp = 0
self._status_polling_task = None
self._user_stream_event_listener_task = None
self._trading_rules_polling_task = None
self._last_poll_timestamp = 0
self._last_trades_poll_coinflex_timestamp = 0
self._order_tracker: ClientOrderTracker = ClientOrderTracker(
connector=self)