Fixed clippy warnings

protocol/src/lib.rs

@@ -23,7 +23,7 @@ pub enum Error {
     InvalidLength,
     InvalidBoolean,
     InvalidNumber,
-    ProtocolError(u8, u8),
+    Protocol(u8, u8),
     NewLine,
 }
 
@@ -31,14 +31,14 @@ pub fn parse_server(bytes: &[u8]) -> Result<(&[u8], Vec<&[u8]>), Error> {
     let (bytes, byte) = next!(bytes);
     match byte {
         b'*' => parse_server_array(bytes),
-        _ => Err(Error::ProtocolError(b'*', byte)),
+        _ => Err(Error::Protocol(b'*', byte)),
     }
 }
 
 fn parse_server_array(bytes: &[u8]) -> Result<(&[u8], Vec<&[u8]>), Error> {
     let (bytes, len) = read_line_number!(bytes, i32);
     if len <= 0 {
-        return Err(Error::ProtocolError(b'x', b'y'));
+        return Err(Error::Protocol(b'x', b'y'));
     }
 
     let mut v = vec![];
@@ -48,12 +48,12 @@ fn parse_server_array(bytes: &[u8]) -> Result<(&[u8], Vec<&[u8]>), Error> {
         let n = next!(bytes);
         let r = match n.1 {
             b'$' => parse_blob(n.0),
-            _ => Err(Error::ProtocolError(b'$', n.1)),
+            _ => Err(Error::Protocol(b'$', n.1)),
         }?;
         bytes = r.0;
         v.push(match r.1 {
             Value::Blob(x) => Ok(x),
-            _ => Err(Error::ProtocolError(b'x', b'y')),
+            _ => Err(Error::Protocol(b'x', b'y')),
         }?);
     }
 

src/db/expiration.rs

@@ -126,22 +126,10 @@ mod test {
     fn get_expiration() {
         let mut db = ExpirationDb::new();
         let keys = vec![
-            (
-                bytes!(b"hix"),
-                Instant::now() + Duration::from_secs(15),
-            ),
-            (
-                bytes!(b"key"),
-                Instant::now() + Duration::from_secs(2),
-            ),
-            (
-                bytes!(b"bar"),
-                Instant::now() + Duration::from_secs(3),
-            ),
-            (
-                bytes!(b"hi"),
-                Instant::now() + Duration::from_secs(3),
-            ),
+            (bytes!(b"hix"), Instant::now() + Duration::from_secs(15)),
+            (bytes!(b"key"), Instant::now() + Duration::from_secs(2)),
+            (bytes!(b"bar"), Instant::now() + Duration::from_secs(3)),
+            (bytes!(b"hi"), Instant::now() + Duration::from_secs(3)),
         ];
 
         keys.iter()
@@ -172,22 +160,10 @@ mod test {
     pub fn remove() {
         let mut db = ExpirationDb::new();
         let keys = vec![
-            (
-                bytes!(b"hix"),
-                Instant::now() + Duration::from_secs(15),
-            ),
-            (
-                bytes!(b"key"),
-                Instant::now() + Duration::from_secs(2),
-            ),
-            (
-                bytes!(b"bar"),
-                Instant::now() + Duration::from_secs(3),
-            ),
-            (
-                bytes!(b"hi"),
-                Instant::now() + Duration::from_secs(3),
-            ),
+            (bytes!(b"hix"), Instant::now() + Duration::from_secs(15)),
+            (bytes!(b"key"), Instant::now() + Duration::from_secs(2)),
+            (bytes!(b"bar"), Instant::now() + Duration::from_secs(3)),
+            (bytes!(b"hi"), Instant::now() + Duration::from_secs(3)),
         ];
 
         keys.iter()

src/db/mod.rs

@@ -120,9 +120,11 @@ impl Db {
         keys.iter()
             .map(|key| {
                 let mut entries = self.entries[self.get_slot(key)].write().unwrap();
-                if entries.remove(key).is_some() {
-                    expirations.remove(&key);
-                    deleted += 1;
+                if let Some(entry) = entries.remove(key) {
+                    expirations.remove(key);
+                    if entry.is_valid() {
+                        deleted += 1;
+                    }
                 }
             })
             .for_each(drop);
@@ -164,7 +166,7 @@ impl Db {
 
     pub fn getset(&self, key: &Bytes, value: &Value) -> Value {
         let mut entries = self.entries[self.get_slot(key)].write().unwrap();
-        self.expirations.lock().unwrap().remove(&key);
+        self.expirations.lock().unwrap().remove(key);
         entries
             .insert(key.clone(), Entry::new(value.clone(), None))
             .filter(|x| x.is_valid())
@@ -174,7 +176,7 @@ impl Db {
     pub fn getdel(&self, key: &Bytes) -> Value {
         let mut entries = self.entries[self.get_slot(key)].write().unwrap();
         entries.remove(key).map_or(Value::Null, |x| {
-            self.expirations.lock().unwrap().remove(&key);
+            self.expirations.lock().unwrap().remove(key);
             x.get().clone()
         })
     }
@@ -184,7 +186,7 @@ impl Db {
         let expires_at = expires_in.map(|duration| Instant::now() + duration);
 
         if let Some(expires_at) = expires_at {
-            self.expirations.lock().unwrap().add(&key, expires_at);
+            self.expirations.lock().unwrap().add(key, expires_at);
         }
         entries.insert(key.clone(), Entry::new(value.clone(), expires_at));
         Value::OK
@@ -227,30 +229,133 @@ mod test {
     use crate::bytes;
 
     #[test]
+    fn incr_wrong_type() {
+        let db = Db::new(100);
+        db.set(&bytes!(b"num"), &Value::Blob(bytes!("some string")), None);
+
+        let r = db.incr(&bytes!("num"), 1);
+
+        assert!(r.is_err());
+        assert_eq!(Error::NotANumber, r.expect_err("should fail"));
+        assert_eq!(Value::Blob(bytes!("some string")), db.get(&bytes!("num")));
+    }
+
+    #[test]
+    fn incr_blob_float() {
+        let db = Db::new(100);
+        db.set(&bytes!(b"num"), &Value::Blob(bytes!("1.1")), None);
+
+        assert_eq!(Value::Float(2.2), db.incr(&bytes!("num"), 1.1).unwrap());
+        assert_eq!(Value::Blob(bytes!("2.2")), db.get(&bytes!("num")));
+    }
+
+    #[test]
+    fn incr_blob_int_float() {
+        let db = Db::new(100);
+        db.set(&bytes!(b"num"), &Value::Blob(bytes!("1")), None);
+
+        assert_eq!(Value::Float(2.1), db.incr(&bytes!("num"), 1.1).unwrap());
+        assert_eq!(Value::Blob(bytes!("2.1")), db.get(&bytes!("num")));
+    }
+
+    #[test]
+    fn incr_blob_int() {
+        let db = Db::new(100);
+        db.set(&bytes!(b"num"), &Value::Blob(bytes!("1")), None);
+
+        assert_eq!(Value::Integer(2), db.incr(&bytes!("num"), 1).unwrap());
+        assert_eq!(Value::Blob(bytes!("2")), db.get(&bytes!("num")));
+    }
+
+    #[test]
+    fn incr_blob_int_set() {
+        let db = Db::new(100);
+        assert_eq!(Value::Integer(1), db.incr(&bytes!("num"), 1).unwrap());
+        assert_eq!(Value::Blob(bytes!("1")), db.get(&bytes!("num")));
+    }
+
+    #[test]
+    fn incr_blob_float_set() {
+        let db = Db::new(100);
+        assert_eq!(Value::Float(1.1), db.incr(&bytes!("num"), 1.1).unwrap());
+        assert_eq!(Value::Blob(bytes!("1.1")), db.get(&bytes!("num")));
+    }
+
+    #[test]
+    fn del() {
+        let db = Db::new(100);
+        db.set(
+            &bytes!(b"expired"),
+            &Value::OK,
+            Some(Duration::from_secs(0)),
+        );
+        db.set(&bytes!(b"valid"), &Value::OK, None);
+        db.set(
+            &bytes!(b"expiring"),
+            &Value::OK,
+            Some(Duration::from_secs(5)),
+        );
+
+        assert_eq!(
+            Value::Integer(2),
+            db.del(&[
+                bytes!(b"expired"),
+                bytes!(b"valid"),
+                bytes!(b"expiring"),
+                bytes!(b"not_existing_key")
+            ])
+        );
+    }
+
+    #[test]
+    fn ttl() {
+        let db = Db::new(100);
+        db.set(
+            &bytes!(b"expired"),
+            &Value::OK,
+            Some(Duration::from_secs(0)),
+        );
+        db.set(&bytes!(b"valid"), &Value::OK, None);
+        db.set(
+            &bytes!(b"expiring"),
+            &Value::OK,
+            Some(Duration::from_secs(5)),
+        );
+
+        assert_eq!(None, db.ttl(&bytes!(b"expired")));
+        assert_eq!(None, db.ttl(&bytes!(b"not_existing_key")));
+        assert_eq!(Some(None), db.ttl(&bytes!(b"valid")));
+        assert!(match db.ttl(&bytes!(b"expiring")) {
+            Some(Some(_)) => true,
+            _ => false,
+        });
+    }
+
+    #[test]
     fn purge_keys() {
         let db = Db::new(100);
-        db.set(& bytes!(b"one"), &Value::OK, Some(Duration::from_secs(0)));
+        db.set(&bytes!(b"one"), &Value::OK, Some(Duration::from_secs(0)));
         // Expired keys should not be returned, even if they are not yet
         // removed by the purge process.
-        assert_eq!(Value::Null, db.get(& bytes!(b"one")));
+        assert_eq!(Value::Null, db.get(&bytes!(b"one")));
 
         // Purge twice
         assert_eq!(1, db.purge());
         assert_eq!(0, db.purge());
 
-        assert_eq!(Value::Null, db.get(& bytes!(b"one")));
+        assert_eq!(Value::Null, db.get(&bytes!(b"one")));
     }
 
     #[test]
     fn replace_purge_keys() {
         let db = Db::new(100);
-        db.set(& bytes!(b"one"), &Value::OK, Some(Duration::from_secs(0)));
+        db.set(&bytes!(b"one"), &Value::OK, Some(Duration::from_secs(0)));
         // Expired keys should not be returned, even if they are not yet
         // removed by the purge process.
-        assert_eq!(Value::Null, db.get(& bytes!(b"one")));
+        assert_eq!(Value::Null, db.get(&bytes!(b"one")));
 
-        db.set(& bytes!(b"one"), &Value::OK, Some(Duration::from_secs(5)));
-        assert_eq!(Value::OK, db.get(& bytes!(b"one")));
+        db.set(&bytes!(b"one"), &Value::OK, Some(Duration::from_secs(5)));
+        assert_eq!(Value::OK, db.get(&bytes!(b"one")));
 
         // Purge should return 0 as the expired key has been removed already
         assert_eq!(0, db.purge());

src/error.rs

@@ -1,9 +1,10 @@
 use crate::value::Value;
 
+#[derive(Debug, Eq, PartialEq)]
 pub enum Error {
     CommandNotFound(String),
     InvalidArgsCount(String),
-    ProtocolError(String, String),
+    Protocol(String, String),
     WrongArgument(String, String),
     NotANumber,
     WrongType,
@@ -19,7 +20,7 @@ impl From<Error> for Value {
         let err_msg = match value {
             Error::CommandNotFound(x) => format!("unknown command `{}`", x),
             Error::InvalidArgsCount(x) => format!("wrong number of arguments for '{}' command", x),
-            Error::ProtocolError(x, y) => format!("Protocol error: expected '{}', got '{}'", x, y),
+            Error::Protocol(x, y) => format!("Protocol error: expected '{}', got '{}'", x, y),
             Error::NotANumber => "value is not an integer or out of range".to_string(),
             Error::WrongArgument(x, y) => format!(
                 "Unknown subcommand or wrong number of arguments for '{}'. Try {} HELP.",

src/macros.rs

@@ -155,6 +155,6 @@ macro_rules! check_arg {
 #[macro_export]
 macro_rules! bytes {
     ($content:tt) => {
-        Bytes::from(& $content [..])
-    }
+        Bytes::from(&$content[..])
+    };
 }

src/value.rs

@@ -38,7 +38,7 @@ impl From<&Value> for Vec<u8> {
             Value::Blob(x) => {
                 let s = format!("${}\r\n", x.len());
                 let mut s: BytesMut = s.as_str().as_bytes().into();
-                s.extend_from_slice(&x);
+                s.extend_from_slice(x);
                 s.extend_from_slice(b"\r\n");
                 s.to_vec()
             }
@@ -57,7 +57,7 @@ impl TryFrom<&Value> for i64 {
         match val {
             Value::BigInteger(x) => (*x).try_into().map_err(|_| Error::NotANumber),
             Value::Integer(x) => Ok(*x),
-            Value::Blob(x) => bytes_to_number::<i64>(&x),
+            Value::Blob(x) => bytes_to_number::<i64>(x),
             Value::String(x) => x.parse::<i64>().map_err(|_| Error::NotANumber),
             _ => Err(Error::NotANumber),
         }
@@ -70,7 +70,7 @@ impl TryFrom<&Value> for f64 {
     fn try_from(val: &Value) -> Result<Self, Self::Error> {
         match val {
             Value::Float(x) => Ok(*x),
-            Value::Blob(x) => bytes_to_number::<f64>(&x),
+            Value::Blob(x) => bytes_to_number::<f64>(x),
             Value::String(x) => x.parse::<f64>().map_err(|_| Error::NotANumber),
             _ => Err(Error::NotANumber),
         }