test(socketio): fix tests

Totodore · May 6, 2024 · 93f67de · 93f67de
1 parent 69cad19
commit 93f67de
Show file tree

Hide file tree

Showing 3 changed files with 96 additions and 18 deletions.
diff --git a/socketioxide/src/ns.rs b/socketioxide/src/ns.rs
@@ -128,9 +128,11 @@ impl<A: Adapter> Namespace<A> {
     /// This function is using .await points only when called with [`DisconnectReason::ClosingServer`]
     pub async fn close(&self, reason: DisconnectReason) {
         use futures_util::future;
-        #[cfg(feature = "tracing")]
         let sockets = self.sockets.read().unwrap().clone();
+
+        #[cfg(feature = "tracing")]
         tracing::debug!(?self.path, "closing {} sockets in namespace", sockets.len());
+
         if reason == DisconnectReason::ClosingServer {
             // When closing the underlying transport, this will indirectly close the socket
             // Therefore there is no need to manually call `s.close()`.

diff --git a/socketioxide/tests/connect.rs b/socketioxide/tests/connect.rs
@@ -3,10 +3,7 @@ mod utils;
 use bytes::Bytes;
 use engineioxide::Packet::*;
 use socketioxide::{
-    extract::{SocketRef, State},
-    handler::ConnectHandler,
-    packet::Packet,
-    SendError, SocketError, SocketIo,
+    extract::SocketRef, handler::ConnectHandler, packet::Packet, SendError, SocketError, SocketIo,
 };
 use tokio::sync::mpsc;
 
@@ -115,36 +112,94 @@ pub async fn connect_middleware_error() {
 }
 
 #[tokio::test]
-async fn remove_ns() {
-    use tokio::sync::mpsc::Sender;
+async fn remove_ns_from_connect_handler() {
+    let (tx, mut rx) = tokio::sync::mpsc::channel::<()>(2);
+    let (_svc, io) = SocketIo::new_svc();
+
+    let io_clone = io.clone();
+    io.ns("/test1", move || {
+        tx.try_send(()).unwrap();
+        io_clone.delete_ns("/test1");
+    });
+
+    let (stx, mut srx) = io.new_dummy_sock("/test1", ()).await;
+    timeout_rcv(&mut srx).await;
+    assert_ok!(stx.try_send(create_msg("/test1", "delete_ns", ())));
+    timeout_rcv(&mut rx).await;
+    assert_ok!(stx.try_send(create_msg("/test1", "delete_ns", ())));
+    // No response since ns is already deleted
+    let elapsed = tokio::time::timeout(std::time::Duration::from_millis(200), rx.recv()).await;
+    assert!(elapsed.is_err() || elapsed.unwrap().is_none());
+}
 
+#[tokio::test]
+async fn remove_ns_from_middleware() {
     let (tx, mut rx) = tokio::sync::mpsc::channel::<()>(2);
+    let (_svc, io) = SocketIo::new_svc();
 
-    let (_svc, io) = SocketIo::builder().with_state(tx).build_svc();
+    let io_clone = io.clone();
+    let middleware = move || {
+        tx.try_send(()).unwrap();
+        io_clone.delete_ns("/test1");
+        Ok::<(), std::convert::Infallible>(())
+    };
+    fn handler() {}
+    io.ns("/test1", handler.with(middleware));
+
+    let (stx, mut srx) = io.new_dummy_sock("/test1", ()).await;
+    timeout_rcv(&mut srx).await;
+    assert_ok!(stx.try_send(create_msg("/test1", "delete_ns", ())));
+    timeout_rcv(&mut rx).await;
+    assert_ok!(stx.try_send(create_msg("/test1", "delete_ns", ())));
+    // No response since ns is already deleted
+    let elapsed = tokio::time::timeout(std::time::Duration::from_millis(200), rx.recv()).await;
+    assert!(elapsed.is_err() || elapsed.unwrap().is_none());
+}
+
+#[tokio::test]
+async fn remove_ns_from_event_handler() {
+    let (tx, mut rx) = tokio::sync::mpsc::channel::<()>(2);
+    let (_svc, io) = SocketIo::new_svc();
 
     let io_clone = io.clone();
-    let io_clone2 = io.clone();
     io.ns("/test1", move |s: SocketRef| {
-        s.on("delete_ns", move |State::<Sender<()>>(tx)| {
-            io_clone2.delete_ns("/test1");
+        s.on("delete_ns", move || {
+            io_clone.delete_ns("/test1");
             tx.try_send(()).unwrap();
         });
     });
-    io.ns("/test2", move |s: SocketRef| {
-        s.on_disconnect(move |State::<Sender<()>>(tx)| {
-            io_clone.delete_ns("/test2");
-            tx.try_send(()).unwrap();
-        })
-    });
+
     let (stx, mut srx) = io.new_dummy_sock("/test1", ()).await;
     timeout_rcv(&mut srx).await;
     assert_ok!(stx.try_send(create_msg("/test1", "delete_ns", ())));
     timeout_rcv(&mut rx).await;
     assert_ok!(stx.try_send(create_msg("/test1", "delete_ns", ())));
     // No response since ns is already deleted
+    let elapsed = tokio::time::timeout(std::time::Duration::from_millis(200), rx.recv()).await;
+    assert!(elapsed.is_err() || elapsed.unwrap().is_none());
+}
+
+#[tokio::test]
+async fn remove_ns_from_disconnect_handler() {
+    let (tx, mut rx) = tokio::sync::mpsc::channel::<&'static str>(2);
+    let (_svc, io) = SocketIo::new_svc();
+
+    let io_clone = io.clone();
+    io.ns("/test2", move |s: SocketRef| {
+        tx.try_send("connect").unwrap();
+        s.on_disconnect(move || {
+            io_clone.delete_ns("/test2");
+            tx.try_send("disconnect").unwrap();
+        })
+    });
 
     let (stx, mut srx) = io.new_dummy_sock("/test2", ()).await;
+    assert_eq!(timeout_rcv(&mut rx).await, "connect");
     timeout_rcv(&mut srx).await;
     assert_ok!(stx.try_send(Close));
-    timeout_rcv(&mut rx).await;
+    assert_eq!(timeout_rcv(&mut rx).await, "disconnect");
+
+    let (_stx, mut _srx) = io.new_dummy_sock("/test2", ()).await;
+    let elapsed = tokio::time::timeout(std::time::Duration::from_millis(200), rx.recv()).await;
+    assert!(elapsed.is_err() || elapsed.unwrap().is_none());
 }
diff --git a/socketioxide/tests/disconnect_reason.rs b/socketioxide/tests/disconnect_reason.rs
@@ -228,6 +228,27 @@ pub async fn server_ns_disconnect() {
     assert_eq!(data, DisconnectReason::ServerNSDisconnect);
 }
 
+#[tokio::test]
+pub async fn server_ns_close() {
+    let (tx, mut rx) = mpsc::channel::<DisconnectReason>(1);
+    let io = create_server(12353).await;
+    let io2 = io.clone();
+    io.ns("/test", move |socket: SocketRef| {
+        socket.on_disconnect(move |reason: DisconnectReason| tx.try_send(reason).unwrap());
+        io2.delete_ns("/test");
+    });
+
+    let mut ws = create_ws_connection(12353).await;
+    ws.send(Message::Text("40/test,{}".to_string()))
+        .await
+        .unwrap();
+    let data = tokio::time::timeout(Duration::from_millis(20), rx.recv())
+        .await
+        .expect("timeout waiting for DisconnectReason::ServerNSDisconnect")
+        .unwrap();
+    assert_eq!(data, DisconnectReason::ServerNSDisconnect);
+}
+
 #[tokio::test]
 pub async fn server_ws_closing() {
     let io = create_server(12350).await;