Allow tests for wasm with wasm-pack

Author: wackazong

Cargo.toml

@@ -18,6 +18,16 @@ gloo-timers = { version = "0.3", features = ["futures"] }
 [dev-dependencies]
 anyhow = "1"
 reqwest = "0.12"
+
+[target.'cfg(target_arch = "wasm32")'.dev-dependencies]
+tokio = { version = "1", features = [
+  "macros",
+  "rt",
+  "sync",
+], default-features = false }
+wasm-bindgen-test = "0.3"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
 sqlx = { version = "0.8.0", features = ["runtime-tokio", "sqlite"] }
 tokio = { version = "1", features = [
   "time",

examples/blocking.rs

@@ -1,16 +1,21 @@
 use anyhow::Result;
-use backon::BlockingRetryable;
-use backon::ExponentialBuilder;
 
 // For more examples, please see: https://docs.rs/backon/#examples
 
 fn fetch() -> Result<String> {
     Ok("hello, world!".to_string())
 }
 
+// this example does not run on wasm32-unknown-unknown
+#[cfg(not(target_arch = "wasm32"))]
 fn main() -> Result<()> {
-    let content = fetch.retry(&ExponentialBuilder::default()).call()?;
+    use backon::BlockingRetryable;
+
+    let content = fetch.retry(&backon::ExponentialBuilder::default()).call()?;
     println!("fetch succeeded: {}", content);
 
     Ok(())
 }
+
+#[cfg(target_arch = "wasm32")]
+fn main() {}

examples/closure.rs

@@ -1,15 +1,18 @@
-use anyhow::Result;
-use backon::BlockingRetryable;
-use backon::ExponentialBuilder;
-
 // For more examples, please see: https://docs.rs/backon/#examples
 
-fn main() -> Result<()> {
+// this example does not run on wasm32-unknown-unknown
+#[cfg(not(target_arch = "wasm32"))]
+fn main() -> anyhow::Result<()> {
+    use backon::BlockingRetryable;
+
     let var = 42;
     // `f` can use input variables
     let f = || Ok::<u32, anyhow::Error>(var);
-    let result = f.retry(&ExponentialBuilder::default()).call()?;
+    let result = f.retry(&backon::ExponentialBuilder::default()).call()?;
     println!("var = {result}");
 
     Ok(())
 }
+
+#[cfg(target_arch = "wasm32")]
+fn main() {}

examples/sqlx.rs

@@ -1,20 +1,24 @@
-use anyhow::Result;
-use backon::ExponentialBuilder;
-use backon::Retryable;
-use sqlx::sqlite::SqlitePoolOptions;
+// For more examples, please see: https://docs.rs/backon/#examples
 
+// this example does not run on wasm32-unknown-unknown
+#[cfg(not(target_arch = "wasm32"))]
 #[tokio::main]
-async fn main() -> Result<()> {
-    let pool = SqlitePoolOptions::new()
+async fn main() -> anyhow::Result<()> {
+    use backon::Retryable;
+
+    let pool = sqlx::sqlite::SqlitePoolOptions::new()
         .max_connections(5)
         .connect("sqlite::memory:")
         .await?;
 
     let row: (i64,) = (|| sqlx::query_as("SELECT $1").bind(150_i64).fetch_one(&pool))
-        .retry(&ExponentialBuilder::default())
+        .retry(&backon::ExponentialBuilder::default())
         .await?;
 
     assert_eq!(row.0, 150);
 
     Ok(())
 }
+
+#[cfg(target_arch = "wasm32")]
+fn main() {}

src/constant.rs

@@ -129,6 +129,9 @@ impl Iterator for ConstantBackoff {
 mod tests {
     use std::time::Duration;
 
+    #[cfg(target_arch = "wasm32")]
+    use wasm_bindgen_test::wasm_bindgen_test as test;
+
     use crate::backoff::BackoffBuilder;
     use crate::constant::ConstantBuilder;
 

src/exponential.rs

@@ -180,6 +180,9 @@ pub(crate) fn saturating_mul(d: Duration, rhs: f32) -> Duration {
 mod tests {
     use std::time::Duration;
 
+    #[cfg(target_arch = "wasm32")]
+    use wasm_bindgen_test::wasm_bindgen_test as test;
+
     use crate::backoff::BackoffBuilder;
     use crate::exponential::ExponentialBuilder;
 

src/fibonacci.rs

@@ -164,6 +164,9 @@ impl Iterator for FibonacciBackoff {
 mod tests {
     use std::time::Duration;
 
+    #[cfg(target_arch = "wasm32")]
+    use wasm_bindgen_test::wasm_bindgen_test as test;
+
     use crate::backoff::BackoffBuilder;
     use crate::fibonacci::FibonacciBuilder;
 

src/lib.rs

@@ -181,9 +181,14 @@ pub use retry::Retryable;
 mod retry_with_context;
 pub use retry_with_context::RetryableWithContext;
 
+#[cfg(not(target_arch = "wasm32"))]
 mod blocking_retry;
+#[cfg(not(target_arch = "wasm32"))]
 pub use blocking_retry::BlockingRetry;
+#[cfg(not(target_arch = "wasm32"))]
 pub use blocking_retry::BlockingRetryable;
 
+#[cfg(not(target_arch = "wasm32"))]
 mod blocking_retry_with_context;
+#[cfg(not(target_arch = "wasm32"))]
 pub use blocking_retry_with_context::BlockingRetryableWithContext;

src/retry.rs

@@ -288,14 +288,20 @@ mod tests {
 
     use tokio::sync::Mutex;
 
+    #[cfg(target_arch = "wasm32")]
+    use wasm_bindgen_test::wasm_bindgen_test as test;
+
+    #[cfg(not(target_arch = "wasm32"))]
+    use tokio::test;
+
     use super::*;
     use crate::exponential::ExponentialBuilder;
 
     async fn always_error() -> anyhow::Result<()> {
         Err(anyhow::anyhow!("test_query meets error"))
     }
 
-    #[tokio::test]
+    #[test]
     async fn test_retry() -> anyhow::Result<()> {
         let result = always_error
             .retry(&ExponentialBuilder::default().with_min_delay(Duration::from_millis(1)))
@@ -306,7 +312,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[test]
     async fn test_retry_with_not_retryable_error() -> anyhow::Result<()> {
         let error_times = Mutex::new(0);
 
@@ -331,7 +337,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[test]
     async fn test_retry_with_retryable_error() -> anyhow::Result<()> {
         let error_times = Mutex::new(0);
 
@@ -356,7 +362,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[test]
     async fn test_fn_mut_when_and_notify() -> anyhow::Result<()> {
         let mut calls_retryable: Vec<()> = vec![];
         let mut calls_notify: Vec<()> = vec![];

src/retry_with_context.rs

@@ -336,12 +336,17 @@ where
 mod tests {
     use std::time::Duration;
 
-    use anyhow::anyhow;
+    use anyhow::{anyhow, Result};
     use tokio::sync::Mutex;
 
+    #[cfg(target_arch = "wasm32")]
+    use wasm_bindgen_test::wasm_bindgen_test as test;
+
+    #[cfg(not(target_arch = "wasm32"))]
+    use tokio::test;
+
     use super::*;
     use crate::exponential::ExponentialBuilder;
-    use anyhow::Result;
 
     struct Test;
 
@@ -351,7 +356,7 @@ mod tests {
         }
     }
 
-    #[tokio::test]
+    #[test]
     async fn test_retry_with_not_retryable_error() -> Result<()> {
         let error_times = Mutex::new(0);