yog 0.0.2

//! End-to-end drive of the W8/bl-2930 `bl` multiplex arm through
//! `yog::multiplex::dispatch` — `yog bl <argv…>` IS balls, over the FULL verb
//! surface: the W9 `prime`/`sync`/`install` refusal is deleted, so this file
//! proves the whole ball rung against a real store on disk — `prime` founds
//! the checkout and binds the plugin chain to the world's own shims, `create`
//! seals a ball, `claim` cuts the code worktree (spawning the bound
//! `bl-delivery`/`bl-tracker` shims as real subprocesses), and `close`
//! delivers the tagged squash to the project's `main`.
//!
//! **This test binary owns its process environment** (the
//! `tests/multiplex_lernie.rs` precedent): the arm is a *binding* — it reads
//! `$XDG_STATE_HOME`/`$XDG_DATA_HOME`/`$HOME`/`$USER` live at the process
//! boundary, none injectable through `dispatch`'s argv surface — so this file
//! mutates its own env, lawful exactly here: every `tests/*.rs` is a separate
//! process and the one `#[test]` below is this binary's only test.
//!
//! **The plugin spawns re-enter the real yog binary.** In-process, the shims
//! `ensure_tools` writes would target *this test binary* (`current_exe`), so
//! the `BL_DELIVERY_BINARY`/`BL_TRACKER_BINARY` seams point at wrapper
//! scripts that exec `$CARGO_BIN_EXE_yog <namespace> "$@"` — the claim's
//! plugin chain then runs the built yog's own multiplex arms, which is the
//! production shape (a shim whose target is yog) with the target made
//! explicit.

#![allow(clippy::unwrap_used)]

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

use yog::multiplex::dispatch;

// git vars a hook-invoked test may inherit. This binary scrubs them from its
// OWN env rather than a child's — the balls it drives runs in-process — but the
// list is `yog::git_env`'s, the one the spawn sites use.
use yog::git_env::INHERITED as INHERITED_GIT_ENV;

fn set(key: &str, value: &Path) {
    // SAFETY: single-threaded — this binary runs exactly one #[test], and no
    // other thread exists to read the env concurrently (module doc).
    unsafe { std::env::set_var(key, value) };
}

fn argv(parts: &[&str]) -> Vec<String> {
    parts.iter().map(|s| (*s).to_string()).collect()
}

/// A wrapper program answering a sibling plugin's contract by exec'ing the
/// built yog under that namespace (module doc).
fn plugin_wrapper(dir: &Path, namespace: &str) -> PathBuf {
    use std::os::unix::fs::PermissionsExt;
    let path = dir.join(namespace);
    fs::write(
        &path,
        format!(
            "#!/bin/sh\nexec '{}' '{namespace}' \"$@\"\n",
            env!("CARGO_BIN_EXE_yog")
        ),
    )
    .unwrap();
    fs::set_permissions(&path, fs::Permissions::from_mode(0o755)).unwrap();
    path
}

/// The scratch global gitconfig: identity for the store commits balls seals,
/// and the wall against every other ambient global setting.
fn fixture_gitconfig(dir: &Path) -> PathBuf {
    let path = dir.join("gitconfig");
    fs::write(
        &path,
        "[user]\n\tname = Tester\n\temail = t@test.invalid\n[commit]\n\tgpgsign = false\n",
    )
    .unwrap();
    path
}

fn git(dir: &Path, args: &[&str]) -> String {
    let out = yog::git_env::git()
        .current_dir(dir)
        .args(args)
        .output()
        .unwrap();
    assert!(
        out.status.success(),
        "git {args:?}: {}",
        String::from_utf8_lossy(&out.stderr)
    );
    String::from_utf8(out.stdout).unwrap()
}

/// The one dir entry of `dir` (the percent-encoded clone key, the worktree id
/// dir, …) — asserting there is exactly one.
fn sole_child(dir: &Path) -> PathBuf {
    let mut entries: Vec<_> = fs::read_dir(dir)
        .unwrap()
        .map(|e| e.unwrap().path())
        .collect();
    assert_eq!(
        entries.len(),
        1,
        "one entry under {}: {entries:?}",
        dir.display()
    );
    entries.remove(0)
}

