feat(ui): add a Maildir overview under Help

Nothing in the UI reported database-level facts: every query gave a
thread count for that query, and nothing said how much mail there is
overall. A dialog under Help now shows messages, threads and tags from
notmuch, plus the account list from config, since notmuch does not model
accounts at all.

A separate worker call rather than a reuse of requestCounts, which counts
threads to match the row count of a query. This counts messages, which is
what a user means by "how much mail is in here". The test pins 4 messages
in 3 threads against the fixture and fails if they are ever made equal,
so routing both through one count cannot pass unnoticed.

Every field starts at -1 and renders as "unknown" when notmuch could not
answer it. Printing 0 would say the Maildir is empty, and telling someone
their mail is gone is the worst way to report an index that failed to
open.

The dialog opens showing "Counting..." rather than blocking, since
counting every message is not free on a large database. That makes two
lifetimes matter: the reply can arrive after the dialog is closed, so the
label is a QPointer, and the dialog can be closed and reopened while a
count runs, so a generation counter drops the older answer. The test
drains DeferredDelete before firing the late reply, because close()
deletes through deleteLater and without that the dangling case is never
actually reached.

1 files changed, 44 insertions, 0 deletions

diff --git a/tests/test_notmuchworker.cpp b/tests/test_notmuchworker.cpp
index be62ad3..b419915 100644
--- a/tests/test_notmuchworker.cpp
+++ b/tests/test_notmuchworker.cpp
@@ -60,6 +60,8 @@ private slots:
 
     void requestCountsAnswersOneCountPerQuery();
     void requestCountsKeepsPositionOnAnInvalidQuery();
+    void requestDatabaseStatsCountsMessagesNotThreads();
+    void requestDatabaseStatsOnUnreadableConfigEmitsError();
 
 private:
     /// Tags of one message, read back through a fresh worker query.
@@ -523,5 +525,47 @@ void TestNotmuchWorker::requestCountsKeepsPositionOnAnInvalidQuery()
     QCOMPARE(counts.at(2), 3);
 }
 
+void TestNotmuchWorker::requestDatabaseStatsCountsMessagesNotThreads()
+{
+    NotmuchWorker worker(m_fixture.configPath());
+    QSignalSpy spy(&worker, &NotmuchWorker::databaseStatsReady);
+
+    worker.requestDatabaseStats(11);
+
+    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.at(0).at(1).value<quint64>(), quint64(11));
+    const auto stats = spy.at(0).at(0).value<DatabaseStats>();
+
+    // The fixture holds four messages in three threads: thread A is a message
+    // and its reply. **That difference is the whole point of this call.**
+    // requestCounts() counts threads, to match the row count of a query; this
+    // one counts messages, which is what a user means by "how much mail". A
+    // reimplementation that reused the thread count would report 3 here and be
+    // confidently wrong under the label "messages".
+    QCOMPARE(stats.messages, 4);
+    QCOMPARE(stats.threads, 3);
+    QVERIFY2(stats.messages != stats.threads,
+             "messages and threads are equal, so this fixture cannot prove the "
+             "two counts are distinct: add a reply to it");
+
+    // Every tag the fixture creates, plus notmuch's own.
+    QVERIFY(stats.tags > 0);
+}
+
+void TestNotmuchWorker::requestDatabaseStatsOnUnreadableConfigEmitsError()
+{
+    // Fails closed like every other entry point. The dialog then shows its
+    // fields as unknown rather than as zero, since "no mail at all" is the
+    // wrong thing to tell someone whose index failed to open.
+    NotmuchWorker worker(QStringLiteral("/nonexistent/qtmaildir-test/config"));
+    QSignalSpy ready(&worker, &NotmuchWorker::databaseStatsReady);
+    QSignalSpy errors(&worker, &NotmuchWorker::errorOccurred);
+
+    worker.requestDatabaseStats(1);
+
+    QCOMPARE(errors.size(), 1);
+    QVERIFY(ready.isEmpty());
+}
+
 QTEST_MAIN(TestNotmuchWorker)
 #include "test_notmuchworker.moc"