#1022 Command Migration: ('HEXISTS', 'HKEYS', 'HVALS')

go.sum

@@ -30,8 +30,6 @@ github.com/dgryski/go-metro v0.0.0-20211217172704-adc40b04c140 h1:y7y0Oa6UawqTFP
 github.com/dgryski/go-metro v0.0.0-20211217172704-adc40b04c140/go.mod h1:c9O8+fpSOX1DM8cPNSkX/qsBWdkD4yd2dpciOWQjpBw=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
-github.com/dicedb/go-dice v0.0.0-20241008164514-476ca02cf6b9 h1:e8fYQMtzhtbY29pTM5b1V5ll11YH4DswftICadMeAJw=
-github.com/dicedb/go-dice v0.0.0-20241008164514-476ca02cf6b9/go.mod h1:8+VZrr14c2LW8fW4tWZ8Bv3P2lfvlg+PpsSn5cWWuiQ=
 github.com/dicedb/go-dice v0.0.0-20241008182110-fc365d560804 h1:13mgInfjInxupefIfs2rvOQgvwiGO9E6wx2+rKFEUAo=
 github.com/dicedb/go-dice v0.0.0-20241008182110-fc365d560804/go.mod h1:8+VZrr14c2LW8fW4tWZ8Bv3P2lfvlg+PpsSn5cWWuiQ=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=

integration_tests/commands/async/bitfield_test.go

@@ -11,7 +11,7 @@ func TestBitfield(t *testing.T) {
 	conn := getLocalConnection()
 	defer conn.Close()
 
-        FireCommand(conn, "FLUSHDB")
+	FireCommand(conn, "FLUSHDB")
 	defer FireCommand(conn, "FLUSHDB") // clean up after all test cases
 	syntaxErrMsg := "ERR syntax error"
 	bitFieldTypeErrMsg := "ERR Invalid bitfield type. Use something like i16 u8. Note that u64 is not supported but i64 is."

integration_tests/commands/async/check_type_test.go

@@ -14,8 +14,8 @@ func TestErrorsForSetData(t *testing.T) {
 
 	setErrorMsg := "WRONGTYPE Operation against a key holding the wrong kind of value"
 	testCases := []struct {
-		name        string
-		cmd         []string
+		name       string
+		cmd        []string
 		expected   []interface{}
 		assertType []string
 		delay      []time.Duration

integration_tests/commands/async/del_test.go

@@ -50,4 +50,4 @@ func TestDel(t *testing.T) {
 			}
 		})
 	}
-}
+}

integration_tests/commands/async/dump_test.go

@@ -38,8 +38,8 @@ func TestDumpRestore(t *testing.T) {
 						return false
 					}
 					return len(decoded) > 11 &&
-						decoded[0] == 0x09 && 
-						decoded[1] == 0x00 && 
+						decoded[0] == 0x09 &&
+						decoded[1] == 0x00 &&
 						string(decoded[6:11]) == "hello" &&
 						decoded[11] == 0xFF
 				},

integration_tests/commands/async/hkeys_test.go

@@ -31,7 +31,7 @@ func TestHKEYS(t *testing.T) {
 			name:     "HKEYS with wrong number of arguments",
 			commands: []string{"HKEYS key_hkeys03 x", "HKEYS"},
 			expected: []interface{}{"ERR wrong number of arguments for 'hkeys' command",
-					"ERR wrong number of arguments for 'hkeys' command"},
+				"ERR wrong number of arguments for 'hkeys' command"},
 		},
 	}
 
@@ -45,4 +45,4 @@ func TestHKEYS(t *testing.T) {
 			}
 		}
 	}
-}
+}

integration_tests/commands/async/hsetnx_test.go

