Processor scanner tests for Ethereum

processor/src/tests/mod.rs

@@ -1,22 +1,18 @@
 use std::sync::OnceLock;
 
 mod key_gen;
-pub(crate) use key_gen::test_key_gen;
 
 mod scanner;
-pub(crate) use scanner::{test_scanner, test_no_deadlock_in_multisig_completed};
 
 mod signer;
-pub(crate) use signer::{sign, test_signer};
+pub(crate) use signer::sign;
 
 mod cosigner;
 mod batch_signer;
 
 mod wallet;
-pub(crate) use wallet::test_wallet;
 
 mod addresses;
-pub(crate) use addresses::test_addresses;
 
 // Effective Once
 static INIT_LOGGER_CELL: OnceLock<()> = OnceLock::new();
@@ -27,22 +23,21 @@ fn init_logger() {
 #[macro_export]
 macro_rules! test_network {
   (
-    $N: ident,
+    $N: ty,
     $docker: ident,
     $network: ident,
     $key_gen: ident,
     $scanner: ident,
-    $signer: ident,
-    $wallet: ident,
-    $addresses: ident,
     $no_deadlock_in_multisig_completed: ident,
   ) => {
+    use core::{pin::Pin, future::Future};
     use $crate::tests::{
-      init_logger, test_key_gen, test_scanner, test_no_deadlock_in_multisig_completed, test_signer,
-      test_wallet, test_addresses,
+      init_logger,
+      key_gen::test_key_gen,
+      scanner::{test_scanner, test_no_deadlock_in_multisig_completed},
     };
 
-    // This doesn't interact with a node and accordingly doesn't need to be run
+    // This doesn't interact with a node and accordingly doesn't need to be spawn one
     #[tokio::test]
     async fn $key_gen() {
       init_logger();
@@ -54,34 +49,8 @@ macro_rules! test_network {
       init_logger();
       let docker = $docker();
       docker.run(|ops| async move {
-        test_scanner($network(&ops).await).await;
-      });
-    }
-
-    #[test]
-    fn $signer() {
-      init_logger();
-      let docker = $docker();
-      docker.run(|ops| async move {
-        test_signer($network(&ops).await).await;
-      });
-    }
-
-    #[test]
-    fn $wallet() {
-      init_logger();
-      let docker = $docker();
-      docker.run(|ops| async move {
-        test_wallet($network(&ops).await).await;
-      });
-    }
-
-    #[test]
-    fn $addresses() {
-      init_logger();
-      let docker = $docker();
-      docker.run(|ops| async move {
-        test_addresses($network(&ops).await).await;
+        let new_network = $network(&ops).await;
+        test_scanner(new_network).await;
       });
     }
 
@@ -90,7 +59,57 @@ macro_rules! test_network {
       init_logger();
       let docker = $docker();
       docker.run(|ops| async move {
-        test_no_deadlock_in_multisig_completed($network(&ops).await).await;
+        let new_network = $network(&ops).await;
+        test_no_deadlock_in_multisig_completed(new_network).await;
+      });
+    }
+  };
+}
+
+#[macro_export]
+macro_rules! test_utxo_network {
+  (
+    $N: ty,
+    $docker: ident,
+    $network: ident,
+    $key_gen: ident,
+    $scanner: ident,
+    $no_deadlock_in_multisig_completed: ident,
+    $signer: ident,
+    $wallet: ident,
+    $addresses: ident,
+  ) => {
+    use $crate::tests::{signer::test_signer, wallet::test_wallet, addresses::test_addresses};
+
+    test_network!($N, $docker, $network, $key_gen, $scanner, $no_deadlock_in_multisig_completed,);
+
+    #[test]
+    fn $signer() {
+      init_logger();
+      let docker = $docker();
+      docker.run(|ops| async move {
+        let new_network = $network(&ops).await;
+        test_signer(new_network).await;
+      });
+    }
+
+    #[test]
+    fn $wallet() {
+      init_logger();
+      let docker = $docker();
+      docker.run(|ops| async move {
+        let new_network = $network(&ops).await;
+        test_wallet(new_network).await;
+      });
+    }
+
+    #[test]
+    fn $addresses() {
+      init_logger();
+      let docker = $docker();
+      docker.run(|ops| async move {
+        let new_network = $network(&ops).await;
+        test_addresses(new_network).await;
       });
     }
   };