Merge pull request #228 from codecrafters-io/data-type-assertion

Data Type Assertion

Author: UdeshyaDhungana

internal/anti_cheat.go

@@ -32,7 +32,7 @@ func antiCheatTest(stageHarness *test_case_harness.TestCaseHarness) error {
 	commandTestCase := test_cases.SendCommandTestCase{
 		Command:                   "MEMORY",
 		Args:                      []string{"DOCTOR"},
-		Assertion:                 resp_assertions.NewRegexStringAssertion("[sS]am"),
+		Assertion:                 resp_assertions.NewRegexBulkStringAssertion("[sS]am"),
 		ShouldSkipUnreadDataCheck: true,
 	}
 	err = commandTestCase.Run(client, logger)

internal/resp_assertions/array_element_assertion.go

@@ -12,8 +12,10 @@ type ArrayElementAssertion struct {
 }
 
 func (a ArrayElementAssertion) Run(value resp_value.Value) error {
-	if value.Type != resp_value.ARRAY {
-		return fmt.Errorf("Expected array, got %s", value.Type)
+	arrayTypeAssertion := DataTypeAssertion{ExpectedType: resp_value.ARRAY}
+
+	if err := arrayTypeAssertion.Run(value); err != nil {
+		return err
 	}
 
 	array := value.Array()

internal/resp_assertions/array_elements_assertion.go

@@ -1,7 +1,6 @@
 package resp_assertions
 
 import (
-	"fmt"
 	"slices"
 
 	resp_value "github.com/codecrafters-io/redis-tester/internal/resp/value"
@@ -18,8 +17,10 @@ type ArrayElementsAssertion struct {
 }
 
 func (a ArrayElementsAssertion) Run(value resp_value.Value) error {
-	if value.Type != resp_value.ARRAY {
-		return fmt.Errorf("Expected array, got %s", value.Type)
+	dataTypeAssertion := DataTypeAssertion{ExpectedType: resp_value.ARRAY}
+
+	if err := dataTypeAssertion.Run(value); err != nil {
+		return err
 	}
 
 	// Sort the indexes so the assertion runs serially

internal/resp_assertions/bulk_string_absent_from_array_assertion.go

@@ -11,8 +11,10 @@ type BulkStringAbsentFromArrayAssertion struct {
 }
 
 func (a BulkStringAbsentFromArrayAssertion) Run(value resp_value.Value) error {
-	if value.Type != resp_value.ARRAY {
-		return fmt.Errorf("Expected array, got %s", value.Type)
+	arrayTypeAssertion := DataTypeAssertion{ExpectedType: resp_value.ARRAY}
+
+	if err := arrayTypeAssertion.Run(value); err != nil {
+		return err
 	}
 
 	array := value.Array()

internal/resp_assertions/bulk_string_assertion.go

@@ -0,0 +1,29 @@
+package resp_assertions
+
+import (
+	"fmt"
+
+	resp_value "github.com/codecrafters-io/redis-tester/internal/resp/value"
+)
+
+type BulkStringAssertion struct {
+	ExpectedValue string
+}
+
+func NewBulkStringAssertion(expectedValue string) RESPAssertion {
+	return BulkStringAssertion{ExpectedValue: expectedValue}
+}
+
+func (a BulkStringAssertion) Run(value resp_value.Value) error {
+	bulkStringTypeAssertion := DataTypeAssertion{ExpectedType: resp_value.BULK_STRING}
+
+	if err := bulkStringTypeAssertion.Run(value); err != nil {
+		return err
+	}
+
+	if value.String() != a.ExpectedValue {
+		return fmt.Errorf("Expected %q, got %q", a.ExpectedValue, value.String())
+	}
+
+	return nil
+}

internal/resp_assertions/bulk_string_present_in_array_assertion.go

@@ -11,8 +11,10 @@ type BulkStringPresentInArrayAssertion struct {
 }
 
 func (a BulkStringPresentInArrayAssertion) Run(value resp_value.Value) error {
-	if value.Type != resp_value.ARRAY {
-		return fmt.Errorf("Expected array, got %s", value.Type)
+	arrayTypeAssertion := DataTypeAssertion{ExpectedType: resp_value.ARRAY}
+
+	if err := arrayTypeAssertion.Run(value); err != nil {
+		return err
 	}
 
 	array := value.Array()

internal/resp_assertions/command_assertion.go

@@ -20,8 +20,10 @@ func NewCommandAssertion(expectedCommand string, expectedArgs ...string) RESPAss
 }
 
 func (a CommandAssertion) Run(value resp_value.Value) error {
-	if value.Type != resp_value.ARRAY {
-		return fmt.Errorf("Expected array type, got %s", value.Type)
+	arrayTypeAssertion := DataTypeAssertion{ExpectedType: resp_value.ARRAY}
+
+	if err := arrayTypeAssertion.Run(value); err != nil {
+		return err
 	}
 
 	elements := value.Array()
@@ -30,8 +32,8 @@ func (a CommandAssertion) Run(value resp_value.Value) error {
 		return fmt.Errorf("Expected array with at least 1 element, got %d elements", len(elements))
 	}
 
-	if elements[0].Type != resp_value.SIMPLE_STRING && elements[0].Type != resp_value.BULK_STRING {
-		return fmt.Errorf("Expected first array element to be a string, got %s", elements[0].Type)
+	if elements[0].Type != resp_value.BULK_STRING {
+		return fmt.Errorf("Expected first array element to be a bulk string, got %s", elements[0].Type)
 	}
 
 	command := elements[0].String()
@@ -46,8 +48,8 @@ func (a CommandAssertion) Run(value resp_value.Value) error {
 
 	for i, expectedArg := range a.ExpectedArgs {
 		actualArg := elements[i+1]
-		if actualArg.Type != resp_value.SIMPLE_STRING && actualArg.Type != resp_value.BULK_STRING {
-			return fmt.Errorf("Expected argument %d to be a string, got %s", i+1, actualArg.Type)
+		if actualArg.Type != resp_value.BULK_STRING {
+			return fmt.Errorf("Expected argument %d to be a bulk string, got %s", i+1, actualArg.Type)
 		}
 
 		if actualArg.String() != expectedArg {

internal/resp_assertions/data_type_assertion.go

@@ -11,8 +11,22 @@ type DataTypeAssertion struct {
 }
 
 func (a DataTypeAssertion) Run(value resp_value.Value) error {
+	dataTypeHint := ""
+
+	switch a.ExpectedType {
+	case resp_value.NIL:
+		dataTypeHint = "$-1\r\n"
+	case resp_value.NIL_ARRAY:
+		dataTypeHint = "*-1\r\n"
+	}
+
+	// Spacing
+	if dataTypeHint != "" {
+		dataTypeHint = " " + dataTypeHint
+	}
+
 	if value.Type != a.ExpectedType {
-		return fmt.Errorf("Expected %s, found %s", a.ExpectedType, value.Type)
+		return fmt.Errorf("Expected %s%s, found %s", a.ExpectedType, dataTypeHint, value.Type)
 	}
 	return nil
 }

internal/resp_assertions/error_assertion.go

@@ -15,8 +15,10 @@ func NewErrorAssertion(expectedValue string) RESPAssertion {
 }
 
 func (a ErrorAssertion) Run(value resp_value.Value) error {
-	if value.Type != resp_value.ERROR {
-		return fmt.Errorf("Expected error, got %s", value.Type)
+	respErrorTypeAssertion := DataTypeAssertion{ExpectedType: resp_value.ERROR}
+
+	if err := respErrorTypeAssertion.Run(value); err != nil {
+		return err
 	}
 
 	if value.Error() != a.ExpectedValue {

internal/resp_assertions/floating_point_bulk_string_assertion.go

@@ -21,8 +21,10 @@ func NewFloatingPointBulkStringAssertion(expectedValue float64, tolerance float6
 }
 
 func (a FloatingPointBulkStringAssertion) Run(value resp_value.Value) error {
-	if value.Type != resp_value.BULK_STRING {
-		return fmt.Errorf("Expected bulk string, got %s", value.Type)
+	bulkStringTypeAssertion := DataTypeAssertion{ExpectedType: resp_value.BULK_STRING}
+
+	if err := bulkStringTypeAssertion.Run(value); err != nil {
+		return err
 	}
 
 	stringValue := value.String()