Merge pull request #6161 from orsissimo/test/refactor-commands

test: add disallow_reorg_within_first_proposal_burn_block_timing_secs_but_more_than_one_block_scenario and refactor commands

Author: aldur

Cargo.lock

@@ -52,8 +52,8 @@ tempfile = "3.3"
 mockito = "1.5"
 serial_test = "3.2.0"
 pinny = { git = "https://github.com/BitcoinL2-Labs/pinny-rs.git", rev = "54ba9d533a7b84525a5e65a3eae1a3ae76b9ea49" } #v0.0.2
-madhouse = { git = "https://github.com/stacks-network/madhouse-rs.git", rev = "fc651ddcbaf85e888b06d4a87aa788c4b7ba9309" }
-proptest = { git = "https://github.com/proptest-rs/proptest.git", rev = "c9bdf18c232665b2b740c667c81866b598d06dc7" }
+madhouse = { git = "https://github.com/stacks-network/madhouse-rs.git", tag = "0.2.0" }
+proptest = "1.6.*"
 stdext = "0.3.1"
 
 [[bin]]

testnet/stacks-node/Cargo.toml

@@ -1,244 +1,129 @@
-use std::sync::atomic::Ordering;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 
 use madhouse::{Command, CommandWrapper};
-use proptest::prelude::{Just, Strategy};
-use stacks::chainstate::stacks::TenureChangeCause;
+use proptest::strategy::Strategy;
 use tracing::info;
 
 use super::context::{SignerTestContext, SignerTestState};
-use crate::tests::neon_integrations::get_chain_info;
-use crate::tests::signer::v0::{wait_for_block_pushed_by_miner_key, MultipleMinerTest};
 
