test(p2p/webrtc): signaling discovery and exchange

re: #772

Author: binier

.github/workflows/ci.yaml

@@ -284,7 +284,7 @@ jobs:
     needs:
       - k8s-peers
       - build-tests
-    #  - build-tests-webrtc
+      - build-tests-webrtc
     runs-on: ubuntu-20.04
     container:
       image: minaprotocol/mina-daemon:3.0.0-dc6bf78-focal-devnet
@@ -309,6 +309,7 @@ jobs:
           - connection_discovery_rust_as_seed
           - connection_discovery_rust_to_ocaml_via_seed
           - connection_discovery_rust_to_ocaml
+          - webrtc_p2p_signaling
           # - webrtc_single_node
           # - webrtc_multi_node
       fail-fast: false
@@ -331,6 +332,12 @@ jobs:
         with:
           pattern: tests*
           merge-multiple: true
+      
+      - name: Download tests
+        uses: actions/download-artifact@v4
+        with:
+          pattern: tests-webrtc*
+          merge-multiple: true
 
       - name: Setup permissions
         run: |

node/testing/src/scenarios/mod.rs

@@ -18,6 +18,7 @@ pub mod p2p;
 
 mod driver;
 pub use driver::*;
+use p2p::signaling::P2pSignaling;
 
 pub use crate::cluster::runner::*;
 
@@ -66,6 +67,7 @@ pub enum Scenarios {
     SimulationSmall(SimulationSmall),
     SimulationSmallForeverRealTime(SimulationSmallForeverRealTime),
     P2pReceiveBlock(P2pReceiveBlock),
+    P2pSignaling(P2pSignaling),
     MultiNodePubsubPropagateBlock(MultiNodePubsubPropagateBlock),
     RecordReplayBootstrap(RecordReplayBootstrap),
     RecordReplayBlockProduction(RecordReplayBlockProduction),
@@ -90,6 +92,7 @@ impl Scenarios {
             Self::SimulationSmall(_) => true,
             Self::SimulationSmallForeverRealTime(_) => true,
             Self::MultiNodePubsubPropagateBlock(_) => true, // in progress
+            Self::P2pSignaling(_) => cfg!(feature = "p2p-webrtc"),
             _ => false,
         }
     }
@@ -148,6 +151,7 @@ impl Scenarios {
             Self::SimulationSmall(_) => SimulationSmall::DOCS,
             Self::SimulationSmallForeverRealTime(_) => SimulationSmallForeverRealTime::DOCS,
             Self::P2pReceiveBlock(_) => P2pReceiveBlock::DOCS,
+            Self::P2pSignaling(_) => P2pSignaling::DOCS,
             Self::MultiNodePubsubPropagateBlock(_) => MultiNodePubsubPropagateBlock::DOCS,
             Self::RecordReplayBootstrap(_) => RecordReplayBootstrap::DOCS,
             Self::RecordReplayBlockProduction(_) => RecordReplayBlockProduction::DOCS,
@@ -184,6 +188,7 @@ impl Scenarios {
             Self::SimulationSmall(v) => v.run(runner).await,
             Self::SimulationSmallForeverRealTime(v) => v.run(runner).await,
             Self::P2pReceiveBlock(v) => v.run(runner).await,
+            Self::P2pSignaling(v) => v.run(runner).await,
             Self::MultiNodePubsubPropagateBlock(v) => v.run(runner).await,
             Self::RecordReplayBootstrap(v) => v.run(runner).await,
             Self::RecordReplayBlockProduction(v) => v.run(runner).await,

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

@@ -3,3 +3,4 @@ pub mod basic_incoming_connections;
 pub mod basic_outgoing_connections;
 pub mod kademlia;
 pub mod pubsub;
+pub mod signaling;

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

@@ -0,0 +1,60 @@
+use std::{collections::BTreeSet, time::Duration};
+
+use node::{
+    p2p::{P2pPeerAction, PeerId},
+    Action, P2pAction,
+};
+
+use crate::{
+    node::RustNodeTestingConfig,
+    scenarios::{ClusterRunner, DynEffectsData, RunCfg},
+};
+
+/// Makes sure that when using WebRTC only nodes, peers can discover
+/// each other and connect to each other via p2p signaling.
+#[derive(documented::Documented, Default, Clone, Copy)]
+pub struct P2pSignaling;
+
+impl P2pSignaling {
+    pub async fn run(self, mut runner: ClusterRunner<'_>) {
+        const NODES_N: usize = 4;
+
+        let seed_config = RustNodeTestingConfig::devnet_default();
+        let seed = runner.add_rust_node(seed_config.clone());
+
+        let node_config = seed_config.initial_peers(vec![seed.into()]);
+        let _node_1 = runner.add_rust_node(node_config.clone());
+        let _node_2 = runner.add_rust_node(node_config.clone());
+        let _node_3 = runner.add_rust_node(node_config.clone());
+
+        let node_peers: [_; NODES_N] = std::array::from_fn(|_| BTreeSet::<PeerId>::new());
+        let node_peers = DynEffectsData::new(node_peers);
+
+        runner
+            .run(
+                RunCfg::default()
+                    .timeout(Duration::from_secs(60))
+                    .advance_time(1..=100)
+                    .action_handler(move |node_id, _state, _, action| {
+                        if action.action().kind().to_string().contains("Signaling") {
+                            let me = _state.p2p.my_id();
+                            let me_pk = me.to_public_key().unwrap();
+                            dbg!((me, me_pk, action.action()));
+                        }
+                        match action.action() {
+                            Action::P2p(P2pAction::Peer(P2pPeerAction::Ready {
+                                peer_id, ..
+                            })) => {
+                                node_peers.inner()[node_id.index()].insert(*peer_id);
+                                dbg!(node_peers.inner())
+                                    .iter()
+                                    .all(|v| v.len() == NODES_N - 1)
+                            }
+                            _ => false,
+                        }
+                    }),
+            )
+            .await
+            .expect("peers didn't discover each other");
+    }
+}

node/testing/tests/p2p_signaling.rs

@@ -0,0 +1,7 @@
+#![cfg(feature = "p2p-webrtc")]
+
+use openmina_node_testing::scenarios::p2p::signaling::P2pSignaling;
+
+mod common;
+
+scenario_test!(p2p_signaling, P2pSignaling, P2pSignaling, true);