test and document support for async-std

Author: spencerjibz

Cargo.toml

@@ -14,16 +14,14 @@ readme = "./README.md"
 [dependencies]
 anyhow = "1.0.75"
 bincode = "1.3.3"
-cfg-if = "1.0.0"
 futures = "0.3.29"
 lazy_static = "1.4.0"
 tokio-test = "0.4.3"
 
 [dependencies.async-std]
 version = "1.12.0"
 optional = true
-
-features = ["alloc"]
+features = ["alloc","attributes"]
 [dependencies.serde]
 version = "1.0.190"
 features = ["derive"]

src/lib.rs

@@ -18,7 +18,6 @@
 
         ```
         use async_event_emitter::AsyncEventEmitter;
-
         #[tokio::main]
         async fn main() {
         let mut event_emitter = AsyncEventEmitter::new();
@@ -29,9 +28,7 @@
 
         }
         ```
-
         ## Basic Usage
-
         We can emit and listen to values of any type so long as they implement  the Debug trait and serde's Serialize and Deserialize traits.
         A single EventEmitter instance can have listeners to values of multiple types.
 
@@ -107,8 +104,16 @@
             // When the <"Hello"> event is emitted in main.rs then print <"Random stuff!">
             EVENT_EMITTER.lock().await.on("Hello", |_: ()| async { println!("Random stuff!")});
         }
-
         ```
+     ## Using async-std instead of tokio
+      Tokio is the default  runtime for this library but async-std support can be able enabled by disabling default-features on the crate and enable the ```use-async-std``` feature.
+     <br>
+      **Note**: Use simply replace tokio::main with async-std::main and tokio::test with async-std::test (provided you've enabled the "attributes" feature on the crate.
+
+     ### Testing
+       Run the tests on this crate with all-features enabled as follows:
+       ``` cargo test --all-features```
+
 
         License: MIT
 */
@@ -156,6 +161,11 @@ impl AsyncEventEmitter {
     where
         T: Serialize + Deserialize<'a> + Send + Sync + 'a + std::fmt::Debug,
     {
+        #[cfg(feature = "use-async-std")]
+        use async_std::task::spawn;
+        #[cfg(not(feature = "use-async-std"))]
+        use tokio::spawn;
+
         let mut callback_handlers: Vec<_> = Vec::new();
 
         if let Some(listeners) = self.listeners.get_mut(event) {
@@ -167,33 +177,11 @@ impl AsyncEventEmitter {
 
                 match listener.limit {
                     None => {
-                        cfg_if::cfg_if! {
-                          if  #[cfg(feature = "use-async-std")] {
-                            use async_std::task::spawn;
-                          callback_handlers.push(spawn(async move {
-                         callback(bytes).await;
-                        }));
-                          } else {
-                             use tokio::spawn;
-                         callback_handlers
-                             .push(spawn(async move { callback(bytes).await }));
-                          }
-
-                         };
+                        callback_handlers.push(spawn(async move { callback(bytes).await }));
                     }
                     Some(limit) => {
                         if limit != 0 {
-                            cfg_if::cfg_if! {
-                              if  #[cfg(feature = "use-async-std")] {
-                              callback_handlers.push(async_std::task::spawn(async move {
-                             callback(bytes).await;
-                            }));
-                              } else {
-                             callback_handlers
-                                 .push(tokio::spawn(async move { callback(bytes).await }));
-                              }
-
-                             };
+                            callback_handlers.push(spawn(async move { callback(bytes).await }));
 
                             listener.limit = Some(limit - 1);
                         } else {
@@ -210,7 +198,7 @@ impl AsyncEventEmitter {
         }
 
         for handles in callback_handlers {
-            handles.await;
+            _ = handles.await;
         }
 
         Ok(())

tests/emitter.rs

@@ -1,3 +1,11 @@
+mod tester {
+    /// use
+    #[cfg(feature = "use-async-std")]
+    pub use async_std::test;
+    #[cfg(not(feature = "use-async-std"))]
+    pub use tokio::test;
+}
+
 #[cfg(test)]
 
 mod async_event_emitter {
@@ -26,8 +34,7 @@ mod async_event_emitter {
     #[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
     struct DateTime(Date, Time);
 
-    #[tokio::test]
-
+    #[tester::test]
     async fn test_async_event() -> anyhow::Result<()> {
         let mut event_emitter = AsyncEventEmitter::new();
 
@@ -50,7 +57,7 @@ mod async_event_emitter {
         Ok(())
     }
 
-    #[tokio::test]
+    #[tester::test]
     async fn test_emit_multiple_args() -> anyhow::Result<()> {
         let mut event_emitter = AsyncEventEmitter::new();
         let time = Time {
@@ -78,7 +85,7 @@ mod async_event_emitter {
         Ok(())
     }
 
-    #[tokio::test]
+    #[tester::test]
     async fn listens_once_with_multiple_emits() -> anyhow::Result<()> {
         let mut event_emitter = AsyncEventEmitter::new();
         let name = "LOG_DATE".to_string();
@@ -118,7 +125,7 @@ mod async_event_emitter {
 
         Ok(())
     }
-    #[tokio::test]
+    #[tester::test]
     async fn remove_listeners() -> anyhow::Result<()> {
         let mut event_emitter = AsyncEventEmitter::new();
         let dt = DateTime(
@@ -163,7 +170,7 @@ mod async_event_emitter {
         Ok(())
     }
 
-    #[tokio::test]
+    #[tester::test]
     #[should_panic]
     async fn panics_on_different_values_for_same_event() {
         let mut event_emitter = AsyncEventEmitter::new();
@@ -176,7 +183,7 @@ mod async_event_emitter {
             .unwrap();
         event_emitter.emit("value", 12).await.unwrap();
     }
-    #[tokio::test]
+    #[tester::test]
 
     async fn global_event_emitter() {
         // We need to maintain a lock through the mutex so we can avoid data races
@@ -189,6 +196,7 @@ mod async_event_emitter {
 
     // tests/listener_tests.rs
 
+    use crate::tester;
     use async_event_emitter::AsyncListener;
 
     #[test]