ccxt 4.1.54__py2.py3-none-any.whl → 4.1.56__py2.py3-none-any.whl

ccxt/test/test_async.py

@@ -21,11 +21,22 @@ sys.path.append(root)
 import ccxt.async_support as ccxt  # noqa: E402
 
 # ------------------------------------------------------------------------------
+import asyncio
+# from typing import Optional
+# from typing import List
+from ccxt.base.errors import NotSupported
+from ccxt.base.errors import NetworkError
+from ccxt.base.errors import ExchangeNotAvailable
+from ccxt.base.errors import OnMaintenance
+from ccxt.base.errors import AuthenticationError
 
+# ------------------------------------------------------------------------------
 
 class Argv(object):
-    idTests = False
-    staticTests = False
+    id_tests = False
+    static_tests = False
+    request_tests = False
+    response_tests = False
     token_bucket = False
     sandbox = False
     privateOnly = False
@@ -48,6 +59,8 @@ parser.add_argument('--verbose', action='store_true', help='enable verbose outpu
 parser.add_argument('--info', action='store_true', help='enable info output')
 parser.add_argument('--static', action='store_true', help='run static tests')
 parser.add_argument('--idTests', action='store_true', help='run brokerId tests')
+parser.add_argument('--responseTests', action='store_true', help='run response tests')
+parser.add_argument('--requestTests', action='store_true', help='run response tests')
 parser.add_argument('--nonce', type=int, help='integer')
 parser.add_argument('exchange', type=str, help='exchange id in lowercase', nargs='?')
 parser.add_argument('symbol', type=str, help='symbol in uppercase', nargs='?')
@@ -81,17 +94,6 @@ sys.excepthook = handle_all_unhandled_exceptions
 
 # non-transpiled part, but shared names among langs
 
-
-class baseMainTestClass():
-    lang = 'PY'
-    staticTestsFailed = False
-    skippedMethods = {}
-    checkedPublicTests = {}
-    testFiles = {}
-    publicTests = {}
-    pass
-
-
 is_synchronous = 'async' not in os.path.basename(__file__)
 
 rootDir = current_dir + '/../../../'
@@ -101,6 +103,22 @@ LOG_CHARS_LENGTH = 10000
 ext = 'py'
 
 
+class baseMainTestClass():
+    lang = 'PY'
+    request_tests_failed = False
+    response_tests_failed = False
+    response_tests = False
+    skipped_methods = {}
+    check_public_tests = {}
+    test_files = {}
+    public_tests = {}
+    root_dir = rootDir
+    env_vars = envVars
+    ext = ext
+    root_dir_for_skips = rootDirForSkips
+    pass
+
+
 def dump(*args):
     print(' '.join([str(arg) for arg in args]))
 
@@ -153,6 +171,9 @@ async def call_method(testFiles, methodName, exchange, skippedProperties, args):
 async def call_exchange_method_dynamically(exchange, methodName, args):
     return await getattr(exchange, methodName)(*args)
 
+async def call_overriden_method(exchange, methodName, args):
+    # needed for php
+    return await call_exchange_method_dynamically(exchange, methodName, args)
 
 def exception_message(exc):
     message = '[' + type(exc).__name__ + '] ' + "".join(format_exception(type(exc), exc, exc.__traceback__, limit=6))
@@ -197,196 +218,196 @@ async def close(exchange):
     if (hasattr(exchange, 'close')):
         await exchange.close()
 
-# *********************************
-# ***** AUTO-TRANSPILER-START *****
-# -*- coding: utf-8 -*-
-
-# PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
-# https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
-
-
-import asyncio
-from typing import List
-from ccxt.base.errors import NotSupported
-from ccxt.base.errors import NetworkError
-from ccxt.base.errors import ExchangeNotAvailable
-from ccxt.base.errors import OnMaintenance
-from ccxt.base.errors import AuthenticationError
+def is_null_value(value):
+    return value is None
 
+def set_fetch_response(exchange: ccxt.Exchange, data):
+    async def fetch(url, method='GET', headers=None, body=None):
+        return data
+    exchange.fetch = fetch
+    return exchange
 
+# *********************************
+# ***** AUTO-TRANSPILER-START *****
 class testMainClass(baseMainTestClass):
-
     def parse_cli_args(self):
-        self.idTests = get_cli_arg_value('--idTests')
-        self.staticTests = get_cli_arg_value('--static')
+        self.response_tests = get_cli_arg_value('--responseTests')
+        self.id_tests = get_cli_arg_value('--idTests')
+        self.request_tests = get_cli_arg_value('--requestTests')
         self.info = get_cli_arg_value('--info')
         self.verbose = get_cli_arg_value('--verbose')
         self.debug = get_cli_arg_value('--debug')
-        self.privateTest = get_cli_arg_value('--private')
-        self.privateTestOnly = get_cli_arg_value('--privateOnly')
+        self.private_test = get_cli_arg_value('--private')
+        self.private_test_only = get_cli_arg_value('--privateOnly')
         self.sandbox = get_cli_arg_value('--sandbox')
 
-    async def init(self, exchangeId, symbol):
+    async def init(self, exchange_id, symbol):
         self.parse_cli_args()
-        if self.staticTests:
-            await self.run_static_tests(exchangeId, symbol)  # symbol here is the testname
+        if self.response_tests:
+            await self.run_static_response_tests(exchange_id, symbol)
             return
-        if self.idTests:
+        if self.request_tests:
+            await self.run_static_request_tests(exchange_id, symbol)  # symbol here is the testname
+            return
+        if self.id_tests:
             await self.run_broker_id_tests()
             return
-        symbolStr = symbol is not symbol if None else 'all'
-        dump('\nTESTING ', ext, {'exchange': exchangeId, 'symbol': symbolStr}, '\n')
-        exchangeArgs = {
+        symbol_str = symbol if symbol is not None else 'all'
+        dump('\nTESTING ', self.ext, {
+            'exchange': exchange_id,
+            'symbol': symbol_str,
+        }, '\n')
+        exchange_args = {
             'verbose': self.verbose,
             'debug': self.debug,
             'enableRateLimit': True,
             'timeout': 30000,
         }
-        exchange = init_exchange(exchangeId, exchangeArgs)
+        exchange = init_exchange(exchange_id, exchange_args)
         await self.import_files(exchange)
         self.expand_settings(exchange, symbol)
         await self.start_test(exchange, symbol)
 
     async def import_files(self, exchange):
         # exchange tests
-        self.testFiles = {}
+        self.test_files = {}
         properties = list(exchange.has.keys())
         properties.append('loadMarkets')
         await set_test_files(self, properties)
 
     def expand_settings(self, exchange, symbol):
-        exchangeId = exchange.id
-        keysGlobal = rootDir + 'keys.json'
-        keysLocal = rootDir + 'keys.local.json'
-        keysGlobalExists = io_file_exists(keysGlobal)
-        keysLocalExists = io_file_exists(keysLocal)
-        globalSettings = io_file_read(keysGlobal) if keysGlobalExists else {}
-        localSettings = io_file_read(keysLocal) if keysLocalExists else {}
-        allSettings = exchange.deep_extend(globalSettings, localSettings)
-        exchangeSettings = exchange.safe_value(allSettings, exchangeId, {})
-        if exchangeSettings:
-            settingKeys = list(exchangeSettings.keys())
-            for i in range(0, len(settingKeys)):
-                key = settingKeys[i]
-                if exchangeSettings[key]:
-                    finalValue = None
-                    if isinstance(exchangeSettings[key], dict):
+        exchange_id = exchange.id
+        keys_global = self.root_dir + 'keys.json'
+        keys_local = self.root_dir + 'keys.local.json'
+        keys_global_exists = io_file_exists(keys_global)
+        keys_local_exists = io_file_exists(keys_local)
+        global_settings = io_file_read(keys_global) if keys_global_exists else {}
+        local_settings = io_file_read(keys_local) if keys_local_exists else {}
+        all_settings = exchange.deep_extend(global_settings, local_settings)
+        exchange_settings = exchange.safe_value(all_settings, exchange_id, {})
+        if exchange_settings:
+            setting_keys = list(exchange_settings.keys())
+            for i in range(0, len(setting_keys)):
+                key = setting_keys[i]
+                if exchange_settings[key]:
+                    final_value = None
+                    if isinstance(exchange_settings[key], dict):
                         existing = get_exchange_prop(exchange, key, {})
-                        finalValue = exchange.deep_extend(existing, exchangeSettings[key])
+                        final_value = exchange.deep_extend(existing, exchange_settings[key])
                     else:
-                        finalValue = exchangeSettings[key]
-                    set_exchange_prop(exchange, key, finalValue)
+                        final_value = exchange_settings[key]
+                    set_exchange_prop(exchange, key, final_value)
         # credentials
-        reqCreds = get_exchange_prop(exchange, 're' + 'quiredCredentials')  # dont glue the r-e-q-u-i-r-e phrase, because leads to messed up transpilation
-        objkeys = list(reqCreds.keys())
+        req_creds = get_exchange_prop(exchange, 're' + 'quiredCredentials')  # dont glue the r-e-q-u-i-r-e phrase, because leads to messed up transpilation
+        objkeys = list(req_creds.keys())
         for i in range(0, len(objkeys)):
             credential = objkeys[i]
-            isRequired = reqCreds[credential]
-            if isRequired and get_exchange_prop(exchange, credential) is None:
-                fullKey = exchangeId + '_' + credential
-                credentialEnvName = fullKey.upper()  # example: KRAKEN_APIKEY
-                credentialValue = envVars[credentialEnvName] if (credentialEnvName in envVars) else None
-                if credentialValue:
-                    set_exchange_prop(exchange, credential, credentialValue)
+            is_required = req_creds[credential]
+            if is_required and get_exchange_prop(exchange, credential) is None:
+                full_key = exchange_id + '_' + credential
+                credential_env_name = full_key.upper()  # example: KRAKEN_APIKEY
+                credential_value = self.env_vars[credential_env_name] if (credential_env_name in self.env_vars) else None
+                if credential_value:
+                    set_exchange_prop(exchange, credential, credential_value)
         # skipped tests
-        skippedFile = rootDirForSkips + 'skip-tests.json'
-        skippedSettings = io_file_read(skippedFile)
-        skippedSettingsForExchange = exchange.safe_value(skippedSettings, exchangeId, {})
+        skipped_file = self.root_dir_for_skips + 'skip-tests.json'
+        skipped_settings = io_file_read(skipped_file)
+        skipped_settings_for_exchange = exchange.safe_value(skipped_settings, exchange_id, {})
         # others
-        timeout = exchange.safe_value(skippedSettingsForExchange, 'timeout')
+        timeout = exchange.safe_value(skipped_settings_for_exchange, 'timeout')
         if timeout is not None:
             exchange.timeout = timeout
-        exchange.httpsProxy = exchange.safe_string(skippedSettingsForExchange, 'httpsProxy')
-        self.skippedMethods = exchange.safe_value(skippedSettingsForExchange, 'skipMethods', {})
-        self.checkedPublicTests = {}
+        exchange.https_proxy = exchange.safe_string(skipped_settings_for_exchange, 'httpsProxy')
+        self.skipped_methods = exchange.safe_value(skipped_settings_for_exchange, 'skipMethods', {})
+        self.checked_public_tests = {}
 
     def add_padding(self, message, size):
         # has to be transpilable
         res = ''
-        missingSpace = size - len(message) - 0  # - 0 is added just to trick transpile to treat the .length string for php
-        if missingSpace > 0:
-            for i in range(0, missingSpace):
+        message_length = len(message)  # avoid php transpilation issue
+        missing_space = size - message_length - 0  # - 0 is added just to trick transpile to treat the .length as a string for php
+        if missing_space > 0:
+            for i in range(0, missing_space):
                 res += ' '
         return message + res
 
-    async def test_method(self, methodName, exchange, args, isPublic):
-        isLoadMarkets = (methodName == 'loadMarkets')
-        methodNameInTest = get_test_name(methodName)
-        # if self is a private test, and the implementation was already tested in public, then no need to re-test it in private test(exception is fetchCurrencies, because our approach in base exchange)
-        if not isPublic and (methodNameInTest in self.checkedPublicTests) and (methodName != 'fetchCurrencies'):
+    async def test_method(self, method_name, exchange, args, is_public):
+        is_load_markets = (method_name == 'loadMarkets')
+        method_name_in_test = get_test_name(method_name)
+        # if this is a private test, and the implementation was already tested in public, then no need to re-test it in private test (exception is fetchCurrencies, because our approach in base exchange)
+        if not is_public and (method_name_in_test in self.checked_public_tests) and (method_name != 'fetchCurrencies'):
             return
-        skipMessage = None
-        if not isLoadMarkets and (not(methodName in exchange.has) or not exchange.has[methodName]):
-            skipMessage = '[INFO:UNSUPPORTED_TEST]'  # keep it aligned with the longest message
-        elif (methodName in self.skippedMethods) and (isinstance(self.skippedMethods[methodName], str)):
-            skipMessage = '[INFO:SKIPPED_TEST]'
-        elif not (methodNameInTest in self.testFiles):
-            skipMessage = '[INFO:UNIMPLEMENTED_TEST]'
-        # exceptionally for `loadMarkets` call, we call it before it's even checked for "skip" need it to be called anyway(but can skip "test.loadMarket" for it)
-        if isLoadMarkets:
+        skip_message = None
+        if not is_load_markets and (not (method_name in exchange.has) or not exchange.has[method_name]):
+            skip_message = '[INFO:UNSUPPORTED_TEST]'  # keep it aligned with the longest message
+        elif (method_name in self.skipped_methods) and (isinstance(self.skipped_methods[method_name], str)):
+            skip_message = '[INFO:SKIPPED_TEST]'
+        elif not (method_name_in_test in self.test_files):
+            skip_message = '[INFO:UNIMPLEMENTED_TEST]'
+        # exceptionally for `loadMarkets` call, we call it before it's even checked for "skip" as we need it to be called anyway (but can skip "test.loadMarket" for it)
+        if is_load_markets:
             await exchange.load_markets(True)
-        if skipMessage:
+        if skip_message:
             if self.info:
-                dump(self.add_padding(skipMessage, 25), exchange.id, methodNameInTest)
+                dump(self.add_padding(skip_message, 25), exchange.id, method_name_in_test)
             return
         if self.info:
-            argsStringified = '(' + ','.join(args) + ')'
-            dump(self.add_padding('[INFO:TESTING]', 25), exchange.id, methodNameInTest, argsStringified)
-        skippedProperties = exchange.safe_value(self.skippedMethods, methodName, {})
-        await call_method(self.testFiles, methodNameInTest, exchange, skippedProperties, args)
+            args_stringified = '(' + ','.join(args) + ')'
+            dump(self.add_padding('[INFO:TESTING]', 25), exchange.id, method_name_in_test, args_stringified)
+        skipped_properties = exchange.safe_value(self.skipped_methods, method_name, {})
+        await call_method(self.test_files, method_name_in_test, exchange, skipped_properties, args)
         # if it was passed successfully, add to the list of successfull tests
-        if isPublic:
-            self.checkedPublicTests[methodNameInTest] = True
+        if is_public:
+            self.checked_public_tests[method_name_in_test] = True
 
-    async def test_safe(self, methodName, exchange, args=[], isPublic=False):
-        # `testSafe` method does not raise an exception, instead mutes it.
-        # The reason we mute the thrown exceptions here is because if self test is part
+    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 mute the thrown exceptions here is because if this test is part
         # of "runPublicTests", then we don't want to stop the whole test if any single
         # test-method fails. For example, if "fetchOrderBook" public test fails, we still
-        # want to run "fetchTickers" and other methods. However, independently self fact,
-        # from those test-methods we still echo-out(console.log/print...) the exception
+        # want to run "fetchTickers" and other methods. However, independently this fact,
+        # from those test-methods we still echo-out (console.log/print...) the exception
         # messages with specific formatted message "[TEST_FAILURE] ..." and that output is
         # then regex-parsed by run-tests.js, so the exceptions are still printed out to
         # console from there. So, even if some public tests fail, the script will continue
-        # doing other things(testing other spot/swap or private tests ...)
-        maxRetries = 3
-        argsStringified = exchange.json(args)  # args.join() breaks when we provide a list of symbols | "args.toString()" breaks bcz of "array to string conversion"
-        for i in range(0, maxRetries):
+        # doing other things (testing other spot/swap or private tests ...)
+        max_retries = 3
+        args_stringified = exchange.json(args)  # args.join() breaks when we provide a list of symbols | "args.toString()" breaks bcz of "array to string conversion"
+        for i in range(0, max_retries):
             try:
-                await self.test_method(methodName, exchange, args, isPublic)
+                await self.test_method(method_name, exchange, args, is_public)
                 return True
             except Exception as e:
-                isAuthError = (isinstance(e, AuthenticationError))
-                isNotSupported = (isinstance(e, NotSupported))
-                isNetworkError = (isinstance(e, NetworkError))  # includes "DDoSProtection", "RateLimitExceeded", "RequestTimeout", "ExchangeNotAvailable", "isOperationFailed", "InvalidNonce", ...
-                isExchangeNotAvailable = (isinstance(e, ExchangeNotAvailable))
-                isOnMaintenance = (isinstance(e, OnMaintenance))
-                tempFailure = isNetworkError and (not isExchangeNotAvailable or isOnMaintenance)  # we do not mute specifically "ExchangeNotAvailable" excetpion(but its subtype "OnMaintenance" can be muted)
-                if tempFailure:
-                    # if last retry was gone with same `tempFailure` error, then let's eventually return False
-                    if i == maxRetries - 1:
-                        dump('[TEST_WARNING]', 'Method could not be tested due to a repeated Network/Availability issues', ' | ', exchange.id, methodName, argsStringified)
+                is_auth_error = (isinstance(e, AuthenticationError))
+                is_not_supported = (isinstance(e, NotSupported))
+                is_network_error = (isinstance(e, NetworkError))  # includes "DDoSProtection", "RateLimitExceeded", "RequestTimeout", "ExchangeNotAvailable", "isOperationFailed", "InvalidNonce", ...
+                is_exchange_not_available = (isinstance(e, ExchangeNotAvailable))
+                is_on_maintenance = (isinstance(e, OnMaintenance))
+                temp_failure = is_network_error and (not is_exchange_not_available or is_on_maintenance)  # we do not mute specifically "ExchangeNotAvailable" excetpion (but its subtype "OnMaintenance" can be muted)
+                if temp_failure:
+                    # if last retry was gone with same `tempFailure` error, then let's eventually return false
+                    if i == max_retries - 1:
+                        dump('[TEST_WARNING]', 'Method could not be tested due to a repeated Network/Availability issues', ' | ', exchange.id, method_name, args_stringified)
                     else:
                         # wait and retry again
                         await exchange.sleep(i * 1000)  # increase wait seconds on every retry
                         continue
                 elif isinstance(e, OnMaintenance):
-                    # in case of maintenance, skip exchange(don't fail the test)
+                    # in case of maintenance, skip exchange (don't fail the test)
                     dump('[TEST_WARNING] Exchange is on maintenance', exchange.id)
-                # If public test faces authentication error, we don't break(see comments under `testSafe` method)
-                elif isPublic and isAuthError:
-                    # in case of loadMarkets, it means that "tester"(developer or travis) does not have correct authentication, so it does not have a point to proceed at all
-                    if methodName == 'loadMarkets':
-                        dump('[TEST_WARNING]', 'Exchange can not be tested, because of authentication problems during loadMarkets', exception_message(e), exchange.id, methodName, argsStringified)
+                elif is_public and is_auth_error:
+                    # in case of loadMarkets, it means that "tester" (developer or travis) does not have correct authentication, so it does not have a point to proceed at all
+                    if method_name == 'loadMarkets':
+                        dump('[TEST_WARNING]', 'Exchange can not be tested, because of authentication problems during loadMarkets', exception_message(e), exchange.id, method_name, args_stringified)
                     if self.info:
-                        dump('[TEST_WARNING]', 'Authentication problem for public method', exception_message(e), exchange.id, methodName, argsStringified)
+                        dump('[TEST_WARNING]', 'Authentication problem for public method', exception_message(e), exchange.id, method_name, args_stringified)
                 else:
-                    # if not a temporary connectivity issue, then mark test(no need to re-try)
-                    if isNotSupported:
-                        dump('[NOT_SUPPORTED]', exchange.id, methodName, argsStringified)
-                        return True  # why consider not supported failed test?
+                    # if not a temporary connectivity issue, then mark test as failed (no need to re-try)
+                    if is_not_supported:
+                        dump('[NOT_SUPPORTED]', exchange.id, method_name, args_stringified)
+                        return True   # why consider not supported as a failed test?
                     else:
-                        dump('[TEST_FAILURE]', exception_message(e), exchange.id, methodName, argsStringified)
+                        dump('[TEST_FAILURE]', exception_message(e), exchange.id, method_name, args_stringified)
                 return False
 
     async def run_public_tests(self, exchange, symbol):
@@ -404,8 +425,8 @@ class testMainClass(baseMainTestClass):
             'fetchTime': [],
         }
         market = exchange.market(symbol)
-        isSpot = market['spot']
-        if isSpot:
+        is_spot = market['spot']
+        if is_spot:
             tests['fetchCurrencies'] = []
         else:
             tests['fetchFundingRates'] = [symbol]
@@ -414,76 +435,54 @@ class testMainClass(baseMainTestClass):
             tests['fetchIndexOHLCV'] = [symbol]
             tests['fetchMarkOHLCV'] = [symbol]
             tests['fetchPremiumIndexOHLCV'] = [symbol]
-        self.publicTests = tests
-        testNames = list(tests.keys())
+        self.public_tests = tests
+        test_names = list(tests.keys())
         promises = []
-        for i in range(0, len(testNames)):
-            testName = testNames[i]
-            testArgs = tests[testName]
-            promises.append(self.test_safe(testName, exchange, testArgs, True))
+        for i in range(0, len(test_names)):
+            test_name = test_names[i]
+            test_args = tests[test_name]
+            promises.append(self.test_safe(test_name, exchange, test_args, True))
         # todo - not yet ready in other langs too
-        # promises.append(testThrottle())
+        # promises.push (testThrottle ());
         results = await asyncio.gather(*promises)
         # now count which test-methods retuned `false` from "testSafe" and dump that info below
         if self.info:
             errors = []
-            for i in range(0, len(testNames)):
+            for i in range(0, len(test_names)):
                 if not results[i]:
-                    errors.append(testNames[i])
-            # we don't raise exception for public-tests, see comments under 'testSafe' method
-            errorsInMessage = ''
+                    errors.append(test_names[i])
+            # we don't throw exception for public-tests, see comments under 'testSafe' method
+            errors_in_message = ''
             if errors:
-                failedMsg = ', '.join(errors)
-                errorsInMessage = ' | Failed methods : ' + failedMsg
-            messageContent = '[INFO:PUBLIC_TESTS_END] ' + market['type'] + errorsInMessage
-            messageWithPadding = self.add_padding(messageContent, 25)
-            dump(messageWithPadding, exchange.id)
+                failed_msg = ', '.join(errors)
+                errors_in_message = ' | Failed methods : ' + failed_msg
+            message_content = '[INFO:PUBLIC_TESTS_END] ' + market['type'] + errors_in_message
+            message_with_padding = self.add_padding(message_content, 25)
+            dump(message_with_padding, exchange.id)
 
     async def load_exchange(self, exchange):
         result = await self.test_safe('loadMarkets', exchange, [], True)
         if not result:
             return False
-        symbols = [
-            'BTC/CNY',
-            'BTC/USD',
-            'BTC/USDT',
-            'BTC/EUR',
-            'BTC/ETH',
-            'ETH/BTC',
-            'BTC/JPY',
-            'ETH/EUR',
-            'ETH/JPY',
-            'ETH/CNY',
-            'ETH/USD',
-            'LTC/CNY',
-            'DASH/BTC',
-            'DOGE/BTC',
-            'BTC/AUD',
-            'BTC/PLN',
-            'USD/SLL',
-            'BTC/RUB',
-            'BTC/UAH',
-            'LTC/BTC',
-            'EUR/USD',
-        ]
-        resultSymbols = []
-        exchangeSpecificSymbols = exchange.symbols
-        for i in range(0, len(exchangeSpecificSymbols)):
-            symbol = exchangeSpecificSymbols[i]
+        symbols = ['BTC/CNY', 'BTC/USD', 'BTC/USDT', 'BTC/EUR', 'BTC/ETH', 'ETH/BTC', 'BTC/JPY', 'ETH/EUR', 'ETH/JPY', 'ETH/CNY', 'ETH/USD', 'LTC/CNY', 'DASH/BTC', 'DOGE/BTC', 'BTC/AUD', 'BTC/PLN', 'USD/SLL', 'BTC/RUB', 'BTC/UAH', 'LTC/BTC', 'EUR/USD']
+        result_symbols = []
+        exchange_specific_symbols = exchange.symbols
+        for i in range(0, len(exchange_specific_symbols)):
+            symbol = exchange_specific_symbols[i]
             if exchange.in_array(symbol, symbols):
-                resultSymbols.append(symbol)
-        resultMsg = ''
-        resultLength = len(resultSymbols)
-        exchangeSymbolsLength = len(exchange.symbols)
-        if resultLength > 0:
-            if exchangeSymbolsLength > resultLength:
-                resultMsg = ', '.join(resultSymbols) + ' + more...'
+                result_symbols.append(symbol)
+        result_msg = ''
+        result_length = len(result_symbols)
+        exchange_symbols_length = len(exchange.symbols)
+        if result_length > 0:
+            if exchange_symbols_length > result_length:
+                result_msg = ', '.join(result_symbols) + ' + more...'
             else:
-                resultMsg = ', '.join(resultSymbols)
-        dump('Exchange loaded', exchangeSymbolsLength, 'symbols', resultMsg)
+                result_msg = ', '.join(result_symbols)
+        dump('Exchange loaded', exchange_symbols_length, 'symbols', result_msg)
         return True
 
-    def get_test_symbol(self, exchange, isSpot, symbols):
+    def get_test_symbol(self, exchange, is_spot, symbols):
         symbol = None
         for i in range(0, len(symbols)):
             s = symbols[i]
@@ -518,140 +517,86 @@ class testMainClass(baseMainTestClass):
         return res
 
     def get_valid_symbol(self, exchange, spot=True):
-        currentTypeMarkets = self.get_markets_from_exchange(exchange, spot)
-        codes = [
-            'BTC',
-            'ETH',
-            'XRP',
-            'LTC',
-            'BCH',
-            'EOS',
-            'BNB',
-            'BSV',
-            'USDT',
-            'ATOM',
-            'BAT',
-            'BTG',
-            'DASH',
-            'DOGE',
-            'ETC',
-            'IOTA',
-            'LSK',
-            'MKR',
-            'NEO',
-            'PAX',
-            'QTUM',
-            'TRX',
-            'TUSD',
-            'USD',
-            'USDC',
-            'WAVES',
-            'XEM',
-            'XMR',
-            'ZEC',
-            'ZRX',
-        ]
-        spotSymbols = [
-            'BTC/USD',
-            'BTC/USDT',
-            'BTC/CNY',
-            'BTC/EUR',
-            'BTC/ETH',
-            'ETH/BTC',
-            'ETH/USD',
-            'ETH/USDT',
-            'BTC/JPY',
-            'LTC/BTC',
-            'ZRX/WETH',
-            'EUR/USD',
-        ]
-        swapSymbols = [
-            'BTC/USDT:USDT',
-            'BTC/USD:USD',
-            'ETH/USDT:USDT',
-            'ETH/USD:USD',
-            'LTC/USDT:USDT',
-            'DOGE/USDT:USDT',
-            'ADA/USDT:USDT',
-            'BTC/USD:BTC',
-            'ETH/USD:ETH',
-        ]
-        targetSymbols = spotSymbols if spot else swapSymbols
-        symbol = self.get_test_symbol(exchange, spot, targetSymbols)
+        current_type_markets = self.get_markets_from_exchange(exchange, spot)
+        codes = ['BTC', 'ETH', 'XRP', 'LTC', 'BCH', 'EOS', 'BNB', 'BSV', 'USDT', 'ATOM', 'BAT', 'BTG', 'DASH', 'DOGE', 'ETC', 'IOTA', 'LSK', 'MKR', 'NEO', 'PAX', 'QTUM', 'TRX', 'TUSD', 'USD', 'USDC', 'WAVES', 'XEM', 'XMR', 'ZEC', 'ZRX']
+        spot_symbols = ['BTC/USD', 'BTC/USDT', 'BTC/CNY', 'BTC/EUR', 'BTC/ETH', 'ETH/BTC', 'ETH/USD', 'ETH/USDT', 'BTC/JPY', 'LTC/BTC', 'ZRX/WETH', 'EUR/USD']
+        swap_symbols = ['BTC/USDT:USDT', 'BTC/USD:USD', 'ETH/USDT:USDT', 'ETH/USD:USD', 'LTC/USDT:USDT', 'DOGE/USDT:USDT', 'ADA/USDT:USDT', 'BTC/USD:BTC', 'ETH/USD:ETH']
+        target_symbols = spot_symbols if spot else swap_symbols
+        symbol = self.get_test_symbol(exchange, spot, target_symbols)
         # if symbols wasn't found from above hardcoded list, then try to locate any symbol which has our target hardcoded 'base' code
         if symbol is None:
             for i in range(0, len(codes)):
-                currentCode = codes[i]
-                marketsArrayForCurrentCode = exchange.filter_by(currentTypeMarkets, 'base', currentCode)
-                indexedMkts = exchange.index_by(marketsArrayForCurrentCode, 'symbol')
-                symbolsArrayForCurrentCode = list(indexedMkts.keys())
-                symbolsLength = len(symbolsArrayForCurrentCode)
-                if symbolsLength:
-                    symbol = self.get_test_symbol(exchange, spot, symbolsArrayForCurrentCode)
+                current_code = codes[i]
+                markets_array_for_current_code = exchange.filter_by(current_type_markets, 'base', current_code)
+                indexed_mkts = exchange.index_by(markets_array_for_current_code, 'symbol')
+                symbols_array_for_current_code = list(indexed_mkts.keys())
+                symbols_length = len(symbols_array_for_current_code)
+                if symbols_length:
+                    symbol = self.get_test_symbol(exchange, spot, symbols_array_for_current_code)
                     break
         # if there wasn't found any symbol with our hardcoded 'base' code, then just try to find symbols that are 'active'
         if symbol is None:
-            activeMarkets = exchange.filter_by(currentTypeMarkets, 'active', True)
-            activeSymbols = []
-            for i in range(0, len(activeMarkets)):
-                activeSymbols.append(activeMarkets[i]['symbol'])
-            symbol = self.get_test_symbol(exchange, spot, activeSymbols)
+            active_markets = exchange.filter_by(current_type_markets, 'active', True)
+            active_symbols = []
+            for i in range(0, len(active_markets)):
+                active_symbols.append(active_markets[i]['symbol'])
+            symbol = self.get_test_symbol(exchange, spot, active_symbols)
         if symbol is None:
-            values = list(currentTypeMarkets.values())
-            valuesLength = len(values)
-            if valuesLength > 0:
+            values = list(current_type_markets.values())
+            values_length = len(values)
+            if values_length > 0:
                 first = values[0]
                 if first is not None:
                     symbol = first['symbol']
         return symbol
 
-    async def test_exchange(self, exchange, providedSymbol=None):
-        spotSymbol = None
-        swapSymbol = None
-        if providedSymbol is not None:
-            market = exchange.market(providedSymbol)
+    async def test_exchange(self, exchange, provided_symbol=None):
+        spot_symbol = None
+        swap_symbol = None
+        if provided_symbol is not None:
+            market = exchange.market(provided_symbol)
             if market['spot']:
-                spotSymbol = providedSymbol
+                spot_symbol = provided_symbol
             else:
-                swapSymbol = providedSymbol
+                swap_symbol = provided_symbol
         else:
             if exchange.has['spot']:
-                spotSymbol = self.get_valid_symbol(exchange, True)
+                spot_symbol = self.get_valid_symbol(exchange, True)
             if exchange.has['swap']:
-                swapSymbol = self.get_valid_symbol(exchange, False)
-        if spotSymbol is not None:
-            dump('Selected SPOT SYMBOL:', spotSymbol)
-        if swapSymbol is not None:
-            dump('Selected SWAP SYMBOL:', swapSymbol)
-        if not self.privateTestOnly:
-            if exchange.has['spot'] and spotSymbol is not None:
+                swap_symbol = self.get_valid_symbol(exchange, False)
+        if spot_symbol is not None:
+            dump('Selected SPOT SYMBOL:', spot_symbol)
+        if swap_symbol is not None:
+            dump('Selected SWAP SYMBOL:', swap_symbol)
+        if not self.private_test_only:
+            if exchange.has['spot'] and spot_symbol is not None:
                 if self.info:
                     dump('[INFO:SPOT TESTS]')
                 exchange.options['type'] = 'spot'
-                await self.run_public_tests(exchange, spotSymbol)
-            if exchange.has['swap'] and swapSymbol is not None:
+                await self.run_public_tests(exchange, spot_symbol)
+            if exchange.has['swap'] and swap_symbol is not None:
                 if self.info:
                     dump('[INFO:SWAP TESTS]')
                 exchange.options['type'] = 'swap'
-                await self.run_public_tests(exchange, swapSymbol)
-        if self.privateTest or self.privateTestOnly:
-            if exchange.has['spot'] and spotSymbol is not None:
+                await self.run_public_tests(exchange, swap_symbol)
+        if self.private_test or self.private_test_only:
+            if exchange.has['spot'] and spot_symbol is not None:
                 exchange.options['defaultType'] = 'spot'
-                await self.run_private_tests(exchange, spotSymbol)
-            if exchange.has['swap'] and swapSymbol is not None:
+                await self.run_private_tests(exchange, spot_symbol)
+            if exchange.has['swap'] and swap_symbol is not None:
                 exchange.options['defaultType'] = 'swap'
-                await self.run_private_tests(exchange, swapSymbol)
+                await self.run_private_tests(exchange, swap_symbol)
 
     async def run_private_tests(self, exchange, symbol):
         if not exchange.check_required_credentials(False):
             dump('[Skipping private tests]', 'Keys not found')
             return
         code = self.get_exchange_code(exchange)
-        # if exchange.extendedTest:
-        #     await test('InvalidNonce', exchange, symbol)
-        #     await test('OrderNotFound', exchange, symbol)
-        #     await test('InvalidOrder', exchange, symbol)
-        #     await test('InsufficientFunds', exchange, symbol, balance)  # danger zone - won't execute with non-empty balance
+        # if (exchange.extendedTest) {
+        #     await test ('InvalidNonce', exchange, symbol);
+        #     await test ('OrderNotFound', exchange, symbol);
+        #     await test ('InvalidOrder', exchange, symbol);
+        #     await test ('InsufficientFunds', exchange, symbol, balance); # danger zone - won't execute with non-empty balance
         # }
         tests = {
             'signIn': [],
@@ -672,40 +617,25 @@ class testMainClass(baseMainTestClass):
             'fetchBorrowRates': [],
             'fetchBorrowRate': [code],
             'fetchBorrowInterest': [code, symbol],
-            # 'addMargin': [],
-            # 'reduceMargin': [],
-            # 'setMargin': [],
-            # 'setMarginMode': [],
-            # 'setLeverage': [],
             'cancelAllOrders': [symbol],
-            # 'cancelOrder': [],
-            # 'cancelOrders': [],
             'fetchCanceledOrders': [symbol],
-            # 'fetchClosedOrder': [],
-            # 'fetchOpenOrder': [],
-            # 'fetchOrder': [],
-            # 'fetchOrderTrades': [],
             'fetchPosition': [symbol],
             'fetchDeposit': [code],
             'createDepositAddress': [code],
             'fetchDepositAddress': [code],
             'fetchDepositAddresses': [code],
             'fetchDepositAddressesByNetwork': [code],
-            # 'editOrder': [],
             'fetchBorrowRateHistory': [code],
             'fetchBorrowRatesPerSymbol': [],
             'fetchLedgerEntry': [code],
-            # 'fetchWithdrawal': [],
-            # 'transfer': [],
-            # 'withdraw': [],
         }
         market = exchange.market(symbol)
-        isSpot = market['spot']
-        if isSpot:
+        is_spot = market['spot']
+        if is_spot:
             tests['fetchCurrencies'] = []
         else:
             # derivatives only
-            tests['fetchPositions'] = [symbol]  # self test fetches all positions for 1 symbol
+            tests['fetchPositions'] = [symbol]  # this test fetches all positions for 1 symbol
             tests['fetchPosition'] = [symbol]
             tests['fetchPositionRisk'] = [symbol]
             tests['setPositionMode'] = [symbol]
@@ -713,23 +643,23 @@ class testMainClass(baseMainTestClass):
             tests['fetchOpenInterestHistory'] = [symbol]
             tests['fetchFundingRateHistory'] = [symbol]
             tests['fetchFundingHistory'] = [symbol]
-        combinedPublicPrivateTests = exchange.deep_extend(self.publicTests, tests)
-        testNames = list(combinedPublicPrivateTests.keys())
+        combined_public_private_tests = exchange.deep_extend(self.public_tests, tests)
+        test_names = list(combined_public_private_tests.keys())
         promises = []
-        for i in range(0, len(testNames)):
-            testName = testNames[i]
-            testArgs = combinedPublicPrivateTests[testName]
-            promises.append(self.test_safe(testName, exchange, testArgs, False))
+        for i in range(0, len(test_names)):
+            test_name = test_names[i]
+            test_args = combined_public_private_tests[test_name]
+            promises.append(self.test_safe(test_name, exchange, test_args, False))
         results = await asyncio.gather(*promises)
         errors = []
-        for i in range(0, len(testNames)):
-            testName = testNames[i]
+        for i in range(0, len(test_names)):
+            test_name = test_names[i]
             success = results[i]
             if not success:
-                errors.append(testName)
-        errorsCnt = len(errors)  # PHP transpile count($errors)
-        if errorsCnt > 0:
-            # raise Error('Failed private tests [' + market['type'] + ']: ' + ', '.join(errors))
+                errors.append(test_name)
+        errors_cnt = len(errors)  # PHP transpile count($errors)
+        if errors_cnt > 0:
+            # throw new Error ('Failed private tests [' + market['type'] + ']: ' + errors.join (', '));
             dump('[TEST_FAILURE]', 'Failed private tests [' + market['type'] + ']: ' + ', '.join(errors))
         else:
             if self.info:
@@ -741,7 +671,6 @@ class testMainClass(baseMainTestClass):
             return
         if self.sandbox or get_exchange_prop(exchange, 'sandbox'):
             exchange.set_sandbox_mode(True)
-        # because of python-async, we need proper `.close()` handling
         try:
             result = await self.load_exchange(exchange)
             if not result:
@@ -753,296 +682,373 @@ class testMainClass(baseMainTestClass):
             await close(exchange)
             raise e
 
-    def assert_static_error(self, cond: bool, message: str, calculatedOutput, storedOutput):
+    def assert_static_error(self, cond, message, calculated_output, stored_output):
         #  -----------------------------------------------------------------------------
         #  --- Init of static tests functions------------------------------------------
         #  -----------------------------------------------------------------------------
-        calculatedString = json_stringify(calculatedOutput)
-        outputString = json_stringify(storedOutput)
-        errorMessage = message + ' expected ' + outputString + ' received: ' + calculatedString
-        assert cond, errorMessage
+        calculated_string = json_stringify(calculated_output)
+        output_string = json_stringify(stored_output)
+        error_message = message + ' expected ' + output_string + ' received: ' + calculated_string
+        assert cond, error_message
 
-    def load_markets_from_file(self, id: str):
+    def load_markets_from_file(self, id):
         # load markets from file
-        # to make self test
+        # to make this test as fast as possible
         # and basically independent from the exchange
         # so we can run it offline
-        filename = rootDir + './ts/src/test/static/markets/' + id + '.json'
+        filename = self.root_dir + './ts/src/test/static/markets/' + id + '.json'
+        content = io_file_read(filename)
+        return content
+
+    def load_currencies_from_file(self, id):
+        filename = self.root_dir + './ts/src/test/static/currencies/' + id + '.json'
         content = io_file_read(filename)
         return content
 
-    def load_static_data(self, targetExchange: str = None):
-        folder = rootDir + './ts/src/test/static/data/'
+    def load_static_data(self, folder, target_exchange=None):
         result = {}
-        if targetExchange:
+        if target_exchange:
             # read a single exchange
-            result[targetExchange] = io_file_read(folder + targetExchange + '.json')
+            result[target_exchange] = io_file_read(folder + target_exchange + '.json')
             return result
         files = io_dir_read(folder)
         for i in range(0, len(files)):
             file = files[i]
-            exchangeName = file.replace('.json', '')
+            exchange_name = file.replace('.json', '')
             content = io_file_read(folder + file)
-            result[exchangeName] = content
+            result[exchange_name] = content
         return result
 
-    def remove_hostnamefrom_url(self, url: str):
+    def remove_hostnamefrom_url(self, url):
         if url is None:
             return None
-        urlParts = url.split('/')
+        url_parts = url.split('/')
         res = ''
-        for i in range(0, len(urlParts)):
+        for i in range(0, len(url_parts)):
             if i > 2:
-                current = urlParts[i]
+                current = url_parts[i]
                 if current.find('?') > -1:
-                    # handle urls like self: /v1/account/accounts?AccessK
-                    currentParts = current.split('?')
+                    # handle urls like this: /v1/account/accounts?AccessK
+                    current_parts = current.split('?')
                     res += '/'
-                    res += currentParts[0]
+                    res += current_parts[0]
                     break
                 res += '/'
                 res += current
         return res
 
-    def urlencoded_to_dict(self, url: str):
+    def urlencoded_to_dict(self, url):
         result = {}
         parts = url.split('&')
         for i in range(0, len(parts)):
             part = parts[i]
-            keyValue = part.split('=')
-            keysLength = len(keyValue)
-            if keysLength != 2:
+            key_value = part.split('=')
+            keys_length = len(key_value)
+            if keys_length != 2:
                 continue
-            key = keyValue[0]
-            value = keyValue[1]
+            key = key_value[0]
+            value = key_value[1]
             if (value is not None) and ((value.startswith('[')) or (value.startswith('{'))):
-                # some exchanges might return something like self: timestamp=1699382693405&batchOrders=[{\"symbol\":\"LTCUSDT\",\"side\":\"BUY\",\"newClientOrderI
+                # some exchanges might return something like this: timestamp=1699382693405&batchOrders=[{\"symbol\":\"LTCUSDT\",\"side\":\"BUY\",\"newClientOrderI
                 value = json_parse(value)
             result[key] = value
         return result
 
-    def assert_new_and_stored_output(self, exchange, skipKeys: List[str], newOutput, storedOutput):
-        if (isinstance(storedOutput, dict)) and (isinstance(newOutput, dict)):
-            storedOutputKeys = list(storedOutput.keys())
-            newOutputKeys = list(newOutput.keys())
-            storedKeysLength = len(storedOutputKeys)
-            newKeysLength = len(newOutputKeys)
-            self.assert_static_error(storedKeysLength == newKeysLength, 'output length mismatch', storedOutput, newOutput)
+    def assert_new_and_stored_output(self, exchange, skip_keys, new_output, stored_output, strict_type_check=True):
+        if is_null_value(new_output) and is_null_value(stored_output):
+            return
+        if not new_output and not stored_output:
+            return
+        if (isinstance(stored_output, dict)) and (isinstance(new_output, dict)):
+            stored_output_keys = list(stored_output.keys())
+            new_output_keys = list(new_output.keys())
+            stored_keys_length = len(stored_output_keys)
+            new_keys_length = len(new_output_keys)
+            self.assert_static_error(stored_keys_length == new_keys_length, 'output length mismatch', stored_output, new_output)
             # iterate over the keys
-            for i in range(0, len(storedOutputKeys)):
-                key = storedOutputKeys[i]
-                if exchange.in_array(key, skipKeys):
+            for i in range(0, len(stored_output_keys)):
+                key = stored_output_keys[i]
+                if exchange.in_array(key, skip_keys):
                     continue
-                if not (exchange.in_array(key, newOutputKeys)):
-                    self.assert_static_error(False, 'output key missing: ' + key, storedOutput, newOutput)
-                storedValue = storedOutput[key]
-                newValue = newOutput[key]
-                self.assert_new_and_stored_output(exchange, skipKeys, newValue, storedValue)
-        elif isinstance(storedOutput, list) and (isinstance(newOutput, list)):
-            storedArrayLength = len(storedOutput)
-            newArrayLength = len(newOutput)
-            self.assert_static_error(storedArrayLength == newArrayLength, 'output length mismatch', storedOutput, newOutput)
-            for i in range(0, len(storedOutput)):
-                storedItem = storedOutput[i]
-                newItem = newOutput[i]
-                self.assert_new_and_stored_output(exchange, skipKeys, newItem, storedItem)
+                if not (exchange.in_array(key, new_output_keys)):
+                    self.assert_static_error(False, 'output key missing: ' + key, stored_output, new_output)
+                stored_value = stored_output[key]
+                new_value = new_output[key]
+                self.assert_new_and_stored_output(exchange, skip_keys, new_value, stored_value, strict_type_check)
+        elif isinstance(stored_output, list) and (isinstance(new_output, list)):
+            stored_array_length = len(stored_output)
+            new_array_length = len(new_output)
+            self.assert_static_error(stored_array_length == new_array_length, 'output length mismatch', stored_output, new_output)
+            for i in range(0, len(stored_output)):
+                stored_item = stored_output[i]
+                new_item = new_output[i]
+                self.assert_new_and_stored_output(exchange, skip_keys, new_item, stored_item, strict_type_check)
         else:
             # built-in types like strings, numbers, booleans
-            messageError = 'output value mismatch:' + str(newOutput) + ' != ' + str(storedOutput)
-            self.assert_static_error(newOutput == storedOutput, messageError, storedOutput, newOutput)
+            sanitized_new_output = None if (not new_output) else new_output  # we store undefined as nulls in the json file so we need to convert it back
+            sanitized_stored_output = None if (not stored_output) else stored_output
+            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:
+                # 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)
+            else:
+                is_boolean = (isinstance(sanitized_new_output, bool)) or (isinstance(sanitized_stored_output, bool))
+                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)
+                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)
 
