jabber.developer2
b63a9d29f8
All checks were successful
CI Code / Check spelling (pull_request) Successful in 15s
CI Code / Check coding style (pull_request) Successful in 26s
CI Code / Linux (debian) (pull_request) Successful in 5m3s
CI Code / Linux (arch) (pull_request) Successful in 6m25s
CI Code / Linux (ubuntu) (pull_request) Successful in 8m1s
CI Code / Code Coverage (pull_request) Successful in 9m27s
T03 — keep secrets out of profanity.log: - new redact_secrets() helper (common.c) masks the content of SASL auth/response/challenge/success and <password> elements; applied in the libstrophe logger (_xmpp_file_logger) and the stderr-to-log bridge (REQ-DAR-03, REQ-LOG-06) - _add_to_db() no longer logs decrypted message bodies or the full INSERT statement (REQ-DAR-03) T07 — owner-only permissions on key material and history (REQ-AUTH-01): - chmod 0600 on chatlog.db after open (journal/WAL files inherit) - chmod 0600 on OTR keys.txt and fingerprints.txt after every write - parent dirs are already 0700 (create_dir); this is defense in depth T08 — integrity before trust: - PRAGMA quick_check(1) gates every chatlog.db open; on failure the DB stays closed, the user is warned once in the console and the session continues without history (REQ-RES-02) - OMEMO aesgcm downloads decrypt into a 0600 tempfile next to the target and rename it into place only after the GCM tag verifies; the open-command hook no longer runs on failed decryption (REQ-CRY-06) Tests: redact_secrets unit tests; AES-256-GCM roundtrip and tampered-tag/ciphertext unit tests (crypto.c now linked into unittests under BUILD_OMEMO); functional test planting a corrupt chatlog.db and asserting graceful degradation. Closes #146
577 lines
20 KiB
C
577 lines
20 KiB
C
/*
|
|
* 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 (& < > ") 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: & <tag> "quoted"</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 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 nl-second-line-9m 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"));
|
|
}
|
|
|
|
/*
|
|
* 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."));
|
|
}
|
|
|
|
/*
|
|
* 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();
|
|
}
|
|
|
|
/*
|
|
* Test: messages from the SAME bare JID but with DIFFERENT resources are
|
|
* stored together in one contact's history AND remain distinguishable on
|
|
* reopen — the resource part of the sender JID must be preserved per row,
|
|
* not collapsed.
|
|
*
|
|
* Flow:
|
|
* 1. /history on
|
|
* 2. buddy1@localhost/phone sends msg A
|
|
* 3. buddy1@localhost/laptop sends msg B
|
|
* 4. buddy1@localhost/tablet sends msg C
|
|
* 5. Close the auto-opened chat window so its in-memory buffer is gone.
|
|
* 6. /msg buddy1@localhost — chatwin_new() rehydrates from DB.
|
|
* 7. All three bodies must reappear, AND the resource markers
|
|
* "/phone", "/laptop", "/tablet" must each be visible on at least one
|
|
* history line (PREF_RESOURCE_MESSAGE is on by default in the test
|
|
* profile, so the renderer prefixes each line with "Buddy1/<res>").
|
|
*/
|
|
void
|
|
message_db_history_multi_resource(void** state)
|
|
{
|
|
prof_connect();
|
|
|
|
prof_input("/history on");
|
|
assert_true(prof_output_regex("Chat history enabled\\."));
|
|
|
|
stbbr_send(
|
|
"<message id='res-multi-A' to='stabber@localhost' "
|
|
"from='buddy1@localhost/phone' type='chat'>"
|
|
"<body>multi-resource-A-from-phone</body>"
|
|
"</message>");
|
|
assert_true(prof_output_exact("<< chat message: Buddy1/phone (win 2)"));
|
|
|
|
stbbr_send(
|
|
"<message id='res-multi-B' to='stabber@localhost' "
|
|
"from='buddy1@localhost/laptop' type='chat'>"
|
|
"<body>multi-resource-B-from-laptop</body>"
|
|
"</message>");
|
|
assert_true(prof_output_exact("<< chat message: Buddy1/laptop (win 2)"));
|
|
|
|
stbbr_send(
|
|
"<message id='res-multi-C' to='stabber@localhost' "
|
|
"from='buddy1@localhost/tablet' type='chat'>"
|
|
"<body>multi-resource-C-from-tablet</body>"
|
|
"</message>");
|
|
assert_true(prof_output_exact("<< chat message: Buddy1/tablet (win 2)"));
|
|
|
|
prof_input("/close 2");
|
|
assert_true(prof_output_exact("Closed window 2"));
|
|
|
|
prof_input("/msg buddy1@localhost");
|
|
|
|
/* All three bodies must be present in history (single-contact aggregation) */
|
|
assert_true(prof_output_exact("multi-resource-A-from-phone"));
|
|
assert_true(prof_output_exact("multi-resource-B-from-laptop"));
|
|
assert_true(prof_output_exact("multi-resource-C-from-tablet"));
|
|
|
|
/* Each resource must remain identifiable on rehydrate — proves we don't
|
|
* lose per-row resource info when loading the same JID's chat back. */
|
|
assert_true(prof_output_regex("Buddy1/phone"));
|
|
assert_true(prof_output_regex("Buddy1/laptop"));
|
|
assert_true(prof_output_regex("Buddy1/tablet"));
|
|
}
|
|
|
|
/*
|
|
* Test: corrupt chatlog.db degrades gracefully (issue #146, REQ-RES-02).
|
|
*
|
|
* A chatlog.db with a valid SQLite magic but garbage content is planted
|
|
* before connecting. Database init must fail cleanly: the user gets a
|
|
* console warning, the session stays up, and the client stays responsive.
|
|
*/
|
|
void
|
|
message_db_corrupt_database_degrades_gracefully(void** state)
|
|
{
|
|
const char* xdg_data = getenv("XDG_DATA_HOME");
|
|
assert_non_null(xdg_data);
|
|
|
|
GString* db_file = g_string_new(xdg_data);
|
|
g_string_append(db_file, "/profanity/database/stabber_at_localhost");
|
|
assert_int_equal(0, g_mkdir_with_parents(db_file->str, 0700));
|
|
g_string_append(db_file, "/chatlog.db");
|
|
|
|
/* valid 16-byte SQLite header magic followed by garbage: sqlite3_open
|
|
* succeeds (lazy open), the integrity gate must catch it */
|
|
FILE* db = fopen(db_file->str, "wb");
|
|
assert_non_null(db);
|
|
assert_int_equal(16, fwrite("SQLite format 3", 1, 16, db));
|
|
for (int i = 0; i < 4096; i++) {
|
|
fputc(0xA5, db);
|
|
}
|
|
fclose(db);
|
|
g_string_free(db_file, TRUE);
|
|
|
|
prof_connect();
|
|
|
|
assert_true(prof_output_exact("Chat history storage is unavailable for this session"));
|
|
|
|
/* client is still alive and responsive after the failed DB init */
|
|
prof_input("/autoping set 60");
|
|
assert_true(prof_output_exact("Autoping interval set to 60 seconds."));
|
|
}
|