feat(testing): record addition of rust/ocaml nodes in scenario as steps

re: #188

Author: binier

node/testing/src/cluster/mod.rs

@@ -38,7 +38,7 @@ use openmina_node_native::{http_server, rpc::RpcService, NodeService, RpcSender}
 use rand::{rngs::StdRng, SeedableRng};
 use serde::Serialize;
 
-use crate::node::{OcamlStep, TestPeerId};
+use crate::node::{DaemonJson, OcamlStep, TestPeerId};
 use crate::{
     network_debugger::Debugger,
     node::{
@@ -385,6 +385,14 @@ impl Cluster {
             .map(|(i, node)| (ClusterNodeId::new_unchecked(i), node))
     }
 
+    pub fn ocaml_nodes_iter(&self) -> impl Iterator<Item = (ClusterOcamlNodeId, &OcamlNode)> {
+        self.ocaml_nodes
+            .iter()
+            .enumerate()
+            .filter_map(|(i, node)| node.as_ref().map(|node| (i, node)))
+            .map(|(i, node)| (ClusterOcamlNodeId::new_unchecked(i), node))
+    }
+
     pub fn node(&self, node_id: ClusterNodeId) -> Option<&Node> {
         self.nodes.get(node_id.index())
     }
@@ -545,6 +553,45 @@ impl Cluster {
                     }
                 }
             }
+            ScenarioStep::AddNode { config } => match config {
+                NodeTestingConfig::Rust(config) => {
+                    self.add_rust_node(config);
+                    true
+                }
+                NodeTestingConfig::Ocaml(config) => {
+                    // before starting ocaml node, read and save secret
+                    // keys from daemon.json.
+                    let mut json_owned = None;
+                    let json = match &config.daemon_json {
+                        DaemonJson::Custom(path) => {
+                            let bytes = tokio::fs::read(path).await.map_err(|err| {
+                                anyhow::anyhow!(
+                                    "error reading daemon.json from path({path}): {err}"
+                                )
+                            })?;
+                            let json = serde_json::from_slice(&bytes).map_err(|err| {
+                                anyhow::anyhow!(
+                                    "failed to parse damon.json from path({path}): {err}"
+                                )
+                            })?;
+                            json_owned.insert(json)
+                        }
+                        DaemonJson::InMem(json) => json,
+                    };
+                    let accounts = json["ledger"]["accounts"].as_array().ok_or_else(|| {
+                        anyhow::anyhow!("daemon.json `.ledger.accounts` is not array")
+                    })?;
+
+                    accounts
+                        .iter()
+                        .filter_map(|account| account["sk"].as_str())
+                        .filter_map(|sk| sk.parse().ok())
+                        .for_each(|sk| self.add_account_sec_key(sk));
+
+                    self.add_ocaml_node(config);
+                    true
+                }
+            },
             ScenarioStep::ConnectNodes { dialer, listener } => {
                 let listener_addr = match listener {
                     ListenerNode::Rust(listener) => {

node/testing/src/node/config.rs

@@ -5,7 +5,7 @@ pub use super::ocaml::{
 };
 pub use super::rust::{RustNodeBlockProducerTestingConfig, RustNodeTestingConfig, TestPeerId};
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, derive_more::From, Debug, Clone)]
 #[serde(tag = "kind")]
 pub enum NodeTestingConfig {
     Rust(RustNodeTestingConfig),

node/testing/src/node/ocaml/config.rs

@@ -211,6 +211,7 @@ impl DaemonJson {
             let sec_key = AccountSecretKey::rand();
             let pub_key = sec_key.public_key();
             let account = serde_json::json!({
+                "sk": sec_key.to_string(),
                 "pk": pub_key.to_string(),
                 "balance": format!("{balance}.000000000"),
                 "delegate": pub_key.to_string(),

node/testing/src/scenario/step.rs

@@ -2,7 +2,7 @@ use node::{event_source::Event, p2p::connection::outgoing::P2pConnectionOutgoing
 use serde::{Deserialize, Serialize};
 
 use crate::cluster::{ClusterNodeId, ClusterOcamlNodeId};
-use crate::node::OcamlStep;
+use crate::node::{NodeTestingConfig, OcamlStep};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(tag = "kind")]
@@ -19,6 +19,10 @@ pub enum ScenarioStep {
         node_id: ClusterNodeId,
         event: String,
     },
+    /// Create a new node, start it and add it to the cluster.
+    AddNode {
+        config: NodeTestingConfig,
+    },
     ConnectNodes {
         dialer: ClusterNodeId,
         listener: ListenerNode,

node/testing/src/scenarios/cluster_runner.rs

@@ -14,8 +14,8 @@ use crate::{
     cluster::{Cluster, ClusterNodeId, ClusterOcamlNodeId},
     network_debugger::Debugger,
     node::{
-        DaemonJson, DaemonJsonGenConfig, Node, OcamlNode, OcamlNodeTestingConfig,
-        RustNodeTestingConfig,
+        DaemonJson, DaemonJsonGenConfig, Node, NodeTestingConfig, OcamlNode,
+        OcamlNodeTestingConfig, RustNodeTestingConfig,
     },
     scenario::ScenarioStep,
     service::{DynEffects, NodeTestingService, PendingEventId},
@@ -67,6 +67,10 @@ impl<'a> ClusterRunner<'a> {
         self.cluster.nodes_iter()
     }
 
+    pub fn ocaml_nodes_iter(&self) -> impl Iterator<Item = (ClusterOcamlNodeId, &OcamlNode)> {
+        self.cluster.ocaml_nodes_iter()
+    }
+
     pub fn daemon_json_gen(
         &mut self,
         genesis_timestamp: &str,
@@ -98,11 +102,33 @@ impl<'a> ClusterRunner<'a> {
     }
 
     pub fn add_rust_node(&mut self, testing_config: RustNodeTestingConfig) -> ClusterNodeId {
-        self.cluster.add_rust_node(testing_config)
+        let step = ScenarioStep::AddNode {
+            config: testing_config.into(),
+        };
+        (self.add_step)(&step);
+        let ScenarioStep::AddNode {
+            config: NodeTestingConfig::Rust(config),
+        } = step
+        else {
+            unreachable!()
+        };
+
+        self.cluster.add_rust_node(config)
     }
 
     pub fn add_ocaml_node(&mut self, testing_config: OcamlNodeTestingConfig) -> ClusterOcamlNodeId {
-        self.cluster.add_ocaml_node(testing_config)
+        let step = ScenarioStep::AddNode {
+            config: testing_config.into(),
+        };
+        (self.add_step)(&step);
+        let ScenarioStep::AddNode {
+            config: NodeTestingConfig::Ocaml(config),
+        } = step
+        else {
+            unreachable!()
+        };
+
+        self.cluster.add_ocaml_node(config)
     }
 
     pub async fn exec_step(&mut self, step: ScenarioStep) -> anyhow::Result<bool> {