v31.1-roots.1 · Commit 5: [PATCH 05/17] feat(net): preserve Roots peer controls and health view on v31

src/qt/test/apptests.cpp

Before: src/qt/test/apptests.cpp · After: src/qt/test/apptests.cpp

File metadata

index 752c877381031e47a453ae93f38126fe929da2a0..9ec8aa0a19d79762ef432f8476795808a0aed605 100644

Download original patch · Release notes

Diff rows 1–192 of 192. Line numbers refer to the original before/after files.

+ Added− RemovedUnmarked lines are context.

Scroll the code area horizontally to read long lines. Before is on the left; after is on the right. Unified view fits narrow screens more easily.

src/qt/test/apptests.cpp CHANGED Viewed

@@ -11,8 +11,23 @@
 #include <qt/bitcoingui.h>
 #include <qt/networkstyle.h>
 #include <qt/rpcconsole.h>
 #include <test/util/setup_common.h>
 #include <validation.h>
 #include <QAction>
 #include <QLineEdit>
@@ -49,6 +64,149 @@ void TestRpcCommand(RPCConsole* console)
     const QString pattern = QStringLiteral("\"chain\": \"(\\w+)\"");
     QCOMPARE(FindInConsole(output, pattern), QString("regtest"));
 }
 } // namespace
 //! Entry point for BitcoinApplication tests.
@@ -67,6 +225,12 @@ void AppTests::appTests()
 #endif
     qRegisterMetaType<interfaces::BlockAndHeaderTipInfo>("interfaces::BlockAndHeaderTipInfo");
     m_app.parameterSetup();
     QVERIFY(m_app.createOptionsModel(/*resetSettings=*/true));
     QScopedPointer<const NetworkStyle> style(NetworkStyle::instantiate(Params().GetChainType()));
@@ -99,6 +263,8 @@ void AppTests::consoleTests(RPCConsole* console)
 {
     HandleCallback callback{"consoleTests", *this};
     TestRpcCommand(console);
 }
 //! Destructor to shut down after the last expected callback completes.

 #include <qt/bitcoingui.h>
 #include <qt/networkstyle.h>
 #include <qt/rpcconsole.h>
+#include <qt/peertablemodel.h>
+#include <QLabel>
+#include <QTableView>
+#include <QSortFilterProxyModel>
 #include <test/util/setup_common.h>
 #include <validation.h>
+#include <interfaces/node.h>
+#include <univalue.h>
+#include <QDebug>
+#include <QDir>
+#include <QTabWidget>
+#include <QSplitter>
+#include <QScrollArea>
+#include <QScrollBar>
+#include <QItemSelectionModel>
+#include <future>
+#include <thread>
 #include <QAction>
 #include <QLineEdit>
     const QString pattern = QStringLiteral("\"chain\": \"(\\w+)\"");
     QCOMPARE(FindInConsole(output, pattern), QString("regtest"));
 }