/// bl-52ed — a **discovery probe** (an argv that is exactly the flag) reads
/// balls' interface, never the world: the arm's shim converge is skipped, so
/// each probe answers 0 and `world` — the anchor's yog root — stays absent.
fn probes_answer_and_found_nothing(world: &Path) {
    for probe in ["--help", "-h", "--skill"] {
        assert_eq!(dispatch(&argv(&["yog", "bl", probe])), Some(0), "{probe}");
        assert!(!world.exists(), "{probe} founded {}", world.display());
    }
}

/// An unusable anchor is a failed converge: the shims are every verb's
/// precondition (a `prime` binds them as siblings), so a tools dir that cannot
/// exist reports and fails (1) before balls runs at all — while a probe, which
/// needs no shim, still answers 0 (bl-52ed: help must not depend on a world
/// being writable). Anchoring `$XDG_DATA_HOME` inside a regular file makes the
/// dir uncreatable (ENOTDIR) — the `tests/multiplex_lernie.rs` idiom.
fn an_unusable_anchor_fails_every_verb_but_a_probe(tmp: &Path) {
    let blocked = tmp.join("not-a-dir");
    fs::write(&blocked, "").unwrap();
    set("XDG_DATA_HOME", &blocked.join("xdg-data"));
    assert_eq!(dispatch(&argv(&["yog", "bl", "--skill", "prime"])), Some(1));
    assert_eq!(dispatch(&argv(&["yog", "bl", "--help"])), Some(0));
}

