feat!: use result instead of unwrap

ctrlaltf24 · ctrlaltf24 · commit 3e0a2129e894 · 2024-09-24T18:39:49.000Z
- emit/emit_json functions switch from taking ownership and returning Emitter to taking mutable ref returning a result of an empty tuple
diff --git a/Cargo.toml b/Cargo.toml
@@ -18,6 +18,7 @@ serde = "1.0"
 serde_json = "1.0"
 serde_derive = "1.0"
 rmp-serde = { version = "1.3", optional = true }
+thiserror = "1"
 
 [dev-dependencies]
 testcontainers = { version = "0.22.0", features = ["blocking"] }
@@ -32,3 +33,7 @@ default = ["js-v7"]
 js-v7 = ["rmp-serde"]
 # Compatible with python-socketio v4 (socket.io protocol version 3 or 4)
 python-v4 = []
+
+[lints.clippy]
+unwrap_in_result = "deny"
+unwrap_used = "deny"
diff --git a/src/implementations/javascript.rs b/src/implementations/javascript.rs
@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use crate::Emitter;
+use crate::{Emitter, Result};
 use redis::Commands;
 use rmp_serde::Serializer;
 use serde::Serialize;
@@ -41,7 +41,7 @@ impl Emitter {
         self
     }
 
-    pub fn emit(mut self, message: Vec<&str>) -> Emitter {
+    pub fn emit(&mut self, message: Vec<&str>) -> Result<()> {
         let packet = Packet {
             _type: 2,
             data: message.iter().map(|s| s.to_string()).collect(),
@@ -53,19 +53,18 @@ impl Emitter {
         };
         let mut msg = Vec::new();
         let val = (self.uid.clone(), packet, opts);
-        val.serialize(&mut Serializer::new(&mut msg).with_struct_map())
-            .unwrap();
+        val.serialize(&mut Serializer::new(&mut msg).with_struct_map())?;
 
         let channel = if self.rooms.len() == 1 {
             format!("{}{}#", self.channel, self.rooms.join("#"))
         } else {
             self.channel.clone()
         };
 
-        let _: () = self.redis.publish(channel, msg).unwrap();
+        let _: () = self.redis.publish(channel, msg)?;
         self.rooms = vec![];
         self.flags = HashMap::new();
-        self
+        Ok(())
     }
 }
 
@@ -91,8 +90,8 @@ mod tests {
         pubsub.subscribe("socket.io#/#").unwrap();
 
         // act
-        let io = Emitter::new(redis);
-        io.emit(vec!["test1", "test2"]);
+        let mut io = Emitter::new(redis).unwrap();
+        io.emit(vec!["test1", "test2"]).unwrap();
 
         // assert
         let actual = decode_msg(pubsub.get_message().unwrap());
@@ -122,8 +121,8 @@ mod tests {
         pubsub.subscribe("socket.io#/custom#").unwrap();
 
         // act
-        let io = Emitter::new(redis);
-        io.of("/custom").emit(vec!["test"]);
+        let io = Emitter::new(redis).unwrap();
+        io.of("/custom").emit(vec!["test"]).unwrap();
 
         // assert
         let actual = decode_msg(pubsub.get_message().unwrap());
@@ -153,8 +152,8 @@ mod tests {
         pubsub.subscribe("socket.io#/custom#").unwrap();
 
         // act
-        let io = Emitter::new(redis);
-        io.of("/custom").emit(vec!["test"]);
+        let io = Emitter::new(redis).unwrap();
+        io.of("/custom").emit(vec!["test"]).unwrap();
 
         // assert
         let actual = decode_msg(pubsub.get_message().unwrap());
@@ -184,8 +183,8 @@ mod tests {
         pubsub.subscribe("socket.io#/#room1#").unwrap();
 
         // act
-        let io = Emitter::new(redis);
-        io.to("room1").emit(vec!["test"]);
+        let io = Emitter::new(redis).unwrap();
+        io.to("room1").emit(vec!["test"]).unwrap();
 
         // assert
         let actual = decode_msg(pubsub.get_message().unwrap());
diff --git a/src/implementations/python_socketio.rs b/src/implementations/python_socketio.rs
@@ -4,7 +4,7 @@ use redis::Commands;
 use serde::Serialize;
 use serde_json::json;
 
-use crate::Emitter;
+use crate::{Emitter, Result};
 
 impl Emitter {
     /// Overrides the default channel name.
@@ -13,15 +13,19 @@ impl Emitter {
         self
     }
 
-    pub fn emit_json<T: Serialize, Event: Display>(mut self, event: Event, message: T) -> Emitter {
+    pub fn emit_json<T: Serialize, Event: Display>(
+        &mut self,
+        event: Event,
+        message: T,
+    ) -> Result<()> {
         fn _emit_json(
             redis: &mut redis::Client,
             channel: &str,
             nsp: &str,
             room: Option<&str>,
             event: &str,
             data: &serde_json::Value,
-        ) {
+        ) -> Result<()> {
             let message = json!({
                 "method": "emit",
                 "event": event,
@@ -32,10 +36,11 @@ impl Emitter {
                 "callback": null,
                 "host_id": null,
             });
-            let _: () = redis.publish(channel, message.to_string()).unwrap();
+            let _: () = redis.publish(channel, message.to_string())?;
+            Ok(())
         }
         let event = event.to_string();
-        let data = serde_json::to_value(&message).unwrap();
+        let data = serde_json::to_value(&message)?;
 
         if self.rooms.is_empty() {
             _emit_json(
@@ -45,7 +50,7 @@ impl Emitter {
                 None,
                 &event,
                 &data,
-            );
+            )?;
         } else {
             for room in self.rooms.iter() {
                 _emit_json(
@@ -55,10 +60,10 @@ impl Emitter {
                     Some(&room),
                     &event,
                     &data,
-                );
+                )?;
             }
         }
-        self
+        Ok(())
     }
 }
 
@@ -243,10 +248,11 @@ while True:
     #[test]
     fn test_emit_json() {
         let (redis, redis_url, container) = launch_containers(None);
-        let emitter = Emitter::new(redis::Client::open(redis_url).unwrap());
+        let emitter = Emitter::new(redis::Client::open(redis_url).unwrap()).unwrap();
         emitter
             .to("room")
-            .emit_json("my_event", json!({"key": "value"}));
+            .emit_json("my_event", json!({"key": "value"}))
+            .unwrap();
         // Now check to see if the message was received
         let messages = PythonSocketIOImage::messages(&container);
         container.stop().unwrap();
@@ -264,10 +270,13 @@ while True:
     #[test]
     fn test_custom_channel() {
         let (redis, redis_url, container) = launch_containers(Some("custom_channel".to_string()));
-        let emitter = Emitter::new(redis::Client::open(redis_url).unwrap()).channel("custom_channel");
+        let emitter = Emitter::new(redis::Client::open(redis_url).unwrap())
+            .unwrap()
+            .channel("custom_channel");
         emitter
             .to("room")
-            .emit_json("my_event", json!({"key": "value"}));
+            .emit_json("my_event", json!({"key": "value"}))
+            .unwrap();
         // Now check to see if the message was received
         let messages = PythonSocketIOImage::messages(&container);
         container.stop().unwrap();
@@ -285,8 +294,10 @@ while True:
     #[test]
     fn test_no_room() {
         let (redis, redis_url, container) = launch_containers(None);
-        let emitter = Emitter::new(redis::Client::open(redis_url).unwrap());
-        emitter.emit_json("my_event", json!({"key": "value"}));
+        let mut emitter = Emitter::new(redis::Client::open(redis_url).unwrap()).unwrap();
+        emitter
+            .emit_json("my_event", json!({"key": "value"}))
+            .unwrap();
         // Now check to see if the message was received
         let messages = PythonSocketIOImage::messages(&container);
         container.stop().unwrap();
@@ -304,8 +315,8 @@ while True:
     #[test]
     fn test_array_data() {
         let (redis, redis_url, container) = launch_containers(None);
-        let emitter = Emitter::new(redis::Client::open(redis_url).unwrap());
-        emitter.emit_json("my_event", json!([1, 2, 3]));
+        let mut emitter = Emitter::new(redis::Client::open(redis_url).unwrap()).unwrap();
+        emitter.emit_json("my_event", json!([1, 2, 3])).unwrap();
         // Now check to see if the message was received
         let messages = PythonSocketIOImage::messages(&container);
         container.stop().unwrap();
diff --git a/src/lib.rs b/src/lib.rs
@@ -28,31 +28,31 @@ pub struct EmitterOpts<'a> {
 }
 
 pub trait IntoEmitter {
-    fn into_emitter(self) -> Emitter;
+    fn into_emitter(self) -> Result<Emitter>;
 }
 
 impl IntoEmitter for redis::Client {
-    fn into_emitter(self) -> Emitter {
-        create_emitter(self, "socket.io", "/")
+    fn into_emitter(self) -> Result<Emitter> {
+        Ok(create_emitter(self, "socket.io", "/"))
     }
 }
 
 impl<'a> IntoEmitter for EmitterOpts<'a> {
-    fn into_emitter(self) -> Emitter {
+    fn into_emitter(self) -> Result<Emitter> {
         let addr = format!("redis://{}:{}", self.host, self.port);
         let prefix = self.key.unwrap_or("socket.io");
 
-        create_emitter(redis::Client::open(addr.as_str()).unwrap(), prefix, "/")
+        Ok(create_emitter(redis::Client::open(addr.as_str())?, prefix, "/"))
     }
 }
 
 impl IntoEmitter for &str {
-    fn into_emitter(self) -> Emitter {
-        create_emitter(
-            redis::Client::open(format!("redis://{}", self).as_str()).unwrap(),
+    fn into_emitter(self) -> Result<Emitter> {
+        Ok(create_emitter(
+            redis::Client::open(format!("redis://{}", self).as_str())?,
             "socket.io",
             "/",
-        )
+        ))
     }
 }
 
@@ -74,7 +74,7 @@ fn create_emitter(redis: redis::Client, prefix: &str, nsp: &str) -> Emitter {
 }
 
 impl Emitter {
-    pub fn new<I: IntoEmitter>(data: I) -> Emitter {
+    pub fn new<I: IntoEmitter>(data: I) -> Result<Emitter> {
         data.into_emitter()
     }
 
@@ -96,6 +96,22 @@ compile_error!("At least one of the features 'js-v7' or 'python-v4' must be enab
 #[cfg(all(feature = "js-v7", feature = "python-v4"))]
 compile_error!("Only one of the features 'js-v7' or 'python-v4' can be enabled.");
 
+#[non_exhaustive]
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("Error connecting to Redis: {0}")]
+    Redis(#[from] redis::RedisError),
+    #[error("Error serializing data: {0}")]
+    #[cfg(feature = "python-v4")]
+    Serde(#[from] serde_json::Error),
+    #[error("Error serializing data: {0}")]
+    #[cfg(feature = "js-v7")]
+    Serde(#[from] rmp_serde::encode::Error),
+
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
 #[cfg(test)]
 pub(crate) mod tests {
     pub const DOCKER_NETWORK_NAME: &str = "testcontainers-socketio";