@@ -1,38 +1,38 @@
-package async
-
-import (
-	"testing"
-
-	"gotest.tools/v3/assert"
-)
-
-func TestHSETNX(t *testing.T) {
-	conn := getLocalConnection()
-	defer conn.Close()
-
-	testCases := []TestCase{
-		{
-			commands: []string{"HSETNX key_nx_t1 field value", "HSET key_nx_t1 field value_new"},
-			expected: []interface{}{ONE, ZERO},
-		},
-		{
-			commands: []string{"HSETNX key_nx_t2 field1 value1"},
-			expected: []interface{}{ONE},
-		},
-		{
-			commands: []string{"HSETNX key_nx_t3 field value", "HSETNX key_nx_t3 field new_value", "HSETNX key_nx_t3"},
-			expected: []interface{}{ONE, ZERO, "ERR wrong number of arguments for 'hsetnx' command"},
-		},
-		{
-			commands: []string{"SET key_nx_t4 v", "HSETNX key_nx_t4 f v"},
-			expected: []interface{}{"OK", "WRONGTYPE Operation against a key holding the wrong kind of value"},
-		},
-	}
-
-	for _, tc := range testCases {
-		for i, cmd := range tc.commands {
-			result := FireCommand(conn, cmd)
-			assert.DeepEqual(t, tc.expected[i], result)
-		}
-	}
-}
+package async
+
+import (
+	"testing"
+
+	"gotest.tools/v3/assert"
+)
+
+func TestHSETNX(t *testing.T) {
+	conn := getLocalConnection()
+	defer conn.Close()
+
+	testCases := []TestCase{
+		{
+			commands: []string{"HSETNX key_nx_t1 field value", "HSET key_nx_t1 field value_new"},
+			expected: []interface{}{ONE, ZERO},
+		},
+		{
+			commands: []string{"HSETNX key_nx_t2 field1 value1"},
+			expected: []interface{}{ONE},
+		},
+		{
+			commands: []string{"HSETNX key_nx_t3 field value", "HSETNX key_nx_t3 field new_value", "HSETNX key_nx_t3"},
+			expected: []interface{}{ONE, ZERO, "ERR wrong number of arguments for 'hsetnx' command"},
+		},
+		{
+			commands: []string{"SET key_nx_t4 v", "HSETNX key_nx_t4 f v"},
+			expected: []interface{}{"OK", "WRONGTYPE Operation against a key holding the wrong kind of value"},
+		},
+	}
+
+	for _, tc := range testCases {
+		for i, cmd := range tc.commands {
+			result := FireCommand(conn, cmd)
+			assert.DeepEqual(t, tc.expected[i], result)
+		}
+	}
+}

integration_tests/commands/async/hvals_test.go

@@ -1,9 +1,10 @@
 package async
 
 import (
-	testifyAssert "github.com/stretchr/testify/assert"
 	"testing"
 
+	testifyAssert "github.com/stretchr/testify/assert"
+
 	"gotest.tools/v3/assert"
 )
 
@@ -26,12 +27,12 @@ func TestHvals(t *testing.T) {
 		{
 			name:     "HVALS on wrong key type",
 			commands: []string{"SET hvalsKey02 field", "HVALS hvalsKey02"},
-			expected: []interface{}{"OK", "WRONGTYPE Operation against a key holding the wrong kind of value"},
+			expected: []interface{}{"OK", "ERR -WRONGTYPE Operation against a key holding the wrong kind of value"},
 		},
 		{
 			name:     "HVALS with wrong number of arguments",
 			commands: []string{"HVALS hvalsKey03 x", "HVALS"},
-			expected: []interface{}{"ERR wrong number of arguments for 'hvals' command", "ERR wrong number of arguments for 'hvals' command"},
+			expected: []interface{}{"ERR wrong number of arguments for 'HVALS' command", "ERR wrong number of arguments for 'HVALS' command"},
 		},
 	}
 

integration_tests/commands/async/json_arrpop_test.go

