use Counters instead of global test vars

Author: rdeioris

testnet/stacks-node/src/nakamoto_node/signer_coordinator.rs

@@ -16,8 +16,6 @@
 use std::collections::{BTreeMap, HashMap};
 use std::ops::Bound::Included;
 use std::sync::atomic::AtomicBool;
-#[cfg(test)]
-use std::sync::LazyLock;
 use std::sync::{Arc, Mutex};
 use std::thread::JoinHandle;
 use std::time::{Duration, Instant};
@@ -38,8 +36,6 @@ use stacks::types::chainstate::{StacksBlockId, StacksPrivateKey};
 use stacks::util::hash::Sha512Trunc256Sum;
 use stacks::util::secp256k1::MessageSignature;
 use stacks::util_lib::boot::boot_code_id;
-#[cfg(test)]
-use stacks_common::util::tests::TestFlag;
 
 use super::stackerdb_listener::StackerDBListenerComms;
 use super::Error as NakamotoNodeError;
@@ -50,11 +46,6 @@ use crate::nakamoto_node::stackerdb_listener::{
 use crate::neon::Counters;
 use crate::Config;
 
-#[cfg(test)]
-/// Test-only value for storing the current rejection based timeout
-pub static BLOCK_REJECTIONS_CURRENT_TIMEOUT: LazyLock<TestFlag<Duration>> =
-    LazyLock::new(TestFlag::default);
-
 /// The state of the signer database listener, used by the miner thread to
 /// interact with the signer listener.
 pub struct SignerCoordinator {
@@ -410,7 +401,13 @@ impl SignerCoordinator {
                 rejections_timer = Instant::now();
 
                 #[cfg(test)]
-                BLOCK_REJECTIONS_CURRENT_TIMEOUT.set(*rejections_timeout);
+                {
+                    Counters::set(
+                        &counters.naka_miner_current_rejections_timeout_secs,
+                        rejections_timeout.as_secs(),
+                    );
+                    Counters::set(&counters.naka_miner_current_rejections, rejections);
+                }
             }
 
             if block_status

testnet/stacks-node/src/run_loop/neon.rs

@@ -115,6 +115,11 @@ pub struct Counters {
     pub naka_signer_pushed_blocks: RunLoopCounter,
     pub naka_miner_directives: RunLoopCounter,
 
+    #[cfg(test)]
+    pub naka_miner_current_rejections: RunLoopCounter,
+    #[cfg(test)]
+    pub naka_miner_current_rejections_timeout_secs: RunLoopCounter,
+
     #[cfg(test)]
     pub naka_skip_commit_op: TestFlag<bool>,
 }
@@ -133,7 +138,7 @@ impl Counters {
     fn inc(_ctr: &RunLoopCounter) {}
 
     #[cfg(test)]
-    fn set(ctr: &RunLoopCounter, value: u64) {
+    pub fn set(ctr: &RunLoopCounter, value: u64) {
         ctr.0.store(value, Ordering::SeqCst);
     }
 

testnet/stacks-node/src/tests/signer/mod.rs

@@ -98,6 +98,7 @@ pub struct RunningNodes {
     pub nakamoto_test_skip_commit_op: TestFlag<bool>,
     pub coord_channel: Arc<Mutex<CoordinatorChannels>>,
     pub conf: NeonConfig,
+    pub counters: Counters,
 }
 
 /// A test harness for running a v0 or v1 signer integration test
@@ -943,6 +944,9 @@ fn setup_stx_btc_node<G: FnMut(&mut NeonConfig)>(
     } = run_loop.counters();
 
     let coord_channel = run_loop.coordinator_channels();
+
+    let run_loop_counters = run_loop.counters();
+
     let run_loop_thread = thread::spawn(move || run_loop.start(None, 0));
 
     // Give the run loop some time to start up!
@@ -978,5 +982,6 @@ fn setup_stx_btc_node<G: FnMut(&mut NeonConfig)>(
         nakamoto_miner_directives: naka_miner_directives.0,
         coord_channel,
         conf: naka_conf,
+        counters: run_loop_counters,
     }
 }

testnet/stacks-node/src/tests/signer/v0.rs

@@ -76,7 +76,6 @@ use crate::event_dispatcher::{MinedNakamotoBlockEvent, TEST_SKIP_BLOCK_ANNOUNCEM
 use crate::nakamoto_node::miner::{
     TEST_BLOCK_ANNOUNCE_STALL, TEST_BROADCAST_STALL, TEST_MINE_STALL,
 };
-use crate::nakamoto_node::signer_coordinator::BLOCK_REJECTIONS_CURRENT_TIMEOUT;
 use crate::nakamoto_node::stackerdb_listener::TEST_IGNORE_SIGNERS;
 use crate::neon::Counters;
 use crate::run_loop::boot_nakamoto;
@@ -7877,9 +7876,23 @@ fn block_validation_check_rejection_timeout_heuristic() {
         .wait_for_block_rejections(timeout.as_secs(), &[all_signers[19]])
         .unwrap();
 
-    thread::sleep(Duration::from_secs(3));
-
-    assert_eq!(BLOCK_REJECTIONS_CURRENT_TIMEOUT.get().as_secs(), 123);
+    wait_for(60, || {
+        Ok(signer_test
+            .running_nodes
+            .counters
+            .naka_miner_current_rejections
+            .get()
+            >= 1)
+    })
+    .unwrap();
+    assert_eq!(
+        signer_test
+            .running_nodes
+            .counters
+            .naka_miner_current_rejections_timeout_secs
+            .get(),
+        123
+    );
 
     info!("------------------------- Check Rejections-based timeout with 2 rejections -------------------------");
 
@@ -7899,9 +7912,23 @@ fn block_validation_check_rejection_timeout_heuristic() {
         .wait_for_block_rejections(timeout.as_secs(), &[all_signers[18], all_signers[19]])
         .unwrap();
 
-    thread::sleep(Duration::from_secs(3));
-
-    assert_eq!(BLOCK_REJECTIONS_CURRENT_TIMEOUT.get().as_secs(), 20);
+    wait_for(60, || {
+        Ok(signer_test
+            .running_nodes
+            .counters
+            .naka_miner_current_rejections
+            .get()
+            >= 2)
+    })
+    .unwrap();
+    assert_eq!(
+        signer_test
+            .running_nodes
+            .counters
+            .naka_miner_current_rejections_timeout_secs
+            .get(),
+        20
+    );
 
     info!("------------------------- Check Rejections-based timeout with 3 rejections -------------------------");
 
@@ -7924,9 +7951,24 @@ fn block_validation_check_rejection_timeout_heuristic() {
         )
         .unwrap();
 
-    thread::sleep(Duration::from_secs(3));
+    wait_for(60, || {
+        Ok(signer_test
+            .running_nodes
+            .counters
+            .naka_miner_current_rejections
+            .get()
+            >= 3)
+    })
+    .unwrap();
 
-    assert_eq!(BLOCK_REJECTIONS_CURRENT_TIMEOUT.get().as_secs(), 10);
+    assert_eq!(
+        signer_test
+            .running_nodes
+            .counters
+            .naka_miner_current_rejections_timeout_secs
+            .get(),
+        10
+    );
 
     info!("------------------------- Check Rejections-based timeout with 4 rejections -------------------------");
 
@@ -7959,9 +8001,23 @@ fn block_validation_check_rejection_timeout_heuristic() {
         )
         .unwrap();
 
-    thread::sleep(Duration::from_secs(3));
-
-    assert_eq!(BLOCK_REJECTIONS_CURRENT_TIMEOUT.get().as_secs(), 99);
+    wait_for(60, || {
+        Ok(signer_test
+            .running_nodes
+            .counters
+            .naka_miner_current_rejections
+            .get()
+            >= 4)
+    })
+    .unwrap();
+    assert_eq!(
+        signer_test
+            .running_nodes
+            .counters
+            .naka_miner_current_rejections_timeout_secs
+            .get(),
+        99
+    );
 
     // reset reject/ignore
     TEST_REJECT_ALL_BLOCK_PROPOSAL.set(vec![]);