Run p3 integration tests in CI via a harness-free test_main!

The `wstd tests (wasip3)` CI step was broken: p3's `block_on` blocks on
`waitable-set.wait`, which traps ("cannot block a synchronous task before
returning") when driven from libtest's synchronously-lifted `wasi:cli/run`
`main`. p2's `block_on` blocks via `wasi:io/poll.poll`, which a sync task may
do, so only p3 was affected.

Add a dependency-free `wstd::test_main!` macro (plus a `#[doc(hidden)]`
`__test` support module) that provides a `harness = false` entry point for
integration tests:

* on p3 it async-lifts the test binary's `wasi:cli/run` export, so per-test
  `block_on` calls are made from an async task and no longer trap;
* on p2 it emits a plain `fn main` that runs each test via `block_on`.

Both variants print libtest-style status lines and exit non-zero when a test
fails (whether it panics or returns `Err`), so `cargo test` still reports
failures. Convert all integration tests to plain `async fn`s driven by
`test_main!` and mark each `[[test]]` target `harness = false`.

To let a single `wasm32-wasip2` build serve both backends, add the
component-model async runner flags (`-Wcomponent-model-async`,
`-Wcomponent-model-more-async-builtins`, `-Wcomponent-model-async-stackful`,
`-Sp3`) to the `wasm32-wasip2` runner. These are inert for plain p2 components,
so the wasip2 suite is unaffected.

Finally, gate the two blocking `src/time.rs` unit tests (`timer_now`,
`timer_after_100_milliseconds`) with `#[cfg_attr(wstd_p3, ignore)]`: they run
under libtest's default (synchronous) harness in the `[lib]` target, which
still traps on p3. Their behavior is covered by the integration test suite.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: yoshuawuyts

.cargo/config.toml

@@ -1,9 +1,13 @@
 [target.wasm32-wasip2]
 # wasmtime is given:
+# * component-model async support so p3 test/example components (built for the
+#   wasip2 target with `--features wasip3`) validate and can async-lift their
+#   `wasi:cli/run` export. These flags are inert for plain p2 components.
+# * p3 enabled so p3 components can import the WASI 0.3 interfaces.
 # * http enabled for wasi-http tests
 # * AWS auth environment variables, for running the wstd-aws integration tests.
 # * . directory is available at .
-runner = "wasmtime run -Shttp --env AWS_ACCESS_KEY_ID --env AWS_SECRET_ACCESS_KEY --env AWS_SESSION_TOKEN --dir .::."
+runner = "wasmtime run -Wcomponent-model-async -Wcomponent-model-more-async-builtins -Wcomponent-model-async-stackful -Sp3 -Shttp --env AWS_ACCESS_KEY_ID --env AWS_SECRET_ACCESS_KEY --env AWS_SESSION_TOKEN --dir .::."
 
 [target.wasm32-wasip3]
 # wasmtime is given:

Cargo.toml

@@ -53,6 +53,50 @@ humantime.workspace = true
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
 
+# Integration tests use `wstd::test_main!` with a custom `harness = false`
+# entry point. This is required for p3, where the test binary must async-lift
+# its `wasi:cli/run` export (libtest lifts `main` synchronously, which cannot
+# block on async imports). See `wstd::test_main!` for details.
+[[test]]
+name = "timer"
+harness = false
+
+[[test]]
+name = "sleep"
+harness = false
+
+[[test]]
+name = "stdio"
+harness = false
+
+[[test]]
+name = "http_get"
+harness = false
+
+[[test]]
+name = "http_get_json"
+harness = false
+
+[[test]]
+name = "http_post"
+harness = false
+
+[[test]]
+name = "http_post_json"
+harness = false
+
+[[test]]
+name = "http_handle_error_code"
+harness = false
+
+[[test]]
+name = "http_timeout"
+harness = false
+
+[[test]]
+name = "http_first_byte_timeout"
+harness = false
+
 [workspace]
 members = [
     "axum",

src/lib.rs

@@ -89,6 +89,52 @@ pub mod __internal {
     pub use wasip2;
 }
 
+/// Test-harness support used by the [`test_main!`](crate::test_main) macro.
+///
+/// This is `#[doc(hidden)]` and not part of the public API.
+#[doc(hidden)]
+pub mod __test {
+    /// Conversion from a test function's return type into a pass/fail result.
+    ///
+    /// Implemented for `()` and `Result<(), E: Debug>`, matching the return
+    /// types permitted on the `async fn` tests collected by [`test_main!`].
+    ///
+    /// [`test_main!`]: crate::test_main
+    pub trait TestOutcome {
+        /// Convert the outcome into `Ok(())` on success or an `Err` carrying a
+        /// rendered failure message.
+        fn into_test_result(self) -> Result<(), String>;
+    }
+
+    impl TestOutcome for () {
+        fn into_test_result(self) -> Result<(), String> {
+            Ok(())
+        }
+    }
+
+    impl<E: core::fmt::Debug> TestOutcome for Result<(), E> {
+        fn into_test_result(self) -> Result<(), String> {
+            self.map_err(|err| format!("{err:?}"))
+        }
+    }
+
+    /// Report one test's outcome with a libtest-style status line, returning
+    /// `true` when the test passed.
+    pub fn report(name: &str, outcome: impl TestOutcome) -> bool {
+        match outcome.into_test_result() {
+            Ok(()) => {
+                println!("test {name} ... ok");
+                true
+            }
+            Err(err) => {
+                println!("test {name} ... FAILED");
+                eprintln!("---- {name} ----\n{err}\n");
+                false
+            }
+        }
+    }
+}
+
 // Conditionally-compiled declarative macro for the `#[wstd::main]` entry point.
 //
 // The `#[wstd::main]` proc macro delegates to this declarative macro so the
@@ -141,6 +187,88 @@ macro_rules! __main_export {
     };
 }
 
+/// Define the entry point of an integration-test binary composed of `async fn`
+/// tests.
+///
+/// On p3 a test cannot use the standard libtest harness: libtest lifts its
+/// `main` as a *synchronous* `wasi:cli/run` task, and a synchronous task may
+/// not block on async-lowered imports (it traps with "cannot block a
+/// synchronous task before returning"). Instead, set `harness = false` for the
+/// test target and use this macro, which async-lifts `wasi:cli/run` on p3 and
+/// generates a plain `fn main` on p2. Each listed `async fn` test is driven to
+/// completion with [`block_on`](crate::runtime::block_on):
+///
+/// ```ignore
+/// async fn my_test() -> Result<(), Box<dyn std::error::Error>> {
+///     Ok(())
+/// }
+///
+/// wstd::test_main! { my_test }
+/// ```
+///
+/// Tests may return `()` or `Result<(), E>` where `E: Debug`. The process exits
+/// non-zero if any test returns an error, so `cargo test` reports the failure.
+#[macro_export]
+macro_rules! test_main {
+    ( $( $test:path ),* $(,)? ) => {
+        $crate::__test_main_export! { $( $test ),* }
+    };
+}
+
+#[cfg(wstd_p2)]
+#[macro_export]
+#[doc(hidden)]
+macro_rules! __test_main_export {
+    ( $( $test:path ),* $(,)? ) => {
+        fn main() {
+            let mut all_ok = true;
+            $(
+                all_ok &= $crate::__test::report(
+                    ::core::stringify!($test),
+                    $crate::runtime::block_on($test()),
+                );
+            )*
+            if !all_ok {
+                ::std::process::exit(1);
+            }
+        }
+    };
+}
+
+#[cfg(wstd_p3)]
+#[macro_export]
+#[doc(hidden)]
+macro_rules! __test_main_export {
+    ( $( $test:path ),* $(,)? ) => {
+        const _: () = {
+            struct __WstdTestMain;
+
+            impl $crate::__internal::wasip3::exports::cli::run::Guest for __WstdTestMain {
+                async fn run() -> ::core::result::Result<(), ()> {
+                    let mut all_ok = true;
+                    $(
+                        all_ok &= $crate::__test::report(
+                            ::core::stringify!($test),
+                            $crate::runtime::block_on($test()),
+                        );
+                    )*
+                    if all_ok {
+                        ::core::result::Result::Ok(())
+                    } else {
+                        ::core::result::Result::Err(())
+                    }
+                }
+            }
+
+            $crate::__internal::wasip3::cli::command::export!(__WstdTestMain with_types_in $crate::__internal::wasip3);
+        };
+
+        // The bin target still requires a `fn main`; the real entry point is the
+        // async-lifted `wasi:cli/run` export above, so this is never invoked.
+        fn main() {}
+    };
+}
+
 pub mod prelude {
     pub use crate::future::FutureExt as _;
     pub use crate::io::AsyncRead as _;

src/time.rs

@@ -424,13 +424,21 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(
+        wstd_p3,
+        ignore = "block_on traps under libtest's synchronous harness on p3; covered by the integration test suite"
+    )]
     fn timer_now() {
         crate::runtime::block_on(debug_duration("timer_now", async {
             Timer::at(Instant::now()).wait().await
         }));
     }
 
     #[test]
+    #[cfg_attr(
+        wstd_p3,
+        ignore = "block_on traps under libtest's synchronous harness on p3; covered by the integration test suite"
+    )]
     fn timer_after_100_milliseconds() {
         crate::runtime::block_on(debug_duration("timer_after_100_milliseconds", async {
             Timer::after(Duration::from_millis(100)).wait().await

tests/http_get.rs

@@ -1,8 +1,7 @@
 use std::error::Error;
 use wstd::http::{Body, Client, HeaderValue, Request};
 
-#[wstd::test]
-async fn main() -> Result<(), Box<dyn Error>> {
+async fn http_get() -> Result<(), Box<dyn Error>> {
     let request = Request::get("https://postman-echo.com/get")
         .header("my-header", HeaderValue::from_str("my-value")?)
         .body(Body::empty())?;
@@ -51,3 +50,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     Ok(())
 }
+
+wstd::test_main! {
+    http_get,
+}

tests/http_get_json.rs

@@ -7,8 +7,7 @@ struct Echo {
     url: String,
 }
 
-#[wstd::test]
-async fn main() -> Result<(), Box<dyn Error>> {
+async fn http_get_json() -> Result<(), Box<dyn Error>> {
     let request = Request::get("https://postman-echo.com/get").body(Body::empty())?;
 
     let response = Client::new().send(request).await?;
@@ -27,3 +26,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     Ok(())
 }
+
+wstd::test_main! {
+    http_get_json,
+}

tests/http_handle_error_code.rs

@@ -1,7 +1,6 @@
 use wstd::http::{Body, Client, Request, error::ErrorCode};
 
 /// Test that `outgoing_handler::handle` errors are properly propagated.
-#[wstd::test]
 async fn handle_returns_error_code() -> Result<(), Box<dyn std::error::Error>> {
     let request = Request::get("ftp://example.com/").body(Body::empty())?;
 
@@ -19,3 +18,7 @@ async fn handle_returns_error_code() -> Result<(), Box<dyn std::error::Error>> {
 
     Ok(())
 }
+
+wstd::test_main! {
+    handle_returns_error_code,
+}

tests/http_post.rs

@@ -1,8 +1,7 @@
 use std::error::Error;
 use wstd::http::{Client, HeaderValue, Request};
 
-#[wstd::test]
-async fn main() -> Result<(), Box<dyn Error>> {
+async fn http_post() -> Result<(), Box<dyn Error>> {
     let request = Request::post("https://postman-echo.com/post")
         .header(
             "content-type",
@@ -49,3 +48,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     Ok(())
 }
+
+wstd::test_main! {
+    http_post,
+}

tests/http_post_json.rs

@@ -12,8 +12,7 @@ struct Echo {
     url: String,
 }
 
-#[wstd::test]
-async fn main() -> Result<(), Box<dyn Error>> {
+async fn http_post_json() -> Result<(), Box<dyn Error>> {
     let test_data = TestData {
         test: "data".to_string(),
     };
@@ -41,3 +40,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     Ok(())
 }
+
+wstd::test_main! {
+    http_post_json,
+}

tests/http_timeout.rs

@@ -2,7 +2,6 @@ use wstd::future::FutureExt;
 use wstd::http::{Body, Client, Request};
 use wstd::time::Duration;
 
-#[wstd::test]
 async fn http_timeout() -> Result<(), Box<dyn std::error::Error>> {
     // This get request will connect to the server, which will then wait 1 second before
     // returning a response.
@@ -21,3 +20,7 @@ async fn http_timeout() -> Result<(), Box<dyn std::error::Error>> {
 
     Ok(())
 }
+
+wstd::test_main! {
+    http_timeout,
+}