update

tests/e2e.rs

@@ -1,17 +1,18 @@
-//! End-to-end smoke-tests for the marlin binary.
+//! End-to-end “happy path” smoke-tests for the `marlin` binary.
 //!
-//! Run with `cargo test --test e2e` or let CI invoke `cargo test`.
+//! Run with `cargo test --test e2e` (CI does) or `cargo test`.
 
 use assert_cmd::prelude::*;
 use predicates::prelude::*;
 use std::{fs, path::PathBuf, process::Command};
 use tempfile::tempdir;
 
-/// Absolute path to the `marlin` binary Cargo just built for this test run.
+/// Absolute path to the freshly-built `marlin` binary.
 fn marlin_bin() -> PathBuf {
     PathBuf::from(env!("CARGO_BIN_EXE_marlin"))
 }
 
+/// Create the demo directory structure and seed files.
 fn spawn_demo_tree(root: &PathBuf) {
     fs::create_dir_all(root.join("Projects/Alpha")).unwrap();
     fs::create_dir_all(root.join("Projects/Beta")).unwrap();
@@ -21,83 +22,100 @@ fn spawn_demo_tree(root: &PathBuf) {
 
     fs::write(root.join("Projects/Alpha/draft1.md"), "- [ ] TODO foo\n").unwrap();
     fs::write(root.join("Projects/Alpha/draft2.md"), "- [x] TODO foo\n").unwrap();
-    fs::write(root.join("Projects/Beta/final.md"),   "done\n").unwrap();
-    fs::write(root.join("Projects/Gamma/TODO.txt"),  "TODO bar\n").unwrap();
-    fs::write(root.join("Logs/app.log"),             "ERROR omg\n").unwrap();
-    fs::write(root.join("Reports/Q1.pdf"),           "PDF\n").unwrap();
+    fs::write(root.join("Projects/Beta/final.md"), "done\n").unwrap();
+    fs::write(root.join("Projects/Gamma/TODO.txt"), "TODO bar\n").unwrap();
+    fs::write(root.join("Logs/app.log"),           "ERROR omg\n").unwrap();
+    fs::write(root.join("Reports/Q1.pdf"),         "PDF\n").unwrap();
 }
 
-fn run(cmd: &mut Command) -> assert_cmd::assert::Assert {
+/// Shorthand for “run and must succeed”.
+fn ok(cmd: &mut Command) -> assert_cmd::assert::Assert {
     cmd.assert().success()
 }
 
 #[test]
 fn full_cli_flow() -> Result<(), Box<dyn std::error::Error>> {
-    // 1. sandbox
-    let tmp      = tempdir()?;
+    /* ── 1 ░ sandbox ───────────────────────────────────────────── */
+
+    let tmp      = tempdir()?;                 // wiped on drop
     let demo_dir = tmp.path().join("marlin_demo");
     spawn_demo_tree(&demo_dir);
 
-    // 2. init  (auto-scan cwd)
-    run(Command::new(marlin_bin())
+    let db_path = demo_dir.join("index.db");
+
+    // Helper to spawn a fresh `marlin` Command with the DB env-var set
+    let marlin = || {
+        let mut c = Command::new(marlin_bin());
+        c.env("MARLIN_DB_PATH", &db_path);
+        c
+    };
+
+    /* ── 2 ░ init ( auto-scan cwd ) ───────────────────────────── */
+
+    ok(marlin()
         .current_dir(&demo_dir)
         .arg("init"));
 
-    // 3. tag & attr
-    run(Command::new(marlin_bin())
+    /* ── 3 ░ tag & attr demos ─────────────────────────────────── */
+
+    ok(marlin()
         .arg("tag")
         .arg(format!("{}/Projects/**/*.md", demo_dir.display()))
         .arg("project/md"));
 
-    run(Command::new(marlin_bin())
+    ok(marlin()
         .arg("attr")
         .arg("set")
         .arg(format!("{}/Reports/*.pdf", demo_dir.display()))
         .arg("reviewed")
         .arg("yes"));
 
-    // 4. search expectations
-    Command::new(marlin_bin())
-        .arg("search")
-        .arg("TODO")
+    /* ── 4 ░ quick search sanity checks ───────────────────────── */
+
+    marlin()
+        .arg("search").arg("TODO")
         .assert()
         .stdout(predicate::str::contains("TODO.txt"));
 
-    Command::new(marlin_bin())
-        .arg("search")
-        .arg("attr:reviewed=yes")
+    marlin()
+        .arg("search").arg("attr:reviewed=yes")
         .assert()
         .stdout(predicate::str::contains("Q1.pdf"));
 
-    // 5. link & backlinks
+    /* ── 5 ░ link flow & backlinks ────────────────────────────── */
+
     let foo = demo_dir.join("foo.txt");
     let bar = demo_dir.join("bar.txt");
     fs::write(&foo, "")?;
     fs::write(&bar, "")?;
-    run(Command::new(marlin_bin()).arg("scan").arg(&demo_dir));
-    run(Command::new(marlin_bin())
+
+    ok(marlin().arg("scan").arg(&demo_dir));
+
+    ok(marlin()
         .arg("link").arg("add")
         .arg(&foo).arg(&bar));
-    Command::new(marlin_bin())
+
+    marlin()
         .arg("link").arg("backlinks").arg(&bar)
         .assert()
         .stdout(predicate::str::contains("foo.txt"));
 
-    // 6. backup / restore round-trip
+    /* ── 6 ░ backup → delete DB → restore ────────────────────── */
+
     let backup_path = String::from_utf8(
-        Command::new(marlin_bin()).arg("backup").output()?.stdout
+        marlin().arg("backup").output()?.stdout
     )?;
     let backup_file = backup_path.split_whitespace().last().unwrap();
 
-    // wipe DB file
-    std::fs::remove_file(dirs::data_dir().unwrap().join("marlin/index.db"))?;
-    run(Command::new(marlin_bin()).arg("restore").arg(backup_file));
+    fs::remove_file(&db_path)?;                        // simulate corruption
+    ok(marlin().arg("restore").arg(backup_file));      // restore
 
-    // sanity: search still works
-    Command::new(marlin_bin())
+    // Search must still work afterwards
+    marlin()
         .arg("search").arg("TODO")
         .assert()
         .stdout(predicate::str::contains("TODO.txt"));
 
     Ok(())
 }
+

tests/neg.rs

@@ -0,0 +1,81 @@
+//! Negative-path integration tests (“should fail / warn”).
+
+use predicates::str;
+use tempfile::tempdir;
+
+mod util;
+use util::marlin;
+
+/* ───────────────────────── LINKS ─────────────────────────────── */
+
+#[test]
+fn link_non_indexed_should_fail() {
+    let tmp = tempdir().unwrap();
+
+    marlin(&tmp).current_dir(tmp.path()).arg("init").assert().success();
+
+    std::fs::write(tmp.path().join("foo.txt"), "").unwrap();
+    std::fs::write(tmp.path().join("bar.txt"), "").unwrap();
+
+    marlin(&tmp)
+        .current_dir(tmp.path())
+        .args([
+            "link", "add",
+            &tmp.path().join("foo.txt").to_string_lossy(),
+            &tmp.path().join("bar.txt").to_string_lossy()
+        ])
+        .assert()
+        .failure()
+        .stderr(str::contains("file not indexed"));
+}
+
+/* ───────────────────────── ATTR ─────────────────────────────── */
+
+#[test]
+fn attr_set_on_non_indexed_file_should_warn() {
+    let tmp = tempdir().unwrap();
+    marlin(&tmp).current_dir(tmp.path()).arg("init").assert().success();
+
+    let ghost = tmp.path().join("ghost.txt");
+    std::fs::write(&ghost, "").unwrap();
+
+    marlin(&tmp)
+        .args(["attr","set",
+               &ghost.to_string_lossy(),"foo","bar"])
+        .assert()
+        .success()                       // exits 0
+        .stderr(str::contains("not indexed"));
+}
+
+/* ───────────────────── COLLECTIONS ───────────────────────────── */
+
+#[test]
+fn coll_add_unknown_collection_should_fail() {
+    let tmp  = tempdir().unwrap();
+    let file = tmp.path().join("doc.txt");
+    std::fs::write(&file, "").unwrap();
+
+    marlin(&tmp).current_dir(tmp.path()).arg("init").assert().success();
+
+    marlin(&tmp)
+        .args(["coll","add","nope",&file.to_string_lossy()])
+        .assert()
+        .failure();
+}
+
+/* ───────────────────── RESTORE (bad file) ───────────────────── */
+
+#[test]
+fn restore_with_nonexistent_backup_should_fail() {
+    let tmp   = tempdir().unwrap();
+
+    // create an empty DB first
+    marlin(&tmp).arg("init").assert().success();
+
+    marlin(&tmp)
+        .args(["restore", "/definitely/not/here.db"])
+        .assert()
+        .failure()
+        .stderr(str::contains("Failed to restore"));
+}
+

tests/pos.rs

@@ -0,0 +1,171 @@
+//! Positive-path integration checks for every sub-command
+//! that already has real logic behind it.
+
+mod util;
+use util::marlin;
+
+use predicates::{prelude::*, str};          // brings `PredicateBooleanExt::and`
+use std::fs;
+use tempfile::tempdir;
+
+/* ─────────────────────────── TAG ─────────────────────────────── */
+
+#[test]
+fn tag_should_add_hierarchical_tag_and_search_finds_it() {
+    let tmp  = tempdir().unwrap();
+    let file = tmp.path().join("foo.md");
+    fs::write(&file, "# test\n").unwrap();
+
+    marlin(&tmp).current_dir(tmp.path()).arg("init").assert().success();
+
+    marlin(&tmp)
+        .args(["tag", file.to_str().unwrap(), "project/md"])
+        .assert().success();
+
+    marlin(&tmp)
+        .args(["search", "tag:project/md"])
+        .assert()
+        .success()
+        .stdout(str::contains("foo.md"));
+}
+
+/* ─────────────────────────── ATTR ────────────────────────────── */
+
+#[test]
+fn attr_set_then_ls_roundtrip() {
+    let tmp  = tempdir().unwrap();
+    let file = tmp.path().join("report.pdf");
+    fs::write(&file, "%PDF-1.4\n").unwrap();
+
+    marlin(&tmp).current_dir(tmp.path()).arg("init").assert().success();
+
+    marlin(&tmp)
+        .args(["attr", "set", file.to_str().unwrap(), "reviewed", "yes"])
+        .assert().success();
+
+    marlin(&tmp)
+        .args(["attr", "ls", file.to_str().unwrap()])
+        .assert()
+        .success()
+        .stdout(str::contains("reviewed = yes"));
+}
+
+/* ─────────────────────── COLLECTIONS ────────────────────────── */
+
+#[test]
+fn coll_create_add_and_list() {
+    let tmp = tempdir().unwrap();
+
+    let a = tmp.path().join("a.txt");
+    let b = tmp.path().join("b.txt");
+    fs::write(&a, "").unwrap();
+    fs::write(&b, "").unwrap();
+
+    marlin(&tmp).current_dir(tmp.path()).arg("init").assert().success();
+
+    marlin(&tmp).args(["coll", "create", "Set"]).assert().success();
+    for f in [&a, &b] {
+        marlin(&tmp).args(["coll", "add", "Set", f.to_str().unwrap()]).assert().success();
+    }
+
+    marlin(&tmp)
+        .args(["coll", "list", "Set"])
+        .assert()
+        .success()
+        .stdout(str::contains("a.txt").and(str::contains("b.txt")));
+}
+
+/* ─────────────────────────── VIEWS ───────────────────────────── */
+
+#[test]
+fn view_save_list_and_exec() {
+    let tmp  = tempdir().unwrap();
+
+    let todo = tmp.path().join("TODO.txt");
+    fs::write(&todo, "remember the milk\n").unwrap();
+
+    marlin(&tmp).current_dir(tmp.path()).arg("init").assert().success();
+
+    // save & list
+    marlin(&tmp).args(["view", "save", "tasks", "milk"]).assert().success();
+    marlin(&tmp)
+        .args(["view", "list"])
+        .assert()
+        .success()
+        .stdout(str::contains("tasks: milk"));
+
+    // exec
+    marlin(&tmp)
+        .args(["view", "exec", "tasks"])
+        .assert()
+        .success()
+        .stdout(str::contains("TODO.txt"));
+}
+
+/* ─────────────────────────── LINKS ───────────────────────────── */
+
+#[test]
+fn link_add_rm_and_list() {
+    let tmp = tempdir().unwrap();
+
+    let foo = tmp.path().join("foo.txt");
+    let bar = tmp.path().join("bar.txt");
+    fs::write(&foo, "").unwrap();
+    fs::write(&bar, "").unwrap();
+
+    // handy closure
+    let mc = || marlin(&tmp);
+
+    mc().current_dir(tmp.path()).arg("init").assert().success();
+    mc().args(["scan", tmp.path().to_str().unwrap()]).assert().success();
+
+    // add
+    mc().args(["link", "add", foo.to_str().unwrap(), bar.to_str().unwrap()])
+        .assert().success();
+
+    // list (outgoing default)
+    mc().args(["link", "list", foo.to_str().unwrap()])
+        .assert().success()
+        .stdout(str::contains("foo.txt").and(str::contains("bar.txt")));
+
+    // remove
+    mc().args(["link", "rm", foo.to_str().unwrap(), bar.to_str().unwrap()])
+        .assert().success();
+
+    // list now empty
+    mc().args(["link", "list", foo.to_str().unwrap()])
+        .assert().success()
+        .stdout(str::is_empty());
+}
+
+/* ─────────────────────── SCAN (multi-path) ───────────────────── */
+
+#[test]
+fn scan_with_multiple_paths_indexes_all() {
+    let tmp = tempdir().unwrap();
+
+    let dir_a = tmp.path().join("A");
+    let dir_b = tmp.path().join("B");
+    std::fs::create_dir_all(&dir_a).unwrap();
+    std::fs::create_dir_all(&dir_b).unwrap();
+    let f1 = dir_a.join("one.txt");
+    let f2 = dir_b.join("two.txt");
+    fs::write(&f1, "").unwrap();
+    fs::write(&f2, "").unwrap();
+
+    marlin(&tmp).current_dir(tmp.path()).arg("init").assert().success();
+
+    // multi-path scan
+    marlin(&tmp)
+        .args(["scan", dir_a.to_str().unwrap(), dir_b.to_str().unwrap()])
+        .assert().success();
+
+    // both files findable
+    for term in ["one.txt", "two.txt"] {
+        marlin(&tmp).args(["search", term])
+            .assert()
+            .success()
+            .stdout(str::contains(term));
+    }
+}
+

tests/test.md

@@ -62,7 +62,7 @@ If you wire **“cargo test --all”** into CI (GitHub Actions, GitLab, etc.), p
 ```bash
 git pull && cargo build --release &&
 sudo install -Dm755 target/release/marlin /usr/local/bin/marlin &&
-cargo test --test e2e -- --nocapture
+cargo test --all -- --nocapture
 ```
 
 Stick that in a shell alias (`alias marlin-ci='…'`) and you’ve got a 5-second upgrade-and-verify loop.

tests/util.rs

@@ -0,0 +1,23 @@
+//! tests/util.rs
+//! Small helpers shared across integration tests.
+
+use std::path::{Path, PathBuf};
+use tempfile::TempDir;
+use assert_cmd::Command; 
+/// Absolute path to the freshly-built `marlin` binary.
+pub fn bin() -> PathBuf {
+    PathBuf::from(env!("CARGO_BIN_EXE_marlin"))
+}
+
+/// Build a `Command` for `marlin` whose `MARLIN_DB_PATH` is
+/// `<tmp>/index.db`.
+///
+/// Each call yields a brand-new `Command`, so callers can freely add
+/// arguments, change the working directory, etc., without affecting
+/// other invocations.
+pub fn marlin(tmp: &TempDir) -> Command {
+    let db_path: &Path = &tmp.path().join("index.db");
+    let mut cmd = Command::new(bin());
+    cmd.env("MARLIN_DB_PATH", db_path);
+    cmd
+}