@@ -19,9 +19,9 @@ func TestJSONARRPOP(t *testing.T) {
 	testCases := []struct {
 		name        string
 		commands    []string
-		expected   []interface{}
-		assertType []string
-		jsonResp   []bool
+		expected    []interface{}
+		assertType  []string
+		jsonResp    []bool
 		nestedArray bool
 		path        string
 	}{

integration_tests/commands/async/mget_test.go

@@ -13,7 +13,7 @@ func TestMGET(t *testing.T) {
 
 	defer FireCommand(conn, "DEL k1")
 	defer FireCommand(conn, "DEL k2")
-	
+
 	testCases := []struct {
 		name     string
 		commands []string

integration_tests/commands/async/object_test.go

@@ -12,8 +12,8 @@ func TestObjectCommand(t *testing.T) {
 	defer conn.Close()
 
 	testCases := []struct {
-		name        string
-		commands    []string
+		name       string
+		commands   []string
 		expected   []interface{}
 		assertType []string
 		delay      []time.Duration

integration_tests/commands/async/ttl_pttl_test.go

@@ -12,8 +12,8 @@ func TestTTLPTTL(t *testing.T) {
 	defer conn.Close()
 
 	testCases := []struct {
-		name        string
-		commands    []string
+		name       string
+		commands   []string
 		expected   []interface{}
 		assertType []string
 		delay      []time.Duration

integration_tests/commands/http/hexists_test.go

@@ -0,0 +1,51 @@
+package http
+
+import (
+	"testing"
+
+	"gotest.tools/v3/assert"
+)
+
+func TestHExists(t *testing.T) {
+	cmdExec := NewHTTPCommandExecutor()
+
+	testCases := []TestCase{
+		{
+			name: "HTTP Check if field exists when k f and v are set",
+			commands: []HTTPCommand{
+				{Command: "HSET", Body: map[string]interface{}{"key": "k", "field": "f", "value": "v"}},
+				{Command: "HEXISTS", Body: map[string]interface{}{"key": "k", "field": "f"}},
+			},
+			expected: []interface{}{float64(1), "1"},
+		},
+		{
+			name: "HTTP Check if field exists when k exists but not f and v",
+			commands: []HTTPCommand{
+				{Command: "HSET", Body: map[string]interface{}{"key": "k", "field": "f1", "value": "v"}},
+				{Command: "HEXISTS", Body: map[string]interface{}{"key": "k", "field": "f"}},
+			},
+			expected: []interface{}{float64(1), "0"},
+		},
+		{
+			name: "HTTP Check if field exists when no k,f and v exist",
+			commands: []HTTPCommand{
+				{Command: "HEXISTS", Body: map[string]interface{}{"key": "k", "field": "f"}},
+			},
+			expected: []interface{}{"0"},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			cmdExec.FireCommand(HTTPCommand{
+				Command: "HDEL",
+				Body:    map[string]interface{}{"key": "k", "field": "f"},
+			})
+
+			for i, cmd := range tc.commands {
+				result, _ := cmdExec.FireCommand(cmd)
+				assert.DeepEqual(t, tc.expected[i], result)
+			}
+		})
+	}
+}

integration_tests/commands/http/hkeys_test.go

@@ -0,0 +1,49 @@
+package http
+
+import (
+	"testing"
+
+	"gotest.tools/v3/assert"
+)
+
+func TestHKeys(t *testing.T) {
+	cmdExec := NewHTTPCommandExecutor()
+
+	testCases := []TestCase{
+		{
+			name: "HTTP One or more keys exist",
+			commands: []HTTPCommand{
+				{Command: "HSET", Body: map[string]interface{}{"key": "k", "field": "f", "value": "v"}},
+				{Command: "HSET", Body: map[string]interface{}{"key": "k", "field": "f1", "value": "v"}},
+				{Command: "HKEYS", Body: map[string]interface{}{"key": "k"}},
+			},
+			expected: []interface{}{float64(1), float64(1), []interface{}{"f", "f1"}},
+		},
+		{
+			name: "HTTP No keys exist",
+			commands: []HTTPCommand{
+				{Command: "HKEYS", Body: map[string]interface{}{"key": "k"}},
+			},
+			expected: []interface{}{nil},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			cmdExec.FireCommand(HTTPCommand{
+				Command: "HDEL",
+				Body:    map[string]interface{}{"key": "k", "field": "f"},
+			})
+			cmdExec.FireCommand(HTTPCommand{
+				Command: "HDEL",
+				Body:    map[string]interface{}{"key": "k", "field": "f1"},
+			})
+
+			for i, cmd := range tc.commands {
+				result, _ := cmdExec.FireCommand(cmd)
+				// fmt.Printf("%v | %v\n", result, tc.expected[i])
+				assert.DeepEqual(t, tc.expected[i], result)
+			}
+		})
+	}
+}

integration_tests/commands/http/hvals_test.go

@@ -0,0 +1,50 @@
+package http
+
+import (
+	"fmt"
+	"testing"
+
+	"gotest.tools/v3/assert"
+)
+
+func TestHVals(t *testing.T) {
+	cmdExec := NewHTTPCommandExecutor()
+
+	testCases := []TestCase{
+		{
+			name: "HTTP One or more keys exist",
+			commands: []HTTPCommand{
+				{Command: "HSET", Body: map[string]interface{}{"key": "k", "field": "f", "value": "v"}},
+				{Command: "HSET", Body: map[string]interface{}{"key": "k", "field": "f1", "value": "v1"}},
+				{Command: "HVALS", Body: map[string]interface{}{"key": "k"}},
+			},
+			expected: []interface{}{float64(1), float64(1), []interface{}{"v", "v1"}},
+		},
+		{
+			name: "HTTP No keys exist",
+			commands: []HTTPCommand{
+				{Command: "HVALS", Body: map[string]interface{}{"key": "k"}},
+			},
+			expected: []interface{}{[]interface{}{}},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			cmdExec.FireCommand(HTTPCommand{
+				Command: "HDEL",
+				Body:    map[string]interface{}{"key": "k", "field": "f"},
+			})
+			cmdExec.FireCommand(HTTPCommand{
+				Command: "HDEL",
+				Body:    map[string]interface{}{"key": "k", "field": "f1"},
+			})
+
+			for i, cmd := range tc.commands {
+				result, _ := cmdExec.FireCommand(cmd)
+				fmt.Printf("%v | %v\n", result, tc.expected[i])
+				assert.DeepEqual(t, tc.expected[i], result)
+			}
+		})
+	}
+}