test: add generation arguments

Signed-off-by: etorreborre <etorreborre@yahoo.com>

Author: etorreborre

crates/amaru-consensus/src/consensus/headers_tree/data_generation/actions.rs

@@ -44,6 +44,7 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::cmp::Reverse;
 use std::collections::BTreeMap;
 use std::fmt::{Debug, Display, Formatter};
+use std::str::FromStr;
 use std::sync::Arc;
 
 /// This data type models the events sent by the ChainSync mini-protocol with simplified data for the tests.
@@ -315,6 +316,30 @@ pub fn random_walk(
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub struct Ratio(pub u32, pub u32);
 
+impl Display for Ratio {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}/{}", self.0, self.1)
+    }
+}
+
+impl FromStr for Ratio {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let parts: Vec<&str> = s.split('/').collect();
+        if parts.len() != 2 {
+            return Err("Ratio must be in the form 'numerator/denominator'".to_string());
+        }
+        let numerator = parts[0]
+            .parse::<u32>()
+            .map_err(|_| format!("Invalid numerator in ratio: {}", parts[0]))?;
+        let denominator = parts[1]
+            .parse::<u32>()
+            .map_err(|_| format!("Invalid denominator in ratio: {}", parts[1]))?;
+        Ok(Ratio(numerator, denominator))
+    }
+}
+
 /// Generate random walks for a fixed number of peers on a given tree of headers.
 ///
 /// The returned list of actions is transposed so that the actions from different peers are interleaved.
