use fmm_core::{
catalogue::Catalogue,
explore::*,
portal::{PortalMod, Release, ReleaseInfo},
};
fn m(name: &str, category: Option<&str>, tags: &[&str]) -> PortalMod {
PortalMod {
name: name.into(),
title: name.into(),
category: category.map(Into::into),
tags: Some(tags.iter().map(|s| (*s).into()).collect()),
latest_release: Some(Release {
version: "1.0.0".into(),
info_json: ReleaseInfo {
factorio_version: "2.0".into(),
dependencies: None,
},
..Default::default()
}),
..Default::default()
}
}
fn names(index: &ExploreIndex, state: &ViewState) -> Vec<String> {
index
.query(state)
.rows
.iter()
.map(|&i| index.mods[i].name.clone())
.collect()
}
fn count(index: &ExploreIndex, state: &ViewState, id: &str) -> usize {
index.query(state).counts[FILTERS.iter().position(|s| *s == id).unwrap()]
}
#[test]
fn parses_bulk_missing_optional_fields_and_rejects_malformed_envelopes() {
let c = Catalogue::parse(br#"{"results":[{"name":"bare"},{"name":"tagged","tags":["trains"],"latest_release":{"version":"1","info_json":{"factorio_version":"2.0"}}}]}"#).unwrap();
assert_eq!(c.results.len(), 2);
assert!(c.results[0].tags.is_none());
assert!(c.results[0].latest_release.is_none());
assert_eq!(c.results[0].downloads_count, 0);
assert_eq!(c.results[1].tags.as_ref().unwrap(), &["trains"]);
assert!(Catalogue::parse(br#"{"results":[{}]}"#).is_err());
assert!(Catalogue::parse(br#"{}"#).is_err());
assert!(Catalogue::parse(br#"{"results":null}"#).is_err());
assert!(Catalogue::parse(b"invalid").is_err());
}
#[test]
fn full_response_keeps_common_tags_and_thumbnail_in_portal_mod() {
let c: fmm_core::portal::PortalModFull =
serde_json::from_str(r#"{"name":"a","tags":["power"],"thumbnail":"/assets/a.thumb.png"}"#)
.unwrap();
assert_eq!(c.mod_.tags.unwrap(), ["power"]);
assert_eq!(
fmm_core::portal::thumbnail_url(c.mod_.thumbnail.as_deref()).unwrap(),
"https://assets-mod.factorio.com/assets/a.thumb.png"
);
}
#[test]
fn exact_game_line_and_latest_only_excludes_missing_and_other_releases() {
let good = m("good", None, &[]);
let mut old = m("old", None, &[]);
old.latest_release
.as_mut()
.unwrap()
.info_json
.factorio_version = "1.1".into();
let mut future = m("future", None, &[]);
future.releases = good.latest_release.clone().map(|r| vec![r]);
future
.latest_release
.as_mut()
.unwrap()
.info_json
.factorio_version = "2.1".into();
let mut missing = m("missing", None, &[]);
missing.latest_release = None;
let i = ExploreIndex::new(vec![good, old, future, missing], "2.0.77");
assert_eq!(names(&i, &ViewState::default()), ["good"]);
}
#[test]
fn internal_default_exclusion_and_mutually_exclusive_toggles() {
let i = ExploreIndex::new(
vec![m("a", Some("internal"), &[]), m("b", None, &[])],
"2.0",
);
let mut s = ViewState::default();
assert_eq!(names(&i, &s), ["b"]);
assert_eq!(count(&i, &s, "internal"), 1);
s.toggle_filter("internal", false);
assert_eq!(s.filters[8], FilterMode::Include);
assert_eq!(names(&i, &s), ["a"]);
s.toggle_filter("internal", true);
assert_eq!(s.filters[8], FilterMode::Exclude);
s.toggle_filter("internal", true);
assert_eq!(s.filters[8], FilterMode::Off);
assert_eq!(names(&i, &s), ["a", "b"]);
assert!(!s.set_filter("unknown", FilterMode::Include));
}
#[test]
fn all_categories_tags_and_expansion_match_their_respective_items() {
for (n, id) in FILTERS.iter().enumerate() {
let mut item = if n == 0 {
m("target", None, &[])
} else if n < 10 {
m(
"target",
if *id == "no-category" { None } else { Some(id) },
&[],
)
} else {
m("target", None, &[id])
};
if n == 0 {
item.latest_release.as_mut().unwrap().info_json.dependencies =
Some(vec!["space-age >= 2.0".into()]);
}
let i = ExploreIndex::new(vec![item], "2.0.77");
let mut s = ViewState::default();
s.set_filter(id, FilterMode::Include);
assert_eq!(names(&i, &s), ["target"], "include {id}");
assert_eq!(count(&i, &s, id), 1, "count {id}");
s.set_filter(id, FilterMode::Exclude);
assert!(names(&i, &s).is_empty(), "exclude {id}");
}
}
#[test]
fn within_group_or_across_groups_and_and_exclusion_dominates() {
let i = ExploreIndex::new(
vec![
m("a", Some("content"), &["trains"]),
m("b", Some("tweaks"), &["power"]),
m("c", Some("content"), &["power", "cheats"]),
m("d", Some("utilities"), &["power"]),
],
"2.0",
);
let mut s = ViewState::default();
s.set_filter("content", FilterMode::Include);
s.set_filter("tweaks", FilterMode::Include);
assert_eq!(names(&i, &s), ["a", "b", "c"]);
s.set_filter("power", FilterMode::Include);
assert_eq!(names(&i, &s), ["b", "c"]);
s.set_filter("trains", FilterMode::Include);
assert_eq!(names(&i, &s), ["a", "b", "c"]);
s.set_filter("cheats", FilterMode::Exclude);
assert_eq!(names(&i, &s), ["a", "b"]);
}
#[test]
fn counts_ignore_own_group_but_respect_search_game_line_and_other_groups() {
let mut future = m("factory-future", Some("content"), &["power"]);
future
.latest_release
.as_mut()
.unwrap()
.info_json
.factorio_version = "2.1".into();
let i = ExploreIndex::new(
vec![
m("factory-a", Some("content"), &["power"]),
m("factory-b", Some("tweaks"), &["power"]),
m("other", Some("content"), &["trains"]),
m("factory-internal", Some("internal"), &["power"]),
future,
],
"2.0",
);
let mut s = ViewState {
search: "FACTORY".into(),
..Default::default()
};
s.set_filter("content", FilterMode::Include);
s.set_filter("power", FilterMode::Include);
assert_eq!(count(&i, &s, "content"), 1);
assert_eq!(count(&i, &s, "tweaks"), 1);
assert_eq!(count(&i, &s, "internal"), 1);
assert_eq!(count(&i, &s, "power"), 1);
s.set_filter("trains", FilterMode::Exclude);
assert_eq!(count(&i, &s, "power"), 1);
s.search = "missing".into();
assert_eq!(i.query(&s).counts, [0; 28]);
}
#[test]
fn expansion_missing_dependencies_does_not_match_and_counts_react_to_categories() {
let mut a = m("a", Some("content"), &[]);
a.latest_release.as_mut().unwrap().info_json.dependencies = Some(vec!["space-age".into()]);
let i = ExploreIndex::new(vec![a, m("b", Some("tweaks"), &[])], "2.0");
let mut s = ViewState::default();
assert_eq!(count(&i, &s, "space-age"), 1);
s.set_filter("space-age", FilterMode::Include);
assert_eq!(names(&i, &s), ["a"]);
s.set_filter("tweaks", FilterMode::Include);
assert!(names(&i, &s).is_empty());
assert_eq!(count(&i, &s, "space-age"), 0);
assert_eq!(count(&i, &s, "content"), 1);
}
#[test]
fn case_insensitive_search_covers_title_name_owner_summary_and_unicode() {
let mut a = m("internal-name", None, &[]);
a.title = "Énergie".into();
a.owner = "Engineer".into();
a.summary = "Factory Helpers".into();
let i = ExploreIndex::new(vec![a], "2.0");
for q in ["NAME", "éNERGIE", "ENGINEER", "HELPERS", ""] {
assert_eq!(
names(
&i,
&ViewState {
search: q.into(),
..Default::default()
}
),
["internal-name"]
);
}
}
#[test]
fn relevance_ranks_exact_prefix_contains_then_other_fields_and_download_ties() {
let mut mods: Vec<_> = ["z-exact", "prefix", "contains", "other", "empty"]
.iter()
.map(|n| m(n, None, &[]))
.collect();
for (m, title) in
mods.iter_mut()
.zip(["Rail", "Rail planner", "A Rail helper", "Helper", "Helper"])
{
m.title = title.into();
}
mods[3].owner = "Rail".into();
mods[4].summary = "Rail".into();
mods[4].downloads_count = 10;
let i = ExploreIndex::new(mods, "2.0");
assert_eq!(
names(
&i,
&ViewState {
search: "rail".into(),
..Default::default()
}
),
["z-exact", "prefix", "contains", "empty", "other"]
);
assert_eq!(names(&i, &ViewState::default())[0], "empty");
}
#[test]
fn downloads_updated_trending_and_final_english_name_tiebreak() {
let mut a = m("a", None, &[]);
let mut b = m("b", None, &[]);
let mut c = m("c", None, &[]);
a.downloads_count = 8;
b.downloads_count = 8;
c.downloads_count = 9;
a.score = Some(-1.0);
b.score = Some(1.0);
for (m, date) in [
(&mut a, "2026-01-01"),
(&mut b, "2026-03-01"),
(&mut c, "2026-02-01"),
] {
m.latest_release.as_mut().unwrap().released_at = date.into();
}
let i = ExploreIndex::new(vec![c, b, a], "2.0");
for (sort, expected) in [
(Sort::Downloads, ["c", "a", "b"]),
(Sort::Updated, ["b", "c", "a"]),
(Sort::Trending, ["b", "a", "c"]),
] {
assert_eq!(
names(
&i,
&ViewState {
sort,
..Default::default()
}
),
expected
);
}
}
#[test]
#[ignore = "release timing probe; run fixture generator first"]
fn time_catalogue_load_and_queries_24k() {
let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../out/fixtures/catalogue-24k.json");
let start = std::time::Instant::now();
let mut c = Catalogue::load(&path).unwrap();
eprintln!("24k file read+parse: {:?}", start.elapsed());
assert_eq!(c.results.len(), 24000);
for m in &mut c.results {
m.latest_release
.as_mut()
.unwrap()
.info_json
.factorio_version = "2.0".into();
}
let start = std::time::Instant::now();
let i = ExploreIndex::new(c.results, "2.0.77");
eprintln!("24k index: {:?}", start.elapsed());
for sort in [
Sort::Relevance,
Sort::Downloads,
Sort::Updated,
Sort::Trending,
] {
for search in ["", "factory", "fixture"] {
let mut state = ViewState {
sort,
search: search.into(),
..Default::default()
};
state.set_filter("internal", FilterMode::Off);
let mut max = std::time::Duration::ZERO;
for _ in 0..20 {
let start = std::time::Instant::now();
let r = i.query(&state);
std::hint::black_box(r);
max = max.max(start.elapsed());
}
eprintln!("24k query {sort:?} {search:?}: max of 20 {max:?}");
}
}
}
#[test]
fn counts_are_unknown_when_the_catalogue_lacks_tags_and_dependencies() {
let bit = |id: &str| 1u32 << FILTERS.iter().position(|s| *s == id).unwrap();
let mut bare = m("bare", Some("content"), &[]);
bare.tags = None;
let index = ExploreIndex::new(vec![bare.clone()], "2.0.77");
let known = index.query(&ViewState::default()).known;
assert_ne!(known & bit("content"), 0);
assert_eq!(known & bit("trains"), 0);
assert_eq!(known & 1, 0, "Space Age needs dependencies");
let index = ExploreIndex::new(vec![bare, m("tagged", None, &["trains"])], "2.0.77");
let known = index.query(&ViewState::default()).known;
assert_ne!(known & bit("trains"), 0);
assert_eq!(known >> 28, 0);
}