ccxt 4.2.30__py2.py3-none-any.whl → 4.2.34__py2.py3-none-any.whl

ccxt/test/test_async.py

@@ -27,7 +27,7 @@ import asyncio
 from ccxt.base.errors import NotSupported
 from ccxt.base.errors import ProxyError
 from ccxt.base.errors import OperationFailed
-from ccxt.base.errors import ExchangeError
+# from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ExchangeNotAvailable
 from ccxt.base.errors import OnMaintenance
 from ccxt.base.errors import AuthenticationError
@@ -128,6 +128,7 @@ class baseMainTestClass():
     response_tests_failed = False
     response_tests = False
     ws_tests = False
+    load_keys = False
     skipped_methods = {}
     check_public_tests = {}
     test_files = {}
@@ -146,6 +147,9 @@ def dump(*args):
     print(' '.join([str(arg) for arg in args]))
 
 
+def convert_ascii(str):
+    return str  # stub
+
 def json_parse(elem):
     return json.loads(elem)
 
@@ -270,6 +274,7 @@ class testMainClass(baseMainTestClass):
         self.private_test = get_cli_arg_value('--private')
         self.private_test_only = get_cli_arg_value('--privateOnly')
         self.sandbox = get_cli_arg_value('--sandbox')
+        self.load_keys = get_cli_arg_value('--loadKeys')
         self.ws_tests = get_cli_arg_value('--ws')
 
     async def init(self, exchange_id, symbol_argv):
@@ -288,11 +293,12 @@ class testMainClass(baseMainTestClass):
             await self.run_broker_id_tests()
             return
         symbol_str = symbol_argv if symbol_argv is not None else 'all'
-        dump(self.new_line + '' + self.new_line + '' + '[INFO] TESTING ', self.ext, {
+        exchange_object = {
             'exchange': exchange_id,
             'symbol': symbol_str,
             'isWs': self.ws_tests,
-        }, self.new_line)
+        }
+        dump(self.new_line + '' + self.new_line + '' + '[INFO] TESTING ', self.ext, json_stringify(exchange_object), self.new_line)
         exchange_args = {
             'verbose': self.verbose,
             'debug': self.debug,
@@ -300,6 +306,8 @@ class testMainClass(baseMainTestClass):
             'timeout': 30000,
         }
         exchange = init_exchange(exchange_id, exchange_args, self.ws_tests)
+        if exchange.alias:
+            exit_script(0)
         await self.import_files(exchange)
         assert len(list(self.test_files.keys())) > 0, 'Test files were not loaded'  # ensure test files are found & filled
         self.expand_settings(exchange)
@@ -373,7 +381,7 @@ class testMainClass(baseMainTestClass):
         # others
         timeout = exchange.safe_value(skipped_settings_for_exchange, 'timeout')
         if timeout is not None:
-            exchange.timeout = timeout
+            exchange.timeout = exchange.parse_to_int(timeout)
         if get_cli_arg_value('--useProxy'):
             exchange.http_proxy = exchange.safe_string(skipped_settings_for_exchange, 'httpProxy')
             exchange.https_proxy = exchange.safe_string(skipped_settings_for_exchange, 'httpsProxy')
@@ -445,6 +453,7 @@ class testMainClass(baseMainTestClass):
         # if it was passed successfully, add to the list of successfull tests
         if is_public:
             self.checked_public_tests[method_name] = True
+        return
 
     async def test_safe(self, method_name, exchange, args=[], is_public=False):
         # `testSafe` method does not throw an exception, instead mutes it. The reason we
@@ -505,6 +514,7 @@ class testMainClass(baseMainTestClass):
                     else:
                         dump('[TEST_FAILURE]', exception_message(e), self.exchange_hint(exchange), method_name, args_stringified)
                         return False
