curriculum-project-hub/crates/cph-model/tests/load.rs

//! Integration tests for `cph_model::load`, driven by static fixtures under
//! `tests/fixtures/`. The fixtures double as documentation of the ADR-0008
//! on-disk format.

use std::path::PathBuf;

use cph_diag::DiagCode;
use cph_model::load;

/// Absolute path to a fixture engineering-file root.
fn fixture(name: &str) -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("tests/fixtures")
        .join(name)
}

#[test]
fn valid_two_part_lesson_loads_in_order_with_no_errors() {
    let (lesson, diags) = load(&fixture("valid"));

    let lesson = lesson.expect("valid fixture must produce a Lesson");
    assert!(
        diags.is_empty(),
        "valid fixture must have no diagnostics, got: {diags:?}"
    );

    assert_eq!(lesson.project.id, "fixture-valid");
    assert_eq!(lesson.project.name, "valid-2-part");
    assert_eq!(lesson.info.title, "测试课：两个部件");
    // A single-string `author` loads as a one-element list.
    assert_eq!(lesson.info.authors, vec!["范式教育教研组".to_string()]);

    // Parts preserve declared order: segment first, lemma second.
    assert_eq!(lesson.parts.len(), 2);
    assert_eq!(lesson.parts[0].kind, "segment");
    assert_eq!(lesson.parts[0].path, PathBuf::from("segments/intro"));
    assert_eq!(lesson.parts[0].descriptor.kind, "segment");
    assert_eq!(lesson.parts[1].kind, "lemma");
    assert_eq!(lesson.parts[1].path, PathBuf::from("lemmas/young"));
    assert_eq!(lesson.parts[1].descriptor.kind, "lemma");

    // `source` scalar survives on the lemma descriptor; `kind` is removed.
    let scalars = &lesson.parts[1].descriptor.scalars;
    assert_eq!(
        scalars.get("source").and_then(|v| v.as_str()),
        Some("测试引理")
    );
    assert!(scalars.get("kind").is_none());

    // Targets are collected from [targets.*], in declared order.
    assert_eq!(lesson.target_names(), vec!["student", "teacher"]);
    // Empty `[targets.x]` bodies → all-default build config, no diagnostics:
    // single-file artifact at build/<name>.pdf + one typst-compile step.
    for target in &lesson.targets {
        assert_eq!(
            target.artifact,
            cph_model::Artifact::SingleFile {
                filepath: PathBuf::from(format!("build/{}.pdf", target.name)),
            }
        );
        assert_eq!(
            target.steps,
            vec![cph_model::Step::TypstCompile {
                template: PathBuf::from(format!("exports/{}.typ", target.name)),
            }]
        );
    }

    // Descriptor dir is absolute, anchored under the root.
    assert!(lesson.parts[0].descriptor.dir.is_absolute());
    assert_eq!(
        lesson.parts[0].descriptor.dir,
        lesson.root.join("segments/intro")
    );
}

#[test]
fn missing_part_folder_yields_part_path_missing() {
    let (lesson, diags) = load(&fixture("missing-part"));

    // Still produces a Lesson (loader stays best-effort).
    let lesson = lesson.expect("missing-part fixture must still produce a Lesson");
    assert_eq!(lesson.parts.len(), 2, "both parts are recorded for order");

    let missing: Vec<_> = diags
        .iter()
        .filter(|d| d.code == DiagCode::PartPathMissing)
        .collect();
    assert_eq!(
        missing.len(),
        1,
        "exactly one PartPathMissing expected, got diags: {diags:?}"
    );
    assert_eq!(missing[0].severity, cph_diag::Severity::Error);
}

#[test]
fn kind_mismatch_yields_unknown_kind_diagnostic() {
    let (lesson, diags) = load(&fixture("kind-mismatch"));

    let lesson = lesson.expect("kind-mismatch fixture must still produce a Lesson");
    assert_eq!(lesson.parts.len(), 1);

    let mismatch: Vec<_> = diags
        .iter()
        .filter(|d| d.code == DiagCode::UnknownKind)
        .collect();
    assert_eq!(
        mismatch.len(),
        1,
        "exactly one kind-mismatch diagnostic expected, got: {diags:?}"
    );
    assert!(
        mismatch[0].message.contains("segment") && mismatch[0].message.contains("lemma"),
        "message should name both kinds, got: {}",
        mismatch[0].message
    );
}

