Optimize redis tests --filter=[core]

Author: matyhtf

core-tests/include/redis_client.h

@@ -62,6 +62,7 @@ class RedisClient {
     bool Connect(const std::string &host = "127.0.0.1", int port = 6379, struct timeval timeout = {});
     std::string Get(const std::string &key);
     bool Set(const std::string &key, const std::string &value);
+    long Ttl(const std::string &key);
 };
 
 }  // namespace swoole

core-tests/src/_lib/redis.cpp

@@ -35,6 +35,18 @@ string RedisClient::Get(const string &key) {
     }
 }
 
+long RedisClient::Ttl(const std::string &key) {
+    const char *argv[] = {"TTL", key.c_str()};
+    size_t argvlen[] = {strlen(argv[0]), key.length()};
+
+    auto reply = Request(SW_ARRAY_SIZE(argv), argv, argvlen);
+    if (!reply.empty() && reply->integer) {
+        return reply->integer;
+    } else {
+        return 0;
+    }
+}
+
 bool RedisClient::Set(const string &key, const string &value) {
     const char *argv[] = {"SET", key.c_str(), value.c_str()};
     size_t argvlen[] = {strlen(argv[0]), key.length(), value.length()};

core-tests/src/protocol/redis.cpp

@@ -49,6 +49,7 @@ TEST(redis, server) {
     port->open_redis_protocol = true;
 
     serv.create();
+    std::unordered_map<std::string, std::string> redis_data;
 
     serv.onWorkerStart = [&](Server *serv, Worker *worker) {
         if (worker->id != 0) {
@@ -61,23 +62,48 @@ TEST(redis, server) {
                 ASSERT_TRUE(redis.Connect("127.0.0.1", serv->get_primary_port()->port));
                 ASSERT_TRUE(redis.Set(REDIS_TEST_KEY, REDIS_TEST_VALUE));
                 ASSERT_EQ(redis.Get(REDIS_TEST_KEY), REDIS_TEST_VALUE);
+
+                ASSERT_EQ(redis.Get(REDIS_TEST_KEY + "-not-exists"), "");
+
+                String rdata;
+                rdata.append_random_bytes(128 * 1024, true);
+                auto data = rdata.to_std_string();
+
+                ASSERT_TRUE(redis.Set(REDIS_TEST_KEY + "-big-key", data));
+                ASSERT_EQ(redis.Get(REDIS_TEST_KEY + "-big-key"), data);
+
+                ASSERT_EQ(redis.Ttl(REDIS_TEST_KEY), -1);
+
                 kill(serv->gs->master_pid, SIGTERM);
             },
             serv);
     };
 
-    serv.onReceive = [](Server *serv, RecvData *req) -> int {
+    serv.onReceive = [&redis_data](Server *serv, RecvData *req) -> int {
         int session_id = req->info.fd;
         auto list = redis::parse(req->data, req->info.len);
 
         String *buffer = sw_tg_buffer();
         buffer->clear();
 
         if (strcasecmp(list[0].c_str(), "GET") == 0) {
-            redis::format(buffer, redis::REPLY_STRING, REDIS_TEST_VALUE);
-            serv->send(session_id, buffer->str, buffer->length);
+            auto result = redis_data.find(list[1]);
+            if (result == redis_data.end()) {
+                redis::format_nil(buffer);
+                serv->send(session_id, buffer->str, buffer->length);
+            } else {
+                char buf[64];
+                auto n = snprintf(buf, sizeof(buf), "$%zu\r\n", result->second.length());
+                serv->send(session_id, buf, n);
+                serv->send(session_id, result->second.c_str(), result->second.length());
+                serv->send(session_id, SW_CRLF, SW_CRLF_LEN);
+            }
         } else if (strcasecmp(list[0].c_str(), "SET") == 0) {
             redis::format(buffer, redis::REPLY_STATUS, "OK");
+            redis_data[list[1]] = list[2];
+            serv->send(session_id, buffer->str, buffer->length);
+        }  else if (strcasecmp(list[0].c_str(), "TTL") == 0) {
+            redis::format(buffer, redis::REPLY_INT, -1);
             serv->send(session_id, buffer->str, buffer->length);
         }
 

include/swoole_redis.h

@@ -61,7 +61,7 @@ static sw_inline const char *get_number(const char *p, int *_ret) {
 
 int recv_packet(Protocol *protocol, Connection *conn, String *buffer);
 std::vector<std::string> parse(const char *data, size_t len);
-bool format(String *buf);
+bool format_nil(String *buf);
 bool format(String *buf, enum ReplyType type, const std::string &value);
 bool format(String *buf, enum ReplyType type, long value);
 

src/protocol/redis.cc

@@ -173,7 +173,7 @@ int recv_packet(Protocol *protocol, Connection *conn, String *buffer) {
     return SW_ERR;
 }
 
-bool format(String *buf) {
+bool format_nil(String *buf) {
     return buf->append(SW_STRL(SW_REDIS_RETURN_NIL)) == SW_OK;
 }