itest: make test files more concise

itest/tests/helpers.py

@@ -0,0 +1,68 @@
+from binascii import hexlify
+from bitcoin.wallet import CBitcoinSecret
+from fixtures import whatthefee, postgres_factory, swapd_factory
+from pyln.testing.fixtures import (
+    bitcoind,
+    directory,
+    db_provider,
+    executor,
+    jsonschemas,
+    node_cls,
+    node_factory,
+    setup_logging,
+    teardown_checks,
+    test_base_dir,
+    test_name,
+)
+from pyln.testing.utils import wait_for, SLOW_MACHINE
+import hashlib
+import os
+
+__all__ = [
+    "bitcoind",
+    "directory",
+    "db_provider",
+    "executor",
+    "jsonschemas",
+    "node_cls",
+    "node_factory",
+    "setup_logging",
+    "teardown_checks",
+    "test_base_dir",
+    "test_name",
+    "wait_for",
+    "SLOW_MACHINE",
+    "setup_user_and_swapper",
+    "add_fund_init",
+    "whatthefee",
+    "postgres_factory",
+    "swapd_factory",
+]
+
+
+def setup_user_and_swapper(node_factory, swapd_factory, swapd_opts=None):
+    user = node_factory.get_node()
+    swapper = swapd_factory.get_swapd(options=swapd_opts)
+    swapper.lightning_node.openchannel(user, 1000000)
+    wait_for(
+        lambda: all(
+            channel["state"] == "CHANNELD_NORMAL"
+            for channel in swapper.lightning_node.rpc.listpeerchannels()["channels"]
+        )
+    )
+    return user, swapper
+
+
+def add_fund_init(user, swapper, amount=100_000_000):
+    preimage = os.urandom(32)
+    h = hashlib.sha256(preimage).digest()
+    secret_key = CBitcoinSecret.from_secret_bytes(os.urandom(32))
+    public_key = secret_key.pub
+    add_fund_resp = swapper.rpc.add_fund_init(user, public_key, h)
+    payment_request = user.rpc.invoice(
+        amount,
+        "test",
+        "test",
+        preimage=hexlify(preimage).decode("ASCII"),
+    )["bolt11"]
+    return add_fund_resp.address, payment_request, hexlify(h).decode("ASCII")

itest/tests/test_filtered_address.py

@@ -1,59 +1,19 @@
-from binascii import hexlify
-from bitcoin.wallet import CBitcoinSecret
-from pyln.testing.fixtures import (
-    bitcoind,
-    directory,
-    db_provider,
-    executor,
-    jsonschemas,
-    node_cls,
-    node_factory,
-    setup_logging,
-    teardown_checks,
-    test_base_dir,
-    test_name,
-)
-from pyln.testing.utils import wait_for
-from fixtures import whatthefee, swapd_factory, postgres_factory
-import hashlib
-import os
+from helpers import *
 import grpc
 
 
 def test_filtered_address(node_factory, swapd_factory):
     user = node_factory.get_node()
     swapper = swapd_factory.get_swapd()
-    swapper.lightning_node.openchannel(user, 1000000)
-    wait_for(
-        lambda: all(
-            channel["state"] == "CHANNELD_NORMAL"
-            for channel in swapper.lightning_node.rpc.listpeerchannels()["channels"]
-        )
-    )
     user_address = user.rpc.newaddr()["bech32"]
-    # create 2 utxos, because the first will be needed as reserve
     user_address, user_txid = user.fundwallet(200_000)
     swapper.internal_rpc.add_address_filters([user_address])
 
-    user_node_id = user.info["id"]
-    secret_key = CBitcoinSecret.from_secret_bytes(os.urandom(32))
-    public_key = secret_key.pub
-    preimage = os.urandom(32)
-    h = hashlib.sha256(preimage).digest()
-    add_fund_resp = swapper.rpc.add_fund_init(user, public_key, h)
-    txid = user.rpc.withdraw(add_fund_resp.address, 100_000)["txid"]
+    address, payment_request, _ = add_fund_init(user, swapper)
+    txid = user.rpc.withdraw(address, 100_000)["txid"]
     user.bitcoin.generate_block(1)
 
-    wait_for(
-        lambda: len(swapper.internal_rpc.get_swap(add_fund_resp.address).outputs) > 0
-    )
-
-    payment_request = user.rpc.invoice(
-        100_000_000,
-        "swap-success",
-        "swap-success",
-        preimage=hexlify(preimage).decode("ASCII"),
-    )["bolt11"]
+    wait_for(lambda: len(swapper.internal_rpc.get_swap(address).outputs) > 0)
 
     try:
         swapper.rpc.get_swap_payment(payment_request)

itest/tests/test_pay_after_deadline_fails.py

