2a4119c | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

2a4119c — Peter John 2026-11-02T15:01:16+05:30

Add plum-game/web-test: playwright-rs browser check for web game builds

Generated files not shown: plum-game/web-test/Cargo.lock

Files changed (6) hide show

plum-game/web-test/Cargo.toml +19 -0
plum-game/web-test/README.md +28 -0
plum-game/web-test/examples/install-browsers.rs +6 -0
plum-game/web-test/src/lib.rs +302 -0
plum-game/web-test/src/main.rs +42 -0
plum-game/web-test/tests/web_check.rs +23 -0

plum-game/web-test/Cargo.toml ADDED Viewed

@@ -0,0 +1,19 @@
+[package]
+name = "plum-web-test"
+version = "0.1.0"
+edition = "2021"
+[workspace]
+[lib]
+name = "plum_web_test"
+path = "src/lib.rs"
+[[bin]]
+name = "plum-web-test"
+path = "src/main.rs"
+[dependencies]
+playwright-rs = "0.20.1"
+tokio = { version = "1", features = ["full"] }
+image = { version = "0.25", default-features = false, features = ["png"] }

plum-game/web-test/README.md ADDED Viewed

@@ -0,0 +1,28 @@
+# plum-web-test
+Browser check for `plum game --web` builds, driven by [playwright-rs](https://crates.io/crates/playwright-rs) 0.20.
+Standalone crate (own `[workspace]`, not part of the root workspace).
+It builds `plum-cli`, exports the game with `plum game --web`, serves the output on
+127.0.0.1:0, opens it in headless Chromium, clicks the canvas once, then asserts:
+the canvas is not one uniform colour, two screenshots 1 s apart differ (the game
+animates), and there are no page errors or console errors (except the known harmless
+macroquad `register_plugin is not defined`). AudioContext state is reported; a missing
+running context is only a warning unless `--require-audio` is given.
+## One-time setup
+Downloads the Chromium build matching the bundled Playwright driver (about 100 MB, to
+`~/Library/Caches/ms-playwright` on macOS; the driver itself is fetched by the crate's build script):
+    cargo run --manifest-path plum-game/web-test/Cargo.toml --example install-browsers
+## Usage
+    cargo run --manifest-path plum-game/web-test/Cargo.toml -- plum-examples/game.plum --screenshot /tmp/orb-run.png
+Options: `--frames-wait SECS` (default 8), `--screenshot OUT.png`, `--require-audio`.
+Exit code is non-zero with a message on failure.
+`cargo test --manifest-path plum-game/web-test/Cargo.toml` runs the same check on
+`plum-examples/game.plum`; it skips with a note if Chromium is not installed.

plum-game/web-test/examples/install-browsers.rs ADDED Viewed

@@ -0,0 +1,6 @@
+// One-time setup: installs the Chromium build matching the bundled Playwright driver.
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    playwright_rs::install_browsers(Some(&["chromium"])).await?;
+    Ok(())
+}

plum-game/web-test/src/lib.rs ADDED Viewed

@@ -0,0 +1,302 @@
+//! Browser check for `plum game --web` builds, driven by playwright-rs.
+use playwright_rs::{LaunchOptions, Playwright};
+use std::io::{Read, Write};
+use std::net::{TcpListener, TcpStream};
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+pub struct Options {
+    pub frames_wait: f64,
+    pub screenshot: Option<PathBuf>,
+    pub require_audio: bool,
+}
+impl Default for Options {
+    fn default() -> Self {
+        Options { frames_wait: 8.0, screenshot: None, require_audio: false }
+    }
+}
+/// Whether `playwright install chromium` has been run (browser cache dir exists).
+pub fn chromium_installed() -> bool {
+    let dir = if let Ok(p) = std::env::var("PLAYWRIGHT_BROWSERS_PATH") {
+        PathBuf::from(p)
+    } else {
+        let home = PathBuf::from(std::env::var("HOME").unwrap_or_default());
+        if cfg!(target_os = "macos") {
+            home.join("Library/Caches/ms-playwright")
+        } else if cfg!(target_os = "windows") {
+            PathBuf::from(std::env::var("LOCALAPPDATA").unwrap_or_default()).join("ms-playwright")
+        } else {
+            home.join(".cache/ms-playwright")
+        }
+    };
+    std::fs::read_dir(dir)
+        .map(|rd| rd.flatten().any(|e| e.file_name().to_string_lossy().starts_with("chromium")))
+        .unwrap_or(false)
+}
+pub fn repo_root() -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR")).join("../..").canonicalize().expect("repo root")
+}
+/// Builds plum-cli and exports `file` as a web build into `out`.
+pub fn build_web(file: &Path, out: &Path) -> Result<(), String> {
+    let root = repo_root();
+    let st = Command::new("cargo")
+        .args(["build", "-p", "plum-cli"])
+        .current_dir(&root)
+        .status()
+        .map_err(|e| format!("cargo build: {e}"))?;
+    if !st.success() {
+        return Err("cargo build -p plum-cli failed".into());
+    }
+    let file = file.canonicalize().map_err(|e| format!("{}: {e}", file.display()))?;
+    let o = Command::new(root.join("target/debug/plum"))
+        .args(["game", "--web"])
+        .arg(&file)
+        .arg("-o")
+        .arg(out)
+        .current_dir(&root)
+        .output()
+        .map_err(|e| format!("plum game --web: {e}"))?;
+    if !o.status.success() {
+        return Err(format!(
+            "plum game --web failed:\n{}{}",
+            String::from_utf8_lossy(&o.stdout),
+            String::from_utf8_lossy(&o.stderr)
+        ));
+    }
+    Ok(())
+}
+fn mime(path: &Path) -> &'static str {
+    match path.extension().and_then(|e| e.to_str()).unwrap_or("") {
+        "wasm" => "application/wasm",
+        "js" | "mjs" => "text/javascript",
+        "html" => "text/html",
+        "png" => "image/png",
+        "wav" => "audio/wav",
+        "ogg" => "audio/ogg",
+        "txt" => "text/plain",
+        "json" => "application/json",
+        _ => "application/octet-stream",
+    }
+}
+fn respond(mut s: TcpStream, root: &Path) {
+    let mut buf = [0u8; 8192];
+    let n = s.read(&mut buf).unwrap_or(0);
+    let req = String::from_utf8_lossy(&buf[..n]);
+    let target = req.split_whitespace().nth(1).unwrap_or("/");
+    let rel = target.split(['?', '#']).next().unwrap_or("/").trim_start_matches('/');
+    let rel = if rel.is_empty() { "index.html" } else { rel };
+    let ok = !rel.split('/').any(|c| c == ".." || c.contains('\\'));
+    let path = root.join(rel);
+    match std::fs::read(&path).ok().filter(|_| ok) {
+        Some(body) => {
+            let head = format!(
+                "HTTP/1.1 200 OK\r\nContent-Type: {}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
+                mime(&path),
+                body.len()
+            );
+            let _ = s.write_all(head.as_bytes());
+            let _ = s.write_all(&body);
+        }
+        None => {
+            let _ = s.write_all(b"HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\nConnection: close\r\n\r\n");
+        }
+    }
+}
+/// Serves `root` on 127.0.0.1:0; returns the port. Stops when `stop` is set.
+pub fn serve(root: PathBuf, stop: Arc<AtomicBool>) -> u16 {
+    let l = TcpListener::bind("127.0.0.1:0").expect("bind");
+    let port = l.local_addr().unwrap().port();
+    std::thread::spawn(move || {
+        for s in l.incoming() {
+            if stop.load(Ordering::Relaxed) {
+                break;
+            }
+            if let Ok(s) = s {
+                let root = root.clone();
+                std::thread::spawn(move || respond(s, &root));
+            }
+        }
+    });
+    port
+}
+pub struct Shot {
+    pub w: u32,
+    pub h: u32,
+    pub rgba: Vec<u8>,
+}
+pub fn decode(png: &[u8]) -> Result<Shot, String> {
+    let img = image::load_from_memory(png).map_err(|e| format!("decode screenshot: {e}"))?.to_rgba8();
+    Ok(Shot { w: img.width(), h: img.height(), rgba: img.into_raw() })
+}
+/// Number of distinct colours (capped at `cap`).
+pub fn distinct_colours(s: &Shot, cap: usize) -> usize {
+    let mut set = std::collections::HashSet::new();
+    for p in s.rgba.chunks_exact(4) {
+        set.insert([p[0], p[1], p[2]]);
+        if set.len() >= cap {
+            break;
+        }
+    }
+    set.len()
+}
+/// Fraction-free count of pixels that differ between two same-sized shots.
+pub fn differing_pixels(a: &Shot, b: &Shot) -> usize {
+    if (a.w, a.h) != (b.w, b.h) {
+        return usize::MAX;
+    }
+    a.rgba.chunks_exact(4).zip(b.rgba.chunks_exact(4)).filter(|(x, y)| x != y).count()
+}
+const AUDIO_HOOK: &str = r#"(() => {
+  window.__plumAudio = [];
+  for (const k of ["AudioContext", "webkitAudioContext"]) {
+    const Orig = window[k];
+    if (!Orig) continue;
+    window[k] = function (...a) { const c = new Orig(...a); window.__plumAudio.push(c); return c; };
+    window[k].prototype = Orig.prototype;
+  }
+})()"#;
+const AUDIO_PROBE: &str = "() => (window.__plumAudio || []).map(c => c.state)";
+/// Runs the full check; Ok(report) on success, Err(message) on any failure.
+pub async fn run(file: &Path, opts: &Options) -> Result<String, String> {
+    let tmp = std::env::temp_dir().join(format!("plum-web-test-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&tmp);
+    std::fs::create_dir_all(&tmp).map_err(|e| e.to_string())?;
+    let res = run_in(file, opts, &tmp).await;
+    let _ = std::fs::remove_dir_all(&tmp);
+    res
+}
+async fn run_in(file: &Path, opts: &Options, dir: &Path) -> Result<String, String> {
+    build_web(file, dir)?;
+    let stop = Arc::new(AtomicBool::new(false));
+    let port = serve(dir.to_path_buf(), stop.clone());
+    let res = check(port, opts).await;
+    stop.store(true, Ordering::Relaxed);
+    let _ = TcpStream::connect(("127.0.0.1", port)); // unblock accept
+    res
+}
+fn pe<E: std::fmt::Display>(what: &'static str) -> impl FnOnce(E) -> String {
+    move |e| format!("{what}: {e}")
+}
+async fn check(port: u16, opts: &Options) -> Result<String, String> {
+    let pw = Playwright::launch().await.map_err(pe("launch playwright"))?;
+    let launch = LaunchOptions::new().headless(true).args(
+        ["--use-angle=swiftshader", "--enable-unsafe-swiftshader", "--ignore-gpu-blocklist", "--autoplay-policy=no-user-gesture-required"]
+            .map(String::from)
+            .to_vec(),
+    );
+    let browser = pw.chromium().launch_with_options(launch).await.map_err(pe("launch chromium"))?;
+    let out = check_page(&browser, port, opts).await;
+    let _ = browser.close().await;
+    out
+}
+async fn check_page(browser: &playwright_rs::protocol::Browser, port: u16, opts: &Options) -> Result<String, String> {
+    let page = browser.new_page().await.map_err(pe("new page"))?;
+    let errors: Arc<Mutex<Vec<String>>> = Arc::default();
+    let logs: Arc<Mutex<Vec<String>>> = Arc::default();
+    {
+        let (errors, logs) = (errors.clone(), logs.clone());
+        page.on_console(move |m| {
+            let (errors, logs) = (errors.clone(), logs.clone());
+            async move {
+                let line = format!("console.{}: {}", m.type_(), m.text());
+                if m.type_() == "error" && !m.text().contains("register_plugin is not defined") {
+                    errors.lock().unwrap().push(line.clone());
+                }
+                logs.lock().unwrap().push(line);
+                Ok(())
+            }
+        })
+        .await
+        .map_err(pe("on_console"))?;
+    }
+    {
+        let errors = errors.clone();
+        page.on_pageerror(move |m| {
+            let errors = errors.clone();
+            async move {
+                if !m.contains("register_plugin is not defined") {
+                    errors.lock().unwrap().push(format!("pageerror: {m}"));
+                }
+                Ok(())
+            }
+        })
+        .await
+        .map_err(pe("on_pageerror"))?;
+    }
+    page.add_init_script(AUDIO_HOOK).await.map_err(pe("init script"))?;
+    page.goto(&format!("http://127.0.0.1:{port}/"), None).await.map_err(pe("goto"))?;
+    // Give the wasm time to load, then provide a user gesture on the canvas.
+    tokio::time::sleep(Duration::from_secs_f64((opts.frames_wait / 2.0).min(3.0))).await;
+    let size: Vec<f64> = page
+        .evaluate("() => { const r = document.getElementById('glcanvas').getBoundingClientRect(); return [r.width, r.height]; }", None::<&()>)
+        .await
+        .map_err(pe("canvas lookup (is there a #glcanvas?)"))?;
+    page.mouse().click(size[0] / 2.0, size[1] / 2.0, None).await.map_err(pe("click"))?;
+    tokio::time::sleep(Duration::from_secs_f64((opts.frames_wait - (opts.frames_wait / 2.0).min(3.0)).max(0.0))).await;
+    let png1 = page.screenshot(None).await.map_err(pe("screenshot"))?;
+    tokio::time::sleep(Duration::from_secs(1)).await;
+    let png2 = page.screenshot(None).await.map_err(pe("screenshot"))?;
+    let audio: Vec<String> = page.evaluate(AUDIO_PROBE, None::<&()>).await.unwrap_or_default();
+    if let Some(p) = &opts.screenshot {
+        std::fs::write(p, &png2).map_err(|e| format!("write {}: {e}", p.display()))?;
+    }
+    let (a, b) = (decode(&png1)?, decode(&png2)?);
+    let colours = distinct_colours(&b, 1000);
+    let diff = differing_pixels(&a, &b);
+    let errs = errors.lock().unwrap().clone();
+    let mut report = format!(
+        "canvas {}x{}, distinct colours: {colours}{}, pixels changed over 1s: {}\naudio: {}",
+        b.w,
+        b.h,
+        if colours >= 1000 { "+" } else { "" },
+        if diff == usize::MAX { "size changed".into() } else { diff.to_string() },
+        if audio.is_empty() { "no AudioContext created".to_string() } else { format!("AudioContext states {audio:?}") },
+    );
+    let mut failures = vec![];
+    if colours <= 1 {
+        failures.push("canvas is blank (uniformly one colour)".to_string());
+    }
+    if diff == 0 {
+        failures.push("canvas did not change between snapshots 1s apart (game not animating)".to_string());
+    }
+    failures.extend(errs.iter().cloned());
+    let audio_ok = audio.iter().any(|s| s == "running");
+    if !audio_ok {
+        if opts.require_audio {
+            failures.push("--require-audio: no running AudioContext".to_string());
+        } else {
+            report.push_str("\nWARNING: no running AudioContext (informational)");
+        }
+    }
+    if failures.is_empty() {
+        Ok(report)
+    } else {
+        let logs = logs.lock().unwrap().join("\n");
+        Err(format!("{}\n{report}\n--- console ---\n{logs}", failures.join("\n")))
+    }
+}

plum-game/web-test/src/main.rs ADDED Viewed

@@ -0,0 +1,42 @@
+use plum_web_test::{chromium_installed, run, Options};
+use std::path::PathBuf;
+const USAGE: &str = "usage: plum-web-test <file.plum> [--frames-wait SECS] [--screenshot OUT.png] [--require-audio]";
+#[tokio::main]
+async fn main() {
+    let mut file: Option<PathBuf> = None;
+    let mut opts = Options::default();
+    let mut args = std::env::args().skip(1);
+    while let Some(a) = args.next() {
+        match a.as_str() {
+            "--frames-wait" => {
+                opts.frames_wait = args.next().and_then(|v| v.parse().ok()).unwrap_or_else(|| fail("--frames-wait needs a number"));
+            }
+            "--screenshot" => opts.screenshot = Some(args.next().map(PathBuf::from).unwrap_or_else(|| fail("--screenshot needs a path"))),
+            "--require-audio" => opts.require_audio = true,
+            "-h" | "--help" => {
+                println!("{USAGE}");
+                return;
+            }
+            s if s.starts_with("--") => fail(&format!("unknown flag {s}\n{USAGE}")),
+            _ => file = Some(PathBuf::from(a)),
+        }
+    }
+    let Some(file) = file else { fail(USAGE) };
+    if !chromium_installed() {
+        fail("Playwright Chromium is not installed; see plum-game/web-test/README.md (one-time setup)");
+    }
+    match run(&file, &opts).await {
+        Ok(report) => println!("{report}\nPASS"),
+        Err(e) => {
+            eprintln!("FAIL: {e}");
+            std::process::exit(1);
+        }
+    }
+}
+fn fail(msg: &str) -> ! {
+    eprintln!("{msg}");
+    std::process::exit(2);
+}

plum-game/web-test/tests/web_check.rs ADDED Viewed

@@ -0,0 +1,23 @@
+use plum_web_test::{chromium_installed, repo_root, run, Options};
+#[test]
+fn orb_run_renders_and_animates() {
+    if !chromium_installed() {
+        eprintln!("SKIP: Playwright Chromium not installed (see plum-game/web-test/README.md)");
+        return;
+    }
+    let rt = tokio::runtime::Runtime::new().unwrap();
+    let file = repo_root().join("plum-examples/game.plum");
+    let report = rt.block_on(run(&file, &Options::default())).unwrap_or_else(|e| panic!("{e}"));
+    println!("{report}");
+}
+#[test]
+fn image_helpers() {
+    use plum_web_test::{differing_pixels, distinct_colours, Shot};
+    let a = Shot { w: 2, h: 1, rgba: vec![1, 2, 3, 255, 1, 2, 3, 255] };
+    let b = Shot { w: 2, h: 1, rgba: vec![1, 2, 3, 255, 9, 2, 3, 255] };
+    assert_eq!(distinct_colours(&a, 10), 1);
+    assert_eq!(distinct_colours(&b, 10), 2);
+    assert_eq!(differing_pixels(&a, &b), 1);
+}