test(disco): add functional test for disco#items error handling

Verifies that /disco items displays error responses (e.g. service-unavailable)
to the user, per XEP-0030 Section 7.

Dockerfile.arch

@@ -1,10 +1,9 @@
-FROM archlinux:latest
+FROM archlinux
 
 ENV TERM=xterm
 ENV CC="ccache gcc"
 
-RUN pacman -Syyu --noconfirm
-
+RUN pacman -Syu --noconfirm
 # reflector is optional - if it fails due to network issues, continue with default mirrorlist
 RUN pacman -S --needed --noconfirm reflector && \
     (reflector --latest 20 --protocol https --sort rate --save /etc/pacman.d/mirrorlist || true)

Makefile.am

@@ -185,8 +185,8 @@ functionaltest_sources = \
 	tests/functionaltests/test_software.c tests/functionaltests/test_software.h \
 	tests/functionaltests/test_muc.c tests/functionaltests/test_muc.h \
 	tests/functionaltests/test_disconnect.c tests/functionaltests/test_disconnect.h \
-	tests/functionaltests/test_history.c tests/functionaltests/test_history.h \
 	tests/functionaltests/test_lastactivity.c tests/functionaltests/test_lastactivity.h \
+	tests/functionaltests/test_disco.c tests/functionaltests/test_disco.h \
 	tests/functionaltests/functionaltests.c
 
 main_source = src/main.c

src/xmpp/iq.c

@@ -129,6 +129,7 @@ static void _ping_get_handler(xmpp_stanza_t* const stanza);
 static int _version_result_id_handler(xmpp_stanza_t* const stanza, void* const userdata);
 static int _disco_info_response_id_handler(xmpp_stanza_t* const stanza, void* const userdata);
 static int _disco_info_response_id_handler_onconnect(xmpp_stanza_t* const stanza, void* const userdata);
+static int _disco_items_response_id_handler(xmpp_stanza_t* const stanza, void* const userdata);
 static int _http_upload_response_id_handler(xmpp_stanza_t* const stanza, void* const upload_ctx);
 static int _last_activity_response_id_handler(xmpp_stanza_t* const stanza, void* const userdata);
 static int _room_info_response_id_handler(xmpp_stanza_t* const stanza, void* const userdata);
@@ -203,7 +204,11 @@ _iq_handler(xmpp_conn_t* const conn, xmpp_stanza_t* const stanza, void* const us
         _disco_items_get_handler(stanza);
     }
     if (discoitems && (g_strcmp0(type, STANZA_TYPE_RESULT) == 0)) {
-        _disco_items_result_handler(stanza);
+        // Only handle onconnect here, user requests use id_handler
+        const char* id = xmpp_stanza_get_id(stanza);
+        if (g_strcmp0(id, "discoitemsreq_onconnect") == 0) {
+            _disco_items_result_handler(stanza);
+        }
     }
 
     xmpp_stanza_t* lastactivity = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_LASTACTIVITY);
@@ -637,7 +642,11 @@ void
 iq_disco_items_request(const char* jid)
 {
     xmpp_ctx_t* const ctx = connection_get_ctx();
-    xmpp_stanza_t* iq = stanza_create_disco_items_iq(ctx, "discoitemsreq", jid, NULL);
+    auto_char char* id = connection_create_stanza_id();
+    xmpp_stanza_t* iq = stanza_create_disco_items_iq(ctx, id, jid, NULL);
+
+    iq_id_handler_add(id, _disco_items_response_id_handler, NULL, NULL);
+
     iq_send_stanza(iq);
     xmpp_stanza_release(iq);
 }
