feat: refactoring the python binding test

Author: heyolaniran

bindings/python/src/ldk_node/test_ldk_node.py

@@ -12,6 +12,9 @@
 DEFAULT_TEST_NETWORK = Network.REGTEST
 DEFAULT_BITCOIN_CLI_BIN = "bitcoin-cli"
 
+DEFAULT_MAX_ATTEMPS=25
+SLEEP_TIME=0.5
+
 def bitcoin_cli(cmd):
     args = []
 
@@ -51,9 +54,9 @@ def mine_and_wait(esplora_endpoint, blocks):
 def wait_for_block(esplora_endpoint, block_hash):
     url = esplora_endpoint + "/block/" + block_hash + "/status"
     attempts = 0
-    max_attempts = 30
 
-    while attempts < max_attempts:
+
+    while attempts < DEFAULT_MAX_ATTEMPS:
         try:
             res = requests.get(url, timeout=10)
             json = res.json()
@@ -64,16 +67,16 @@ def wait_for_block(esplora_endpoint, block_hash):
             print(f"Error: {e}")
 
         attempts += 1
-        time.sleep(0.5)
+        time.sleep(SLEEP_TIME)
 
-    raise Exception(f"Failed to confirm block {block_hash} after {max_attempts} attempts")
+    raise Exception(f"Failed to confirm block {block_hash} after {DEFAULT_MAX_ATTEMPS} attempts")
 
 def wait_for_tx(esplora_endpoint, txid):
     url = esplora_endpoint + "/tx/" + txid
     attempts = 0
-    max_attempts = 30
+    
 
-    while attempts < max_attempts:
+    while attempts < DEFAULT_MAX_ATTEMPS:
         try:
             res = requests.get(url, timeout=10)
             json = res.json()
@@ -84,9 +87,9 @@ def wait_for_tx(esplora_endpoint, txid):
             print(f"Error: {e}")
 
         attempts += 1
-        time.sleep(0.5)
+        time.sleep(SLEEP_TIME)
 
-    raise Exception(f"Failed to confirm transaction {txid} after {max_attempts} attempts")
+    raise Exception(f"Failed to confirm transaction {txid} after {DEFAULT_MAX_ATTEMPS} attempts")
 
 def send_to_address(address, amount_sats):
     amount_btc = amount_sats/100000000.0
@@ -112,6 +115,14 @@ def get_esplora_endpoint():
         return str(os.environ['ESPLORA_ENDPOINT'])
     return DEFAULT_ESPLORA_SERVER_URL
 
+# handling events
+
+def event_handling(node, expected_event_type):
+    event = node.wait_next_event()
+    assert isinstance(event, expected_event_type)
+    print("EVENT:", event)
+    node.event_handled()
+
 class TestLdkNode(unittest.TestCase):
     def setUp(self):
         bitcoin_cli("createwallet ldk_node_test")
@@ -123,26 +134,33 @@ def setUp(self):
     def test_channel_full_cycle(self):
         esplora_endpoint = get_esplora_endpoint()
 
-        ## Setup Node 1
+        ## Setup NodeS 1 & 2 in paralel
         tmp_dir_1 = tempfile.TemporaryDirectory("_ldk_node_1")
+        tmp_dir_2 =  tempfile.TemporaryDirectory("_ldk_node_2")
         print("TMP DIR 1:", tmp_dir_1.name)
+        print("TMP DIR 2:", tmp_dir_2.name)
 
+        # listening addresses
         listening_addresses_1 = ["127.0.0.1:2323"]
-        node_1 = setup_node(tmp_dir_1.name, esplora_endpoint, listening_addresses_1)
-        node_1.start()
-        node_id_1 = node_1.node_id()
-        print("Node ID 1:", node_id_1)
+        listening_addresses_2 = ["127.0.0.1:2324"]
 
-        # Setup Node 2
-        tmp_dir_2 = tempfile.TemporaryDirectory("_ldk_node_2")
-        print("TMP DIR 2:", tmp_dir_2.name)
+        # Start both node 
 
-        listening_addresses_2 = ["127.0.0.1:2324"]
-        node_2 = setup_node(tmp_dir_2.name, esplora_endpoint, listening_addresses_2)
+        node_1 = setup_node(tmp_dir=tmp_dir_1 , esplora_endpoint=esplora_endpoint, listening_addresses=listening_addresses_1)
+        node_2 = setup_node(tmp_dir=tmp_dir_2, esplora_endpoint=esplora_endpoint, listening_addresses=listening_addresses_2)
+
+        node_1.start()
         node_2.start()
+
+        # get Nodes IDs
+        node_id_1 = node_1.node_id()
         node_id_2 = node_2.node_id()
+        print("Node ID 1:", node_id_1)
         print("Node ID 2:", node_id_2)
 
