improvise/tests/shipped_documents_load.rs

//! Every `.improv` document this repository ships must load (improvise-odbc).
//! "Shipped" is "tracked", read off git's index: `context/test-evidence/tui.md`.

use std::path::{Path, PathBuf};

/// Every tracked `.improv` and `.improv.gz` under `root`. Outside a checkout this
/// panics rather than answering empty (improvise-c0aj).
fn shipped_documents(root: &Path) -> Vec<PathBuf> {
    let out = git(root)
        .args(["ls-files", "-z", "--", "*.improv", "*.improv.gz"])
        .output()
        .expect("git runs: this test reads the index, so it needs a checkout");
    assert!(
        out.status.success(),
        "git ls-files failed in {}: {}",
        root.display(),
        String::from_utf8_lossy(&out.stderr)
    );
    let mut found: Vec<PathBuf> = String::from_utf8(out.stdout)
        .expect("UTF-8 paths")
        .split('\0')
        .filter(|p| !p.is_empty())
        .map(|p| root.join(p))
        .collect();
    found.sort();
    found
}

#[test]
fn every_shipped_document_loads() {
    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
    let documents = shipped_documents(root);
    assert!(
        !documents.is_empty(),
        "precondition: the index must list at least one shipped document"
    );

    for path in documents {
        let workbook = improvise::persistence::load(&path)
            .unwrap_or_else(|e| panic!("{} does not load: {e}", path.display()));
        assert!(
            workbook.views.contains_key(&workbook.active_view),
            "{} loads but its initial view {:?} is not one of {:?}",
            path.display(),
            workbook.active_view,
            workbook.views.keys().collect::<Vec<_>>()
        );
    }
}

/// improvise-gk51: in every shipped document, pivot and records mode, a cell
/// projected as a `Record` is one the host would accept a write to.
#[test]
fn every_record_a_shipped_document_projects_is_writable() {
    use improvise::command::key::{KeyCode, KeyEvent, KeyModifiers};
    use improvise::protocol::CellId;
    use improvise::ui::app::App;
    use improvise_command::ui::project::{Viewport, grid_of};

    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
    let mut records = 0;
    let mut refused = Vec::new();
    for path in shipped_documents(root) {
        let workbook = improvise::persistence::load(&path).expect("every shipped document loads");
        let mut app = App::new(workbook, None);
        for _mode in ["pivot", "records"] {
            let whole = Viewport {
                row_offset: 0,
                col_offset: 0,
                rows: app.layout.row_count(),
                cols: app.layout.col_count(),
            };
            let grid = grid_of(&app, whole);
            for cell in grid.cells.iter().flatten() {
                if let Some(CellId::Record(record)) = &cell.id {
                    records += 1;
                    if let Some(why) = app.unwritable(record) {
                        refused.push(format!("{}: {why}", path.display()));
                    }
                }
            }
            let r = KeyEvent::new(KeyCode::Char('R'), KeyModifiers::NONE);
            let _ = app.handle_key(r);
        }
    }
    assert!(
        records > 0,
        "precondition: the shipped documents project records"
    );
    assert!(
        refused.is_empty(),
        "projected as Record, then refused: {refused:?}"
    );
}

/// `git -C root`, with every repo-local variable a caller exported removed,
/// since `GIT_DIR` and friends override `-C` (improvise-53zz).
fn git(root: &Path) -> std::process::Command {
    let names = std::process::Command::new("git")
        .args(["rev-parse", "--local-env-vars"])
        .output()
        .expect("git runs");
    let mut git = std::process::Command::new("git");
    for name in String::from_utf8(names.stdout).expect("UTF-8").lines() {
        git.env_remove(name);
    }
    git.arg("-C").arg(root);
    git
}

/// A scratch repository, so each way of shipping a document is set up for real.
fn scratch_repo() -> tempfile::TempDir {
    let dir = tempfile::tempdir().expect("a temp dir");
    run_git(dir.path(), &["init", "-q"]);
    dir
}

fn run_git(root: &Path, args: &[&str]) {
    let status = git(root)
        .env("GIT_CONFIG_GLOBAL", "/dev/null")
        .env("GIT_CONFIG_NOSYSTEM", "1")
        .args(args)
        .status()
        .expect("git runs");
    assert!(status.success(), "git {args:?} failed");
}

fn write(root: &Path, rel: &str, text: &str) {
    let path = root.join(rel);
    std::fs::create_dir_all(path.parent().expect("a parent")).expect("dirs");
    std::fs::write(path, text).expect("writes");
}

fn walked(root: &Path, rel: &str) -> bool {
    shipped_documents(root).contains(&root.join(rel))
}

