cproof/tests/unittests/test_database_export.c

/*
 * test_database_export.c
 *
 * Unit tests for the flatfile write→parse round-trip, escape/unescape helpers,
 * jid_to_dir path construction, and parser edge cases — these are the core
 * functions exercised by database_export.c during export and import.
 *
 * Copyright (C) 2026 Profanity Contributors
 * License: GPL-3.0-or-later (same as Profanity)
 */

#include "prof_cmocka.h"

#include <glib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "config.h"
#include "database_flatfile.h"

/* ================================================================
 * Helper: write a single line to a temporary file, then read and
 * parse it back.  Returns the parsed result; caller must free with
 * ff_parsed_line_free().  The temp file is removed automatically.
 * ================================================================ */
static ff_parsed_line_t*
_roundtrip(const char* timestamp, const char* type, const char* enc,
           const char* stanza_id, const char* archive_id, const char* replace_id,
           const char* from_jid, const char* from_resource, const char* message)
{
    char tmppath[] = "/tmp/proftest_rt_XXXXXX";
    int fd = mkstemp(tmppath);
    assert_true(fd >= 0);

    FILE* fp = fdopen(fd, "w");
    assert_non_null(fp);

    ff_write_line(fp, timestamp, type, enc,
                  stanza_id, archive_id, replace_id,
                  from_jid, from_resource, message);
    fclose(fp);

    /* Read & parse */
    fp = fopen(tmppath, "r");
    assert_non_null(fp);

    gboolean truncated = FALSE;
    char* buf = ff_readline(fp, &truncated);
    fclose(fp);
    unlink(tmppath);

    assert_non_null(buf);
    assert_false(truncated);

    ff_parsed_line_t* pl = ff_parse_line(buf);
    free(buf);

    return pl;
}

/* ================================================================
 * Write → parse round-trip tests
 * ================================================================ */

void
test_ff_roundtrip_simple_chat(void** state)
{
    ff_parsed_line_t* pl = _roundtrip(
        "2025-06-15T12:30:00+00:00", "chat", "none",
        NULL, NULL, NULL,
        "alice@example.com", NULL, "Hello, world!");

    assert_non_null(pl);
    assert_string_equal(pl->timestamp_str, "2025-06-15T12:30:00+00:00");
    assert_string_equal(pl->type, "chat");
    assert_string_equal(pl->enc, "none");
    assert_string_equal(pl->from_jid, "alice@example.com");
    assert_null(pl->stanza_id);
    assert_null(pl->archive_id);
    assert_null(pl->replace_id);
    assert_string_equal(pl->message, "Hello, world!");
    ff_parsed_line_free(pl);
}

void
test_ff_roundtrip_with_all_metadata(void** state)
{
    ff_parsed_line_t* pl = _roundtrip(
        "2025-06-15T12:30:00+00:00", "chat", "omemo",
        "sid-abc-123", "aid-xyz-789", "corrects-old-id",
        "bob@example.com", "phone", "Encrypted message.");

    assert_non_null(pl);
    assert_string_equal(pl->stanza_id, "sid-abc-123");
    assert_string_equal(pl->archive_id, "aid-xyz-789");
    assert_string_equal(pl->replace_id, "corrects-old-id");
    assert_string_equal(pl->enc, "omemo");
    assert_string_equal(pl->from_jid, "bob@example.com");
    assert_string_equal(pl->from_resource, "phone");
    assert_string_equal(pl->message, "Encrypted message.");
    ff_parsed_line_free(pl);
}

void
test_ff_roundtrip_with_resource(void** state)
{
    ff_parsed_line_t* pl = _roundtrip(
        "2025-01-01T00:00:00Z", "chat", "none",
        NULL, NULL, NULL,
        "user@jabber.org", "Profanity.abc123", "hi");

    assert_non_null(pl);
    assert_string_equal(pl->from_jid, "user@jabber.org");
    assert_string_equal(pl->from_resource, "Profanity.abc123");
    assert_string_equal(pl->message, "hi");
    ff_parsed_line_free(pl);
}

void
test_ff_roundtrip_newline_in_body(void** state)
{
    ff_parsed_line_t* pl = _roundtrip(
        "2025-03-01T10:00:00Z", "chat", "none",
        NULL, NULL, NULL,
        "alice@x.com", NULL, "line1\nline2\nline3");

    assert_non_null(pl);
    assert_string_equal(pl->message, "line1\nline2\nline3");
    ff_parsed_line_free(pl);
}

void
test_ff_roundtrip_pipe_in_stanza_id(void** state)
{
    /* pipes in stanza_id must be escaped in metadata */
    ff_parsed_line_t* pl = _roundtrip(
        "2025-03-01T10:00:00Z", "chat", "none",
        "id|with|pipes", "aid|also|has|pipes", NULL,
        "a@b.com", NULL, "test");

    assert_non_null(pl);
    assert_string_equal(pl->stanza_id, "id|with|pipes");
    assert_string_equal(pl->archive_id, "aid|also|has|pipes");
    ff_parsed_line_free(pl);
}

