Implement integration tests

.github/workflows/ci.yml

@@ -5,7 +5,15 @@ name: CI
 jobs:
   check:
     name: Check
+
     runs-on: ubuntu-latest
+
+    services:
+      redis:
+        image: redis:latest
+        ports:
+          - 6379:6379
+
     steps:
       - name: Checkout sources
         uses: actions/checkout@v2

Cargo.toml

@@ -30,4 +30,5 @@ strum = "0.26.2"
 strum_macros = "0.26.2"
 
 [dev-dependencies]
+redis = "0.25.4"
 tokio = { version = "1.35.0", features = ["full", "test-util"] }

src/commands/get.rs

@@ -19,7 +19,7 @@ impl Executable for Get {
 
         match value {
             Some(value) => Ok(Frame::Bulk(value.clone())),
-            None => Ok(Frame::Null),
+            None => Ok(Frame::NullBulkString),
         }
     }
 }
@@ -83,6 +83,6 @@ mod tests {
 
         let res = cmd.exec(store.clone()).unwrap();
 
-        assert_eq!(res, Frame::Null);
+        assert_eq!(res, Frame::NullBulkString);
     }
 }

src/frame.rs

@@ -28,8 +28,13 @@ pub enum Frame {
     Error(String),
     Integer(i64),
     Bulk(Bytes),
-    Null,
     Array(Vec<Frame>),
+    // Whereas RESP3 has a dedicated data type for null values, RESP2 has no such type. Instead,
+    // due to historical reasons, the representation of null values in RESP2 is via predetermined
+    // forms of the bulk strings and arrays types.
+    Null,
+    NullBulkString,
+    NullArray,
 }
 
 // Protocol specification: https://redis.io/docs/reference/protocol-spec/
@@ -173,6 +178,20 @@ impl Frame {
                 bytes.extend_from_slice(CRLF);
                 bytes
             }
+            Frame::NullBulkString => {
+                let mut bytes = Vec::with_capacity(4);
+                bytes.push(u8::from(DataType::BulkString));
+                bytes.extend_from_slice("-1".as_bytes());
+                bytes.extend_from_slice(CRLF);
+                bytes
+            }
+            Frame::NullArray => {
+                let mut bytes = Vec::with_capacity(4);
+                bytes.push(u8::from(DataType::Array));
+                bytes.extend_from_slice("-1".as_bytes());
+                bytes.extend_from_slice(CRLF);
+                bytes
+            }
             Frame::Array(arr) => {
                 let length_str = arr.len().to_string();
                 let mut bytes = Vec::with_capacity(1 + length_str.len() + CRLF.len());
@@ -204,6 +223,8 @@ impl fmt::Display for Frame {
             Frame::Integer(i) => write!(f, ":{}", i),
             Frame::Bulk(bytes) => write!(f, "${}", String::from_utf8_lossy(bytes)),
             Frame::Null => write!(f, "$-1"),
+            Frame::NullBulkString => write!(f, "$-1"),
+            Frame::NullArray => write!(f, "*-1"),
             Frame::Array(arr) => {
                 write!(f, "*{}\r\n", arr.len())?;
                 for frame in arr {

src/server.rs

@@ -9,7 +9,7 @@ use crate::connection::Connection;
 use crate::store::Store;
 use crate::Error;
 
-const PORT: u16 = 6379;
+const PORT: u16 = 6378;
 
 pub async fn run() -> Result<(), Error> {
     let subscriber = tracing_subscriber::FmtSubscriber::new();

tests/integration.rs

@@ -0,0 +1,47 @@
+use redis::Connection;
+use redis::RedisError;
+use redis::Value;
+use rustdis::server::run;
+use tokio::time::{sleep, Duration};
+
+async fn connect() -> Result<(Connection, Connection), RedisError> {
+    tokio::spawn(async { run().await });
+    // Give the server some time to start.
+    sleep(Duration::from_millis(100)).await;
+
+    let our_client = redis::Client::open("redis://127.0.0.1:6378/")?;
+    let our_connection = our_client.get_connection()?;
+
+    let thir_client = redis::Client::open("redis://127.0.0.1:6379/")?;
+    let their_connection = thir_client.get_connection()?;
+
+    Ok((our_connection, their_connection))
+}
+
+#[tokio::test]
+async fn test_set_and_get() {
+    let (mut our_connection, mut their_connection) = connect().await.unwrap();
+
+    let pipeline = redis::pipe()
+        .cmd("SET")
+        .arg("key_1")
+        .arg(1)
+        .cmd("SET")
+        .arg("key_2")
+        .arg("Argentina")
+        .cmd("GET")
+        .arg("key_1")
+        .cmd("GET")
+        .arg("key_2")
+        .cmd("GET")
+        .arg("nonexistentkey")
+        .clone();
+
+    let our_response: (Value, Value, Value, Value, Value) =
+        pipeline.clone().query(&mut our_connection).unwrap();
+
+    let their_response: (Value, Value, Value, Value, Value) =
+        pipeline.clone().query(&mut their_connection).unwrap();
+
+    assert_eq!(our_response, their_response)
+}