-    def assert_static_output(self, exchange, type: str, skipKeys: List[str], storedUrl: str, requestUrl: str, storedOutput, newOutput):
-        if storedUrl != requestUrl:
+    def assert_static_request_output(self, exchange, type, skip_keys, stored_url, request_url, stored_output, new_output):
+        if stored_url != request_url:
             # remove the host part from the url
-            firstPath = self.remove_hostnamefrom_url(storedUrl)
-            secondPath = self.remove_hostnamefrom_url(requestUrl)
-            self.assert_static_error(firstPath == secondPath, 'url mismatch', firstPath, secondPath)
-        # body(aka storedOutput and newOutput) is not defined and information is in the url
+            first_path = self.remove_hostnamefrom_url(stored_url)
+            second_path = self.remove_hostnamefrom_url(request_url)
+            self.assert_static_error(first_path == second_path, 'url mismatch', first_path, second_path)
+        # body (aka storedOutput and newOutput) is not defined and information is in the url
         # example: "https://open-api.bingx.com/openApi/spot/v1/trade/order?quoteOrderQty=5&side=BUY&symbol=LTC-USDT&timestamp=1698777135343&type=MARKET&signature=d55a7e4f7f9dbe56c4004c9f3ab340869d3cb004e2f0b5b861e5fbd1762fd9a0
