mod common;
use common::{TempDir, entry, fixture, write};
use fmm_core::{
local_mods::{LocalMod, ModSource, scan_mods_dir},
mod_list::*,
paths::*,
portal::*,
store::{apply_changes_with, load_snapshot},
updates::*,
version::*,
};
use serde_json::json;
use std::{cmp::Ordering::*, collections::HashMap, fs, io::Write};
#[test]
fn compares_numerically() {
assert_eq!(compare_versions("1.10.0", "1.9.9"), Greater);
assert_eq!(compare_versions("2.0", "2.0.0"), Equal);
assert_eq!(compare_versions("0.1.0", "0.1.1"), Less);
}
#[cfg(windows)]
#[test]
fn english_title_collation_matches_the_ts_app_for_case_accents_and_punctuation() {
use fmm_core::text::compare_english;
let mut titles = ["a-b", "ab", "a b", "é", "e", "E", "!foo", "z"];
titles.sort_by(|a, b| compare_english(a, b, true));
assert_eq!(titles, ["!foo", "a b", "a-b", "ab", "é", "e", "E", "z"]);
let mut titles = ["Zoo", "alpha", "Alpha", "é", "e"];
titles.sort_by(|a, b| compare_english(a, b, false));
assert_eq!(titles, ["alpha", "Alpha", "e", "é", "Zoo"]);
}
#[test]
fn reduces_a_game_version_to_its_release_line() {
assert_eq!(game_line("2.0.77"), "2.0");
}
#[test]
fn parses_every_dependency_prefix() {
assert_eq!(
parse_dependency("base >= 2.0").unwrap(),
Dependency {
kind: DependencyKind::Required,
name: "base".into(),
comparator: Some(Comparator::GreaterEqual),
version: Some("2.0".into())
}
);
for (text, kind, name) in [
(
"? informatron >= 0.4.0",
DependencyKind::Optional,
"informatron",
),
(
"(?) space-exploration",
DependencyKind::HiddenOptional,
"space-exploration",
),
("! bobplates", DependencyKind::Incompatible, "bobplates"),
("~ flib", DependencyKind::NoLoadOrder, "flib"),
] {
let d = parse_dependency(text).unwrap();
assert_eq!(d.kind, kind);
assert_eq!(d.name, name);
}
let d = parse_dependency("Mod With Spaces = 1.2.3").unwrap();
assert_eq!(d.name, "Mod With Spaces");
assert_eq!(d.comparator, Some(Comparator::Equal));
}
#[test]
fn checks_constraints() {
let dep = parse_dependency("a >= 0.4.0").unwrap();
assert!(satisfies("0.4.1", &dep));
assert!(!satisfies("0.3.9", &dep));
}
#[test]
fn round_trips_in_the_game_layout_and_keeps_a_backup() {
let dir = TempDir::new();
let file = dir.0.join("mod-list.json");
let original = format_mod_list(&ModList {
mods: vec![entry("base", true), entry("flib", false)],
});
assert_eq!(
original,
"{\n \"mods\": \n [ \n {\n \"name\": \"base\",\n \"enabled\": true\n }, \n {\n \"name\": \"flib\",\n \"enabled\": false\n }\n ]\n}\n"
);
write(&file, &original);
write_mod_list(
&file,
&set_enabled(&read_mod_list(&file).unwrap(), "flib", true),
)
.unwrap();
assert_eq!(
read_mod_list(&file).unwrap().mods,
[entry("base", true), entry("flib", true)]
);
assert_eq!(
fs::read_to_string(sibling(&file, ".bak")).unwrap(),
original
);
assert!(!sibling(&file, ".tmp").exists());
}
#[test]
fn appends_unknown_mods() {
assert_eq!(
set_enabled(&ModList { mods: vec![] }, "x", true).mods,
[entry("x", true)]
);
}
#[test]
fn reads_folders_versioned_folders_and_zips() {
let dir = TempDir::new();
let info = |name: &str, version: &str| {
json!({ "name": name, "version": version, "title": name.to_uppercase(), "factorio_version": "2.0" }).to_string()
};
write(dir.0.join("plain/info.json"), info("plain", "1.0.0"));
write(
dir.0.join("versioned_2.1.0/info.json"),
info("versioned", "2.1.0"),
);
let mut zip = zip::ZipWriter::new(fs::File::create(dir.0.join("zipped_0.3.0.zip")).unwrap());
for (name, bytes) in [
("info.json", info("zipped", "0.3.0").into_bytes()),
("thumbnail.png", vec![137, 80, 78, 71]),
("data.lua", b"-- big file not inflated".to_vec()),
] {
zip.start_file(
format!("zipped_0.3.0/{name}"),
zip::write::SimpleFileOptions::default(),
)
.unwrap();
zip.write_all(&bytes).unwrap();
}
zip.finish().unwrap();
write(dir.0.join("mod-list.json"), "{}");
fs::create_dir(dir.0.join("empty")).unwrap();
let result = scan_mods_dir(&dir.0, Some(&dir.0.join(".thumbs"))).unwrap();
assert_eq!(
result
.mods
.iter()
.map(|m| format!("{}@{}:{:?}", m.name, m.version, m.source))
.collect::<Vec<_>>(),
[
]
);
assert!(result.mods[2].thumbnail.as_ref().unwrap().exists());
assert_eq!(
result
.errors
.iter()
.map(|e| e.path.file_name().unwrap().to_str().unwrap())
.collect::<Vec<_>>(),
["empty"]
);
}
fn release(version: &str, factorio: &str) -> Release {
Release {
version: version.into(),
info_json: ReleaseInfo {
factorio_version: factorio.into(),
..Default::default()
},
..Default::default()
}
}
fn remote(name: &str, releases: Vec<Release>) -> PortalMod {
PortalMod {
name: name.into(),
title: name.into(),
releases: Some(releases),
..Default::default()
}
}
fn local(name: &str, version: &str) -> LocalMod {
LocalMod {
name: name.into(),
title: name.into(),
version: version.into(),
source: ModSource::Folder,
author: String::new(),
description: String::new(),
factorio_version: "2.0".into(),
dependencies: vec![],
path: "".into(),
thumbnail: None,
}
}
#[test]
fn picks_the_newest_release_for_the_installed_game_line_only() {
let m = remote(
"a",
vec![
release("1.0.0", "1.1"),
release("1.3.5", "2.0"),
release("1.4.0", "2.1"),
],
);
assert_eq!(
newest_compatible_release(&m, "2.0.77").unwrap().version,
"1.3.5"
);
}
#[test]
fn reports_updates_unknown_mods_and_releases_for_newer_games() {
let mut base = local("base", "2.0.77");
base.source = ModSource::Builtin;
let plan = plan_updates(
&[
local("a", "1.3.2"),
local("b", "1.0.0"),
local("gone", "0.1.0"),
base,
],
&[
remote("a", vec![release("1.3.5", "2.0"), release("1.4.0", "2.1")]),
remote("b", vec![release("1.0.0", "2.0")]),
],
"2.0.77",
);
assert_eq!(
plan.updates
.iter()
.map(|u| format!("{} {}->{}", u.name, u.local_version, u.new_version))
.collect::<Vec<_>>(),
["a 1.3.2->1.3.5"]
);
assert_eq!(plan.not_on_portal, ["gone"]);
assert_eq!(
plan.newer_for_other_game,
[OtherGameRelease {
name: "a".into(),
version: "1.4.0".into(),
factorio_version: "2.1".into()
}]
);
}
#[test]
fn resolves_system_portable_literal_and_macro_write_data() {
let dir = TempDir::new();
let install = dir.0.join("install");
let roaming = dir.0.join("roaming");
fs::create_dir_all(&install).unwrap();
let env = HashMap::from([
("APPDATA".into(), roaming.to_string_lossy().into_owned()),
("HOME".into(), roaming.to_string_lossy().into_owned()),
]);
assert_eq!(
resolve_user_dir(&install, &env).unwrap(),
if cfg!(target_os = "linux") {
roaming.join(".factorio")
} else if cfg!(target_os = "macos") {
roaming.join("Library/Application Support/factorio")
} else {
roaming.join("Factorio")
}
);
write(
install.join("config-path.cfg"),
"use-system-read-write-data-directories=false\r\n",
);
assert_eq!(resolve_user_dir(&install, &env).unwrap(), install);
write(
install.join("config/config.ini"),
"write-data=__PATH__executable__/../..\n",
);
assert_eq!(resolve_user_dir(&install, &env).unwrap(), install);
let custom = dir.0.join("custom");
write(
install.join("config/config.ini"),
format!("write-data={}\r\n", custom.display()),
);
assert_eq!(resolve_user_dir(&install, &env).unwrap(), custom);
#[cfg(not(target_os = "linux"))]
assert!(
find_factorio_with_env(Some(&install), &env)
.unwrap()
.is_none()
);
#[cfg(target_os = "linux")]
assert!(
find_factorio_with_env(Some(&install), &env)
.unwrap_err()
.to_string()
.contains("Invalid explicit")
);
write(
install.join("data/base/info.json"),
"{\"version\":\"2.0.77\"}",
);
let paths = find_factorio_with_env(Some(&install), &env)
.unwrap()
.unwrap();
assert_eq!(paths.game_version, "2.0.77");
assert_eq!(paths.mod_list_path, custom.join("mods/mod-list.json"));
}
#[test]
fn loads_a_snapshot_and_applies_to_a_temporary_user_folder() {
let (dir, snapshot) = fixture();
let loaded = load_snapshot(Some(&snapshot.paths.install_dir), &dir.0.join("cache")).unwrap();
assert_eq!(loaded.builtin.len(), 4);
assert_eq!(loaded.mods.len(), 3);
let change = vec![("a".into(), true)];
let original = fs::read(&loaded.paths.mod_list_path).unwrap();
assert!(apply_changes_with(&loaded, &change, &vec![], &|| true).is_err());
assert_eq!(fs::read(&loaded.paths.mod_list_path).unwrap(), original);
apply_changes_with(&loaded, &change, &vec![], &|| false).unwrap();
assert!(is_enabled(
&read_mod_list(&loaded.paths.mod_list_path).unwrap(),
"a"
));
}
#[test]
fn preserves_pins_and_defaults_missing_lists_and_metadata() {
let dir = TempDir::new();
let file = dir.0.join("mod-list.json");
assert_eq!(read_mod_list(&file).unwrap().mods, [entry("base", true)]);
let mut pinned = entry("x", false);
pinned.version = Some("1.2.3".into());
write_mod_list(
&file,
&set_enabled(
&ModList {
mods: vec![pinned.clone()],
},
"x",
true,
),
)
.unwrap();
pinned.enabled = true;
assert_eq!(read_mod_list(&file).unwrap().mods, [pinned]);
write(&file, "{\"mods\":{}}");
assert!(read_mod_list(&file).is_err());
write(
dir.0.join("plain/info.json"),
"{\"name\":\"plain\",\"version\":\"1.0.0\",\"dependencies\":\"base >= 0.12\"}",
);
let scan = scan_mods_dir(&dir.0, None).unwrap();
assert_eq!(scan.mods[0].title, "plain");
assert_eq!(scan.mods[0].factorio_version, "0.12");
assert_eq!(scan.mods[0].dependencies.len(), 1);
}
#[test]
fn builds_portal_urls_without_network_calls() {
assert_eq!(
mirror_url("Mod With/名字", "1.2.3"),
"https://mods-storage.re146.dev/Mod%20With%2F%E5%90%8D%E5%AD%97/1.2.3.zip"
);
assert_eq!(
mod_full_url("a b"),
"https://mods.factorio.com/api/mods/a%20b/full"
);
assert_eq!(
thumbnail_url(Some("/abc.png")).unwrap(),
"https://assets-mod.factorio.com/abc.png"
);
assert_eq!(
thumbnail_url(Some("https://example/a.png")).unwrap(),
"https://example/a.png"
);
assert!(thumbnail_url(Some("/a/.thumb.png")).is_none());
assert!(thumbnail_url(None).is_none());
let urls = mods_by_name_urls(&(0..51).map(|i| format!("mod {i}")).collect::<Vec<_>>());
assert_eq!(urls.len(), 2);
assert_eq!(urls[0].matches("namelist=").count(), 50);
assert!(urls[1].ends_with("namelist=mod%2050"));
}
#[test]
fn handles_latest_release_fallback_duplicate_locals_and_no_compatible_release() {
let m = PortalMod {
name: "a".into(),
latest_release: Some(release("2.0.0", "2.0")),
..Default::default()
};
assert_eq!(
newest_compatible_release(&m, "2.0.77").unwrap().version,
"2.0.0"
);
assert!(newest_compatible_release(&m, "1.1.110").is_none());
let plan = plan_updates(&[local("a", "1.0.0"), local("a", "2.0.0")], &[m], "2.0.77");
assert!(plan.updates.is_empty());
}
#[test]
fn rejects_invalid_dependencies_and_checks_all_comparators() {
for text in ["", "?", "a != 1.2", "a >= 1", "a >= 1.2.3.4", "a >> 1.2"] {
assert!(parse_dependency(text).is_none(), "{text}");
}
for (op, yes, no) in [
("<", "1.1", "1.2"),
("<=", "1.2", "1.3"),
("=", "1.2.0", "1.3"),
(">=", "1.2", "1.1"),
(">", "1.3", "1.2"),
] {
let d = parse_dependency(&format!("a {op} 1.2")).unwrap();
assert!(satisfies(yes, &d));
assert!(!satisfies(no, &d));
}
assert!(satisfies("1.0", &parse_dependency("a").unwrap()));
}
#[test]
fn corrupt_mods_are_scan_errors_instead_of_losing_valid_mods() {
let dir = TempDir::new();
write(dir.0.join("bad.zip"), "not a zip");
write(dir.0.join("broken/info.json"), "{");
write(
dir.0.join("valid/info.json"),
"{\"name\":\"valid\",\"version\":\"1.0.0\"}",
);
let scan = scan_mods_dir(&dir.0, None).unwrap();
assert_eq!(scan.mods.len(), 1);
assert_eq!(scan.errors.len(), 2);
}
#[test]
fn locale_cfg_overrides_info_json_title_and_description_in_folders_zips_and_builtins() {
let dir = TempDir::new();
let info = |name: &str| {
json!({ "name": name, "version": "1.0.0", "title": "Info title", "description": "Info description", "factorio_version": "2.0" }).to_string()
};
let cfg = |name: &str| {
format!(
"[mod-name]\n{name}=Locale title\n\n[mod-description]\n{name}=Locale\\ndescription\n"
)
};
write(dir.0.join("folder/info.json"), info("folder"));
write(dir.0.join("folder/locale/en/folder.cfg"), cfg("folder"));
write(
dir.0.join("folder/locale/de/folder.cfg"),
"[mod-name]\nfolder=Deutsch\n",
);
write(dir.0.join("plain/info.json"), info("plain"));
write(dir.0.join("builtin/base/info.json"), info("base"));
write(
dir.0.join("builtin/base/locale/en/base.cfg"),
"[mod-description]\nbase=Built-in text\n",
);
let mut zip = zip::ZipWriter::new(fs::File::create(dir.0.join("zipped_1.0.0.zip")).unwrap());
for (name, text) in [
("info.json", info("zipped")),
("locale/en/zipped.cfg", cfg("zipped")),
(
"locale/fr/zipped.cfg",
"[mod-name]\nzipped=Francais\n".into(),
),
] {
zip.start_file(
format!("zipped_1.0.0/{name}"),
zip::write::SimpleFileOptions::default(),
)
.unwrap();
zip.write_all(text.as_bytes()).unwrap();
}
zip.finish().unwrap();
let mods = scan_mods_dir(&dir.0, None).unwrap().mods;
let get = |n: &str| mods.iter().find(|m| m.name == n).unwrap();
for name in ["folder", "zipped"] {
assert_eq!(get(name).title, "Locale title");
assert_eq!(get(name).description, "Locale\ndescription");
}
assert_eq!(get("plain").title, "Info title");
assert_eq!(get("plain").description, "Info description");
// scan_builtin_mods expects <install>/data/<mod>.
let install = dir.0.join("install");
fs::create_dir_all(install.join("data")).unwrap();
fs::rename(dir.0.join("builtin/base"), install.join("data/base")).unwrap();
let builtin = fmm_core::local_mods::scan_builtin_mods(&install).unwrap();
assert_eq!(builtin[0].description, "Built-in text");
assert_eq!(builtin[0].title, "Info title");
}