Files
effectcraft/crates/host/tests/it/library.rs
T
dotCooCoo 5dfcadd09b Plug-in Library: a package with an unreadable repo URL downloads nothing
When a package names a `repo` that isn't a GitHub repository URL
(`https://github.com/<owner>/<repo>`, a trailing `/` or `.git` allowed, or
a folder in one, `.../tree/<ref>/<path>`), Install, Update and Preview now
refuse its release URLs with an error naming the package. Before, such a
`repo` skipped the repository check and any GitHub release asset was
downloaded. A package without a `repo` keeps any repository's release
asset.

The example catalog's schema now holds `repo` and release `url` to the
same forms, and `scripts/validate.sh` checks that every release is an
asset of the package's `repo` before it downloads anything.
2026-11-05 23:40:33 -08:00

386 lines
22 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! The Plug-in Library in a full session, against a local catalog (`file://`): install, update,
//! remove and start-up loading of WebAssembly packages, checksum and URL rules.
use std::path::{Path, PathBuf};
use effectcraft_engine::Session;
use effectcraft_engine::project::{GroupKind, LayerId, Node};
use effectcraft_engine::segment::sha256;
use serde_json::{Value, json};
use super::plugins::wat_plugin;
/// A fresh folder for one test: the plug-ins folder and the catalog's files.
fn tmp(name: &str) -> PathBuf {
let d = std::env::temp_dir().join(format!("effectcraft-library-{name}-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&d);
std::fs::create_dir_all(d.join("served")).unwrap();
d
}
/// `p` as a `file://` URL (`file:///C:/…` on Windows).
fn file_url(p: &Path) -> String {
let s = p.to_string_lossy().replace('\\', "/");
if s.starts_with('/') { format!("file://{s}") } else { format!("file:///{s}") }
}
/// A host session that installs into `dir`.
fn session(dir: &Path) -> Session {
let mut s = effectcraft_host::session();
s.plugins_dir = Some(dir.join("Plug-ins"));
s
}
/// A served module for `effect`; returns (url, sha256).
fn serve(dir: &Path, file: &str, effect: &str) -> (String, String) {
let bytes = wat_plugin(effect, 1, "i32.const 0").into_bytes();
let path = dir.join("served").join(file);
std::fs::write(&path, &bytes).unwrap();
(file_url(&path), sha256::hex(&bytes))
}
/// Write the catalog (`packages`) and return its URL.
fn write_catalog(dir: &Path, packages: Value) -> String {
let path = dir.join("served").join("index.json");
std::fs::write(&path, json!({"schema": 1, "packages": packages}).to_string()).unwrap();
file_url(&path)
}
/// A catalog release entry for a served module.
fn release(version: &str, (url, sha): &(String, String), effect: &str) -> Value {
json!({"version": version, "api": 1, "url": url, "sha256": sha, "effects": [effect]})
}
/// The package `id` in a `library.list` reply.
fn package<'a>(list: &'a Value, id: &str) -> &'a Value {
list["packages"].as_array().unwrap().iter().find(|p| p["id"] == id).unwrap_or_else(|| panic!("no {id} in {list}"))
}
/// The effect ids registered in the process.
fn plugin_ids(s: &mut Session) -> Vec<String> {
let l = s.execute("effect.plugins.list", json!({})).unwrap();
l["plugins"].as_array().unwrap().iter().filter_map(|p| p["id"].as_str().map(str::to_string)).collect()
}
#[test]
fn install_update_and_remove_a_package() {
let dir = tmp("cycle");
let fx = "org.test.library.cycle";
let v1 = serve(&dir, "cycle-1.wasm", fx);
let catalog = write_catalog(
&dir,
json!([{"id": "org.test.cycle", "name": "Cycle", "author": "Tester", "license": "MIT", "tags": ["test"], "versions": [release("1.0.0", &v1, fx)]}]),
);
let mut s = session(&dir);
// Before a catalog: nothing listed, installing is refused.
assert_eq!(s.execute("library.list", json!({})).unwrap()["packages"], json!([]));
assert!(s.execute("library.install", json!({"id": "org.test.cycle", "wait": true})).unwrap_err().to_string().contains("library.refresh"));
assert_eq!(s.execute("library.refresh", json!({"catalog": catalog, "wait": true})).unwrap()["packages"], 1);
let l = s.execute("library.list", json!({"query": "tester"})).unwrap();
let p = package(&l, "org.test.cycle");
assert_eq!((p["latest"].as_str(), p["installed"].as_str(), p["effects"][0].as_str()), (Some("1.0.0"), None, Some(fx)), "{l}");
assert_eq!(l["tags"], json!(["test"]));
assert_eq!(s.execute("library.list", json!({"query": "no such thing"})).unwrap()["packages"], json!([]));
let r = s.execute("library.install", json!({"id": "org.test.cycle", "wait": true})).unwrap();
assert_eq!((r["installed"].as_bool(), r["restartNeeded"].as_bool()), (Some(true), Some(false)), "{r}");
assert!(plugin_ids(&mut s).iter().any(|i| i == fx), "loaded right away");
let lib = dir.join("Plug-ins").join("Library");
assert!(lib.join("org.test.cycle").join("1.0.0").join("org.test.cycle.wasm").is_file());
let installed: Value = serde_json::from_slice(&std::fs::read(lib.join("installed.json")).unwrap()).unwrap();
assert_eq!(installed["packages"]["org.test.cycle"]["version"], "1.0.0");
// The effect applies like any other.
s.execute("comp.new", json!({"name": "L", "width": 8, "height": 8, "duration": 1})).unwrap();
let layer = s.execute("layer.newSolid", json!({"color": [1, 0, 0], "width": 8, "height": 8})).unwrap()["layer"].clone();
s.execute("effect.apply", json!({"layer": layer, "effect": fx})).unwrap();
assert_eq!(s.execute("library.missing", json!({})).unwrap()["effects"], json!([]));
// Version 2: an update; the loaded version stays until the next start.
let v2 = serve(&dir, "cycle-2.wasm", fx);
let catalog = write_catalog(&dir, json!([{"id": "org.test.cycle", "name": "Cycle", "versions": [release("1.0.0", &v1, fx), release("1.10.0", &v2, fx)]}]));
s.execute("library.refresh", json!({"catalog": catalog, "wait": true})).unwrap();
assert_eq!(package(&s.execute("library.list", json!({})).unwrap(), "org.test.cycle")["updateAvailable"], true);
let r = s.execute("library.update", json!({"wait": true})).unwrap();
assert_eq!(r["updating"], json!(["org.test.cycle"]), "{r}");
let p = s.execute("library.list", json!({"installed": true})).unwrap();
let p = package(&p, "org.test.cycle");
assert_eq!((p["installed"].as_str(), p["updateAvailable"].as_bool(), p["restartNeeded"].as_bool()), (Some("1.10.0"), Some(false), Some(true)), "{p}");
assert!(!lib.join("org.test.cycle").join("1.0.0").exists(), "the old version is removed");
let r = s.execute("library.uninstall", json!({"id": "org.test.cycle"})).unwrap();
assert_eq!((r["removed"].as_bool(), r["restartNeeded"].as_bool()), (Some(true), Some(true)));
assert!(!lib.join("org.test.cycle").exists());
assert_eq!(s.execute("library.uninstall", json!({"id": "org.test.cycle"})).unwrap()["removed"], false);
// Still listed by the catalog, no longer installed.
assert!(package(&s.execute("library.list", json!({})).unwrap(), "org.test.cycle")["installed"].is_null());
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn a_wrong_checksum_or_a_bad_module_installs_nothing() {
let dir = tmp("checks");
let (url, _) = serve(&dir, "a.wasm", "org.test.library.checks.a");
let garbage = dir.join("served").join("garbage.wasm");
std::fs::write(&garbage, b"\0asm\x01\0\0\0garbage").unwrap();
let garbage_sha = sha256::hex(&std::fs::read(&garbage).unwrap());
let catalog = write_catalog(
&dir,
json!([
{"id": "org.test.badsum", "name": "Bad Sum", "versions": [{"version": "1", "api": 1, "url": url, "sha256": "0".repeat(64)}]},
{"id": "org.test.garbage", "name": "Garbage", "versions": [{"version": "1", "api": 1, "url": file_url(&garbage), "sha256": garbage_sha}]},
{"id": "org.test.web", "name": "Web", "versions": [{"version": "1", "api": 1, "url": "https://example.com/x.wasm", "sha256": "0".repeat(64)}]},
{"id": "org.test.future", "name": "Future", "versions": [{"version": "1", "api": 99, "url": url, "sha256": "0".repeat(64)}]}
]),
);
let mut s = session(&dir);
s.execute("library.refresh", json!({"catalog": catalog, "wait": true})).unwrap();
let e = s.execute("library.install", json!({"id": "org.test.badsum", "wait": true})).unwrap_err().to_string();
assert!(e.contains("SHA-256"), "{e}");
let e = s.execute("library.install", json!({"id": "org.test.garbage", "wait": true})).unwrap_err().to_string();
assert!(e.contains("didn't load"), "{e}");
let e = s.execute("library.install", json!({"id": "org.test.web", "wait": true})).unwrap_err().to_string();
assert!(e.contains("isn't on GitHub"), "{e}");
let e = s.execute("library.install", json!({"id": "org.test.future", "wait": true})).unwrap_err().to_string();
assert!(e.contains("no release for this EffectCraft"), "{e}");
assert_eq!(package(&s.execute("library.list", json!({})).unwrap(), "org.test.future")["needsNewerApp"], true);
let lib = dir.join("Plug-ins").join("Library");
for id in ["org.test.badsum", "org.test.garbage", "org.test.web"] {
assert!(!lib.join(id).exists(), "{id}");
}
assert!(!lib.join("installed.json").exists());
// Remote catalogs must be on GitHub too; the list still works from the cached copy.
assert!(s.execute("library.refresh", json!({"catalog": "https://example.com/index.json"})).unwrap_err().to_string().contains("isn't on GitHub"));
assert!(s.execute("library.refresh", json!({"catalog": "http://raw.githubusercontent.com/x"})).is_err());
let mut fresh = session(&dir);
assert_eq!(fresh.execute("library.list", json!({})).unwrap()["packages"].as_array().unwrap().len(), 4, "read from catalog.json");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn downloads_are_release_assets_of_the_package_repository() {
let dir = tmp("assets");
let sum = "0".repeat(64);
let pkg =
|id: &str, repo: &str, url: &str| json!({"id": id, "name": id, "repo": repo, "versions": [{"version": "1", "api": 1, "url": url, "sha256": sum}]});
let catalog = write_catalog(
&dir,
json!([
pkg("org.test.other", "https://github.com/me/glow", "https://github.com/someone/else/releases/download/v1/glow.wasm"),
pkg("org.test.raw", "https://github.com/me/glow", "https://raw.githubusercontent.com/me/glow/main/glow.wasm"),
pkg("org.test.page", "", "https://github.com/me/glow/blob/main/glow.wasm"),
pkg("org.test.dots", "https://github.com/me/glow", "https://github.com/me/glow/releases/download/%2e%2e/%2E%2E/x/y/glow.wasm"),
pkg("org.test.tree", "https://github.com/me/glow/tree/main", "https://github.com/someone/else/releases/download/v1/glow.wasm"),
pkg("org.test.http", "http://github.com/me/glow", "https://github.com/me/glow/releases/download/v1/glow.wasm"),
pkg("org.test.blob", "https://github.com/me/glow/blob/main/README.md", "https://github.com/me/glow/releases/download/v1/glow.wasm"),
]),
);
let mut s = session(&dir);
s.execute("library.refresh", json!({"catalog": catalog, "wait": true})).unwrap();
for (id, why) in [
("org.test.other", "isn't a release asset of the package's repository https://github.com/me/glow"),
("org.test.raw", "isn't a release asset"),
("org.test.page", "isn't a release asset"),
("org.test.dots", "isn't a release asset"),
("org.test.tree", "isn't a release asset of the package's repository https://github.com/me/glow/tree/main"),
("org.test.http", "org.test.http: the package's `repo` http://github.com/me/glow isn't a GitHub repository URL"),
("org.test.blob", "org.test.blob: the package's `repo` https://github.com/me/glow/blob/main/README.md isn't a GitHub repository URL"),
] {
for c in ["library.install", "library.preview"] {
let e = s.execute(c, json!({"id": id, "wait": true})).unwrap_err().to_string();
assert!(e.contains(why), "{c} {id}: {e}");
}
}
assert!(!dir.join("Plug-ins").join("Library").join("installed.json").exists());
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn installed_packages_load_at_start_and_changed_files_are_refused() {
let dir = tmp("startup");
let lib = dir.join("Plug-ins").join("Library");
let mut entries = serde_json::Map::new();
for (id, effect, tamper) in
[("org.test.start.ok", "org.test.library.start.ok", false), ("org.test.start.tampered", "org.test.library.start.tampered", true)]
{
let bytes = wat_plugin(effect, 1, "i32.const 0").into_bytes();
let file = format!("{id}/1.0.0/{id}.wasm");
let path = lib.join(id).join("1.0.0");
std::fs::create_dir_all(&path).unwrap();
let written = if tamper { wat_plugin(effect, 1, "i32.const 1").into_bytes() } else { bytes.clone() };
std::fs::write(path.join(format!("{id}.wasm")), written).unwrap();
entries.insert(id.into(), json!({"version": "1.0.0", "file": file, "sha256": sha256::hex(&bytes), "effects": [effect]}));
}
entries.insert("org.test.start.escape".into(), json!({"version": "1", "file": "../../outside.wasm", "sha256": "0".repeat(64)}));
std::fs::write(lib.join("installed.json"), json!({"packages": entries}).to_string()).unwrap();
let mut s = session(&dir);
let r = s.execute("library.loadInstalled", json!({})).unwrap();
let loaded: Vec<&str> = r["loaded"].as_array().unwrap().iter().filter_map(|v| v["package"].as_str()).collect();
assert_eq!(loaded, ["org.test.start.ok"], "{r}");
let errors = r["errors"].to_string();
assert!(errors.contains("org.test.start.tampered") && errors.contains("SHA-256"), "{r}");
assert!(errors.contains("bad module path"), "{r}");
assert!(plugin_ids(&mut s).iter().any(|i| i == "org.test.library.start.ok"));
// Running it again loads nothing twice.
assert_eq!(s.execute("library.loadInstalled", json!({})).unwrap()["loaded"], json!([]));
// Without a catalog the installed packages are still listed.
let l = s.execute("library.list", json!({})).unwrap();
let p = package(&l, "org.test.start.ok");
assert_eq!((p["unlisted"].as_bool(), p["loaded"].as_str()), (Some(true), Some("1.0.0")), "{l}");
// A corrupt installed.json is an empty library, not a failure.
std::fs::write(lib.join("installed.json"), b"{not json").unwrap();
assert_eq!(session(&dir).execute("library.loadInstalled", json!({})).unwrap()["loaded"], json!([]));
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn missing_effects_name_the_packages_that_provide_them() {
let dir = tmp("missing");
let fx = "org.test.library.missing.fx";
let v = serve(&dir, "m.wasm", fx);
let catalog = write_catalog(&dir, json!([{"id": "org.test.missing", "name": "Missing", "versions": [release("1.0.0", &v, fx)]}]));
let mut s = session(&dir);
s.execute("library.refresh", json!({"catalog": catalog, "wait": true})).unwrap();
// A project whose effects include one this session doesn't have (as when a project from
// someone with the plug-in opens here).
s.execute("comp.new", json!({"name": "M", "width": 8, "height": 8, "duration": 1})).unwrap();
let layer = s.execute("layer.newSolid", json!({"color": [1, 0, 0], "width": 8, "height": 8})).unwrap()["layer"].as_u64().unwrap();
s.execute("effect.apply", json!({"layer": layer, "effect": "ec.blur.gaussian"})).unwrap();
s.execute("effect.apply", json!({"layer": layer, "effect": "ec.blur.gaussian"})).unwrap();
let cid = s.active_comp_id().unwrap();
let proj = std::sync::Arc::make_mut(&mut s.project);
let l = proj.comp_mut(cid).unwrap().layer_mut(LayerId(layer)).unwrap();
let first = l.props.sub_mut("effects").unwrap().children.iter_mut().find_map(|n| match n {
Node::Group(g) => Some(g),
_ => None,
});
first.unwrap().kind = GroupKind::Effect { effect: fx.into() };
let r = s.execute("library.missing", json!({})).unwrap();
assert_eq!(r["effects"], json!([{"effect": fx, "packages": ["org.test.missing"]}]), "{r}");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn preview_renders_a_package_without_installing_it() {
let dir = tmp("preview");
let fx = "org.test.library.preview.fx";
// The preview frame (320 × 180 RGBA f32) needs more than the test module's two pages.
let bytes = wat_plugin(fx, 1, "i32.const 0").replace("(memory (export \"memory\") 2)", "(memory (export \"memory\") 20)").into_bytes();
let path = dir.join("served").join("p.wasm");
std::fs::write(&path, &bytes).unwrap();
let v = (file_url(&path), sha256::hex(&bytes));
let mut bad = release("1.0.0", &v, fx);
bad["sha256"] = json!("0".repeat(64));
let catalog = write_catalog(
&dir,
json!([
{"id": "org.test.preview", "name": "Preview", "preview": {"video": "https://www.youtube.com/watch?v=x"}, "versions": [release("1.0.0", &v, fx)]},
{"id": "org.test.preview.bad", "name": "Bad", "preview": {"video": "javascript:alert(1)"}, "versions": [bad]}
]),
);
let mut s = session(&dir);
s.execute("library.refresh", json!({"catalog": catalog, "wait": true})).unwrap();
let r = s.execute("library.preview", json!({"id": "org.test.preview", "wait": true})).unwrap();
assert_eq!((r["frames"].as_u64(), r["width"].as_u64(), r["effect"]["id"].as_str()), (Some(24), Some(320), Some(fx)), "{r}");
let st = s.library.status();
let pv = st.preview.as_ref().unwrap();
assert_eq!((pv.before.len(), pv.frames[0].len()), (320 * 180 * 4, 320 * 180 * 4));
// Previewing installs and registers nothing.
assert!(!dir.join("Plug-ins").join("Library").join("org.test.preview").exists());
assert!(!plugin_ids(&mut s).iter().any(|i| i == fx));
let l = s.execute("library.list", json!({})).unwrap();
let p = package(&l, "org.test.preview");
assert_eq!((p["previewed"].as_bool(), p["video"].as_str()), (Some(true), Some("https://www.youtube.com/watch?v=x")), "{l}");
assert!(package(&l, "org.test.preview.bad")["video"].is_null(), "only https:// videos are kept");
// Asking again answers from memory; a wrong checksum previews nothing.
assert_eq!(s.execute("library.preview", json!({"id": "org.test.preview"})).unwrap()["frames"], 24);
let e = s.execute("library.preview", json!({"id": "org.test.preview.bad", "wait": true})).unwrap_err().to_string();
assert!(e.contains("SHA-256"), "{e}");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn a_reinstall_that_fails_to_load_keeps_the_installed_copy() {
let dir = tmp("reinstall");
let fx = "org.test.library.reinstall.fx";
let v = serve(&dir, "r.wasm", fx);
let catalog = write_catalog(&dir, json!([{"id": "org.test.reinstall", "name": "Reinstall", "versions": [release("1.0.0", &v, fx)]}]));
let mut s = session(&dir);
s.execute("library.refresh", json!({"catalog": catalog, "wait": true})).unwrap();
s.execute("library.install", json!({"id": "org.test.reinstall", "wait": true})).unwrap();
// A second session in this process: the effect is registered already, so loading fails.
let mut other = session(&dir);
let e = other.execute("library.install", json!({"id": "org.test.reinstall", "wait": true})).unwrap_err().to_string();
assert!(e.contains("didn't load"), "{e}");
let lib = dir.join("Plug-ins").join("Library");
assert!(lib.join("org.test.reinstall").join("1.0.0").join("org.test.reinstall.wasm").is_file());
let installed: Value = serde_json::from_slice(&std::fs::read(lib.join("installed.json")).unwrap()).unwrap();
assert_eq!(installed["packages"]["org.test.reinstall"]["version"], "1.0.0");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn an_update_that_would_not_load_keeps_the_loaded_version() {
let dir = tmp("badupdate");
let fx = "org.test.library.badupdate.fx";
let v1 = serve(&dir, "u1.wasm", fx);
// The right checksum for a file that isn't a plug-in.
let junk = b"not a WebAssembly module".to_vec();
let path = dir.join("served").join("u2.wasm");
std::fs::write(&path, &junk).unwrap();
let v2 = (file_url(&path), sha256::hex(&junk));
let catalog = write_catalog(&dir, json!([{"id": "org.test.badupdate", "name": "Bad Update", "versions": [release("1.0.0", &v1, fx)]}]));
let mut s = session(&dir);
s.execute("library.refresh", json!({"catalog": catalog, "wait": true})).unwrap();
s.execute("library.install", json!({"id": "org.test.badupdate", "wait": true})).unwrap();
let catalog =
write_catalog(&dir, json!([{"id": "org.test.badupdate", "name": "Bad Update", "versions": [release("1.0.0", &v1, fx), release("2.0.0", &v2, fx)]}]));
s.execute("library.refresh", json!({"catalog": catalog, "wait": true})).unwrap();
// Version 1 is loaded in this session, so version 2 would only load at the next start.
let e = s.execute("library.update", json!({"id": "org.test.badupdate", "wait": true})).unwrap_err().to_string();
assert!(e.contains("didn't load"), "{e}");
let lib = dir.join("Plug-ins").join("Library");
assert!(lib.join("org.test.badupdate").join("1.0.0").join("org.test.badupdate.wasm").is_file());
assert!(!lib.join("org.test.badupdate").join("2.0.0").exists());
let installed: Value = serde_json::from_slice(&std::fs::read(lib.join("installed.json")).unwrap()).unwrap();
assert_eq!(installed["packages"]["org.test.badupdate"]["version"], "1.0.0");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn update_all_updates_every_package_and_min_app_is_enforced() {
let dir = tmp("updateall");
let (fa, fb) = ("org.test.library.updateall.a", "org.test.library.updateall.b");
let (a1, b1) = (serve(&dir, "a1.wasm", fa), serve(&dir, "b1.wasm", fb));
let catalog = write_catalog(
&dir,
json!([
{"id": "org.test.ua", "name": "A", "versions": [release("1.0.0", &a1, fa)]},
{"id": "org.test.ub", "name": "B", "versions": [release("1.0.0", &b1, fb)]}
]),
);
let mut s = session(&dir);
s.execute("library.refresh", json!({"catalog": catalog, "wait": true})).unwrap();
for id in ["org.test.ua", "org.test.ub"] {
s.execute("library.install", json!({"id": id, "wait": true})).unwrap();
}
let mut future = release("3.0.0", &a1, fa);
future["minApp"] = json!("999.0");
let catalog = write_catalog(
&dir,
json!([
{"id": "org.test.ua", "name": "A", "versions": [release("1.0.0", &a1, fa), release("2.0.0", &a1, fa), future]},
{"id": "org.test.ub", "name": "B", "versions": [release("1.0.0", &b1, fb), release("2.0.0", &b1, fb)]}
]),
);
s.execute("library.refresh", json!({"catalog": catalog, "wait": true})).unwrap();
let e = s.execute("library.install", json!({"id": "org.test.ua", "version": "3.0.0", "wait": true})).unwrap_err().to_string();
assert!(e.contains("999.0"), "{e}");
let r = s.execute("library.update", json!({"wait": true})).unwrap();
assert_eq!(r["updating"], json!(["org.test.ua", "org.test.ub"]), "{r}");
let l = s.execute("library.list", json!({"installed": true})).unwrap();
for id in ["org.test.ua", "org.test.ub"] {
assert_eq!(package(&l, id)["installed"], "2.0.0", "{l}");
}
let _ = std::fs::remove_dir_all(&dir);
}