-        if (storedOutput is None) and (newOutput is None):
-            if (storedUrl is not None) and (requestUrl is not None):
-                storedUrlParts = storedUrl.split('?')
-                newUrlParts = requestUrl.split('?')
-                storedUrlQuery = exchange.safe_value(storedUrlParts, 1)
-                newUrlQuery = exchange.safe_value(newUrlParts, 1)
-                if (storedUrlQuery is None) and (newUrlQuery is None):
+        if (stored_output is None) and (new_output is None):
+            if (stored_url is not None) and (request_url is not None):
+                stored_url_parts = stored_url.split('?')
+                new_url_parts = request_url.split('?')
+                stored_url_query = exchange.safe_value(stored_url_parts, 1)
+                new_url_query = exchange.safe_value(new_url_parts, 1)
+                if (stored_url_query is None) and (new_url_query is None):
                     # might be a get request without any query parameters
                     # example: https://api.gateio.ws/api/v4/delivery/usdt/positions
                     return
-                storedUrlParams = self.urlencoded_to_dict(storedUrlQuery)
-                newUrlParams = self.urlencoded_to_dict(newUrlQuery)
-                self.assert_new_and_stored_output(exchange, skipKeys, newUrlParams, storedUrlParams)
+                stored_url_params = self.urlencoded_to_dict(stored_url_query)
+                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
-        # body is defined
         if type == 'json':
