From 7e513d2d5c85eefdf4b23d3e1295699e45cc4886 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 24 Oct 2026 22:47:37 +0200 Subject: [PATCH] Launcher: Horizon's registry as a mod browser source A browser source for Horizon's own registry (docs/api/mod-index.md): it reads index.json (HORIZON_MOD_INDEX for a test registry, cached in the game folder for when the registry can't be reached), searches it by kind and words, lists versions with the SHA-256 the index gives, and blocks the versions it says were taken down. Downloads accept the registry's release host and check SHA-256; file:// files only from a local index. Installing, the takedown check before play and the CLI come next. Co-Authored-By: Claude Opus 5.5 --- launcher/Cargo.lock | 9 + launcher/Cargo.toml | 2 + launcher/src/browser.rs | 40 +++- launcher/src/browser/curseforge.rs | 1 + launcher/src/browser/download.rs | 41 +++- launcher/src/browser/horizon.rs | 280 ++++++++++++++++++++++++ launcher/src/browser/horizon/tests.rs | 61 ++++++ launcher/src/browser/installed/tests.rs | 1 + launcher/src/browser/java.rs | 1 + launcher/src/browser/modrinth.rs | 1 + launcher/src/browser/tests.rs | 4 +- 11 files changed, 423 insertions(+), 18 deletions(-) create mode 100644 launcher/src/browser/horizon.rs create mode 100644 launcher/src/browser/horizon/tests.rs diff --git a/launcher/Cargo.lock b/launcher/Cargo.lock index 5155420e0..a416a39ff 100644 --- a/launcher/Cargo.lock +++ b/launcher/Cargo.lock @@ -2673,6 +2673,7 @@ dependencies = [ "horizon-bench", "horizon-core", "horizon-friends", + "horizon-mods", "horizon-port-pack", "horizon-prepare", "horizon-release-sign", @@ -2698,8 +2699,10 @@ name = "horizon-mods" version = "0.1.0" dependencies = [ "log", + "minisign-verify", "serde", "serde_json", + "sha2 0.10.9", "toml 1.1.8+spec-1.1.0", "zip", ] @@ -3470,6 +3473,12 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" +[[package]] +name = "minisign-verify" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "871285dc19d8d0ebe0eef3d0e99a205f2a71363b122632cbbfa4a6c370a960ce" + [[package]] name = "miniz_oxide" version = "0.8.9" diff --git a/launcher/Cargo.toml b/launcher/Cargo.toml index a402d0e28..cfe9787d6 100644 --- a/launcher/Cargo.toml +++ b/launcher/Cargo.toml @@ -31,6 +31,8 @@ horizon-friends = { path = "../crates/horizon-friends" } horizon-bench = { path = "../crates/horizon-bench" } # Import modpack: the porting pipeline, run on the player's own files (docs/modpacks.md). horizon-port-pack = { path = "../crates/horizon-port-pack" } +# Horizon's mod registry: its index and the checks a download passes before install. +horizon-mods = { path = "../crates/horizon-mods", features = ["index"] } # Signed updates: archives are checked against the release's signed checksums (docs/security.md). horizon-release-sign = { path = "../crates/horizon-release-sign" } # Opt-in data collection: the consent, the outbox and its upload (docs/telemetry.md). diff --git a/launcher/src/browser.rs b/launcher/src/browser.rs index f02638db5..7f81d5e37 100644 --- a/launcher/src/browser.rs +++ b/launcher/src/browser.rs @@ -8,6 +8,7 @@ pub mod curseforge; pub mod details; pub mod download; +pub mod horizon; pub mod images; pub mod installed; pub mod java; @@ -56,6 +57,8 @@ impl Kind { pub enum SourceId { Modrinth, CurseForge, + /// Horizon's own registry of reviewed mods, modpacks and resource packs ([`horizon`]). + Horizon, } impl SourceId { @@ -63,6 +66,7 @@ impl SourceId { match self { SourceId::Modrinth => "Modrinth", SourceId::CurseForge => "CurseForge", + SourceId::Horizon => "Horizon", } } } @@ -132,6 +136,8 @@ pub struct FileRef { pub name: String, pub size: u64, pub sha512: Option, + /// What Horizon's registry lists. + pub sha256: Option, pub sha1: Option, pub primary: bool, } @@ -139,11 +145,13 @@ pub struct FileRef { impl FileRef { /// The strongest checksum the source gives: what the download is checked against. pub fn checksum(&self) -> Option<(&'static str, &str)> { - match (&self.sha512, &self.sha1) { - (Some(h), _) => Some(("SHA-512", h)), - (None, Some(h)) => Some(("SHA-1", h)), - (None, None) => None, - } + [ + ("SHA-512", &self.sha512), + ("SHA-256", &self.sha256), + ("SHA-1", &self.sha1), + ] + .into_iter() + .find_map(|(algo, h)| Some((algo, h.as_deref()?))) } } @@ -230,10 +238,11 @@ pub trait Source: Send + Sync { /// What the launcher says wherever CurseForge would be. pub const CURSEFORGE_SOON: &str = "CurseForge support is coming soon."; -/// The sources this launcher uses: Modrinth. CurseForge support is coming soon: its API needs a -/// paid key, so no search or install goes to it; `curseforge` is kept for then. +/// The sources this launcher uses: Modrinth and Horizon's registry. CurseForge support is coming +/// soon: its API needs a paid key, so no search or install goes to it; `curseforge` is kept for +/// then. pub fn sources() -> Vec> { - vec![Box::new(modrinth::Modrinth)] + vec![Box::new(modrinth::Modrinth), Box::new(horizon::Registry)] } /// The source of that id, when this launcher can use it. @@ -243,6 +252,15 @@ pub fn source(id: SourceId) -> Option> { /// How well a project of `kind` made for `game_versions` and `loaders` runs in Horizon. pub fn support(kind: Kind, game_versions: &[String], loaders: &[String]) -> Support { + if loaders.iter().any(|l| l == horizon::LOADER) { + // Made for Horizon and reviewed: it runs when it is for the version Horizon plays. + return match newest_release(game_versions) + .filter(|_| !game_versions.iter().any(|v| v == GAME)) + { + Some(other) => Support::No(format!("Made for Horizon on {other}.")), + None => Support::Works, + }; + } match kind { Kind::ResourcePack => { if game_versions.iter().any(|v| v == GAME) { @@ -309,6 +327,12 @@ pub fn pick(kind: Kind, versions: &[Version], everything: bool) -> Option<&Versi let mut usable = versions .iter() .filter(|v| v.blocked.is_none() && v.file().is_some()); + if versions + .iter() + .any(|v| v.loaders.iter().any(|l| l == horizon::LOADER)) + { + return usable.find(|v| v.game_versions.iter().any(|g| g == GAME)); + } if kind == Kind::Mod { let java = |v: &&Version| { v.loaders diff --git a/launcher/src/browser/curseforge.rs b/launcher/src/browser/curseforge.rs index 4894fe5f0..e17a6b822 100644 --- a/launcher/src/browser/curseforge.rs +++ b/launcher/src/browser/curseforge.rs @@ -164,6 +164,7 @@ pub(super) fn parse_file(f: &Value) -> Option { name: name.clone(), size: f["fileLength"].as_u64().unwrap_or(0), sha512: None, + sha256: None, sha1, primary: true, }] diff --git a/launcher/src/browser/download.rs b/launcher/src/browser/download.rs index 66199fd07..593273245 100644 --- a/launcher/src/browser/download.rs +++ b/launcher/src/browser/download.rs @@ -1,16 +1,18 @@ //! Downloads that reach the game folder only when their checksum matches the source's. use super::{safe_name, FileRef}; use sha1::Sha1; -use sha2::{Digest, Sha512}; +use sha2::{Digest, Sha256, Sha512}; use std::fs; use std::io::{Read, Write}; use std::path::{Path, PathBuf}; -/// Hosts a file may come from: Modrinth's and CurseForge's file servers. -const HOSTS: [&str; 3] = [ +/// Hosts a file may come from: Modrinth's and CurseForge's file servers, and the release assets +/// of Horizon's registry. +const HOSTS: [&str; 4] = [ "https://cdn.modrinth.com/", "https://edge.forgecdn.net/", "https://mediafilez.forgecdn.net/", + horizon_mods::index::FILE_HOST, ]; /// Bigger than any pack these sources serve (Modrinth caps uploads at 500 MiB). const MAX: u64 = 1 << 30; @@ -31,10 +33,15 @@ pub(super) fn agent() -> ureq::Agent { pub fn refuse(file: &FileRef) -> Option { if !HOSTS.iter().any(|h| file.url.starts_with(h)) { return Some(format!( - "{} isn't on Modrinth's or CurseForge's file servers.", + "{} isn't on Modrinth's, CurseForge's or Horizon's file servers.", file.url )); } + refuse_file(file) +} + +/// [`refuse`] without the host: the name, the checksum and the size. +fn refuse_file(file: &FileRef) -> Option { if safe_name(&file.name).is_none() { return Some(format!("{:?} isn't a plain file name.", file.name)); } @@ -50,26 +57,29 @@ pub fn refuse(file: &FileRef) -> Option { /// Hashes as they are written: the strongest one the file lists. enum Hasher { Sha512(Sha512), + Sha256(Sha256), Sha1(Sha1), } impl Hasher { fn for_file(file: &FileRef) -> Self { - if file.sha512.is_some() { - Hasher::Sha512(Sha512::new()) - } else { - Hasher::Sha1(Sha1::new()) + match file.checksum() { + Some(("SHA-512", _)) => Hasher::Sha512(Sha512::new()), + Some(("SHA-256", _)) => Hasher::Sha256(Sha256::new()), + _ => Hasher::Sha1(Sha1::new()), } } fn update(&mut self, bytes: &[u8]) { match self { Hasher::Sha512(h) => h.update(bytes), + Hasher::Sha256(h) => h.update(bytes), Hasher::Sha1(h) => h.update(bytes), } } fn hex(self) -> String { let bytes: Vec = match self { Hasher::Sha512(h) => h.finalize().to_vec(), + Hasher::Sha256(h) => h.finalize().to_vec(), Hasher::Sha1(h) => h.finalize().to_vec(), }; bytes.iter().map(|b| format!("{b:02x}")).collect() @@ -81,13 +91,26 @@ impl Hasher { /// `progress` gets the fraction done. pub fn save( file: &FileRef, - mut reader: impl Read, + reader: impl Read, folder: &Path, progress: &dyn Fn(f32), ) -> Result { if let Some(why) = refuse(file) { return Err(why); } + save_from_anywhere(file, reader, folder, progress) +} + +/// [`save`] for a file that comes from no host: a local test registry's. +pub(super) fn save_from_anywhere( + file: &FileRef, + mut reader: impl Read, + folder: &Path, + progress: &dyn Fn(f32), +) -> Result { + if let Some(why) = refuse_file(file) { + return Err(why); + } let (algo, want) = file.checksum().expect("refuse checks for one"); fs::create_dir_all(folder).map_err(|e| format!("{}: {e}", folder.display()))?; let target = folder.join(&file.name); diff --git a/launcher/src/browser/horizon.rs b/launcher/src/browser/horizon.rs new file mode 100644 index 000000000..a54bca17f --- /dev/null +++ b/launcher/src/browser/horizon.rs @@ -0,0 +1,280 @@ +//! Horizon's own registry (docs/api/mod-index.md): mods, modpacks and resource packs made for +//! Horizon, reviewed as pull requests in ludovic111/horizon-mods. One file lists them all, +//! `index.json`: this is the browser source that searches it and downloads its files, checked +//! against the SHA-256 it lists. Versions the index says were taken down are blocked. +use super::{ + details::{Details, Link}, + download, FileRef, Kind, Project, Query, Source, SourceId, Version, GAME, +}; +use horizon_mods::index::{self, Index}; +use std::fs; +use std::path::{Path, PathBuf}; +use std::sync::{Arc, Mutex}; +use std::time::{Duration, Instant}; + +/// Where the registry publishes its index (GitHub Pages of ludovic111/horizon-mods). +pub const INDEX_URL: &str = "https://ludovic111.github.io/horizon-mods/index.json"; +/// The registry's pages on the website, `/`. +const SITE: &str = "https://playhorizon.dev/mods"; +/// The report form of a project. +const REPORT: &str = "https://github.com/ludovic111/horizon-mods/issues/new?template=report.yml"; +/// The loader name the browser gives registry versions, so `support` and `pick` know them. +pub const LOADER: &str = "horizon"; +/// How long a fetched index is used before it is fetched again. +const FRESH: Duration = Duration::from_secs(600); +/// Larger than any index should be. +const MAX_INDEX: u64 = 16 << 20; +/// The last index fetched, kept in the game folder for when the registry can't be reached. +const CACHE: &str = "mod-browser/horizon-index.json"; + +/// Where the index comes from: `HORIZON_MOD_INDEX` (a file or an `https://` address, for a +/// test registry), else [`INDEX_URL`]. +fn location() -> String { + std::env::var("HORIZON_MOD_INDEX") + .ok() + .filter(|v| !v.is_empty()) + .unwrap_or_else(|| INDEX_URL.to_owned()) +} + +/// True when the index is a local file: its files may then be local too (`file://`), for +/// trying a registry out before it is published. +pub fn local() -> bool { + !location().starts_with("https://") +} + +static LOADED: Mutex)>> = Mutex::new(None); + +/// The index: the one fetched in the last ten minutes, else fetched again (and kept in the game +/// folder), else the copy kept last time. +pub fn index() -> Result, String> { + if let Some((at, index)) = LOADED.lock().unwrap().as_ref() { + if at.elapsed() < FRESH { + return Ok(index.clone()); + } + } + let cache = crate::backend::game_home().join(CACHE); + let index = match fetch_index() { + Ok((index, text)) => { + if let Some(dir) = cache.parent() { + let _ = fs::create_dir_all(dir); + } + let _ = fs::write(&cache, text); + index + } + Err(e) => { + let kept = fs::read_to_string(&cache).map_err(|_| e.clone())?; + match local() { + true => Index::parse_local(&kept), + false => Index::parse(&kept), + } + .map_err(|_| e)? + } + }; + let index = Arc::new(index); + *LOADED.lock().unwrap() = Some((Instant::now(), index.clone())); + Ok(index) +} + +fn fetch_index() -> Result<(Index, String), String> { + use std::io::Read; + let at = location(); + let text = if at.starts_with("https://") { + let response = download::agent().get(&at).call().map_err(|e| match e { + ureq::Error::Status(code, _) => format!("The mod registry answered {code}."), + ureq::Error::Transport(t) => format!("The mod registry can't be reached: {t}"), + })?; + let mut text = String::new(); + response + .into_reader() + .take(MAX_INDEX) + .read_to_string(&mut text) + .map_err(|e| e.to_string())?; + text + } else { + fs::read_to_string(&at).map_err(|e| format!("{at}: {e}"))? + }; + let index = match local() { + true => Index::parse_local(&text)?, + false => Index::parse(&text)?, + }; + Ok((index, text)) +} + +/// The browser's kind for a registry kind; None for one the launcher doesn't install yet +/// (Horizon modpacks and shader packs, kinds newer than this launcher). +fn kind_of(kind: &index::Kind) -> Option { + match kind { + index::Kind::Mod => Some(Kind::Mod), + index::Kind::ResourcePack => Some(Kind::ResourcePack), + index::Kind::Modpack | index::Kind::Shader | index::Kind::Other(_) => None, + } +} + +fn project_of(p: &index::Project) -> Option { + let mut game_versions: Vec = p.versions.iter().map(|v| v.game.clone()).collect(); + game_versions.dedup(); + Some(Project { + source: SourceId::Horizon, + id: p.id.clone(), + slug: p.id.clone(), + title: p.name.clone(), + summary: p.summary.clone(), + author: p.authors.join(", "), + downloads: 0, + page: format!("{SITE}/{}", p.id), + icon: p.icon.clone(), + license: p.license.clone(), + kind: kind_of(&p.kind)?, + game_versions, + loaders: vec![LOADER.into()], + }) +} + +fn version_of(index: &Index, p: &index::Project, v: &index::Version) -> Version { + Version { + id: v.version.clone(), + number: v.version.clone(), + published: v.published.clone(), + game_versions: vec![v.game.clone()], + loaders: vec![LOADER.into()], + files: vec![FileRef { + url: v.file.url.clone(), + name: v.file.name.clone(), + size: v.file.size, + sha512: None, + sha256: Some(v.file.sha256.clone()), + sha1: None, + primary: true, + }], + required: v.requires.iter().map(|r| r.id.clone()).collect(), + blocked: index + .revoked(&p.id, &v.file.sha256) + .map(|r| format!("taken down: {}", r.reason)), + } +} + +/// The words of a query found in a project's id, name, summary or authors. +fn matches(p: &index::Project, text: &str) -> bool { + let hay = format!("{} {} {} {}", p.id, p.name, p.summary, p.authors.join(" ")).to_lowercase(); + text.split_whitespace() + .all(|word| hay.contains(&word.to_lowercase())) +} + +/// The projects of the query's kind whose words match, for this game unless `everything`. +fn search(index: &Index, query: &Query) -> Vec { + index + .projects + .iter() + .filter(|p| kind_of(&p.kind) == Some(query.kind) && matches(p, &query.text)) + .filter(|p| query.everything || p.versions.iter().any(|v| v.game == GAME)) + .filter_map(project_of) + .skip(query.offset) + .take(query.limit) + .collect() +} + +/// The registry as a browser source. +pub struct Registry; + +impl Source for Registry { + fn id(&self) -> SourceId { + SourceId::Horizon + } + + fn search(&self, query: &Query) -> Result, String> { + Ok(search(&*index()?, query)) + } + + fn project(&self, id: &str) -> Result { + let index = index()?; + let p = index + .project(id) + .ok_or_else(|| format!("{id} isn't in Horizon's registry."))?; + project_of(p).ok_or_else(|| { + format!( + "{} is a {} in Horizon's registry: this launcher can't install those yet.", + p.name, + p.kind.name() + ) + }) + } + + fn versions(&self, project: &Project) -> Result, String> { + let index = index()?; + let p = index + .project(&project.id) + .ok_or_else(|| format!("{} isn't in Horizon's registry.", project.title))?; + Ok(p.versions + .iter() + .map(|v| version_of(&index, p, v)) + .collect()) + } + + fn details(&self, project: &Project) -> Result { + let index = index()?; + let p = index + .project(&project.id) + .ok_or_else(|| format!("{} isn't in Horizon's registry.", project.title))?; + let newest = p.versions.first(); + let mut body = p.description.clone(); + if let Some(v) = newest.filter(|v| !v.capabilities.is_empty()) { + body.push_str("\n\n## What it may do\n\n"); + for c in &v.capabilities { + body.push_str(&format!("- May {}\n", c.describe())); + } + } + Ok(Details { + body, + links: vec![ + Link { + label: "Source".into(), + url: p.source.clone(), + }, + Link { + label: "Page".into(), + url: project.page.clone(), + }, + Link { + label: "Report".into(), + url: format!("{REPORT}&title={}", p.id), + }, + ], + authors: p.authors.clone(), + published: p + .versions + .last() + .map(|v| v.published.clone()) + .unwrap_or_default(), + updated: newest.map(|v| v.published.clone()).unwrap_or_default(), + ..Details::default() + }) + } + + fn fetch( + &self, + file: &FileRef, + folder: &Path, + progress: &dyn Fn(f32), + ) -> Result { + fetch(file, folder, local(), progress) + } +} + +/// Downloads a registry file, checked; `file://` files only from a local index. +fn fetch( + file: &FileRef, + folder: &Path, + local: bool, + progress: &dyn Fn(f32), +) -> Result { + match file.url.strip_prefix("file://").filter(|_| local) { + Some(path) => { + let reader = fs::File::open(path).map_err(|e| format!("{path}: {e}"))?; + download::save_from_anywhere(file, reader, folder, progress) + } + None => download::fetch(file, folder, progress), + } +} + +#[cfg(test)] +mod tests; diff --git a/launcher/src/browser/horizon/tests.rs b/launcher/src/browser/horizon/tests.rs new file mode 100644 index 000000000..1ca0cf3ee --- /dev/null +++ b/launcher/src/browser/horizon/tests.rs @@ -0,0 +1,61 @@ +//! The registry source against the sample index of `horizon_mods::index` +//! (`crates/horizon-mods/tests/index/`), its files served from disk. +use super::*; + +fn fixtures() -> PathBuf { + Path::new(env!("CARGO_MANIFEST_DIR")).join("../crates/horizon-mods/tests/index") +} + +/// The sample index with its files on disk, as a local test registry lists them. +fn sample() -> Index { + let text = fs::read_to_string(fixtures().join("index-v1.json")).unwrap(); + let mut index = Index::parse(&text).unwrap(); + for p in &mut index.projects { + for v in &mut p.versions { + let path = fixtures().join(&v.file.name); + v.file.url = format!("file://{}", path.canonicalize().unwrap_or(path).display()); + } + } + index +} + +fn hud(index: &Index) -> Project { + project_of(index.project("coords_hud").unwrap()).unwrap() +} + +#[test] +fn searches_by_kind_and_words() { + let index = sample(); + let found = |text: &str, kind| -> Vec { + search(&index, &Query::new(text, kind)) + .into_iter() + .map(|p| p.id) + .collect() + }; + assert_eq!(found("", Kind::Mod), ["coords_hud"]); + assert_eq!(found("coordinates HUD", Kind::Mod), ["coords_hud"]); + assert!(found("zoom", Kind::Mod).is_empty()); + // Kinds this launcher can't install yet (modpacks, a world) are never offered. + assert!(found("", Kind::Modpack).is_empty()); + assert!(found("skyblock", Kind::ResourcePack).is_empty()); + let p = hud(&index); + assert_eq!(p.support(), super::super::Support::Works); + assert_eq!(p.page, "https://playhorizon.dev/mods/coords_hud"); +} + +#[test] +fn registry_versions_run_when_made_for_this_game() { + use super::super::{pick, support, Support}; + let v = |game: &str| vec![game.to_owned()]; + let horizon = vec![LOADER.to_owned()]; + assert_eq!(support(Kind::Mod, &v(GAME), &horizon), Support::Works); + assert!(!support(Kind::Mod, &v("26.2"), &horizon).installable()); + let index = sample(); + let p = index.project("coords_hud").unwrap(); + let versions: Vec = p + .versions + .iter() + .map(|x| version_of(&index, p, x)) + .collect(); + assert_eq!(pick(Kind::Mod, &versions, false).unwrap().number, "0.1.0"); +} diff --git a/launcher/src/browser/installed/tests.rs b/launcher/src/browser/installed/tests.rs index e940ce0f1..cb2814c29 100644 --- a/launcher/src/browser/installed/tests.rs +++ b/launcher/src/browser/installed/tests.rs @@ -86,6 +86,7 @@ impl Fake { .map(|b| format!("{b:02x}")) .collect(), ), + sha256: None, sha1: None, primary: true, }; diff --git a/launcher/src/browser/java.rs b/launcher/src/browser/java.rs index 76ce43c95..62122d1f5 100644 --- a/launcher/src/browser/java.rs +++ b/launcher/src/browser/java.rs @@ -326,6 +326,7 @@ mod tests { name: "a.jar".into(), size: 1, sha512: sha512.map(str::to_owned), + sha256: None, sha1: sha1.map(str::to_owned), primary: true, }; diff --git a/launcher/src/browser/modrinth.rs b/launcher/src/browser/modrinth.rs index 722549742..52e0aa7f0 100644 --- a/launcher/src/browser/modrinth.rs +++ b/launcher/src/browser/modrinth.rs @@ -139,6 +139,7 @@ pub(super) fn parse_version(v: &Value) -> Option { name: f["filename"].as_str()?.to_owned(), size: f["size"].as_u64().unwrap_or(0), sha512: f["hashes"]["sha512"].as_str().map(str::to_ascii_lowercase), + sha256: None, sha1: f["hashes"]["sha1"].as_str().map(str::to_ascii_lowercase), primary: f["primary"].as_bool().unwrap_or(false), }) diff --git a/launcher/src/browser/tests.rs b/launcher/src/browser/tests.rs index 6167d5bd9..50bfbae40 100644 --- a/launcher/src/browser/tests.rs +++ b/launcher/src/browser/tests.rs @@ -18,6 +18,7 @@ fn version(id: &str, games: &[&str], loaders: &[&str]) -> Version { name: format!("{id}.zip"), size: 3, sha512: Some("ab".into()), + sha256: None, sha1: None, primary: true, }], @@ -305,6 +306,7 @@ fn file_for(body: &[u8], sha512: bool) -> FileRef { name: "pack.zip".into(), size: body.len() as u64, sha512: sha512.then(|| hex(&sha2::Sha512::digest(body))), + sha256: None, sha1: (!sha512).then(|| hex(&sha1::Sha1::digest(body))), primary: true, } @@ -383,6 +385,6 @@ fn live_modrinth_search_pick_and_download() { #[test] fn curseforge_is_coming_soon_and_never_searched() { let ids: Vec = sources().iter().map(|s| s.id()).collect(); - assert_eq!(ids, [SourceId::Modrinth]); + assert_eq!(ids, [SourceId::Modrinth, SourceId::Horizon]); assert!(source(SourceId::CurseForge).is_none()); }