/// improvise-c0aj: one test per way of shipping a document that reading the
/// root `.gitignore` missed. Evidence: `context/test-evidence/tui.md`.
#[test]
fn a_single_file_un_ignore_is_walked() {
    let repo = scratch_repo();
    let root = repo.path();
    write(root, ".gitignore", "*.improv\n!web/demo.improv\n");
    write(root, "web/demo.improv", "x");
    run_git(root, &["add", ".gitignore", "web/demo.improv"]);
    assert!(walked(root, "web/demo.improv"));
}

#[test]
fn a_gzipped_document_is_walked() {
    let repo = scratch_repo();
    let root = repo.path();
    write(root, ".gitignore", "*.improv\n");
    write(root, "docs/model.improv.gz", "x");
    run_git(root, &["add", ".gitignore", "docs/model.improv.gz"]);
    assert!(walked(root, "docs/model.improv.gz"));
}

#[test]
fn a_document_un_ignored_by_a_nested_gitignore_is_walked() {
    let repo = scratch_repo();
    let root = repo.path();
    write(root, ".gitignore", "*.improv\n");
    write(root, "harness/.gitignore", "!keep.improv\n");
    write(root, "harness/keep.improv", "x");
    run_git(
        root,
        &[
            "add",
            ".gitignore",
            "harness/.gitignore",
            "harness/keep.improv",
        ],
    );
    assert!(walked(root, "harness/keep.improv"));
}

/// An empty walk would pass every per-document assertion vacuously, so a
/// directory git cannot read must stop the test instead.
#[test]
#[should_panic(expected = "git ls-files failed")]
fn a_directory_that_is_not_a_checkout_fails_loudly() {
    let not_a_repo = tempfile::tempdir().expect("a temp dir");
    shipped_documents(not_a_repo.path());
}

#[test]
fn a_force_added_document_is_walked() {
    let repo = scratch_repo();
    let root = repo.path();
    write(root, ".gitignore", "*.improv\n");
    write(root, "secret/forced.improv", "x");
    run_git(root, &["add", ".gitignore"]);
    run_git(root, &["add", "-f", "secret/forced.improv"]);
    assert!(walked(root, "secret/forced.improv"));
}

/// Runs one of this binary's own tests in a child process with `env` added,
/// since the environment is what is under test and threads share ours.
fn rerun_with_env(test: &str, env: &[(&str, &Path)]) -> std::process::Output {
    let mut child = std::process::Command::new(std::env::current_exe().expect("test binary"));
    child.args([test, "--exact", "--nocapture"]);
    for (name, value) in env {
        child.env(name, value);
    }
    let out = child.output().expect("the test binary runs");
    let stdout = String::from_utf8_lossy(&out.stdout);
    assert!(
        stdout.contains("running 1 test"),
        "{test} did not run: {stdout}"
    );
    out
}

/// improvise-53zz: a hook in a linked worktree exports `GIT_DIR`, which beats
/// `-C`. Evidence: `context/test-evidence/tui.md`.
#[test]
fn a_scratch_repo_ignores_an_inherited_git_dir() {
    let outer = scratch_repo();
    let dot_git = outer.path().join(".git");
    let out = rerun_with_env(
        "a_single_file_un_ignore_is_walked",
        &[
            ("GIT_DIR", &dot_git),
            ("GIT_INDEX_FILE", &dot_git.join("index")),
        ],
    );
    assert!(
        out.status.success(),
        "the shape test fails under an inherited GIT_DIR: {}",
        String::from_utf8_lossy(&out.stdout)
    );
    let staged = git(outer.path())
        .args(["ls-files"])
        .output()
        .expect("git runs");
    assert!(
        staged.stdout.is_empty(),
        "the outer index gained: {}",
        String::from_utf8_lossy(&staged.stdout)
    );
}

/// improvise-53zz: a user's `*.gz` exclude refused the gzip shape test's `add`.
/// Evidence: `context/test-evidence/tui.md`.
#[test]
fn a_scratch_repo_ignores_the_users_global_and_system_excludes() {
    let home = tempfile::tempdir().expect("a temp dir");
    let excludes = home.path().join("ignore");
    std::fs::write(&excludes, "*.gz\n").expect("writes");
    let config = home.path().join("gitconfig");
    let text = format!("[core]\n\texcludesFile = {}\n", excludes.display());
    std::fs::write(&config, text).expect("writes");
    for scope in ["GIT_CONFIG_GLOBAL", "GIT_CONFIG_SYSTEM"] {
        let out = rerun_with_env("a_gzipped_document_is_walked", &[(scope, &config)]);
        assert!(
            out.status.success(),
            "the gzip shape test fails under a `*.gz` exclude in {scope}: {}",
            String::from_utf8_lossy(&out.stdout)
        );
    }
}