-            if isinstance(storedOutput, str):
-                storedOutput = json_parse(storedOutput)
-            if isinstance(newOutput, str):
-                newOutput = json_parse(newOutput)
+            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':
-            storedOutput = self.urlencoded_to_dict(storedOutput)
-            newOutput = self.urlencoded_to_dict(newOutput)
-        self.assert_new_and_stored_output(exchange, skipKeys, newOutput, storedOutput)
+            stored_output = self.urlencoded_to_dict(stored_output)
+            new_output = self.urlencoded_to_dict(new_output)
+        self.assert_new_and_stored_output(exchange, skip_keys, new_output, stored_output)
+
+    def assert_static_response_output(self, exchange, skip_keys, computed_result, stored_result):
+        self.assert_new_and_stored_output(exchange, skip_keys, computed_result, stored_result, False)
 
     def sanitize_data_input(self, input):
         # remove nulls and replace with unefined instead
         if input is None:
             return None
-        newInput = []
+        new_input = []
         for i in range(0, len(input)):
             current = input[i]
-            if current == None:  # noqa: E711
-                newInput.append(None)
+            if is_null_value(current):
+                new_input.append(None)
             else:
-                newInput.append(current)
-        return newInput
+                new_input.append(current)
+        return new_input
 
-    async def test_method_statically(self, exchange, method: str, data: object, type: str, skipKeys: List[str]):
+    async def test_method_statically(self, exchange, method, data, type, skip_keys):
         output = None
