Standardize command naming pattern to not include "Command"

BowTiedRadone · BowTiedRadone · commit f8d74044ac71 · 2025-04-16T13:44:14.000-04:00
diff --git a/testnet/stacks-node/src/tests/signer/commands/block_commit.rs b/testnet/stacks-node/src/tests/signer/commands/block_commit.rs
@@ -4,17 +4,17 @@ use madhouse::{Command, CommandWrapper};
 use proptest::prelude::{Just, Strategy};
 use std::sync::{Arc, Mutex};
 
-pub struct SubmitBlockCommitSecondaryMinerCommand {
+pub struct SubmitBlockCommitSecondaryMiner {
     miners: Arc<Mutex<MultipleMinerTest>>,
 }
 
-impl SubmitBlockCommitSecondaryMinerCommand {
+impl SubmitBlockCommitSecondaryMiner {
     pub fn new(miners: Arc<Mutex<MultipleMinerTest>>) -> Self {
         Self { miners }
     }
 }
 
-impl Command<SignerTestState, SignerTestContext> for SubmitBlockCommitSecondaryMinerCommand {
+impl Command<SignerTestState, SignerTestContext> for SubmitBlockCommitSecondaryMiner {
     fn check(&self, state: &SignerTestState) -> bool {
         info!(
             "Checking: Submitting block commit miner 2. Result: {:?}",
@@ -41,22 +41,22 @@ impl Command<SignerTestState, SignerTestContext> for SubmitBlockCommitSecondaryM
         ctx: Arc<SignerTestContext>,
     ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
         Just(CommandWrapper::new(
-            SubmitBlockCommitSecondaryMinerCommand::new(ctx.miners.clone()),
+            SubmitBlockCommitSecondaryMiner::new(ctx.miners.clone()),
         ))
     }
 }
 
-pub struct SubmitBlockCommitPrimaryMinerCommand {
+pub struct SubmitBlockCommitPrimaryMiner {
     miners: Arc<Mutex<MultipleMinerTest>>,
 }
 
-impl SubmitBlockCommitPrimaryMinerCommand {
+impl SubmitBlockCommitPrimaryMiner {
     pub fn new(miners: Arc<Mutex<MultipleMinerTest>>) -> Self {
         Self { miners }
     }
 }
 
-impl Command<SignerTestState, SignerTestContext> for SubmitBlockCommitPrimaryMinerCommand {
+impl Command<SignerTestState, SignerTestContext> for SubmitBlockCommitPrimaryMiner {
     fn check(&self, state: &SignerTestState) -> bool {
         info!(
             "Checking: Submitting block commit miner 1. Result: {:?}",
@@ -83,7 +83,7 @@ impl Command<SignerTestState, SignerTestContext> for SubmitBlockCommitPrimaryMin
         ctx: Arc<SignerTestContext>,
     ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
         Just(CommandWrapper::new(
-            SubmitBlockCommitPrimaryMinerCommand::new(ctx.miners.clone()),
+            SubmitBlockCommitPrimaryMiner::new(ctx.miners.clone()),
         ))
     }
 }
diff --git a/testnet/stacks-node/src/tests/signer/commands/block_wait.rs b/testnet/stacks-node/src/tests/signer/commands/block_wait.rs
@@ -4,17 +4,17 @@ use madhouse::{Command, CommandWrapper};
 use proptest::prelude::{Just, Strategy};
 use std::sync::{atomic::Ordering, Arc, Mutex};
 
-pub struct WaitForBlockFromMiner1Command {
+pub struct WaitForBlockFromMiner1 {
     miners: Arc<Mutex<MultipleMinerTest>>,
 }
 
-impl WaitForBlockFromMiner1Command {
+impl WaitForBlockFromMiner1 {
     pub fn new(miners: Arc<Mutex<MultipleMinerTest>>) -> Self {
         Self { miners }
     }
 }
 
-impl Command<SignerTestState, SignerTestContext> for WaitForBlockFromMiner1Command {
+impl Command<SignerTestState, SignerTestContext> for WaitForBlockFromMiner1 {
     fn check(&self, state: &SignerTestState) -> bool {
         info!(
             "Checking: Waiting for Nakamoto block from miner 1. Result: {:?}",
@@ -56,23 +56,23 @@ impl Command<SignerTestState, SignerTestContext> for WaitForBlockFromMiner1Comma
     fn build(
         ctx: Arc<SignerTestContext>,
     ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
-        Just(CommandWrapper::new(WaitForBlockFromMiner1Command::new(
+        Just(CommandWrapper::new(WaitForBlockFromMiner1::new(
             ctx.miners.clone(),
         )))
     }
 }
 
-pub struct WaitForBlockFromMiner2Command {
+pub struct WaitForBlockFromMiner2 {
     miners: Arc<Mutex<MultipleMinerTest>>,
 }
 
-impl WaitForBlockFromMiner2Command {
+impl WaitForBlockFromMiner2 {
     pub fn new(miners: Arc<Mutex<MultipleMinerTest>>) -> Self {
         Self { miners }
     }
 }
 
-impl Command<SignerTestState, SignerTestContext> for WaitForBlockFromMiner2Command {
+impl Command<SignerTestState, SignerTestContext> for WaitForBlockFromMiner2 {
     fn check(&self, state: &SignerTestState) -> bool {
         info!(
             "Checking: Waiting for Nakamoto block from miner 2. Result: {:?}",
@@ -115,7 +115,7 @@ impl Command<SignerTestState, SignerTestContext> for WaitForBlockFromMiner2Comma
     fn build(
         ctx: Arc<SignerTestContext>,
     ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
-        Just(CommandWrapper::new(WaitForBlockFromMiner2Command::new(
+        Just(CommandWrapper::new(WaitForBlockFromMiner2::new(
             ctx.miners.clone(),
         )))
     }
diff --git a/testnet/stacks-node/src/tests/signer/commands/mining.rs b/testnet/stacks-node/src/tests/signer/commands/mining.rs
@@ -8,18 +8,18 @@ use stacks::chainstate::stacks::TenureChangeCause;
 use std::sync::{Arc, Mutex};
 use tracing::info;
 
-pub struct MineBitcoinBlockTenureChangePrimaryMinerCommand {
+pub struct MineBitcoinBlockTenureChangePrimaryMiner {
     miners: Arc<Mutex<MultipleMinerTest>>,
 }
 
-impl MineBitcoinBlockTenureChangePrimaryMinerCommand {
+impl MineBitcoinBlockTenureChangePrimaryMiner {
     pub fn new(miners: Arc<Mutex<MultipleMinerTest>>) -> Self {
         Self { miners }
     }
 }
 
 impl Command<SignerTestState, SignerTestContext>
-    for MineBitcoinBlockTenureChangePrimaryMinerCommand
+    for MineBitcoinBlockTenureChangePrimaryMiner
 {
     fn check(&self, state: &SignerTestState) -> bool {
         info!(
@@ -77,23 +77,23 @@ impl Command<SignerTestState, SignerTestContext>
         ctx: Arc<SignerTestContext>,
     ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
         Just(CommandWrapper::new(
-            MineBitcoinBlockTenureChangePrimaryMinerCommand::new(ctx.miners.clone()),
+            MineBitcoinBlockTenureChangePrimaryMiner::new(ctx.miners.clone()),
         ))
     }
 }
 
-pub struct MineBitcoinBlockTenureChangeSecondaryMinerCommand {
+pub struct MineBitcoinBlockTenureChangeSecondaryMiner {
     miners: Arc<Mutex<MultipleMinerTest>>,
 }
 
-impl MineBitcoinBlockTenureChangeSecondaryMinerCommand {
+impl MineBitcoinBlockTenureChangeSecondaryMiner {
     pub fn new(miners: Arc<Mutex<MultipleMinerTest>>) -> Self {
         Self { miners }
     }
 }
 
 impl Command<SignerTestState, SignerTestContext>
-    for MineBitcoinBlockTenureChangeSecondaryMinerCommand
+    for MineBitcoinBlockTenureChangeSecondaryMiner
 {
     fn check(&self, state: &SignerTestState) -> bool {
         info!(
@@ -147,7 +147,7 @@ impl Command<SignerTestState, SignerTestContext>
         ctx: Arc<SignerTestContext>,
     ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
         Just(CommandWrapper::new(
-            MineBitcoinBlockTenureChangeSecondaryMinerCommand::new(ctx.miners.clone()),
+            MineBitcoinBlockTenureChangeSecondaryMiner::new(ctx.miners.clone()),
         ))
     }
 }
diff --git a/testnet/stacks-node/src/tests/signer/commands/mod.rs b/testnet/stacks-node/src/tests/signer/commands/mod.rs
@@ -13,13 +13,13 @@ mod transfer;
 pub use context::{SignerTestContext};
 
 pub use block_commit::{
-    SubmitBlockCommitPrimaryMinerCommand, SubmitBlockCommitSecondaryMinerCommand,
+    SubmitBlockCommitPrimaryMiner, SubmitBlockCommitSecondaryMiner,
 };
-pub use block_wait::{WaitForBlockFromMiner1Command, WaitForBlockFromMiner2Command};
+pub use block_wait::{WaitForBlockFromMiner1, WaitForBlockFromMiner2};
 pub use boot::BootToEpoch3;
 pub use commit_ops::{SkipCommitOpPrimaryMiner, SkipCommitOpSecondaryMiner};
-pub use mining::MineBitcoinBlockTenureChangePrimaryMinerCommand;
-pub use shutdown::ShutdownMinersCommand;
-pub use stalling::{RecoverFromStallCommand, StallMiningCommand};
+pub use mining::MineBitcoinBlockTenureChangePrimaryMiner;
+pub use shutdown::ShutdownMiners;
+pub use stalling::{RecoverFromStall, StallMining};
 pub use tenure::MineBitcoinBlock;
-pub use transfer::SendTransferTxCommand;
+pub use transfer::SendTransferTx;
diff --git a/testnet/stacks-node/src/tests/signer/commands/shutdown.rs b/testnet/stacks-node/src/tests/signer/commands/shutdown.rs
@@ -4,17 +4,17 @@ use madhouse::{Command, CommandWrapper};
 use proptest::prelude::{Just, Strategy};
 use std::sync::{Arc, Mutex};
 
-pub struct ShutdownMinersCommand {
+pub struct ShutdownMiners {
     miners: Arc<Mutex<MultipleMinerTest>>,
 }
 
-impl ShutdownMinersCommand {
+impl ShutdownMiners {
     pub fn new(miners: Arc<Mutex<MultipleMinerTest>>) -> Self {
         Self { miners }
     }
 }
 
-impl Command<SignerTestState, SignerTestContext> for ShutdownMinersCommand {
+impl Command<SignerTestState, SignerTestContext> for ShutdownMiners {
     fn check(&self, _state: &SignerTestState) -> bool {
         info!("Checking: Shutting down miners. Result: {:?}", true);
         true
@@ -37,7 +37,7 @@ impl Command<SignerTestState, SignerTestContext> for ShutdownMinersCommand {
     fn build(
         ctx: Arc<SignerTestContext>,
     ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
-        Just(CommandWrapper::new(ShutdownMinersCommand::new(
+        Just(CommandWrapper::new(ShutdownMiners::new(
             ctx.miners.clone(),
         )))
     }
diff --git a/testnet/stacks-node/src/tests/signer/commands/stalling.rs b/testnet/stacks-node/src/tests/signer/commands/stalling.rs
@@ -3,9 +3,9 @@ use madhouse::{Command, CommandWrapper};
 use proptest::prelude::{Just, Strategy};
 use std::sync::Arc;
 
-pub struct StallMiningCommand;
+pub struct StallMining;
 
-impl Command<SignerTestState, SignerTestContext> for StallMiningCommand {
+impl Command<SignerTestState, SignerTestContext> for StallMining {
     fn check(&self, state: &SignerTestState) -> bool {
         info!(
             "Checking: Stalling mining. Result: {:?}",
@@ -27,13 +27,13 @@ impl Command<SignerTestState, SignerTestContext> for StallMiningCommand {
     fn build(
         _ctx: Arc<SignerTestContext>,
     ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
-        Just(CommandWrapper::new(StallMiningCommand))
+        Just(CommandWrapper::new(StallMining))
     }
 }
 
-pub struct RecoverFromStallCommand;
+pub struct RecoverFromStall;
 
-impl Command<SignerTestState, SignerTestContext> for RecoverFromStallCommand {
+impl Command<SignerTestState, SignerTestContext> for RecoverFromStall {
     fn check(&self, state: &SignerTestState) -> bool {
         info!(
             "Checking: Recovering from mining stall. Result: {:?}",
@@ -55,6 +55,6 @@ impl Command<SignerTestState, SignerTestContext> for RecoverFromStallCommand {
     fn build(
         _ctx: Arc<SignerTestContext>,
     ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
-        Just(CommandWrapper::new(RecoverFromStallCommand))
+        Just(CommandWrapper::new(RecoverFromStall))
     }
 }
diff --git a/testnet/stacks-node/src/tests/signer/commands/transfer.rs b/testnet/stacks-node/src/tests/signer/commands/transfer.rs
@@ -4,17 +4,17 @@ use madhouse::{Command, CommandWrapper};
 use proptest::prelude::{Just, Strategy};
 use std::sync::{Arc, Mutex};
 
-pub struct SendTransferTxCommand {
+pub struct SendTransferTx {
     miners: Arc<Mutex<MultipleMinerTest>>,
 }
 
-impl SendTransferTxCommand {
+impl SendTransferTx {
     pub fn new(miners: Arc<Mutex<MultipleMinerTest>>) -> Self {
         Self { miners }
     }
 }
 
-impl Command<SignerTestState, SignerTestContext> for SendTransferTxCommand {
+impl Command<SignerTestState, SignerTestContext> for SendTransferTx {
     fn check(&self, _state: &SignerTestState) -> bool {
         info!("Checking: Sending transfer tx. Result: {:?}", true);
         true
@@ -33,7 +33,7 @@ impl Command<SignerTestState, SignerTestContext> for SendTransferTxCommand {
     fn build(
         ctx: Arc<SignerTestContext>,
     ) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {
-        Just(CommandWrapper::new(SendTransferTxCommand::new(
+        Just(CommandWrapper::new(SendTransferTx::new(
             ctx.miners.clone(),
         )))
     }
diff --git a/testnet/stacks-node/src/tests/signer/v0.rs b/testnet/stacks-node/src/tests/signer/v0.rs
@@ -10450,20 +10450,20 @@ fn allow_reorg_within_first_proposal_burn_block_timing_secs_scenario() {
         SkipCommitOpSecondaryMiner,
         BootToEpoch3,
         SkipCommitOpPrimaryMiner,
-        MineBitcoinBlockTenureChangePrimaryMinerCommand,
-        SubmitBlockCommitSecondaryMinerCommand,
-        StallMiningCommand,
+        MineBitcoinBlockTenureChangePrimaryMiner,
+        SubmitBlockCommitSecondaryMiner,
+        StallMining,
         MineBitcoinBlock,
-        SubmitBlockCommitPrimaryMinerCommand,
-        RecoverFromStallCommand,
-        WaitForBlockFromMiner2Command,
+        SubmitBlockCommitPrimaryMiner,
+        RecoverFromStall,
+        WaitForBlockFromMiner2,
         MineBitcoinBlock,
-        WaitForBlockFromMiner1Command,
-        SubmitBlockCommitPrimaryMinerCommand,
-        SendTransferTxCommand,
-        WaitForBlockFromMiner1Command,
-        MineBitcoinBlockTenureChangePrimaryMinerCommand,
-        ShutdownMinersCommand
+        WaitForBlockFromMiner1,
+        SubmitBlockCommitPrimaryMiner,
+        SendTransferTx,
+        WaitForBlockFromMiner1,
+        MineBitcoinBlockTenureChangePrimaryMiner,
+        ShutdownMiners
     ]
 }
 

Original file line number	Diff line number	Diff line change
`@@ -4,17 +4,17 @@ use madhouse::{Command, CommandWrapper};`
`4`	`4`	`use proptest::prelude::{Just, Strategy};`
`5`	`5`	`use std::sync::{Arc, Mutex};`
`6`	`6`
`7`		`-pub struct SubmitBlockCommitSecondaryMinerCommand {`
	`7`	`+pub struct SubmitBlockCommitSecondaryMiner {`
`8`	`8`	`miners: Arc<Mutex<MultipleMinerTest>>,`
`9`	`9`	`}`
`10`	`10`
`11`		`-impl SubmitBlockCommitSecondaryMinerCommand {`
	`11`	`+impl SubmitBlockCommitSecondaryMiner {`
`12`	`12`	`pub fn new(miners: Arc<Mutex<MultipleMinerTest>>) -> Self {`
`13`	`13`	`Self { miners }`
`14`	`14`	`}`
`15`	`15`	`}`
`16`	`16`
`17`		`-impl Command<SignerTestState, SignerTestContext> for SubmitBlockCommitSecondaryMinerCommand {`
	`17`	`+impl Command<SignerTestState, SignerTestContext> for SubmitBlockCommitSecondaryMiner {`
`18`	`18`	`fn check(&self, state: &SignerTestState) -> bool {`
`19`	`19`	`info!(`
`20`	`20`	`"Checking: Submitting block commit miner 2. Result: {:?}",`
`@@ -41,22 +41,22 @@ impl Command<SignerTestState, SignerTestContext> for SubmitBlockCommitSecondaryM`
`41`	`41`	`ctx: Arc<SignerTestContext>,`
`42`	`42`	`) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {`
`43`	`43`	`Just(CommandWrapper::new(`
`44`		`- SubmitBlockCommitSecondaryMinerCommand::new(ctx.miners.clone()),`
	`44`	`+ SubmitBlockCommitSecondaryMiner::new(ctx.miners.clone()),`
`45`	`45`	`))`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`49`		`-pub struct SubmitBlockCommitPrimaryMinerCommand {`
	`49`	`+pub struct SubmitBlockCommitPrimaryMiner {`
`50`	`50`	`miners: Arc<Mutex<MultipleMinerTest>>,`
`51`	`51`	`}`
`52`	`52`
`53`		`-impl SubmitBlockCommitPrimaryMinerCommand {`
	`53`	`+impl SubmitBlockCommitPrimaryMiner {`
`54`	`54`	`pub fn new(miners: Arc<Mutex<MultipleMinerTest>>) -> Self {`
`55`	`55`	`Self { miners }`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`		`-impl Command<SignerTestState, SignerTestContext> for SubmitBlockCommitPrimaryMinerCommand {`
	`59`	`+impl Command<SignerTestState, SignerTestContext> for SubmitBlockCommitPrimaryMiner {`
`60`	`60`	`fn check(&self, state: &SignerTestState) -> bool {`
`61`	`61`	`info!(`
`62`	`62`	`"Checking: Submitting block commit miner 1. Result: {:?}",`
`@@ -83,7 +83,7 @@ impl Command<SignerTestState, SignerTestContext> for SubmitBlockCommitPrimaryMin`
`83`	`83`	`ctx: Arc<SignerTestContext>,`
`84`	`84`	`) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {`
`85`	`85`	`Just(CommandWrapper::new(`
`86`		`- SubmitBlockCommitPrimaryMinerCommand::new(ctx.miners.clone()),`
	`86`	`+ SubmitBlockCommitPrimaryMiner::new(ctx.miners.clone()),`
`87`	`87`	`))`
`88`	`88`	`}`
`89`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,18 +8,18 @@ use stacks::chainstate::stacks::TenureChangeCause;`
`8`	`8`	`use std::sync::{Arc, Mutex};`
`9`	`9`	`use tracing::info;`
`10`	`10`
`11`		`-pub struct MineBitcoinBlockTenureChangePrimaryMinerCommand {`
	`11`	`+pub struct MineBitcoinBlockTenureChangePrimaryMiner {`
`12`	`12`	`miners: Arc<Mutex<MultipleMinerTest>>,`
`13`	`13`	`}`
`14`	`14`
`15`		`-impl MineBitcoinBlockTenureChangePrimaryMinerCommand {`
	`15`	`+impl MineBitcoinBlockTenureChangePrimaryMiner {`
`16`	`16`	`pub fn new(miners: Arc<Mutex<MultipleMinerTest>>) -> Self {`
`17`	`17`	`Self { miners }`
`18`	`18`	`}`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`impl Command<SignerTestState, SignerTestContext>`
`22`		`- for MineBitcoinBlockTenureChangePrimaryMinerCommand`
	`22`	`+ for MineBitcoinBlockTenureChangePrimaryMiner`
`23`	`23`	`{`
`24`	`24`	`fn check(&self, state: &SignerTestState) -> bool {`
`25`	`25`	`info!(`
`@@ -77,23 +77,23 @@ impl Command<SignerTestState, SignerTestContext>`
`77`	`77`	`ctx: Arc<SignerTestContext>,`
`78`	`78`	`) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {`
`79`	`79`	`Just(CommandWrapper::new(`
`80`		`- MineBitcoinBlockTenureChangePrimaryMinerCommand::new(ctx.miners.clone()),`
	`80`	`+ MineBitcoinBlockTenureChangePrimaryMiner::new(ctx.miners.clone()),`
`81`	`81`	`))`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
`85`		`-pub struct MineBitcoinBlockTenureChangeSecondaryMinerCommand {`
	`85`	`+pub struct MineBitcoinBlockTenureChangeSecondaryMiner {`
`86`	`86`	`miners: Arc<Mutex<MultipleMinerTest>>,`
`87`	`87`	`}`
`88`	`88`
`89`		`-impl MineBitcoinBlockTenureChangeSecondaryMinerCommand {`
	`89`	`+impl MineBitcoinBlockTenureChangeSecondaryMiner {`
`90`	`90`	`pub fn new(miners: Arc<Mutex<MultipleMinerTest>>) -> Self {`
`91`	`91`	`Self { miners }`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`impl Command<SignerTestState, SignerTestContext>`
`96`		`- for MineBitcoinBlockTenureChangeSecondaryMinerCommand`
	`96`	`+ for MineBitcoinBlockTenureChangeSecondaryMiner`
`97`	`97`	`{`
`98`	`98`	`fn check(&self, state: &SignerTestState) -> bool {`
`99`	`99`	`info!(`
`@@ -147,7 +147,7 @@ impl Command<SignerTestState, SignerTestContext>`
`147`	`147`	`ctx: Arc<SignerTestContext>,`
`148`	`148`	`) -> impl Strategy<Value = CommandWrapper<SignerTestState, SignerTestContext>> {`
`149`	`149`	`Just(CommandWrapper::new(`
`150`		`- MineBitcoinBlockTenureChangeSecondaryMinerCommand::new(ctx.miners.clone()),`
	`150`	`+ MineBitcoinBlockTenureChangeSecondaryMiner::new(ctx.miners.clone()),`
`151`	`151`	`))`
`152`	`152`	`}`
`153`	`153`	`}`