-pub struct MineBitcoinBlockTenureChangeMiner1 {
-    miners: Arc<Mutex<MultipleMinerTest>>,
+/// Command to mine a single Bitcoin block in the test environment and wait for its confirmation.
+/// This command simulates the process of mining a new Bitcoin block in the Stacks blockchain
+/// testing framework. Unlike the tenure change variant, this command simply advances the
+/// Bitcoin chain by one block without explicitly triggering a tenure change transaction.
+pub struct MinerMineBitcoinBlocks {
+    ctx: Arc<SignerTestContext>,
+    num_blocks: u64,
 }
 
-impl MineBitcoinBlockTenureChangeMiner1 {
-    pub fn new(miners: Arc<Mutex<MultipleMinerTest>>) -> Self {
-        Self { miners }
+impl MinerMineBitcoinBlocks {
+    fn new(ctx: Arc<SignerTestContext>, num_blocks: u64) -> Self {
+        Self { ctx, num_blocks }
     }
-}
-
-impl Command<SignerTestState, SignerTestContext> for MineBitcoinBlockTenureChangeMiner1 {
-    fn check(&self, state: &SignerTestState) -> bool {
-        let (conf_1, _) = self.miners.lock().unwrap().get_node_configs();
-        let burn_height = get_chain_info(&conf_1).burn_block_height;
-        let miner_1_submitted_commit_last_burn_height = self
-            .miners
-            .lock()
-            .unwrap()
-            .get_primary_submitted_commit_last_burn_height()
-            .0
-            .load(Ordering::SeqCst);
-        let miner_2_submitted_commit_last_burn_height = self
-            .miners
-            .lock()
-            .unwrap()
-            .get_secondary_submitted_commit_last_burn_height()
-            .0
-            .load(Ordering::SeqCst);
-
-        info!(
-            "Checking: Miner 1 mining Bitcoin block and tenure change tx. Result: {:?} && {:?} && {:?}",
-            state.is_booted_to_nakamoto, burn_height == miner_1_submitted_commit_last_burn_height, burn_height > miner_2_submitted_commit_last_burn_height
-        );
-        state.is_booted_to_nakamoto
-            && burn_height == miner_1_submitted_commit_last_burn_height
-            && burn_height > miner_2_submitted_commit_last_burn_height
-    }
-
-    fn apply(&self, _state: &mut SignerTestState) {
-        info!("Applying: Miner 1 mining Bitcoin block and tenure change tx");
-
-        let (stacks_height_before, conf_1, miner_pk_1) = {
-            let mut miners = self.miners.lock().unwrap();
-            let stacks_height_before = miners.get_peer_stacks_tip_height();
-            let (conf_1, _) = miners.get_node_configs();
-            let burnchain = conf_1.get_burnchain();
-            let sortdb = burnchain.open_sortition_db(true).unwrap();
-
-            miners
-                .mine_bitcoin_block_and_tenure_change_tx(&sortdb, TenureChangeCause::BlockFound, 60)
-                .expect("Failed to mine BTC block");
-
-            let (miner_pk_1, _) = miners.get_miner_public_keys();
 
-            (stacks_height_before, conf_1, miner_pk_1)
-        };
-
-        info!(
-            "Waiting for Nakamoto block {} pushed by miner 1",
-            stacks_height_before + 1
-        );
-
-        let miner_1_block =
-            wait_for_block_pushed_by_miner_key(30, stacks_height_before + 1, &miner_pk_1)
-                .expect("Failed to get block");
-
-        let mined_block_height = miner_1_block.header.chain_length;
-        info!(
-            "Miner 1 mined Nakamoto block height: {}",
-            mined_block_height
-        );
-
-        let info_after = get_chain_info(&conf_1);
-        assert_eq!(info_after.stacks_tip, miner_1_block.header.block_hash());
-        assert_eq!(info_after.stacks_tip_height, mined_block_height);
-        assert_eq!(mined_block_height, stacks_height_before + 1);
+    pub fn one(ctx: Arc<SignerTestContext>) -> Self {
+        Self::new(ctx, 1)
     }
 
-    fn label(&self) -> String {
-        "MINE_BITCOIN_BLOCK_AND_TENURE_CHANGE_MINER_1".to_string()
+    pub fn multiple(ctx: Arc<SignerTestContext>, num_blocks: u64) -> Self {
+        Self::new(ctx, num_blocks)
     }
-
-    fn build(
-        ctx: Arc<SignerTestContext>,
-    ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
-        Just(CommandWrapper::new(
-            MineBitcoinBlockTenureChangeMiner1::new(ctx.miners.clone()),
-        ))
-    }
-}
-
-pub struct MineBitcoinBlockTenureChangeMiner2 {
-    miners: Arc<Mutex<MultipleMinerTest>>,
 }
 
-impl MineBitcoinBlockTenureChangeMiner2 {
-    pub fn new(miners: Arc<Mutex<MultipleMinerTest>>) -> Self {
-        Self { miners }
+impl Command<SignerTestState, SignerTestContext> for MinerMineBitcoinBlocks {
+    fn check(&self, _state: &SignerTestState) -> bool {
+        info!("Checking: Mining tenure. Result: {}", true);
+        true
     }
-}
 
-impl Command<SignerTestState, SignerTestContext> for MineBitcoinBlockTenureChangeMiner2 {
-    fn check(&self, state: &SignerTestState) -> bool {
-        let (conf_1, _) = self.miners.lock().unwrap().get_node_configs();
-        let burn_height = get_chain_info(&conf_1).burn_block_height;
-        let miner_1_submitted_commit_last_burn_height = self
-            .miners
-            .lock()
-            .unwrap()
-            .get_primary_submitted_commit_last_burn_height()
-            .0
-            .load(Ordering::SeqCst);
-        let miner_2_submitted_commit_last_burn_height = self
-            .miners
-            .lock()
-            .unwrap()
-            .get_secondary_submitted_commit_last_burn_height()
-            .0
-            .load(Ordering::SeqCst);
+    fn apply(&self, state: &mut SignerTestState) {
+        info!("Applying: Mining {} Bitcoin block(s)", self.num_blocks);
 
-        info!(
-            "Checking: Miner 2 mining Bitcoin block and tenure change tx. Result: {:?} && {:?} && {:?}",
-            state.is_booted_to_nakamoto, burn_height == miner_1_submitted_commit_last_burn_height, burn_height > miner_2_submitted_commit_last_burn_height
-        );
-        state.is_booted_to_nakamoto
-            && burn_height == miner_2_submitted_commit_last_burn_height
-            && burn_height > miner_1_submitted_commit_last_burn_height
-    }
-
-    fn apply(&self, _state: &mut SignerTestState) {
-        info!("Applying: Miner 2 mining Bitcoin block and tenure change tx");
+        state.last_stacks_block_height = Some(self.ctx.get_peer_stacks_tip_height());
 
-        let stacks_height_before = self.miners.lock().unwrap().get_peer_stacks_tip_height();
+        // We can use miner 1 sortition db - it's the same for both miners
+        let sortdb = self.ctx.get_sortition_db(1);
 
-        let (conf_1, conf_2) = self.miners.lock().unwrap().get_node_configs();
-        let burnchain = conf_1.get_burnchain();
-        let sortdb = burnchain.open_sortition_db(true).unwrap();
-        self.miners
+        self.ctx
+            .miners
             .lock()
             .unwrap()
-            .mine_bitcoin_block_and_tenure_change_tx(&sortdb, TenureChangeCause::BlockFound, 60)
+            .mine_bitcoin_blocks_and_confirm(&sortdb, self.num_blocks, 30)
             .expect("Failed to mine BTC block");
-
-        let (_, miner_pk_2) = self.miners.lock().unwrap().get_miner_public_keys();
-
-        info!(
-            "Waiting for Nakamoto block {} pushed by miner 2",
-            stacks_height_before + 1
-        );
-
-        let secondary_miner_block =
-            wait_for_block_pushed_by_miner_key(30, stacks_height_before + 1, &miner_pk_2)
-                .expect("Failed to get block N");
-
-        let mined_block_height = secondary_miner_block.header.chain_length;
-
-        let info_after = get_chain_info(&conf_2);
-        assert_eq!(
-            info_after.stacks_tip,
-            secondary_miner_block.header.block_hash()
-        );
-        assert_eq!(info_after.stacks_tip_height, mined_block_height);
-        assert_eq!(mined_block_height, stacks_height_before + 1);
     }
 
     fn label(&self) -> String {
-        "MINE_BITCOIN_BLOCK_AND_TENURE_CHANGE_MINER_2".to_string()
+        format!("MINE_{}_BITCOIN_BLOCK(S)", self.num_blocks)
     }
 
     fn build(
         ctx: Arc<SignerTestContext>,
     ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
-        Just(CommandWrapper::new(
-            MineBitcoinBlockTenureChangeMiner2::new(ctx.miners.clone()),
-        ))
+        (1u64..5u64).prop_map({
+            move |num_blocks| {
+                CommandWrapper::new(MinerMineBitcoinBlocks::multiple(ctx.clone(), num_blocks))
+            }
+        })
     }
 }
 
-pub struct MineBitcoinBlock {
-    miners: Arc<Mutex<MultipleMinerTest>>,
-    timeout_secs: u64,
+/// Command to generate a specified number of Bitcoin blocks in the regtest environment.
+/// Unlike other mining commands, this command directly instructs the Bitcoin regtest
+/// controller to generate between 1-5 blocks without waiting for confirmations or
+/// monitoring their effect on the Stacks chain. It represents a low-level operation
+/// to advance the Bitcoin chain state.
+pub struct ChainGenerateBitcoinBlocks {
+    ctx: Arc<SignerTestContext>,
+    num_blocks: u64,
 }
 
-impl MineBitcoinBlock {
-    pub fn new(miners: Arc<Mutex<MultipleMinerTest>>, timeout_secs: u64) -> Self {
-        Self {
-            miners,
-            timeout_secs,
-        }
+impl ChainGenerateBitcoinBlocks {
+    fn new(ctx: Arc<SignerTestContext>, num_blocks: u64) -> Self {
+        Self { ctx, num_blocks }
+    }
+
+    pub fn one(ctx: Arc<SignerTestContext>) -> Self {
+        Self::new(ctx, 1)
+    }
+
+    pub fn multiple(ctx: Arc<SignerTestContext>, num_blocks: u64) -> Self {
+        Self::new(ctx, num_blocks)
     }
 }
 
-impl Command<SignerTestState, SignerTestContext> for MineBitcoinBlock {
+impl Command<SignerTestState, SignerTestContext> for ChainGenerateBitcoinBlocks {
     fn check(&self, _state: &SignerTestState) -> bool {
-        info!("Checking: Mining tenure. Result: {:?}", true);
+        info!(
+            "Checking: Build next {} Bitcoin block(s). Result: {}",
+            self.num_blocks, true
+        );
         true
     }
 
     fn apply(&self, _state: &mut SignerTestState) {
-        info!(
-            "Applying: Mining tenure and waiting for it for {:?} seconds",
-            self.timeout_secs
-        );
+        info!("Applying: Build next {} Bitcoin block(s)", self.num_blocks);
 
-        let sortdb = {
-            let miners = self.miners.lock().unwrap();
-            let (conf_1, _) = miners.get_node_configs();
-            let burnchain = conf_1.get_burnchain();
-            let sortdb = burnchain.open_sortition_db(true).unwrap();
-            sortdb
-        };
-
-        {
-            let mut miners = self.miners.lock().unwrap();
-            miners
-                .mine_bitcoin_blocks_and_confirm(&sortdb, 1, self.timeout_secs)
-                .expect("Failed to mine BTC block");
-        }
+        self.ctx
+            .miners
+            .lock()
+            .unwrap()
+            .btc_regtest_controller_mut()
+            .build_next_block(self.num_blocks);
     }
 
     fn label(&self) -> String {
-        "MINE_BITCOIN_BLOCK".to_string()
+        format!("BUILD_NEXT_{}_BITCOIN_BLOCKS", self.num_blocks)
     }
 
     fn build(
         ctx: Arc<SignerTestContext>,
     ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
-        (60u64..90u64).prop_map(move |timeout_secs| {
-            CommandWrapper::new(MineBitcoinBlock::new(ctx.miners.clone(), timeout_secs))
+        (1u64..=5u64).prop_map({
+            move |num_blocks| {
+                CommandWrapper::new(ChainGenerateBitcoinBlocks::multiple(
+                    ctx.clone(),
+                    num_blocks,
+                ))
+            }
         })
     }
 }