-        requestUrl = None
+        request_url = None
         try:
             await call_exchange_method_dynamically(exchange, method, self.sanitize_data_input(data['input']))
         except Exception as e:
             if not (isinstance(e, NetworkError)):
-                # if it's not a network error, it means our request was not created succesfully
-                # so we might have an error in the request creation
                 raise e
             output = exchange.last_request_body
-            requestUrl = exchange.last_request_url
+            request_url = exchange.last_request_url
         try:
-            callOutput = exchange.safe_value(data, 'output')
-            self.assert_static_output(exchange, type, skipKeys, data['url'], requestUrl, callOutput, output)
+            call_output = exchange.safe_value(data, 'output')
+            self.assert_static_request_output(exchange, type, skip_keys, data['url'], request_url, call_output, output)
         except Exception as e:
-            self.staticTestsFailed = True
-            errorMessage = '[' + self.lang + '][STATIC_TEST_FAILURE]' + '[' + exchange.id + ']' + '[' + method + ']' + '[' + data['description'] + ']' + str(e)
-            dump(errorMessage)
-
-    def init_offline_exchange(self, exchangeName: str):
-        markets = self.load_markets_from_file(exchangeName)
-        return init_exchange(exchangeName, {'markets': markets, 'rateLimit': 1, 'httpsProxy': 'http://fake:8080', 'apiKey': 'key', 'secret': 'secretsecret', 'password': 'password', 'uid': 'uid', 'accounts': [{'id': 'myAccount'}], 'options': {'enableUnifiedAccount': True, 'enableUnifiedMargin': False, 'accessToken': 'token', 'expires': 999999999999999, 'leverageBrackets': {}}})
+            self.request_tests_failed = True
+            error_message = '[' + self.lang + '][STATIC_REQUEST_TEST_FAILURE]' + '[' + exchange.id + ']' + '[' + method + ']' + '[' + data['description'] + ']' + str(e)
+            dump(error_message)
 
