Exists command

Also remove intermediate step in try_from parser to command

Author: gillchristian

src/commands/exists.rs

@@ -2,6 +2,7 @@ use std::sync::{Arc, Mutex};
 
 use crate::commands::executable::Executable;
 use crate::commands::CommandParser;
+use crate::commands::CommandParserError;
 use crate::frame::Frame;
 use crate::store::Store;
 use crate::Error;
@@ -12,17 +13,103 @@ pub struct Exists {
 }
 
 impl Executable for Exists {
-    fn exec(self, _store: Arc<Mutex<Store>>) -> Result<Frame, Error> {
-        Ok(Frame::Simple("OK".to_string()))
+    fn exec(self, store: Arc<Mutex<Store>>) -> Result<Frame, Error> {
+        let mut count = 0;
+        let store = store.lock().unwrap();
+        for key in self.keys {
+            if store.exists(&key) {
+                count += 1;
+            }
+        }
+        Ok(Frame::Integer(count))
     }
 }
 
 impl TryFrom<&mut CommandParser> for Exists {
     type Error = Error;
 
     fn try_from(parser: &mut CommandParser) -> Result<Self, Self::Error> {
-        let key = parser.next_string()?;
-        println!("key: {}", key);
-        Ok(Self { keys: vec![key] })
+        let mut keys = vec![];
+
+        loop {
+            match parser.next_string() {
+                Ok(key) => keys.push(key),
+                Err(CommandParserError::EndOfStream) if !keys.is_empty() => {
+                    break;
+                }
+                Err(err) => return Err(err.into()),
+            }
+        }
+
+        Ok(Self { keys })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use bytes::Bytes;
+
+    use crate::commands::Command;
+
+    use super::*;
+
+    #[test]
+    fn multiple_keys() {
+        let frame = Frame::Array(vec![
+            Frame::Bulk(Bytes::from("EXISTS")),
+            Frame::Bulk(Bytes::from("foo")),
+            Frame::Bulk(Bytes::from("bar")),
+            Frame::Bulk(Bytes::from("baz")),
+        ]);
+        let cmd = Command::try_from(frame).unwrap();
+        assert_eq!(
+            cmd,
+            Command::Exists(Exists {
+                keys: vec!["foo".to_string(), "bar".to_string(), "baz".to_string()]
+            })
+        );
+    }
+
+    #[test]
+    fn single_key() {
+        let frame = Frame::Array(vec![
+            Frame::Bulk(Bytes::from("EXISTS")),
+            Frame::Bulk(Bytes::from("foo")),
+        ]);
+        let cmd = Command::try_from(frame).unwrap();
+        assert_eq!(
+            cmd,
+            Command::Exists(Exists {
+                keys: vec!["foo".to_string()]
+            })
+        );
+    }
+
+    #[test]
+    fn zero_keys() {
+        let frame = Frame::Array(vec![Frame::Bulk(Bytes::from("EXISTS"))]);
+        let err = Command::try_from(frame).err().unwrap();
+        let err = err.downcast_ref::<CommandParserError>().unwrap();
+
+        assert_eq!(*err, CommandParserError::EndOfStream);
+    }
+
+    #[test]
+    fn invalid_frame() {
+        let frame = Frame::Array(vec![
+            Frame::Bulk(Bytes::from("EXISTS")),
+            Frame::Integer(42),
+            Frame::Bulk(Bytes::from("foo")),
+        ]);
+        let err = Command::try_from(frame).err().unwrap();
+        let err = err.downcast_ref::<CommandParserError>().unwrap();
+
+        assert_eq!(
+            *err,
+            CommandParserError::InvalidFrame {
+                expected: "simple or bulk string".to_string(),
+                actual: Frame::Integer(42)
+            }
+        );
     }
 }

src/commands/mod.rs

@@ -66,20 +66,34 @@ impl TryFrom<Frame> for Command {
     type Error = Error;
 
     fn try_from(frame: Frame) -> Result<Self, Self::Error> {
-        let mut parser = CommandParser::try_from(frame)?;
+        // Clients send commands to the Redis server as RESP arrays.
+        let frames = match frame {
+            Frame::Array(array) => array,
+            frame => {
+                return Err(Box::new(CommandParserError::InvalidFrame {
+                    expected: "array".to_string(),
+                    actual: frame,
+                }))
+            }
+        };
+
+        let parser = &mut CommandParser {
+            parts: frames.into_iter(),
+        };
+
         let command_name = parser.parse_command_name()?;
 
         match &command_name[..] {
-            "get" => Get::try_from(&mut parser).map(Command::Get),
-            "set" => Set::try_from(&mut parser).map(Command::Set),
-            "exists" => Exists::try_from(&mut parser).map(Command::Exists),
-            "dbsize" => DBSize::try_from(&mut parser).map(Command::DBsize),
-            "info" => Info::try_from(&mut parser).map(Command::Info),
-            "client" => Client::try_from(&mut parser).map(Command::Client),
-            "module" => Module::try_from(&mut parser).map(Command::Module),
-            "command" => Foo::try_from(&mut parser).map(Command::Command),
-            "config" => Config::try_from(&mut parser).map(Command::Config),
-            "type" => Type::try_from(&mut parser).map(Command::Type),
+            "get" => Get::try_from(parser).map(Command::Get),
+            "set" => Set::try_from(parser).map(Command::Set),
+            "exists" => Exists::try_from(parser).map(Command::Exists),
+            "dbsize" => DBSize::try_from(parser).map(Command::DBsize),
+            "info" => Info::try_from(parser).map(Command::Info),
+            "client" => Client::try_from(parser).map(Command::Client),
+            "module" => Module::try_from(parser).map(Command::Module),
+            "command" => Foo::try_from(parser).map(Command::Command),
+            "config" => Config::try_from(parser).map(Command::Config),
+            "type" => Type::try_from(parser).map(Command::Type),
             name => Err(format!("protocol error; unknown command {:?}", name).into()),
         }
     }
@@ -147,7 +161,7 @@ impl CommandParser {
     }
 }
 
-#[derive(Debug, ThisError)]
+#[derive(Debug, ThisError, PartialEq)]
 pub(crate) enum CommandParserError {
     #[error("protocol error; invalid frame, expected {expected}, got {actual}")]
     InvalidFrame { expected: String, actual: Frame },
@@ -157,27 +171,6 @@ pub(crate) enum CommandParserError {
     EndOfStream,
 }
 
-impl TryFrom<Frame> for CommandParser {
-    type Error = CommandParserError;
-
-    fn try_from(frame: Frame) -> Result<Self, Self::Error> {
-        // Clients send commands to the Redis server as RESP arrays.
-        let frames = match frame {
-            Frame::Array(array) => array,
-            frame => {
-                return Err(CommandParserError::InvalidFrame {
-                    expected: "array".to_string(),
-                    actual: frame,
-                })
-            }
-        };
-
-        Ok(Self {
-            parts: frames.into_iter(),
-        })
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/store.rs

@@ -19,6 +19,10 @@ impl Store {
     pub fn get(&self, key: &str) -> Option<&Bytes> {
         self.store.get(key)
     }
+
+    pub fn exists(&self, key: &str) -> bool {
+        self.store.contains_key(key)
+    }
 }
 
 impl Default for Store {