refactor: enhance XReadResponseAssertion with ToSerializable method for improved serialization of response values

Author: andy1li

internal/resp/value/value.go

@@ -125,3 +125,19 @@ func (v *Value) FormattedString() string {
 
 	return ""
 }
+
+func (v Value) ToSerializable() interface{} {
+	switch v.Type {
+	case BULK_STRING:
+		return v.String()
+	case ARRAY:
+		arr := v.Array()
+		result := make([]interface{}, len(arr))
+		for i, elem := range arr {
+			result[i] = elem.ToSerializable()
+		}
+		return result
+	default:
+		return v.String()
+	}
+}

internal/resp_assertions/xread_response_assertion.go

@@ -3,7 +3,6 @@ package resp_assertions
 import (
 	"encoding/json"
 	"fmt"
-	"reflect"
 
 	resp_value "github.com/codecrafters-io/redis-tester/internal/resp/value"
 )
@@ -31,72 +30,53 @@ func (a XReadResponseAssertion) Run(value resp_value.Value) error {
 		return fmt.Errorf("Expected array, got %s", value.Type)
 	}
 
-	expected := a.normalizeExpected()
-	actual := normalizeActual(value)
+	expected := a.buildExpected().ToSerializable()
+	actual := value.ToSerializable()
 
-	if !reflect.DeepEqual(expected, actual) {
-		expectedJSON, err := json.MarshalIndent(expected, "", "  ")
-		if err != nil {
-			return fmt.Errorf("failed to marshal expected value: %w", err)
-		}
-		actualJSON, err := json.MarshalIndent(actual, "", "  ")
-		if err != nil {
-			return fmt.Errorf("failed to marshal actual value: %w", err)
-		}
+	expectedJSON, err := json.MarshalIndent(expected, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal expected value: %w", err)
+	}
+	actualJSON, err := json.MarshalIndent(actual, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal actual value: %w", err)
+	}
+
+	if string(expectedJSON) != string(actualJSON) {
 		return fmt.Errorf("XREAD response mismatch:\nExpected:\n%s\nGot:\n%s", expectedJSON, actualJSON)
 	}
 
 	return nil
 }
 
-func (a XReadResponseAssertion) normalizeExpected() []interface{} {
-	result := make([]interface{}, len(a.ExpectedStreamResponses))
-
+func (a XReadResponseAssertion) buildExpected() resp_value.Value {
+	streams := make([]resp_value.Value, len(a.ExpectedStreamResponses))
 	for i, stream := range a.ExpectedStreamResponses {
-		entries := make([][]interface{}, 0, len(stream.Entries))
-		for _, entry := range stream.Entries {
-			flatPairs := make([]string, 0, len(entry.FieldValuePairs)*2)
-			for _, pair := range entry.FieldValuePairs {
-				flatPairs = append(flatPairs, pair[0], pair[1])
-			}
-			entries = append(entries, []interface{}{entry.Id, flatPairs})
-		}
-		result[i] = []interface{}{stream.Key, entries}
+		streams[i] = stream.toRESPValue()
 	}
+	return resp_value.NewArrayValue(streams)
+}
 
-	return result
+func (s StreamResponse) toRESPValue() resp_value.Value {
+	entries := make([]resp_value.Value, len(s.Entries))
+	for i, entry := range s.Entries {
+		entries[i] = entry.toRESPValue()
+	}
+	return resp_value.NewArrayValue([]resp_value.Value{
+		resp_value.NewBulkStringValue(s.Key),
+		resp_value.NewArrayValue(entries),
+	})
 }
 
-func normalizeActual(v resp_value.Value) interface{} {
-	switch v.Type {
-	case resp_value.BULK_STRING:
-		return v.String()
-	case resp_value.ARRAY:
-		arr := v.Array()
-		result := make([]interface{}, len(arr))
-		for i, elem := range arr {
-			// Special handling for stream entries (second element of the outer array)
-			if i == 1 && len(arr) == 2 {
-				entries := elem.Array()
-				typedEntries := make([][]interface{}, len(entries))
-				for j, entry := range entries {
-					entryArr := entry.Array()
-					if len(entryArr) == 2 {
-						fvPairs := entryArr[1].Array()
-						strPairs := make([]string, len(fvPairs))
-						for k, pair := range fvPairs {
-							strPairs[k] = pair.String()
-						}
-						typedEntries[j] = []interface{}{normalizeActual(entryArr[0]), strPairs}
-					}
-				}
-				result[i] = typedEntries
-				continue
-			}
-			result[i] = normalizeActual(elem)
+func (e StreamEntry) toRESPValue() resp_value.Value {
+	var fieldValues []resp_value.Value
+	for _, pair := range e.FieldValuePairs {
+		for _, v := range pair {
+			fieldValues = append(fieldValues, resp_value.NewBulkStringValue(v))
 		}
-		return result
-	default:
-		return v.String()
 	}
+	return resp_value.NewArrayValue([]resp_value.Value{
+		resp_value.NewBulkStringValue(e.Id),
+		resp_value.NewArrayValue(fieldValues),
+	})
 }