-    async def test_exchange_statically(self, exchangeName: str, exchangeData: object, testName: str = None):
+    async def test_response_statically(self, exchange, method, skip_keys, data):
+        expected_result = exchange.safe_value(data, 'parsedResponse')
+        mocked_exchange = set_fetch_response(exchange, data['httpResponse'])
+        try:
+            unified_result = await call_exchange_method_dynamically(exchange, method, self.sanitize_data_input(data['input']))
+            self.assert_static_response_output(mocked_exchange, skip_keys, unified_result, expected_result)
+        except Exception as e:
+            self.request_tests_failed = True
+            error_message = '[' + self.lang + '][STATIC_RESPONSE_TEST_FAILURE]' + '[' + exchange.id + ']' + '[' + method + ']' + '[' + data['description'] + ']' + str(e)
+            dump(error_message)
+        set_fetch_response(exchange, None)  # reset state
+
+    def init_offline_exchange(self, exchange_name):
+        markets = self.load_markets_from_file(exchange_name)
+        currencies = self.load_currencies_from_file(exchange_name)
+        exchange = init_exchange(exchange_name, {
+            'markets': markets,
+            'enableRateLimit': False,
+            'rateLimit': 1,
+            'httpsProxy': 'http://fake:8080',
+            'apiKey': 'key',
+            'secret': 'secretsecret',
+            'password': 'password',
+            'uid': 'uid',
+            'accounts': [{
+    'id': 'myAccount',
+}],
+            'options': {
+                'enableUnifiedAccount': True,
+                'enableUnifiedMargin': False,
+                'accessToken': 'token',
+                'expires': 999999999999999,
+                'leverageBrackets': {},
+            },
+        })
+        exchange.currencies = currencies  # not working in python if assigned  in the config dict
+        return exchange
+
+    async def test_exchange_request_statically(self, exchange_name, exchange_data, test_name=None):
         # instantiate the exchange and make sure that we sink the requests to avoid an actual request
