feat(tests): Unit tests for all commands

Signed-off-by: Ankush Chavan <cankush625@gmail.com>

Author: cankush625

cmd/command_test.go

@@ -0,0 +1,26 @@
+package cmd
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+)
+
+// TestCommand tests the Command function for
+// all possible valid and invalid inputs
+func TestCommand(t *testing.T) {
+	tests := []struct {
+		command []string
+		want    []byte
+		wantErr error
+	}{
+		{[]string{"COMMAND"}, []byte("+\r\n"), nil},
+		{[]string{"COMMAND", "DOCS"}, []byte("+OK\r\n"), nil},
+		{[]string{"COMMAND", "DOCS", "random_arg"}, []byte("+OK\r\n"), nil},
+	}
+	for _, test := range tests {
+		if got, gotErr := Command(test.command); !reflect.DeepEqual(got, test.want) || !errors.Is(gotErr, test.wantErr) {
+			t.Errorf("Command(%v) = %v, %v", test.command, got, gotErr)
+		}
+	}
+}

cmd/echo_test.go

@@ -0,0 +1,25 @@
+package cmd
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+)
+
+// TestEcho tests the Echo function for
+// all possible valid and invalid inputs
+func TestEcho(t *testing.T) {
+	tests := []struct {
+		command []string
+		want    []byte
+		wantErr error
+	}{
+		{[]string{"ECHO", "hello"}, []byte("+hello\r\n"), nil},
+		{[]string{"ECHO"}, []byte("-message is required\r\n"), MessageRequiredError},
+	}
+	for _, test := range tests {
+		if got, gotErr := Echo(test.command); !reflect.DeepEqual(got, test.want) || !errors.Is(gotErr, test.wantErr) {
+			t.Errorf("Echo(%v) = %v, %v", test.command, got, gotErr)
+		}
+	}
+}

cmd/get_test.go

@@ -0,0 +1,33 @@
+package cmd
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+)
+
+// TestGet tests the Get function for
+// all possible valid and invalid inputs
+func TestGet(t *testing.T) {
+	// Prepare
+	// Insert a key in the cache
+	_, _ = Set([]string{"SET", "tenant", "ACME"})
+	tests := []struct {
+		command []string
+		want    []byte
+		wantErr error
+	}{
+		// Key exists in the cache
+		{[]string{"GET", "tenant"}, []byte("+ACME\r\n"), nil},
+		// Key doesn't exist in the cache
+		{[]string{"GET", "org"}, []byte("$-1\r\n"), nil},
+		// Wrong number of arguments to the GET command
+		{[]string{"GET"}, []byte("-wrong number of arguments\r\n"), WrongNumberOfArgumentsError},
+		{[]string{"GET", "tenant", "random_arg"}, []byte("-wrong number of arguments\r\n"), WrongNumberOfArgumentsError},
+	}
+	for _, test := range tests {
+		if got, gotErr := Get(test.command); !reflect.DeepEqual(got, test.want) || !errors.Is(gotErr, test.wantErr) {
+			t.Errorf("Get(%v) = %v, %v", test.command, got, gotErr)
+		}
+	}
+}

cmd/ping_test.go

@@ -0,0 +1,26 @@
+package cmd
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+)
+
+// TestPing tests the Ping function for
+// all possible valid and invalid inputs
+func TestPing(t *testing.T) {
+	tests := []struct {
+		command []string
+		want    []byte
+		wantErr error
+	}{
+		{[]string{"PING"}, []byte("+PONG\r\n"), nil},
+		{[]string{"PING", "Hello"}, []byte("+Hello\r\n"), nil},
+		{[]string{"PING", "hello"}, []byte("+hello\r\n"), nil},
+	}
+	for _, test := range tests {
+		if got, gotErr := Ping(test.command); !reflect.DeepEqual(got, test.want) || !errors.Is(gotErr, test.wantErr) {
+			t.Errorf("Ping(%v) = %v, %v", test.command, got, gotErr)
+		}
+	}
+}

cmd/set_test.go

@@ -0,0 +1,27 @@
+package cmd
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+)
+
+// TestSet tests the Set function for
+// all possible valid and invalid inputs
+func TestSet(t *testing.T) {
+	tests := []struct {
+		command []string
+		want    []byte
+		wantErr error
+	}{
+		{[]string{"SET", "tenant", "ACME"}, []byte("+OK\r\n"), nil},
+		{[]string{"SET", "tenant"}, []byte("-missing arguments\r\n"), MissingArgumentsError},
+		{[]string{"SET"}, []byte("-missing arguments\r\n"), MissingArgumentsError},
+		{[]string{"SET", "tenant", "ACME", "asd"}, []byte("-syntax error\r\n"), SyntaxError},
+	}
+	for _, test := range tests {
+		if got, gotErr := Set(test.command); !reflect.DeepEqual(got, test.want) || !errors.Is(gotErr, test.wantErr) {
+			t.Errorf("Set(%v) = %v, %v", test.command, got, gotErr)
+		}
+	}
+}

exc/command_executor.go

@@ -3,10 +3,12 @@ package exc
 import (
 	"HelixDB/cmd"
 	"HelixDB/common"
-	"fmt"
+	"errors"
 	"strings"
 )
 
+var UnsupportedCommand = errors.New("unsupported command")
+
 func ExecuteCommand(command []string) ([]byte, error) {
 	switch strings.ToUpper(command[0]) {
 	case common.Ping:
@@ -20,5 +22,5 @@ func ExecuteCommand(command []string) ([]byte, error) {
 	case common.Set:
 		return cmd.Set(command)
 	}
-	return []byte("-unsupported command\r\n"), fmt.Errorf("unsupported command")
+	return []byte("-unsupported command\r\n"), UnsupportedCommand
 }

exc/command_executor_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 // TestExecuteCommand tests the ExecuteCommand function for
-// all possible valid inputs
+// all possible valid and invalid inputs
 func TestExecuteCommand(t *testing.T) {
 	tests := []struct {
 		command []string
@@ -37,6 +37,7 @@ func TestExecuteCommand(t *testing.T) {
 		{[]string{"GET"}, []byte("-wrong number of arguments\r\n"), cmd.WrongNumberOfArgumentsError},
 		{[]string{"GET", "tenant", "random_arg"}, []byte("-wrong number of arguments\r\n"), cmd.WrongNumberOfArgumentsError},
 		// Unsupported/Invalid command
+		{[]string{"UNSUPPORTED"}, []byte("-unsupported command\r\n"), UnsupportedCommand},
 	}
 	for _, test := range tests {
 		if got, gotErr := ExecuteCommand(test.command); !reflect.DeepEqual(got, test.want) || !errors.Is(gotErr, test.wantErr) {

resp/parser_test.go

@@ -8,7 +8,7 @@ import (
 )
 
 // TestParseCommand tests the ParseCommand function for
-// all possible valid inputs
+// all possible valid and invalid inputs
 func TestParseCommand(t *testing.T) {
 	tests := []struct {
 		command []byte