void
test_ff_roundtrip_backslash_in_body(void** state)
{
    ff_parsed_line_t* pl = _roundtrip(
        "2025-03-01T10:00:00Z", "chat", "none",
        NULL, NULL, NULL,
        "a@b.com", NULL, "path\\to\\file C:\\Users\\test");

    assert_non_null(pl);
    assert_string_equal(pl->message, "path\\to\\file C:\\Users\\test");
    ff_parsed_line_free(pl);
}

void
test_ff_roundtrip_unicode_body(void** state)
{
    ff_parsed_line_t* pl = _roundtrip(
        "2025-03-01T10:00:00Z", "chat", "none",
        NULL, NULL, NULL,
        "a@b.com", NULL, "Привет мир 🌍 日本語テスト");

    assert_non_null(pl);
    assert_string_equal(pl->message, "Привет мир 🌍 日本語テスト");
    ff_parsed_line_free(pl);
}

void
test_ff_roundtrip_empty_body(void** state)
{
    ff_parsed_line_t* pl = _roundtrip(
        "2025-03-01T10:00:00Z", "chat", "none",
        NULL, NULL, NULL,
        "a@b.com", NULL, "");

    assert_non_null(pl);
    assert_string_equal(pl->message, "");
    ff_parsed_line_free(pl);
}

void
test_ff_roundtrip_colonspace_in_resource(void** state)
{
    /* ": " in resource must be escaped during write and unescaped on parse */
    ff_parsed_line_t* pl = _roundtrip(
        "2025-03-01T10:00:00Z", "chat", "none",
        NULL, NULL, NULL,
        "a@b.com", "res: with: colons", "msg");

    assert_non_null(pl);
    assert_string_equal(pl->from_jid, "a@b.com");
    assert_string_equal(pl->from_resource, "res: with: colons");
    assert_string_equal(pl->message, "msg");
    ff_parsed_line_free(pl);
}

void
test_ff_roundtrip_muc_type(void** state)
{
    ff_parsed_line_t* pl = _roundtrip(
        "2025-03-01T10:00:00Z", "muc", "none",
        NULL, NULL, NULL,
        "room@conference.x.com", "nick", "hello room");

    assert_non_null(pl);
    assert_string_equal(pl->type, "muc");
    assert_string_equal(pl->from_jid, "room@conference.x.com");
    assert_string_equal(pl->from_resource, "nick");
    ff_parsed_line_free(pl);
}

void
test_ff_roundtrip_omemo_enc(void** state)
{
    ff_parsed_line_t* pl = _roundtrip(
        "2025-03-01T10:00:00Z", "chat", "omemo",
        "sid-1", NULL, NULL,
        "a@b.com", NULL, "secret");

    assert_non_null(pl);
    assert_string_equal(pl->enc, "omemo");
    ff_parsed_line_free(pl);
}

void
test_ff_roundtrip_replace_id(void** state)
{
    /* LMC (Last Message Correction): corrects: field round-trip */
    ff_parsed_line_t* pl = _roundtrip(
        "2025-03-01T10:00:00Z", "chat", "none",
        "new-id", NULL, "old-id-to-correct",
        "a@b.com", NULL, "corrected text");

    assert_non_null(pl);
    assert_string_equal(pl->stanza_id, "new-id");
    assert_string_equal(pl->replace_id, "old-id-to-correct");
    assert_string_equal(pl->message, "corrected text");
    ff_parsed_line_free(pl);
}

/* ================================================================
 * Escape / unescape symmetry tests
 * ================================================================ */

void
test_ff_escape_unescape_message_identity(void** state)
{
    const char* inputs[] = {
        "simple text",
        "has\\backslash",
        "has\nnewline",
        "has\rcarriage return",
        "all\\together\nnow\r!",
        "already escaped \\n \\r \\\\",
        "",
    };

    for (size_t i = 0; i < sizeof(inputs) / sizeof(inputs[0]); i++) {
        char* escaped = ff_escape_message(inputs[i]);
        assert_non_null(escaped);
        /* escaped must not contain raw newlines */
        assert_null(strchr(escaped, '\n'));
        assert_null(strchr(escaped, '\r'));

        char* unescaped = ff_unescape_message(escaped);
        assert_string_equal(unescaped, inputs[i]);

        g_free(escaped);
        g_free(unescaped);
    }
}

void
test_ff_escape_unescape_meta_identity(void** state)
{
    const char* inputs[] = {
        "simple-id",
        "has|pipe",
        "has]bracket",
        "has\\backslash",
        "has\nnewline",
        "all|to]ge\\th\ner",
    };

    for (size_t i = 0; i < sizeof(inputs) / sizeof(inputs[0]); i++) {
        char* escaped = ff_escape_meta_value(inputs[i]);
        assert_non_null(escaped);

        char* unescaped = ff_unescape_meta_value(escaped);
        assert_string_equal(unescaped, inputs[i]);

        g_free(escaped);
        g_free(unescaped);
    }
}