@@ -1,57 +1,19 @@
-from binascii import hexlify
-from bitcoin.wallet import CBitcoinSecret
-from pyln.testing.fixtures import (
-    bitcoind,
-    directory,
-    db_provider,
-    executor,
-    jsonschemas,
-    node_cls,
-    node_factory,
-    setup_logging,
-    teardown_checks,
-    test_base_dir,
-    test_name,
-)
-from pyln.testing.utils import wait_for
-from fixtures import whatthefee, swapd_factory, postgres_factory
+from helpers import *
 import grpc
-import hashlib
-import os
 
 
 def test_pay_after_deadline_fails(node_factory, swapd_factory):
     user = node_factory.get_node()
     swapper = swapd_factory.get_swapd()
-    swapper.lightning_node.openchannel(user, 1000000)
-    wait_for(
-        lambda: all(
-            channel["state"] == "CHANNELD_NORMAL"
-            for channel in swapper.lightning_node.rpc.listpeerchannels()["channels"]
-        )
-    )
-    user_node_id = user.info["id"]
-    secret_key = CBitcoinSecret.from_secret_bytes(os.urandom(32))
-    public_key = secret_key.pub
-    preimage = os.urandom(32)
-    h = hashlib.sha256(preimage).digest()
-    add_fund_resp = swapper.rpc.add_fund_init(user, public_key, h)
-    txid = user.bitcoin.rpc.sendtoaddress(add_fund_resp.address, 100_000 / 10**8)
+    address, payment_request, _ = add_fund_init(user, swapper)
+    user.bitcoin.rpc.sendtoaddress(address, 100_000 / 10**8)
     user.bitcoin.generate_block(1)
 
-    wait_for(
-        lambda: len(swapper.internal_rpc.get_swap(add_fund_resp.address).outputs) > 0
-    )
+    wait_for(lambda: len(swapper.internal_rpc.get_swap(address).outputs) > 0)
 
     height = user.bitcoin.rpc.getblockcount()
     user.bitcoin.generate_block(216)
     user.bitcoin.wait_for_log(r"UpdateTip: new best=.* height={}".format(height + 216))
-    payment_request = user.rpc.invoice(
-        100_000_000,
-        "swap-success",
-        "swap-success",
-        preimage=hexlify(preimage).decode("ASCII"),
-    )["bolt11"]
 
     try:
         swapper.rpc.get_swap_payment(payment_request)

itest/tests/test_pay_again_fails.py

@@ -1,61 +1,20 @@
-from binascii import hexlify
-from bitcoin.wallet import CBitcoinSecret
-from pyln.testing.fixtures import (
-    bitcoind,
-    directory,
-    db_provider,
-    executor,
-    jsonschemas,
-    node_cls,
-    node_factory,
-    setup_logging,
-    teardown_checks,
-    test_base_dir,
-    test_name,
-)
-from pyln.testing.utils import wait_for
-from fixtures import whatthefee, swapd_factory, postgres_factory
+from helpers import *
 import grpc
-import hashlib
-import os
 
 
 def test_pay_again_fails(node_factory, swapd_factory):
-    user = node_factory.get_node()
-    swapper = swapd_factory.get_swapd()
-    swapper.lightning_node.openchannel(user, 1000000)
-    wait_for(
-        lambda: all(
-            channel["state"] == "CHANNELD_NORMAL"
-            for channel in swapper.lightning_node.rpc.listpeerchannels()["channels"]
-        )
-    )
-    user_node_id = user.info["id"]
-    secret_key = CBitcoinSecret.from_secret_bytes(os.urandom(32))
-    public_key = secret_key.pub
-    preimage = os.urandom(32)
-    h = hashlib.sha256(preimage).digest()
-    add_fund_resp = swapper.rpc.add_fund_init(user, public_key, h)
-    txid = user.bitcoin.rpc.sendtoaddress(add_fund_resp.address, 100_000 / 10**8)
+    user, swapper = setup_user_and_swapper(node_factory, swapd_factory)
+    address, payment_request, h = add_fund_init(user, swapper)
+    user.bitcoin.rpc.sendtoaddress(address, 100_000 / 10**8)
     user.bitcoin.generate_block(1)
 
-    wait_for(
-        lambda: len(swapper.internal_rpc.get_swap(add_fund_resp.address).outputs) > 0
-    )
+    wait_for(lambda: len(swapper.internal_rpc.get_swap(address).outputs) > 0)
 
-    payment_request = user.rpc.invoice(
-        100_000_000,
-        "swap-success",
-        "swap-success",
-        preimage=hexlify(preimage).decode("ASCII"),
-    )["bolt11"]
     swapper.rpc.get_swap_payment(payment_request)
     wait_for(
-        lambda: user.rpc.listinvoices(payment_hash=hexlify(h).decode("ASCII"))[
-            "invoices"
-        ][0]["status"]
-        == "paid"
+        lambda: user.rpc.listinvoices(payment_hash=h)["invoices"][0]["status"] == "paid"
     )
+
     try:
         swapper.rpc.get_swap_payment(payment_request)
         assert False