AILang/crates/ailang-surface/tests/round_trip.rs

//! Round-trip gate for the form-(A) projection.
//!
//! Two complementary checks over `examples/`:
//!
//! 1. `print_then_parse_round_trips_every_fixture`: for every
//!    `examples/*.ail.json` fixture, load → `print` → `parse` →
//!    canonical bytes; assert byte-equal to original.
//!
//! 2. `every_ailx_fixture_matches_its_json_counterpart`: for every
//!    `examples/*.ailx` fixture, parse → canonical bytes; if a
//!    same-stem `.ail.json` counterpart exists, assert canonical-byte
//!    equality against it. The `.ailx` side is the human/AI authoring
//!    ground-truth — fixtures must be writeable without going through
//!    the printer and still match the JSON-AST.
//!
//! Both tests gather fixtures dynamically via `read_dir`; no hardcoded
//! lists. The tests are pure readers — they do not write into the
//! working tree.

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

fn examples_dir() -> PathBuf {
    // `CARGO_MANIFEST_DIR` is the surface crate root; examples live two
    // levels up.
    let crate_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    crate_dir.parent().unwrap().parent().unwrap().join("examples")
}

fn list_json_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| {
                    // Round-trip every fixture. The 22b.1/22b.2/22b.3 filter
                    // was retired in 22b.4a once the Form-A parser+printer
                    // arms for ClassDef / InstanceDef landed.
                    n.ends_with(".ail.json")
                })
                .unwrap_or(false)
        })
        .collect();
    paths.sort();
    paths
}

#[test]
fn print_then_parse_round_trips_every_fixture() {
    let fixtures = list_json_fixtures();
    assert!(
        !fixtures.is_empty(),
        "no .ail.json fixtures found under {}",
        examples_dir().display()
    );

    let mut failures = Vec::<String>::new();
    let mut passed = 0usize;
    for path in &fixtures {
        match round_trip_one(path) {
            Ok(()) => passed += 1,
            Err(msg) => failures.push(format!("{}: {msg}", path.display())),
        }
    }
    if !failures.is_empty() {
        panic!(
            "round-trip failed for {} of {} fixtures (passed: {}):\n{}",
            failures.len(),
            fixtures.len(),
            passed,
            failures.join("\n")
        );
    }
    eprintln!("round-trip ok for {passed} fixtures");
}

fn round_trip_one(path: &Path) -> Result<(), String> {
    let original = ailang_core::load_module(path).map_err(|e| format!("load: {e}"))?;
    let text = ailang_surface::print(&original);
    let parsed = ailang_surface::parse(&text)
        .map_err(|e| format!("re-parse failed: {e}\n--- printed text ---\n{text}"))?;
    let bytes_orig = ailang_core::canonical::to_bytes(&original);
    let bytes_round = ailang_core::canonical::to_bytes(&parsed);
    if bytes_orig != bytes_round {
        let s_orig = String::from_utf8_lossy(&bytes_orig).into_owned();
        let s_round = String::from_utf8_lossy(&bytes_round).into_owned();
        return Err(format!(
            "canonical bytes differ.\noriginal: {s_orig}\nround:    {s_round}"
        ));
    }
    Ok(())
}

fn list_ailx_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(".ailx"))
                .unwrap_or(false)
        })
        .collect();
    paths.sort();
    paths
}

#[test]
fn every_ailx_fixture_matches_its_json_counterpart() {
    let fixtures = list_ailx_fixtures();
    assert!(
        !fixtures.is_empty(),
        "no .ailx fixtures found under {}",
        examples_dir().display()
    );

    let mut failures = Vec::<String>::new();
    let mut paired = 0usize;
    let mut parse_only = 0usize;

    for ailx_path in &fixtures {
        let text = match std::fs::read_to_string(ailx_path) {
            Ok(t) => t,
            Err(e) => {
                failures.push(format!("{}: read failed: {e}", ailx_path.display()));
                continue;
            }
        };
        let parsed = match ailang_surface::parse(&text) {
            Ok(m) => m,
            Err(e) => {
                failures.push(format!("{}: parse failed: {e}", ailx_path.display()));
                continue;
            }
        };

        // Same-stem counterpart lookup. `<stem>.ailx` → `<stem>.ail.json`.
        let stem = ailx_path
            .file_name()
            .and_then(|n| n.to_str())
            .and_then(|n| n.strip_suffix(".ailx"))
            .unwrap_or("");
        let json_path = ailx_path.with_file_name(format!("{stem}.ail.json"));

        if !json_path.exists() {
            // Spec: parse success alone is sufficient for `.ailx` files
            // without a JSON counterpart. (Today: none expected.)
            parse_only += 1;
            continue;
        }

        let original = match ailang_core::load_module(&json_path) {
            Ok(m) => m,
            Err(e) => {
                failures.push(format!(
                    "{}: load_module({}) failed: {e}",
                    ailx_path.display(),
                    json_path.display()
                ));
                continue;
            }
        };
        let bytes_orig = ailang_core::canonical::to_bytes(&original);
        let bytes_parsed = ailang_core::canonical::to_bytes(&parsed);
        if bytes_orig != bytes_parsed {
            let s_orig = String::from_utf8_lossy(&bytes_orig).into_owned();
            let s_round = String::from_utf8_lossy(&bytes_parsed).into_owned();
            failures.push(format!(
                "{} vs {}: canonical bytes differ.\noriginal: {s_orig}\nparsed:   {s_round}",
                ailx_path.display(),
                json_path.display()
            ));
            continue;
        }
        paired += 1;
    }

    if !failures.is_empty() {
        panic!(
            "{} of {} .ailx fixture(s) failed cross-check (paired ok: {}, parse-only: {}):\n{}",
            failures.len(),
            fixtures.len(),
            paired,
            parse_only,
            failures.join("\n\n")
        );
    }
    eprintln!(
        ".ailx cross-check ok ({} paired, {} parse-only)",
        paired, parse_only
    );
}