+
+        # Send funds to both addresses in parallel
+
         address_1 = node_1.onchain_payment().new_address()
         txid_1 = send_to_address(address_1, 100000)
         address_2 = node_2.onchain_payment().new_address()
@@ -153,37 +171,28 @@ def test_channel_full_cycle(self):
 
         mine_and_wait(esplora_endpoint, 6)
 
+        # Sync both nodes
         node_1.sync_wallets()
         node_2.sync_wallets()
 
-        spendable_balance_1 = node_1.list_balances().spendable_onchain_balance_sats
-        spendable_balance_2 = node_2.list_balances().spendable_onchain_balance_sats
-        total_balance_1 = node_1.list_balances().total_onchain_balance_sats
-        total_balance_2 = node_2.list_balances().total_onchain_balance_sats
-
-        print("SPENDABLE 1:", spendable_balance_1)
-        self.assertEqual(spendable_balance_1, 100000)
-
-        print("SPENDABLE 2:", spendable_balance_2)
-        self.assertEqual(spendable_balance_2, 100000)
+        # verify balances
 
-        print("TOTAL 1:", total_balance_1)
-        self.assertEqual(total_balance_1, 100000)
-
-        print("TOTAL 2:", total_balance_2)
-        self.assertEqual(total_balance_2, 100000)
+        for node, name in [(node_1, '1'), (node_2,"2")] :
+            spendable_balance = node.list_balances().spendable_onchain_balance_sats
+            total_balance = node.list_balances().total_onchain_balance_sats
+            self.assertEqual(spendable_balance, 100000, f"Node {name} spendable balance should be 100000 sats, the test spotted {spendable_balance} sats")
+            self.assertEqual(total_balance, 100000, f"Node {name} total balance should be 100000 sats, the test spotted {total_balance} sats")
+        
 
         node_1.open_channel(node_id_2, listening_addresses_2[0], 50000, None, None)
 
+        # check if both nodes received the channel pending event
         channel_pending_event_1 = node_1.wait_next_event()
         assert isinstance(channel_pending_event_1, Event.CHANNEL_PENDING)
         print("EVENT:", channel_pending_event_1)
         node_1.event_handled()
 
-        channel_pending_event_2 = node_2.wait_next_event()
-        assert isinstance(channel_pending_event_2, Event.CHANNEL_PENDING)
-        print("EVENT:", channel_pending_event_2)
-        node_2.event_handled()
+        event_handling(node_2, Event.CHANNEL_PENDING)
 
         funding_txid = channel_pending_event_1.funding_txo.txid
         wait_for_tx(esplora_endpoint, funding_txid)
@@ -198,37 +207,28 @@ def test_channel_full_cycle(self):
         print("funding_txo:", funding_txid)
         node_1.event_handled()
 
-        channel_ready_event_2 = node_2.wait_next_event()
-        assert isinstance(channel_ready_event_2, Event.CHANNEL_READY)
-        print("EVENT:", channel_ready_event_2)
-        node_2.event_handled()
+        # check if the channel is active
+        event_handling(node_2, Event.CHANNEL_READY)
 
         description = Bolt11InvoiceDescription.DIRECT("asdf")
         invoice = node_2.bolt11_payment().receive(2500000, description, 9217)
         node_1.bolt11_payment().send(invoice, None)
 
-        payment_successful_event_1 = node_1.wait_next_event()
-        assert isinstance(payment_successful_event_1, Event.PAYMENT_SUCCESSFUL)
-        print("EVENT:", payment_successful_event_1)
-        node_1.event_handled()
 
-        payment_received_event_2 = node_2.wait_next_event()
-        assert isinstance(payment_received_event_2, Event.PAYMENT_RECEIVED)
-        print("EVENT:", payment_received_event_2)
-        node_2.event_handled()
+        # check if the payment is done
+        event_handling(node_1, Event.PAYMENT_SUCCESSFUL)
+        # check if the node 2 received the payment
+        event_handling(node_2, Event.PAYMENT_RECEIVED)
 
-        node_2.close_channel(channel_ready_event_2.user_channel_id, node_id_1)
 
-        channel_closed_event_1 = node_1.wait_next_event()
-        assert isinstance(channel_closed_event_1, Event.CHANNEL_CLOSED)
-        print("EVENT:", channel_closed_event_1)
-        node_1.event_handled()
+     
+
+        node_2.close_channel(channel_ready_event_2.user_channel_id, node_id_1)
 
-        channel_closed_event_2 = node_2.wait_next_event()
-        assert isinstance(channel_closed_event_2, Event.CHANNEL_CLOSED)
-        print("EVENT:", channel_closed_event_2)
-        node_2.event_handled()
+        for node in [node_1, node_2]:
+            event_handling(node, Event.CHANNEL_CLOSED)
 
+        # mine and wait for the close transaction to confirm
         mine_and_wait(esplora_endpoint, 1)
 
         node_1.sync_wallets()