Reformat tests with black.

tests/basicswap/common.py

@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 
 # Copyright (c) 2020-2024 tecnovert
+# Copyright (c) 2024 The Basicswap developers
 # Distributed under the MIT software license, see the accompanying
 # file LICENSE.txt or http://www.opensource.org/licenses/mit-license.php.
 
@@ -17,7 +18,9 @@ from basicswap.contrib.rpcauth import generate_salt, password_to_hmac
 from basicswap.bin.prepare import downloadPIVXParams
 
 
-TEST_HTTP_HOST = os.getenv('TEST_HTTP_HOST', '127.0.0.1')  # Set to 0.0.0.0 when used in docker
+TEST_HTTP_HOST = os.getenv(
+    "TEST_HTTP_HOST", "127.0.0.1"
+)  # Set to 0.0.0.0 when used in docker
 TEST_HTTP_PORT = 1800
 
 BASE_P2P_PORT = 12792
@@ -39,84 +42,99 @@ PIVX_BASE_PORT = 34892
 PIVX_BASE_RPC_PORT = 35892
 PIVX_BASE_ZMQ_PORT = 36892
 
-PREFIX_SECRET_KEY_REGTEST = 0x2e
+PREFIX_SECRET_KEY_REGTEST = 0x2E
 
 
-def prepareDataDir(datadir, node_id, conf_file, dir_prefix, base_p2p_port=BASE_PORT, base_rpc_port=BASE_RPC_PORT, num_nodes=3, extra_opts=[]):
+def prepareDataDir(
+    datadir,
+    node_id,
+    conf_file,
+    dir_prefix,
+    base_p2p_port=BASE_PORT,
+    base_rpc_port=BASE_RPC_PORT,
+    num_nodes=3,
+    extra_opts=[],
+):
     node_dir = os.path.join(datadir, dir_prefix + str(node_id))
     if not os.path.exists(node_dir):
         os.makedirs(node_dir)
     cfg_file_path = os.path.join(node_dir, conf_file)
     if os.path.exists(cfg_file_path):
         return
-    with open(cfg_file_path, 'w+') as fp:
-        fp.write('regtest=1\n')
-        fp.write('[regtest]\n')
-        fp.write('port=' + str(base_p2p_port + node_id) + '\n')
-        fp.write('rpcport=' + str(base_rpc_port + node_id) + '\n')
+    with open(cfg_file_path, "w+") as fp:
+        fp.write("regtest=1\n")
+        fp.write("[regtest]\n")
+        fp.write("port=" + str(base_p2p_port + node_id) + "\n")
+        fp.write("rpcport=" + str(base_rpc_port + node_id) + "\n")
 
         salt = generate_salt(16)
-        fp.write('rpcauth={}:{}${}\n'.format('test' + str(node_id), salt, password_to_hmac(salt, 'test_pass' + str(node_id))))
+        fp.write(
+            "rpcauth={}:{}${}\n".format(
+                "test" + str(node_id),
+                salt,
+                password_to_hmac(salt, "test_pass" + str(node_id)),
+            )
+        )
 
-        fp.write('daemon=0\n')
-        fp.write('printtoconsole=0\n')
-        fp.write('server=1\n')
-        fp.write('discover=0\n')
-        fp.write('listenonion=0\n')
-        fp.write('bind=127.0.0.1\n')
-        fp.write('debug=1\n')
-        fp.write('debugexclude=libevent\n')
+        fp.write("daemon=0\n")
+        fp.write("printtoconsole=0\n")
+        fp.write("server=1\n")
+        fp.write("discover=0\n")
+        fp.write("listenonion=0\n")
+        fp.write("bind=127.0.0.1\n")
+        fp.write("debug=1\n")
+        fp.write("debugexclude=libevent\n")
 
-        fp.write('fallbackfee=0.01\n')
-        fp.write('acceptnonstdtxn=0\n')
-        fp.write('txindex=1\n')
-        fp.write('wallet=wallet.dat\n')
+        fp.write("fallbackfee=0.01\n")
+        fp.write("acceptnonstdtxn=0\n")
+        fp.write("txindex=1\n")
+        fp.write("wallet=wallet.dat\n")
 
-        fp.write('findpeers=0\n')
+        fp.write("findpeers=0\n")
 
         for opt in extra_opts:
-            fp.write(opt + '\n')
+            fp.write(opt + "\n")
 
         if base_p2p_port == BTC_BASE_PORT:
-            fp.write('deprecatedrpc=create_bdb\n')
+            fp.write("deprecatedrpc=create_bdb\n")
         elif base_p2p_port == BASE_PORT:  # Particl
