feat(test-harness): add Composer .test fixture parser and runner

Foundation for porting Composer's installer integration fixtures.
Parser covers the 13 sections of InstallerTest.php; runner sets up a
tempdir from COMPOSER/LOCK/INSTALLED and invokes the mozart binary.
No fixtures are migrated in this commit.

5 files changed, 416 insertions, 0 deletions

diff --git a/Cargo.lock b/Cargo.lock
index e7778c3..bf4b5d6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1209,6 +1209,16 @@ dependencies = [
 ]
 
 [[package]]
+name = "mozart-test-harness"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "regex",
+ "serde_json",
+ "tempfile",
+]
+
+[[package]]
 name = "mozart-vcs"
 version = "0.1.0"
 dependencies = [
diff --git a/crates/mozart-test-harness/Cargo.toml b/crates/mozart-test-harness/Cargo.toml
new file mode 100644
index 0000000..61b9109
--- /dev/null
+++ b/crates/mozart-test-harness/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "mozart-test-harness"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+anyhow.workspace = true
+regex.workspace = true
+serde_json.workspace = true
+tempfile.workspace = true
diff --git a/crates/mozart-test-harness/src/lib.rs b/crates/mozart-test-harness/src/lib.rs
new file mode 100644
index 0000000..f8fa2b3
--- /dev/null
+++ b/crates/mozart-test-harness/src/lib.rs
@@ -0,0 +1,12 @@
+//! Harness for Composer's `.test` integration fixture format.
+//!
+//! See `composer/tests/Composer/Test/Fixtures/installer/SAMPLE` and
+//! `composer/tests/Composer/Test/InstallerTest.php` for the reference
+//! implementation. This crate provides the parser and a binary-invoking
+//! runner; actual `.test` fixtures and tests live elsewhere.
+
+mod parser;
+mod runner;
+
+pub use parser::{ParsedTest, parse_test_file, parse_test_str};
+pub use runner::{RunResult, run_test};
diff --git a/crates/mozart-test-harness/src/parser.rs b/crates/mozart-test-harness/src/parser.rs
new file mode 100644
index 0000000..dbc71ae
--- /dev/null
+++ b/crates/mozart-test-harness/src/parser.rs
@@ -0,0 +1,322 @@
+use anyhow::{Context, Result, bail};
+use std::collections::HashMap;
+use std::fs;
+use std::path::Path;
+
+const VALID_SECTIONS: &[&str] = &[
+    "TEST",
+    "CONDITION",
+    "COMPOSER",
+    "LOCK",
+    "INSTALLED",
+    "RUN",
+    "EXPECT-LOCK",
+    "EXPECT-INSTALLED",
+    "EXPECT-OUTPUT",
+    "EXPECT-OUTPUT-OPTIMIZED",
+    "EXPECT-EXIT-CODE",
+    "EXPECT-EXCEPTION",
+    "EXPECT",
+];
+
+const REQUIRED_SECTIONS: &[&str] = &["TEST", "COMPOSER", "RUN", "EXPECT"];
+
+#[derive(Debug, Clone)]
+pub struct ParsedTest {
+    pub test: String,
+    pub condition: Option<String>,
+    pub composer: String,
+    pub lock: Option<String>,
+    pub installed: Option<String>,
+    pub run: String,
+    pub expect_lock: Option<String>,
+    pub expect_installed: Option<String>,
+    pub expect_output: Option<String>,
+    pub expect_output_optimized: Option<String>,
+    pub expect_exit_code: Option<i32>,
+    pub expect_exception: Option<String>,
+    pub expect: String,
+}
+
+pub fn parse_test_file(path: &Path) -> Result<ParsedTest> {
+    let content =
+        fs::read_to_string(path).with_context(|| format!("failed to read {}", path.display()))?;
+    parse_test_str(&content).with_context(|| format!("failed to parse {}", path.display()))
+}
+
+pub fn parse_test_str(content: &str) -> Result<ParsedTest> {
+    let mut sections = split_sections(content)?;
+
+    for required in REQUIRED_SECTIONS {
+        if !sections.contains_key(*required) {
+            bail!("missing required section: --{required}--");
+        }
+    }
+
+    let mut take = |key: &str| sections.remove(key);
+
+    let test = take("TEST").unwrap();
+    let composer = take("COMPOSER").unwrap();
+    let run = take("RUN").unwrap();
+    let expect = take("EXPECT").unwrap();
+
+    let expect_exit_code = match take("EXPECT-EXIT-CODE") {
+        Some(s) => Some(
+            s.trim()
+                .parse::<i32>()
+                .with_context(|| format!("invalid EXPECT-EXIT-CODE: {s:?}"))?,
+        ),
+        None => None,
+    };
+
+    Ok(ParsedTest {
+        test,
+        condition: take("CONDITION"),
+        composer,
+        lock: take("LOCK"),
+        installed: take("INSTALLED"),
+        run,
+        expect_lock: take("EXPECT-LOCK"),
+        expect_installed: take("EXPECT-INSTALLED"),
+        expect_output: take("EXPECT-OUTPUT"),
+        expect_output_optimized: take("EXPECT-OUTPUT-OPTIMIZED"),
+        expect_exit_code,
+        expect_exception: take("EXPECT-EXCEPTION"),
+        expect,
+    })
+}
+
+fn split_sections(content: &str) -> Result<HashMap<String, String>> {
+    let header_re = regex::Regex::new(r"^--([A-Z][A-Z-]*)--$").unwrap();
+
+    let mut sections: HashMap<String, String> = HashMap::new();
+    let mut current_section: Option<String> = None;
+    let mut current_body = String::new();
+
+    for line in content.split_inclusive('\n') {
+        let trimmed = line.trim_end_matches('\n').trim_end_matches('\r');
+        if let Some(caps) = header_re.captures(trimmed) {
+            let name = caps[1].to_string();
+            if !VALID_SECTIONS.contains(&name.as_str()) {
+                bail!("unknown section: --{name}--");
+            }
+            if let Some(prev) = current_section.take() {
+                let body = trim_trailing_newlines(&current_body).to_string();
+                if sections.insert(prev.clone(), body).is_some() {
+                    bail!("duplicate section: --{prev}--");
+                }
+                current_body.clear();
+            }
+            current_section = Some(name);
+        } else if current_section.is_some() {
+            current_body.push_str(line);
+        }
+    }
+
+    if let Some(name) = current_section.take() {
+        let body = trim_trailing_newlines(&current_body).to_string();
+        if sections.insert(name.clone(), body).is_some() {
+            bail!("duplicate section: --{name}--");
+        }
+    }
+
+    Ok(sections)
+}
+
+fn trim_trailing_newlines(s: &str) -> &str {
+    s.trim_end_matches(['\n', '\r'])
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_minimal_required_sections() {
+        let input = "\
+--TEST--
+A simple test
+--COMPOSER--
+{\"require\": {\"a/a\": \"1.0.0\"}}
+--RUN--
+install
+--EXPECT--
+Installing a/a (1.0.0)
+";
+        let t = parse_test_str(input).unwrap();
+        assert_eq!(t.test, "A simple test");
+        assert_eq!(t.composer, "{\"require\": {\"a/a\": \"1.0.0\"}}");
+        assert_eq!(t.run, "install");
+        assert_eq!(t.expect, "Installing a/a (1.0.0)");
+        assert!(t.lock.is_none());
+        assert!(t.installed.is_none());
+        assert!(t.expect_output.is_none());
+        assert!(t.expect_exit_code.is_none());
+    }
+
+    #[test]
+    fn parses_all_sections() {
+        let input = "\
+--TEST--
+desc
+--CONDITION--
+true
+--COMPOSER--
+{}
+--LOCK--
+{\"packages\": []}
+--INSTALLED--
+[]
+--RUN--
+update --with-dependencies a/a
+--EXPECT-LOCK--
+{\"packages\": []}
+--EXPECT-INSTALLED--
+[]
+--EXPECT-OUTPUT--
+some output
+--EXPECT-OUTPUT-OPTIMIZED--
+optimized output
+--EXPECT-EXIT-CODE--
+2
+--EXPECT-EXCEPTION--
+SomeException
+--EXPECT--
+op log
+";
+        let t = parse_test_str(input).unwrap();
+        assert_eq!(t.test, "desc");
+        assert_eq!(t.condition.as_deref(), Some("true"));
+        assert_eq!(t.composer, "{}");
+        assert_eq!(t.lock.as_deref(), Some("{\"packages\": []}"));
+        assert_eq!(t.installed.as_deref(), Some("[]"));
+        assert_eq!(t.run, "update --with-dependencies a/a");
+        assert_eq!(t.expect_lock.as_deref(), Some("{\"packages\": []}"));
+        assert_eq!(t.expect_installed.as_deref(), Some("[]"));
+        assert_eq!(t.expect_output.as_deref(), Some("some output"));
+        assert_eq!(
+            t.expect_output_optimized.as_deref(),
+            Some("optimized output")
+        );
+        assert_eq!(t.expect_exit_code, Some(2));
+        assert_eq!(t.expect_exception.as_deref(), Some("SomeException"));
+        assert_eq!(t.expect, "op log");
+    }
+
+    #[test]
+    fn preserves_internal_newlines_in_body() {
+        let input = "\
+--TEST--
+multi
+--COMPOSER--
+{
+    \"name\": \"a/a\"
+}
+--RUN--
+install
+--EXPECT--
+line1
+line2
+line3
+";
+        let t = parse_test_str(input).unwrap();
+        assert_eq!(t.composer, "{\n    \"name\": \"a/a\"\n}");
+        assert_eq!(t.expect, "line1\nline2\nline3");
+    }
+
+    #[test]
+    fn rejects_unknown_section() {
+        let input = "\
+--TEST--
+x
+--MYSTERY--
+y
+--COMPOSER--
+{}
+--RUN--
+install
+--EXPECT--
+z
+";
+        let err = parse_test_str(input).unwrap_err();
+        assert!(err.to_string().contains("unknown section"), "{err}");
+    }
+
+    #[test]
+    fn rejects_missing_required_section() {
+        let input = "\
+--TEST--
+x
+--COMPOSER--
+{}
+--EXPECT--
+z
+";
+        let err = parse_test_str(input).unwrap_err();
+        assert!(err.to_string().contains("RUN"), "{err}");
+    }
+
+    #[test]
+    fn rejects_duplicate_section() {
+        let input = "\
+--TEST--
+first
+--COMPOSER--
+{}
+--RUN--
+install
+--TEST--
+second
+--EXPECT--
+z
+";
+        let err = parse_test_str(input).unwrap_err();
+        assert!(err.to_string().contains("duplicate"), "{err}");
+    }
+
+    #[test]
+    fn rejects_invalid_exit_code() {
+        let input = "\
+--TEST--
+x
+--COMPOSER--
+{}
+--RUN--
+install
+--EXPECT-EXIT-CODE--
+not-a-number
+--EXPECT--
+z
+";
+        let err = parse_test_str(input).unwrap_err();
+        assert!(err.to_string().contains("EXPECT-EXIT-CODE"), "{err}");
+    }
+
+    #[test]
+    fn skips_text_before_first_section() {
+        let input = "\
+this is a header comment
+that should be ignored
+--TEST--
+x
+--COMPOSER--
+{}
+--RUN--
+install
+--EXPECT--
+z
+";
+        let t = parse_test_str(input).unwrap();
+        assert_eq!(t.test, "x");
+    }
+
+    #[test]
+    fn handles_crlf_line_endings() {
+        let input =
+            "--TEST--\r\nx\r\n--COMPOSER--\r\n{}\r\n--RUN--\r\ninstall\r\n--EXPECT--\r\nz\r\n";
+        let t = parse_test_str(input).unwrap();
+        assert_eq!(t.test, "x");
+        assert_eq!(t.composer, "{}");
+        assert_eq!(t.expect, "z");
+    }
+}
diff --git a/crates/mozart-test-harness/src/runner.rs b/crates/mozart-test-harness/src/runner.rs
new file mode 100644
index 0000000..e041cd7
--- /dev/null
+++ b/crates/mozart-test-harness/src/runner.rs
@@ -0,0 +1,62 @@
+use anyhow::{Context, Result};
+use std::path::Path;
+use std::process::Command;
+use tempfile::TempDir;
+
+use crate::parser::ParsedTest;
+
+/// Outcome of running a parsed `.test` against the `mozart` binary.
+///
+/// The temp directory is kept alive in this struct so callers can inspect
+/// files written by the run; it is removed when `RunResult` is dropped.
+pub struct RunResult {
+    pub working_dir: TempDir,
+    pub stdout: String,
+    pub stderr: String,
+    pub exit_code: i32,
+    pub final_lock: Option<String>,
+    pub final_installed: Option<String>,
+}
+
+/// Set up a temp project from the parsed test, invoke `mozart` with the
+/// `--RUN--` command, and capture the result.
+pub fn run_test(test: &ParsedTest, mozart_bin: &Path) -> Result<RunResult> {
+    let working_dir = TempDir::new().context("failed to create tempdir")?;
+    let root = working_dir.path();
+
+    std::fs::write(root.join("composer.json"), &test.composer)
+        .context("failed to write composer.json")?;
+
+    if let Some(lock) = &test.lock {
+        std::fs::write(root.join("composer.lock"), lock)
+            .context("failed to write composer.lock")?;
+    }
+
+    if let Some(installed) = &test.installed {
+        let vendor_composer = root.join("vendor").join("composer");
+        std::fs::create_dir_all(&vendor_composer)
+            .context("failed to create vendor/composer dir")?;
+        std::fs::write(vendor_composer.join("installed.json"), installed)
+            .context("failed to write installed.json")?;
+    }
+
+    let args: Vec<&str> = test.run.split_whitespace().collect();
+    let output = Command::new(mozart_bin)
+        .args(&args)
+        .current_dir(root)
+        .output()
+        .with_context(|| format!("failed to invoke {}", mozart_bin.display()))?;
+
+    let final_lock = std::fs::read_to_string(root.join("composer.lock")).ok();
+    let final_installed =
+        std::fs::read_to_string(root.join("vendor").join("composer").join("installed.json")).ok();
+
+    Ok(RunResult {
+        working_dir,
+        stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
+        stderr: String::from_utf8_lossy(&output.stderr).into_owned(),
+        exit_code: output.status.code().unwrap_or(-1),
+        final_lock,
+        final_installed,
+    })
+}