+        return True
 
     async def run_public_tests(self, exchange, symbol):
         tests = {
@@ -701,7 +711,7 @@ class testMainClass(baseMainTestClass):
             dump('[INFO] Skipping private tests', 'Keys not found')
             return
         code = self.get_exchange_code(exchange)
-        # if (exchange.extendedTest) {
+        # if (exchange.deepExtendedTest) {
         #     await test ('InvalidNonce', exchange, symbol);
         #     await test ('OrderNotFound', exchange, symbol);
         #     await test ('InvalidOrder', exchange, symbol);
@@ -778,7 +788,7 @@ class testMainClass(baseMainTestClass):
                 exception = e
         # if exception was set, then throw it
         if exception:
-            raise ExchangeError('[TEST_FAILURE] Failed ' + proxy_test_name + ' : ' + exception_message(exception))
+            error_message = '[TEST_FAILURE] Failed ' + proxy_test_name + ' : ' + exception_message(exception)
 
     async def start_test(self, exchange, symbol):
         # we do not need to test aliases
@@ -881,9 +891,9 @@ class testMainClass(baseMainTestClass):
 
     def assert_new_and_stored_output(self, exchange, skip_keys, new_output, stored_output, strict_type_check=True, asserting_key=None):
         if is_null_value(new_output) and is_null_value(stored_output):
-            return
+            return True
         if not new_output and not stored_output:
-            return
+            return True
         if (isinstance(stored_output, dict)) and (isinstance(new_output, dict)):
             stored_output_keys = list(stored_output.keys())
             new_output_keys = list(new_output.keys())
@@ -915,7 +925,7 @@ class testMainClass(baseMainTestClass):
             new_output_string = str(sanitized_new_output) if sanitized_new_output else 'undefined'
             stored_output_string = str(sanitized_stored_output) if sanitized_stored_output else 'undefined'
             message_error = 'output value mismatch:' + new_output_string + ' != ' + stored_output_string
-            if strict_type_check:
+            if strict_type_check and (self.lang != 'C#'):
                 # upon building the request we want strict type check to make sure all the types are correct
                 # when comparing the response we want to allow some flexibility, because a 50.0 can be equal to 50 after saving it to the json file
                 self.assert_static_error(sanitized_new_output == sanitized_stored_output, message_error, stored_output, new_output, asserting_key)
@@ -924,11 +934,34 @@ class testMainClass(baseMainTestClass):
                 is_string = (isinstance(sanitized_new_output, str)) or (isinstance(sanitized_stored_output, str))
                 is_undefined = (sanitized_new_output is None) or (sanitized_stored_output is None)  # undefined is a perfetly valid value
                 if is_boolean or is_string or is_undefined:
-                    self.assert_static_error(new_output_string == stored_output_string, message_error, stored_output, new_output, asserting_key)
+                    if self.lang == 'C#':
+                        # tmp c# number comparsion
+                        is_number = False
+                        try:
+                            exchange.parse_to_numeric(sanitized_new_output)
+                            is_number = True
+                        except Exception as e:
+                            # if we can't parse it to number, then it's not a number
+                            is_number = False
+                        if is_number:
+                            self.assert_static_error(exchange.parse_to_numeric(sanitized_new_output) == exchange.parse_to_numeric(sanitized_stored_output), message_error, stored_output, new_output, asserting_key)
+                            return True
+                        else:
+                            self.assert_static_error(convert_ascii(new_output_string) == convert_ascii(stored_output_string), message_error, stored_output, new_output, asserting_key)
+                            return True
+                    else:
+                        self.assert_static_error(convert_ascii(new_output_string) == convert_ascii(stored_output_string), message_error, stored_output, new_output, asserting_key)
+                        return True
                 else:
-                    numeric_new_output = exchange.parse_to_numeric(new_output_string)
-                    numeric_stored_output = exchange.parse_to_numeric(stored_output_string)
-                    self.assert_static_error(numeric_new_output == numeric_stored_output, message_error, stored_output, new_output, asserting_key)
+                    if self.lang == 'C#':
+                        stringified_new_output = exchange.number_to_string(sanitized_new_output)
+                        stringified_stored_output = exchange.number_to_string(sanitized_stored_output)
+                        self.assert_static_error(str(stringified_new_output) == str(stringified_stored_output), message_error, stored_output, new_output, asserting_key)
+                    else:
+                        numeric_new_output = exchange.parse_to_numeric(new_output_string)
+                        numeric_stored_output = exchange.parse_to_numeric(stored_output_string)
+                        self.assert_static_error(numeric_new_output == numeric_stored_output, message_error, stored_output, new_output, asserting_key)
+        return True   # c# requ
 
     def assert_static_request_output(self, exchange, type, skip_keys, stored_url, request_url, stored_output, new_output):
         if stored_url != request_url:
@@ -952,12 +985,12 @@ class testMainClass(baseMainTestClass):
                 new_url_params = self.urlencoded_to_dict(new_url_query)
                 self.assert_new_and_stored_output(exchange, skip_keys, new_url_params, stored_url_params)
                 return
-        if type == 'json':
+        if type == 'json' and (stored_output is not None) and (new_output is not None):
             if isinstance(stored_output, str):
                 stored_output = json_parse(stored_output)
             if isinstance(new_output, str):
                 new_output = json_parse(new_output)
-        elif type == 'urlencoded':
+        elif type == 'urlencoded' and (stored_output is not None) and (new_output is not None):
             stored_output = self.urlencoded_to_dict(stored_output)
             new_output = self.urlencoded_to_dict(new_output)
         elif type == 'both':
@@ -1071,8 +1104,9 @@ class testMainClass(baseMainTestClass):
                 skip_keys = exchange.safe_value(exchange_data, 'skipKeys', [])
                 await self.test_method_statically(exchange, method, result, type, skip_keys)
                 # reset options
-                exchange.options = old_exchange_options
+                exchange.options = exchange.deep_extend(old_exchange_options, {})
         await close(exchange)
+        return True   # in c# methods that will be used with promiseAll need to return something
 
     async def test_exchange_response_statically(self, exchange_name, exchange_data, test_name=None):
         exchange = self.init_offline_exchange(exchange_name)
@@ -1092,16 +1126,20 @@ class testMainClass(baseMainTestClass):
                 is_disabled = exchange.safe_value(result, 'disabled', False)
                 if is_disabled:
                     continue
+                is_disabled_c_sharp = exchange.safe_value(result, 'disabledCS', False)
+                if is_disabled_c_sharp and (self.lang == 'C#'):
+                    continue
                 is_disabled_php = exchange.safe_value(result, 'disabledPHP', False)
-                if is_disabled_php and (self.ext == 'php'):
+                if is_disabled_php and (self.lang == 'PHP'):
                     continue
                 if (test_name is not None) and (test_name != description):
                     continue
                 skip_keys = exchange.safe_value(exchange_data, 'skipKeys', [])
                 await self.test_response_statically(exchange, method, skip_keys, result)
                 # reset options
-                exchange.options = old_exchange_options
+                exchange.options = exchange.deep_extend(old_exchange_options, {})
         await close(exchange)
+        return True   # in c# methods that will be used with promiseAll need to return something
 
     def get_number_of_tests_from_exchange(self, exchange, exchange_data):
         sum = 0
@@ -1171,7 +1209,7 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             spot_order_request = self.urlencoded_to_dict(exchange.last_request_body)
         client_order_id = spot_order_request['newClientOrderId']
-        assert client_order_id.startswith(spot_id), 'spot clientOrderId does not start with spotId'
+        assert client_order_id.startswith(str(spot_id)), 'spot clientOrderId does not start with spotId'
         swap_id = 'x-xcKtGhcu'
         swap_order_request = None
         try:
@@ -1184,10 +1222,11 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             swap_inverse_order_request = self.urlencoded_to_dict(exchange.last_request_body)
         client_order_id_spot = swap_order_request['newClientOrderId']
-        assert client_order_id_spot.startswith(swap_id), 'swap clientOrderId does not start with swapId'
+        assert client_order_id_spot.startswith(str(swap_id)), 'swap clientOrderId does not start with swapId'
         client_order_id_inverse = swap_inverse_order_request['newClientOrderId']
-        assert client_order_id_inverse.startswith(swap_id), 'swap clientOrderIdInverse does not start with swapId'
+        assert client_order_id_inverse.startswith(str(swap_id)), 'swap clientOrderIdInverse does not start with swapId'
         await close(exchange)
+        return True
 
     async def test_okx(self):
         exchange = self.init_offline_exchange('okx')
@@ -1198,7 +1237,7 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             spot_order_request = json_parse(exchange.last_request_body)
         client_order_id = spot_order_request[0]['clOrdId']  # returns order inside array
-        assert client_order_id.startswith(id), 'spot clientOrderId does not start with id'
+        assert client_order_id.startswith(str(id)), 'spot clientOrderId does not start with id'
         assert spot_order_request[0]['tag'] == id, 'id different from spot tag'
         swap_order_request = None
         try:
@@ -1206,9 +1245,10 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             swap_order_request = json_parse(exchange.last_request_body)
         client_order_id_spot = swap_order_request[0]['clOrdId']
-        assert client_order_id_spot.startswith(id), 'swap clientOrderId does not start with id'
+        assert client_order_id_spot.startswith(str(id)), 'swap clientOrderId does not start with id'
         assert swap_order_request[0]['tag'] == id, 'id different from swap tag'
         await close(exchange)
+        return True
 
     async def test_cryptocom(self):
         exchange = self.init_offline_exchange('cryptocom')
@@ -1221,6 +1261,7 @@ class testMainClass(baseMainTestClass):
             request = json_parse(exchange.last_request_body)
         assert request['params']['broker_id'] == id, 'id different from  broker_id'
         await close(exchange)
+        return True
 
     async def test_bybit(self):
         exchange = self.init_offline_exchange('bybit')
@@ -1234,6 +1275,7 @@ class testMainClass(baseMainTestClass):
             req_headers = exchange.last_request_headers
         assert req_headers['Referer'] == id, 'id not in headers'
         await close(exchange)
+        return True
 
     async def test_kucoin(self):
         exchange = self.init_offline_exchange('kucoin')
@@ -1248,19 +1290,21 @@ class testMainClass(baseMainTestClass):
         id = 'ccxt'
         assert req_headers['KC-API-PARTNER'] == id, 'id not in headers'
         await close(exchange)
+        return True
 
     async def test_kucoinfutures(self):
-        kucoin = self.init_offline_exchange('kucoinfutures')
+        exchange = self.init_offline_exchange('kucoinfutures')
         req_headers = None
         id = 'ccxtfutures'
-        assert kucoin.options['partner']['future']['id'] == id, 'id not in options'
-        assert kucoin.options['partner']['future']['key'] == '1b327198-f30c-4f14-a0ac-918871282f15', 'key not in options'
+        assert exchange.options['partner']['future']['id'] == id, 'id not in options'
+        assert exchange.options['partner']['future']['key'] == '1b327198-f30c-4f14-a0ac-918871282f15', 'key not in options'
         try:
-            await kucoin.create_order('BTC/USDT:USDT', 'limit', 'buy', 1, 20000)
+            await exchange.create_order('BTC/USDT:USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
-            req_headers = kucoin.last_request_headers
+            req_headers = exchange.last_request_headers
         assert req_headers['KC-API-PARTNER'] == id, 'id not in headers'
-        await close(kucoin)
+        await close(exchange)
+        return True
 
     async def test_bitget(self):
         exchange = self.init_offline_exchange('bitget')
@@ -1273,6 +1317,7 @@ class testMainClass(baseMainTestClass):
             req_headers = exchange.last_request_headers
         assert req_headers['X-CHANNEL-API-CODE'] == id, 'id not in headers'
         await close(exchange)
+        return True
 
     async def test_mexc(self):
         exchange = self.init_offline_exchange('mexc')
@@ -1286,6 +1331,7 @@ class testMainClass(baseMainTestClass):
             req_headers = exchange.last_request_headers
         assert req_headers['source'] == id, 'id not in headers'
         await close(exchange)
+        return True
 
     async def test_htx(self):
         exchange = self.init_offline_exchange('htx')
@@ -1297,7 +1343,7 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             spot_order_request = json_parse(exchange.last_request_body)
         client_order_id = spot_order_request['client-order-id']
-        assert client_order_id.startswith(id), 'spot clientOrderId does not start with id'
+        assert client_order_id.startswith(str(id)), 'spot clientOrderId does not start with id'
         # swap test
         swap_order_request = None
         try:
@@ -1310,10 +1356,11 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             swap_inverse_order_request = json_parse(exchange.last_request_body)
         client_order_id_spot = swap_order_request['channel_code']
-        assert client_order_id_spot.startswith(id), 'swap channel_code does not start with id'
+        assert client_order_id_spot.startswith(str(id)), 'swap channel_code does not start with id'
         client_order_id_inverse = swap_inverse_order_request['channel_code']
-        assert client_order_id_inverse.startswith(id), 'swap inverse channel_code does not start with id'
+        assert client_order_id_inverse.startswith(str(id)), 'swap inverse channel_code does not start with id'
         await close(exchange)
+        return True
 
     async def test_woo(self):
         exchange = self.init_offline_exchange('woo')
@@ -1325,7 +1372,7 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             spot_order_request = self.urlencoded_to_dict(exchange.last_request_body)
         broker_id = spot_order_request['broker_id']
-        assert broker_id.startswith(id), 'broker_id does not start with id'
+        assert broker_id.startswith(str(id)), 'broker_id does not start with id'
         # swap test
         stop_order_request = None
         try:
@@ -1335,8 +1382,9 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             stop_order_request = json_parse(exchange.last_request_body)
         client_order_id_spot = stop_order_request['brokerId']
-        assert client_order_id_spot.startswith(id), 'brokerId does not start with id'
+        assert client_order_id_spot.startswith(str(id)), 'brokerId does not start with id'
         await close(exchange)
+        return True
 
     async def test_bitmart(self):
         exchange = self.init_offline_exchange('bitmart')
@@ -1350,6 +1398,7 @@ class testMainClass(baseMainTestClass):
             req_headers = exchange.last_request_headers
         assert req_headers['X-BM-BROKER-ID'] == id, 'id not in headers'
         await close(exchange)
+        return True
 
     async def test_coinex(self):
         exchange = self.init_offline_exchange('coinex')
@@ -1361,8 +1410,9 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             spot_order_request = json_parse(exchange.last_request_body)
         client_order_id = spot_order_request['client_id']
-        assert client_order_id.startswith(id), 'clientOrderId does not start with id'
+        assert client_order_id.startswith(str(id)), 'clientOrderId does not start with id'
         await close(exchange)
+        return True
 
     async def test_bingx(self):
         exchange = self.init_offline_exchange('bingx')
@@ -1386,7 +1436,7 @@ class testMainClass(baseMainTestClass):
         except Exception as e:
             request = json_parse(exchange.last_request_body)
         client_order_id = request['clOrdID']
-        assert client_order_id.startswith(id), 'clOrdID does not start with id'
+        assert client_order_id.startswith(str(id)), 'clOrdID does not start with id'
         await close(exchange)
 
 # ***** AUTO-TRANSPILER-END *****