void
test_ff_escape_meta_null_returns_null(void** state)
{
    assert_null(ff_escape_meta_value(NULL));
    assert_null(ff_escape_meta_value(""));
    assert_null(ff_unescape_meta_value(NULL));
}

void
test_ff_escape_message_null_returns_empty(void** state)
{
    char* result = ff_escape_message(NULL);
    assert_non_null(result);
    assert_string_equal(result, "");
    g_free(result);

    result = ff_unescape_message(NULL);
    assert_non_null(result);
    assert_string_equal(result, "");
    g_free(result);
}

/* ================================================================
 * jid_to_dir tests
 * ================================================================ */

void
test_ff_jid_to_dir_simple(void** state)
{
    char* dir = ff_jid_to_dir("alice");
    assert_non_null(dir);
    assert_string_equal(dir, "alice");
    g_free(dir);
}

void
test_ff_jid_to_dir_with_at(void** state)
{
    char* dir = ff_jid_to_dir("alice@example.com");
    assert_non_null(dir);
    assert_string_equal(dir, "alice_at_example.com");
    g_free(dir);
}

void
test_ff_jid_to_dir_path_traversal_rejected(void** state)
{
    /* Slashes and '..' must be sanitized */
    char* dir = ff_jid_to_dir("../../etc/passwd");
    assert_non_null(dir);
    /* No slashes or '..' sequences should remain */
    assert_null(strchr(dir, '/'));
    assert_null(strstr(dir, ".."));
    g_free(dir);
}

void
test_ff_jid_to_dir_null(void** state)
{
    assert_null(ff_jid_to_dir(NULL));
    assert_null(ff_jid_to_dir(""));
}

/* ================================================================
 * Parser edge-case tests
 * ================================================================ */

void
test_ff_parse_line_empty(void** state)
{
    assert_null(ff_parse_line(NULL));
    assert_null(ff_parse_line(""));
}

void
test_ff_parse_line_comment(void** state)
{
    assert_null(ff_parse_line("# this is a comment"));
    assert_null(ff_parse_line("# profanity chat log — UTF-8, LF line endings"));
}

void
test_ff_parse_line_legacy_format(void** state)
{
    /* Legacy chatlog.c format: {timestamp} - {sender}: {message} */
    ff_parsed_line_t* pl = ff_parse_line(
        "2025-06-15T12:30:00+00:00 - alice@example.com: Hello legacy");

    assert_non_null(pl);
    assert_string_equal(pl->timestamp_str, "2025-06-15T12:30:00+00:00");
    assert_string_equal(pl->from_jid, "alice@example.com");
    assert_string_equal(pl->message, "Hello legacy");
    assert_string_equal(pl->type, "chat");
    assert_string_equal(pl->enc, "none");
    ff_parsed_line_free(pl);
}

void
test_ff_parse_line_no_metadata(void** state)
{
    /* Simple format without [] brackets */
    ff_parsed_line_t* pl = ff_parse_line(
        "2025-06-15T12:30:00Z alice@example.com: Simple message");

    assert_non_null(pl);
    assert_string_equal(pl->from_jid, "alice@example.com");
    assert_string_equal(pl->message, "Simple message");
    ff_parsed_line_free(pl);
}

void
test_ff_parse_line_invalid_timestamp(void** state)
{
    /* Invalid timestamp should cause parse failure */
    ff_parsed_line_t* pl = ff_parse_line(
        "not-a-timestamp [chat|none] a@b.com: msg");

    assert_null(pl);
}

/* ================================================================
 * Type / enc conversion round-trip
 * ================================================================ */

void
test_ff_type_str_roundtrip(void** state)
{
    assert_int_equal(PROF_MSG_TYPE_CHAT, ff_get_message_type_type(ff_get_message_type_str(PROF_MSG_TYPE_CHAT)));
    assert_int_equal(PROF_MSG_TYPE_MUC, ff_get_message_type_type(ff_get_message_type_str(PROF_MSG_TYPE_MUC)));
    assert_int_equal(PROF_MSG_TYPE_MUCPM, ff_get_message_type_type(ff_get_message_type_str(PROF_MSG_TYPE_MUCPM)));
}

void
test_ff_enc_str_roundtrip(void** state)
{
    assert_int_equal(PROF_MSG_ENC_NONE, ff_get_message_enc_type(ff_get_message_enc_str(PROF_MSG_ENC_NONE)));
    assert_int_equal(PROF_MSG_ENC_OTR, ff_get_message_enc_type(ff_get_message_enc_str(PROF_MSG_ENC_OTR)));
    assert_int_equal(PROF_MSG_ENC_PGP, ff_get_message_enc_type(ff_get_message_enc_str(PROF_MSG_ENC_PGP)));
    assert_int_equal(PROF_MSG_ENC_OX, ff_get_message_enc_type(ff_get_message_enc_str(PROF_MSG_ENC_OX)));
    assert_int_equal(PROF_MSG_ENC_OMEMO, ff_get_message_enc_type(ff_get_message_enc_str(PROF_MSG_ENC_OMEMO)));
}