smartbotic-database/tests/test_lmdb_env.cpp

// v2.0 storage engine — unit tests for LmdbEnv (Task 1.2) plus WriteTxn /
// ReadTxn / LmdbDbi primitives (Task 1.3).

#include <atomic>
#include <cassert>
#include <cstdlib>
#include <filesystem>
#include <iostream>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <unistd.h>

#include <lmdb.h>

#include "storage/lmdb_dbi.hpp"
#include "storage/lmdb_env.hpp"
#include "storage/lmdb_txn.hpp"

namespace fs = std::filesystem;

using smartbotic::db::storage::LmdbDbi;
using smartbotic::db::storage::LmdbEnv;
using smartbotic::db::storage::LmdbEnvOpts;
using smartbotic::db::storage::ReadTxn;
using smartbotic::db::storage::WriteTxn;

namespace {

void check(bool cond, const char* msg) {
    if (!cond) {
        std::cerr << "FAIL: " << msg << "\n";
        std::abort();
    }
}

// Per-process, unique tmpdir for test isolation.
std::string make_tmpdir(const char* tag) {
    static std::atomic<int> counter{0};
    int n = counter.fetch_add(1);
    std::string path = "/tmp/lmdb-env-test-" + std::to_string(::getpid()) +
                       "-" + std::to_string(n) + "-" + tag;
    std::error_code ec;
    fs::remove_all(path, ec);
    return path;
}

struct TmpDir {
    std::string path;
    explicit TmpDir(const char* tag) : path(make_tmpdir(tag)) {}
    ~TmpDir() {
        std::error_code ec;
        fs::remove_all(path, ec);
    }
    TmpDir(const TmpDir&) = delete;
    TmpDir& operator=(const TmpDir&) = delete;
};

// Helper: populate an LMDB env via raw mdb_* calls. Used by the env-only
// tests below; once Task 1.3 adds WriteTxn / LmdbDbi, the txn-level tests
// will use those wrappers instead.
void raw_populate(const std::string& path, size_t map_size,
                  int n_entries, size_t entry_size) {
    std::error_code ec;
    fs::create_directories(path, ec);
    if (ec) {
        throw std::runtime_error(
            "raw_populate: create_directories: " + ec.message());
    }
    MDB_env* env = nullptr;
    if (mdb_env_create(&env) != MDB_SUCCESS) {
        throw std::runtime_error("raw_populate: env_create");
    }
    if (mdb_env_set_mapsize(env, map_size) != MDB_SUCCESS) {
        mdb_env_close(env);
        throw std::runtime_error("raw_populate: set_mapsize");
    }
    if (mdb_env_open(env, path.c_str(), 0, 0644) != MDB_SUCCESS) {
        mdb_env_close(env);
        throw std::runtime_error("raw_populate: env_open");
    }
    MDB_txn* txn = nullptr;
    if (mdb_txn_begin(env, nullptr, 0, &txn) != MDB_SUCCESS) {
        mdb_env_close(env);
        throw std::runtime_error("raw_populate: txn_begin");
    }
    MDB_dbi dbi = 0;
    if (mdb_dbi_open(txn, nullptr, MDB_CREATE, &dbi) != MDB_SUCCESS) {
        mdb_txn_abort(txn);
        mdb_env_close(env);
        throw std::runtime_error("raw_populate: dbi_open");
    }
    std::string blob(entry_size, 'x');
    for (int i = 0; i < n_entries; ++i) {
        std::string k = "k" + std::to_string(i);
        MDB_val kv{k.size(), const_cast<char*>(k.data())};
        MDB_val vv{blob.size(), const_cast<char*>(blob.data())};
        int rc = mdb_put(txn, dbi, &kv, &vv, 0);
        if (rc != MDB_SUCCESS) {
            mdb_txn_abort(txn);
            mdb_env_close(env);
            throw std::runtime_error("raw_populate: put");
        }
    }
    if (mdb_txn_commit(txn) != MDB_SUCCESS) {
        mdb_env_close(env);
        throw std::runtime_error("raw_populate: txn_commit");
    }
    mdb_env_close(env);
}

void raw_get(const std::string& path, const std::string& key,
             std::string& out_value, bool& found) {
    found = false;
    MDB_env* env = nullptr;
    if (mdb_env_create(&env) != MDB_SUCCESS) {
        throw std::runtime_error("raw_get: env_create");
    }
    if (mdb_env_set_mapsize(env, 4ULL << 20) != MDB_SUCCESS) {
        mdb_env_close(env);
        throw std::runtime_error("raw_get: set_mapsize");
    }
    if (mdb_env_open(env, path.c_str(), 0, 0644) != MDB_SUCCESS) {
        mdb_env_close(env);
        throw std::runtime_error("raw_get: env_open");
    }
    MDB_txn* txn = nullptr;
    if (mdb_txn_begin(env, nullptr, MDB_RDONLY, &txn) != MDB_SUCCESS) {
        mdb_env_close(env);
        throw std::runtime_error("raw_get: txn_begin");
    }
    MDB_dbi dbi = 0;
    int rc = mdb_dbi_open(txn, nullptr, 0, &dbi);
    if (rc != MDB_SUCCESS) {
        mdb_txn_abort(txn);
        mdb_env_close(env);
        if (rc == MDB_NOTFOUND) return;
        throw std::runtime_error("raw_get: dbi_open");
    }
    MDB_val kv{key.size(), const_cast<char*>(key.data())};
    MDB_val vv{0, nullptr};
    rc = mdb_get(txn, dbi, &kv, &vv);
    if (rc == MDB_SUCCESS) {
        out_value.assign(static_cast<const char*>(vv.mv_data), vv.mv_size);
        found = true;
    }
    mdb_txn_abort(txn);
    mdb_env_close(env);
}

// =========================================================================
// Task 1.2 — LmdbEnv tests
// =========================================================================

void test_open_creates_dir() {
    TmpDir td("create-dir");
    check(!fs::exists(td.path), "precondition: tmpdir absent");
    LmdbEnvOpts opts;
    opts.path = td.path;
    LmdbEnv env(opts);
    check(fs::exists(td.path) && fs::is_directory(td.path),
          "LmdbEnv constructor created the env directory");
    // LMDB also created its data.mdb / lock.mdb in there.
    check(fs::exists(td.path + "/data.mdb"), "data.mdb exists after open");
    check(fs::exists(td.path + "/lock.mdb"), "lock.mdb exists after open");
}

void test_path_accessor() {
    TmpDir td("path-accessor");
    LmdbEnvOpts opts;
    opts.path = td.path;
    LmdbEnv env(opts);
    check(env.path() == td.path, "env.path() returns configured path");
    check(env.raw() != nullptr, "env.raw() returns non-null MDB_env*");
}

void test_mapsize_too_small_fails() {
    TmpDir td("mapsize-small");

    // Populate via raw LMDB so the data.mdb file grows past the small mapsize
    // we'll try to reopen with.
    raw_populate(td.path, 4ULL << 20 /* 4 MiB */, 16, 64 * 1024 /* 64 KiB */);

    // Sanity: the populated dir reports nonzero on-disk bytes.
    uint64_t bytes = 0;
    {
        LmdbEnvOpts opts;
        opts.path = td.path;
        opts.map_size_bytes = 4ULL << 20;
        LmdbEnv env(opts);
        bytes = env.on_disk_bytes();
    }
    check(bytes > 0, "populated env has nonzero on_disk_bytes");

    // Re-opening with a smaller mapsize than the existing data file must
    // fail fast — LMDB rejects mapsize < size-of-data-file.
    LmdbEnvOpts opts;
    opts.path = td.path;
    opts.map_size_bytes = 4096;  // 4 KiB — far below data.mdb size.
    bool threw = false;
    try {
        LmdbEnv env(opts);
    } catch (const std::runtime_error&) {
        threw = true;
    }
    check(threw, "opening with too-small mapsize fails fast");
}

void test_double_open_same_path_separate_envs() {
    TmpDir td("double-open");
    LmdbEnvOpts opts;
    opts.path = td.path;

    // Seed via raw LMDB so we have data to read through the second handle.
    raw_populate(td.path, 4ULL << 20, 4, 64);

    // LMDB supports multi-process access; two envs on the same path should
    // both be openable from the same process too.
    LmdbEnv a(opts);
    LmdbEnv b(opts);

    check(a.raw() != nullptr, "first env handle non-null");
    check(b.raw() != nullptr, "second env handle non-null");
    check(a.raw() != b.raw(), "two LmdbEnv handles are distinct objects");

    // Sanity: both envs see the seeded data via raw_get (which opens a third
    // handle internally — proves multi-handle reads work).
    std::string v;
    bool found = false;
    raw_get(td.path, "k0", v, found);
    check(found, "raw_get sees seeded key while two LmdbEnv handles are open");
}

void test_on_disk_bytes_nonzero_after_create() {
    TmpDir td("on-disk-bytes");
    LmdbEnvOpts opts;
    opts.path = td.path;
    LmdbEnv env(opts);
    check(env.on_disk_bytes() > 0,
          "fresh env reports nonzero on_disk_bytes (data.mdb/lock.mdb initialised)");
}

void test_move_constructor_transfers_ownership() {
    TmpDir td("move-ctor");
    LmdbEnvOpts opts;
    opts.path = td.path;
    LmdbEnv a(opts);
    MDB_env* raw_a = a.raw();
    check(raw_a != nullptr, "source env has non-null raw before move");

    LmdbEnv b(std::move(a));
    check(b.raw() == raw_a, "moved-to env owns the original handle");
    check(a.raw() == nullptr, "moved-from env has null handle");
    check(b.path() == td.path, "moved-to env retains path");
}

// =========================================================================
// Task 1.3 — WriteTxn / ReadTxn / LmdbDbi tests
// =========================================================================

void test_write_txn_commit_roundtrip() {
    TmpDir td("commit-roundtrip");
    LmdbEnvOpts opts;
    opts.path = td.path;
    LmdbEnv env(opts);

    {
        WriteTxn wtxn(env);
        LmdbDbi dbi(wtxn, "_test");
        dbi.put(wtxn, "alpha", "one");
        dbi.put(wtxn, "beta", "two");
        wtxn.commit();
    }

    {
        ReadTxn rtxn(env);
        LmdbDbi dbi(rtxn, "_test");
        auto a = dbi.get(rtxn, "alpha");
        check(a.has_value() && std::string(*a) == "one", "alpha = one");
        auto b = dbi.get(rtxn, "beta");
        check(b.has_value() && std::string(*b) == "two", "beta = two");
        auto c = dbi.get(rtxn, "gamma");
        check(!c.has_value(), "gamma absent -> nullopt");
    }
}

void test_write_txn_abort_discards() {
    TmpDir td("abort-discards");
    LmdbEnvOpts opts;
    opts.path = td.path;
    LmdbEnv env(opts);

    // First commit creates the sub-db so the post-abort read txn can open it.
    {
        WriteTxn wtxn(env);
        LmdbDbi dbi(wtxn, "_test");
        dbi.put(wtxn, "seed", "ok");
        wtxn.commit();
    }

    {
        WriteTxn wtxn(env);
        LmdbDbi dbi(wtxn, "_test");
        dbi.put(wtxn, "alpha", "one");
        wtxn.abort();
    }

    {
        ReadTxn rtxn(env);
        LmdbDbi dbi(rtxn, "_test");
        auto a = dbi.get(rtxn, "alpha");
        check(!a.has_value(), "aborted put leaves no trace");
        auto s = dbi.get(rtxn, "seed");
        check(s.has_value(), "seed survived (sanity check that the sub-db is intact)");
    }
}

void test_read_during_write() {
    TmpDir td("read-during-write");
    LmdbEnvOpts opts;
    opts.path = td.path;
    LmdbEnv env(opts);

    // Seed: k=v1.
    {
        WriteTxn wtxn(env);
        LmdbDbi dbi(wtxn, "_test");
        dbi.put(wtxn, "k", "v1");
        wtxn.commit();
    }

    // Open a long-lived read txn on the v1 snapshot.
    ReadTxn rtxn(env);
    LmdbDbi rdbi(rtxn, "_test");

    // Update k -> v2 in a separate, committed write txn.
    {
        WriteTxn wtxn(env);
        LmdbDbi wdbi(wtxn, "_test");
        wdbi.put(wtxn, "k", "v2");
        wtxn.commit();
    }

    // The pre-existing read txn still sees v1 (LMDB MVCC snapshot).
    auto got = rdbi.get(rtxn, "k");
    check(got.has_value() && std::string(*got) == "v1",
          "long-lived read txn sees pre-write snapshot value");

    // A fresh read txn sees v2.
    {
        ReadTxn r2(env);
        LmdbDbi d2(r2, "_test");
        auto g2 = d2.get(r2, "k");
        check(g2.has_value() && std::string(*g2) == "v2",
              "fresh read txn sees post-write value");
    }
}

void test_multiple_subdbs_isolated() {
    TmpDir td("multi-subdb");
    LmdbEnvOpts opts;
    opts.path = td.path;
    LmdbEnv env(opts);

    {
        WriteTxn wtxn(env);
        LmdbDbi a(wtxn, "_a");
        LmdbDbi b(wtxn, "_b");
        a.put(wtxn, "k", "from_a");
        b.put(wtxn, "k", "from_b");
        wtxn.commit();
    }

    {
        ReadTxn rtxn(env);
        LmdbDbi a(rtxn, "_a");
        LmdbDbi b(rtxn, "_b");
        auto ga = a.get(rtxn, "k");
        auto gb = b.get(rtxn, "k");
        check(ga.has_value() && std::string(*ga) == "from_a",
              "sub-db _a returns _a's value for k");
        check(gb.has_value() && std::string(*gb) == "from_b",
              "sub-db _b returns _b's value for k");
    }
}

void test_del_returns_false_on_missing() {
    TmpDir td("del-missing");
    LmdbEnvOpts opts;
    opts.path = td.path;
    LmdbEnv env(opts);

    {
        WriteTxn wtxn(env);
        LmdbDbi dbi(wtxn, "_test");
        dbi.put(wtxn, "present", "x");
        bool d1 = dbi.del(wtxn, "absent");
        check(!d1, "del on missing key returns false (not an error)");
        bool d2 = dbi.del(wtxn, "present");
        check(d2, "del on present key returns true");
        bool d3 = dbi.del(wtxn, "present");
        check(!d3, "second del on now-absent key returns false");
        wtxn.commit();
    }
}

void test_count_matches_puts() {
    TmpDir td("count");
    LmdbEnvOpts opts;
    opts.path = td.path;
    LmdbEnv env(opts);

    const int N = 100;
    {
        WriteTxn wtxn(env);
        LmdbDbi dbi(wtxn, "_test");
        for (int i = 0; i < N; ++i) {
            std::string k = "k" + std::to_string(i);
            dbi.put(wtxn, k, "v");
        }
        wtxn.commit();
    }

    {
        ReadTxn rtxn(env);
        LmdbDbi dbi(rtxn, "_test");
        check(dbi.count(rtxn) == static_cast<uint64_t>(N),
              "count() matches puts");
    }
}

void test_write_txn_throws_if_committed_twice() {
    TmpDir td("double-commit");
    LmdbEnvOpts opts;
    opts.path = td.path;
    LmdbEnv env(opts);

    WriteTxn wtxn(env);
    LmdbDbi dbi(wtxn, "_test");
    dbi.put(wtxn, "k", "v");
    wtxn.commit();

    bool threw = false;
    try {
        wtxn.commit();
    } catch (const std::runtime_error&) {
        threw = true;
    }
    check(threw, "second commit() throws");
}

void test_write_txn_destructor_aborts_if_not_finalised() {
    TmpDir td("dtor-abort");
    LmdbEnvOpts opts;
    opts.path = td.path;
    LmdbEnv env(opts);

    // Seed an empty sub-db so the post-scope read txn can open it.
    {
        WriteTxn wtxn(env);
        LmdbDbi dbi(wtxn, "_test");
        dbi.put(wtxn, "seed", "s");
        wtxn.commit();
    }

    // Drop a write txn without committing — destructor must abort, not commit.
    {
        WriteTxn wtxn(env);
        LmdbDbi dbi(wtxn, "_test");
        dbi.put(wtxn, "alpha", "one");
        // No commit; let the dtor run.
    }

    {
        ReadTxn rtxn(env);
        LmdbDbi dbi(rtxn, "_test");
        auto a = dbi.get(rtxn, "alpha");
        check(!a.has_value(), "destructor of uncommitted WriteTxn discards writes");
    }
}

void test_commit_after_abort_throws() {
    TmpDir td("commit-after-abort");
    LmdbEnvOpts opts;
    opts.path = td.path;
    LmdbEnv env(opts);

    WriteTxn wtxn(env);
    LmdbDbi dbi(wtxn, "_test");
    dbi.put(wtxn, "k", "v");
    wtxn.abort();

    bool threw = false;
    try {
        wtxn.commit();
    } catch (const std::runtime_error&) {
        threw = true;
    }
    check(threw, "commit() after abort() throws");
}

void test_write_txn_move_construct() {
    TmpDir td("write-move");
    LmdbEnvOpts opts;
    opts.path = td.path;
    LmdbEnv env(opts);

    auto make_txn = [&]() {
        WriteTxn t(env);
        return t;  // forces move-construction
    };

    {
        WriteTxn moved = make_txn();
        LmdbDbi dbi(moved, "_test");
        dbi.put(moved, "k", "from-moved");
        moved.commit();
    }

    {
        ReadTxn rtxn(env);
        LmdbDbi dbi(rtxn, "_test");
        auto g = dbi.get(rtxn, "k");
        check(g.has_value() && std::string(*g) == "from-moved",
              "moved WriteTxn commits successfully");
    }
}

void test_get_returns_view_into_mmap() {
    // The contract says get() returns a string_view that lives for the
    // duration of the txn. Exercise that lifetime: read the value, use
    // it while the txn is alive, drop the txn.
    TmpDir td("mmap-view");
    LmdbEnvOpts opts;
    opts.path = td.path;
    LmdbEnv env(opts);

    {
        WriteTxn wtxn(env);
        LmdbDbi dbi(wtxn, "_test");
        dbi.put(wtxn, "k", "hello world");
        wtxn.commit();
    }

    ReadTxn rtxn(env);
    LmdbDbi dbi(rtxn, "_test");
    auto v = dbi.get(rtxn, "k");
    check(v.has_value(), "get returns value");
    check(v->size() == 11, "string_view has expected length");
    check(std::string(*v) == "hello world", "string_view content matches");
    // rtxn drops at end of scope; we don't touch v after that.
}

}  // namespace

int main() {
    // Task 1.2 — env.
    test_open_creates_dir();
    test_path_accessor();
    test_mapsize_too_small_fails();
    test_double_open_same_path_separate_envs();
    test_on_disk_bytes_nonzero_after_create();
    test_move_constructor_transfers_ownership();

    // Task 1.3 — txn + dbi.
    test_write_txn_commit_roundtrip();
    test_write_txn_abort_discards();
    test_read_during_write();
    test_multiple_subdbs_isolated();
    test_del_returns_false_on_missing();
    test_count_matches_puts();
    test_write_txn_throws_if_committed_twice();
    test_write_txn_destructor_aborts_if_not_finalised();
    test_commit_after_abort_throws();
    test_write_txn_move_construct();
    test_get_returns_view_into_mmap();

    std::cout << "test_lmdb_env: all passed\n";
    return 0;
}