#![cfg(target_os = "macos")]
mod common;
use common::{TempDir, write};
use fmm_core::{
app_dirs::{self, Kind},
discovery, download,
install::{Disk, FileOps, TRASH_NAME},
macos, paths, settings,
};
use std::{
collections::HashMap,
fs,
os::unix::fs::symlink,
path::Path,
sync::{Arc, Barrier},
};
fn env(home: &Path) -> HashMap<String, String> {
HashMap::from([("HOME".into(), home.to_string_lossy().into_owned())])
}
#[test]
fn library_defaults_and_independent_absolute_overrides() {
let dir = TempDir::new();
let mut e = env(&dir.0);
let root = |base: &str| dir.0.join(base).join("werry/factoriomodmanager");
for (kind, override_key, expected) in [
(
Kind::Settings,
"FMM_SETTINGS_DIR",
root("Library/Application Support"),
),
(
Kind::Metadata,
"FMM_METADATA_DIR",
root("Library/Application Support").join("metadata"),
),
(Kind::Cache, "FMM_CACHE_DIR", root("Library/Caches")),
] {
assert_eq!(app_dirs::directory(&e, kind).unwrap(), expected);
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);
assert!(app_dirs::directory(&HashMap::new(), kind).is_err());
assert!(app_dirs::directory(&env(Path::new("relative")), kind).is_err());
}
assert_eq!(fs::read_dir(&dir.0).unwrap().count(), 0);
}
#[test]
fn steam_and_standalone_bundles_resolve_to_contents_and_native_data() {
let dir = TempDir::new();
let home = dir.0.join("home");
let e = env(&home);
let steam = home.join("Library/Application Support/Steam");
let other = dir.0.join("other library");
let game = other.join("steamapps/common/Factorio");
let contents = game.join(paths::MACOS_BUNDLE_ROOT);
write(
contents.join("data/base/info.json"),
r#"{"version":"2.0.77"}"#,
);
let escaped = serde_json::to_string(&other.to_string_lossy()).unwrap();
write(
steam.join("steamapps/libraryfolders.vdf"),
format!(r#""libraryfolders" {{ "1" {{ "path" {escaped} }} }}"#),
);
let standalone = home.join("Applications").join(paths::MACOS_BUNDLE_ROOT);
write(
standalone.join("data/base/info.json"),
r#"{"version":"2.0.76"}"#,
);
let native = home.join("Library/Application Support/factorio");
assert_eq!(paths::default_user_dir(&e), native);
write(native.join("mods/mod-list.json"), r#"{"mods":[]}"#);
write(
native.join("config/config.ini"),
"[path]\nwrite-data=__PATH__system-write-data__\n",
);
let folders = discovery::detect(&e);
// The real /Applications bundle may follow; HOME-relative installs come first.
assert_eq!(folders.installs[..2], [contents.clone(), standalone]);
assert_eq!(folders.data, vec![native.clone()]);
for chosen in [&game, &game.join("factorio.app"), &contents] {
assert_eq!(paths::game_dir(chosen), contents);
let found = paths::find_factorio_with_env(Some(chosen), &e)
.unwrap()
.unwrap();
assert_eq!(found.install_dir, contents);
assert_eq!(found.game_version, "2.0.77");
assert_eq!(found.mod_list_path, native.join("mods/mod-list.json"));
let saved =
settings::Settings::from_inputs(&native.to_string_lossy(), &chosen.to_string_lossy())
.unwrap();
assert_eq!(saved.install_dir, Some(contents.clone()));
}
assert_eq!(paths::game_dir(&dir.0), dir.0);
}
#[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 trash_wording_and_refusals_never_reach_the_real_trash() {
assert_eq!(TRASH_NAME, "Trash");
{
use trash::macos::{DeleteMethod, TrashContextExtMacos};
assert!(matches!(
macos::trash_context().delete_method(),
DeleteMethod::NsFileManager
));
}
let dir = TempDir::new();
write(dir.0.join("elsewhere/a.zip"), b"zip");
assert!(Disk.trash(&dir.0.join("elsewhere/a.zip")).is_err());
write(dir.0.join("target.zip"), b"zip");
fs::create_dir_all(dir.0.join("mods")).unwrap();
symlink(dir.0.join("target.zip"), dir.0.join("mods/a.zip")).unwrap();
assert!(Disk.trash(&dir.0.join("mods/a.zip")).is_err());
assert!(dir.0.join("elsewhere/a.zip").exists());
assert!(fs::symlink_metadata(dir.0.join("mods/a.zip")).is_ok());
}
#[test]
fn process_names_match_factorio_and_fail_open() {
assert!(!macos::factorio_running_among(None));
assert!(!macos::factorio_running_among(Some(vec![])));
assert!(!macos::factorio_running_among(Some(vec![
b"factorio-helper".to_vec(),
b"Steam".to_vec(),
])));
for name in ["factorio", "Factorio", "factorio.exe"] {
assert!(macos::factorio_running_among(Some(vec![
b"zsh".to_vec(),
name.as_bytes().to_vec(),
])));
}
let own = std::env::current_exe().unwrap();
let own = own.file_name().unwrap().as_encoded_bytes();
let names = macos::process_names().expect("process table is listable");
assert!(names.iter().any(|n| n == own), "own process is listed");
}
#[test]
fn browser_validates_exact_argv_and_propagates_failures() {
let url = "https://mods.factorio.com/mod/a?x=1&y=%20";
macos::open_browser_with(url, |program, args| {
assert_eq!(program, "/usr/bin/open");
assert_eq!(args, [url]);
Ok(())
})
.unwrap();
for bad in [
"javascript:alert(1)",
"file:///etc/passwd",
"-a Terminal",
"https://a\n--evil",
] {
assert!(macos::open_browser_with(bad, |_, _| panic!("invalid URL launched")).is_err());
}
assert!(
macos::open_browser_with(url, |_, _| Err("nonzero exit".into()))
.unwrap_err()
.to_string()
.contains("nonzero exit")
);
}
#[test]
fn install_contained_data_refuses_cleanup_and_running_game_keeps_parts() {
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={} running={}",
install.display(),
version,
data.display(),
macos::factorio_running()
);
}
}