nedb-engine 6.1.0

// SPDX-FileCopyrightText: 2026 INTERCHAINED LLC
// SPDX-License-Identifier: BUSL-1.1
// NEDB · © 2026 INTERCHAINED LLC × Eth-Interchained × Vex (Claude Opus 5)

//! NEDB v3 integration tests — Db-level behavior of the segment substrate.
//!
//! These exercise the public `Db` API end to end: v3 write/read/reopen,
//! compaction/pruning, dual-read migration from v2 loose objects, and the
//! default-off (v2) path. Kept in a SINGLE test fn because the v3 switch is the
//! process-global `NEDB_DAG_V3` env var read at `Db::open`; running the
//! scenarios sequentially avoids racing it across parallel test threads.

use std::fs;
use std::path::Path;

use nedb_engine::Db;
use serde_json::json;

fn put_one(db: &Db, coll: &str, id: &str, v: &str) {
    db.put_batch(vec![(
        coll.to_string(),
        id.to_string(),
        json!({ "v": v }),
        Vec::new(),
        None,
        None,
    )])
    .expect("put_batch");
    db.flush_all();
}

fn value(db: &Db, coll: &str, id: &str) -> Option<String> {
    db.get(coll, id)
        .and_then(|n| n.data.get("v").and_then(|x| x.as_str().map(|s| s.to_string())))
}

/// Compaction prunes history — and must degrade gracefully, not lie.
///
/// `compact()` deliberately keeps only CURRENT versions, so it drops every
/// superseded version and every tombstone. That is the documented trade: an
/// operator explicitly exchanges the audit trail for disk space, and nothing
/// invokes it automatically.
///
/// The requirement is therefore not that history survives — the operator asked
/// for it to go. It is that afterwards a graveyard entry pointing at a pruned
/// tombstone reads as ABSENT rather than erroring, panicking, or resurrecting a
/// stale value. A dangling pointer that produces a confident wrong answer would
/// be far worse than one that produces nothing.
///
/// Lives here rather than in a `#[cfg(test)]` unit test because it needs
/// `NEDB_DAG_V3`, and `set_var` is process-global while cargo runs lib tests in
/// parallel threads — setting it there leaked into an unrelated test and broke
/// it, which is its own small lesson.
#[test]
fn compaction_prunes_history_and_degrades_gracefully() {
    std::env::set_var("NEDB_DAG_V3", "1");
    let tmp = std::env::temp_dir().join(format!("nedb_compact_hist_{}", std::process::id()));
    let _ = fs::remove_dir_all(&tmp);
    let db = Db::open(&tmp, None).unwrap();

    put_one(&db, "o", "a", "first");
    put_one(&db, "o", "live", "stays");
    let v1_seq = db.get("o", "a").expect("just written").seq;
    assert!(db.delete("o", "a").unwrap());

    // Reachable BEFORE compaction — a delete is a tombstone, not an erasure.
    assert_eq!(
        db.get_as_of("o", "a", v1_seq).map(|n| n.data["v"].clone()),
        Some(json!("first")),
        "a deleted document's history must be readable before compaction",
    );

    db.compact().expect("compact");

    // AFTER: absent, not wrong.
    assert!(db.get_as_of("o", "a", v1_seq).is_none(),
            "a pruned version must read as absent, never as a stale value");
    assert!(db.get("o", "a").is_none(), "and it is still deleted");
    assert_eq!(value(&db, "o", "live").as_deref(), Some("stays"),
               "the living are untouched by compaction");

    let (_ok, bad) = db.verify();
    assert!(bad.is_empty(), "verify stays clean after compaction: {:?}", bad);

    let _ = fs::remove_dir_all(&tmp);
}

