Files
horizon-airdef/launcher/src/instances/tests.rs
T
socksprox 9b6faeb8cf launcher: the game's made-up name can be rolled for a new one
The game's own name (horizon-player.txt) isn't a kept offline name, so
Forget never applied to it and there was no way to be rid of it. Settings
> Account shows it with "New name", which writes a fresh PlayerNNNNN to
every existing game home — the default and each instance's — so the
player stays the same (new) player in its worlds, as PLAYER_FILES' copies
do.

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
2026-10-27 18:13:55 +01:00

300 lines
11 KiB
Rust

use super::*;
use std::collections::BTreeMap;
fn scratch(name: &str) -> PathBuf {
let root = std::env::temp_dir().join(format!(
"horizon-launcher-instances-{name}-{}",
std::process::id()
));
let _ = fs::remove_dir_all(&root);
fs::create_dir_all(&root).unwrap();
root
}
fn put(path: &Path, text: &str) {
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, text).unwrap();
}
/// Every file under `dir`, relative, with its bytes.
fn files(dir: &Path) -> BTreeMap<PathBuf, Vec<u8>> {
fn walk(root: &Path, dir: &Path, out: &mut BTreeMap<PathBuf, Vec<u8>>) {
for e in fs::read_dir(dir).unwrap().flatten() {
let p = e.path();
if p.is_dir() {
walk(root, &p, out);
} else {
out.insert(p.strip_prefix(root).unwrap().into(), fs::read(&p).unwrap());
}
}
}
let mut out = BTreeMap::new();
walk(dir, dir, &mut out);
out
}
/// A game home as a player has it before instances: worlds, options, packs, a session, an
/// imported modpack and a registry modpack with their own worlds.
fn player_home(home: &Path) {
put(&home.join("saves/World/level.dat"), "world");
put(&home.join("saves/World/region/r.0.0.mca"), "region");
put(&home.join("saves/Other/level.dat"), "other");
put(&home.join("options.txt"), "fov:90\n");
put(&home.join("horizon-player.txt"), "name:Player123\n");
put(&home.join("resourcepacks/faithful.zip"), "pack");
put(&home.join("logs/latest.log"), "log");
put(&home.join("sessions/a.json"), "token");
put(&home.join("telemetry/consent.json"), "{}");
let pack = horizon_port_pack::import::Pack {
name: "Small Pack".into(),
..Default::default()
};
put(
&home.join("ports/small-pack/pack.json"),
&serde_json::to_string(&pack).unwrap(),
);
put(
&home.join("ports/small-pack/home/saves/Modded/level.dat"),
"modded",
);
put(
&home.join("horizon-packs/cozy/pack.json"),
r#"{"id":"cozy","name":"Cozy","version":"1.0.0","sha256":"00","mods":[]}"#,
);
put(
&home.join("horizon-packs/cozy/home/saves/Cozy/level.dat"),
"cozy",
);
}
#[test]
fn a_new_player_name_replaces_the_kept_one_everywhere() {
let root = scratch("newname");
let (home, data) = (root.join("horizon"), root.join("launcher"));
player_home(&home);
// An own instance that has the old name, and one with no file yet.
put(
&home.join("instances/one/horizon-player.txt"),
"name:Player123\n",
);
fs::create_dir_all(home.join("instances/two")).unwrap();
let name = new_player_name_in(&home, &data).unwrap();
assert_ne!(name, "Player123");
assert!(name.starts_with("Player") && name.len() == 11);
let kept = |home: &Path| fs::read_to_string(home.join("horizon-player.txt")).unwrap();
for h in [
&home,
&home.join("instances/one"),
&home.join("instances/two"),
&home.join("ports/small-pack/home"),
&home.join("horizon-packs/cozy/home"),
] {
assert_eq!(kept(h), format!("name:{name}\n"), "{}", h.display());
}
let _ = fs::remove_dir_all(&root);
}
#[test]
fn existing_worlds_stay_where_they_are_and_every_folder_becomes_an_instance() {
let root = scratch("migrate");
let (home, data) = (root.join("horizon"), root.join("launcher"));
player_home(&home);
let before = files(&home);
// A launcher with instances, on a player's existing folders: no instances.json yet.
let all = list_in(&home, &data);
let ids: Vec<&str> = all.iter().map(|i| i.id.as_str()).collect();
assert_eq!(ids, [DEFAULT, "pack:cozy", "port:small-pack"]);
assert_eq!(all[0].name, "Horizon");
assert_eq!(all[0].home, home);
assert_eq!(all[1].home, home.join("horizon-packs/cozy/home"));
assert_eq!(all[2].name, "Small Pack");
assert_eq!(all[2].home, home.join("ports/small-pack/home"));
// Everything the player can do with instances, then not one byte of theirs has moved.
let empty = create_in(&home, &data, "Survival", None).unwrap();
let copy = create_in(&home, &data, "My copy", Some(&all[0])).unwrap();
edit_in(&home, &data, DEFAULT, |m| m.name = Some("Main".into())).unwrap();
edit_in(&home, &data, "Small Pack", |m| {
m.icon = Some(Icon::Texture("diamond".into()));
m.group = Some("Modded".into());
})
.unwrap();
let after = files(&home);
for (path, bytes) in &before {
assert_eq!(after.get(path), Some(bytes), "{} changed", path.display());
}
assert!(!data.join("settings.json").exists());
// The empty one has only the player's options and name; the copy has the worlds and
// packs, never the sessions, logs, data collection or other instances.
assert_eq!(empty.home, home.join("instances/survival"));
let empty_files: Vec<PathBuf> = files(&empty.home).into_keys().collect();
assert_eq!(
empty_files,
[PathBuf::from("horizon-player.txt"), "options.txt".into()]
);
let copied = files(&copy.home);
for kept in [
"saves/World/region/r.0.0.mca",
"saves/Other/level.dat",
"resourcepacks/faithful.zip",
] {
assert_eq!(copied[Path::new(kept)], before[Path::new(kept)]);
}
assert!(copied.keys().all(|p| {
let top = p.components().next().unwrap().as_os_str().to_str().unwrap();
!NOT_COPIED.contains(&top)
}));
let all = list_in(&home, &data);
assert_eq!(all[0].name, "Main");
let port = find_in(&all, "port:small-pack").unwrap();
assert_eq!(port.group.as_deref(), Some("Modded"));
assert_eq!(port.home, home.join("ports/small-pack/home"));
fs::remove_dir_all(&root).unwrap();
}
#[test]
fn names_stay_unique_and_packs_are_not_copied() {
let root = scratch("names");
let (home, data) = (root.join("horizon"), root.join("launcher"));
player_home(&home);
create_in(&home, &data, "Survival", None).unwrap();
assert!(create_in(&home, &data, "survival", None).is_err());
assert!(create_in(&home, &data, " ", None).is_err());
// Another name with the same folder name gets the next free folder.
let second = create_in(&home, &data, "Survival!", None).unwrap();
assert_eq!(second.id, "survival-2");
assert_eq!(second.name, "Survival!");
assert!(edit_in(&home, &data, "survival-2", |m| m.name =
Some("SURVIVAL".into()))
.is_err());
let port = find_in(&list_in(&home, &data), "small-pack").unwrap();
assert!(create_in(&home, &data, "Pack copy", Some(&port)).is_err());
assert!(!home.join("instances/pack-copy").exists());
// An empty group is no group.
let grouped = edit_in(&home, &data, "Survival", |m| m.group = Some(" ".into())).unwrap();
assert_eq!(grouped.group, None);
// An import named like an instance: both can still change everything but their names.
let mut store = Store::load(&data);
store.instances.entry(port.id.clone()).or_default().name = Some("Survival".into());
store.save(&data).unwrap();
let launched = edit_in(&home, &data, "survival", |m| {
m.launch.wrapper = "nice".into()
})
.unwrap();
assert_eq!(launched.launch.wrapper, "nice");
assert!(edit_in(&home, &data, "survival-2", |m| m.name =
Some("survival".into()))
.is_err());
fs::remove_dir_all(&root).unwrap();
}
#[test]
fn an_instance_follows_the_players_answers() {
let root = scratch("follow");
let (main, own) = (root.join("main"), root.join("own"));
put(&main.join("options.txt"), "fov:90\n");
put(&main.join("horizon-player.txt"), "name:Player123\n");
put(&main.join("telemetry/consent.json"), r#"{"version":1}"#);
horizon_core::no_ai::set(&main, true).unwrap();
put(&own.join("options.txt"), "fov:70\n");
follow_player(&main, &own);
assert_eq!(
fs::read_to_string(own.join("options.txt")).unwrap(),
"fov:70\n"
);
assert_eq!(
fs::read_to_string(own.join("horizon-player.txt")).unwrap(),
"name:Player123\n"
);
assert_eq!(
fs::read_to_string(own.join("telemetry/consent.json")).unwrap(),
r#"{"version":1}"#
);
assert!(horizon_core::no_ai::is_on(&own));
horizon_core::no_ai::set(&main, false).unwrap();
follow_player(&main, &own);
assert!(!horizon_core::no_ai::is_on(&own));
fs::remove_dir_all(&root).unwrap();
}
#[test]
fn icons_are_a_texture_name_or_a_colour() {
assert_eq!(Icon::parse("#3FA7D6"), Ok(Icon::Colour("#3fa7d6".into())));
assert_eq!(
Icon::parse("grass_block"),
Ok(Icon::Texture("grass_block".into()))
);
for bad in ["#12345", "../x", "Grass", "", "#zzzzzz"] {
assert!(Icon::parse(bad).is_err(), "{bad}");
}
let root = scratch("icon");
put(
&root.join("assets/minecraft/textures/item/diamond.png"),
"png",
);
let diamond = Icon::Texture("diamond".into()).texture(&root).unwrap();
assert!(diamond.ends_with("item/diamond.png"));
assert_eq!(Icon::Texture("stone".into()).texture(&root), None);
fs::remove_dir_all(&root).unwrap();
}
#[test]
fn an_instance_keeps_its_own_version_until_it_follows_updates_again() {
let root = scratch("version");
let (home, data) = (root.join("horizon"), root.join("launcher"));
player_home(&home);
create_in(&home, &data, "Old world", None).unwrap();
let pinned = edit_in(&home, &data, "Old world", |m| {
m.version = Some("v0.1.0".into())
})
.unwrap();
assert_eq!(pinned.version.as_deref(), Some("v0.1.0"));
// Renaming keeps it; the other instances follow the launcher's version.
let renamed = edit_in(&home, &data, "old-world", |m| m.name = Some("Older".into())).unwrap();
assert_eq!(renamed.version.as_deref(), Some("v0.1.0"));
assert!(list_in(&home, &data)
.iter()
.filter(|i| i.id != "old-world")
.all(|i| i.version.is_none()));
let follows = edit_in(&home, &data, "Older", |m| m.version = None).unwrap();
assert_eq!(follows.version, None);
fs::remove_dir_all(&root).unwrap();
}
#[test]
fn play_time_adds_up_per_instance_and_survives_a_rename() {
let root = scratch("play-time");
let (home, data) = (root.join("home"), root.join("data"));
fs::create_dir_all(home.join(OWN).join("skyblock")).unwrap();
let ended = UNIX_EPOCH + Duration::from_secs(1_800_000_000);
record_play_in(&data, "skyblock", Duration::from_secs(25 * 60 + 10), ended).unwrap();
edit_in(&home, &data, "skyblock", |m| m.name = Some("Sky".into())).unwrap();
let later = ended + Duration::from_secs(3600);
record_play_in(&data, "skyblock", Duration::from_secs(40 * 60), later).unwrap();
let all = list_in(&home, &data);
let sky = find_in(&all, "Sky").unwrap();
assert_eq!(sky.played, Duration::from_secs(65 * 60 + 10));
assert_eq!(sky.last_played, Some(later));
let default = find_in(&all, DEFAULT).unwrap();
assert_eq!(
(default.played, default.last_played),
(Duration::ZERO, None)
);
// Never played: nothing written for it.
let text = fs::read_to_string(data.join(FILE)).unwrap();
assert!(!text.contains("horizon"), "{text}");
fs::remove_dir_all(&root).unwrap();
}
#[test]
fn play_time_reads_as_minutes_then_hours() {
let t = |s| play_time(Duration::from_secs(s));
assert_eq!(t(59), "under a minute");
assert_eq!(t(12 * 60 + 59), "12 min");
assert_eq!(t(3 * 3600 + 5 * 60), "3 h 05 min");
assert_eq!(t(140 * 3600 + 7 * 60), "140 h");
}