trying Box approach

Shopify · Aug 28, 2024 · a0dda25 · a0dda25
1 parent 34bb3f5
commit a0dda25
Show file tree

Hide file tree

Showing 4 changed files with 1,602 additions and 43 deletions.
diff --git a/src/lib.rs b/src/lib.rs
@@ -15,9 +15,7 @@ mod parser;
 use self::parser::{
     parse_ascii_metadump_response, parse_ascii_response, parse_ascii_stats_response, Response,
 };
-pub use self::parser::{
-    ErrorKind, KeyMetadata, MetadumpResponse, ParseInput, StatsResponse, Status, Value,
-};
+pub use self::parser::{ErrorKind, KeyMetadata, MetadumpResponse, StatsResponse, Status, Value, ParseInput};
 
 /// High-level memcached client.
 ///
@@ -180,6 +178,10 @@ impl Client {
         let kr = key.as_ref();
         let vr = value.parse_input();
 
+        // let vr = value.parse_input();
+
+        // println!("vr in set method: {:?}", vr.bytes());
+
         self.conn.write_all(b"set ").await?;
         self.conn.write_all(kr).await?;
 
@@ -537,12 +539,18 @@ impl<'a> MetadumpIter<'a> {
 mod tests {
     use super::*;
 
+    async fn setup_client() -> Client {
+        let client = Client::new("tcp://127.0.0.1:11211")
+            .await
+            .expect("Failed to connect to server");
+
+        client
+    }
+
     #[ignore = "Relies on a running memcached server"]
     #[tokio::test]
     async fn test_add() {
-        let mut client = Client::new("tcp://127.0.0.1:11211")
-            .await
-            .expect("Failed to connect to server");
+        let mut client = setup_client().await;
 
         let key = "async-memcache-test-key-add";
 
@@ -554,16 +562,81 @@ mod tests {
         assert!(result.is_ok());
     }
 
+    #[ignore = "Relies on a running memcached server"]
+    #[tokio::test]
+    async fn test_original_set() {
+        let mut client = setup_client().await;
+
+        let key = "original-set-key";
+        let value = "value";
+        let result = client.original_set(key, value, None, None).await;
+
+        assert!(result.is_ok());
+
+        let result = client.get(key).await;
+
+        assert!(result.is_ok());
+
+        let get_result = result.unwrap();
+
+        assert_eq!(String::from_utf8(get_result.unwrap().data).unwrap(), value);
+    }
+
+    #[ignore = "Relies on a running memcached server"]
+    #[tokio::test]
+    async fn test_new_set_with_string_value() {
+        let mut client = setup_client().await;
+
+        let key = "new-set-key";
+        let value = "value";
+        let result = client.set(key, value, None, None).await;
+
+        assert!(result.is_ok());
+
+        let result = client.get(key).await;
+
+        assert!(result.is_ok());
+
+        let get_result = result.unwrap();
+
+        assert_eq!(String::from_utf8(get_result.unwrap().data).unwrap(), value);
+    }
+
+    #[ignore = "Relies on a running memcached server"]
+    #[tokio::test]
+    async fn test_new_set_with_u64_value() {
+        let mut client = setup_client().await;
+
+        let key = "new-set-key-with-u64-value";
+        let value = 20;
+
+        println!("value: {}", value);
+        let result = client.set(key, value, None, None).await;
+
+        println!("result: {:?}", result);
+        assert!(result.is_ok());
+
+        let result = client.get(key).await;
+
+        assert!(result.is_ok());
+
+        let get_result = result.unwrap();
+
+        println!("get_result: {:?}", get_result);
+
+        println!("get_result.unwrap().data: {:?}", String::from_utf8(get_result.unwrap().data).unwrap());
+
+        assert!(1==2);
+    }
+
     #[ignore = "Relies on a running memcached server"]
     #[tokio::test]
     async fn test_delete() {
-        let mut client = Client::new("tcp://127.0.0.1:11211")
-            .await
-            .expect("Failed to connect to server");
+        let mut client = setup_client().await;
 
         let key = "async-memcache-test-key-delete";
 
-        let value = format!("{}", rand::random::<u64>());
+        let value = format!("{}",rand::random::<u64>());
         let result = client.set(key, value.as_str(), None, None).await;
 
         assert!(result.is_ok(), "failed to set {}, {:?}", key, result);
@@ -590,13 +663,11 @@ mod tests {
     #[ignore = "Relies on a running memcached server"]
     #[tokio::test]
     async fn test_delete_no_reply() {
-        let mut client = Client::new("tcp://127.0.0.1:11211")
-            .await
-            .expect("Failed to connect to server");
+        let mut client = setup_client().await;
 
         let key = "async-memcache-test-key-delete-no-reply";
 
-        let value = format!("{}", rand::random::<u64>());
+        let value = format!("{}",rand::random::<u64>());
         let result = client.set(key, value.as_str(), None, None).await;
 
         assert!(result.is_ok(), "failed to set {}, {:?}", key, result);
@@ -623,9 +694,7 @@ mod tests {
     #[ignore = "Relies on a running memcached server"]
     #[tokio::test]
     async fn test_increment_raises_error_when_key_doesnt_exist() {
-        let mut client = Client::new("tcp://127.0.0.1:11211")
-            .await
-            .expect("Failed to connect to server");
+        let mut client = setup_client().await;
 
         let key = "key-does-not-exist";
         let amount = 1;
@@ -639,9 +708,7 @@ mod tests {
     #[ignore = "Relies on a running memcached server"]
     #[tokio::test]
     async fn test_increments_existing_key() {
-        let mut client = Client::new("tcp://127.0.0.1:11211")
-            .await
-            .expect("Failed to connect to server");
+        let mut client = setup_client().await;
 
         let key = "key-to-increment";
         let value = 1;
@@ -661,9 +728,7 @@ mod tests {
     #[ignore = "Relies on a running memcached server"]
     #[tokio::test]
     async fn test_increment_can_overflow() {
-        let mut client = Client::new("tcp://127.0.0.1:11211")
-            .await
-            .expect("Failed to connect to server");
+        let mut client = setup_client().await;
 
         let key = "key-to-increment-overflow";
         let value = u64::MAX; // max value for u64
@@ -692,9 +757,7 @@ mod tests {
     #[ignore = "Relies on a running memcached server"]
     #[tokio::test]
     async fn test_increments_existing_key_with_no_reply() {
-        let mut client = Client::new("tcp://127.0.0.1:11211")
-            .await
-            .expect("Failed to connect to server");
+        let mut client = setup_client().await;
 
         let key = "key-to-increment-no-reply";
         let value = 1;
@@ -712,9 +775,7 @@ mod tests {
     #[ignore = "Relies on a running memcached server"]
     #[tokio::test]
     async fn test_decrement_raises_error_when_key_doesnt_exist() {
-        let mut client = Client::new("tcp://127.0.0.1:11211")
-            .await
-            .expect("Failed to connect to server");
+        let mut client = setup_client().await;
 
         let key = "fails-to-decrement";
         let amount = 1;
@@ -728,19 +789,13 @@ mod tests {
     #[ignore = "Relies on a running memcached server"]
     #[tokio::test]
     async fn test_decrements_existing_key() {
-        let mut client = Client::new("tcp://127.0.0.1:11211")
-            .await
-            .expect("Failed to connect to server");
+        let mut client = setup_client().await;
 
         let key = "key-to-decrement";
         let value = 10;
 
         let _ = client.set(key, value, None, None).await;
 
-        // let get_response = client.get("key-to-decrement").await;
-
-        // println!("get_response: {:?}", get_response);
-
         let amount = 1;
 
         let result = client.decrement(key, amount).await;
@@ -752,9 +807,7 @@ mod tests {
     #[ignore = "Relies on a running memcached server"]
     #[tokio::test]
     async fn test_decrement_does_not_reduce_value_below_zero() {
-        let mut client = Client::new("tcp://127.0.0.1:11211")
-            .await
-            .expect("Failed to connect to server");
+        let mut client = setup_client().await;
 
         let key = "key-to-decrement-past-zero";
         let value = 0;
@@ -772,9 +825,7 @@ mod tests {
     #[ignore = "Relies on a running memcached server"]
     #[tokio::test]
     async fn test_decrements_existing_key_with_no_reply() {
-        let mut client = Client::new("tcp://127.0.0.1:11211")
-            .await
-            .expect("Failed to connect to server");
+        let mut client = setup_client().await;
 
         let key = "key-to-decrement-no-reply";
         let value = 1;