feat: complete native execution and Steam discovery

2026-07-18 20:11:52 -04:00
parent 514f87dacb
commit bc0090c63d
42 changed files with 6403 additions and 97 deletions
@@ -0,0 +1,263 @@
+//! Isolated CLI contract tests for Phase 1 machine output.
+
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use serde_json::Value;
+
+fn kiln(arguments: &[&str]) -> std::process::Output {
+    Command::new(env!("CARGO_BIN_EXE_kiln"))
+        .args(arguments)
+        .output()
+        .expect("kiln runs")
+}
+
+struct TestDirectory(PathBuf);
+
+impl TestDirectory {
+    fn new() -> Self {
+        let path = std::env::temp_dir().join(format!(
+            "kiln-cli-test-{}-{}",
+            std::process::id(),
+            std::thread::current().name().unwrap_or("unnamed")
+        ));
+        let _ = fs::remove_dir_all(&path);
+        fs::create_dir(&path).expect("test directory");
+        Self(path)
+    }
+
+    fn run(&self, arguments: &[&str]) -> std::process::Output {
+        Command::new(env!("CARGO_BIN_EXE_kiln"))
+            .args(arguments)
+            .env("XDG_CONFIG_HOME", self.0.join("config"))
+            .env("XDG_STATE_HOME", self.0.join("state"))
+            .env("HOME", self.0.join("home"))
+            .output()
+            .expect("kiln runs")
+    }
+
+    fn add_game(&self, id: &str, name: &str, executable: &Path) {
+        let manifests = self.0.join("config/kiln/native");
+        let install = self.0.join("games").join(id);
+        fs::create_dir_all(&manifests).expect("manifest directory");
+        fs::create_dir_all(&install).expect("install directory");
+        fs::write(
+            manifests.join(format!("{id}.toml")),
+            format!(
+                "schema_version = 1\nid = \"{id}\"\nname = \"{name}\"\ninstall_path = \"{}\"\nexecutable = \"{}\"\narguments = [\"native-output\"]\n",
+                install.display(),
+                executable.display()
+            ),
+        )
+        .expect("manifest");
+    }
+
+    fn add_steam_game(&self, app_id: &str, name: &str) {
+        let root = self.0.join("home/.local/share/Steam");
+        let steamapps = root.join("steamapps");
+        let install = steamapps.join("common").join(name);
+        fs::create_dir_all(&install).unwrap();
+        fs::write(
+            steamapps.join("libraryfolders.vdf"),
+            format!(
+                "\"libraryfolders\" {{ \"0\" {{ \"path\" \"{}\" }} }}",
+                root.display()
+            ),
+        )
+        .unwrap();
+        fs::write(
+            steamapps.join(format!("appmanifest_{app_id}.acf")),
+            format!(
+                "\"AppState\" {{ \"appid\" \"{app_id}\" \"name\" \"{name}\" \"StateFlags\" \"4\" \"installdir\" \"{name}\" }}"
+            ),
+        )
+        .unwrap();
+    }
+}
+
+impl Drop for TestDirectory {
+    fn drop(&mut self) {
+        let _ = fs::remove_dir_all(&self.0);
+    }
+}
+
+#[test]
+fn doctor_reports_every_phase_one_schema() {
+    let output = kiln(&["doctor", "--json"]);
+    assert!(output.status.success());
+    let json: Value = serde_json::from_slice(&output.stdout).expect("doctor JSON");
+    assert_eq!(json["status"], "ok");
+    for contract in [
+        "game_record",
+        "installation_registry",
+        "launch_plan",
+        "error",
+        "configuration",
+    ] {
+        let expected = if contract == "launch_plan" { 2 } else { 1 };
+        assert_eq!(json["contracts"][contract], expected);
+    }
+}
+
+#[test]
+fn json_invalid_arguments_return_structured_error() {
+    let output = kiln(&["unknown", "--json"]);
+    assert_eq!(output.status.code(), Some(2));
+    let json: Value = serde_json::from_slice(&output.stderr).expect("error JSON");
+    assert_eq!(json["schema_version"], 1);
+    assert_eq!(json["code"], "invalid-input");
+}
+
+#[test]
+fn unavailable_frontend_returns_unsupported_capability() {
+    let output = kiln(&["frontend", "sync", "--json"]);
+    assert_eq!(output.status.code(), Some(2));
+    let json: Value = serde_json::from_slice(&output.stderr).expect("error JSON");
+    assert_eq!(json["code"], "unsupported-capability");
+    assert_eq!(json["capability"], "frontend");
+}
+
+#[test]
+fn native_cli_completes_discovery_search_plan_execution_and_logging() {
+    let directory = TestDirectory::new();
+    directory.add_game("sample", "Sample Game", Path::new("/usr/bin/printf"));
+
+    let list = directory.run(&["list", "--json"]);
+    assert!(list.status.success());
+    let records: Value = serde_json::from_slice(&list.stdout).expect("list JSON");
+    assert_eq!(records[0]["id"], "native:sample");
+
+    let search = directory.run(&["search", "sample", "--json"]);
+    assert!(search.status.success());
+    let records: Value = serde_json::from_slice(&search.stdout).expect("search JSON");
+    assert_eq!(records.as_array().unwrap().len(), 1);
+
+    let info = directory.run(&["info", "native:sample", "--json"]);
+    assert!(info.status.success());
+    let record: Value = serde_json::from_slice(&info.stdout).expect("info JSON");
+    assert_eq!(record["runtime"], "native");
+
+    let scan = directory.run(&["scan", "--provider", "native", "--no-cache", "--json"]);
+    assert!(scan.status.success());
+    let result: Value = serde_json::from_slice(&scan.stdout).expect("scan JSON");
+    assert_eq!(result["discovered"], 1);
+
+    let dry_run = directory.run(&["launch", "Sample Game", "--dry-run", "--json"]);
+    assert!(dry_run.status.success());
+    let plan: Value = serde_json::from_slice(&dry_run.stdout).expect("plan JSON");
+    assert_eq!(plan["command"]["arguments"][0], "native-output");
+
+    let launch = directory.run(&["launch", "native:sample", "--json"]);
+    assert!(launch.status.success());
+    let outcome: Value = serde_json::from_slice(&launch.stdout).expect("outcome JSON");
+    assert_eq!(outcome["exit_code"], 0);
+    assert!(
+        fs::read_to_string(directory.0.join("state/kiln/logs/native.log"))
+            .expect("launch log")
+            .contains("native-output")
+    );
+}
+
+#[test]
+fn malformed_native_manifest_returns_structured_failure() {
+    let directory = TestDirectory::new();
+    let manifests = directory.0.join("config/kiln/native");
+    fs::create_dir_all(&manifests).unwrap();
+    fs::write(manifests.join("bad.toml"), "schema_version = 99\n").unwrap();
+    let output = directory.run(&["list", "--json"]);
+    assert_eq!(output.status.code(), Some(2));
+    let error: Value = serde_json::from_slice(&output.stderr).expect("error JSON");
+    assert!(matches!(
+        error["code"].as_str(),
+        Some("invalid-input" | "unsupported-version")
+    ));
+}
+
+#[test]
+fn config_defaults_validate_set_and_explain_are_consistent() {
+    let directory = TestDirectory::new();
+    let defaults = directory.run(&["config", "defaults"]);
+    assert!(defaults.status.success());
+    assert!(
+        String::from_utf8(defaults.stdout)
+            .unwrap()
+            .contains("schema_version = 1")
+    );
+
+    let validate = directory.run(&["config", "validate", "--json"]);
+    assert!(validate.status.success());
+    let validated: Value = serde_json::from_slice(&validate.stdout).unwrap();
+    assert_eq!(validated["exists"], false);
+
+    let runtime = directory.run(&["config", "set", "runtime", "umu", "--json"]);
+    assert!(runtime.status.success());
+    let backend = directory.run(&["config", "set", "session-backend", "wayland", "--json"]);
+    assert!(backend.status.success());
+    let configuration = fs::read_to_string(directory.0.join("config/kiln/config.toml")).unwrap();
+    assert!(configuration.contains("# Project Kiln private configuration"));
+    assert!(configuration.contains("runtime = \"umu\""));
+    assert!(configuration.contains("session_backend = \"wayland\""));
+
+    let explain = directory.run(&["config", "explain", "--json"]);
+    assert!(explain.status.success());
+    let resolved: Value = serde_json::from_slice(&explain.stdout).unwrap();
+    assert_eq!(resolved["runtime"]["value"], "umu");
+    assert_eq!(resolved["runtime"]["source"]["tier"], "global-user");
+    assert_eq!(resolved["session_backend"]["value"], "wayland");
+}
+
+#[test]
+fn invalid_configuration_and_failed_launch_are_structured() {
+    let directory = TestDirectory::new();
+    fs::create_dir_all(directory.0.join("config/kiln")).unwrap();
+    fs::write(
+        directory.0.join("config/kiln/config.toml"),
+        "schema_version = 99\n",
+    )
+    .unwrap();
+    let invalid = directory.run(&["config", "validate", "--json"]);
+    assert_eq!(invalid.status.code(), Some(2));
+    let error: Value = serde_json::from_slice(&invalid.stderr).unwrap();
+    assert_eq!(error["code"], "invalid-input");
+
+    fs::remove_file(directory.0.join("config/kiln/config.toml")).unwrap();
+    directory.add_game("failure", "Failure", Path::new("/usr/bin/false"));
+    let failed = directory.run(&["launch", "native:failure", "--json"]);
+    assert_eq!(failed.status.code(), Some(2));
+    let error: Value = serde_json::from_slice(&failed.stderr).unwrap();
+    assert_eq!(error["code"], "launch-failed");
+}
+
+#[test]
+fn steam_provider_cli_discovers_searches_and_resolves_without_launching() {
+    let directory = TestDirectory::new();
+    directory.add_steam_game("620", "Portal 2");
+
+    let list = directory.run(&["list", "--provider", "steam", "--json"]);
+    assert!(list.status.success());
+    let records: Value = serde_json::from_slice(&list.stdout).unwrap();
+    assert_eq!(records[0]["id"], "steam:620");
+    assert_eq!(records[0]["runtime"], "steam-managed");
+    assert_eq!(records[0]["client_required"], true);
+
+    let search = directory.run(&["search", "portal", "--provider", "steam", "--json"]);
+    assert!(search.status.success());
+    assert_eq!(
+        serde_json::from_slice::<Value>(&search.stdout).unwrap()[0]["name"],
+        "Portal 2"
+    );
+
+    let info = directory.run(&["info", "steam:620", "--json"]);
+    assert!(info.status.success());
+    assert_eq!(
+        serde_json::from_slice::<Value>(&info.stdout).unwrap()["store"],
+        "steam"
+    );
+
+    let scan = directory.run(&["scan", "--provider", "steam", "--json"]);
+    assert!(scan.status.success());
+    let result: Value = serde_json::from_slice(&scan.stdout).unwrap();
+    assert_eq!(result["provider"], "steam");
+    assert_eq!(result["discovered"], 1);
+}