#[test]
fn v3_segment_substrate_end_to_end() {
    let tmp = std::env::temp_dir().join(format!("nedb_v3_it_{}", std::process::id()));
    let _ = fs::remove_dir_all(&tmp);
    fs::create_dir_all(&tmp).unwrap();

    // ── 1. v3 mode: write / read / reopen ──────────────────────────────────────
    std::env::set_var("NEDB_DAG_V3", "1");
    let d1 = tmp.join("v3");
    {
        let db = Db::open(&d1, None).unwrap();
        for i in 0..200 {
            put_one(&db, "coins", &format!("u-{:04}", i), &format!("val-{}", i));
        }
        assert_eq!(value(&db, "coins", "u-0000").as_deref(), Some("val-0"));
        assert_eq!(value(&db, "coins", "u-0199").as_deref(), Some("val-199"));
        let (ok, bad) = db.verify();
        assert!(bad.is_empty(), "v3 verify must be clean: {:?}", bad);
        assert!(ok >= 200, "v3 verify should cover all objects");
    }
    // segment files exist; reopen rebuilds the index (via scan/.idx) and reads.
    assert!(d1.join("objects").join("segments").is_dir(), "v3 must create objects/segments/");
    {
        let db = Db::open(&d1, None).unwrap();
        assert_eq!(value(&db, "coins", "u-0123").as_deref(), Some("val-123"));

        // ── 2. compaction prunes superseded versions but keeps current ─────────
        put_one(&db, "coins", "u-0001", "val-1-NEW"); // supersede one → old version dead
        let stats = db.compact().expect("compact");
        assert!(stats.dropped_objects >= 1, "compaction should drop the dead old version");
        assert_eq!(value(&db, "coins", "u-0001").as_deref(), Some("val-1-NEW"), "current version survives compaction");
        assert_eq!(value(&db, "coins", "u-0150").as_deref(), Some("val-150"), "untouched current version survives");
        let (_ok, bad) = db.verify();
        assert!(bad.is_empty(), "verify clean after compaction: {:?}", bad);
    }
    // survives a reopen after compaction
    {
        let db = Db::open(&d1, None).unwrap();
        assert_eq!(value(&db, "coins", "u-0001").as_deref(), Some("val-1-NEW"));
        assert_eq!(value(&db, "coins", "u-0150").as_deref(), Some("val-150"));
    }

    // ── 3. dual-read migration: v2 loose objects readable in v3 mode ──────────
    let d2 = tmp.join("migrate");
    std::env::remove_var("NEDB_DAG_V3"); // write as v2 loose objects first
    {
        let db = Db::open(&d2, None).unwrap();
        put_one(&db, "coins", "old-1", "loose-1");
        put_one(&db, "coins", "old-2", "loose-2");
    }
    assert!(!d2.join("objects").join("segments").is_dir(), "v2 mode must NOT create segments/");
    std::env::set_var("NEDB_DAG_V3", "1"); // reopen in v3 mode
    {
        let db = Db::open(&d2, None).unwrap();
        // old loose objects still readable via dual-read fallback
        assert_eq!(value(&db, "coins", "old-1").as_deref(), Some("loose-1"));
        assert_eq!(value(&db, "coins", "old-2").as_deref(), Some("loose-2"));
        // new writes go to segments
        put_one(&db, "coins", "new-1", "seg-1");
        assert_eq!(value(&db, "coins", "new-1").as_deref(), Some("seg-1"));
        assert!(d2.join("objects").join("segments").is_dir(), "new writes create segments/");
        // both old (loose) and new (segment) survive a reopen
    }
    {
        let db = Db::open(&d2, None).unwrap();
        assert_eq!(value(&db, "coins", "old-1").as_deref(), Some("loose-1"));
        assert_eq!(value(&db, "coins", "new-1").as_deref(), Some("seg-1"));
    }

    // ── 4. default OFF == v2 loose objects, no segments ────────────────────────
    std::env::remove_var("NEDB_DAG_V3");
    let d3 = tmp.join("default");
    {
        let db = Db::open(&d3, None).unwrap();
        put_one(&db, "coins", "x", "y");
        assert_eq!(value(&db, "coins", "x").as_deref(), Some("y"));
    }
    assert!(!d3.join("objects").join("segments").is_dir(), "default (no flag) must stay v2 loose");

    let _ = fs::remove_dir_all(&tmp);
}

#[allow(dead_code)]
fn _unused(_p: &Path) {}

/// The end-to-end prune, in its own process.
///
/// This lives here rather than in a unit test because selecting the v3 segment
/// substrate means setting `NEDB_DAG_V3`, which is process-global. Unit tests
/// run threaded in one process, so setting it there silently changed the
/// storage substrate under every other test that happened to open a database
/// in the same instant — an intermittent failure that looked like flakiness
/// and was actually one test reaching into another's world.
#[test]
fn compaction_prunes_history_and_verification_says_so_plainly() {
    use nedb_engine::db::Db;
    use nedb_engine::root::{RecordStatus, Recomputation, UnavailableReason};

    std::env::set_var("NEDB_DAG_V3", "1");
    let dir = tempfile::tempdir().unwrap();
    let db = Db::open(dir.path(), None).unwrap();

    db.put("orders", "1", serde_json::json!({"v": 1}), vec![], None, None).unwrap();
    let rec = db.create_root().unwrap();
    db.put("orders", "1", serde_json::json!({"v": 2}), vec![], None, None).unwrap();
    db.flush_all();

    assert!(db.verify_root(rec.at_seq).is_verified(), "verifiable before the prune");
    assert_eq!(db.history_floor(), 0);

    let stats = db.compact().expect("compact");
    assert!(stats.dropped_objects > 0, "v3 compaction must actually drop the superseded version");
    assert!(db.history_floor() > 0, "and must record where history now begins");

    let v = db.verify_root(rec.at_seq);
    assert_eq!(v.record, RecordStatus::Valid, "the record itself is still fine");
    assert_eq!(
        v.recomputation,
        Recomputation::Unavailable(UnavailableReason::HistoryPruned),
        "and the engine says plainly that it could not check it"
    );
    assert!(!v.is_verified(), "unavailable is not verified");
    assert!(!v.is_mismatch(), "and it is not a mismatch either");
    assert_eq!(v.exit_code(), 3, "its own exit code, distinct from pass and fail");
}