From 386379efd55e491013d010b0a377771317a21e14 Mon Sep 17 00:00:00 2001
From: Thomas Coratger <60488569+tcoratger@users.noreply.github.com>
Date: Wed, 23 Oct 2024 14:58:56 +0200
Subject: [PATCH] test(tokio-util): add unit tests for `EventSender` (#11980)

---
 crates/tokio-util/src/event_sender.rs | 93 +++++++++++++++++++++++++++
 1 file changed, 93 insertions(+)

diff --git a/crates/tokio-util/src/event_sender.rs b/crates/tokio-util/src/event_sender.rs
index a4e981538..16208ee19 100644
--- a/crates/tokio-util/src/event_sender.rs
+++ b/crates/tokio-util/src/event_sender.rs
@@ -40,3 +40,96 @@ impl<T: Clone + Send + Sync + 'static> EventSender<T> {
         EventStream::new(self.sender.subscribe())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tokio::{
+        task,
+        time::{timeout, Duration},
+    };
+    use tokio_stream::StreamExt;
+
+    #[tokio::test]
+    async fn test_event_broadcast_to_listener() {
+        let sender = EventSender::default();
+
+        // Create a listener for the events
+        let mut listener = sender.new_listener();
+
+        // Broadcast an event
+        sender.notify("event1");
+
+        // Check if the listener receives the event
+        let received_event = listener.next().await;
+        assert_eq!(received_event, Some("event1"));
+    }
+
+    #[tokio::test]
+    async fn test_event_no_listener() {
+        let sender = EventSender::default();
+
+        // Broadcast an event with no listeners
+        sender.notify("event2");
+
+        // Ensure it doesn't panic or fail when no listeners are present
+        // (this test passes if it runs without errors).
+    }
+
+    #[tokio::test]
+    async fn test_multiple_listeners_receive_event() {
+        let sender = EventSender::default();
+
+        // Create two listeners
+        let mut listener1 = sender.new_listener();
+        let mut listener2 = sender.new_listener();
+
+        // Broadcast an event
+        sender.notify("event3");
+
+        // Both listeners should receive the same event
+        let event1 = listener1.next().await;
+        let event2 = listener2.next().await;
+
+        assert_eq!(event1, Some("event3"));
+        assert_eq!(event2, Some("event3"));
+    }
+
+    #[tokio::test]
+    async fn test_bounded_channel_size() {
+        // Create a channel with size 2
+        let sender = EventSender::new(2);
+
+        // Create a listener
+        let mut listener = sender.new_listener();
+
+        // Broadcast 3 events, which exceeds the channel size
+        sender.notify("event4");
+        sender.notify("event5");
+        sender.notify("event6");
+
+        // Only the last two should be received due to the size limit
+        let received_event1 = listener.next().await;
+        let received_event2 = listener.next().await;
+
+        assert_eq!(received_event1, Some("event5"));
+        assert_eq!(received_event2, Some("event6"));
+    }
+
+    #[tokio::test]
+    async fn test_event_listener_timeout() {
+        let sender = EventSender::default();
+        let mut listener = sender.new_listener();
+
+        // Broadcast an event asynchronously
+        task::spawn(async move {
+            tokio::time::sleep(Duration::from_millis(50)).await;
+            sender.notify("delayed_event");
+        });
+
+        // Use a timeout to ensure that the event is received within a certain time
+        let result = timeout(Duration::from_millis(100), listener.next()).await;
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), Some("delayed_event"));
+    }
+}