//! Coverage of the reference Bash installer's command-line surface. //! //! Every mode and flag accepted by the reference Bash installer (see //! `docs/BASH-MIGRATION.md`) must have a Rust equivalent, or be explicitly //! recorded as intentionally dropped. The test inspects `--help` so it never //! executes an installation or bootstraps OpenCode. use std::path::PathBuf; use std::process::Command; /// Flags that must be present in the Rust CLI. const REQUIRED_FLAGS: &[&str] = &[ "--config", "--plan", "--dry-run", "--install", "--yes", "--luks-passphrase-file", "--user-password-file", "--root-password-file", "--bootstrap-opencode", ]; /// Bash-only surface that is intentionally not ported, with the rationale so a /// future session knows the omission was deliberate. const INTENTIONALLY_DROPPED: &[(&str, &str)] = &[ ( "--backend", "an alias for --plan; the Rust CLI has a single deterministic backend", ), ( "--ui", "UI_BACKEND only selected a dialog/whiptail variant; ratatui needs none", ), ("-y", "clap provides the short form of --yes"), ("--version", "clap provides -V/--version"), ("--help", "clap provides -h/--help"), ]; fn help_text() -> String { let out = Command::new(env!("CARGO_BIN_EXE_phoebus-installer")) .arg("--help") .output() .expect("run phoebus-installer --help"); assert!(out.status.success(), "`--help` must succeed"); String::from_utf8_lossy(&out.stdout).into_owned() } fn manifest_path() -> PathBuf { PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("resources/opencode.manifest") } #[test] fn every_bash_cli_mode_has_a_rust_flag() { let help = help_text(); for flag in REQUIRED_FLAGS { assert!(help.contains(flag), "Rust CLI is missing `{flag}`:\n{help}"); } // The dropped surface is recorded in code, not silently forgotten. for (flag, _reason) in INTENTIONALLY_DROPPED { let _ = flag; } } #[test] fn verify_live_nvidia_accepts_a_complete_payload_and_rejects_an_incomplete_one() { fn touch(path: &std::path::Path) { std::fs::create_dir_all(path.parent().unwrap()).unwrap(); std::fs::write(path, vec![0u8; 8192]).unwrap(); } fn complete(root: &std::path::Path) { let kver = "6.16.7-amd64"; touch(&root.join(format!("boot/vmlinuz-{kver}"))); let modules = root.join(format!("lib/modules/{kver}")); std::fs::create_dir_all(&modules).unwrap(); let mut dep = Vec::new(); for m in ["nvidia", "nvidia_modeset", "nvidia_uvm", "nvidia_drm"] { touch(&modules.join(format!("updates/dkms/{m}.ko"))); dep.push(format!("updates/dkms/{m}.ko:")); } std::fs::write(modules.join("modules.dep"), dep.join("\n")).unwrap(); for lib in [ "libnvidia-glcore.so.550.163.01", "libGLX_nvidia.so.0", "libnvidia-egl-gbm.so.1", "libnvidia-egl-wayland.so.1", ] { touch(&root.join("usr/lib/x86_64-linux-gnu").join(lib)); } touch(&root.join("usr/bin/nvidia-smi")); touch(&root.join("usr/share/egl/egl_external_platform.d/15_nvidia_gbm.json")); touch(&root.join("usr/share/egl/egl_external_platform.d/10_nvidia_wayland.json")); touch(&root.join("usr/lib/firmware/nvidia/550.163.01/gsp.bin")); touch(&root.join("usr/local/bin/phoebus-nvidia-load")); let conf = root.join("etc/modprobe.d/phoebus-nvidia.conf"); std::fs::create_dir_all(conf.parent().unwrap()).unwrap(); std::fs::write(&conf, b"blacklist nouveau\noptions nvidia_drm modeset=1\n").unwrap(); } let run = |root: &std::path::Path| { Command::new(env!("CARGO_BIN_EXE_phoebus-installer")) .arg("--verify-live-nvidia") .arg(root) .args([ "--nvidia-version", "550.163.01", "--nvidia-flavor", "proprietary", ]) .output() .expect("run --verify-live-nvidia") }; let dir = tempfile::tempdir().unwrap(); complete(dir.path()); let out = run(dir.path()); assert!( out.status.success(), "{}", String::from_utf8_lossy(&out.stderr) ); let record = std::fs::read_to_string(dir.path().join("etc/phoebus/nvidia")).unwrap(); assert!(record.contains("driver_version=550.163.01")); assert!(record.contains("kernel_version=6.16.7-amd64")); let broken = tempfile::tempdir().unwrap(); complete(broken.path()); std::fs::remove_file(broken.path().join("usr/bin/nvidia-smi")).unwrap(); let out = run(broken.path()); assert!( !out.status.success(), "a missing component must fail the gate" ); assert_eq!(out.status.code(), Some(1)); } #[test] fn live_gpu_plan_reflects_the_fixture_and_the_fail_safe_cmdline() { fn write_device(root: &std::path::Path, addr: &str, class: &str, vendor: &str, device: &str) { let d = root.join("bus/pci/devices").join(addr); std::fs::create_dir_all(&d).unwrap(); std::fs::write(d.join("class"), class).unwrap(); std::fs::write(d.join("vendor"), vendor).unwrap(); std::fs::write(d.join("device"), device).unwrap(); } let run = |sysfs: &std::path::Path, cmdline: &str| -> String { let out = Command::new(env!("CARGO_BIN_EXE_phoebus-installer")) .arg("--live-gpu-plan") .arg("--sysfs-root") .arg(sysfs) .arg("--kernel-cmdline") .arg(cmdline) .output() .expect("run --live-gpu-plan"); assert!(out.status.success()); String::from_utf8_lossy(&out.stdout).into_owned() }; let supported = tempfile::tempdir().unwrap(); write_device( supported.path(), "0000:01:00.0", "0x030000", "0x10de", "0x2482", ); let plan = run(supported.path(), "quiet splash"); assert!(plan.contains("action=load-nvidia"), "{plan}"); assert!(plan.contains("device=10de:2482 Ampere"), "{plan}"); // Blackwell cannot be driven by the bundled 550 branch. let blackwell = tempfile::tempdir().unwrap(); write_device( blackwell.path(), "0000:01:00.0", "0x030000", "0x10de", "0x2b85", ); let plan = run(blackwell.path(), ""); assert!(plan.contains("action=nouveau-fallback"), "{plan}"); assert!(plan.contains("unclaimed=10de:2b85 Blackwell"), "{plan}"); // Fail-safe graphics wins even with a supported GPU present. let plan = run(supported.path(), "quiet nomodeset"); assert!(plan.contains("action=disabled"), "{plan}"); let plan = run(supported.path(), "quiet phoebus.nvidia=off"); assert!(plan.contains("action=disabled"), "{plan}"); // No NVIDIA display device -> leave auto-detection alone. let none = tempfile::tempdir().unwrap(); write_device(none.path(), "0000:00:02.0", "0x030000", "0x8086", "0x9a60"); let plan = run(none.path(), ""); assert!(plan.contains("action=no-device"), "{plan}"); } #[test] fn relocated_opencode_manifest_is_pinned_and_complete() { let path = manifest_path(); assert!(path.is_file(), "missing {}", path.display()); let text = std::fs::read_to_string(&path).expect("read opencode manifest"); let version = text .lines() .find_map(|line| line.strip_prefix("VERSION=")) .expect("manifest pins a VERSION"); assert!(version.starts_with('v'), "unexpected version `{version}`"); for key in ["x86_64.url", "x86_64.sha256", "x86_64.binary"] { assert!(text.contains(key), "manifest is missing `{key}`"); } let sha = text .lines() .find_map(|line| line.strip_prefix("x86_64.sha256=")) .expect("x86_64 checksum"); assert_eq!( sha.len(), 64, "x86_64 checksum must be a SHA-256 hex digest" ); assert!( sha.chars().all(|c| c.is_ascii_hexdigit()), "x86_64 checksum must be hex" ); assert!( sha.chars().any(|c| c != '0'), "x86_64 checksum must not be a placeholder" ); }