-        exchange = self.init_offline_exchange(exchangeName)
-        methods = exchange.safe_value(exchangeData, 'methods', {})
-        methodsNames = list(methods.keys())
-        for i in range(0, len(methodsNames)):
-            method = methodsNames[i]
+        exchange = self.init_offline_exchange(exchange_name)
+        methods = exchange.safe_value(exchange_data, 'methods', {})
+        methods_names = list(methods.keys())
+        for i in range(0, len(methods_names)):
+            method = methods_names[i]
+            results = methods[method]
+            for j in range(0, len(results)):
+                result = results[j]
+                description = exchange.safe_value(result, 'description')
+                if (test_name is not None) and (test_name != description):
+                    continue
+                type = exchange.safe_string(exchange_data, 'outputType')
+                skip_keys = exchange.safe_value(exchange_data, 'skipKeys', [])
+                await self.test_method_statically(exchange, method, result, type, skip_keys)
+        await close(exchange)
+
+    async def test_exchange_response_statically(self, exchange_name, exchange_data, test_name=None):
+        exchange = self.init_offline_exchange(exchange_name)
+        methods = exchange.safe_value(exchange_data, 'methods', {})
+        options = exchange.safe_value(exchange_data, 'options', {})
+        exchange.options = exchange.deep_extend(exchange.options, options)  # custom options to be used in the tests
+        methods_names = list(methods.keys())
+        for i in range(0, len(methods_names)):
+            method = methods_names[i]
             results = methods[method]
             for j in range(0, len(results)):
                 result = results[j]
                 description = exchange.safe_value(result, 'description')
-                if (testName is not None) and (testName != description):
+                if (test_name is not None) and (test_name != description):
                     continue
-                type = exchange.safe_string(exchangeData, 'outputType')
-                skipKeys = exchange.safe_value(exchangeData, 'skipKeys', [])
-                await self.test_method_statically(exchange, method, result, type, skipKeys)
+                skip_keys = exchange.safe_value(exchange_data, 'skipKeys', [])
+                await self.test_response_statically(exchange, method, skip_keys, result)
         await close(exchange)
 
-    def get_number_of_tests_from_exchange(self, exchange, exchangeData: object):
+    def get_number_of_tests_from_exchange(self, exchange, exchange_data):
         sum = 0
-        methods = exchangeData['methods']
-        methodsNames = list(methods.keys())
-        for i in range(0, len(methodsNames)):
-            method = methodsNames[i]
+        methods = exchange_data['methods']
+        methods_names = list(methods.keys())
+        for i in range(0, len(methods_names)):
+            method = methods_names[i]
             results = methods[method]
-            resultsLength = len(results)
-            sum = exchange.sum(sum, resultsLength)
+            results_length = len(results)
+            sum = exchange.sum(sum, results_length)
         return sum
 
-    async def run_static_tests(self, targetExchange: str = None, testName: str = None):
-        staticData = self.load_static_data(targetExchange)
-        exchanges = list(staticData.keys())
-        exchange = init_exchange('Exchange', {})  # tmp to do the calculations until we have the ast-transpiler transpiling self code
+    async def run_static_request_tests(self, target_exchange=None, test_name=None):
+        await self.run_static_tests('request', target_exchange, test_name)
+
+    async def run_static_tests(self, type, target_exchange=None, test_name=None):
+        folder = self.root_dir + './ts/src/test/static/' + type + '/'
+        static_data = self.load_static_data(folder, target_exchange)
+        exchanges = list(static_data.keys())
+        exchange = init_exchange('Exchange', {})  # tmp to do the calculations until we have the ast-transpiler transpiling this code
         promises = []
         sum = 0
-        if targetExchange:
-            dump("Exchange to test: " + targetExchange)
-        if testName:
-            dump("Testing only: " + testName)
+        if target_exchange:
+            dump('Exchange to test: ' + target_exchange)
+        if test_name:
+            dump('Testing only: ' + test_name)
         for i in range(0, len(exchanges)):
-            exchangeName = exchanges[i]
-            exchangeData = staticData[exchangeName]
-            numberOfTests = self.get_number_of_tests_from_exchange(exchange, exchangeData)
-            sum = exchange.sum(sum, numberOfTests)
-            promises.append(self.test_exchange_statically(exchangeName, exchangeData, testName))
+            exchange_name = exchanges[i]
+            exchange_data = static_data[exchange_name]
+            number_of_tests = self.get_number_of_tests_from_exchange(exchange, exchange_data)
+            sum = exchange.sum(sum, number_of_tests)
+            if type == 'request':
+                promises.append(self.test_exchange_request_statically(exchange_name, exchange_data, test_name))
+            else:
+                promises.append(self.test_exchange_response_statically(exchange_name, exchange_data, test_name))
         await asyncio.gather(*promises)
-        if self.staticTestsFailed:
+        if self.request_tests_failed or self.response_tests_failed:
             exit_script(1)
         else:
-            successMessage = '[' + self.lang + '][TEST_SUCCESS] ' + str(sum) + ' static tests passed.'
-            dump(successMessage)
+            success_message = '[' + self.lang + '][TEST_SUCCESS] ' + str(sum) + ' static ' + type + ' tests passed.'
+            dump(success_message)
             exit_script(0)
 
+    async def run_static_response_tests(self, exchange_name=None, test=None):
+        #  -----------------------------------------------------------------------------
+        #  --- Init of mockResponses tests functions------------------------------------
+        #  -----------------------------------------------------------------------------
+        await self.run_static_tests('response', exchange_name, test)
+
     async def run_broker_id_tests(self):
         #  -----------------------------------------------------------------------------
         #  --- Init of brokerId tests functions-----------------------------------------
         #  -----------------------------------------------------------------------------
-        promises = [
-            self.test_binance(),
-            self.test_okx(),
-            self.test_cryptocom(),
-            self.test_bybit(),
-            self.test_kucoin(),
-            self.test_kucoinfutures(),
-            self.test_bitget(),
-            self.test_mexc(),
-            self.test_huobi(),
-            self.test_woo(),
-            self.test_bitmart(),
-            self.test_coinex()
-        ]
+        promises = [self.test_binance(), self.test_okx(), self.test_cryptocom(), self.test_bybit(), self.test_kucoin(), self.test_kucoinfutures(), self.test_bitget(), self.test_mexc(), self.test_huobi(), self.test_woo(), self.test_bitmart(), self.test_coinex()]
         await asyncio.gather(*promises)
-        successMessage = '[' + self.lang + '][TEST_SUCCESS] brokerId tests passed.'
-        dump(successMessage)
+        success_message = '[' + self.lang + '][TEST_SUCCESS] brokerId tests passed.'
+        dump(success_message)
         exit_script(0)
 
     async def test_binance(self):
         binance = self.init_offline_exchange('binance')
-        spotId = 'x-R4BD3S82'
-        spotOrderRequest = None
+        spot_id = 'x-R4BD3S82'
+        spot_order_request = None
         try:
             await binance.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