#[test]
fn malformed_manifest_is_a_hard_failure() {
    let (lesson, diags) = load(&fixture("malformed-manifest"));

    assert!(
        lesson.is_none(),
        "malformed manifest must be a hard failure (None)"
    );
    assert_eq!(diags.len(), 1, "one hard-failure diagnostic expected");
    assert_eq!(diags[0].code, DiagCode::SchemaViolation);
    assert_eq!(diags[0].severity, cph_diag::Severity::Error);
}

#[test]
fn missing_manifest_is_a_hard_failure() {
    // A directory with no manifest.toml at all.
    let (lesson, diags) = load(&fixture("does-not-exist-at-all"));
    assert!(lesson.is_none());
    assert_eq!(diags.len(), 1);
    assert_eq!(diags[0].code, DiagCode::SchemaViolation);
}

#[test]
fn structured_target_configs_parse_into_typed_builds() {
    use cph_model::{Artifact, Step};

    let (lesson, diags) = load(&fixture("target-configs"));
    let lesson = lesson.expect("target-configs fixture must produce a Lesson");
    assert!(
        diags.is_empty(),
        "well-formed target configs must have no diagnostics, got: {diags:?}"
    );

    // An array `author` loads as the ordered author list.
    assert_eq!(
        lesson.info.authors,
        vec!["张老师".to_string(), "李老师".to_string()]
    );

    // Declared order is preserved.
    assert_eq!(lesson.target_names(), vec!["student", "archive", "teacher"]);

    // student: explicit single-file artifact (with filepath) + one
    // typst-compile step (with template).
    let student = &lesson.targets[0];
    assert_eq!(student.name, "student");
    assert_eq!(
        student.artifact,
        Artifact::SingleFile {
            filepath: PathBuf::from("build/student.pdf"),
        }
    );
    assert_eq!(
        student.steps,
        vec![Step::TypstCompile {
            template: PathBuf::from("exports/student.typ"),
        }]
    );

    // archive: file-tree artifact (root + outputs glob) + two ordered steps,
    // a typst-compile followed by a shell step (order preserved).
    let archive = &lesson.targets[1];
    assert_eq!(archive.name, "archive");
    assert_eq!(
        archive.artifact,
        Artifact::FileTree {
            root: PathBuf::from("build/archive"),
            outputs: "**/*.{html,js,json}".to_string(),
        }
    );
    assert_eq!(
        archive.steps,
        vec![
            Step::TypstCompile {
                template: PathBuf::from("exports/archive.typ"),
            },
            Step::Shell {
                run: "npm run build".to_string(),
            },
        ]
    );

    // teacher: empty body → all defaults.
    let teacher = &lesson.targets[2];
    assert_eq!(teacher.name, "teacher");
    assert_eq!(
        teacher.artifact,
        Artifact::SingleFile {
            filepath: PathBuf::from("build/teacher.pdf"),
        }
    );
    assert_eq!(
        teacher.steps,
        vec![Step::TypstCompile {
            template: PathBuf::from("exports/teacher.typ"),
        }]
    );
}

#[test]
fn malformed_target_config_is_non_fatal_with_schema_violations() {
    use cph_model::{Artifact, Step};

    let (lesson, diags) = load(&fixture("bad-target-config"));
    let lesson = lesson.expect("bad-target-config must still produce a Lesson");

    // Both targets survive despite their malformed fields.
    assert_eq!(lesson.target_names(), vec!["student", "teacher"]);

    // Bad `artifact.type` → SchemaViolation, target kept with default artifact.
    let student = &lesson.targets[0];
    assert_eq!(
        student.artifact,
        Artifact::SingleFile {
            filepath: PathBuf::from("build/student.pdf"),
        }
    );

    // Bad step `type` → the step is skipped; the file-tree artifact survives and
    // the empty step list falls back to the default step.
    let teacher = &lesson.targets[1];
    assert_eq!(
        teacher.artifact,
        Artifact::FileTree {
            root: PathBuf::from("build/teacher"),
            outputs: "**/*.html".to_string(),
        }
    );
    assert_eq!(
        teacher.steps,
        vec![Step::TypstCompile {
            template: PathBuf::from("exports/teacher.typ"),
        }]
    );

    let violations: Vec<_> = diags
        .iter()
        .filter(|d| d.code == DiagCode::SchemaViolation)
        .collect();
    assert_eq!(
        violations.len(),
        2,
        "expected one SchemaViolation per malformed field, got: {diags:?}"
    );
    assert!(
        violations.iter().any(|d| d.message.contains("pdf-thing")),
        "a diagnostic should name the bad artifact type, got: {diags:?}"
    );
    assert!(
        violations
            .iter()
            .any(|d| d.message.contains("make-it-nice")),
        "a diagnostic should name the bad step type, got: {diags:?}"
    );
}

