def test_listen_for_user_stream_does_not_queue_empty_payload(
self, mock_api, mock_ws):
url = web_utils.private_rest_url(path_url=CONSTANTS.USER_ID_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response = {
'id': 'ffffffff-ffff-ffff-ffff-ffffffffff',
'status': 'ACTIVE',
'role': 'INVESTOR',
'email': '*****@*****.**',
'phone': '',
'authorities': [],
'forceChangePassword': None,
'authType': 'API_KEY',
'socials': []
}
mock_api.get(regex_url, body=json.dumps(mock_response))
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value, "")
msg_queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(msg_queue))
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(
mock_ws.return_value)
self.assertEqual(0, msg_queue.qsize())
def test_listen_for_user_stream_connection_failed(self, mock_api, mock_ws):
url = web_utils.private_rest_url(path_url=CONSTANTS.USER_ID_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response = {
'id': 'ffffffff-ffff-ffff-ffff-ffffffffff',
'status': 'ACTIVE',
'role': 'INVESTOR',
'email': '*****@*****.**',
'phone': '',
'authorities': [],
'forceChangePassword': None,
'authType': 'API_KEY',
'socials': []
}
mock_api.get(regex_url, body=json.dumps(mock_response))
mock_ws.side_effect = lambda *arg, **kwars: self._create_exception_and_unlock_test_with_event(
Exception("TEST ERROR."))
msg_queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(msg_queue))
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..."
))
async def rest_auth(self, path_url: str) -> Dict[Any, Any]:
"""REST private GET request"""
url = web_utils.private_rest_url(path_url=path_url, domain=self.domain)
headers = {"Content-Type": "application/x-www-form-urlencoded"}
request = RESTRequest(method=RESTMethod.GET,
url=url,
headers=headers,
is_auth_required=True)
client = await self.api_factory.get_rest_assistant()
response: RESTResponse = await client.call(request)
return await response.json()
def test_get_listen_key_log_exception(self, mock_api):
url = web_utils.private_rest_url(path_url=CONSTANTS.USER_ID_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url,
status=400,
body=json.dumps(self._error_response()))
with self.assertRaises(IOError):
self.async_run_with_timeout(self.data_source._get_listen_key())
async def rest_auth_post(self, json) -> Dict[Any, Any]:
"""REST private POST request (order placement)"""
url = web_utils.private_rest_url(CONSTANTS.ORDER_PATH_URL,
domain=self.domain)
method = RESTMethod.POST
headers = {
"Content-Type":
"application/json" if method == RESTMethod.POST else
"application/x-www-form-urlencoded"
}
request = RESTRequest(method=method,
url=url,
data=json,
params=None,
headers=headers,
is_auth_required=True)
client = await self.api_factory.get_rest_assistant()
response = await client.call(request)
return await response.json()
def test_ping_listen_key_log_exception(self, mock_api):
url = web_utils.private_rest_url(path_url=CONSTANTS.USER_ID_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_api.get(regex_url,
status=400,
body=json.dumps(self._error_response()))
self.data_source._current_listen_key = self.listen_key
result: bool = self.async_run_with_timeout(
self.data_source._ping_listen_key())
self.assertTrue(
self._is_logged(
"WARNING",
f"Failed to refresh the listen key {self.listen_key}: {self._error_response()}"
))
self.assertFalse(result)
def test_ping_listen_key_successful(self, mock_api):
url = web_utils.private_rest_url(path_url=CONSTANTS.USER_ID_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response = {
'id': 'ffffffff-ffff-ffff-ffff-ffffffffff',
'status': 'ACTIVE',
'role': 'INVESTOR',
'email': '*****@*****.**',
'phone': '',
'authorities': [],
'forceChangePassword': None,
'authType': 'API_KEY',
'socials': []
}
mock_api.get(regex_url, body=json.dumps(mock_response))
self.data_source._current_listen_key = self.listen_key
result: bool = self.async_run_with_timeout(
self.data_source._ping_listen_key())
self.assertTrue(result)
def test_listen_for_user_stream_get_listen_key_successful_with_user_update_event(
self, mock_api, mock_ws):
url = web_utils.private_rest_url(path_url=CONSTANTS.USER_ID_PATH_URL,
domain=self.domain)
regex_url = re.compile(f"^{url}".replace(".",
r"\.").replace("?", r"\?"))
mock_response = {
'id': 'ffffffff-ffff-ffff-ffff-ffffffffff',
'status': 'ACTIVE',
'role': 'INVESTOR',
'email': '*****@*****.**',
'phone': '',
'authorities': [],
'forceChangePassword': None,
'authType': 'API_KEY',
'socials': []
}
mock_api.get(regex_url, body=json.dumps(mock_response))
mock_ws.return_value = self.mocking_assistant.create_websocket_mock()
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value,
self._successfully_subscribed_event(),
message_type=aiohttp.WSMsgType.BINARY)
self.mocking_assistant.add_websocket_aiohttp_message(
mock_ws.return_value,
self._user_update_event(),
message_type=aiohttp.WSMsgType.BINARY)
msg_queue = asyncio.Queue()
self.listening_task = self.ev_loop.create_task(
self.data_source.listen_for_user_stream(msg_queue))
msg = self.async_run_with_timeout(msg_queue.get())
self.assertTrue(msg, self._user_update_event)
def test_private_rest_url(self):
path_url = "/auth/account"
expected_url = CONSTANTS.REST_URL.format(
self.endpoint, self.domain) + CONSTANTS.REST_API_VERSION + path_url
self.assertEqual(expected_url,
web_utils.private_rest_url(path_url, self.domain))
