test: delete StopSignal, call handle.stop() directly

StopSignal was a test-only actor message that only worked via the
production-specific TokioRuntimeHandle::stop() it used under the hood.
The `peer_recover` test is the sole caller; it already has the
`TokioRuntimeHandle` from PeerManagerActor::spawn(), so it can call
.stop() directly and skip the message round-trip.

Production shutdown flows through actor_system.stop() and is
unaffected. The unused `should_panic: true` variant goes too — it was
never called outside its own constructor.

Author: shreyan-gupta

chain/network/src/test_utils.rs

@@ -111,30 +111,6 @@ impl Handler<GetInfo, crate::types::NetworkInfo> for PeerManagerActor {
     }
 }
 
-// `StopSignal is used to stop PeerManagerActor for unit tests
-#[derive(Default, Debug)]
-pub struct StopSignal {
-    pub should_panic: bool,
-}
-
-impl StopSignal {
-    pub fn should_panic() -> Self {
-        Self { should_panic: true }
-    }
-}
-
-impl Handler<StopSignal> for PeerManagerActor {
-    fn handle(&mut self, msg: StopSignal) {
-        tracing::debug!(target: "network", "received stop signal");
-
-        if msg.should_panic {
-            panic!("Node crashed");
-        } else {
-            self.transport.shutdown();
-        }
-    }
-}
-
 // Mocked `PeerManager` adapter, has a queue of `PeerManagerMessageRequest` messages.
 #[derive(Default)]
 pub struct MockPeerManagerAdapter {

integration-tests/src/tests/network/peer_handshake.rs

@@ -1,11 +1,11 @@
 use crate::tests::network::runner::*;
-use near_async::messaging::{CanSend, CanSendAsync};
+use near_async::messaging::CanSendAsync;
 use near_async::tokio::TokioRuntimeHandle;
 use near_async::{ActorSystem, time};
 use near_network::PeerManagerActor;
 use near_network::config;
 use near_network::tcp;
-use near_network::test_utils::{GetInfo, StopSignal, convert_boot_nodes, wait_or_timeout};
+use near_network::test_utils::{GetInfo, convert_boot_nodes, wait_or_timeout};
 use near_o11y::testonly::init_test_logger;
 use near_primitives::genesis::GenesisId;
 use parking_lot::Mutex;
@@ -152,8 +152,11 @@ async fn peer_recover() {
                 // Wait a small timeout for connection to be active.
                 state.store(1, Ordering::Relaxed);
             } else if state.load(Ordering::Relaxed) == 1 {
-                // Stop node2.
-                let _ = pm2.lock().send(StopSignal::default());
+                // Stop node2 by cancelling its tokio runtime. This triggers
+                // `stop_actor` on drop (broadcasts Disconnect, shuts down
+                // transport) and cancels all spawned tasks (PeerActors,
+                // background loops), closing the TCP connections to peers.
+                pm2.lock().stop();
                 state.store(2, Ordering::Relaxed);
             } else if state.load(Ordering::Relaxed) == 2 {
                 // Wait until node0 removes node2 from active validators.