-            fp.write('zmqpubsmsg=tcp://127.0.0.1:{}\n'.format(BASE_ZMQ_PORT + node_id))
+            fp.write("zmqpubsmsg=tcp://127.0.0.1:{}\n".format(BASE_ZMQ_PORT + node_id))
             # minstakeinterval=5  # Using walletsettings stakelimit instead
-            fp.write('stakethreadconddelayms=1000\n')
-            fp.write('smsgsregtestadjust=0\n')
+            fp.write("stakethreadconddelayms=1000\n")
+            fp.write("smsgsregtestadjust=0\n")
 
-        if conf_file == 'pivx.conf':
-            params_dir = os.path.join(datadir, 'pivx-params')
+        if conf_file == "pivx.conf":
+            params_dir = os.path.join(datadir, "pivx-params")
             downloadPIVXParams(params_dir)
-            fp.write(f'paramsdir={params_dir}\n')
+            fp.write(f"paramsdir={params_dir}\n")
 
         for i in range(0, num_nodes):
             if node_id == i:
                 continue
-            fp.write('addnode=127.0.0.1:{}\n'.format(base_p2p_port + i))
+            fp.write("addnode=127.0.0.1:{}\n".format(base_p2p_port + i))
 
     return node_dir
 
 
 def checkForks(ro):
     try:
-        if 'bip9_softforks' in ro:
-            assert (ro['bip9_softforks']['csv']['status'] == 'active')
-            assert (ro['bip9_softforks']['segwit']['status'] == 'active')
+        if "bip9_softforks" in ro:
+            assert ro["bip9_softforks"]["csv"]["status"] == "active"
+            assert ro["bip9_softforks"]["segwit"]["status"] == "active"
         else:
-            assert (ro['softforks']['csv']['active'])
-            assert (ro['softforks']['segwit']['active'])
+            assert ro["softforks"]["csv"]["active"]
+            assert ro["softforks"]["segwit"]["active"]
     except Exception as e:
-        logging.warning('Could not parse deployment info')
+        logging.warning("Could not parse deployment info")
 
 
 def stopDaemons(daemons):
     for d in daemons:
-        logging.info('Interrupting %d', d.handle.pid)
+        logging.info("Interrupting %d", d.handle.pid)
         try:
             d.handle.send_signal(signal.SIGINT)
         except Exception as e:
-            logging.info('Interrupting %d, error %s', d.handle.pid, str(e))
+            logging.info("Interrupting %d, error %s", d.handle.pid, str(e))
     for d in daemons:
         try:
             d.handle.wait(timeout=20)
@@ -124,21 +142,23 @@ def stopDaemons(daemons):
                 if fp:
                     fp.close()
         except Exception as e:
-            logging.info('Closing %d, error %s', d.handle.pid, str(e))
+            logging.info("Closing %d, error %s", d.handle.pid, str(e))
 
 
-def wait_for_bid(delay_event, swap_client, bid_id, state=None, sent: bool = False, wait_for: int = 20) -> None:
-    logging.info('wait_for_bid %s', bid_id.hex())
+def wait_for_bid(
+    delay_event, swap_client, bid_id, state=None, sent: bool = False, wait_for: int = 20
+) -> None:
+    logging.info("wait_for_bid %s", bid_id.hex())
     for i in range(wait_for):
         if delay_event.is_set():
-            raise ValueError('Test stopped.')
+            raise ValueError("Test stopped.")
         delay_event.wait(1)
 
         filters = {
-            'bid_id': bid_id,
+            "bid_id": bid_id,
         }
         bids = swap_client.listBids(sent=sent, filters=filters)
-        assert (len(bids) < 2)
+        assert len(bids) < 2
         for bid in bids:
             if bid[2] == bid_id:
                 if isinstance(state, (list, tuple)):