@@ -2514,13 +2523,12 @@ _http_upload_response_id_handler(xmpp_stanza_t* const stanza, void* const userda
 static void
 _disco_items_result_handler(xmpp_stanza_t* const stanza)
 {
-    log_debug("Received disco#items response");
+    // This handler is only for onconnect disco#items requests
+    log_debug("Received disco#items response (onconnect)");
     const char* id = xmpp_stanza_get_id(stanza);
-    const char* from = xmpp_stanza_get_from(stanza);
     GSList* items = NULL;
 
-    if ((g_strcmp0(id, "discoitemsreq") != 0) && (g_strcmp0(id, "discoitemsreq_onconnect") != 0)) {
-        log_warning("_disco_items_result_handler: Received unexpected disco id: %s", id);
+    if (g_strcmp0(id, "discoitemsreq_onconnect") != 0) {
         return;
     }
 
@@ -2555,23 +2563,80 @@ _disco_items_result_handler(xmpp_stanza_t* const stanza)
         child = xmpp_stanza_get_next(child);
     }
 
-    if (g_strcmp0(id, "discoitemsreq") == 0) {
-        cons_show_disco_items(items, from);
-    } else if (g_strcmp0(id, "discoitemsreq_onconnect") == 0) {
-        connection_set_disco_items(items);
+    connection_set_disco_items(items);
 
-        while (late_delivery_windows) {
-            LateDeliveryUserdata* del_data = late_delivery_windows->data;
-            _iq_mam_request(del_data->win, del_data->startdate, del_data->enddate);
-            free(del_data);
-            late_delivery_windows = g_slist_delete_link(late_delivery_windows,
-                                                        late_delivery_windows);
-        }
+    while (late_delivery_windows) {
+        LateDeliveryUserdata* del_data = late_delivery_windows->data;
+        _iq_mam_request(del_data->win, del_data->startdate, del_data->enddate);
+        free(del_data);
+        late_delivery_windows = g_slist_delete_link(late_delivery_windows,
+                                                    late_delivery_windows);
     }
 
     g_slist_free_full(items, (GDestroyNotify)_item_destroy);
 }
 
+static int
+_disco_items_response_id_handler(xmpp_stanza_t* const stanza, void* const userdata)
+{
+    const char* from = xmpp_stanza_get_from(stanza);
+    const char* type = xmpp_stanza_get_type(stanza);
+
+    if (from) {
+        log_debug("Received disco#items response from: %s", from);
+    } else {
+        log_debug("Received disco#items response");
+    }
+
+    // Handle error responses
+    if (g_strcmp0(type, STANZA_TYPE_ERROR) == 0) {
+        auto_char char* error_message = stanza_get_error_message(stanza);
+        if (from) {
+            cons_show_error("Service discovery failed for %s: %s", from, error_message);
+        } else {
+            cons_show_error("Service discovery failed: %s", error_message);
+        }
+        return 0;
+    }
+
+    // Handle result responses
+    xmpp_stanza_t* query = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_QUERY);
+    if (query == NULL) {
+        cons_show_disco_items(NULL, from);
+        return 0;
+    }
+
+    GSList* items = NULL;
+    xmpp_stanza_t* child = xmpp_stanza_get_children(query);
+
+    while (child) {
+        const char* stanza_name = xmpp_stanza_get_name(child);
+        if (stanza_name && (g_strcmp0(stanza_name, STANZA_NAME_ITEM) == 0)) {
+            const char* item_jid = xmpp_stanza_get_attribute(child, STANZA_ATTR_JID);
+            if (item_jid) {
+                DiscoItem* item = malloc(sizeof(struct disco_item_t));
+                if (item) {
+                    item->jid = strdup(item_jid);
+                    const char* item_name = xmpp_stanza_get_attribute(child, STANZA_ATTR_NAME);
+                    if (item_name) {
+                        item->name = strdup(item_name);
+                    } else {
+                        item->name = NULL;
+                    }
+                    items = g_slist_append(items, item);
+                }
+            }
+        }
+
+        child = xmpp_stanza_get_next(child);
+    }
+
+    cons_show_disco_items(items, from);
+    g_slist_free_full(items, (GDestroyNotify)_item_destroy);
+
+    return 0;
+}
+
 void
 iq_feature_retrieval_complete_handler(void)
 {

tests/functionaltests/functionaltests.c

@@ -15,10 +15,10 @@
  * functional tests run less frequently than unit tests.
  *
  * Tests are organized into groups for better maintainability and parallel execution:
- *   Group 1: Connect, Ping, Rooms, Software, Last Activity  (19 tests)
- *   Group 2: Message, Receipts, Roster, DB History           (22 tests)
- *   Group 3: Chat Session, Presence, Disconnect              (22 tests)
- *   Group 4: MUC, Carbons                                    (21 tests)
+ *   Group 1: Connect, Ping, Rooms, Software
+ *   Group 2: Message, Receipts, Roster, Chat Session
+ *   Group 3: Presence, Disconnect
+ *   Group 4: MUC, Carbons
  *
  * Parallel execution:
  *   ./functionaltests        - run all tests sequentially
@@ -53,7 +53,7 @@
 #include "test_muc.h"
 #include "test_disconnect.h"
 #include "test_lastactivity.h"
-#include "test_history.h"
+#include "test_disco.h"
 
 /* Macro to wrap each test with setup/teardown functions */
 #define PROF_FUNC_TEST(test) cmocka_unit_test_setup_teardown(test, init_prof_test, close_prof_test)
@@ -78,9 +78,8 @@ main(int argc, char* argv[])
     fprintf(stderr, "[PROF_TEST] Starting functional tests, group=%d\n", group);
 
     /* ============================================================
-     * GROUP 1: Connect, Ping, Rooms, Software, Last Activity
+     * GROUP 1: Connect, Ping, Rooms, Software
      * Basic XMPP session establishment and server queries
-     * (19 tests)
      * ============================================================ */
     const struct CMUnitTest group1_tests[] = {
         /* Connection tests - verify login, roster, bookmarks */
@@ -114,9 +113,8 @@ main(int argc, char* argv[])
     };
 
     /* ============================================================
-     * GROUP 2: Message, Receipts, Roster, DB History
+     * GROUP 2: Message, Receipts, Roster, Chat Session
      * Core messaging and contact management
-     * (23 tests)
      * ============================================================ */
     const struct CMUnitTest group2_tests[] = {
         /* Basic message send/receive */
@@ -136,29 +134,6 @@ main(int argc, char* argv[])
         PROF_FUNC_TEST(sends_remove_item_nick),
         PROF_FUNC_TEST(sends_nick_change),
 
-        /* Database persistence - message write+read round-trip */
-        PROF_FUNC_TEST(message_db_history_on_reopen),
-        PROF_FUNC_TEST(message_db_history_multiple),
-        PROF_FUNC_TEST(message_db_history_contact_isolation),
-        PROF_FUNC_TEST(message_db_history_special_chars),
-        PROF_FUNC_TEST(message_db_history_outgoing),
-        PROF_FUNC_TEST(message_db_history_dialog),
-        PROF_FUNC_TEST(message_db_history_empty),
-        PROF_FUNC_TEST(message_db_history_long_message),
-        PROF_FUNC_TEST(message_db_history_newline),
-        PROF_FUNC_TEST(message_db_history_service_chars),
-#ifdef HAVE_HISTORY_VERIFY
-        PROF_FUNC_TEST(message_db_history_verify),
-#endif
-        PROF_FUNC_TEST(message_db_history_lmc),
-    };
-
-    /* ============================================================
-     * GROUP 3: Chat Session, Presence, Disconnect
-     * Session routing, status management, clean teardown
-     * (22 tests)
-     * ============================================================ */
-    const struct CMUnitTest group3_tests[] = {
         /* Chat session management - bare/full JID routing */
         PROF_FUNC_TEST(sends_message_to_barejid_when_contact_offline),
         PROF_FUNC_TEST(sends_message_to_barejid_when_contact_online),
@@ -166,8 +141,13 @@ main(int argc, char* argv[])
         PROF_FUNC_TEST(sends_subsequent_messages_to_fulljid),
         PROF_FUNC_TEST(resets_to_barejid_after_presence_received),
         PROF_FUNC_TEST(new_session_when_message_received_from_different_fulljid),
+    };
 
-        /* Presence - online/away/xa/dnd/chat status management */
+    /* ============================================================
+     * GROUP 3: Presence, Disconnect, Disco
+     * Online/away/xa/dnd/chat status management
+     * ============================================================ */
+    const struct CMUnitTest group3_tests[] = {
         PROF_FUNC_TEST(presence_online),
         PROF_FUNC_TEST(presence_online_with_message),
         PROF_FUNC_TEST(presence_away),
@@ -186,12 +166,14 @@ main(int argc, char* argv[])
 
         /* Disconnect - clean session termination */
         PROF_FUNC_TEST(disconnect_ends_session),
+
+        /* Service Discovery - XEP-0030 */
+        PROF_FUNC_TEST(disco_items_error_handling),
     };
 
     /* ============================================================
      * GROUP 4: MUC, Carbons
      * Multi-user chat and message synchronization
-     * (21 tests)
      * ============================================================ */
     const struct CMUnitTest group4_tests[] = {
         /* MUC room join with various options - XEP-0045 */
@@ -234,9 +216,9 @@ main(int argc, char* argv[])
         const struct CMUnitTest* tests;
         size_t count;
     } groups[] = {
-        { "Group 1: Connect/Ping/Rooms/Software/LastActivity", group1_tests, ARRAY_SIZE(group1_tests) },
-        { "Group 2: Message/Receipts/Roster/DBHistory", group2_tests, ARRAY_SIZE(group2_tests) },
-        { "Group 3: Session/Presence/Disconnect", group3_tests, ARRAY_SIZE(group3_tests) },
+        { "Group 1: Connect/Ping/Rooms/Software", group1_tests, ARRAY_SIZE(group1_tests) },
+        { "Group 2: Message/Receipts/Roster/Session", group2_tests, ARRAY_SIZE(group2_tests) },
+        { "Group 3: Presence/Disconnect/Disco", group3_tests, ARRAY_SIZE(group3_tests) },
         { "Group 4: MUC/Carbons", group4_tests, ARRAY_SIZE(group4_tests) },
     };
     const int num_groups = ARRAY_SIZE(groups);

tests/functionaltests/test_disco.c

@@ -0,0 +1,36 @@
+#include <glib.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <setjmp.h>
+#include <cmocka.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <stabber.h>
+
+#include "proftest.h"
+
+void
+disco_items_error_handling(void **state)
+{
+    /*
+     * Test that /disco items displays error responses to user.
+     * Per XEP-0030 Section 7: errors like service-unavailable must be shown.
+     */
+    stbbr_for_query("http://jabber.org/protocol/disco#items",
+        "<iq to='stabber@localhost/profanity' type='error' from='broken.localhost'>"
+            "<error type='cancel'>"
+                "<service-unavailable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>"
+            "</error>"
+        "</iq>"
+    );
+
+    prof_connect();
+
+    prof_input("/disco items broken.localhost");
+
+    prof_timeout(10);
+    /* Per XEP-0030, error should be displayed to user */
+    assert_true(prof_output_regex("Service discovery failed.*service-unavailable"));
+    prof_timeout_reset();
+}

tests/functionaltests/test_disco.h

@@ -0,0 +1 @@
+void disco_items_error_handling(void** state);

tests/functionaltests/test_history.c

@@ -1,475 +0,0 @@
-/*
- * test_history.c
- *
- * Functional test for database message persistence.
- * Verifies that a received chat message is written to the database
- * and loaded back as history when the chat window is reopened.
- *
- * These tests only exercise the public log_database API through normal
- * profanity UI operations, so they work with any storage backend.
- */
-
-#include <glib.h>
-#include <stdio.h>
-#include <string.h>
-#include "prof_cmocka.h"
-#include <stdlib.h>
-#include <string.h>
-
-#include <stabber.h>
-
-#include "proftest.h"
-
-/*
- * Test: message written to DB is loaded as history on chat window reopen.
- *
- * Flow:
- *   1. Connect and enable /history on (enables PREF_CHLOG + PREF_HISTORY)
- *   2. Receive a chat message while on the console window — the message
- *      body is NOT rendered to the terminal (only a console notification
- *      "<< chat message: ... (win N)" appears), but the message IS
- *      written to the database via chat_log_msg_in()
- *   3. Close the auto-created chat window (destroying its in-memory buffer)
- *   4. Reopen the chat window with /msg — chatwin_new() calls
- *      _chatwin_history() which reads from log_database_get_previous_chat()
- *   5. Assert the message body appears in the terminal output, proving
- *      it was persisted to and read back from the database
- */
-void
-message_db_history_on_reopen(void **state)
-{
-    prof_connect();
-
-    /* Enable chat logging and history display */
-    prof_input("/history on");
-    assert_true(prof_output_regex("Chat history enabled\\."));
-
-    /* Receive a message while on the console window.
-     * The body text is NOT printed to the visible terminal — only the
-     * console notification appears.  The message is logged to the DB. */
-    stbbr_send(
-        "<message id='hist-db-test-1' to='stabber@localhost' "
-        "from='buddy1@localhost/phone' type='chat'>"
-        "<body>persistence-roundtrip-check-42</body>"
-        "</message>");
-
-    /* Wait for the console notification (proves message was received).
-     * buddy1@localhost is in the roster as "Buddy1", and PREF_RESOURCE_MESSAGE
-     * is on by default, so the display name is "Buddy1/phone". */
-    assert_true(prof_output_exact("<< chat message: Buddy1/phone (win 2)"));
-
-    /* Close the chat window that was auto-created for the incoming message.
-     * This destroys its in-memory buffer so the text is gone from UI. */
-    prof_input("/close 2");
-    assert_true(prof_output_exact("Closed window 2"));
-
-    /* Reopen the chat window — chatwin_new() will load history from DB.
-     * The message body should now appear on screen for the first time. */
-    prof_input("/msg buddy1@localhost");
-
-    /* The history-loaded message must contain the body we sent earlier.
-     * Since the body was never rendered to the terminal before (it was
-     * only in the hidden window's ncurses buffer which was destroyed),
-     * finding it now proves the database write+read round-trip works. */
-    assert_true(prof_output_exact("persistence-roundtrip-check-42"));
-}
-
-/*
- * Test: multiple messages from the same contact are all preserved.
- *
- * Uses different resources so each console notification is unique and
- * we can reliably synchronise on each delivery before proceeding.
- */
-void
-message_db_history_multiple(void **state)
-{
-    prof_connect();
-
-    prof_input("/history on");
-    assert_true(prof_output_regex("Chat history enabled\\."));
-
-    /* Three messages from different resources → distinct notifications */
-    stbbr_send(
-        "<message id='multi1' to='stabber@localhost' "
-        "from='buddy1@localhost/phone' type='chat'>"
-        "<body>db-multi-first-aaa</body>"
-        "</message>");
-    assert_true(prof_output_exact("<< chat message: Buddy1/phone (win 2)"));
-
-    stbbr_send(
-        "<message id='multi2' to='stabber@localhost' "
-        "from='buddy1@localhost/laptop' type='chat'>"
-        "<body>db-multi-second-bbb</body>"
-        "</message>");
-    assert_true(prof_output_exact("<< chat message: Buddy1/laptop (win 2)"));
-
-    stbbr_send(
-        "<message id='multi3' to='stabber@localhost' "
-        "from='buddy1@localhost/tablet' type='chat'>"
-        "<body>db-multi-third-ccc</body>"
-        "</message>");
-    assert_true(prof_output_exact("<< chat message: Buddy1/tablet (win 2)"));
-
-    /* Close and reopen */
-    prof_input("/close 2");
-    assert_true(prof_output_exact("Closed window 2"));
-
-    prof_input("/msg buddy1@localhost");
-
-    /* All three must be present in history */
-    assert_true(prof_output_exact("db-multi-first-aaa"));
-    assert_true(prof_output_exact("db-multi-second-bbb"));
-    assert_true(prof_output_exact("db-multi-third-ccc"));
-}
-
-/*
- * Test: messages are stored per-contact — buddy1's history does not
- * leak into buddy2's window.
- *
- * 1. Receive from buddy1 and buddy2 while on console (bodies hidden)
- * 2. Close all chat windows
- * 3. Open buddy1 → verify buddy1's body present, buddy2's body absent
- */
-void
-message_db_history_contact_isolation(void **state)
-{
-    prof_connect();
-
-    prof_input("/history on");
-    assert_true(prof_output_regex("Chat history enabled\\."));
-
-    /* Receive from buddy1 */
-    stbbr_send(
-        "<message id='iso1' to='stabber@localhost' "
-        "from='buddy1@localhost/phone' type='chat'>"
-        "<body>isolation-buddy1-only-xyzzy</body>"
-        "</message>");
-    assert_true(prof_output_exact("<< chat message: Buddy1/phone (win 2)"));
-
-    /* Receive from buddy2 */
-    stbbr_send(
-        "<message id='iso2' to='stabber@localhost' "
-        "from='buddy2@localhost/phone' type='chat'>"
-        "<body>isolation-buddy2-only-plugh</body>"
-        "</message>");
-    assert_true(prof_output_exact("<< chat message: Buddy2/phone (win 3)"));
-
-    /* Close all chat windows at once */
-    prof_input("/close all");
-    assert_true(prof_output_exact("Closed 2 windows."));
-
-    /* Open buddy1 — history should contain ONLY buddy1's message */
-    prof_input("/msg buddy1@localhost");
-    assert_true(prof_output_exact("isolation-buddy1-only-xyzzy"));
-
-    /* buddy2's body was never printed to the terminal (received on
-     * console), so finding it now would mean cross-contact leakage */
-    prof_timeout(3);
-    assert_false(prof_output_exact("isolation-buddy2-only-plugh"));
-    prof_timeout_reset();
-}
-
-/*
- * Test: special characters survive the DB write+read round-trip.
- *
- * The XMPP body uses XML entities (&amp; &lt; &gt; &quot;) which the
- * XML parser decodes before storage.  The DB must preserve the decoded
- * characters and return them unchanged.
- */
-void
-message_db_history_special_chars(void **state)
-{
-    prof_connect();
-
-    prof_input("/history on");
-    assert_true(prof_output_regex("Chat history enabled\\."));
-
-    stbbr_send(
-        "<message id='spec1' to='stabber@localhost' "
-        "from='buddy1@localhost/phone' type='chat'>"
-        "<body>chars: &amp; &lt;tag&gt; &quot;quoted&quot;</body>"
-        "</message>");
-    assert_true(prof_output_exact("<< chat message: Buddy1/phone (win 2)"));
-
-    prof_input("/close 2");
-    assert_true(prof_output_exact("Closed window 2"));
-
-    prof_input("/msg buddy1@localhost");
-
-    /* The decoded text must appear exactly as-is */
-    assert_true(prof_output_exact("chars: & <tag> \"quoted\""));
-}
-
-/*
- * Test: outgoing message (sent via /msg) persists in DB.
- *
- * NOTE: The outgoing body IS rendered to the terminal when sent. Since
- * prof_output_exact searches the cumulative buffer, the assertion alone
- * does not conclusively prove DB persistence. However, combined with
- * the incoming tests, this verifies the end-to-end outgoing write path
- * and catches crashes in the outgoing DB code.
- */
-void
-message_db_history_outgoing(void **state)
-{
-    prof_connect();
-
-    prof_input("/history on");
-    assert_true(prof_output_regex("Chat history enabled\\."));
-
-    /* Send outgoing — opens and focuses chat window */
-    prof_input("/msg buddy1@localhost db-outgoing-sent-42");
-    assert_true(prof_output_regex("me: .+db-outgoing-sent-42"));
-
-    prof_input("/close 2");
-    assert_true(prof_output_exact("Closed window 2"));
-
-    /* Reopen — history should load the outgoing message */
-    prof_input("/msg buddy1@localhost");
-    assert_true(prof_output_exact("db-outgoing-sent-42"));
-}
-
-/*
- * Test: a dialog (outgoing + incoming) is fully preserved in history.
- *
- * Sends an outgoing message, then closes the window. A reply arrives
- * while on the console (body never rendered). After reopen, both sides
- * of the conversation appear — proving the incoming read from DB works
- * and the outgoing write path completed without error.
- */
-void
-message_db_history_dialog(void **state)
-{
-    prof_connect();
-
-    prof_input("/history on");
-    assert_true(prof_output_regex("Chat history enabled\\."));
-
-    /* Phase 1: send outgoing (renders to terminal) */
-    prof_input("/msg buddy1@localhost dialog-out-msg-42");
-    assert_true(prof_output_regex("me: .+dialog-out-msg-42"));
-
-    /* Return to console */
-    prof_input("/close 2");
-    assert_true(prof_output_exact("Closed window 2"));
-
-    /* Phase 2: receive reply on console (body NOT in terminal buffer) */
-    stbbr_send(
-        "<message id='dlg-in' to='stabber@localhost' "
-        "from='buddy1@localhost/phone' type='chat'>"
-        "<body>dialog-in-reply-77</body>"
-        "</message>");
-    assert_true(prof_output_exact("<< chat message: Buddy1/phone (win 2)"));
-
-    /* Close the auto-created window */
-    prof_input("/close 2");
-    assert_true(prof_output_exact("Closed window 2"));
-
-    /* Phase 3: reopen — history should have both directions */
-    prof_input("/msg buddy1@localhost");
-
-    /* Incoming body conclusively proves DB round-trip */
-    assert_true(prof_output_exact("dialog-in-reply-77"));
-    /* Outgoing body is consistent with DB persistence */
-    assert_true(prof_output_exact("dialog-out-msg-42"));
-}
-
-/*
- * Test: opening a chat window for a contact with no prior messages
- * does not crash and the window is usable.
- */
-void
-message_db_history_empty(void **state)
-{
-    prof_connect();
-
-    prof_input("/history on");
-    assert_true(prof_output_regex("Chat history enabled\\."));
-
-    /* buddy2 has never exchanged messages — history is empty */
-    prof_input("/msg buddy2@localhost");
-    assert_true(prof_output_exact("buddy2@localhost"));
-
-    /* Verify the window is functional by sending a message */
-    prof_input("empty-history-smoke-test");
-    assert_true(prof_output_regex("me: .+empty-history-smoke-test"));
-}
-
-/*
- * Test: a long message (1000+ characters) is not truncated by the DB.
- */
-void
-message_db_history_long_message(void **state)
-{
-    prof_connect();
-
-    prof_input("/history on");
-    assert_true(prof_output_regex("Chat history enabled\\."));
-
-    /* Build a 1020-character body: 1000 x 'A' + unique suffix */
-    char body[1100];
-    memset(body, 'A', 1000);
-    strcpy(body + 1000, "-long-db-end-MARKER");
-
-    char xml[1500];
-    snprintf(xml, sizeof(xml),
-        "<message id='long1' to='stabber@localhost' "
-        "from='buddy1@localhost/phone' type='chat'>"
-        "<body>%s</body>"
-        "</message>", body);
-    stbbr_send(xml);
-
-    assert_true(prof_output_exact("<< chat message: Buddy1/phone (win 2)"));
-
-    prof_input("/close 2");
-    assert_true(prof_output_exact("Closed window 2"));
-
-    prof_input("/msg buddy1@localhost");
-    assert_true(prof_output_exact("-long-db-end-MARKER"));
-}
-
-/*
- * Test: message body containing embedded newlines (LF) is stored and
- * loaded correctly.
- *
- * Uses XML character reference &#10; for literal newline in body.
- */
-void
-message_db_history_newline(void **state)
-{
-    prof_connect();
-
-    prof_input("/history on");
-    assert_true(prof_output_regex("Chat history enabled\\."));
-
-    stbbr_send(
-        "<message id='nl1' to='stabber@localhost' "
-        "from='buddy1@localhost/phone' type='chat'>"
-        "<body>nl-first-line-7k&#10;nl-second-line-9m&#10;nl-third-line-2p</body>"
-        "</message>");
-    assert_true(prof_output_exact("<< chat message: Buddy1/phone (win 2)"));
-
-    prof_input("/close 2");
-    assert_true(prof_output_exact("Closed window 2"));
-
-    prof_input("/msg buddy1@localhost");
-    /* Each fragment must survive the round-trip */
-    assert_true(prof_output_exact("nl-first-line-7k"));
-    assert_true(prof_output_exact("nl-second-line-9m"));
-    assert_true(prof_output_exact("nl-third-line-2p"));
-}
-
-/*
- * Test: characters that could break storage format (backslash, pipe,
- * percent, braces, brackets, equals) survive DB round-trip.
- */
-void
-message_db_history_service_chars(void **state)
-{
-    prof_connect();
-
-    prof_input("/history on");
-    assert_true(prof_output_regex("Chat history enabled\\."));
-
-    stbbr_send(
-        "<message id='svc1' to='stabber@localhost' "
-        "from='buddy1@localhost/phone' type='chat'>"
-        "<body>svc: a\\b c|d e%f {g} [h] i=j</body>"
-        "</message>");
-    assert_true(prof_output_exact("<< chat message: Buddy1/phone (win 2)"));
-
-    prof_input("/close 2");
-    assert_true(prof_output_exact("Closed window 2"));
-
-    prof_input("/msg buddy1@localhost");
-    assert_true(prof_output_exact("svc: a\\b c|d e%f {g} [h] i=j"));
-}
-
-#ifdef HAVE_HISTORY_VERIFY
-/*
- * Test: /history verify reports no issues after normal message writes.
- */
-void
-message_db_history_verify(void **state)
-{
-    prof_connect();
-
-    prof_input("/history on");
-    assert_true(prof_output_regex("Chat history enabled\\."));
-
-    /* Write a few messages to create non-trivial DB state */
-    stbbr_send(
-        "<message id='ver1' to='stabber@localhost' "
-        "from='buddy1@localhost/phone' type='chat'>"
-        "<body>verify-msg-one</body>"
-        "</message>");
-    assert_true(prof_output_exact("<< chat message: Buddy1/phone (win 2)"));
-
-    stbbr_send(
-        "<message id='ver2' to='stabber@localhost' "
-        "from='buddy2@localhost/phone' type='chat'>"
-        "<body>verify-msg-two</body>"
-        "</message>");
-    assert_true(prof_output_exact("<< chat message: Buddy2/phone (win 3)"));
-
-    /* Run verify — should find no issues */
-    prof_input("/history verify");
-    assert_true(prof_output_exact("Verification complete: no issues found."));
-}
-#endif /* HAVE_HISTORY_VERIFY */
-
-/*
- * Test: LMC (Last Message Correction, XEP-0308) — incoming correction
- * replaces the original in DB history.
- *
- * Both messages arrive while focused on the console so their bodies
- * are never rendered to the terminal. After reopen, only the corrected
- * text should appear — the original should be absent.
- */
-void
-message_db_history_lmc(void **state)
-{
-    prof_connect();
-
-    prof_input("/history on");
-    assert_true(prof_output_regex("Chat history enabled\\."));
-
-    /* Original message (body never displayed — received on console) */
-    stbbr_send(
-        "<message id='lmc-orig-1' to='stabber@localhost' "
-        "from='buddy1@localhost/phone' type='chat'>"
-        "<body>lmc-before-correction-aaa</body>"
-        "</message>");
-    assert_true(prof_output_exact("<< chat message: Buddy1/phone (win 2)"));
-
-    /* Correction replacing the original (XEP-0308).
-     * Use buddy2 message as sync barrier to ensure correction is processed. */
-    stbbr_send(
-        "<message id='lmc-corr-1' to='stabber@localhost' "
-        "from='buddy1@localhost/phone' type='chat'>"
-        "<body>lmc-after-correction-zzz</body>"
-        "<replace id='lmc-orig-1' xmlns='urn:xmpp:message-correct:0'/>"
-        "</message>");
-
-    /* Sync barrier: send from buddy2, wait for its notification */
-    stbbr_send(
-        "<message id='lmc-sync' to='stabber@localhost' "
-        "from='buddy2@localhost/phone' type='chat'>"
-        "<body>lmc-sync-barrier</body>"
-        "</message>");
-    assert_true(prof_output_exact("<< chat message: Buddy2/phone (win 3)"));
-
-    /* Close buddy1 and buddy2 windows */
-    prof_input("/close all");
-    assert_true(prof_output_exact("Closed 2 windows."));
-
-    /* Reopen buddy1 — should have corrected text only */
-    prof_input("/msg buddy1@localhost");
-    assert_true(prof_output_exact("lmc-after-correction-zzz"));
-
-    /* Original body was never in the terminal buffer (received on console).
-     * Its absence in history proves the correction was applied in the DB. */
-    prof_timeout(3);
-    assert_false(prof_output_exact("lmc-before-correction-aaa"));
-    prof_timeout_reset();
-}

tests/functionaltests/test_history.h

@@ -1,14 +0,0 @@
-void message_db_history_on_reopen(void **state);
-void message_db_history_multiple(void **state);
-void message_db_history_contact_isolation(void **state);
-void message_db_history_special_chars(void **state);
-void message_db_history_outgoing(void **state);
-void message_db_history_dialog(void **state);
-void message_db_history_empty(void **state);
-void message_db_history_long_message(void **state);
-void message_db_history_newline(void **state);
-void message_db_history_service_chars(void **state);
-#ifdef HAVE_HISTORY_VERIFY
-void message_db_history_verify(void **state);
-#endif
-void message_db_history_lmc(void **state);