test(p2p): tests for connections with the same id

akoptelov · akoptelov · commit 3899c15d36bc · 2023-12-22T17:35:42.000+03:00
diff --git a/node/testing/src/cluster/mod.rs b/node/testing/src/cluster/mod.rs
@@ -34,6 +34,7 @@ use openmina_node_native::{http_server, rpc::RpcService, NodeService, RpcSender}
 use rand::{rngs::StdRng, SeedableRng};
 use serde::Serialize;
 
+use crate::node::TestPeerId;
 use crate::{
     network_debugger::Debugger,
     node::{Node, NodeTestingConfig, RustNodeTestingConfig},
@@ -112,16 +113,18 @@ impl Cluster {
     pub fn add_rust_node(&mut self, testing_config: RustNodeTestingConfig) -> ClusterNodeId {
         let node_i = self.nodes.len();
         let (shutdown_tx, shutdown_rx) = mpsc::channel(1);
-        let secret_key = if testing_config.randomize_peer_id {
-            P2pSecretKey::from_bytes(rand::random())
-        } else {
-            let mut bytes = [0; 32];
-            let bytes_len = bytes.len();
-            let i_bytes = node_i.to_be_bytes();
-            let i = bytes_len - i_bytes.len();
-            bytes[i..bytes_len].copy_from_slice(&i_bytes);
-            P2pSecretKey::from_bytes(bytes)
-        };
+        let secret_key = P2pSecretKey::from_bytes(match testing_config.peer_id {
+            TestPeerId::Derived => {
+                let mut bytes = [0; 32];
+                let bytes_len = bytes.len();
+                let i_bytes = node_i.to_be_bytes();
+                let i = bytes_len - i_bytes.len();
+                bytes[i..bytes_len].copy_from_slice(&i_bytes);
+                bytes
+            }
+            TestPeerId::Random => rand::random(),
+            TestPeerId::Bytes(bytes) => bytes,
+        });
         let pub_key = secret_key.public_key();
 
         let http_port = self
diff --git a/node/testing/src/node/config.rs b/node/testing/src/node/config.rs
@@ -1,6 +1,6 @@
 use std::time::Duration;
 
-use node::p2p::connection::outgoing::P2pConnectionOutgoingInitOpts;
+use node::p2p::{connection::outgoing::P2pConnectionOutgoingInitOpts};
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -9,6 +9,14 @@ pub enum NodeTestingConfig {
     Rust(RustNodeTestingConfig),
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone, Default)]
+pub enum TestPeerId {
+    #[default]
+    Derived,
+    Random,
+    Bytes([u8; 32]),
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct RustNodeTestingConfig {
     pub chain_id: String,
@@ -17,7 +25,7 @@ pub struct RustNodeTestingConfig {
     pub ask_initial_peers_interval: Duration,
     pub initial_peers: Vec<P2pConnectionOutgoingInitOpts>,
     pub libp2p_port: Option<u16>,
-    pub randomize_peer_id: bool,
+    pub peer_id: TestPeerId,
 }
 
 impl RustNodeTestingConfig {
@@ -29,7 +37,7 @@ impl RustNodeTestingConfig {
             ask_initial_peers_interval: Duration::from_secs(10),
             initial_peers: vec![],
             libp2p_port: None,
-            randomize_peer_id: false,
+            peer_id: TestPeerId::default(),
         }
     }
 
@@ -58,8 +66,13 @@ impl RustNodeTestingConfig {
         self
     }
 
-    pub fn randomize_peer_id(mut self) -> Self {
-        self.randomize_peer_id = true;
+    pub fn with_random_peer_id(mut self) -> Self {
+        self.peer_id = TestPeerId::Random;
+        self
+    }
+
+    pub fn with_peer_id(mut self, bytes: [u8; 32]) -> Self {
+        self.peer_id = TestPeerId::Bytes(bytes);
         self
     }
 }
diff --git a/node/testing/src/node/mod.rs b/node/testing/src/node/mod.rs
@@ -1,5 +1,5 @@
 mod config;
-pub use config::{NodeTestingConfig, RustNodeTestingConfig};
+pub use config::{NodeTestingConfig, RustNodeTestingConfig, TestPeerId};
 
 use node::event_source::{Event, EventSourceNewEventAction};
 use node::p2p::PeerId;
diff --git a/node/testing/src/scenarios/driver.rs b/node/testing/src/scenarios/driver.rs
@@ -64,6 +64,17 @@ pub fn connection_finalized_event(
     }
 }
 
+pub fn connection_finalized_with_res_event(
+    pred: impl Fn(ClusterNodeId, &PeerId, &Result<(), String>) -> bool,
+) -> impl Fn(ClusterNodeId, &Event, &State) -> bool {
+    move |node_id, event, _| {
+        matches!(
+            event,
+            Event::P2p(P2pEvent::Connection(P2pConnectionEvent::Finalized(peer, res))) if pred(node_id, peer, res)
+        )
+    }
+}
+
 pub fn as_listen_new_addr_event(event: &Event) -> Option<(&Multiaddr, &P2pListenerId)> {
     if let Event::P2p(P2pEvent::Listen(P2pListenEvent::NewListenAddr { listener_id, addr })) = event
     {
@@ -282,6 +293,7 @@ pub async fn wait_for_nodes_listening_on_localhost<'cluster>(
     driver.run_until(duration, pred).await
 }
 
+
 /// Creates `num` Rust nodes in the cluster
 pub fn add_rust_nodes<'cluster, N, NodeIds, PeerIds>(
     driver: &mut Driver,
diff --git a/node/testing/src/scenarios/p2p/basic_incoming_connections.rs b/node/testing/src/scenarios/p2p/basic_incoming_connections.rs
@@ -1,10 +1,11 @@
-use std::{time::Duration, collections::BTreeSet};
+use std::{collections::BTreeSet, time::Duration};
 
 use crate::{
     node::RustNodeTestingConfig,
     scenarios::{
-        add_rust_nodes, connection_finalized_event, wait_for_nodes_listening_on_localhost,
-        ClusterRunner, Driver, as_connection_finalized_event,
+        add_rust_nodes, as_connection_finalized_event, connection_finalized_event,
+        connection_finalized_with_res_event, wait_for_nodes_listening_on_localhost, ClusterRunner,
+        Driver,
     },
 };
 
@@ -64,8 +65,7 @@ impl AcceptMultipleIncomingConnections {
 
         let mut driver = Driver::new(runner);
 
-        let (node_ut, _) =
-            driver.add_rust_node(RustNodeTestingConfig::berkeley_default());
+        let (node_ut, _) = driver.add_rust_node(RustNodeTestingConfig::berkeley_default());
         assert!(
             wait_for_nodes_listening_on_localhost(&mut driver, Duration::from_secs(30), [node_ut])
                 .await
@@ -104,6 +104,59 @@ impl AcceptMultipleIncomingConnections {
             .run_until(Duration::from_secs(3 * 60), pred)
             .await
             .unwrap();
-        assert!(satisfied, "did not accept connection from peers: {:?}", peer_ids);
+        assert!(
+            satisfied,
+            "did not accept connection from peers: {:?}",
+            peer_ids
+        );
+    }
+}
+
+/// Node should not accept connection from itself.
+#[derive(documented::Documented, Default, Clone, Copy)]
+pub struct DoesNotAcceptConnectionFromSelf;
+
+impl DoesNotAcceptConnectionFromSelf {
+    pub async fn run<'cluster>(self, runner: ClusterRunner<'cluster>) {
+        let mut driver = Driver::new(runner);
+        let (node_ut, node_ut_peer_id) =
+            driver.add_rust_node(RustNodeTestingConfig::berkeley_default());
+
+        assert!(
+            wait_for_nodes_listening_on_localhost(&mut driver, Duration::from_secs(60), [node_ut])
+                .await
+                .unwrap(),
+            "node should be listening"
+        );
+
+        driver
+            .exec_step(crate::scenario::ScenarioStep::ConnectNodes {
+                dialer: node_ut,
+                listener: crate::scenario::ListenerNode::Rust(node_ut),
+            })
+            .await
+            .expect("connect event should be dispatched"); // should it?
+
+        // wait for node under test receives connection event
+        let connected = driver
+            .wait_for(
+                Duration::from_secs(10),
+                connection_finalized_with_res_event(|node_id, peer, res| {
+                    node_id == node_ut && peer == &node_ut_peer_id && res.is_err()
+                }),
+            )
+            .await
+            .unwrap()
+            .expect("connected event");
+
+        let state = driver
+            .exec_even_step(connected)
+            .await
+            .unwrap()
+            .expect("connected event sholuld be executed");
+        assert!(
+            state.p2p.get_ready_peer(&node_ut_peer_id).is_none(),
+            "self-peer should not be ready"
+        );
     }
 }
diff --git a/node/testing/src/scenarios/p2p/basic_outgoing_connections.rs b/node/testing/src/scenarios/p2p/basic_outgoing_connections.rs
@@ -1,13 +1,13 @@
 use std::{collections::BTreeSet, time::Duration};
 
-use node::p2p::{P2pPeerState, P2pPeerStatus, PeerId};
+use node::p2p::{identity::SecretKey, P2pPeerState, P2pPeerStatus, PeerId};
 
 use crate::{
     cluster::ClusterNodeId,
     node::RustNodeTestingConfig,
     scenarios::{
         add_rust_nodes, as_connection_finalized_event, connection_finalized_event,
-        wait_for_nodes_listening_on_localhost, ClusterRunner, Driver,
+        wait_for_nodes_listening_on_localhost, ClusterRunner, Driver, connection_finalized_with_res_event,
     },
 };
 
@@ -125,3 +125,147 @@ impl MakeMultipleOutgoingConnections {
         assert!(satisfied, "did not connect to peers: {:?}", peer_ids);
     }
 }
+
+/// Node shouldn't establish connection with a node with the same peer_id.
+#[derive(documented::Documented, Default, Clone, Copy)]
+pub struct DontConnectToNodeWithSameId;
+
+impl DontConnectToNodeWithSameId {
+    pub async fn run<'cluster>(self, runner: ClusterRunner<'cluster>) {
+        let mut driver = Driver::new(runner);
+
+        let port = 11108;
+        let node_ut_port = 11109;
+        let bytes: [u8; 32] = rand::random();
+
+        // start a node with the same peer_id on different port
+        let (node, _) = driver.add_rust_node(
+            RustNodeTestingConfig::berkeley_default()
+                .libp2p_port(port)
+                .with_peer_id(bytes)
+        );
+        // wait for it to be ready
+        assert!(
+            wait_for_nodes_listening_on_localhost(&mut driver, Duration::from_secs(30), [node])
+                .await
+                .unwrap(),
+            "node should be listening"
+        );
+
+        // start node under test with the other node as its initial peer
+        let (node_ut, _) = driver.add_rust_node(
+            RustNodeTestingConfig::berkeley_default()
+                .libp2p_port(node_ut_port)
+                .with_peer_id(bytes)
+        );
+
+        driver
+            .exec_step(crate::scenario::ScenarioStep::ConnectNodes {
+                dialer: node_ut,
+                listener: crate::scenario::ListenerNode::Rust(node),
+            })
+            .await
+            .expect("connect event should be dispatched");
+
+        let connected = driver
+            .wait_for(
+                Duration::from_secs(60),
+                connection_finalized_event(|node_id, _peer| node_id == node_ut),
+            )
+            .await
+            .unwrap();
+
+        assert!(connected.is_none(), "the node sholdn't try to connect to itself");
+    }
+}
+
+/// Node shouldn't connect to itself even if its address specified in initial peers.
+#[derive(documented::Documented, Default, Clone, Copy)]
+pub struct DontConnectToSelfInitialPeer;
+
+impl DontConnectToSelfInitialPeer {
+    pub async fn run<'cluster>(self, runner: ClusterRunner<'cluster>) {
+        let mut driver = Driver::new(runner);
+
+        let port = 11109;
+        let bytes: [u8; 32] = rand::random();
+        let peer_id = SecretKey::from_bytes(bytes.clone()).public_key().peer_id().to_libp2p_string();
+        let self_maddr = format!("/ip4/127.0.0.1/tcp/{port}/p2p/{peer_id}")
+            .parse()
+            .unwrap();
+        let (node_ut, _) = driver.add_rust_node(
+            RustNodeTestingConfig::berkeley_default()
+                .libp2p_port(port)
+                .with_peer_id(bytes)
+                .initial_peers(vec![self_maddr]),
+        );
+        assert!(
+            wait_for_nodes_listening_on_localhost(&mut driver, Duration::from_secs(30), [node_ut])
+                .await
+                .unwrap(),
+            "node should be listening"
+        );
+
+        let connected = driver
+            .wait_for(
+                Duration::from_secs(60),
+                connection_finalized_with_res_event(|node_id, _peer, _res| node_id == node_ut),
+            )
+            .await
+            .unwrap();
+
+        assert!(connected.is_none(), "the node sholdn't try to connect to itself");
+    }
+}
+
+/// Node shouldn't connect to a node with the same peer id even if its address specified in initial peers.
+#[derive(documented::Documented, Default, Clone, Copy)]
+pub struct DontConnectToInitialPeerWithSameId;
+
+impl DontConnectToInitialPeerWithSameId {
+    pub async fn run<'cluster>(self, runner: ClusterRunner<'cluster>) {
+        let mut driver = Driver::new(runner);
+
+        let port = 11108;
+        let node_ut_port = 11109;
+        let bytes: [u8; 32] = rand::random();
+        let peer_id = SecretKey::from_bytes(bytes.clone()).public_key().peer_id().to_libp2p_string();
+
+
+        let self_maddr = format!("/ip4/127.0.0.1/tcp/{port}/p2p/{peer_id}")
+            .parse()
+            .unwrap();
+
+        // start a node with the same peer_id on different port
+        let (node, _) = driver.add_rust_node(
+            RustNodeTestingConfig::berkeley_default()
+                .libp2p_port(port)
+                .with_peer_id(bytes)
+        );
+        // wait for it to be ready
+        assert!(
+            wait_for_nodes_listening_on_localhost(&mut driver, Duration::from_secs(30), [node])
+                .await
+                .unwrap(),
+            "node should be listening"
+        );
+
+        // start node under test with the other node as its initial peer
+        let (node_ut, _) = driver.add_rust_node(
+            RustNodeTestingConfig::berkeley_default()
+                .libp2p_port(node_ut_port)
+                .with_peer_id(bytes)
+                .initial_peers(vec![self_maddr]),
+        );
+
+        let connected = driver
+            .wait_for(
+                Duration::from_secs(60),
+                connection_finalized_with_res_event(|node_id, _peer, _res| node_id == node_ut),
+            )
+            .await
+            .unwrap();
+
+        assert!(connected.is_none(), "the node sholdn't try to connect to itself");
+    }
+}
diff --git a/node/testing/src/scenarios/solo_node/basic_connectivity_accept_incoming.rs b/node/testing/src/scenarios/solo_node/basic_connectivity_accept_incoming.rs
@@ -46,7 +46,7 @@ impl SoloNodeBasicConnectivityAcceptIncoming {
             .ask_initial_peers_interval(Duration::from_secs(3600))
             .max_peers(MAX_PEERS_PER_NODE)
             .initial_peers(initial_peers)
-            .randomize_peer_id();
+            .with_random_peer_id();
 
         let node_id = runner.add_rust_node(config);
 
diff --git a/node/testing/tests/p2p_basic_incoming.rs b/node/testing/tests/p2p_basic_incoming.rs
diff --git a/node/testing/tests/p2p_basic_outgoing.rs b/node/testing/tests/p2p_basic_outgoing.rs
diff --git a/p2p/testing.md b/p2p/testing.md

Original file line number	Diff line number	Diff line change
`@@ -64,6 +64,17 @@ pub fn connection_finalized_event(`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`
	`67`	`+pub fn connection_finalized_with_res_event(`
	`68`	`+ pred: impl Fn(ClusterNodeId, &PeerId, &Result<(), String>) -> bool,`
	`69`	`+) -> impl Fn(ClusterNodeId, &Event, &State) -> bool {`
	`70`	`+ move \|node_id, event, _\| {`
	`71`	`+ matches!(`
	`72`	`+ event,`
	`73`	`+ Event::P2p(P2pEvent::Connection(P2pConnectionEvent::Finalized(peer, res))) if pred(node_id, peer, res)`
	`74`	`+ )`
	`75`	`+ }`
	`76`	`+}`
	`77`	`+`
`67`	`78`	`pub fn as_listen_new_addr_event(event: &Event) -> Option<(&Multiaddr, &P2pListenerId)> {`
`68`	`79`	`if let Event::P2p(P2pEvent::Listen(P2pListenEvent::NewListenAddr { listener_id, addr })) = event`
`69`	`80`	`{`
`@@ -282,6 +293,7 @@ pub async fn wait_for_nodes_listening_on_localhost<'cluster>(`
`282`	`293`	`driver.run_until(duration, pred).await`
`283`	`294`	`}`
`284`	`295`
	`296`	`+`
`285`	`297`	/// Creates `num` Rust nodes in the cluster
`286`	`298`	`pub fn add_rust_nodes<'cluster, N, NodeIds, PeerIds>(`
`287`	`299`	`driver: &mut Driver,`