AILang/crates/ail/tests/roundtrip_cli.rs

//! CLI-pipeline idempotency gate: every `examples/*.ail` survives
//! `ail parse | ail render | ail parse` with byte identity on the
//! canonical JSON output.
//!
//! This is the user-facing-surface defence line. Crate-internal
//! roundtrip tests in `ailang-surface` cover the same property
//! at the library level; this test additionally protects the
//! `ail parse` and `ail render` CLI wrappers from drift (output
//! formatting, exit codes, stdout framing).
//!
//! Pure reader: the test writes only to a `tempfile::TempDir`
//! that lives outside the repo and is cleaned up by Drop. No
//! committed content is mutated.
//!
//! Retired iter form-a.1 T9:
//! `cli_render_then_parse_preserves_canonical_bytes_on_every_fixture`
//! (walked `.ail.json` corpus; replaced by the corpus-flipped
//! `cli_parse_then_render_then_parse_is_idempotent` below, added in
//! T1). The `list_json_fixtures` helper and `roundtrip_one` helper
//! were the only consumers of `.ail.json` walks and are retired
//! alongside.

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

fn ail_bin() -> &'static str {
    env!("CARGO_BIN_EXE_ail")
}

fn workspace_root() -> PathBuf {
    let manifest_dir = env!("CARGO_MANIFEST_DIR");
    Path::new(manifest_dir).parent().unwrap().parent().unwrap().to_path_buf()
}

fn examples_dir() -> PathBuf {
    workspace_root().join("examples")
}

/// Fixtures that intentionally do NOT parse — the `#55` cutover
/// reject corpus. These are negative fixtures whose whole point is
/// that the parser rejects them, so `parse∘render∘parse` is not a
/// meaningful property for them and the harness must skip them.
///
/// Scope is deliberately minimal: only fixtures that fail at the
/// PARSE stage belong here. The other `*reject*.ail` cutover
/// fixtures (`borrow_return_reject`, `borrow_value_reject`,
/// `own_return_provenance_reject`, the `embed_export_*_rejected`
/// set, …) parse cleanly and are rejected only later at CHECK time,
/// so they round-trip fine and are NOT excluded.
///
/// - `bare_slot_reject.ail`: a bare fn-type slot with no mode. The
///   binary-ParamMode parser rejects it ("fn-type slot requires a
///   mode: write (own T) or (borrow T)").
const NON_PARSEABLE_FIXTURES: &[&str] = &["bare_slot_reject.ail"];

fn list_ail_fixtures() -> Vec<PathBuf> {
    let dir = examples_dir();
    let mut paths: Vec<PathBuf> = std::fs::read_dir(&dir)
        .unwrap_or_else(|e| panic!("read_dir({}): {e}", dir.display()))
        .filter_map(|entry| entry.ok())
        .map(|e| e.path())
        .filter(|p| {
            p.file_name()
                .and_then(|n| n.to_str())
                .map(|n| {
                    n.ends_with(".ail") && !NON_PARSEABLE_FIXTURES.contains(&n)
                })
                .unwrap_or(false)
        })
        .collect();
    paths.sort();
    paths
}

/// CLI-pipeline idempotency (post-form-a-default-authoring §C3): for
/// every `.ail` fixture, the user-facing pipeline
/// `ail parse <ail> | ail render | ail parse` is byte-identical
/// to direct `ail parse <ail>`. Pins drift internal tests cannot see.
#[test]
fn cli_parse_then_render_then_parse_is_idempotent() {
    let fixtures = list_ail_fixtures();
    assert!(
        !fixtures.is_empty(),
        "no .ail fixtures found under {}",
        examples_dir().display()
    );

    let tmpdir = tempfile::TempDir::new().expect("create tempdir");
    let mut checked = 0usize;
    let mut failures = Vec::<String>::new();

    for ail_path in &fixtures {
        // Direct parse → JSON tempfile.
        let json1 = tmpdir.path().join(format!("v1_{checked}.ail.json"));
        let parse1 = Command::new(ail_bin())
            .args([
                "parse",
                ail_path.to_str().unwrap(),
                "-o",
                json1.to_str().unwrap(),
            ])
            .output()
            .expect("spawn ail parse #1");
        if !parse1.status.success() {
            failures.push(format!(
                "{}: first ail parse exit={:?}\nstderr: {}",
                ail_path.display(),
                parse1.status.code(),
                String::from_utf8_lossy(&parse1.stderr),
            ));
            checked += 1;
            continue;
        }

        // Render that JSON → .ail tempfile.
        let ail_round = tmpdir.path().join(format!("round_{checked}.ail"));
        let rendered = Command::new(ail_bin())
            .args(["render", json1.to_str().unwrap()])
            .output()
            .expect("spawn ail render");
        if !rendered.status.success() {
            failures.push(format!(
                "{}: ail render exit={:?}\nstderr: {}",
                ail_path.display(),
                rendered.status.code(),
                String::from_utf8_lossy(&rendered.stderr),
            ));
            checked += 1;
            continue;
        }
        std::fs::write(&ail_round, &rendered.stdout)
            .expect("write ail_round tempfile");

        // Re-parse → second JSON tempfile.
        let json2 = tmpdir.path().join(format!("v2_{checked}.ail.json"));
        let parse2 = Command::new(ail_bin())
            .args([
                "parse",
                ail_round.to_str().unwrap(),
                "-o",
                json2.to_str().unwrap(),
            ])
            .output()
            .expect("spawn ail parse #2");
        if !parse2.status.success() {
            failures.push(format!(
                "{}: second ail parse exit={:?}\nstderr: {}",
                ail_path.display(),
                parse2.status.code(),
                String::from_utf8_lossy(&parse2.stderr),
            ));
            checked += 1;
            continue;
        }

        // Assert the two canonical JSONs are byte-equal.
        let b1 = std::fs::read(&json1).expect("read json1");
        let b2 = std::fs::read(&json2).expect("read json2");
        if b1 != b2 {
            let s1 = String::from_utf8_lossy(&b1).into_owned();
            let s2 = String::from_utf8_lossy(&b2).into_owned();
            failures.push(format!(
                "{}: CLI parse|render|parse non-idempotent.\n  v1: {s1}\n  v2: {s2}",
                ail_path.display(),
            ));
        }
        checked += 1;
    }

    if !failures.is_empty() {
        panic!(
            "CLI parse|render|parse non-idempotent on {} of {} fixtures:\n{}",
            failures.len(),
            checked,
            failures.join("\n\n")
        );
    }
    assert!(checked > 0, "no .ail fixtures found");
    eprintln!("CLI parse|render|parse idempotent for {checked} fixtures");
}