chore(server): Better hash tests (Part 1) (#5922)

Author: dranikpg

src/server/hset_family_test.cc

@@ -17,7 +17,6 @@ extern "C" {
 using namespace testing;
 using namespace std;
 using namespace util;
-using namespace boost;
 using namespace facade;
 
 namespace dfly {
@@ -58,13 +57,76 @@ TEST_F(HSetFamilyTest, Basic) {
 }
 
 TEST_F(HSetFamilyTest, HSet) {
-  string val(1024, 'b');
+  // Simulate HSET on mirror map
+  {
+    absl::flat_hash_map<string, string> mirror;  // mirror
+
+    // Generate HSET commands and check how many new entries were added
+    absl::InsecureBitGen gen{};
+    while (mirror.size() < 600) {
+      vector<string> cmd = {"HSET", "hash"};
+      size_t new_values = 0;
+      for (int i = 0; i < 20; i++) {
+        string key = GetRandomHex(gen, 3);
+        string value = GetRandomHex(gen, 20, 10);
+        new_values += mirror.contains(key) ? 0 : 1;
+        mirror[key] = value;
+
+        cmd.emplace_back(key);
+        cmd.emplace_back(value);
+      }
+
+      EXPECT_THAT(Run(cmd), IntArg(new_values));
+    }
+
+    // Verify consistency
+    EXPECT_THAT(Run({"HLEN", "hash"}), IntArg(mirror.size()));
+    for (const auto& [key, value] : mirror)
+      EXPECT_EQ(Run({"HGET", "hash", key}), mirror[key]);
+  }
+
+  // HSet with same key twice
+  Run({"HSET", "hash", "key1", "value1", "key1", "value2"});
+  EXPECT_EQ(Run({"HGET", "hash", "key1"}), "value2");
+
+  // Wrong value cases
+  EXPECT_THAT(Run({"HSET", "key"}), ErrArg("wrong number of arguments"));
+  EXPECT_THAT(Run({"HSET", "key", "key"}), ErrArg("wrong number of arguments"));
+  EXPECT_THAT(Run({"HSET", "key", "key", "value", "key2"}), ErrArg("wrong number of arguments"));
+}
+
+TEST_F(HSetFamilyTest, HSetNX) {
+  // Should create new field
+  EXPECT_THAT(Run({"HSETNX", "hash", "key1", "value1"}), IntArg(1));
+  EXPECT_EQ(Run({"HGET", "hash", "key1"}), "value1");
+
+  // Should not overwrite
+  EXPECT_THAT(Run({"HSETNX", "hash", "key1", "value2"}), IntArg(0));
+  EXPECT_EQ(Run({"HGET", "hash", "key1"}), "value1");
+
+  // Wrong value cases
+  EXPECT_THAT(Run({"HSETNX", "key"}), ErrArg("wrong number of arguments"));
+  EXPECT_THAT(Run({"HSET", "key", "key"}), ErrArg("wrong number of arguments"));
+}
+
+// Listpack handles integers separately, so create a mix of different types
+TEST_F(HSetFamilyTest, MixedTypes) {
+  absl::flat_hash_set<string> str_keys, int_keys;
+  for (int i = 0; i < 100; i++) {
+    auto key1 = absl::StrCat("s", i);
+    auto key2 = absl::StrCat("i", i);
+    Run({"HSET", "hash", key1, "VALUE", key2, "123456"});
+    str_keys.emplace(key1);
+    int_keys.emplace(key2);
+  }
 
-  EXPECT_EQ(1, CheckedInt({"hset", "large", "a", val}));
-  EXPECT_EQ(1, CheckedInt({"hlen", "large"}));
-  EXPECT_EQ(1024, CheckedInt({"hstrlen", "large", "a"}));
+  for (string_view key : str_keys)
+    EXPECT_EQ(Run({{"HGET", "hash", key}}), "VALUE");
 
-  EXPECT_EQ(1, CheckedInt({"hset", "small", "", "565323349817"}));
+  for (string_view key : int_keys) {
+    EXPECT_EQ(Run({{"HGET", "hash", key}}), "123456");
+    EXPECT_EQ(CheckedInt({"hincrby", "hash", key, "1"}), 123456 + 1);
+  }
 }
 
 TEST_P(HestFamilyTestProtocolVersioned, Get) {
@@ -101,24 +163,22 @@ TEST_P(HestFamilyTestProtocolVersioned, Get) {
   EXPECT_THAT(resp.GetVec(), ElementsAre("a", "1", "b", "2", "c", "3"));
 }
 
-TEST_F(HSetFamilyTest, HSetNx) {
-  EXPECT_EQ(1, CheckedInt({"hsetnx", "key", "field", "val"}));
-  EXPECT_EQ(Run({"hget", "key", "field"}), "val");
-
-  EXPECT_EQ(0, CheckedInt({"hsetnx", "key", "field", "val2"}));
-  EXPECT_EQ(Run({"hget", "key", "field"}), "val");
-
-  EXPECT_EQ(1, CheckedInt({"hsetnx", "key", "field2", "val2"}));
-  EXPECT_EQ(Run({"hget", "key", "field2"}), "val2");
-
-  // check dict path
-  EXPECT_EQ(0, CheckedInt({"hsetnx", "key", "field2", string(512, 'a')}));
-  EXPECT_EQ(Run({"hget", "key", "field2"}), "val2");
-}
+TEST_F(HSetFamilyTest, HIncrBy) {
+  int total = 10;
+  // Check new field is created
+  EXPECT_EQ(CheckedInt({"hincrby", "key", "field", "10"}), 10);
+  EXPECT_EQ(Run({"hget", "key", "field"}), "10");
+  // Simulate multiple additions
+  for (int i = -100; i < 100; i += 7) {
+    total += i;
+    EXPECT_EQ(CheckedInt({"hincrby", "key", "field", to_string(i)}), total);
+  }
 
-TEST_F(HSetFamilyTest, HIncr) {
-  EXPECT_EQ(10, CheckedInt({"hincrby", "key", "field", "10"}));
+  // Overflow
+  Run({"hset", "key", "field2", to_string(numeric_limits<int64_t>::max() - 1)});
+  EXPECT_THAT(Run({"hincrby", "key", "field2", "2"}), ErrArg("would overflow"));
 
+  // Error case
   Run({"hset", "key", "a", " 1"});
   auto resp = Run({"hincrby", "key", "a", "10"});
   EXPECT_THAT(resp, ErrArg("hash value is not an integer"));

src/server/test_utils.cc

@@ -429,7 +429,7 @@ RespExpr BaseFamilyTest::RunPrivileged(std::initializer_list<const std::string_v
   return res;
 }
 
-RespExpr BaseFamilyTest::Run(absl::Span<std::string> span) {
+RespExpr BaseFamilyTest::Run(absl::Span<const std::string> span) {
   vector<string_view> sv_vec(span.size());
   for (unsigned i = 0; i < span.size(); ++i) {
     sv_vec[i] = span[i];

src/server/test_utils.h

@@ -81,7 +81,7 @@ class BaseFamilyTest : public ::testing::Test {
   RespExpr RunPrivileged(std::initializer_list<const std::string_view> list);
 
   RespExpr Run(ArgSlice list);
-  RespExpr Run(absl::Span<std::string> list);
+  RespExpr Run(absl::Span<const std::string> list);
 
   RespExpr Run(std::string_view id, ArgSlice list);