use crate::common::{CompiledTest, invoke_and_capture_output};
use camino::Utf8Path;
use test_r::{test, test_dep};
use wasmtime::component::Val;
#[test_dep(tagged_as = "module_resolution", scope = Cloneable)]
async fn compiled_module_resolution() -> CompiledTest {
let path = Utf8Path::new("examples/runtime/module-resolution");
CompiledTest::new(path, true)
.await
.expect("Failed to compile module_resolution")
}
#[test]
async fn esm_package_map_edge_cases(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-esm-package-map-edge-cases",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn esm_encoded_relative_paths(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-esm-encoded-relative-paths",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn esm_invalid_package_specifiers(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-esm-invalid-package-specifiers",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn esm_data_url_import_attributes(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-esm-data-url-import-attributes",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn esm_injected_helpers_ignore_lexical_global_this(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-esm-injected-helpers-ignore-lexical-global-this",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn esm_json_url_cache_keys(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-esm-json-url-cache-keys",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn esm_json_import_ignores_global_this_property(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-esm-json-import-ignores-global-this-property",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn static_loader_absolute_entry_specifier(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-static-loader-absolute-entry-specifier",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn registered_loader_module_realm_isolation(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-registered-loader-module-realm-isolation",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn registered_loader_resolve_result_not_mutated(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-registered-loader-resolve-result-not-mutated",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn esm_forbidden_cjs_globals(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-esm-forbidden-cjs-globals",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn import_meta_resolve(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-import-meta-resolve",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn rust_bridge_globals_non_replaceable(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-rust-bridge-globals-non-replaceable",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn module_bridge_globals_non_replaceable(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-module-bridge-globals-non-replaceable",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn cjs_dynamic_import_attribute_scanner(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-cjs-dynamic-import-attribute-scanner",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn loader_commonjs_source_named_exports(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-loader-commonjs-source-named-exports",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn loader_commonjs_json_cache(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-loader-commonjs-json-cache",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn loader_commonjs_require_apis(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-loader-commonjs-require-apis",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn unknown_node_specifier_cannot_be_shadowed(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-unknown-node-specifier-cannot-be-shadowed",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn loader_module_source_validation(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-loader-module-source-validation",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn package_custom_conditions(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-package-custom-conditions",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn cjs_package_json_parse_cache(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-cjs-package-json-parse-cache",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn sync_builtin_esm_exports(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-sync-builtin-esm-exports",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn esm_resolution_error_urls(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-esm-resolution-error-urls",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn cjs_direct_named_exports(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-cjs-direct-named-exports",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn esm_imports_side_effect_commonjs(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-esm-imports-side-effect-common-js",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn cjs_define_property_named_exports(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-cjs-define-property-named-exports",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn cjs_reexport_named_exports(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-cjs-reexport-named-exports",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn cjs_analyzer_false_positive_guards(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-cjs-analyzer-false-positive-guards",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn cjs_shared_loader_identity(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-cjs-shared-loader-identity",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn module_syntax_detection_and_diagnostics(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-module-syntax-detection-and-diagnostics",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn cjs_package_reexport_named_exports(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-cjs-package-reexport-named-exports",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn find_package_json(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-find-package-json",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn vm_main_context_default_loader(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-vm-main-context-default-loader",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn vm_source_text_module_link_semantics(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-vm-source-text-module-link-semantics",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn require_esm_error_handling(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-require-esm-error-handling",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn require_esm_tla_retry(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-require-esm-tla-retry",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn require_esm_rejection_tracking(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-require-esm-rejection-tracking",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn unhandled_rejection_turn_ordering(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-unhandled-rejection-turn-ordering",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn require_esm_cycle_guards(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-require-esm-cycle-guards",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn cjs_esm_default_snapshot_timing(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-cjs-esm-default-snapshot-timing",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn cjs_symlink_circular_cache(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-cjs-symlink-circular-cache",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn esm_symlink_module_identity(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-esm-symlink-module-identity",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn cjs_node_module_loading_compat(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-cjs-node-module-loading-compat",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn cjs_nested_dependency_cache_shape(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-cjs-nested-dependency-cache-shape",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn cjs_module_children_graph(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-cjs-module-children-graph",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn esm_template_top_level_await_detection(
#[tagged_as("module_resolution")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-esm-template-top-level-await-detection",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}