add simple test cases for polyfill that check if it can successfully load and run the wasm plugin. create wasm-serve package to serve wasm files locally

Author: zahash

Cargo.toml

@@ -7,6 +7,7 @@ members = [
     "core",
     "iota",
     "test-utils",
+    "wasm-serve",
 ]
 
 [workspace.package]

polyfill/jsoncodegen-wasm32-wasip1.test.ts

@@ -0,0 +1,23 @@
+// node --test
+
+import assert from "node:assert";
+import { test } from "node:test";
+
+import { WasmPlugin } from "./jsoncodegen-wasm32-wasip1.ts";
+
+// cargo run --bin wasm-serve -- target/wasm32-wasip1/wasm/jsoncodegen*.wasm --port 7357
+const wasmServer = "http://localhost:7357/";
+
+// list of wasm files that are served by the wasm-server is listed at "/"
+const response = await fetch(wasmServer);
+const filenames = await response.json();
+
+for (const filename of filenames) {
+  const url = new URL(filename, wasmServer);
+
+  test(url.href, async () => {
+    const plugin = await WasmPlugin.load(url);
+    const output = plugin.run("{}");
+    assert.ok(output, "Plugin should return a string");
+  });
+}

polyfill/jsoncodegen-wasm32-wasip1.ts

@@ -30,7 +30,7 @@ export class WasmPlugin {
    * * @param url - The URL of the .wasm file.
    * @returns A promise that resolves to a generic WasmPlugin.
    */
-  static async load(url: string): Promise<WasmPlugin> {
+  static async load(url: string | URL): Promise<WasmPlugin> {
     const response = fetch(url);
 
     try {
@@ -121,8 +121,10 @@ export class PluginManager {
  * Not exported to the consumer.
  */
 class WasiExit extends Error {
-  constructor(public code: number) {
+  public code: number;
+  constructor(code: number) {
     super(`WASI Exit: ${code}`);
+    this.code = code;
   }
 }
 

wasm-serve/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "wasm-serve"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+axum = "0.8"
+clap = { version = "4", features = ["derive"] }
+tokio = { version = "1", features = ["rt-multi-thread"] }
+tower-http = { version = "0.6", features = ["fs", "trace"] }
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }

wasm-serve/src/main.rs

@@ -0,0 +1,55 @@
+use axum::{
+    Json, Router,
+    routing::{get, get_service},
+};
+use clap::Parser;
+use std::{net::SocketAddr, path::PathBuf};
+use tower_http::services::ServeFile;
+use tracing_subscriber::EnvFilter;
+
+/// A simple server to serve WASM files
+#[derive(Parser, Debug)]
+struct Args {
+    /// List of .wasm files to serve
+    #[arg(required = true, num_args = 1..)]
+    files: Vec<PathBuf>,
+
+    #[arg(short, long, default_value_t = 0)]
+    port: u16,
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env(/* RUST_LOG env var sets logging level */))
+        .init();
+
+    let args = Args::parse();
+    let mut app = Router::new();
+
+    let mut route_paths = vec![];
+
+    for path in args.files {
+        if path.is_file()
+            && let Some(unicode_path) = path.to_str()
+        {
+            let route_path = format!("/{}", unicode_path);
+            let service = get_service(ServeFile::new(&path));
+            app = app.route(&route_path, service);
+
+            tracing::info!("serving file {:?} at route {}", path, route_path);
+            route_paths.push(route_path);
+        }
+    }
+
+    app = app.route("/", get(Json(route_paths)));
+
+    let addr = SocketAddr::from(([0, 0, 0, 0], args.port));
+    let listener = tokio::net::TcpListener::bind(addr).await?;
+    let local_addr = listener.local_addr()?;
+
+    tracing::info!("listening on {}", local_addr);
+    axum::serve(listener, app).await?;
+
+    Ok(())
+}