test: ensure ln channels and payments with rpc commands

Author: pinheadmz

.github/workflows/test.yml

@@ -44,6 +44,7 @@ jobs:
           - dag_connection_test.py
           - graph_test.py
           - logging_test.py
+          - ln_basic_test.py
           - rpc_test.py
           - services_test.py
           - signet_test.py

src/warnet/ln.py

@@ -1,8 +1,8 @@
 import json
 
 import click
-
-from .k8s import get_pod
+from typing import Optional
+from .k8s import get_pod, get_default_namespace_or
 from .process import run_command
 
 
@@ -13,24 +13,26 @@ def ln():
 
 @ln.command(context_settings={"ignore_unknown_options": True})
 @click.argument("pod", type=str)
-@click.argument("command", type=str, required=True)
-def rpc(pod: str, command: str):
+@click.argument("method", type=str)
+@click.argument("params", type=str, nargs=-1)  # this will capture all remaining arguments
+@click.option("--namespace", default=None, show_default=True)
+def rpc(pod: str, method: str, params: str, namespace: Optional[str]):
     """
     Call lightning cli rpc <command> on <ln pod name>
     """
-    print(_rpc(pod, command))
+    print(_rpc(pod, method, params, namespace))
 
 
-def _rpc(pod_name: str, command: str):
+def _rpc(pod_name: str, method: str, params: str = "", namespace: Optional[str] = None):
     # TODO: when we add back cln we'll need to describe the pod,
     # get a label with implementation type and then adjust command
     pod = get_pod(pod_name)
+    namespace = get_default_namespace_or(namespace)
     chain = pod.metadata.labels["chain"]
-    cmd = f"kubectl exec {pod_name} -- lncli --network {chain} {command}"
+    cmd = f"kubectl -n {namespace} exec {pod_name} -- lncli --network {chain} {method} {' '.join(map(str, params))}"
     return run_command(cmd)
 
-
-@ln.command(context_settings={"ignore_unknown_options": True})
+@ln.command()
 @click.argument("pod", type=str)
 def pubkey(
     pod: str,
@@ -41,3 +43,17 @@ def pubkey(
     # TODO: again here, cln will need a different command
     info = _rpc(pod, "getinfo")
     print(json.loads(info)["identity_pubkey"])
+
+@ln.command()
+@click.argument("pod", type=str)
+def host(
+    pod: str,
+):
+    """
+    Get lightning node host from <ln pod name>
+    """
+    # TODO: again here, cln will need a different command
+    info = _rpc(pod, "getinfo")
+    uris = json.loads(info)["uris"]
+    if uris and len(uris) >= 0:
+        print(uris[0].split("@")[1])

test/data/ln/network.yaml

@@ -1,22 +1,13 @@
 nodes:
   - name: tank-0000
-    connect:
+    addnode:
       - tank-0001
     lnd: true
   - name: tank-0001
-    connect:
+    addnode:
       - tank-0002
     lnd: true
   - name: tank-0002
-    connect:
+    addnode:
       - tank-0000
-      - tank-0003
     lnd: true
-  - name: tank-0003
-    connect:
-      - tank-0004
-    lnd: true
-  - name: tank-0004
-    connect:
-      - tank-0000
-    lnd: true

test/ln_basic_test.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+
+import json
+import os
+from pathlib import Path
+from time import sleep
+
+from test_base import TestBase
+
+
+class LNBasicTest(TestBase):
+    def __init__(self):
+        super().__init__()
+        self.network_dir = Path(os.path.dirname(__file__)) / "data" / "ln"
+        self.miner_addr = ""
+
+    def run_test(self):
+        try:
+            self.setup_network()
+            self.fund_wallets()
+            self.manual_open_channels()
+            self.wait_for_gossip_sync()
+            self.pay_invoice()
+        finally:
+            self.cleanup()
+
+    def setup_network(self):
+        self.log.info("Setting up network")
+        self.log.info(self.warnet(f"deploy {self.network_dir}"))
+        self.wait_for_all_tanks_status(target="running")
+
+    def fund_wallets(self):
+        self.warnet("bitcoin rpc tank-0000 createwallet miner")
+        self.warnet("bitcoin rpc tank-0000 -generate 110")
+        self.wait_for_predicate(lambda: int(self.warnet("bitcoin rpc tank-0000 getblockcount")) > 100)
+
+        addrs = []
+        for lnd in ["tank-0000-lnd", "tank-0001-lnd", "tank-0002-lnd"]:
+            addrs.append(json.loads(self.warnet(f"ln rpc {lnd} newaddress p2wkh"))["address"])
+
+        self.warnet("bitcoin rpc tank-0000 sendmany '' '{" + f"\"{addrs[0]}\":10,\"{addrs[1]}\":10,\"{addrs[2]}\":10" + "}'")
+        self.warnet("bitcoin rpc tank-0000 -generate 1")
+
+    def manual_open_channels(self):
+        # 0 -> 1 -> 2
+        pk1 = self.warnet("ln pubkey tank-0001-lnd")
+        pk2 = self.warnet("ln pubkey tank-0002-lnd")
+
+        host1 = None
+        host2 = None
+
+        while not host1 or not host2:
+            if not host1:
+                host1 = self.warnet("ln host tank-0001-lnd")
+            if not host2:
+                host2 = self.warnet("ln host tank-0002-lnd")
+            sleep(1)
+
+        print(self.warnet(f"ln rpc tank-0000-lnd openchannel --node_key {pk1} --local_amt 100000 --connect {host1}"))
+        print(self.warnet(f"ln rpc tank-0001-lnd openchannel --node_key {pk2} --local_amt 100000 --connect {host2}"))
+
+        def wait_for_two_txs():
+            return 2 == json.loads(self.warnet("bitcoin rpc tank-0000 getmempoolinfo"))["size"]
+        self.wait_for_predicate(wait_for_two_txs)
+
+        self.warnet("bitcoin rpc tank-0000 -generate 10")
+
+
+    def wait_for_gossip_sync(self):
+        chs0 = []
+        chs1 = []
+        chs2 = []
+
+        while len(chs0) != 2 or len(chs1) != 2 or len(chs2) != 2:
+            if len(chs0) != 2:
+                chs0 = json.loads(self.warnet("ln rpc tank-0000-lnd describegraph"))["edges"]
+            if len(chs1) != 2:
+                chs1 = json.loads(self.warnet("ln rpc tank-0001-lnd describegraph"))["edges"]
+            if len(chs2) != 2:
+                chs2 = json.loads(self.warnet("ln rpc tank-0002-lnd describegraph"))["edges"]
+            sleep(1)
+
+
+    def pay_invoice(self):
+        inv = json.loads(self.warnet("ln rpc tank-0002-lnd addinvoice --amt 1000"))
+        print(inv)
+        print(self.warnet(f"ln rpc tank-0000-lnd payinvoice -f {inv['payment_request']}"))
+
+        def wait_for_success():
+            return 1000 == json.loads(self.warnet("ln rpc tank-0002-lnd channelbalance"))["balance"]
+            self.wait_for_predicate(wait_for_success)
+
+
+if __name__ == "__main__":
+    test = LNBasicTest()
+    test.run_test()