use fmm_core::{
enable::*,
local_mods::{LocalMod, ModSource},
mod_list::{ModList, ModListEntry},
paths::FactorioPaths,
store::Snapshot,
version::{Dependency, parse_dependency},
};
use std::{collections::BTreeSet, path::PathBuf};
fn local(name: &str, version: &str, dependencies: &[&str]) -> LocalMod {
LocalMod {
name: name.into(),
version: version.into(),
title: name.into(),
author: String::new(),
description: String::new(),
factorio_version: "2.0".into(),
dependencies: dependencies
.iter()
.map(|s| parse_dependency(s).unwrap())
.collect(),
source: ModSource::Zip,
path: PathBuf::from(format!("fixtures/{name}_{version}.zip")),
thumbnail: None,
}
}
fn builtin(name: &str, dependencies: &[&str]) -> LocalMod {
let mut mod_ = local(name, "2.0.77", dependencies);
mod_.source = ModSource::Builtin;
mod_
}
fn snapshot(mods: Vec<LocalMod>, active: &[&str]) -> Snapshot {
let mut builtin_mods = vec![builtin("base", &[])];
let (other_builtin, mods): (Vec<_>, Vec<_>) = mods
.into_iter()
.partition(|mod_| mod_.source == ModSource::Builtin);
builtin_mods.extend(other_builtin);
let names: BTreeSet<_> = builtin_mods
.iter()
.chain(&mods)
.map(|m| m.name.clone())
.collect();
Snapshot {
paths: FactorioPaths {
install_dir: PathBuf::from("fixtures/install"),
user_dir: PathBuf::from("fixtures/user"),
mods_dir: PathBuf::from("fixtures/user/mods"),
mod_list_path: PathBuf::from("fixtures/user/mods/mod-list.json"),
game_version: "2.0.77".into(),
},
builtin: builtin_mods,
mods,
scan_errors: Vec::new(),
mod_list: ModList {
mods: names
.into_iter()
.map(|name| ModListEntry {
enabled: name == "base" || active.contains(&name.as_str()),
name,
version: None,
})
.collect(),
},
}
}
fn saved_pin(snapshot: &mut Snapshot, name: &str, version: &str) {
snapshot
.mod_list
.mods
.iter_mut()
.find(|entry| entry.name == name)
.unwrap()
.version = Some(version.into());
}
fn entry<'a>(list: &'a ModList, name: &str) -> &'a ModListEntry {
list.mods.iter().find(|entry| entry.name == name).unwrap()
}
fn names(deps: &[Dependency]) -> Vec<&str> {
deps.iter().map(|dep| dep.name.as_str()).collect()
}
#[test]
fn enabled_uses_pending_over_saved_and_always_protects_base() {
let mut s = snapshot(vec![local("a", "1.0", &[])], &["a"]);
assert!(enabled(&s, &vec![], "a"));
assert!(!enabled(&s, &vec![("a".into(), false)], "a"));
assert!(enabled(&s, &vec![("new".into(), true)], "new"));
assert!(!enabled(&s, &vec![], "absent"));
s.mod_list
.mods
.iter_mut()
.find(|e| e.name == "base")
.unwrap()
.enabled = false;
assert!(enabled(&s, &vec![("base".into(), false)], "base"));
}
#[test]
fn direct_deltas_cancel_noops_and_keep_unrelated_changes() {
let s = snapshot(vec![local("a", "1.0", &[]), local("b", "1.0", &[])], &["a"]);
let pending = vec![("b".into(), true)];
assert_eq!(set_pending(&s, &pending, "a", true), pending);
let changed = set_pending(&s, &pending, "a", false);
assert_eq!(changed, vec![("b".into(), true), ("a".into(), false)]);
assert_eq!(set_pending(&s, &changed, "a", true), pending);
assert_eq!(set_pending(&s, &pending, "base", false), pending);
assert_eq!(set_pending(&s, &pending, "b", true), pending);
assert!(set_pending(&s, &vec![], "absent", false).is_empty());
}
#[test]
fn effective_list_applies_pins_without_enabling_disabled_mods() {
let mut s = snapshot(vec![local("a", "1.0", &[]), local("b", "1.0", &[])], &["a"]);
saved_pin(&mut s, "a", "1.0");
let original = serde_json::to_value(&s).unwrap();
let list = effective_list(
&s,
&vec![("a".into(), false), ("base".into(), false)],
&vec![("b".into(), Some("1.0".into()))],
);
assert!(!entry(&list, "a").enabled);
assert_eq!(entry(&list, "a").version.as_deref(), Some("1.0"));
assert!(!entry(&list, "b").enabled);
assert_eq!(entry(&list, "b").version.as_deref(), Some("1.0"));
assert!(entry(&list, "base").enabled);
assert_eq!(serde_json::to_value(&s).unwrap(), original);
}
#[test]
fn pinning_unlisted_installed_mod_keeps_the_games_enabled_default_unless_pending_disabled() {
let mut s = snapshot(vec![local("a", "1.0", &[])], &[]);
s.mod_list.mods.retain(|entry| entry.name != "a");
let pins = set_pin(&s, &vec![], "a", Some("1.0".into())).unwrap();
let list = effective_list(&s, &vec![], &pins);
assert!(entry(&list, "a").enabled);
assert_eq!(entry(&list, "a").version.as_deref(), Some("1.0"));
assert!(!entry(&effective_list(&s, &vec![("a".into(), false)], &pins), "a").enabled);
}
#[test]
fn latest_removes_saved_pin_and_preserves_enabled_state() {
let mut s = snapshot(vec![local("a", "1.0", &[]), local("a", "2.0", &[])], &["a"]);
saved_pin(&mut s, "a", "1.0");
let pins = set_pin(&s, &vec![], "a", None).unwrap();
assert_eq!(pins, vec![("a".into(), None)]);
let list = effective_list(&s, &vec![], &pins);
assert_eq!(entry(&list, "a").version, None);
assert!(entry(&list, "a").enabled);
assert_eq!(
loaded_mods(&s, &pins)
.iter()
.find(|m| m.name == "a")
.unwrap()
.version,
"2.0"
);
assert!(
set_pin(&s, &pins, "a", Some("1.0".into()))
.unwrap()
.is_empty()
);
}
#[test]
fn pin_deltas_remove_noops_and_retain_other_names() {
let s = snapshot(vec![local("a", "1.0", &[]), local("b", "1.0", &[])], &[]);
let other = vec![("b".into(), Some("1.0".into()))];
assert_eq!(set_pin(&s, &other, "a", None).unwrap(), other);
let changed = set_pin(&s, &other, "a", Some("1.0".into())).unwrap();
assert_eq!(
set_pin(&s, &changed, "a", Some("1.0".into())).unwrap(),
changed
);
assert_eq!(set_pin(&s, &changed, "a", None).unwrap(), other);
}
#[test]
fn pins_validate_installed_name_and_exact_version() {
let s = snapshot(vec![local("a", "1.0", &[])], &[]);
assert!(set_pin(&s, &vec![], "absent", None).is_err());
for version in ["2.0", "1.0.0", ""] {
assert!(set_pin(&s, &vec![], "a", Some(version.into())).is_err());
}
assert!(set_pin(&s, &vec![], "base", Some("2.0.77".into())).is_ok());
}
#[test]
fn installed_versions_are_deduplicated_and_numerically_newest_first() {
let s = snapshot(
vec![
local("a", "1.9", &[]),
local("a", "1.10", &[]),
local("a", "1.10", &[]),
local("a", "1.2", &[]),
local("other", "8.0", &[]),
],
&[],
);
assert_eq!(installed_versions(&s, "a"), ["1.10", "1.9", "1.2"]);
assert_eq!(installed_versions(&s, "base"), ["2.0.77"]);
assert!(installed_versions(&s, "absent").is_empty());
}
#[test]
fn loaded_versions_follow_saved_pending_latest_and_missing_pins() {
let mut s = snapshot(vec![local("a", "1.9", &[]), local("a", "1.10", &[])], &[]);
let version = |pins: &Pins| {
loaded_mods(&s, pins)
.into_iter()
.find(|m| m.name == "a")
.unwrap()
.version
.clone()
};
assert_eq!(version(&vec![]), "1.10");
saved_pin(&mut s, "a", "1.9");
assert_eq!(loaded_mods(&s, &vec![])[0].version, "1.9");
assert_eq!(
loaded_mods(&s, &vec![("a".into(), None)])[0].version,
"1.10"
);
assert_eq!(
loaded_mods(&s, &vec![("a".into(), Some("1.10".into()))])[0].version,
"1.10"
);
saved_pin(&mut s, "a", "1.8");
assert_eq!(
loaded_mods(&s, &vec![])
.iter()
.map(|m| m.name.as_str())
.collect::<Vec<_>>(),
["base"]
);
assert_eq!(
loaded_mods(&s, &vec![("a".into(), Some("1.9.0".into()))]).len(),
1
);
}
#[test]
fn loaded_version_ties_and_order_are_deterministic() {
let mut a = local("a", "1.0", &[]);
a.path = "fixtures/z.zip".into();
let mut b = a.clone();
b.path = "fixtures/a.zip".into();
let mut s = snapshot(vec![local("z", "1.0", &[]), a, b], &[]);
assert_eq!(
loaded_mods(&s, &vec![])
.iter()
.map(|m| m.name.as_str())
.collect::<Vec<_>>(),
["a", "base", "z"]
);
assert_eq!(
loaded_mods(&s, &vec![])[0].path,
PathBuf::from("fixtures/a.zip")
);
s.mods.reverse();
assert_eq!(
loaded_mods(&s, &vec![])[0].path,
PathBuf::from("fixtures/a.zip")
);
let mut folder = local("a", "1.0", &[]);
folder.source = ModSource::Folder;
s.mods.push(folder);
assert_eq!(loaded_mods(&s, &vec![])[0].source, ModSource::Folder);
}
#[test]
fn missing_distinguishes_absent_disabled_and_unsatisfied_requirements() {
let s = snapshot(
vec![
local(
"a",
"1.0",
&["absent >= 2.0", "~ disabled", "old > 1.0", "base >= 2.0"],
),
local("disabled", "1.0", &[]),
local("old", "1.0", &[]),
local("off", "1.0", &["absent"]),
],
&["a", "old"],
);
let issues = diagnose(&s, &vec![], &vec![]);
assert_eq!(issues.len(), 1);
assert_eq!(names(&issues["a"].missing), ["absent", "disabled", "old"]);
assert_eq!(names(&issues["a"].install_missing), ["absent", "old"]);
assert_eq!(
issues["a"].missing[0],
parse_dependency("absent >= 2.0").unwrap()
);
assert!(issues["a"].incompatible.is_empty());
}
#[test]
fn pending_state_controls_required_diagnostics() {
let s = snapshot(vec![local("a", "1.0", &["b"]), local("b", "1.0", &[])], &[]);
assert!(diagnose(&s, &vec![], &vec![]).is_empty());
assert_eq!(
names(&diagnose(&s, &vec![("a".into(), true)], &vec![])["a"].missing),
["b"]
);
assert!(diagnose(&s, &vec![("a".into(), true), ("b".into(), true)], &vec![]).is_empty());
}
#[test]
fn disabled_unsatisfied_dependency_still_needs_install_but_disabled_satisfied_does_not() {
let s = snapshot(
vec![
local("a", "1.0", &["b >= 2.0"]),
local("b", "1.0", &[]),
local("b", "2.0", &[]),
],
&["a"],
);
let latest = diagnose(&s, &vec![], &vec![]);
assert_eq!(names(&latest["a"].missing), ["b"]);
assert!(latest["a"].install_missing.is_empty());
let old = diagnose(&s, &vec![], &vec![("b".into(), Some("1.0".into()))]);
assert_eq!(names(&old["a"].install_missing), ["b"]);
}
#[test]
fn diagnostics_use_exact_pinned_target_instead_of_any_installed_version() {
let mut s = snapshot(
vec![
local("a", "1.0", &["b = 1.0"]),
local("b", "1.0", &[]),
local("b", "2.0", &[]),
],
&["a", "b"],
);
assert_eq!(
names(&diagnose(&s, &vec![], &vec![])["a"].install_missing),
["b"]
);
saved_pin(&mut s, "b", "1.0");
assert!(diagnose(&s, &vec![], &vec![]).is_empty());
assert_eq!(
names(&diagnose(&s, &vec![], &vec![("b".into(), None)])["a"].install_missing),
["b"]
);
saved_pin(&mut s, "b", "9.0");
assert_eq!(
names(&diagnose(&s, &vec![], &vec![])["a"].install_missing),
["b"]
);
}
#[test]
fn constraints_cover_every_comparator_and_numeric_equality() {
for (dependency, ok) in [
("b < 2.0", false),
("b <= 2.0", true),
("b = 2.0", true),
("b >= 2.0", true),
("b > 2.0", false),
("~ b > 1.9", true),
] {
let s = snapshot(
vec![local("a", "1.0", &[dependency]), local("b", "2.0.0", &[])],
&["a", "b"],
);
assert_eq!(
diagnose(&s, &vec![], &vec![]).is_empty(),
ok,
"{dependency}"
);
}
}
#[test]
fn pinned_parent_metadata_controls_diagnostics() {
let mut s = snapshot(
vec![local("a", "1.0", &["old"]), local("a", "2.0", &["new"])],
&["a"],
);
saved_pin(&mut s, "a", "1.0");
assert_eq!(names(&diagnose(&s, &vec![], &vec![])["a"].missing), ["old"]);
assert_eq!(
names(&diagnose(&s, &vec![], &vec![("a".into(), None)])["a"].missing),
["new"]
);
}
#[test]
fn incompatibilities_mark_both_enabled_sides_without_toggling_them() {
let s = snapshot(
vec![
local("a", "1.0", &["! z", "! b", "! z"]),
local("b", "1.0", &["! a"]),
local("z", "1.0", &[]),
],
&["a", "b", "z"],
);
let pending = vec![];
let issues = diagnose(&s, &pending, &vec![]);
assert_eq!(issues["a"].incompatible, ["b", "z"]);
assert_eq!(issues["b"].incompatible, ["a"]);
assert_eq!(issues["z"].incompatible, ["a"]);
assert!(
issues
.values()
.all(|i| i.missing.is_empty() && i.install_missing.is_empty())
);
assert!(pending.is_empty());
assert!(set_pending(&s, &pending, "a", true).is_empty());
}
#[test]
fn incompatibility_constraints_follow_pins_and_pending_enabled_state() {
let mut s = snapshot(
vec![
local("a", "1.0", &["! b >= 2.0"]),
local("b", "1.0", &[]),
local("b", "2.0", &[]),
],
&["a", "b"],
);
assert_eq!(diagnose(&s, &vec![], &vec![])["b"].incompatible, ["a"]);
saved_pin(&mut s, "b", "1.0");
assert!(diagnose(&s, &vec![], &vec![]).is_empty());
let latest = vec![("b".into(), None)];
assert_eq!(diagnose(&s, &vec![], &latest)["a"].incompatible, ["b"]);
assert!(diagnose(&s, &vec![("b".into(), false)], &latest).is_empty());
assert!(diagnose(&s, &vec![("a".into(), false)], &latest).is_empty());
}
#[test]
fn optional_hidden_and_absent_incompatibilities_produce_no_diagnostics() {
let s = snapshot(
vec![local(
"a",
"1.0",
&["? missing >= 9.0", "(?) hidden", "! absent"],
)],
&["a"],
);
assert!(diagnose(&s, &vec![], &vec![]).is_empty());
}
#[test]
fn pending_incompatibility_marks_base_but_never_disables_it() {
let s = snapshot(vec![local("a", "1.0", &["! base >= 2.0"])], &[]);
let result = set_pending(&s, &vec![], "a", true);
let issues = diagnose(&s, &result, &vec![]);
assert_eq!(issues["a"].incompatible, ["base"]);
assert_eq!(issues["base"].incompatible, ["a"]);
assert!(enabled(&s, &result, "base"));
}
#[test]
fn install_requirements_retain_active_parent_constraints_and_pinned_metadata() {
let s = snapshot(
vec![
local("a", "1.0", &["helper >= 2.0"]),
local("b", "1.0", &["helper < 3.0", "? helper = 9.0"]),
local("b", "2.0", &["helper >= 3.0"]),
local("off", "1.0", &["helper = 9.0"]),
],
&["a"],
);
let requirements = install_requirements(
&s,
&vec![("b".into(), true)],
&vec![("b".into(), Some("1.0".into()))],
"a",
);
assert_eq!(
requirements,
[
parse_dependency("helper >= 2.0").unwrap(),
parse_dependency("helper < 3.0").unwrap(),
]
);
assert!(install_requirements(&s, &vec![], &vec![], "off").is_empty());
}