phoebus_os/installer-rs/crates/phoebus-executor/tests/session_script.rs
Phoebus 8a2fce5b18
Some checks are pending
ci / test (push) Waiting to run
feat(desktop): default DMS theme color to Auto
2026-10-02 03:07:12 -07:00

250 lines
9 KiB
Rust

//! Functional test of the generated `phoebus-session-mango` script.
//!
//! Runs the real script against stub `mango`/`dms` binaries so the startup
//! ordering, the Wayland-socket discovery, DMS launch, and helper cleanup are
//! exercised without a physical seat or a Wayland compositor.
use std::path::Path;
use std::process::{Child, Command, Stdio};
use std::time::{Duration, Instant};
use phoebus_core::system::PHOEBUS_MANGO_SESSION_SCRIPT;
fn write_exec(path: &Path, body: &str) {
std::fs::write(path, body).unwrap();
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o755)).unwrap();
}
/// mango stub: creates a real unix socket at $XDG_RUNTIME_DIR/wayland-0 and exits
/// after a moment so the session ends.
const MANGO_OK: &str = r#"#!/bin/sh
echo mango-started >> "$SESSION_TEST_DIR/mango.log"
exec python3 -c 'import os,socket,time; s=socket.socket(socket.AF_UNIX); s.bind(os.path.join(os.environ["XDG_RUNTIME_DIR"],"wayland-0")); s.listen(1); time.sleep(3)'
"#;
/// mango stub that fails before creating the socket.
const MANGO_FAIL: &str = "#!/bin/sh\nexit 1\n";
/// DMS stub: records whether the Wayland socket existed when it started,
/// stores its pid, then sleeps so cleanup has something to kill.
const DMS_STUB: &str = r#"#!/bin/sh
if [ -S "$XDG_RUNTIME_DIR/wayland-0" ]; then s=ok; else s=missing; fi
echo "dms $s wayland_display=${WAYLAND_DISPLAY:-missing}" >> "$SESSION_TEST_DIR/helpers.log"
echo $$ >> "$SESSION_TEST_DIR/helper-pids"
exec sleep 30
"#;
fn wait_timeout(child: &mut Child, secs: u64) -> std::process::ExitStatus {
let deadline = Instant::now() + Duration::from_secs(secs);
loop {
if let Some(status) = child.try_wait().unwrap() {
return status;
}
if Instant::now() >= deadline {
let _ = child.kill();
panic!("session script did not exit within {secs}s");
}
std::thread::sleep(Duration::from_millis(100));
}
}
struct Fixture {
dir: tempfile::TempDir,
script: std::path::PathBuf,
bin: std::path::PathBuf,
runtime: std::path::PathBuf,
}
impl Fixture {
fn new(mango_body: &str) -> Self {
let dir = tempfile::tempdir().unwrap();
let bin = dir.path().join("bin");
let runtime = dir.path().join("runtime");
std::fs::create_dir_all(&bin).unwrap();
std::fs::create_dir_all(&runtime).unwrap();
let script = dir.path().join("phoebus-session-mango");
write_exec(&script, PHOEBUS_MANGO_SESSION_SCRIPT);
write_exec(&bin.join("mango"), mango_body);
write_exec(&bin.join("dms"), DMS_STUB);
Self {
dir,
script,
bin,
runtime,
}
}
fn run(&self) -> (std::process::ExitStatus, String) {
let mut child = Command::new("bash")
.arg(&self.script)
.env_clear()
.env("PATH", format!("{}:/usr/bin:/bin", self.bin.display()))
.env("XDG_RUNTIME_DIR", &self.runtime)
// Skip the dbus-run-session re-exec; the session bus is not what
// this test exercises.
.env("DBUS_SESSION_BUS_ADDRESS", "unix:path=/run/test-bus")
.env("SESSION_TEST_DIR", self.dir.path())
.env("HOME", self.dir.path())
.env("USER", "phoebus")
.stdout(Stdio::null())
.stderr(Stdio::piped())
.spawn()
.unwrap();
let status = wait_timeout(&mut child, 20);
let mut stderr = String::new();
use std::io::Read;
if let Some(mut e) = child.stderr.take() {
let _ = e.read_to_string(&mut stderr);
}
(status, stderr)
}
fn read(&self, name: &str) -> String {
std::fs::read_to_string(self.dir.path().join(name)).unwrap_or_default()
}
}
#[test]
fn helpers_wait_for_the_socket_and_are_reaped() {
let fixture = Fixture::new(MANGO_OK);
let (status, stderr) = fixture.run();
assert!(status.success(), "session failed: {stderr}");
// Mango started and DMS observed the socket and exported WAYLAND_DISPLAY.
let mango_log = fixture.read("mango.log");
assert!(mango_log.contains("mango-started"));
let log = fixture.read("helpers.log");
assert!(log.contains("dms ok"), "helper log: {log:?}");
assert!(
log.contains("wayland_display=wayland-0"),
"helper log: {log:?}"
);
assert!(
!log.contains("missing"),
"a helper raced the socket: {log:?}"
);
// The helpers were killed when mango exited (logout leaves nothing behind).
let pids = fixture.read("helper-pids");
assert!(!pids.trim().is_empty(), "no helper pids recorded");
std::thread::sleep(Duration::from_millis(300));
for pid in pids.lines() {
assert!(
!Path::new(&format!("/proc/{}", pid.trim())).exists(),
"helper {pid} survived logout"
);
}
}
#[test]
fn failure_to_create_the_socket_is_reported() {
let fixture = Fixture::new(MANGO_FAIL);
let (status, stderr) = fixture.run();
assert!(!status.success(), "a dead compositor must fail the session");
assert!(
stderr.contains("mango exited before creating a Wayland socket"),
"{stderr}"
);
assert!(fixture.read("helpers.log").is_empty());
}
#[test]
fn first_login_seeds_wallpaper_folder_and_letter_avatar_without_replacing_choices() {
let fixture = Fixture::new(MANGO_OK);
let wallpapers = fixture.dir.path().join("Pictures/Wallpapers");
std::fs::create_dir_all(&wallpapers).unwrap();
std::fs::write(wallpapers.join("aurora-lagoon.jpg"), b"sample image").unwrap();
let (status, stderr) = fixture.run();
assert!(status.success(), "session failed: {stderr}");
let state = fixture
.dir
.path()
.join(".local/state/DankMaterialShell/session.json");
let cache = fixture
.dir
.path()
.join(".cache/DankMaterialShell/cache.json");
let avatar = fixture.dir.path().join(".face");
let settings = fixture
.dir
.path()
.join(".config/DankMaterialShell/settings.json");
let state_json: serde_json::Value =
serde_json::from_slice(&std::fs::read(&state).unwrap()).unwrap();
let cache_json: serde_json::Value =
serde_json::from_slice(&std::fs::read(&cache).unwrap()).unwrap();
let settings_json: serde_json::Value =
serde_json::from_slice(&std::fs::read(&settings).unwrap()).unwrap();
assert_eq!(settings_json["currentThemeName"], "dynamic");
assert_eq!(settings_json["currentThemeCategory"], "dynamic");
assert_eq!(
state_json["wallpaperPath"],
wallpapers
.join("aurora-lagoon.jpg")
.to_string_lossy()
.as_ref()
);
assert_eq!(
cache_json["wallpaperLastPath"],
wallpapers.to_string_lossy().as_ref()
);
assert_eq!(
cache_json["fileBrowserSettings"]["wallpaper"]["lastPath"],
wallpapers.to_string_lossy().as_ref()
);
assert!(std::fs::read_to_string(&avatar)
.unwrap()
.contains(">P</text>"));
std::fs::write(
&state,
"{\"configVersion\":4,\"wallpaperPath\":\"/chosen/image.jpg\"}",
)
.unwrap();
std::fs::write(&cache, "{\"configVersion\":3,\"wallpaperLastPath\":\"/chosen\",\"fileBrowserSettings\":{\"wallpaper\":{\"lastPath\":\"/chosen\"}}}").unwrap();
std::fs::write(&avatar, b"custom avatar").unwrap();
std::fs::write(
&settings,
r#"{"configVersion":18,"currentThemeName":"purple","currentThemeCategory":"generic"}"#,
)
.unwrap();
std::fs::remove_file(fixture.runtime.join("wayland-0")).unwrap();
let (status, stderr) = fixture.run();
assert!(status.success(), "second session failed: {stderr}");
assert!(fixture
.read(".local/state/DankMaterialShell/session.json")
.contains("/chosen/image.jpg"));
assert!(fixture
.read(".cache/DankMaterialShell/cache.json")
.contains("/chosen"));
assert_eq!(std::fs::read(&avatar).unwrap(), b"custom avatar");
assert!(fixture
.read(".config/DankMaterialShell/settings.json")
.contains("purple"));
}
#[test]
fn missing_theme_choice_is_filled_without_losing_other_dms_settings() {
let fixture = Fixture::new(MANGO_OK);
let wallpapers = fixture.dir.path().join("Pictures/Wallpapers");
std::fs::create_dir_all(&wallpapers).unwrap();
std::fs::write(wallpapers.join("aurora-lagoon.jpg"), b"sample image").unwrap();
let settings = fixture
.dir
.path()
.join(".config/DankMaterialShell/settings.json");
std::fs::create_dir_all(settings.parent().unwrap()).unwrap();
std::fs::write(&settings, r#"{"configVersion":18,"fontSize":15}"#).unwrap();
let (status, stderr) = fixture.run();
assert!(status.success(), "session failed: {stderr}");
let saved: serde_json::Value =
serde_json::from_slice(&std::fs::read(settings).unwrap()).unwrap();
assert_eq!(saved["currentThemeName"], "dynamic");
assert_eq!(saved["currentThemeCategory"], "dynamic");
assert_eq!(saved["fontSize"], 15);
}