fix(postgres): handle UUID byte array comparison in table assertions

PostgreSQL returns UUID columns as []byte when scanned into interface{}.
The previous implementation used fmt.Sprintf("%v", v) which converts
[]byte to its array representation like "[49 49 49 ...]" instead of
the actual string content.

This caused table assertion failures when comparing UUID values:
- Expected: "11111111-1111-4111-a111-111111111111"
- Got: "[49 49 49 49 49 49 49 49 45 ...]"

The fix adds a formatDBValue() helper function that properly converts
[]byte to string, enabling correct UUID comparisons in "contains" steps.

Author: alileza

internal/handler/postgres.go

@@ -266,7 +266,7 @@ func (r *Postgres) tableShouldContain(table string, expected *godog.Table) error
 		}
 		row := make([]string, len(columns))
 		for i, v := range values {
-			row[i] = fmt.Sprintf("%v", v)
+			row[i] = formatDBValue(v)
 		}
 		actual = append(actual, row)
 	}
@@ -338,5 +338,22 @@ func (r *Postgres) Cleanup(ctx context.Context) error {
 	return nil
 }
 
+// formatDBValue converts a database value to its string representation.
+// This handles special types like []byte (used for UUIDs) that need
+// to be converted to strings rather than byte array representations.
+func formatDBValue(v interface{}) string {
+	if v == nil {
+		return "<nil>"
+	}
+	switch val := v.(type) {
+	case []byte:
+		// PostgreSQL returns UUIDs and other binary types as []byte
+		// Convert to string for proper comparison
+		return string(val)
+	default:
+		return fmt.Sprintf("%v", v)
+	}
+}
+
 var _ Handler = (*Postgres)(nil)
 var _ SQLExecutor = (*Postgres)(nil)

internal/handler/postgres_test.go

@@ -0,0 +1,66 @@
+package handler
+
+import "testing"
+
+func TestFormatDBValue(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    interface{}
+		expected string
+	}{
+		{
+			name:     "nil value",
+			input:    nil,
+			expected: "<nil>",
+		},
+		{
+			name:     "string value",
+			input:    "hello",
+			expected: "hello",
+		},
+		{
+			name:     "int value",
+			input:    42,
+			expected: "42",
+		},
+		{
+			name:     "bool true",
+			input:    true,
+			expected: "true",
+		},
+		{
+			name:     "bool false",
+			input:    false,
+			expected: "false",
+		},
+		{
+			name:     "byte slice (UUID)",
+			input:    []byte("11111111-1111-4111-a111-111111111111"),
+			expected: "11111111-1111-4111-a111-111111111111",
+		},
+		{
+			name:     "byte slice (simple string)",
+			input:    []byte("hello world"),
+			expected: "hello world",
+		},
+		{
+			name:     "empty byte slice",
+			input:    []byte{},
+			expected: "",
+		},
+		{
+			name:     "float value",
+			input:    3.14,
+			expected: "3.14",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := formatDBValue(tt.input)
+			if result != tt.expected {
+				t.Errorf("formatDBValue(%v) = %q, want %q", tt.input, result, tt.expected)
+			}
+		})
+	}
+}