#![cfg(target_os = "linux")]
mod common;
use common::{TempDir, write};
use fmm_core::{
app_dirs::{self, Kind},
discovery, download,
install::{Disk, FileOps},
linux, paths, settings,
};
use std::{
collections::HashMap,
fs,
os::unix::fs::{MetadataExt, PermissionsExt, symlink},
path::Path,
process::Command,
sync::{Arc, Barrier},
};
fn env(home: &Path) -> HashMap<String, String> {
HashMap::from([("HOME".into(), home.to_string_lossy().into_owned())])
}
#[test]
fn xdg_defaults_invalid_bases_and_independent_overrides() {
let dir = TempDir::new();
let mut e = env(&dir.0);
let kinds = [
(
Kind::Settings,
"XDG_CONFIG_HOME",
"FMM_SETTINGS_DIR",
".config",
"",
),
(
Kind::Metadata,
"XDG_DATA_HOME",
"FMM_METADATA_DIR",
".local/share",
"metadata",
),
(Kind::Cache, "XDG_CACHE_HOME", "FMM_CACHE_DIR", ".cache", ""),
];
for (kind, xdg, override_key, fallback, suffix) in kinds {
let expected = dir
.0
.join(fallback)
.join("werry/factoriomodmanager")
.join(suffix);
assert_eq!(app_dirs::directory(&e, kind).unwrap(), expected);
for value in ["", "relative"] {
e.insert(xdg.into(), value.into());
assert_eq!(app_dirs::directory(&e, kind).unwrap(), expected);
}
e.insert(xdg.into(), dir.0.join("xdg").to_string_lossy().into_owned());
assert_eq!(
app_dirs::directory(&e, kind).unwrap(),
dir.0.join("xdg/werry/factoriomodmanager").join(suffix)
);
e.insert(
override_key.into(),
dir.0.join(override_key).to_string_lossy().into_owned(),
);
assert_eq!(
app_dirs::directory(&e, kind).unwrap(),
dir.0.join(override_key)
);
e.insert(override_key.into(), "relative".into());
assert!(app_dirs::directory(&e, kind).is_err());
e.remove(override_key);
e.remove(xdg);
assert!(app_dirs::directory(&HashMap::new(), kind).is_err());
}
assert_eq!(fs::read_dir(&dir.0).unwrap().count(), 0);
}
#[test]
fn config_paths_macros_comments_sections_portable_and_failures() {
let dir = TempDir::new();
let install = dir.0.join("game");
let home = dir.0.join("home");
let e = env(&home);
write(
install.join("config-path.cfg"),
" # comment\r\n config-path = __PATH__system-write-data__/config ; comment\r\n use-system-read-write-data-directories = true\r\n",
);
write(
home.join(".factorio/config/config.ini"),
"[path]\r\n read-data = __PATH__system-read-data__\r\n write-data = __PATH__system-write-data__\r\n[other]\nwrite-data=/wrong\n",
);
assert_eq!(
paths::resolve_user_dir(&install, &e).unwrap(),
home.join(".factorio")
);
write(
install.join("config-path.cfg"),
"use-system-read-write-data-directories=false\nconfig-path=__PATH__executable__/../../config\n",
);
for (value, expected) in [
("__PATH__executable__/../..", install.clone()),
("__PATH__system-write-data__", install.clone()),
("__PATH__system-read-data__", install.join("data")),
] {
write(
install.join("config/config.ini"),
format!("[path]\nwrite-data={value}\n"),
);
assert_eq!(paths::resolve_user_dir(&install, &e).unwrap(), expected);
}
for value in ["relative", "", "__PATH__unknown__/mods"] {
write(
install.join("config/config.ini"),
format!("[path]\nwrite-data={value}\n"),
);
assert!(paths::resolve_user_dir(&install, &e).is_err());
}
write(
install.join("config-path.cfg"),
"use-system-read-write-data-directories=perhaps",
);
assert!(paths::resolve_user_dir(&install, &e).is_err());
write(
install.join("config-path.cfg"),
"use-system-read-write-data-directories=true",
);
assert!(paths::resolve_user_dir(&install, &HashMap::new()).is_err());
}
#[test]
fn vdf_structure_comments_escapes_malformed_and_app_ids() {
let dir = TempDir::new();
let path = dir.0.join("spaces é \"quote\"");
let quote = serde_json::to_string(path.to_str().unwrap()).unwrap();
assert_eq!(
discovery::library_paths(&format!(
"// \"1\" \"/bogus\"\n\"libraryfolders\" {{ \"0\" {quote} \"1\" {{ \"path\" {quote} \"apps\" {{ \"427520\" \"/not-a-library\" }} }} }}"
)),
vec![path]
);
for text in [
"\"libraryfolders\" { \"1\" \"/unterminated",
"\"libraryfolders\" { \"1\" \"/valid\"",
"\"apps\" { \"1\" \"/bogus\" }",
"\"libraryfolders\" { \"1\" \"relative\" }",
] {
assert!(discovery::library_paths(text).is_empty());
}
}
#[test]
fn discovery_aliases_case_distinction_flatpak_standalone_and_empty_installs() {
let dir = TempDir::new();
let e = env(&dir.0);
let steam = dir.0.join(".local/share/Steam");
let other = dir.0.join("Library");
let lower = dir.0.join("library");
let game = |root: &Path| {
let p = root.join("steamapps/common/Factorio");
write(p.join("data/base/info.json"), r#"{"version":"2.0.77"}"#);
p
};
let a = game(&steam);
let b = game(&other);
let c = game(&lower);
write(
steam.join("steamapps/libraryfolders.vdf"),
format!(
"\"libraryfolders\" {{ \"1\" \"{}\" \"2\" \"{}\" }}",
other.display(),
lower.display()
),
);
fs::create_dir_all(dir.0.join(".steam")).unwrap();
symlink(&steam, dir.0.join(".steam/steam")).unwrap();
symlink(&steam, dir.0.join(".steam/root")).unwrap();
let flat = dir.0.join(".var/app/com.valvesoftware.Steam");
let f = game(&flat.join(".local/share/Steam"));
write(flat.join(".factorio/mods/mod-list.json"), r#"{"mods":[]}"#);
write(
dir.0.join("factorio/data/base/info.json"),
r#"{"version":"2.0.77"}"#,
);
let detected = discovery::detect(&e);
for p in [&a, &b, &c, &f, &dir.0.join("factorio")] {
assert!(detected.installs.contains(p));
}
assert_eq!(
detected
.installs
.iter()
.filter(|p| fs::canonicalize(p).unwrap() == fs::canonicalize(&a).unwrap())
.count(),
1
);
assert!(detected.data.contains(&flat.join(".factorio")));
let empty = dir.0.join("empty");
fs::create_dir_all(empty.join("steamapps/common/Factorio")).unwrap();
assert!(
discovery::detect_with_roots(&HashMap::new(), &[empty])
.installs
.is_empty()
);
assert!(discovery::detect(&HashMap::new()).data.is_empty());
assert!(!dir.0.join(".factorio").exists());
}
#[test]
fn native_no_replace_files_folders_dangling_links_and_race() {
let dir = TempDir::new();
for folder in [false, true] {
let a = dir.0.join("a");
let b = dir.0.join("b");
if folder {
write(a.join("work"), b"owner work");
} else {
write(&a, b"zip bytes");
}
Disk.rename(&a, &b).unwrap();
Disk.rename(&b, &a).unwrap();
write(&b, b"occupied");
assert!(Disk.rename(&a, &b).is_err());
assert_eq!(fs::read(&b).unwrap(), b"occupied");
fs::remove_file(&b).unwrap();
fs::create_dir(&b).unwrap();
assert!(Disk.rename(&a, &b).is_err());
fs::remove_dir(&b).unwrap();
symlink(dir.0.join("missing"), &b).unwrap();
assert!(Disk.rename(&a, &b).is_err());
assert!(fs::symlink_metadata(&b).unwrap().file_type().is_symlink());
fs::remove_file(&b).unwrap();
if folder {
assert_eq!(fs::read(a.join("work")).unwrap(), b"owner work");
fs::remove_dir_all(a).unwrap();
} else {
assert_eq!(fs::read(&a).unwrap(), b"zip bytes");
fs::remove_file(a).unwrap();
}
}
let barrier = Arc::new(Barrier::new(2));
let destination = dir.0.join("race");
std::thread::scope(|scope| {
let handles: Vec<_> = (0..2)
.map(|i| {
let barrier = barrier.clone();
let destination = &destination;
let source = dir.0.join(format!("source{i}"));
write(&source, [i]);
scope.spawn(move || {
barrier.wait();
(i, source.clone(), Disk.rename(&source, destination).is_ok())
})
})
.collect();
let results: Vec<_> = handles.into_iter().map(|h| h.join().unwrap()).collect();
assert_eq!(results.iter().filter(|r| r.2).count(), 1);
for (i, source, won) in results {
assert_eq!(
fs::read(if won { &destination } else { &source }).unwrap(),
[i]
);
}
});
}
#[test]
fn cross_device_backup_move_refuses_without_losing_payload() {
let dir = TempDir::new();
// /tmp is tmpfs here; HOME filesystem is only used to allocate an isolated temp directory.
let other = std::env::var_os("FMM_TEST_SECOND_TEMP").map(std::path::PathBuf::from);
let Some(other) = other else {
eprintln!(
"UNKNOWN: set FMM_TEST_SECOND_TEMP to an isolated directory on a second filesystem"
);
return;
};
assert_ne!(
fs::metadata(&dir.0).unwrap().dev(),
fs::metadata(&other).unwrap().dev()
);
let a = dir.0.join("mods/a.zip");
write(&a, b"source");
let b = other.join("destination");
assert!(Disk.rename(&a, &b).is_err());
assert_eq!(fs::read(&a).unwrap(), b"source");
assert!(!b.exists());
}
#[test]
fn trash_children_use_only_isolated_xdg_homes() {
for mode in ["normal", "kde-755", "unavailable", "relative", "symlink"] {
let dir = TempDir::new();
let output = Command::new(std::env::current_exe().unwrap())
.args(["--exact", "trash_child", "--nocapture"])
.env("FMM_TRASH_CHILD_MODE", mode)
.env("FMM_TRASH_CHILD_ROOT", &dir.0)
.env("XDG_DATA_HOME", dir.0.join("xdg"))
.env("HOME", dir.0.join("home"))
.output()
.unwrap();
assert!(
output.status.success(),
"mode {mode}\n{}\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
}
}
#[test]
fn trash_child() {
let Ok(mode) = std::env::var("FMM_TRASH_CHILD_MODE") else {
return;
};
let root = std::path::PathBuf::from(std::env::var_os("FMM_TRASH_CHILD_ROOT").unwrap());
assert!(root.starts_with(std::env::temp_dir()));
let xdg = std::path::PathBuf::from(std::env::var_os("XDG_DATA_HOME").unwrap());
let trash = xdg.join("Trash");
let source = root.join("mods/a é % space.zip");
write(&source, b"zip bytes");
match mode.as_str() {
"relative" => {
// Child-only mutation: cannot affect parallel tests or the real Trash.
unsafe {
std::env::set_var("XDG_DATA_HOME", "relative");
}
assert!(Disk.trash(&source).is_err());
assert_eq!(fs::read(source).unwrap(), b"zip bytes");
}
"unavailable" => {
write(&trash, b"not a directory");
assert!(Disk.trash(&source).is_err());
assert_eq!(fs::read(source).unwrap(), b"zip bytes");
}
"symlink" => {
let link = root.join("mods/link");
symlink(&source, &link).unwrap();
assert!(Disk.trash(&link).is_err());
assert_eq!(fs::read(source).unwrap(), b"zip bytes");
}
"normal" | "kde-755" => {
if mode == "kde-755" {
for dir in [&trash, &trash.join("files"), &trash.join("info")] {
fs::create_dir_all(dir).unwrap();
fs::set_permissions(dir, fs::Permissions::from_mode(0o755)).unwrap();
}
}
Disk.trash(&source).unwrap();
assert!(!source.exists());
let files = trash.join("files");
let info = trash.join("info");
assert_eq!(
fs::read(files.join(source.file_name().unwrap())).unwrap(),
b"zip bytes"
);
let records: Vec<_> = fs::read_dir(&info)
.unwrap()
.map(|p| fs::read_to_string(p.unwrap().path()).unwrap())
.collect();
assert!(records[0].contains("a%20%C3%A9%20%25%20space.zip"));
assert!(records[0].contains("DeletionDate="));
assert!(records[0].contains("Path=/"));
write(&source, b"second zip");
Disk.trash(&source).unwrap();
assert_eq!(
fs::read(files.join(source.file_name().unwrap())).unwrap(),
b"zip bytes"
);
assert_eq!(fs::read_dir(&files).unwrap().count(), 2);
let folder = root.join("mods/owners-work");
write(folder.join("work"), b"precious");
Disk.trash(&folder).unwrap();
assert_eq!(
fs::read(files.join("owners-work/work")).unwrap(),
b"precious"
);
}
_ => panic!("unknown mode"),
}
}
#[test]
fn proc_comm_and_argv0_detect_native_proton_skip_errors_and_fail_open() {
let dir = TempDir::new();
let proc = dir.0.join("proc");
assert!(!linux::factorio_running_in(&proc));
fs::create_dir(&proc).unwrap();
assert!(!linux::factorio_running_in(&proc));
write(proc.join("1/comm"), "unrelated\n");
write(proc.join("1/cmdline"), b"/usr/bin/unrelated\0factorio\0");
fs::create_dir_all(proc.join("2/comm")).unwrap(); // read errors on another user's PID are skipped.
fs::create_dir_all(proc.join("3")).unwrap(); // vanished files are normal.
assert!(!linux::factorio_running_in(&proc));
if rustix::process::getuid().as_raw() != 0 {
write(proc.join("6/comm"), "factorio\n");
fs::set_permissions(proc.join("6"), fs::Permissions::from_mode(0o000)).unwrap();
let inaccessible_pid = linux::factorio_running_in(&proc);
fs::set_permissions(proc.join("6"), fs::Permissions::from_mode(0o700)).unwrap();
fs::remove_dir_all(proc.join("6")).unwrap();
assert!(!inaccessible_pid);
fs::set_permissions(&proc, fs::Permissions::from_mode(0o000)).unwrap();
let inaccessible_root = linux::factorio_running_in(&proc);
fs::set_permissions(&proc, fs::Permissions::from_mode(0o700)).unwrap();
assert!(!inaccessible_root);
}
write(proc.join("4/comm"), "factorio\n");
assert!(linux::factorio_running_in(&proc));
fs::remove_dir_all(proc.join("4")).unwrap();
write(
proc.join("5/cmdline"),
b"/games/bin/factorio.exe\0--secret-argument-not-read\0",
);
assert!(linux::factorio_running_in(&proc));
write(proc.join("5/cmdline"), b"/games/bin/factorio\0");
assert!(linux::factorio_running_in(&proc));
}
#[test]
fn browser_validates_exact_argv_and_propagates_failures() {
let url = "https://mods.factorio.com/mod/a?x=1&y=%20";
linux::open_browser_with(url, |program, args| {
assert_eq!(program, "xdg-open");
assert_eq!(args, [url]);
Ok(())
})
.unwrap();
for bad in [
"javascript:alert(1)",
"file:///etc/passwd",
"https://a\n--evil",
] {
assert!(linux::open_browser_with(bad, |_, _| panic!("invalid URL launched")).is_err());
}
for error in ["missing opener", "nonzero exit"] {
assert!(
linux::open_browser_with(url, |_, _| Err(error.into()))
.unwrap_err()
.to_string()
.contains(error)
);
}
}
#[test]
fn portable_install_is_readable_but_cleanup_and_writes_are_protected() {
let (dir, mut snapshot) = common::fixture();
snapshot.paths.install_dir = dir.0.clone();
let part = snapshot.paths.mods_dir.join("a.zip.fmm-part");
write(&part, b"recover");
assert!(download::clean_temp_checked(&snapshot.paths, &|| false).is_err());
assert_eq!(fs::read(&part).unwrap(), b"recover");
assert!(fmm_core::store::apply_changes_with(&snapshot, &vec![], &vec![], &|| false).is_err());
snapshot.paths.install_dir = dir.0.join("install");
assert!(download::clean_temp_checked(&snapshot.paths, &|| true).is_err());
assert!(part.exists());
assert_eq!(
download::clean_temp_checked(&snapshot.paths, &|| false).unwrap(),
1
);
}
#[test]
#[ignore = "read-only owner installation probe; no snapshot cache or effects"]
fn real_install_read_only_probe() {
let e = std::env::vars().collect();
let detected = discovery::detect(&e);
assert!(
!detected.installs.is_empty(),
"No real Factorio install discovered"
);
for install in detected.installs {
let version = paths::read_game_version(&install).unwrap();
let data = paths::resolve_user_dir(&install, &e).unwrap();
settings::validate_data_dir(&data).unwrap();
println!(
"VERIFIED install={} version={} data={} mods={}",
install.display(),
version,
data.display(),
data.join("mods").display()
);
}
}
#[test]
fn explicit_data_recovers_unknown_macros_and_environment_install_wins() {
let (dir, snapshot) = common::fixture();
let install = &snapshot.paths.install_dir;
write(
install.join("config-path.cfg"),
"config-path=__PATH__unknown__/config",
);
let mut e = env(&dir.0);
e.insert(
"FACTORIO_DIR".into(),
install.to_string_lossy().into_owned(),
);
let actual = fmm_core::store::load_snapshot_with_data_env(
Some(&dir.0.join("invalid-saved-install")),
Some(&snapshot.paths.user_dir),
&dir.0.join("cache"),
&e,
)
.unwrap();
assert_eq!(actual.paths.install_dir, *install);
assert_eq!(actual.paths.mods_dir, snapshot.paths.mods_dir);
assert_eq!(actual.paths.game_version, "2.0.77");
assert!(paths::resolve_user_dir(install, &e).is_err());
}