// --- `.cph-version` compatibility gate (ADR-0016) ------------------------------

/// The cph version the running CLI was built with — what `.cph-version` must
/// match exactly (ADR-0016's MVP rule).
const CPH_VERSION: &str = env!("CARGO_PKG_VERSION");

/// Write a one-part lesson into a uniquely-created temp dir, optionally with a
/// `.cph-version` file. `TempDir` owns cleanup so parallel tests cannot delete
/// one another's fixture after a timestamp collision.
fn tmp_lesson_with_version(version: Option<&str>) -> tempfile::TempDir {
    let tmp = tempfile::Builder::new()
        .prefix("cph-version-test-")
        .tempdir()
        .unwrap();
    let p = tmp.path();
    std::fs::write(
        p.join("manifest.toml"),
        "[project]\nid = \"v\"\nname = \"v\"\n[info]\ntitle = \"v\"\n[[parts]]\nkind = \"segment\"\npath = \"segments/a\"\n",
    )
    .unwrap();
    let seg = p.join("segments").join("a");
    std::fs::create_dir_all(&seg).unwrap();
    std::fs::write(seg.join("element.toml"), "kind = \"segment\"\n").unwrap();
    std::fs::write(seg.join("textbook.typ"), "t.\n").unwrap();
    if let Some(v) = version {
        std::fs::write(p.join(".cph-version"), v).unwrap();
    }
    tmp
}

#[test]
fn cph_version_matching_is_not_a_diagnostic() {
    let tmp = tmp_lesson_with_version(Some(CPH_VERSION));
    let (_lesson, diags) = load(tmp.path());
    assert!(
        diags.iter().all(|d| d.code != DiagCode::CphVersionMismatch),
        "a matching .cph-version must not warn, got {diags:?}"
    );
}

#[test]
fn cph_version_mismatch_is_an_error_diagnostic() {
    let tmp = tmp_lesson_with_version(Some("99.99.99"));
    let (lesson, diags) = load(tmp.path());
    // The lesson still loads (so other defects could surface), but the
    // mismatch is an error diagnostic — which alone makes it illegal.
    assert!(lesson.is_some(), "a mismatch should not halt loading");
    let mm: Vec<_> = diags
        .iter()
        .filter(|d| d.code == DiagCode::CphVersionMismatch)
        .collect();
    assert_eq!(
        mm.len(),
        1,
        "expected one CphVersionMismatch, got {diags:?}"
    );
    assert!(
        mm[0].message.contains("99.99.99") && mm[0].message.contains(CPH_VERSION),
        "diagnostic should name both versions, got: {}",
        mm[0].message
    );
}

#[test]
fn cph_version_missing_is_skipped() {
    // No `.cph-version` file at all → skipped (ADR-0016 migration period; OPEN).
    let tmp = tmp_lesson_with_version(None);
    let (_lesson, diags) = load(tmp.path());
    assert!(
        diags.iter().all(|d| d.code != DiagCode::CphVersionMismatch),
        "a missing .cph-version must be skipped, got {diags:?}"
    );
}

#[test]
fn cph_version_empty_is_an_error() {
    let tmp = tmp_lesson_with_version(Some("   \n"));
    let (_lesson, diags) = load(tmp.path());
    assert!(
        diags
            .iter()
            .any(|d| d.code == DiagCode::CphVersionMismatch && d.message.contains("empty")),
        "an empty .cph-version should be an error, got {diags:?}"
    );
}