Merge pull request #701 from pragma-org/etorreborre/test/fix-flaky-simulation-2

test: fix simulation issues

Author: jeluard

crates/amaru/src/tests/setup.rs

@@ -24,6 +24,7 @@ use amaru_ouroboros::{
     can_validate_blocks::mock::{MockCanValidateBlocks, MockCanValidateHeaders},
 };
 use amaru_protocols::{manager::ManagerMessage, store_effects::Store};
+use anyhow::anyhow;
 use pure_stage::{
     Effects, StageGraph, StageRef, TryInStage,
     simulation::{RandStdRng, SimulationBuilder},
@@ -79,7 +80,8 @@ pub fn create_node(
     // in order to simulate what happens when new tips are added and trigger a move of the best
     // chain anchor.
     global_parameters.consensus_security_param = node_config.chain_length;
-    let manager_stage = build_node(&config, &global_parameters, None, stage_graph)?;
+    let manager_stage = build_node(&config, &global_parameters, None, stage_graph)
+        .map_err(|e| anyhow!("Cannot build node.\nThe node config is\n{:?}\n\nThe error is {e:?}", node_config))?;
 
     // The actions stage allows us to send NewTip messages to the manager so that chainsync
     // events can be sent to the node under test.

simulation/amaru-sim/src/simulator/run_config.rs

@@ -93,11 +93,11 @@ impl RunConfig {
     }
 
     pub fn upstream_peers(&self) -> Vec<Peer> {
-        (1..=self.number_of_upstream_peers).map(|i| Peer::new(&format!("127.0.0.1:300{i}"))).collect()
+        (1..=self.number_of_upstream_peers as u16).map(|i| Peer::new(&format!("127.0.0.1:{}", 30000 + i))).collect()
     }
 
     pub fn downstream_peers(&self) -> Vec<Peer> {
-        (1..=self.number_of_downstream_peers).map(|i| Peer::new(&format!("127.0.0.1:400{i}"))).collect()
+        (1..=self.number_of_downstream_peers as u16).map(|i| Peer::new(&format!("127.0.0.1:{}", 40000 + i))).collect()
     }
 
     pub fn rng(&self) -> RandStdRng {

simulation/amaru-sim/src/simulator/run_tests.rs

@@ -89,11 +89,14 @@ pub fn run_test(run_config: &RunConfig, actions: &GeneratedActions) -> TestResul
         let mut rng = run_config.rng();
         let mut nodes = create_nodes(&mut rng, node_configs(run_config, actions)).expect("failed to create nodes");
 
-        // Scale steps based on number of peers (more peers = more stages = more effects)
-        let base_steps = 10000;
-        let per_peer_steps = 2000;
-        let total_peers = run_config.number_of_upstream_peers as usize + run_config.number_of_downstream_peers as usize;
-        let steps = base_steps + (total_peers * per_peer_steps);
+        // Scale steps based on the number of nodes in the system.
+        // Each step runs one effect on one randomly-selected node, so with N nodes
+        // each node gets ~total_steps/N turns. We multiply by total_nodes to ensure
+        // every node (especially the node under test) gets enough turns.
+        let upstream = run_config.number_of_upstream_peers as usize;
+        let downstream = run_config.number_of_downstream_peers as usize;
+        let total_nodes = upstream + downstream + 1;
+        let steps = total_nodes * (5000 + upstream * 500);
 
         nodes.run(&mut rng, steps);
         check_chain_property(nodes, actions)
@@ -117,7 +120,12 @@ pub fn run_test(run_config: &RunConfig, actions: &GeneratedActions) -> TestResul
 pub fn node_configs(run_config: &RunConfig, actions: &GeneratedActions) -> Vec<NodeTestConfig> {
     let upstream_peers = run_config.upstream_peers();
 
-    let upstream_nodes = upstream_peers
+    // Only create nodes for peers that have actions. During shrinking, some peers may lose
+    // all their actions, so we skip creating nodes for them.
+    let active_peers: Vec<_> =
+        upstream_peers.iter().filter(|peer| !get_peer_actions(actions, peer).is_empty()).cloned().collect();
+
+    let upstream_nodes = active_peers
         .iter()
         .map(|peer| {
             NodeTestConfig::default()
@@ -135,7 +143,7 @@ pub fn node_configs(run_config: &RunConfig, actions: &GeneratedActions) -> Vec<N
     let node_under_test = NodeTestConfig::default()
         .with_listen_address(listen_address)
         .with_chain_length(run_config.generated_chain_depth)
-        .with_upstream_peers(upstream_peers)
+        .with_upstream_peers(active_peers)
         .with_trace_buffer(trace_buffer)
         .with_validated_blocks(vec![actions.get_anchor()])
         .with_node_type(NodeUnderTest);