#[test]
fn the_bl_arm_runs_the_whole_rung_on_the_embedded_balls() {
    let tmp = tempfile::TempDir::new().unwrap();
    for var in INHERITED_GIT_ENV {
        // SAFETY: as `set` — one test, one thread.
        unsafe { std::env::remove_var(var) };
    }
    for var in [
        "BL_BINARY",
        "LERNIE_BINARY",
        "BZ_BINARY",
        "YOG_NAME",
        "BALLS_CLOCK",
    ] {
        // SAFETY: as `set` — the arm must run the default (self-multiplex)
        // resolution, not a machine-local override or identity.
        unsafe { std::env::remove_var(var) };
    }
    let bin = tmp.path().join("bin");
    fs::create_dir(&bin).unwrap();
    set("BL_DELIVERY_BINARY", &plugin_wrapper(&bin, "bl-delivery"));
    set("BL_TRACKER_BINARY", &plugin_wrapper(&bin, "bl-tracker"));
    set("HOME", &tmp.path().join("home"));
    set("XDG_DATA_HOME", &tmp.path().join("data"));
    set("XDG_STATE_HOME", &tmp.path().join("state"));
    set("USER", Path::new("rung-actor"));
    set("GIT_CONFIG_GLOBAL", &fixture_gitconfig(tmp.path()));
    set("GIT_CONFIG_SYSTEM", Path::new("/dev/null"));

    // bl-52ed — **help reads the interface, never the world**, and this is the
    // first thing the binary does because every verb below materializes the
    // world it must not have touched. Before this, `yog bl --help` wrote six
    // shims under the fresh anchor — and on a read-only root failed with yog's
    // converge error *instead of* printing help.
    probes_answer_and_found_nothing(&tmp.path().join("data").join("yog"));

    // The project repo the store binds to, and the arm's cwd (balls'
    // invocation path is where `bl` runs).
    let proj = tmp.path().join("proj");
    fs::create_dir(&proj).unwrap();
    git(&proj, &["init", "-q", "-b", "main"]);
    fs::write(proj.join("README.md"), "seed\n").unwrap();
    git(&proj, &["add", "-A"]);
    git(&proj, &["commit", "-qm", "seed"]);
    std::env::set_current_dir(&proj).unwrap();
    // Re-read the invocation path from the source balls reads it from. balls
    // keys its store — and bl-delivery mirrors its territory — on the
    // directory the process runs in, which the kernel (`getcwd`) hands back
    // fully *resolved*: on macOS the tempdir's `/var/folders/…` is a symlink
    // to `/private/var/folders/…`, so bl-delivery mirrors the `/private/…`
    // spelling while `tmp.path()` still says `/var/…`. Deriving the expected
    // paths from the same source keeps both sides in one spelling on every
    // platform (a no-op on Linux, where nothing resolves away).
    let proj = std::env::current_dir().unwrap();

    // The W12 slice/exit plumbing the unit tests can no longer drive without
    // writing shims under the ambient anchor: balls' own exits ride back.
    assert_eq!(dispatch(&argv(&["yog", "bl", "--skill"])), Some(0));
    assert_eq!(dispatch(&argv(&["yog", "bl"])), Some(2));
    assert_eq!(dispatch(&argv(&["yog", "bl", "no-such-verb"])), Some(2));
    // bl-2930: the former W9 refusals are balls' own verbs — their `--skill`
    // docs print (exit 0), no yog guard interposed.
    for verb in ["prime", "sync", "install"] {
        assert_eq!(
            dispatch(&argv(&["yog", "bl", "--skill", verb])),
            Some(0),
            "{verb}"
        );
    }

    // `prime` — founds the checkout AND binds the plugin chain: the arm hands
    // balls `world/tools/bl` as the running executable, so the seed's sibling
    // rule finds the `bl-delivery`/`bl-tracker` shims beside it.
    assert_eq!(
        dispatch(&argv(&["yog", "bl", "prime", "--as", "seam"])),
        Some(0)
    );
    let tools = tmp.path().join("data/yog/world/tools");
    for shim in ["bl", "lernie", "bz", "bl-delivery", "bl-tracker"] {
        assert!(tools.join(shim).is_file(), "shim {shim} converged");
    }
    let clone = sole_child(&tmp.path().join("state/balls/clones"));
    assert!(clone.join("config").is_dir(), "landing founded");
    for plugin in ["bl-delivery", "bl-tracker"] {
        // The landing checkout (`<clone>/config`) holds the config tree, so
        // the gitignored binding symlinks live at `config/plugins/bin/`.
        let bound = fs::read_link(clone.join("config/config/plugins/bin").join(plugin)).unwrap();
        assert_eq!(
            bound,
            tools.join(plugin),
            "{plugin} bound to the world shim"
        );
    }

    // `create` — one ball, sealed into the store checkout.
    assert_eq!(
        dispatch(&argv(&["yog", "bl", "create", "rung ball", "--as", "seam"])),
        Some(0)
    );
    let mut balls_md: Vec<_> = fs::read_dir(clone.join("tasks/tasks"))
        .unwrap()
        .map(|e| e.unwrap().path())
        .filter(|p| p.extension().is_some_and(|e| e == "md"))
        .collect();
    assert_eq!(balls_md.len(), 1, "one sealed ball: {balls_md:?}");
    let task = balls_md.remove(0);
    let id = task.file_stem().unwrap().to_str().unwrap().to_string();

    // `claim` — cuts the code worktree through the bound bl-delivery shim (a
    // real subprocess chain: symlink → shim → yog's plugin arm).
    assert_eq!(
        dispatch(&argv(&["yog", "bl", "claim", &id, "--as", "seam"])),
        Some(0)
    );
    let territory = tmp.path().join("state/balls/plugins/bl-delivery");
    let worktree = territory.join(proj.strip_prefix("/").unwrap()).join(&id);
    assert!(
        worktree.join("README.md").is_file(),
        "worktree materialized at {}",
        worktree.display()
    );

    // `close` — delivers the worktree's diff as the tagged squash on `main`
    // and archives the ball (absence is the record).
    fs::write(worktree.join("work.txt"), "delivered\n").unwrap();
    assert_eq!(
        dispatch(&argv(&["yog", "bl", "close", &id, "--as", "seam"])),
        Some(0)
    );
    let subject = git(&proj, &["log", "-1", "--format=%s", "main"]);
    assert!(
        subject.contains(&format!("[{id}]")),
        "delivery tag on main: {subject}"
    );
    assert!(!task.exists(), "closed ball's file is gone");
    let delivered = git(&proj, &["show", "main:work.txt"]);
    assert_eq!(delivered, "delivered\n");

    an_unusable_anchor_fails_every_verb_but_a_probe(tmp.path());
}