add local client utilities to RenetServer for testing

renet2/src/server.rs

@@ -278,4 +278,39 @@ impl RenetServer {
             None => Err(ClientNotFound),
         }
     }
+
+    /// Creates a local [RenetClient], use this for testing.
+    /// Use [`Self::process_local_client`] to update the local connection.
+    pub fn new_local_client(&mut self, client_id: ClientId) -> RenetClient {
+        let mut client = RenetClient::new_from_server(self.connection_config.clone(), false);
+        client.set_connected();
+        self.add_connection(client_id, false);
+        client
+    }
+
+    /// Disconnects a local [RenetClient] that was created with [`Self::new_local_client`].
+    pub fn disconnect_local_client(&mut self, client_id: ClientId, client: &mut RenetClient) {
+        if client.is_disconnected() {
+            return;
+        }
+        client.disconnect();
+        if self.connections.remove(&client_id).is_some() {
+            self.events.push_back(ServerEvent::ClientDisconnected {
+                client_id,
+                reason: DisconnectReason::DisconnectedByClient,
+            });
+        }
+    }
+
+    /// Given a local [RenetClient], receive and send packets to/from it.
+    /// Use this to update local client created from [`Self::new_local_client`].
+    pub fn process_local_client(&mut self, client_id: ClientId, client: &mut RenetClient) -> Result<(), ClientNotFound> {
+        for packet in self.get_packets_to_send(client_id)? {
+            client.process_packet(&packet);
+        }
+        for packet in client.get_packets_to_send() {
+            self.process_packet_from(&packet, client_id)?
+        }
+        Ok(())
+    }
 }

renet2/tests/lib.rs

@@ -68,3 +68,35 @@ fn test_remote_connection_reliable_channel() {
         server.get_event().unwrap()
     );
 }
+
+#[test]
+fn test_local_client() {
+    init_log();
+
+    let mut server = RenetServer::new(ConnectionConfig::test());
+    let client_id = 0;
+    let mut client = server.new_local_client(client_id);
+
+    let connect_event = server.get_event().unwrap();
+    assert!(connect_event == ServerEvent::ClientConnected { client_id });
+
+    server.send_message(client_id, DefaultChannel::ReliableOrdered, Bytes::from("test server"));
+    client.send_message(DefaultChannel::ReliableOrdered, Bytes::from("test client"));
+    server.process_local_client(client_id, &mut client).unwrap();
+
+    let server_message = server.receive_message(client_id, DefaultChannel::ReliableOrdered).unwrap();
+    assert_eq!(server_message, "test client");
+    let client_message = client.receive_message(DefaultChannel::ReliableOrdered).unwrap();
+    assert_eq!(client_message, "test server");
+
+    server.disconnect_local_client(client_id, &mut client);
+    assert!(client.is_disconnected());
+    let disconnect_event = server.get_event().unwrap();
+    assert!(
+        disconnect_event
+            == ServerEvent::ClientDisconnected {
+                client_id,
+                reason: DisconnectReason::DisconnectedByClient
+            }
+    );
+}