@@ -358,8 +383,9 @@ pub fn any_select_chains(
     peers_nb: usize,
     depth: usize,
     rollback_ratio: Ratio,
+    branching_ratio: Ratio,
 ) -> impl Strategy<Value = Vec<Action>> {
-    any_tree_of_headers(depth, Ratio(1, 2)).prop_flat_map(move |tree| {
+    any_tree_of_headers(depth, branching_ratio).prop_flat_map(move |tree| {
         (1..u64::MAX)
             .prop_map(move |seed| generate_random_walks(&tree, peers_nb, rollback_ratio, seed))
     })

crates/amaru-consensus/src/consensus/headers_tree/headers_tree.rs

@@ -1284,11 +1284,12 @@ mod tests {
     const MAX_LENGTH: usize = 5;
     const TEST_CASES_NB: u32 = 1000;
     const ROLLBACK_RATIO: Ratio = Ratio(1, 2);
+    const BRANCHING_RATIO: Ratio = Ratio(1, 2);
 
     proptest! {
         #![proptest_config(config_begin().no_shrink().with_cases(TEST_CASES_NB).end())]
         #[test]
-        fn run_chain_selection(actions in any_select_chains(DEPTH, 5, ROLLBACK_RATIO)) {
+        fn run_chain_selection(actions in any_select_chains(DEPTH, 5, ROLLBACK_RATIO, BRANCHING_RATIO)) {
             let results = execute_actions(MAX_LENGTH, &actions, false).unwrap();
             let actual_chains = make_best_chains_from_results(&results);
             let expected_chains = make_best_chains_from_actions(&actions);

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

@@ -12,7 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use amaru_consensus::consensus::headers_tree::data_generation::Ratio;
 use clap::Parser;
+use std::str::FromStr;
 
 #[derive(Debug, Parser, Clone)]
 #[clap(name = "Amaru Simulator")]
@@ -39,6 +41,14 @@ pub struct Args {
     #[arg(long, default_value = "10")]
     pub generated_chain_depth: u64,
 
+    /// Ratio of rollbacks in the generated chain for a given peer
+    #[arg(long, default_value = "1/2", value_parser = Ratio::from_str)]
+    pub generated_chain_rollback_ratio: Ratio,
+
+    /// Ratio of branches generated from a central chain that can be explored by peers during input generation
+    #[arg(long, default_value = "1/2", value_parser = Ratio::from_str)]
+    pub generated_chain_branching_ratio: Ratio,
+
     #[arg(long)]
     pub disable_shrinking: bool,
 

simulation/amaru-sim/src/simulator/data_generation/generate.rs

@@ -18,7 +18,7 @@ use crate::simulator::data_generation::base_generators::generate_arrival_times;
 use crate::simulator::{Entry, NodeConfig};
 use crate::sync::ChainSyncMessage;
 use amaru_consensus::IsHeader;
-use amaru_consensus::consensus::headers_tree::data_generation::{Action, Ratio, any_select_chains};
+use amaru_consensus::consensus::headers_tree::data_generation::{Action, any_select_chains};
 use amaru_kernel::peer::Peer;
 use amaru_kernel::to_cbor;
 use amaru_ouroboros_traits::tests::run_with_rng;
@@ -37,7 +37,8 @@ pub fn generate_entries<R: Rng>(
             any_select_chains(
                 node_config.number_of_upstream_peers as usize,
                 node_config.generated_chain_depth as usize,
-                Ratio(1, 2),
+                node_config.generated_chain_rollback_ratio,
+                node_config.generated_chain_branching_ratio,
             ),
         );
 

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

@@ -13,13 +13,16 @@
 // limitations under the License.
 
 use crate::simulator::Args;
+use amaru_consensus::consensus::headers_tree::data_generation::Ratio;
 
 /// Configuration for a single node
 #[derive(Debug, Clone)]
 pub struct NodeConfig {
     pub number_of_upstream_peers: u8,
     pub number_of_downstream_peers: u8,
     pub generated_chain_depth: u64,
+    pub generated_chain_rollback_ratio: Ratio,
+    pub generated_chain_branching_ratio: Ratio,
 }
 
 impl Default for NodeConfig {
@@ -28,6 +31,8 @@ impl Default for NodeConfig {
             number_of_upstream_peers: 2,
             number_of_downstream_peers: 1,
             generated_chain_depth: 10,
+            generated_chain_rollback_ratio: Ratio(1, 2),
+            generated_chain_branching_ratio: Ratio(1, 2),
         }
     }
 }
@@ -38,6 +43,8 @@ impl NodeConfig {
             number_of_upstream_peers: args.number_of_upstream_peers,
             number_of_downstream_peers: args.number_of_downstream_peers,
             generated_chain_depth: args.generated_chain_depth,
+            generated_chain_rollback_ratio: args.generated_chain_rollback_ratio,
+            generated_chain_branching_ratio: args.generated_chain_branching_ratio,
         }
     }
 
@@ -55,4 +62,14 @@ impl NodeConfig {
         self.generated_chain_depth = depth;
         self
     }
+
+    pub fn with_generated_chain_rollback_ratio(mut self, ratio: Ratio) -> Self {
+        self.generated_chain_rollback_ratio = ratio;
+        self
+    }
+
+    pub fn with_generated_chain_branching_ratio(mut self, ratio: Ratio) -> Self {
+        self.generated_chain_branching_ratio = ratio;
+        self
+    }
 }

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

@@ -238,17 +238,17 @@ fn make_chain_selector(
 }
 
 /// Property: at the end of the simulation, the chain built from the history of messages received
-/// must match one of the best chains that could be built from the entries.
+/// downstream must match the best chain built directly from messages coming from upstream peers.
 fn chain_property()
 -> impl Fn(&[Entry<ChainSyncMessage>], &History<ChainSyncMessage>) -> Result<(), String> {
     move |entries, history| {
-        let expected = make_best_chain_from_entries(
+        let expected = make_best_chain_from_upstream_messages(
             &entries
                 .iter()
                 .map(|e| e.envelope.clone())
                 .collect::<Vec<_>>(),
         );
-        let actual = make_best_chain_from_results(history);
+        let actual = make_best_chain_from_downstream_messages(history);
         let actual_chain = actual.list_to_string(",\n ");
         let expected_chain = expected.list_to_string(",\n ");
         assert_eq!(
@@ -261,7 +261,7 @@ fn chain_property()
 }
 
 /// Build the best chain from messages incoming from upstream peers.
-pub fn make_best_chain_from_entries(messages: &[Envelope<ChainSyncMessage>]) -> Chain {
+pub fn make_best_chain_from_upstream_messages(messages: &[Envelope<ChainSyncMessage>]) -> Chain {
     // keep the chain of each peer
     let mut current_chains: BTreeMap<String, Chain> = BTreeMap::new();
 
@@ -309,9 +309,8 @@ pub fn make_best_chain_from_entries(messages: &[Envelope<ChainSyncMessage>]) ->
     current_chains.get(&best_chain_tracker).unwrap().clone()
 }
 
-/// Build the best chain from the results by creating a chain corresponding to the ChainSyncMessage emitted
-/// by the node.
-pub fn make_best_chain_from_results(history: &History<ChainSyncMessage>) -> Chain {
+/// Build the best chain from messages sent to downstream peers.
+pub fn make_best_chain_from_downstream_messages(history: &History<ChainSyncMessage>) -> Chain {
     let mut best_chain = vec![];
     for (i, message) in history.0.iter().enumerate() {
         // only consider messages sent to the first peer

simulation/amaru-sim/tests/simulation.rs

@@ -40,6 +40,14 @@ fn run_simulator() {
             "AMARU_GENERATED_CHAIN_DEPTH",
             node_config.generated_chain_depth,
         ),
+        generated_chain_rollback_ratio: get_env_var(
+            "AMARU_GENERATED_CHAIN_ROLLBACK_RATIO",
+            node_config.generated_chain_rollback_ratio,
+        ),
+        generated_chain_branching_ratio: get_env_var(
+            "AMARU_GENERATED_CHAIN_BRANCHING_RATIO",
+            node_config.generated_chain_branching_ratio,
+        ),
         disable_shrinking: is_true("AMARU_DISABLE_SHRINKING"),
         seed: get_optional_env_var("AMARU_TEST_SEED"),
         persist_on_success: is_true("AMARU_PERSIST_ON_SUCCESS"),

simulation/amaru-sim/tests/traces.rs

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use amaru_consensus::consensus::headers_tree::data_generation::Ratio;
 use amaru_sim::simulator::run::spawn_node;
 use amaru_sim::simulator::simulate::simulate;
 use amaru_sim::simulator::{Args, NodeConfig, NodeHandle, SimulateConfig, generate_entries};
@@ -31,6 +32,8 @@ fn run_simulator_with_traces() {
         number_of_upstream_peers: 1,
         number_of_downstream_peers: 1,
         generated_chain_depth: 1,
+        generated_chain_rollback_ratio: Ratio(1, 2),
+        generated_chain_branching_ratio: Ratio(1, 2),
         disable_shrinking: true,
         seed: None,
         persist_on_success: false,