wasm-rquickjs-cli 0.4.3

Tool for wrapping JavaScript modules as WebAssembly components using the QuickJS engine
use crate::common::{CompiledTest, FeatureCombination, invoke_and_capture_output};
use camino::Utf8Path;
use test_r::{test, test_dep};

#[test_dep(tagged_as = "execution", scope = Cloneable)]
async fn compiled_execution() -> CompiledTest {
    CompiledTest::new_with_features(
        Utf8Path::new("examples/runtime/execution"),
        true,
        FeatureCombination::Normal,
    )
    .await
    .expect("Failed to compile execution")
}

#[test]
async fn execution_isolation(
    #[tagged_as("execution")] compiled: &CompiledTest,
) -> anyhow::Result<()> {
    let (result, output) = invoke_and_capture_output(compiled.wasm_path(), None, "run", &[]).await;
    let result = result?;
    assert!(
        output.is_empty(),
        "nested output leaked to component stdio: {output}"
    );
    let Some(wasmtime::component::Val::String(json)) = result else {
        anyhow::bail!("expected JSON string result, got {result:?}");
    };
    let report: serde_json::Value = serde_json::from_str(&json)?;
    assert_eq!(report["liveStdout"], "live:first\nlive:last\n");
    assert_eq!(report["liveStderr"], "live:warn\nlive:error\n");
    assert_eq!(report["liveResult"]["value"]["label"], "live");
    assert_eq!(report["liveResult"]["value"]["argv"][1], "live");
    assert_eq!(
        report["ordering"][0], "data",
        "output was not delivered live"
    );
    assert_eq!(
        report["ordering"].as_array().unwrap().last().unwrap(),
        "result"
    );
    assert_eq!(report["streamedBeforeResult"], true);
    assert_eq!(report["parentProgress"], true);
    assert_eq!(report["left"]["value"], "left");
    assert_eq!(report["left"]["stdout"], "left\n");
    assert_eq!(report["right"]["value"], "right");
    assert_eq!(report["right"]["stdout"], "right\n");
    assert_eq!(
        report["defaultEnvironment"]["value"]["keys"],
        serde_json::json!([])
    );
    assert_eq!(
        report["defaultEnvironment"]["value"]["parentSecret"],
        serde_json::Value::Null
    );
    assert_eq!(
        report["explicitEnvironment"]["value"]["keys"],
        serde_json::json!(["ALLOWED"])
    );
    assert_eq!(report["explicitEnvironment"]["value"]["allowed"], "visible");
    assert_eq!(
        report["explicitEnvironment"]["value"]["parentSecret"],
        serde_json::Value::Null
    );
    assert_eq!(report["packageCacheFirst"]["value"], "first");
    assert_eq!(report["packageCacheSecond"]["value"], "second");
    assert_eq!(report["timeoutSuccess"]["value"], "quick");
    assert_eq!(report["timeoutError"], "execution job timed out");
    assert_eq!(report["tightLoopTimeoutError"], "execution job timed out");
    assert_eq!(
        report["cpuBeforeSuspendTimeoutError"],
        "execution job timed out"
    );
    assert!(
        report["cpuBeforeSuspendElapsedMs"]
            .as_u64()
            .is_some_and(|elapsed| (300..650).contains(&elapsed)),
        "timeout budget restarted after child suspension: {} ms",
        report["cpuBeforeSuspendElapsedMs"]
    );
    assert_eq!(report["zeroTimeoutCode"], "ERR_INVALID_ARG_TYPE");
    assert_eq!(report["hugeTimeoutCode"], "ERR_OUT_OF_RANGE");
    for name in ["invalidEntry", "invalidSource"] {
        assert_eq!(
            report["invalidProgramOptions"][name], "ERR_INVALID_ARG_TYPE",
            "unexpected validation result for {name}"
        );
    }
    for name in ["invalidEntryWithSource", "invalidSourceWithEntry", "both"] {
        assert_eq!(
            report["invalidProgramOptions"][name], "exactly one of entry or source is required",
            "unexpected exclusivity result for {name}"
        );
    }
    assert_eq!(
        report["overflowError"],
        "execution output exceeded maxBytes"
    );
    assert_eq!(report["truncated"]["value"], "ok");
    assert_eq!(report["truncated"]["stderr"], "éé");
    assert_eq!(report["truncated"]["overflowed"], true);
    assert_eq!(report["entry"]["value"]["kind"], "entry");
    assert_eq!(
        report["entry"]["value"]["argv"][0],
        "wasm-rquickjs-execution"
    );
    assert_eq!(
        report["entry"]["value"]["argv"][1],
        "/tmp/execution-app/entry.mjs"
    );
    assert_eq!(
        report["defaultArgv"]["value"],
        serde_json::json!(["wasm-rquickjs-execution"])
    );
    assert_eq!(report["largeJavaScript"]["value"], "large-javascript");
    assert_eq!(report["typescriptDisabled"], true);
    assert!(
        report["disabledStripError"]
            .as_str()
            .is_some_and(|message| message.contains("TypeScript runtime support is not enabled")),
        "unexpected disabled strip error: {}",
        report["disabledStripError"]
    );
    assert!(
        report["disabledExecutionError"]
            .as_str()
            .is_some_and(|message| message.contains("TypeScript runtime support is not enabled")),
        "unexpected disabled execution error: {}",
        report["disabledExecutionError"]
    );
    assert_eq!(report["imports"]["value"]["local"], "local");
    assert_eq!(report["imports"]["value"]["package"], "package");
    assert_eq!(report["imports"]["value"]["json"], "json");
    assert_eq!(report["imports"]["value"]["cjs"], "cjs");
    assert_eq!(report["imports"]["value"]["afterChdir"], "local");
    assert_eq!(report["imports"]["value"]["cwd"], "/tmp/execution-other");
    assert_eq!(report["privateImport"]["value"], "ERR_MODULE_NOT_FOUND");
    assert_eq!(
        report["removedAliases"]["value"]["legacySpecifier"],
        "ERR_MODULE_NOT_FOUND"
    );
    assert_eq!(
        report["removedAliases"]["value"]["spawnJavaScript"],
        "undefined"
    );
    for check in [
        "hasUndefined",
        "nan",
        "infinity",
        "negativeInfinity",
        "negativeZero",
        "bigint",
        "cycle",
        "map",
        "set",
        "bytes",
    ] {
        assert_eq!(report["cloneChecks"][check], true, "clone check {check}");
    }
    assert!(
        report["resourceError"]
            .as_str()
            .is_some_and(|message| message.contains("execution results cannot contain resources")),
        "unexpected resource error: {}",
        report["resourceError"]
    );
    assert_eq!(report["pathAliases"]["value"]["mode"], 0o611);
    assert_eq!(report["pathAliases"]["value"]["link"], "./sub/../file.txt");
    assert_eq!(
        report["pathAliases"]["value"]["real"],
        "/tmp/alias/file.txt"
    );
    assert_eq!(report["pathAliases"]["value"]["renamed"], "before");
    assert_eq!(
        report["persistentSymlinkCreated"]["value"]["absoluteError"],
        "EINVAL"
    );
    assert_eq!(
        report["persistentSymlinkCreated"]["value"]["absoluteExists"],
        false
    );
    assert_eq!(
        report["persistentSymlinkCreated"]["value"]["existingError"],
        "EEXIST"
    );
    assert_eq!(
        report["persistentSymlinkCreated"]["value"]["existingValue"],
        "preserved"
    );
    assert_eq!(
        report["persistentSymlinkCreated"]["value"]["missingParentError"],
        "ENOENT"
    );
    assert_eq!(
        report["persistentSymlinkCreated"]["value"]["parentFileError"],
        "ENOTDIR"
    );
    assert_eq!(
        report["persistentSymlinkCreated"]["value"]["relativeParentFileError"],
        "ENOTDIR"
    );
    assert_eq!(
        report["persistentSymlinkCreated"]["value"]["bareDestinationError"],
        "EINVAL"
    );
    assert_eq!(
        report["persistentSymlinkCreated"]["value"]["bareDestinationExists"],
        false
    );
    assert_eq!(
        report["persistentSymlinkRead"]["value"]["target"],
        "target.txt"
    );
    assert_eq!(
        report["persistentSymlinkRead"]["value"]["value"],
        "persistent"
    );
    assert_eq!(
        report["persistentSymlinkRead"]["value"]["realpath"],
        "/tmp/persistent-link/target.txt"
    );
    assert_eq!(
        report["persistentSymlinkRead"]["value"]["isSymbolicLink"],
        true
    );
    assert_eq!(
        report["persistentSymlinkEdges"]["value"]["brokenExists"],
        false
    );
    assert_eq!(
        report["persistentSymlinkEdges"]["value"]["brokenIsSymbolicLink"],
        true
    );
    assert_eq!(
        report["persistentSymlinkEdges"]["value"]["brokenTarget"],
        "missing.txt"
    );
    assert_eq!(
        report["persistentSymlinkEdges"]["value"]["cycleError"],
        "ELOOP"
    );
    assert_eq!(
        report["persistentSymlinkEdges"]["value"]["cycleDestinationError"],
        "ELOOP"
    );
    assert_eq!(
        report["persistentSymlinkEdges"]["value"]["recursiveNames"],
        serde_json::json!([
            "linked-target",
            "linked-target/file.txt",
            "target",
            "target/file.txt"
        ])
    );
    for api in ["recursiveCallbackNames", "recursivePromiseNames"] {
        assert_eq!(
            report["persistentSymlinkEdges"]["value"][api],
            serde_json::json!([
                "linked-target",
                "linked-target/file.txt",
                "target",
                "target/file.txt"
            ]),
            "unexpected recursive entries for {api}"
        );
    }
    assert_eq!(
        report["persistentSymlinkEdges"]["value"]["recursiveWatcherIsFsWatcher"],
        true
    );
    let recursive_watch_events = report["persistentSymlinkEdges"]["value"]["recursiveWatchEvents"]
        .as_array()
        .expect("recursive watch events should be an array");
    assert!(
        recursive_watch_events
            .iter()
            .any(|event| event == &serde_json::json!(["rename", "target/created.txt"])),
        "recursive watcher should report the real nested path as a rename: {recursive_watch_events:?}"
    );
    assert!(
        recursive_watch_events.iter().all(|event| !event
            .get(1)
            .and_then(serde_json::Value::as_str)
            .is_some_and(|event| event.starts_with("self/"))),
        "recursive watcher should not follow the self symlink: {recursive_watch_events:?}"
    );
    assert_eq!(
        report["persistentSymlinkEdges"]["value"]["movedTarget"],
        "target.txt"
    );
    assert_eq!(
        report["persistentSymlinkEdges"]["value"]["movedExistsAfterUnlink"],
        false
    );
    assert_eq!(report["cancellationError"], "execution job cancelled");
    assert_eq!(
        report["nested"]["value"],
        "nested execution jobs are not supported"
    );
    assert_eq!(
        report["capacityError"],
        "execution supports at most 8 active jobs per runtime"
    );
    assert_eq!(report["reclaimed"]["value"], "reclaimed");
    assert_eq!(
        report["isolation"]["left"]["value"]["fd"],
        report["isolation"]["right"]["value"]["fd"]
    );
    for side in ["left", "right"] {
        let probe = &report["isolation"][side]["value"];
        assert_eq!(probe["mode"], if side == "left" { 0o600 } else { 0o640 });
        assert_eq!(probe["cwd"], format!("/tmp/execution-isolation-{side}"));
        assert_eq!(probe["linkTarget"], "./target.txt");
        assert_eq!(probe["linkValue"], format!("{side}:target"));
        assert_eq!(probe["packageValue"], format!("{side}:package"));
        assert_eq!(
            report["isolation"][side]["stdout"],
            format!("{side}:stdout\n")
        );
        assert_eq!(
            report["isolation"][side]["stderr"],
            format!("{side}:stderr\n")
        );
    }
    assert_eq!(
        report["isolation"]["left"]["value"]["secondFd"].as_i64(),
        report["isolation"]["left"]["value"]["fd"]
            .as_i64()
            .map(|fd| fd + 1)
    );
    assert_eq!(
        report["isolation"]["right"]["value"]["foreignFdError"],
        "EBADF"
    );
    Ok(())
}