+void TestPeerRefreshState(RPCConsole* console)
+{
+    auto* peer_widget = console->findChild<QTableView*>("peerWidget");
+    QVERIFY(peer_widget);
+    auto* peer_proxy = qobject_cast<QSortFilterProxyModel*>(peer_widget->model());
+    QVERIFY(peer_proxy);
+    auto* peer_model = qobject_cast<PeerTableModel*>(peer_proxy->sourceModel());
+    QVERIFY(peer_model);
+    QCOMPARE(peer_model->rowCount(), 0);
+    QSignalSpy data_changed_spy(peer_model, &QAbstractItemModel::dataChanged);
+    QVERIFY(data_changed_spy.isValid());
+    peer_model->refresh();
+    QCOMPARE(data_changed_spy.count(), 0);
+    const auto set_label = [console](const char* name) {
+        QLabel* label = console->findChild<QLabel*>(name);
+        if (label) label->setText(QStringLiteral("stale"));
+        return label;
+    };
+    QLabel* time_offset = set_label("timeoffset");
+    QLabel* services = set_label("peerServices");
+    QLabel* sync_height = set_label("peerSyncHeight");
+    QLabel* common_height = set_label("peerCommonHeight");
+    QLabel* starting_height = set_label("peerHeight");
+    QLabel* ping_wait = set_label("peerPingWait");
+    QLabel* addr_relay = set_label("peerAddrRelayEnabled");
+    QLabel* addr_processed = set_label("peerAddrProcessed");
+    QLabel* addr_rate_limited = set_label("peerAddrRateLimited");
+    QLabel* relay_txs = set_label("peerRelayTxes");
+    QVERIFY(time_offset);
+    QVERIFY(services);
+    QVERIFY(sync_height);
+    QVERIFY(common_height);
+    QVERIFY(starting_height);
+    QVERIFY(ping_wait);
+    QVERIFY(addr_relay);
+    QVERIFY(addr_processed);
+    QVERIFY(addr_rate_limited);
+    QVERIFY(relay_txs);
+    QVERIFY(QMetaObject::invokeMethod(console, "resetPeerStateStats"));
+    QCOMPARE(time_offset->text(), QStringLiteral("N/A"));
+    QCOMPARE(services->text(), QStringLiteral("N/A"));
+    QCOMPARE(sync_height->text(), QStringLiteral("Unknown"));
+    QCOMPARE(common_height->text(), QStringLiteral("Unknown"));
+    QCOMPARE(starting_height->text(), QStringLiteral("Unknown"));
+    QCOMPARE(ping_wait->text(), QStringLiteral("N/A"));
+    QCOMPARE(addr_relay->text(), QStringLiteral("N/A"));
+    QCOMPARE(addr_processed->text(), QStringLiteral("N/A"));
+    QCOMPARE(addr_rate_limited->text(), QStringLiteral("N/A"));
+    QCOMPARE(relay_txs->text(), QStringLiteral("N/A"));
+}
+// Optional runtime evidence profile. Peers are real regtest nodes supplied by
+// the caller; unavailable state is obtained through the production try-lock.
+void TestLivePeerView(RPCConsole* console, interfaces::Node& node)
+{
+    const auto endpoints{qEnvironmentVariable("ROOTS_PEER_ENDPOINTS").split(',', Qt::SkipEmptyParts)};
+    if (endpoints.isEmpty()) return;
+    QVERIFY(endpoints.size() >= 2);
+    auto* table = console->findChild<QTableView*>("peerWidget");
+    auto* tabs = console->findChild<QTabWidget*>("tabWidget");
+    QVERIFY(table && tabs);
+    auto* proxy = qobject_cast<QSortFilterProxyModel*>(table->model());
+    QVERIFY(proxy);
+    auto* model = qobject_cast<PeerTableModel*>(proxy->sourceModel());
+    QVERIFY(model);
+    model->stopAutoRefresh();
+    for (const auto& endpoint : endpoints) {
+        UniValue params{UniValue::VARR};
+        params.push_back(endpoint.toStdString());
+        params.push_back("onetry");
+        node.executeRpc("addnode", params, "");
+    }
+    QTRY_VERIFY_WITH_TIMEOUT((model->refresh(), model->rowCount() == endpoints.size()), 10000);
+    QTRY_VERIFY_WITH_TIMEOUT((model->refresh(), model->index(0, 0).data(PeerTableModel::StatsRole).value<CNodeCombinedStats*>()->nodeStats.nVersion > 0), 10000);
+    const auto size{qEnvironmentVariable("ROOTS_PEER_CAPTURE_SIZE", "1280x800").split('x')};
+    QCOMPARE(size.size(), 2);
+    console->resize(size[0].toInt(), size[1].toInt());
+    tabs->setCurrentIndex(3); // Native Peers tab.
+    console->show();
+    QTest::qWait(100);
+    QCOMPARE(console->size(), QSize(size[0].toInt(), size[1].toInt()));
+    qInfo() << "Live peer capture:" << console->size() << "font points" << table->font().pointSizeF() << "device pixel ratio" << console->devicePixelRatioF();
+    const auto capture_dir{qEnvironmentVariable("ROOTS_PEER_CAPTURE_DIR")};
+    const auto capture = [&](const QString& name) {
+        if (capture_dir.isEmpty()) return true;
+        return QDir().mkpath(capture_dir) && console->grab().save(capture_dir + '/' + name + ".png");
+    };
+    table->clearSelection();
+    QVERIFY(capture("table"));
+    table->selectRow(0);
+    const auto selected_id{table->selectionModel()->selectedRows().first().data().toLongLong()};
+    table->sortByColumn(PeerTableModel::Received, Qt::DescendingOrder);
+    model->refresh();
+    QCOMPARE(table->selectionModel()->selectedRows().size(), 1);
+    QCOMPARE(table->selectionModel()->selectedRows().first().data().toLongLong(), selected_id);
+    QVERIFY(console->findChild<QLabel*>("peerSubversion")->text() != QStringLiteral("N/A"));
+    // Exercise the native resizable splitter so unavailable values are legible
+    // at 150% font scale as well as in the full-width table capture.
+    console->findChild<QSplitter*>("splitter")->setSizes({console->width() / 2, console->width() / 2});
+    QTest::qWait(100); // Let the shown detail pane receive its layout geometry.
+    QVERIFY(console->findChild<QWidget*>("peersTabRightPanel")->isVisible());
+    QVERIFY(capture("detail"));
+    std::promise<void> locked, release;
+    auto released = release.get_future();
+    std::thread blocker{[&] {
+        LOCK(cs_main);
+        locked.set_value();
+        released.wait();
+    }};
+    locked.get_future().wait();
+    model->refresh();
+    const auto previous_row{table->selectionModel()->selectedRows().first().row()};
+    table->selectRow(previous_row == 0 ? 1 : 0);
+    const bool unavailable{!table->selectionModel()->selectedRows().first().data(PeerTableModel::StatsRole).value<CNodeCombinedStats*>()->fNodeStateStatsAvailable};
+    const bool cleared{console->findChild<QLabel*>("peerServices")->text() == QStringLiteral("N/A") &&
+        console->findChild<QLabel*>("peerSyncHeight")->text() == QStringLiteral("Unknown") &&
+        console->findChild<QLabel*>("peerHeight")->text() == QStringLiteral("Unknown") &&
+        console->findChild<QLabel*>("timeoffset")->text() == QStringLiteral("N/A")};
+    const bool captured{capture("unavailable")};
+    auto* scroll = console->findChild<QScrollArea*>("scrollArea");
+    scroll->verticalScrollBar()->setValue(scroll->verticalScrollBar()->maximum());
+    const bool captured_bottom{capture("unavailable-bottom")};
+    scroll->verticalScrollBar()->setValue(0);
+    release.set_value();
+    blocker.join();
+    QVERIFY(unavailable);
+    QVERIFY(cleared);
+    QVERIFY(captured);
+    QVERIFY(captured_bottom);
+    model->refresh();
+    QVERIFY(console->findChild<QLabel*>("peerServices")->text() != QStringLiteral("N/A"));
+    // Removing the selected peer must not leave its detail pane visible.
+    UniValue params{UniValue::VARR};
+    params.push_back("");
+    params.push_back(table->selectionModel()->selectedRows().first().data().toLongLong());
+    node.executeRpc("disconnectnode", params, "");
+    QTRY_VERIFY_WITH_TIMEOUT((model->refresh(), model->rowCount() == endpoints.size() - 1), 10000);
+    QVERIFY(table->selectionModel()->selectedRows().isEmpty());
+}
 } // namespace
 //! Entry point for BitcoinApplication tests.
 #endif
     qRegisterMetaType<interfaces::BlockAndHeaderTipInfo>("interfaces::BlockAndHeaderTipInfo");
+    const auto font_scale{qEnvironmentVariable("ROOTS_PEER_FONT_SCALE", "1.0").toDouble()};
+    if (font_scale != 1.0) {
+        auto font = m_app.font();
+        font.setPointSizeF(font.pointSizeF() * font_scale);
+        m_app.setFont(font);
+    }
     m_app.parameterSetup();
     QVERIFY(m_app.createOptionsModel(/*resetSettings=*/true));
     QScopedPointer<const NetworkStyle> style(NetworkStyle::instantiate(Params().GetChainType()));
 {
     HandleCallback callback{"consoleTests", *this};
     TestRpcCommand(console);
+    TestPeerRefreshState(console);
+    TestLivePeerView(console, m_app.node());
 }
 //! Destructor to shut down after the last expected callback completes.