Use tokio test where store is used to support spawning

ndelvalle · May 24, 2024 · c122e27 · c122e27
1 parent 7cfdea0
commit c122e27
Show file tree

Hide file tree

Showing 20 changed files with 132 additions and 132 deletions.
diff --git a/src/commands/append.rs b/src/commands/append.rs
@@ -62,8 +62,8 @@ mod tests {
     use crate::commands::Command;
     use bytes::Bytes;
 
-    #[test]
-    fn when_key_does_not_exists() {
+    #[tokio::test]
+    async fn when_key_does_not_exists() {
         let store = Arc::new(Mutex::new(Store::new()));
 
         let frame = Frame::Array(vec![
@@ -87,8 +87,8 @@ mod tests {
         assert_eq!(store.lock().unwrap().get("foo"), Some(&Bytes::from("baz")));
     }
 
-    #[test]
-    fn when_key_exists() {
+    #[tokio::test]
+    async fn when_key_exists() {
         let store = Arc::new(Mutex::new(Store::new()));
 
         let frame = Frame::Array(vec![

diff --git a/src/commands/dbsize.rs b/src/commands/dbsize.rs
@@ -32,8 +32,8 @@ mod tests {
     use crate::commands::Command;
     use bytes::Bytes;
 
-    #[test]
-    fn zero_keys() {
+    #[tokio::test]
+    async fn zero_keys() {
         let frame = Frame::Array(vec![Frame::Bulk(Bytes::from("DBSIZE"))]);
         let cmd = Command::try_from(frame).unwrap();
 
@@ -46,8 +46,8 @@ mod tests {
         assert_eq!(result, Frame::Integer(0));
     }
 
-    #[test]
-    fn multiple_keys() {
+    #[tokio::test]
+    async fn multiple_keys() {
         let frame = Frame::Array(vec![Frame::Bulk(Bytes::from("DBSIZE"))]);
         let cmd = Command::try_from(frame).unwrap();
 

diff --git a/src/commands/decr.rs b/src/commands/decr.rs
@@ -41,8 +41,8 @@ mod tests {
     use crate::commands::Command;
     use bytes::Bytes;
 
-    #[test]
-    fn existing_key() {
+    #[tokio::test]
+    async fn existing_key() {
         let frame = Frame::Array(vec![
             Frame::Bulk(Bytes::from("DECR")),
             Frame::Bulk(Bytes::from("key1")),
@@ -69,8 +69,8 @@ mod tests {
         assert_eq!(store.lock().unwrap().get("key1"), Some(&Bytes::from("0")));
     }
 
-    #[test]
-    fn non_existing_key() {
+    #[tokio::test]
+    async fn non_existing_key() {
         let frame = Frame::Array(vec![
             Frame::Bulk(Bytes::from("DECR")),
             Frame::Bulk(Bytes::from("key1")),
@@ -93,8 +93,8 @@ mod tests {
         assert_eq!(store.lock().unwrap().get("key1"), Some(&Bytes::from("-1")));
     }
 
-    #[test]
-    fn invalid_key_type() {
+    #[tokio::test]
+    async fn invalid_key_type() {
         let frame = Frame::Array(vec![
             Frame::Bulk(Bytes::from("DECR")),
             Frame::Bulk(Bytes::from("key1")),
@@ -127,8 +127,8 @@ mod tests {
         );
     }
 
-    #[test]
-    fn out_of_range() {
+    #[tokio::test]
+    async fn out_of_range() {
         let frame = Frame::Array(vec![
             Frame::Bulk(Bytes::from("DECR")),
             Frame::Bulk(Bytes::from("key1")),

diff --git a/src/commands/decrby.rs b/src/commands/decrby.rs
@@ -43,8 +43,8 @@ mod tests {
     use crate::commands::Command;
     use bytes::Bytes;
 
-    #[test]
-    fn existing_key() {
+    #[tokio::test]
+    async fn existing_key() {
         let frame = Frame::Array(vec![
             Frame::Bulk(Bytes::from("DECRBY")),
             Frame::Bulk(Bytes::from("key1")),
@@ -73,8 +73,8 @@ mod tests {
         assert_eq!(store.lock().unwrap().get("key1"), Some(&Bytes::from("10")));
     }
 
-    #[test]
-    fn non_existing_key() {
+    #[tokio::test]
+    async fn non_existing_key() {
         let frame = Frame::Array(vec![
             Frame::Bulk(Bytes::from("DECRBY")),
             Frame::Bulk(Bytes::from("key1")),
@@ -99,8 +99,8 @@ mod tests {
         assert_eq!(store.lock().unwrap().get("key1"), Some(&Bytes::from("-10")));
     }
 
-    #[test]
-    fn invalid_key_type() {
+    #[tokio::test]
+    async fn invalid_key_type() {
         let frame = Frame::Array(vec![
             Frame::Bulk(Bytes::from("DECRBY")),
             Frame::Bulk(Bytes::from("key1")),
@@ -135,8 +135,8 @@ mod tests {
         );
     }
 
-    #[test]
-    fn out_of_range() {
+    #[tokio::test]
+    async fn out_of_range() {
         let frame = Frame::Array(vec![
             Frame::Bulk(Bytes::from("DECRBY")),
             Frame::Bulk(Bytes::from("key1")),

diff --git a/src/commands/get.rs b/src/commands/get.rs
@@ -41,8 +41,8 @@ mod tests {
     use crate::commands::Command;
     use bytes::Bytes;
 
-    #[test]
-    fn existing_key() {
+    #[tokio::test]
+    async fn existing_key() {
         let store = Arc::new(Mutex::new(Store::new()));
 
         let frame = Frame::Array(vec![
@@ -68,8 +68,8 @@ mod tests {
         assert_eq!(result, Frame::Bulk(Bytes::from("1")));
     }
 
-    #[test]
-    fn non_existing_key() {
+    #[tokio::test]
+    async fn non_existing_key() {
         let store = Arc::new(Mutex::new(Store::new()));
 
         let frame = Frame::Array(vec![

diff --git a/src/commands/getdel.rs b/src/commands/getdel.rs
@@ -45,8 +45,8 @@ mod tests {
 
     use super::*;
 
-    #[test]
-    fn when_key_exists() {
+    #[tokio::test]
+    async fn when_key_exists() {
         let store = Arc::new(Mutex::new(Store::default()));
 
         let frame = Frame::Array(vec![
@@ -71,8 +71,8 @@ mod tests {
         assert_eq!(store.lock().unwrap().get("foo"), None);
     }
 
-    #[test]
-    fn when_key_does_not_exists() {
+    #[tokio::test]
+    async fn when_key_does_not_exists() {
         let store = Arc::new(Mutex::new(Store::default()));
 
         let frame = Frame::Array(vec![

diff --git a/src/commands/getrange.rs b/src/commands/getrange.rs
@@ -78,8 +78,8 @@ mod tests {
 
     use super::*;
 
-    #[test]
-    fn when_key_exists_using_positive_index() {
+    #[tokio::test]
+    async fn when_key_exists_using_positive_index() {
         let store = Arc::new(Mutex::new(Store::default()));
 
         let frame = Frame::Array(vec![
@@ -107,8 +107,8 @@ mod tests {
         assert_eq!(res, Frame::Bulk(Bytes::from("This")));
     }
 
-    #[test]
-    fn when_key_exists_using_negative_index() {
+    #[tokio::test]
+    async fn when_key_exists_using_negative_index() {
         let store = Arc::new(Mutex::new(Store::default()));
 
         let frame = Frame::Array(vec![
@@ -136,8 +136,8 @@ mod tests {
         assert_eq!(res, Frame::Bulk(Bytes::from("ing")));
     }
 
-    #[test]
-    fn when_key_exists_using_positive_and_negative_index() {
+    #[tokio::test]
+    async fn when_key_exists_using_positive_and_negative_index() {
         let store = Arc::new(Mutex::new(Store::default()));
 
         let frame = Frame::Array(vec![
@@ -165,8 +165,8 @@ mod tests {
         assert_eq!(res, Frame::Bulk(Bytes::from("This is a string")));
     }
 
-    #[test]
-    fn when_key_exists_using_out_of_bound_index() {
+    #[tokio::test]
+    async fn when_key_exists_using_out_of_bound_index() {
         let store = Arc::new(Mutex::new(Store::default()));
 
         let frame = Frame::Array(vec![

diff --git a/src/commands/incr.rs b/src/commands/incr.rs
@@ -41,8 +41,8 @@ mod tests {
     use crate::commands::Command;
     use bytes::Bytes;
 
-    #[test]
-    fn existing_key() {
+    #[tokio::test]
+    async fn existing_key() {
         let frame = Frame::Array(vec![
             Frame::Bulk(Bytes::from("INCR")),
             Frame::Bulk(Bytes::from("key1")),
@@ -69,8 +69,8 @@ mod tests {
         assert_eq!(store.lock().unwrap().get("key1"), Some(&Bytes::from("2")));
     }
 
-    #[test]
-    fn non_existing_key() {
+    #[tokio::test]
+    async fn non_existing_key() {
         let frame = Frame::Array(vec![
             Frame::Bulk(Bytes::from("INCR")),
             Frame::Bulk(Bytes::from("key1")),
@@ -93,8 +93,8 @@ mod tests {
         assert_eq!(store.lock().unwrap().get("key1"), Some(&Bytes::from("1")));
     }
 
-    #[test]
-    fn invalid_key_type() {
+    #[tokio::test]
+    async fn invalid_key_type() {
         let frame = Frame::Array(vec![
             Frame::Bulk(Bytes::from("INCR")),
             Frame::Bulk(Bytes::from("key1")),
@@ -127,8 +127,8 @@ mod tests {
         );
     }
 
-    #[test]
-    fn out_of_range() {
+    #[tokio::test]
+    async fn out_of_range() {
         let frame = Frame::Array(vec![
             Frame::Bulk(Bytes::from("INCR")),
             Frame::Bulk(Bytes::from("key1")),

diff --git a/src/commands/incrby.rs b/src/commands/incrby.rs
@@ -43,8 +43,8 @@ mod tests {
     use crate::commands::Command;
     use bytes::Bytes;
 
-    #[test]
-    fn existing_key() {
+    #[tokio::test]
+    async fn existing_key() {
         let frame = Frame::Array(vec![
             Frame::Bulk(Bytes::from("INCRBY")),
             Frame::Bulk(Bytes::from("key1")),
@@ -73,8 +73,8 @@ mod tests {
         assert_eq!(store.lock().unwrap().get("key1"), Some(&Bytes::from("30")));
     }
 
-    #[test]
-    fn non_existing_key() {
+    #[tokio::test]
+    async fn non_existing_key() {
         let frame = Frame::Array(vec![
             Frame::Bulk(Bytes::from("INCRBY")),
             Frame::Bulk(Bytes::from("key1")),
@@ -99,8 +99,8 @@ mod tests {
         assert_eq!(store.lock().unwrap().get("key1"), Some(&Bytes::from("10")));
     }
 
-    #[test]
-    fn invalid_key_type() {
+    #[tokio::test]
+    async fn invalid_key_type() {
         let frame = Frame::Array(vec![
             Frame::Bulk(Bytes::from("INCRBY")),
             Frame::Bulk(Bytes::from("key1")),
@@ -135,8 +135,8 @@ mod tests {
         );
     }
 
-    #[test]
-    fn out_of_range() {
+    #[tokio::test]
+    async fn out_of_range() {
         let frame = Frame::Array(vec![
             Frame::Bulk(Bytes::from("INCRBY")),
             Frame::Bulk(Bytes::from("key1")),

diff --git a/src/commands/incrbyfloat.rs b/src/commands/incrbyfloat.rs
@@ -54,8 +54,8 @@ mod tests {
     use crate::commands::Command;
     use bytes::Bytes;
 
-    #[test]
-    fn existing_key() {
+    #[tokio::test]
+    async fn existing_key() {
         let store = Arc::new(Mutex::new(Store::new()));
 
         let frame = Frame::Array(vec![
@@ -87,8 +87,8 @@ mod tests {
         );
     }
 
-    #[test]
-    fn non_existing_key() {
+    #[tokio::test]
+    async fn non_existing_key() {
         let store = Arc::new(Mutex::new(Store::new()));
 
         let frame = Frame::Array(vec![
@@ -112,8 +112,8 @@ mod tests {
         assert_eq!(store.lock().unwrap().get("key1"), Some(&Bytes::from("10")));
     }
 
-    #[test]
-    fn invalid_key_type() {
+    #[tokio::test]
+    async fn invalid_key_type() {
         let store = Arc::new(Mutex::new(Store::new()));
 
         let frame = Frame::Array(vec![

diff --git a/src/commands/keys.rs b/src/commands/keys.rs
@@ -47,8 +47,8 @@ mod tests {
     use crate::commands::{Command, CommandParserError};
     use bytes::Bytes;
 
-    #[test]
-    fn with_wildcard_pattern() {
+    #[tokio::test]
+    async fn with_wildcard_pattern() {
         let frame = Frame::Array(vec![
             Frame::Bulk(Bytes::from("KEYS")),
             Frame::Bulk(Bytes::from("*")),