-            spotOrderRequest = self.urlencoded_to_dict(binance.last_request_body)
-        clientOrderId = spotOrderRequest['newClientOrderId']
-        assert clientOrderId.startswith(spotId), 'spot clientOrderId does not start with spotId'
-        swapId = 'x-xcKtGhcu'
-        swapOrderRequest = None
+            spot_order_request = self.urlencoded_to_dict(binance.last_request_body)
+        client_order_id = spot_order_request['newClientOrderId']
+        assert client_order_id.startswith(spot_id), 'spot clientOrderId does not start with spotId'
+        swap_id = 'x-xcKtGhcu'
+        swap_order_request = None
         try:
             await binance.create_order('BTC/USDT:USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
-            swapOrderRequest = self.urlencoded_to_dict(binance.last_request_body)
-        swapInverseOrderRequest = None
+            swap_order_request = self.urlencoded_to_dict(binance.last_request_body)
+        swap_inverse_order_request = None
         try:
             await binance.create_order('BTC/USD:BTC', 'limit', 'buy', 1, 20000)
         except Exception as e:
-            swapInverseOrderRequest = self.urlencoded_to_dict(binance.last_request_body)
-        clientOrderIdSpot = swapOrderRequest['newClientOrderId']
-        assert clientOrderIdSpot.startswith(swapId), 'swap clientOrderId does not start with swapId'
-        clientOrderIdInverse = swapInverseOrderRequest['newClientOrderId']
-        assert clientOrderIdInverse.startswith(swapId), 'swap clientOrderIdInverse does not start with swapId'
+            swap_inverse_order_request = self.urlencoded_to_dict(binance.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'
+        client_order_id_inverse = swap_inverse_order_request['newClientOrderId']
+        assert client_order_id_inverse.startswith(swap_id), 'swap clientOrderIdInverse does not start with swapId'
         await close(binance)
 
     async def test_okx(self):
         okx = self.init_offline_exchange('okx')
         id = 'e847386590ce4dBC'
-        spotOrderRequest = None
+        spot_order_request = None
         try:
             await okx.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
-            spotOrderRequest = json_parse(okx.last_request_body)
-        clientOrderId = spotOrderRequest[0]['clOrdId']  # returns order inside array
-        assert clientOrderId.startswith(id), 'spot clientOrderId does not start with id'
-        assert spotOrderRequest[0]['tag'] == id, 'id different from spot tag'
-        swapOrderRequest = None
+            spot_order_request = json_parse(okx.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 spot_order_request[0]['tag'] == id, 'id different from spot tag'
+        swap_order_request = None
         try:
             await okx.create_order('BTC/USDT:USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
-            swapOrderRequest = json_parse(okx.last_request_body)
-        clientOrderIdSpot = swapOrderRequest[0]['clOrdId']
-        assert clientOrderIdSpot.startswith(id), 'swap clientOrderId does not start with id'
-        assert swapOrderRequest[0]['tag'] == id, 'id different from swap tag'
+            swap_order_request = json_parse(okx.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 swap_order_request[0]['tag'] == id, 'id different from swap tag'
         await close(okx)
 
     async def test_cryptocom(self):
@@ -1059,142 +1065,144 @@ class testMainClass(baseMainTestClass):
 
     async def test_bybit(self):
         bybit = self.init_offline_exchange('bybit')
-        reqHeaders = None
+        req_headers = None
         id = 'CCXT'
         assert bybit.options['brokerId'] == id, 'id not in options'
         try:
             await bybit.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
             # we expect an error here, we're only interested in the headers
-            reqHeaders = bybit.last_request_headers
-        assert reqHeaders['Referer'] == id, 'id not in headers'
+            req_headers = bybit.last_request_headers
+        assert req_headers['Referer'] == id, 'id not in headers'
         await close(bybit)
 
     async def test_kucoin(self):
         kucoin = self.init_offline_exchange('kucoin')
-        reqHeaders = None
+        req_headers = None
         assert kucoin.options['partner']['spot']['id'] == 'ccxt', 'id not in options'
         assert kucoin.options['partner']['spot']['key'] == '9e58cc35-5b5e-4133-92ec-166e3f077cb8', 'key not in options'
         try:
             await kucoin.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
             # we expect an error here, we're only interested in the headers
-            reqHeaders = kucoin.last_request_headers
+            req_headers = kucoin.last_request_headers
         id = 'ccxt'
-        assert reqHeaders['KC-API-PARTNER'] == id, 'id not in headers'
+        assert req_headers['KC-API-PARTNER'] == id, 'id not in headers'
         await close(kucoin)
 
     async def test_kucoinfutures(self):
         kucoin = self.init_offline_exchange('kucoinfutures')
-        reqHeaders = None
+        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'
         try:
             await kucoin.create_order('BTC/USDT:USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
-            reqHeaders = kucoin.last_request_headers
-        assert reqHeaders['KC-API-PARTNER'] == id, 'id not in headers'
+            req_headers = kucoin.last_request_headers
+        assert req_headers['KC-API-PARTNER'] == id, 'id not in headers'
         await close(kucoin)
 
     async def test_bitget(self):
         bitget = self.init_offline_exchange('bitget')
-        reqHeaders = None
+        req_headers = None
         id = 'p4sve'
         assert bitget.options['broker'] == id, 'id not in options'
         try:
             await bitget.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
-            reqHeaders = bitget.last_request_headers
-        assert reqHeaders['X-CHANNEL-API-CODE'] == id, 'id not in headers'
+            req_headers = bitget.last_request_headers
+        assert req_headers['X-CHANNEL-API-CODE'] == id, 'id not in headers'
         await close(bitget)
 
     async def test_mexc(self):
         mexc = self.init_offline_exchange('mexc')
-        reqHeaders = None
+        req_headers = None
         id = 'CCXT'
         assert mexc.options['broker'] == id, 'id not in options'
         await mexc.load_markets()
         try:
             await mexc.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
-            reqHeaders = mexc.last_request_headers
-        assert reqHeaders['source'] == id, 'id not in headers'
+            req_headers = mexc.last_request_headers
+        assert req_headers['source'] == id, 'id not in headers'
         await close(mexc)
 
     async def test_huobi(self):
         huobi = self.init_offline_exchange('huobi')
         # spot test
         id = 'AA03022abc'
-        spotOrderRequest = None
+        spot_order_request = None
         try:
             await huobi.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
-            spotOrderRequest = json_parse(huobi.last_request_body)
-        clientOrderId = spotOrderRequest['client-order-id']
-        assert clientOrderId.startswith(id), 'spot clientOrderId does not start with id'
+            spot_order_request = json_parse(huobi.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'
         # swap test
-        swapOrderRequest = None
+        swap_order_request = None
         try:
             await huobi.create_order('BTC/USDT:USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
-            swapOrderRequest = json_parse(huobi.last_request_body)
-        swapInverseOrderRequest = None
+            swap_order_request = json_parse(huobi.last_request_body)
+        swap_inverse_order_request = None
         try:
             await huobi.create_order('BTC/USD:BTC', 'limit', 'buy', 1, 20000)
         except Exception as e:
-            swapInverseOrderRequest = json_parse(huobi.last_request_body)
-        clientOrderIdSpot = swapOrderRequest['channel_code']
-        assert clientOrderIdSpot.startswith(id), 'swap channel_code does not start with id'
-        clientOrderIdInverse = swapInverseOrderRequest['channel_code']
-        assert clientOrderIdInverse.startswith(id), 'swap inverse channel_code does not start with id'
+            swap_inverse_order_request = json_parse(huobi.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'
+        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'
         await close(huobi)
 
     async def test_woo(self):
         woo = self.init_offline_exchange('woo')
         # spot test
         id = 'bc830de7-50f3-460b-9ee0-f430f83f9dad'
-        spotOrderRequest = None
+        spot_order_request = None
         try:
             await woo.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
-            spotOrderRequest = self.urlencoded_to_dict(woo.last_request_body)
-        brokerId = spotOrderRequest['broker_id']
-        assert brokerId.startswith(id), 'broker_id does not start with id'
+            spot_order_request = self.urlencoded_to_dict(woo.last_request_body)
+        broker_id = spot_order_request['broker_id']
+        assert broker_id.startswith(id), 'broker_id does not start with id'
         # swap test
-        stopOrderRequest = None
+        stop_order_request = None
         try:
-            await woo.create_order('BTC/USDT:USDT', 'limit', 'buy', 1, 20000, {'stopPrice': 30000})
+            await woo.create_order('BTC/USDT:USDT', 'limit', 'buy', 1, 20000, {
+                'stopPrice': 30000,
+            })
         except Exception as e:
-            stopOrderRequest = json_parse(woo.last_request_body)
-        clientOrderIdSpot = stopOrderRequest['brokerId']
-        assert clientOrderIdSpot.startswith(id), 'brokerId does not start with id'
+            stop_order_request = json_parse(woo.last_request_body)
+        client_order_id_spot = stop_order_request['brokerId']
+        assert client_order_id_spot.startswith(id), 'brokerId does not start with id'
         await close(woo)
 
     async def test_bitmart(self):
         bitmart = self.init_offline_exchange('bitmart')
-        reqHeaders = None
+        req_headers = None
         id = 'CCXTxBitmart000'
         assert bitmart.options['brokerId'] == id, 'id not in options'
         await bitmart.load_markets()
         try:
             await bitmart.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
-            reqHeaders = bitmart.last_request_headers
-        assert reqHeaders['X-BM-BROKER-ID'] == id, 'id not in headers'
+            req_headers = bitmart.last_request_headers
+        assert req_headers['X-BM-BROKER-ID'] == id, 'id not in headers'
         await close(bitmart)
 
     async def test_coinex(self):
         exchange = self.init_offline_exchange('coinex')
         id = 'x-167673045'
         assert exchange.options['brokerId'] == id, 'id not in options'
-        spotOrderRequest = None
+        spot_order_request = None
         try:
             await exchange.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
         except Exception as e:
-            spotOrderRequest = json_parse(exchange.last_request_body)
-        clientOrderId = spotOrderRequest['client_id']
-        assert clientOrderId.startswith(id), 'clientOrderId does not start with id'
+            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'
         await close(exchange)
 
 # ***** AUTO-TRANSPILER-END *****