test(p2p): update testing doc

Author: akoptelov

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

@@ -357,70 +357,6 @@ impl ConnectToInitialPeers {
     }
 }
 
-/// Node should repeat connecting to unavailable initial peer.
-#[derive(documented::Documented, Default, Clone, Copy)]
-pub struct ConnectToUnavailableInitialPeers;
-
-impl ConnectToUnavailableInitialPeers {
-    pub async fn run<'cluster>(self, runner: ClusterRunner<'cluster>) {
-        const MAX: u16 = 2;
-        const RETRIES: u8 = 3;
-
-        let mut driver = Driver::new(runner);
-
-        let (initial_peers, peer_ids): (Vec<_>, Vec<_>) = (0..MAX)
-            .into_iter()
-            .map(|i| {
-                let port: u16 = 11200 + i;
-                let peer_id = SecretKey::rand().public_key().peer_id();
-                let addr = format!(
-                    "/ip4/127.0.0.1/tcp/{port}/p2p/{peer_id}",
-                    peer_id = peer_id.clone().to_libp2p_string()
-                )
-                .parse()
-                .unwrap();
-                (addr, peer_id)
-            })
-            .unzip();
-
-        let (node_ut, _) = driver
-            .add_rust_node(RustNodeTestingConfig::berkeley_default().initial_peers(initial_peers));
-
-        let mut peer_retries =
-            BTreeMap::from_iter(peer_ids.into_iter().map(|peer_id| (peer_id, 0_u8)));
-
-        // matches event "the node established connection with peer"
-        let pred = |node_id, event: &_, _state: &_| {
-            if node_id != node_ut {
-                false
-            } else if let Some((peer_id, res)) = as_connection_finalized_event(event) {
-                assert!(res.is_err(), "connection to {peer_id} should succeed");
-                let retries = peer_retries.get_mut(&peer_id).unwrap();
-                *retries += 1;
-                if *retries >= RETRIES {
-                    peer_retries.remove(&peer_id);
-                }
-                peer_retries.is_empty()
-            } else {
-                false
-            }
-        };
-
-        let satisfied = driver
-            .run_until(Duration::from_secs(1 * 60), pred)
-            .await
-            .unwrap();
-
-        println!("{:#?}", driver.inner().node(node_ut).unwrap().state().p2p);
-
-        assert!(
-            satisfied,
-            "did not reach retry limit for peers: {:?}",
-            peer_retries
-        );
-    }
-}
-
 /// Node should be able to connect to all initial peers after they become ready.
 #[derive(documented::Documented, Default, Clone, Copy)]
 pub struct ConnectToInitialPeersBecomeReady;
@@ -488,3 +424,67 @@ impl ConnectToInitialPeersBecomeReady {
         assert!(satisfied, "did not connect to peers: {:?}", peer_ids);
     }
 }
+
+/// Node should repeat connecting to unavailable initial peer.
+#[derive(documented::Documented, Default, Clone, Copy)]
+pub struct ConnectToUnavailableInitialPeers;
+
+impl ConnectToUnavailableInitialPeers {
+    pub async fn run<'cluster>(self, runner: ClusterRunner<'cluster>) {
+        const MAX: u16 = 2;
+        const RETRIES: u8 = 3;
+
+        let mut driver = Driver::new(runner);
+
+        let (initial_peers, peer_ids): (Vec<_>, Vec<_>) = (0..MAX)
+            .into_iter()
+            .map(|i| {
+                let port: u16 = 11200 + i;
+                let peer_id = SecretKey::rand().public_key().peer_id();
+                let addr = format!(
+                    "/ip4/127.0.0.1/tcp/{port}/p2p/{peer_id}",
+                    peer_id = peer_id.clone().to_libp2p_string()
+                )
+                .parse()
+                .unwrap();
+                (addr, peer_id)
+            })
+            .unzip();
+
+        let (node_ut, _) = driver
+            .add_rust_node(RustNodeTestingConfig::berkeley_default().initial_peers(initial_peers));
+
+        let mut peer_retries =
+            BTreeMap::from_iter(peer_ids.into_iter().map(|peer_id| (peer_id, 0_u8)));
+
+        // matches event "the node established connection with peer"
+        let pred = |node_id, event: &_, _state: &_| {
+            if node_id != node_ut {
+                false
+            } else if let Some((peer_id, res)) = as_connection_finalized_event(event) {
+                assert!(res.is_err(), "connection to {peer_id} should succeed");
+                let retries = peer_retries.get_mut(&peer_id).unwrap();
+                *retries += 1;
+                if *retries >= RETRIES {
+                    peer_retries.remove(&peer_id);
+                }
+                peer_retries.is_empty()
+            } else {
+                false
+            }
+        };
+
+        let satisfied = driver
+            .run_until(Duration::from_secs(1 * 60), pred)
+            .await
+            .unwrap();
+
+        println!("{:#?}", driver.inner().node(node_ut).unwrap().state().p2p);
+
+        assert!(
+            satisfied,
+            "did not reach retry limit for peers: {:?}",
+            peer_retries
+        );
+    }
+}

p2p/testing.md

@@ -7,7 +7,11 @@
 If two nodes are connecting to each other at the same time, they should be
 connected, so each one has exactly one connection.
 
-- - [`p2p_basic_connections(simultaneous_connections)`](../node/testing/src/scenarios/p2p/basic_connection_handling.rs#L25)
+- [`p2p_basic_connections(simultaneous_connections)`](../node/testing/src/scenarios/p2p/basic_connection_handling.rs#L25)
+
+### Two Rust nodes shouldn't be disconnected for a while after they are connected
+
+- [`p2p_basic_connections(connection_stbility)`](../node/testing/src/scenarios/p2p/basic_connection_handling.rs#L342)
 
 
 ### All connections should be tracked by the state machine
@@ -22,7 +26,7 @@ should be present in the state machine.
 ### Number of active peers should not exceed configured maximum number
 
 **Tests:**
-- [`p2p_basic_connections(max_number_of_peers)`](../node/testing/src/scenarios/p2p/basic_connection_handling.rs#L242)
+- [`p2p_basic_connections(max_number_of_peers)`](../node/testing/src/scenarios/p2p/basic_connection_handling.rs#L248)
 
 
 ## Incoming Connections
@@ -78,6 +82,10 @@ TODO: what if the number of initial peers exceeds the max number of peers?
 - [`p2p_basic_outgoing(connect_to_all_initial_peers)`](../node/testing/src/scenarios/p2p/basic_outgoing_connections.rs#L293)
 - [multi_node_initial_joining](../node/testing/src/scenarios/multi_node/basic_connectivity_initial_joining.rs) (partially?)
 
+### Node should retry connecting to unavailable initial peers
+
+- [`p2p_basic_outgoing(connect_to_unavailableinitial_peers)`](../node/testing/src/scenarios/p2p/basic_outgoing_connections.rs#L433)
+
 ### Node should be able to connect to initial peers eventually, even if initially they are not available.
 
 If, for some reason, the node can't connect to enough peers (e.g. it is the first