remove repeated code

Cargo.toml

@@ -21,6 +21,7 @@ members = [
   "chains/polygon/rosetta-testing-polygon",
   "chains/binance",
   "chains/avalanche",
+  "chains/utils",
 ]
 resolver = "2"
 

chains/avalanche/Cargo.toml

@@ -22,6 +22,7 @@ sha3 = "0.10"
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
 tracing = "0.1.40"
 url = "2.4"
+utils = { path = "../utils" }
 
 [dev-dependencies]
 serial_test = "3.1.1"

chains/avalanche/src/lib.rs

@@ -51,6 +51,7 @@ mod tests {
     use serial_test::serial;
     use sha3::Digest;
     use std::{collections::BTreeMap, future::Future, path::Path};
+    use utils::run_test;
 
     /// Account used to fund other testing accounts.
     const FUNDING_ACCOUNT_PRIVATE_KEY: [u8; 32] =
@@ -68,38 +69,6 @@ mod tests {
         }
     }
 
-    /// Run the test in another thread while sending txs to force binance to mine new blocks
-    /// # Panic
-    /// Panics if the future panics
-    async fn run_test<Fut: Future<Output = ()> + Send + 'static>(future: Fut) {
-        // Guarantee that only one test is incrementing blocks at a time
-        static LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
-
-        // Run the test in another thread
-        let test_handler = tokio::spawn(future);
-
-        // Acquire Lock
-        let guard = LOCK.lock().await;
-
-        // Check if the test is finished after acquiring the lock
-        if test_handler.is_finished() {
-            // Release lock
-            drop(guard);
-
-            // Now is safe to panic
-            if let Err(err) = test_handler.await {
-                std::panic::resume_unwind(err.into_panic());
-            }
-            return;
-        }
-
-        // Now is safe to panic
-        if let Err(err) = test_handler.await {
-            // Resume the panic on the main task
-            std::panic::resume_unwind(err.into_panic());
-        }
-    }
-
     #[tokio::test]
     #[serial]
     async fn network_status() {

chains/binance/Cargo.toml

@@ -18,3 +18,4 @@ rosetta-core.workspace = true
 rosetta-server-ethereum.workspace = true
 sha3 = "0.10"
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
+utils = { path = "../utils" }

chains/binance/src/lib.rs

@@ -49,6 +49,7 @@ mod tests {
     use rosetta_server_ethereum::MaybeWsEthereumClient;
     use sha3::Digest;
     use std::{collections::BTreeMap, future::Future, path::Path};
+    use utils::run_test;
 
     /// Binance rpc url
     const BINANCE_RPC_WS_URL: &str = "ws://127.0.0.1:8546";
@@ -62,38 +63,6 @@ mod tests {
         }
     }
 
-    /// Run the test in another thread while sending txs to force binance to mine new blocks
-    /// # Panic
-    /// Panics if the future panics
-    async fn run_test<Fut: Future<Output = ()> + Send + 'static>(future: Fut) {
-        // Guarantee that only one test is incrementing blocks at a time
-        static LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
-
-        // Run the test in another thread
-        let test_handler: tokio::task::JoinHandle<()> = tokio::spawn(future);
-
-        // Acquire Lock
-        let guard = LOCK.lock().await;
-
-        // Check if the test is finished after acquiring the lock
-        if test_handler.is_finished() {
-            // Release lock
-            drop(guard);
-
-            // Now is safe to panic
-            if let Err(err) = test_handler.await {
-                std::panic::resume_unwind(err.into_panic());
-            }
-            return;
-        }
-
-        // Now is safe to panic
-        if let Err(err) = test_handler.await {
-            // Resume the panic on the main task
-            std::panic::resume_unwind(err.into_panic());
-        }
-    }
-
     #[tokio::test]
     async fn network_status() {
         run_test(async move {

chains/polygon/rosetta-testing-polygon/Cargo.toml

@@ -18,3 +18,4 @@ rosetta-core.workspace = true
 rosetta-server-ethereum.workspace = true
 sha3 = "0.10"
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
+utils = { path = "../../utils" }

chains/polygon/rosetta-testing-polygon/src/lib.rs

@@ -49,6 +49,7 @@ mod tests {
     use rosetta_server_ethereum::MaybeWsEthereumClient;
     use sha3::Digest;
     use std::{collections::BTreeMap, future::Future, path::Path};
+    use utils::run_test;
 
     /// Polygon rpc url
     const POLYGON_RPC_WS_URL: &str = "ws://127.0.0.1:8546";
@@ -62,38 +63,6 @@ mod tests {
         }
     }
 
-    /// Run the test in another thread while sending txs to force polygon to mine new blocks
-    /// # Panic
-    /// Panics if the future panics
-    async fn run_test<Fut: Future<Output = ()> + Send + 'static>(future: Fut) {
-        // Guarantee that only one test is incrementing blocks at a time
-        static LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
-
-        // Run the test in another thread
-        let test_handler: tokio::task::JoinHandle<()> = tokio::spawn(future);
-
-        // Acquire Lock
-        let guard = LOCK.lock().await;
-
-        // Check if the test is finished after acquiring the lock
-        if test_handler.is_finished() {
-            // Release lock
-            drop(guard);
-
-            // Now is safe to panic
-            if let Err(err) = test_handler.await {
-                std::panic::resume_unwind(err.into_panic());
-            }
-            return;
-        }
-
-        // Now is safe to panic
-        if let Err(err) = test_handler.await {
-            // Resume the panic on the main task
-            std::panic::resume_unwind(err.into_panic());
-        }
-    }
-
     #[ignore = "No Polygon CI"]
     #[tokio::test]
     async fn network_status() {

chains/utils/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "utils"
+version = "0.1.0"
+edition = "2021"
+license = "MIT"
+repository = "https://github.com/analog-labs/chain-connectors"
+description = "utils for rosetta test."
+
+[dependencies]
+tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }

chains/utils/src/lib.rs

@@ -0,0 +1,33 @@
+use std::future::Future;
+
+/// Run the test in another thread while sending txs to force binance to mine new blocks
+/// # Panic
+/// Panics if the future panics
+pub async fn run_test<Fut: Future<Output = ()> + Send + 'static>(future: Fut) {
+    // Guarantee that only one test is incrementing blocks at a time
+    static LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
+
+    // Run the test in another thread
+    let test_handler = tokio::spawn(future);
+
+    // Acquire Lock
+    let guard = LOCK.lock().await;
+
+    // Check if the test is finished after acquiring the lock
+    if test_handler.is_finished() {
+        // Release lock
+        drop(guard);
+
+        // Now is safe to panic
+        if let Err(err) = test_handler.await {
+            std::panic::resume_unwind(err.into_panic());
+        }
+        return;
+    }
+
+    // Now is safe to panic
+    if let Err(err) = test_handler.await {
+        // Resume the panic on the main task
+        std::panic::resume_unwind(err.into_panic());
+    }
+}