@@ -149,55 +169,65 @@ def wait_for_bid(delay_event, swap_client, bid_id, state=None, sent: bool = Fals
                 elif state is not None and state != bid[5]:
                     continue
                 return
-    raise ValueError('wait_for_bid timed out.')
+    raise ValueError("wait_for_bid timed out.")
 
 
-def wait_for_bid_tx_state(delay_event, swap_client, bid_id, initiate_state, participate_state, wait_for=30):
-    logging.info('wait_for_bid_tx_state %s %s %s', bid_id.hex(), str(initiate_state), str(participate_state))
+def wait_for_bid_tx_state(
+    delay_event, swap_client, bid_id, initiate_state, participate_state, wait_for=30
+):
+    logging.info(
+        "wait_for_bid_tx_state %s %s %s",
+        bid_id.hex(),
+        str(initiate_state),
+        str(participate_state),
+    )
     for i in range(wait_for):
         if delay_event.is_set():
-            raise ValueError('Test stopped.')
+            raise ValueError("Test stopped.")
         delay_event.wait(1)
         bid = swap_client.getBid(bid_id)
-        if (initiate_state is None or bid.getITxState() == initiate_state) \
-           and (participate_state is None or bid.getPTxState() == participate_state):
+        if (initiate_state is None or bid.getITxState() == initiate_state) and (
+            participate_state is None or bid.getPTxState() == participate_state
+        ):
             return
-    raise ValueError('wait_for_bid_tx_state timed out.')
+    raise ValueError("wait_for_bid_tx_state timed out.")
 
 
-def wait_for_event(delay_event, swap_client, linked_type, linked_id, event_type=None, wait_for=20):
-    logging.info('wait_for_event')
+def wait_for_event(
+    delay_event, swap_client, linked_type, linked_id, event_type=None, wait_for=20
+):
+    logging.info("wait_for_event")
 
     for i in range(wait_for):
         if delay_event.is_set():
-            raise ValueError('Test stopped.')
+            raise ValueError("Test stopped.")
         delay_event.wait(1)
         rv = swap_client.getEvents(linked_type, linked_id)
 
         for event in rv:
             if event_type is None or event.event_type == event_type:
                 return event
-    raise ValueError('wait_for_event timed out.')
+    raise ValueError("wait_for_event timed out.")
 
 
 def wait_for_offer(delay_event, swap_client, offer_id, wait_for=20):
-    logging.info('wait_for_offer %s', offer_id.hex())
+    logging.info("wait_for_offer %s", offer_id.hex())
     for i in range(wait_for):
         if delay_event.is_set():
-            raise ValueError('Test stopped.')
+            raise ValueError("Test stopped.")
         delay_event.wait(1)
         offers = swap_client.listOffers()
         for offer in offers:
             if offer.offer_id == offer_id:
                 return
-    raise ValueError('wait_for_offer timed out.')
+    raise ValueError("wait_for_offer timed out.")
 
 
 def wait_for_no_offer(delay_event, swap_client, offer_id, wait_for=20):
-    logging.info('wait_for_no_offer %s', offer_id.hex())
+    logging.info("wait_for_no_offer %s", offer_id.hex())
     for i in range(wait_for):
         if delay_event.is_set():
-            raise ValueError('Test stopped.')
+            raise ValueError("Test stopped.")
         delay_event.wait(1)
         offers = swap_client.listOffers()
         found_offer = False
@@ -207,35 +237,35 @@ def wait_for_no_offer(delay_event, swap_client, offer_id, wait_for=20):
                 break
         if not found_offer:
             return True
-    raise ValueError('wait_for_offer timed out.')
+    raise ValueError("wait_for_offer timed out.")
 
 
 def wait_for_in_progress(delay_event, swap_client, bid_id, sent=False):
-    logging.info('wait_for_in_progress %s', bid_id.hex())
+    logging.info("wait_for_in_progress %s", bid_id.hex())
     for i in range(20):
         if delay_event.is_set():
-            raise ValueError('Test stopped.')
+            raise ValueError("Test stopped.")
         delay_event.wait(1)
         swaps = swap_client.listSwapsInProgress()
         for b in swaps:
             if b[0] == bid_id:
                 return
-    raise ValueError('wait_for_in_progress timed out.')
+    raise ValueError("wait_for_in_progress timed out.")
 
 
 def wait_for_none_active(delay_event, port, wait_for=30):
     for i in range(wait_for):
         if delay_event.is_set():
-            raise ValueError('Test stopped.')
+            raise ValueError("Test stopped.")
         delay_event.wait(1)
         js = read_json_api(port)
-        if js['num_swapping'] == 0 and js['num_watched_outputs'] == 0:
+        if js["num_swapping"] == 0 and js["num_watched_outputs"] == 0:
             return
-    raise ValueError('wait_for_none_active timed out.')
+    raise ValueError("wait_for_none_active timed out.")
 
 
 def abandon_all_swaps(delay_event, swap_client) -> None:
-    logging.info('abandon_all_swaps')
+    logging.info("abandon_all_swaps")
     for bid in swap_client.listBids(sent=True):
         swap_client.abandonBid(bid[2])
     for bid in swap_client.listBids(sent=False):
@@ -245,37 +275,39 @@ def abandon_all_swaps(delay_event, swap_client) -> None:
 def waitForNumOffers(delay_event, port, offers, wait_for=20):
     for i in range(wait_for):
         if delay_event.is_set():
-            raise ValueError('Test stopped.')
+            raise ValueError("Test stopped.")
         summary = read_json_api(port)
-        if summary['num_network_offers'] >= offers:
+        if summary["num_network_offers"] >= offers:
             return
         delay_event.wait(1)
-    raise ValueError('waitForNumOffers failed')
+    raise ValueError("waitForNumOffers failed")
 
 
 def waitForNumBids(delay_event, port, bids, wait_for=20):
     for i in range(wait_for):
         if delay_event.is_set():
-            raise ValueError('Test stopped.')
+            raise ValueError("Test stopped.")
         summary = read_json_api(port)
-        if summary['num_recv_bids'] >= bids:
+        if summary["num_recv_bids"] >= bids:
             return
         delay_event.wait(1)
-    raise ValueError('waitForNumBids failed')
+    raise ValueError("waitForNumBids failed")
 
 
 def waitForNumSwapping(delay_event, port, bids, wait_for=60):
     for i in range(wait_for):
         if delay_event.is_set():
-            raise ValueError('Test stopped.')
+            raise ValueError("Test stopped.")
         summary = read_json_api(port)
-        if summary['num_swapping'] >= bids:
+        if summary["num_swapping"] >= bids:
             return
         delay_event.wait(1)
-    raise ValueError('waitForNumSwapping failed')
+    raise ValueError("waitForNumSwapping failed")
 
 
-def wait_for_balance(delay_event, url, balance_key, expect_amount, iterations=20, delay_time=3) -> None:
+def wait_for_balance(
+    delay_event, url, balance_key, expect_amount, iterations=20, delay_time=3
+) -> None:
     i = 0
     while not delay_event.is_set():
         rv_js = json.loads(urlopen(url).read())
@@ -284,11 +316,13 @@ def wait_for_balance(delay_event, url, balance_key, expect_amount, iterations=20
         delay_event.wait(delay_time)
         i += 1
         if i > iterations:
-            raise ValueError('Expect {} {}'.format(balance_key, expect_amount))
+            raise ValueError("Expect {} {}".format(balance_key, expect_amount))
 
 
-def wait_for_unspent(delay_event, ci, expect_amount, iterations=20, delay_time=1) -> None:
-    logging.info(f'Waiting for unspent balance: {expect_amount}')
+def wait_for_unspent(
+    delay_event, ci, expect_amount, iterations=20, delay_time=1
+) -> None:
+    logging.info(f"Waiting for unspent balance: {expect_amount}")
     i = 0
     while not delay_event.is_set():
         unspent_addr = ci.getUnspentsByAddr()
@@ -298,36 +332,41 @@ def wait_for_unspent(delay_event, ci, expect_amount, iterations=20, delay_time=1
         delay_event.wait(delay_time)
         i += 1
         if i > iterations:
-            raise ValueError('wait_for_unspent {}'.format(expect_amount))
+            raise ValueError("wait_for_unspent {}".format(expect_amount))
 
 
 def delay_for(delay_event, delay_for=60):
-    logging.info('Delaying for {} seconds.'.format(delay_for))
+    logging.info("Delaying for {} seconds.".format(delay_for))
     delay_event.wait(delay_for)
 
 
 def make_rpc_func(node_id, base_rpc_port=BASE_RPC_PORT):
     node_id = node_id
-    auth = 'test{0}:test_pass{0}'.format(node_id)
+    auth = "test{0}:test_pass{0}".format(node_id)
 
     def rpc_func(method, params=None, wallet=None):
         nonlocal node_id, auth
         return callrpc(base_rpc_port + node_id, auth, method, params, wallet)
+
     return rpc_func
 
 
-def waitForRPC(rpc_func, delay_event, rpc_command='getwalletinfo', max_tries=7):
+def waitForRPC(rpc_func, delay_event, rpc_command="getwalletinfo", max_tries=7):
     for i in range(max_tries + 1):
         if delay_event.is_set():
-            raise ValueError('Test stopped.')
+            raise ValueError("Test stopped.")
         try:
             rpc_func(rpc_command)
             return
         except Exception as ex:
             if i < max_tries:
-                logging.warning('Can\'t connect to RPC: %s. Retrying in %d second/s.', str(ex), (i + 1))
+                logging.warning(
+                    "Can't connect to RPC: %s. Retrying in %d second/s.",
+                    str(ex),
+                    (i + 1),
+                )
                 delay_event.wait(i + 1)
-    raise ValueError('waitForRPC failed')
+    raise ValueError("waitForRPC failed")
 
 
 def extract_states_from_xu_file(file_path, prefix):
@@ -336,39 +375,41 @@ def extract_states_from_xu_file(file_path, prefix):
     alt_counter = 0
     active_path = 0
     states[active_path] = []
-    path_stack = [active_path, ]
+    path_stack = [
+        active_path,
+    ]
     with open(file_path) as fp:
         for line in fp:
             line = line.strip()
-            if line.startswith('#'):
+            if line.startswith("#"):
                 continue
 
-            if line == '};':
+            if line == "};":
                 if len(path_stack) > 1:
                     path_stack.pop()
                     active_path = path_stack[-1]
                 continue
 
-            split_line = line.split('[')
+            split_line = line.split("[")
             if len(split_line) < 2:
                 continue
 
-            definitions = split_line[0].split(' ')
+            definitions = split_line[0].split(" ")
             if len(definitions) < 2:
                 continue
 
-            if definitions[1] == 'alt':
+            if definitions[1] == "alt":
                 alt_counter += 1
                 path_stack.append(alt_counter)
 
                 states[alt_counter] = [s for s in states[active_path]]
                 continue
 
-            if definitions[0] == '---':
+            if definitions[0] == "---":
                 active_path = path_stack[-1]
                 continue
 
-            if definitions[1] != 'abox':
+            if definitions[1] != "abox":
                 continue
             if definitions[0] != prefix:
                 continue
@@ -384,7 +425,7 @@ def extract_states_from_xu_file(file_path, prefix):
                 continue
             label = split_line[1][pos_start:pos_end]
 
-            if line.find('textbgcolor') > 0:
+            if line.find("textbgcolor") > 0:
                 # transaction status
                 pass
 
@@ -396,35 +437,39 @@ def extract_states_from_xu_file(file_path, prefix):
 def compare_bid_states(states, expect_states, exact_match: bool = True) -> bool:
 
     for i in range(len(states) - 1, -1, -1):
-        if states[i][1] == 'Bid Delaying':
+        if states[i][1] == "Bid Delaying":
             del states[i]
 
     try:
         if exact_match:
-            assert (len(states) == len(expect_states))
+            assert len(states) == len(expect_states)
         else:
-            assert (len(states) >= len(expect_states))
+            assert len(states) >= len(expect_states)
 
         for i in range(len(expect_states)):
             s = states[i]
             if s[1] != expect_states[i]:
-                if 'Bid ' + expect_states[i] == s[1]:
-                    logging.warning(f'Expected state {expect_states[i]} not an exact match to {s[1]}.')
+                if "Bid " + expect_states[i] == s[1]:
+                    logging.warning(
+                        f"Expected state {expect_states[i]} not an exact match to {s[1]}."
+                    )
                     continue
                 if [s[0], expect_states[i]] in states:
-                    logging.warning(f'Expected state {expect_states[i]} found out of order at the same time as {s[1]}.')
+                    logging.warning(
+                        f"Expected state {expect_states[i]} found out of order at the same time as {s[1]}."
+                    )
                     continue
-                raise ValueError(f'Expected state {expect_states[i]}, found {s[1]}')
-            assert (s[1] == expect_states[i])
+                raise ValueError(f"Expected state {expect_states[i]}, found {s[1]}")
+            assert s[1] == expect_states[i]
     except Exception as e:
-        logging.info('Expecting states: {}'.format(json.dumps(expect_states, indent=4)))
-        logging.info('Have states: {}'.format(json.dumps(states, indent=4)))
+        logging.info("Expecting states: {}".format(json.dumps(expect_states, indent=4)))
+        logging.info("Have states: {}".format(json.dumps(states, indent=4)))
         raise e
     return True
 
 
 def compare_bid_states_unordered(states, expect_states, ignore_states=[]) -> bool:
-    ignore_states.append('Bid Delaying')
+    ignore_states.append("Bid Delaying")
     for i in range(len(states) - 1, -1, -1):
         if states[i][1] in ignore_states:
             del states[i]
@@ -432,9 +477,9 @@ def compare_bid_states_unordered(states, expect_states, ignore_states=[]) -> boo
     try:
         assert len(states) == len(expect_states)
         for state in expect_states:
-            assert (any(state in s[1] for s in states))
+            assert any(state in s[1] for s in states)
     except Exception as e:
-        logging.info('Expecting states: {}'.format(json.dumps(expect_states, indent=4)))
-        logging.info('Have states: {}'.format(json.dumps(states, indent=4)))
+        logging.info("Expecting states: {}".format(json.dumps(expect_states, indent=4)))
+        logging.info("Have states: {}".format(json.dumps(states, indent=4)))
         raise e
     return True