feat(testing): specify default cluster config in an individual scenario

Author: binier

node/testing/src/cluster/config.rs

@@ -39,7 +39,7 @@ impl ClusterConfig {
         })
     }
 
-    pub fn use_debugger(mut self) -> Self {
+    pub fn use_debugger(&mut self) -> &mut Self {
         self.use_debugger = true;
         self
     }
@@ -48,7 +48,7 @@ impl ClusterConfig {
         self.use_debugger
     }
 
-    pub fn set_replay(mut self) -> Self {
+    pub fn set_replay(&mut self) -> &mut Self {
         self.is_replay = true;
         self
     }
@@ -62,7 +62,7 @@ impl ClusterConfig {
         (range.0)..=(range.1)
     }
 
-    pub fn set_all_rust_to_rust_use_webrtc(mut self) -> Self {
+    pub fn set_all_rust_to_rust_use_webrtc(&mut self) -> &mut Self {
         assert!(cfg!(feature = "p2p-webrtc"));
         self.all_rust_to_rust_use_webrtc = true;
         self
@@ -76,7 +76,7 @@ impl ClusterConfig {
         self.proof_kind
     }
 
-    pub fn set_ocaml_node_executable(mut self, executable: OcamlNodeExecutable) -> Self {
+    pub fn set_ocaml_node_executable(&mut self, executable: OcamlNodeExecutable) -> &mut Self {
         self.ocaml_node_executable = Some(executable);
         self
     }

node/testing/src/main.rs

@@ -72,32 +72,27 @@ impl Command {
             Self::ScenariosGenerate(cmd) => {
                 #[cfg(feature = "scenario-generators")]
                 {
-                    let config = ClusterConfig::new(None).map_err(|err| {
-                        anyhow::anyhow!("failed to create cluster configuration: {err}")
-                    })?;
-                    let config = if cmd.use_debugger {
-                        config.use_debugger()
-                    } else {
-                        config
+                    let run_scenario = |scenario: Scenarios| -> Result<_, anyhow::Error> {
+                        let mut config = scenario.default_cluster_config()?;
+                        if cmd.use_debugger {
+                            config.use_debugger();
+                        }
+                        Ok(scenario.run_only_from_scratch(config))
                     };
-
                     let fut = async move {
                         if let Some(name) = cmd.name {
                             if let Some(scenario) = Scenarios::find_by_name(&name) {
-                                scenario.run_only_from_scratch(config).await;
-                                // scenario.run_and_save_from_scratch(config).await;
+                                run_scenario(scenario)?.await;
                             } else {
                                 anyhow::bail!("no such scenario: \"{name}\"");
                             }
                         } else {
                             for scenario in Scenarios::iter() {
-                                scenario.run_only_from_scratch(config.clone()).await;
-                                // scenario.run_and_save_from_scratch(config.clone()).await;
+                                run_scenario(scenario)?.await;
                             }
                         }
                         Ok(())
                     };
-
                     rt.block_on(async {
                         tokio::select! {
                             res = fut => res,
@@ -113,10 +108,10 @@ impl Command {
                     .into())
             }
             Self::ScenariosRun(cmd) => {
-                let config = ClusterConfig::new(None).map_err(|err| {
+                let mut config = ClusterConfig::new(None).map_err(|err| {
                     anyhow::anyhow!("failed to create cluster configuration: {err}")
                 })?;
-                let config = config.set_replay();
+                config.set_replay();
 
                 let id = cmd.name.parse()?;
                 let fut = async move {

node/testing/src/scenarios/mod.rs

@@ -158,6 +158,16 @@ impl Scenarios {
         }
     }
 
+    pub fn default_cluster_config(self) -> Result<ClusterConfig, anyhow::Error> {
+        let config = ClusterConfig::new(None)
+            .map_err(|err| anyhow::anyhow!("failed to create cluster configuration: {err}"))?;
+
+        match self {
+            Self::P2pSignaling(v) => v.default_cluster_config(config),
+            _ => Ok(config),
+        }
+    }
+
     pub fn blank_scenario(self) -> Scenario {
         let mut scenario = Scenario::new(self.id(), self.parent_id());
         scenario.set_description(self.description().to_owned());

node/testing/src/scenarios/p2p/signaling.rs

@@ -6,6 +6,7 @@ use node::{
 };
 
 use crate::{
+    cluster::ClusterConfig,
     node::RustNodeTestingConfig,
     scenarios::{ClusterRunner, DynEffectsData, RunCfg},
 };
@@ -16,6 +17,14 @@ use crate::{
 pub struct P2pSignaling;
 
 impl P2pSignaling {
+    pub fn default_cluster_config(
+        self,
+        mut config: ClusterConfig,
+    ) -> Result<ClusterConfig, anyhow::Error> {
+        config.set_all_rust_to_rust_use_webrtc();
+        Ok(config)
+    }
+
     pub async fn run(self, mut runner: ClusterRunner<'_>) {
         const NODES_N: usize = 4;
 

node/testing/tests/common.rs

@@ -57,16 +57,16 @@ macro_rules! scenario_test {
                 }));
             }
 
+            let scenario = $scenario_instance;
             #[allow(unused_mut)]
-            let mut config = ClusterConfig::new(None).unwrap();
+            let mut config = scenario.default_cluster_config().unwrap();
             #[cfg(feature = "p2p-webrtc")]
             if $can_test_webrtc {
                 eprintln!("All rust to rust connections will be over webrtc transport");
                 config = config.set_all_rust_to_rust_use_webrtc();
             }
             let mut cluster = Cluster::new(config);
             let runner = ClusterRunner::new(&mut cluster, |_| {});
-            let scenario = $scenario_instance;
             scenario.run(runner).await;
 
             if let Some(summary) = std::env::var_os("GITHUB_STEP_SUMMARY") {