test: add QML RBF controls e2e coverage (Issue #17)

Author: johnny9

doc/test-automation-selectors.md

@@ -24,6 +24,7 @@ It supports the parity backlog Definition of Done (`DefinitionOfDone.md`) requir
 - Receive flow: `receiveAmountInput`, `receiveLabelInput`, `receiveContactSelectButton`, `receiveContactsPopup`, `receiveContactsSearchInput`, `receiveContactRow`, `receiveContactSelectFirstActionButton`, `receiveContactUseButton`, `receiveCreateAddressButton`, `receiveCopySelectedUriButton`, `receiveQrImage`
 - Send flow: `sendAddressInput`, `sendOpenContactsButton`, `sendContactsPopup`, `sendContactsSearchInput`, `sendContactLabelInput`, `sendContactAddressInput`, `sendContactSaveButton`, `sendContactDeleteButton`, `sendContactUseButton`, `sendContinueButton`, `sendResultPopup`
 - Wallet tabs/pages: `walletSendPage`, `walletRequestPaymentPage`, `activityListView`, `activityOpenFirstRowActionButton`, `activityOpenRowAddressInput`, `activityOpenRowByAddressActionButton`, `activityDetailsPage`, `activityDetailsBackButton`
+- Activity RBF actions: `activityDetailsBumpButton`, `activityDetailsBumpPopup`, `activityDetailsBumpPreviewButton`, `activityDetailsBumpConfirmPopup`, `activityDetailsBumpConfirmButton`, `activityDetailsBumpDisabledReasonText`, `activityDetailsCancelButton`, `activityDetailsCancelPopup`, `activityDetailsCancelConfirmButton`, `activityDetailsRbfStatusText`, `activityDetailsReplacementTxidText`
 - Onboarding storage flow: `onboardingStorageAmountDetailedSettingsButton`, `storageSettingsPruneTargetInput`, `storageLocationDefaultOption`
 - RPC console flow: `aboutDeveloperOptionsItem`, `developerRpcConsoleItem`, `rpcConsoleInput`, `rpcConsoleSubmitButton`, `rpcConsoleOutputText`
 - Mempool diagnostics flow: `developerMempoolDiagnosticsItem`, `mempoolDiagnosticsRefreshButton`, `mempoolDiagnosticsTxCountValue`, `mempoolDiagnosticsDynamicUsageValue`, `mempoolDiagnosticsMaxUsageValue`

test/functional/qml_test_rbf_controls.py

@@ -0,0 +1,344 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""End-to-end QML test for activity RBF speed-up/cancel controls.
+
+Runs three isolated scenarios to avoid page-stack/test-object ambiguity:
+1. Eligible speed-up flow with replacement txid/status verification.
+2. Cancel/abandon flow verification for an abandon-eligible transaction.
+3. Ineligible non-RBF transaction disables speed-up with explanatory reason.
+"""
+
+import argparse
+import sys
+from decimal import Decimal
+from pathlib import Path
+from urllib.parse import quote
+
+from qml_test_harness import QmlTestHarness, StepScreenshotRecorder
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+BITCOIN_FUNCTIONAL_PATH = REPO_ROOT / "bitcoin" / "test" / "functional"
+if str(BITCOIN_FUNCTIONAL_PATH) not in sys.path:
+    sys.path.insert(0, str(BITCOIN_FUNCTIONAL_PATH))
+
+from test_framework.authproxy import AuthServiceProxy, JSONRPCException
+from test_framework.util import wait_until_helper_internal
+
+
+WALLET_NAME = "qml_rbf_wallet"
+RECEIVER_WALLET_NAME = "qml_rbf_receiver"
+INITIAL_BLOCKS = 130
+
+
+class ScenarioContext:
+    def __init__(self, harness, gui, shots, rpc, wallet_rpc, receiver_wallet_rpc):
+        self.harness = harness
+        self.gui = gui
+        self.shots = shots
+        self.rpc = rpc
+        self.wallet_rpc = wallet_rpc
+        self.receiver_wallet_rpc = receiver_wallet_rpc
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="QML E2E RBF speed-up/cancel controls test")
+    parser.add_argument(
+        "--socket-path",
+        help="Attach to an existing bridge socket. Not supported by this test.",
+    )
+    parser.add_argument(
+        "--screenshot-dir",
+        help="If set, save step screenshots (PNG) into this directory.",
+    )
+    return parser.parse_args()
+
+
+def build_rpc_url(user, password, port, wallet_name=None):
+    auth = f"{quote(user, safe='')}:{quote(password, safe='')}"
+    base = f"http://{auth}@127.0.0.1:{port}"
+    if wallet_name is None:
+        return base
+    return f"{base}/wallet/{quote(wallet_name, safe='')}"
+
+
+def read_cookie(datadir):
+    cookie_path = Path(datadir) / "regtest" / ".cookie"
+    wait_until_helper_internal(lambda: cookie_path.is_file(), timeout=60)
+    cookie = cookie_path.read_text(encoding="utf8").strip()
+    user, password = cookie.split(":", 1)
+    return user, password
+
+
+def connect_rpc(datadir, rpc_port):
+    user, password = read_cookie(datadir)
+    rpc = AuthServiceProxy(build_rpc_url(user, password, rpc_port), timeout=120)
+
+    def rpc_ready():
+        try:
+            return rpc.getblockchaininfo()["chain"] == "regtest"
+        except Exception:
+            return False
+
+    wait_until_helper_internal(rpc_ready, timeout=60)
+
+    wallet_rpc = AuthServiceProxy(
+        build_rpc_url(user, password, rpc_port, WALLET_NAME), timeout=120
+    )
+    receiver_wallet_rpc = AuthServiceProxy(
+        build_rpc_url(user, password, rpc_port, RECEIVER_WALLET_NAME), timeout=120
+    )
+    return rpc, wallet_rpc, receiver_wallet_rpc
+
+
+def ensure_wallet_loaded(rpc, wallet_name):
+    try:
+        rpc.createwallet(wallet_name)
+        return
+    except JSONRPCException as e:
+        if "already exists" not in str(e).lower():
+            raise
+    try:
+        rpc.loadwallet(wallet_name)
+    except JSONRPCException as e:
+        if "already loaded" not in str(e).lower():
+            raise
+
+
+def wait_for_gui_wallet_ready(gui):
+    gui.wait_for_property("walletBadge", "loading", timeout_ms=30000, value=False)
+    gui.wait_for_property("walletBadge", "noWalletLoaded", timeout_ms=30000, value=False)
+    gui.wait_for_property("walletBadge", "text", timeout_ms=30000, contains=WALLET_NAME)
+
+
+def select_wallet_tab(gui, tab_object_name, expected_page):
+    gui.click(tab_object_name)
+    gui.wait_for_page(expected_page, timeout_ms=15000)
+
+
+def setup_scenario(args, tag):
+    harness = QmlTestHarness(
+        skip_onboard=True,
+        # -walletbroadcast=0 keeps unconfirmed wallet txs local, enabling
+        # deterministic abandon coverage in a one-node harness.
+        extra_args=["-fallbackfee=0.00001000", "-walletbroadcast=0"],
+    )
+    harness.start()
+
+    gui = harness.driver
+    shots = StepScreenshotRecorder(gui, args.screenshot_dir)
+    rpc, wallet_rpc, receiver_wallet_rpc = connect_rpc(harness.datadir, harness.rpc_port)
+
+    ensure_wallet_loaded(rpc, RECEIVER_WALLET_NAME)
+    ensure_wallet_loaded(rpc, WALLET_NAME)
+    wait_for_gui_wallet_ready(gui)
+
+    funding_addr = wallet_rpc.getnewaddress(f"qml-rbf-{tag}-fund", "bech32")
+    rpc.generatetoaddress(INITIAL_BLOCKS, funding_addr)
+
+    return ScenarioContext(harness, gui, shots, rpc, wallet_rpc, receiver_wallet_rpc)
+
+
+def teardown_scenario(ctx):
+    ctx.harness.stop()
+
+
+def list_send_txids(wallet_rpc):
+    return {
+        tx["txid"]
+        for tx in wallet_rpc.listtransactions("*", 5000, 0, True)
+        if tx.get("txid") and tx.get("category") == "send"
+    }
+
+
+def wait_for_new_send_txid(wallet_rpc, known_send_txids):
+    observed = {"txid": None}
+
+    def find_new_send_txid():
+        for tx in wallet_rpc.listtransactions("*", 5000, 0, True):
+            txid = tx.get("txid")
+            if not txid or txid in known_send_txids:
+                continue
+            if tx.get("category") == "send":
+                observed["txid"] = txid
+                return True
+        return False
+
+    wait_until_helper_internal(find_new_send_txid, timeout=30)
+    if observed["txid"] is None:
+        raise AssertionError("Did not observe new send transaction")
+
+    known_send_txids.add(observed["txid"])
+    return observed["txid"]
+
+
+def send_via_qml(gui, wallet_rpc, known_send_txids, address, amount_btc, note):
+    select_wallet_tab(gui, "walletSendTab", "walletSendPage")
+    gui.set_text("sendAddressInput", address)
+    gui.set_text("sendAmountInput", str(amount_btc))
+    gui.set_text("sendNoteInput", note)
+    gui.wait_for_property("sendContinueButton", "enabled", timeout_ms=15000, value=True)
+
+    gui.click("sendContinueButton")
+    gui.wait_for_page("walletSendReviewPage", timeout_ms=15000)
+    gui.click("sendConfirmButton")
+    gui.wait_for_page("sendResultPopup", timeout_ms=15000)
+    gui.click("sendResultCloseButton")
+
+    return wait_for_new_send_txid(wallet_rpc, known_send_txids)
+
+
+def open_activity_details_for_txid(gui, expected_txid):
+    select_wallet_tab(gui, "walletActivityTab", "activityListView")
+
+    def open_and_match():
+        gui.click("activityOpenFirstRowActionButton")
+        gui.wait_for_page("activityDetailsPage", timeout_ms=10000)
+        opened_txid = gui.get_property("activityDetailsPage", "txid")
+        if opened_txid == expected_txid:
+            return True
+        gui.click("activityDetailsBackButton")
+        gui.wait_for_page("activityListView", timeout_ms=10000)
+        return False
+
+    wait_until_helper_internal(open_and_match, timeout=30)
+
+
+def transaction_is_abandoned(tx_info):
+    if tx_info.get("abandoned") is True:
+        return True
+    for detail in tx_info.get("details", []):
+        if detail.get("abandoned") is True:
+            return True
+    return False
+
+
+def run_bump_scenario(args):
+    ctx = setup_scenario(args, "bump")
+    try:
+        gui = ctx.gui
+        wallet_rpc = ctx.wallet_rpc
+        receiver_wallet_rpc = ctx.receiver_wallet_rpc
+
+        known_send_txids = list_send_txids(wallet_rpc)
+        destination = receiver_wallet_rpc.getnewaddress("qml-rbf-bump", "bech32")
+        original_txid = send_via_qml(
+            gui,
+            wallet_rpc,
+            known_send_txids,
+            destination,
+            Decimal("0.00300000"),
+            "qml-rbf-bump",
+        )
+
+        open_activity_details_for_txid(gui, original_txid)
+        gui.wait_for_property("activityDetailsBumpButton", "enabled", timeout_ms=10000, value=True)
+
+        gui.click("activityDetailsBumpButton")
+        gui.wait_for_property("activityDetailsBumpPopup", "opened", timeout_ms=10000, value=True)
+        gui.click("activityDetailsBumpPreviewButton")
+        gui.wait_for_property("activityDetailsBumpConfirmPopup", "opened", timeout_ms=10000, value=True)
+        gui.click("activityDetailsBumpConfirmButton")
+
+        replacement_txid = gui.wait_for_property(
+            "activityDetailsReplacementTxidText", "text", timeout_ms=15000, non_empty=True
+        )
+        status_text = gui.wait_for_property(
+            "activityDetailsRbfStatusText", "text", timeout_ms=15000, non_empty=True
+        )
+
+        assert replacement_txid != original_txid
+        assert "replacement" in status_text.lower(), status_text
+
+        replacement_tx = wallet_rpc.gettransaction(replacement_txid)
+        assert replacement_tx.get("txid") == replacement_txid
+
+        gui.wait_for_property("activityDetailsBumpButton", "enabled", timeout_ms=10000, value=False)
+        second_bump_reason = gui.wait_for_property(
+            "activityDetailsBumpDisabledReasonText", "text", timeout_ms=10000, non_empty=True
+        )
+        assert len(second_bump_reason.strip()) > 0
+
+        original_tx = wallet_rpc.gettransaction(original_txid)
+        if "replaced_by_txid" in original_tx:
+            assert original_tx["replaced_by_txid"] == replacement_txid
+        else:
+            conflicts = original_tx.get("walletconflicts", [])
+            assert replacement_txid in conflicts, "Original tx missing replacement linkage"
+
+        ctx.shots.capture("rbf_bump_success")
+        return original_txid, replacement_txid
+    finally:
+        teardown_scenario(ctx)
+
+
+def run_cancel_scenario(args):
+    ctx = setup_scenario(args, "cancel")
+    try:
+        gui = ctx.gui
+        wallet_rpc = ctx.wallet_rpc
+        receiver_wallet_rpc = ctx.receiver_wallet_rpc
+
+        cancel_destination = receiver_wallet_rpc.getnewaddress("qml-rbf-cancel", "bech32")
+        cancel_txid = wallet_rpc.sendtoaddress(
+            cancel_destination,
+            Decimal("0.00250000"),
+            "qml-rbf-cancel",
+        )
+
+        wait_until_helper_internal(
+            lambda: any(
+                tx.get("txid") == cancel_txid
+                for tx in wallet_rpc.listtransactions("*", 5000, 0, True)
+            ),
+            timeout=30,
+        )
+
+        open_activity_details_for_txid(gui, cancel_txid)
+        gui.wait_for_property("activityDetailsCancelButton", "enabled", timeout_ms=10000, value=True)
+
+        gui.click("activityDetailsCancelButton")
+        gui.wait_for_property("activityDetailsCancelPopup", "opened", timeout_ms=10000, value=True)
+        gui.click("activityDetailsCancelConfirmButton")
+
+        cancel_status = gui.wait_for_property(
+            "activityDetailsRbfStatusText", "text", timeout_ms=15000, non_empty=True
+        )
+        assert "canceled" in cancel_status.lower(), cancel_status
+
+        canceled_tx = wallet_rpc.gettransaction(cancel_txid)
+        assert transaction_is_abandoned(canceled_tx), "Canceled tx is not marked abandoned"
+
+        ctx.shots.capture("rbf_cancel_success")
+        return cancel_txid
+    finally:
+        teardown_scenario(ctx)
+
+def run_tests():
+    args = parse_args()
+    if args.socket_path:
+        raise AssertionError(
+            "--socket-path is not supported for this test; it requires harness-managed RPC/datadir."
+        )
+
+    original_txid, replacement_txid = run_bump_scenario(args)
+    cancel_txid = run_cancel_scenario(args)
+
+    print("\n" + "=" * 60)
+    print("QML RBF speed-up/cancel E2E PASSED")
+    print(f"Original txid: {original_txid}")
+    print(f"Replacement txid: {replacement_txid}")
+    print(f"Canceled txid: {cancel_txid}")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    try:
+        run_tests()
+    except Exception as e:
+        print(f"\nFAILED: {e}", file=sys.stderr)
+        import traceback
+
+        traceback.print_exc()
+        sys.exit(1)