fix: acceptance tests - response_status_codes as strings, filter rule assertions

- Send response_status_codes as []string per API (RetryRule schema)
- normalizeRulesForAPI: convert numeric codes to strings for --rules/--rules-file
- assertFilterRuleFieldMatches: accept body/headers as string or map from API
- assertResponseStatusCodesMatch: accept codes as string or number in responses
- Update comments to avoid referencing local-only OpenAPI file

Made-with: Cursor

Author: leggetter

pkg/cmd/connection_common.go

@@ -103,7 +103,7 @@ func buildConnectionRules(f *connectionRuleFlags) ([]hookdeck.Rule, error) {
 		if err := json.Unmarshal([]byte(f.Rules), &rules); err != nil {
 			return nil, fmt.Errorf("invalid JSON for --rules: %w", err)
 		}
-		return rules, nil
+		return normalizeRulesForAPI(rules), nil
 	}
 
 	if f.RulesFile != "" {
@@ -115,7 +115,7 @@ func buildConnectionRules(f *connectionRuleFlags) ([]hookdeck.Rule, error) {
 		if err := json.Unmarshal(data, &rules); err != nil {
 			return nil, fmt.Errorf("invalid JSON in rules file: %w", err)
 		}
-		return rules, nil
+		return normalizeRulesForAPI(rules), nil
 	}
 
 	// Build each rule type (order matches create: deduplicate -> transform -> filter -> delay -> retry)
@@ -191,9 +191,10 @@ func buildConnectionRules(f *connectionRuleFlags) ([]hookdeck.Rule, error) {
 		if f.RuleRetryInterval > 0 {
 			rule["interval"] = f.RuleRetryInterval
 		}
+		// API expects response_status_codes as []string (RetryRule schema)
 		if f.RuleRetryResponseStatusCode != "" {
 			parts := strings.Split(f.RuleRetryResponseStatusCode, ",")
-			intCodes := make([]int, 0, len(parts))
+			strCodes := make([]string, 0, len(parts))
 			for _, part := range parts {
 				part = strings.TrimSpace(part)
 				if part == "" {
@@ -206,16 +207,47 @@ func buildConnectionRules(f *connectionRuleFlags) ([]hookdeck.Rule, error) {
 				if n < 100 || n > 599 {
 					return nil, fmt.Errorf("invalid HTTP status code %d in --rule-retry-response-status-codes: must be between 100 and 599", n)
 				}
-				intCodes = append(intCodes, n)
+				strCodes = append(strCodes, part)
 			}
-			rule["response_status_codes"] = intCodes
+			rule["response_status_codes"] = strCodes
 		}
 		rules = append(rules, rule)
 	}
 
 	return rules, nil
 }
 
+// normalizeRulesForAPI ensures rules match the API schema: RetryRule.response_status_codes
+// must be []string; FilterRule body/headers may be string or object.
+func normalizeRulesForAPI(rules []hookdeck.Rule) []hookdeck.Rule {
+	out := make([]hookdeck.Rule, len(rules))
+	for i, r := range rules {
+		out[i] = make(hookdeck.Rule)
+		for k, v := range r {
+			out[i][k] = v
+		}
+		if r["type"] == "retry" {
+			if codes, ok := r["response_status_codes"].([]interface{}); ok && len(codes) > 0 {
+				strCodes := make([]string, 0, len(codes))
+				for _, c := range codes {
+					switch v := c.(type) {
+					case string:
+						strCodes = append(strCodes, v)
+					case float64:
+						strCodes = append(strCodes, strconv.Itoa(int(v)))
+					case int:
+						strCodes = append(strCodes, strconv.Itoa(v))
+					default:
+						strCodes = append(strCodes, fmt.Sprintf("%v", c))
+					}
+				}
+				out[i]["response_status_codes"] = strCodes
+			}
+		}
+	}
+	return out
+}
+
 // parseJSONOrString attempts to parse s as a JSON object or array. Only values
 // starting with '{' or '[' (after trimming whitespace) are candidates for
 // parsing; bare primitives like "order", 123, or true are returned as-is so

test/acceptance/connection_rules_json_test.go

@@ -127,9 +127,9 @@ func TestConnectionCreateWithRulesJSONExactValues(t *testing.T) {
 				assert.Equal(t, float64(3), rule["count"])
 				assert.Equal(t, float64(10000), rule["interval"])
 
-				statusCodes, ok := rule["response_status_codes"].([]interface{})
-				require.True(t, ok, "response_status_codes should be an array")
-				assert.Equal(t, []interface{}{float64(500), float64(502), float64(503)}, statusCodes)
+				statusCodes, ok := rule["response_status_codes"]
+				require.True(t, ok, "response_status_codes should be present")
+				assertResponseStatusCodesMatch(t, statusCodes, "500", "502", "503")
 			}
 		}
 		assert.True(t, foundFilter, "Should have a filter rule")
@@ -205,10 +205,9 @@ func TestConnectionCreateWithRulesFileExactValues(t *testing.T) {
 			assert.Equal(t, float64(5), rule["count"])
 			assert.Equal(t, float64(30000), rule["interval"])
 
-			statusCodes, ok := rule["response_status_codes"].([]interface{})
-			require.True(t, ok)
-			expectedCodes := []interface{}{float64(500), float64(502), float64(503), float64(504)}
-			assert.Equal(t, expectedCodes, statusCodes)
+			statusCodes, ok := rule["response_status_codes"]
+			require.True(t, ok, "response_status_codes should be present")
+			assertResponseStatusCodesMatch(t, statusCodes, "500", "502", "503", "504")
 		}
 	}
 	assert.True(t, foundFilter, "Should have a filter rule")

test/acceptance/connection_test.go

@@ -1274,8 +1274,8 @@ func TestConnectionWithFilterRule(t *testing.T) {
 
 	rule := getConn.Rules[0]
 	assert.Equal(t, "filter", rule["type"], "Rule type should be filter")
-	assert.Equal(t, `{"type":"payment"}`, rule["body"], "Filter body should match input")
-	assert.Equal(t, `{"content-type":"application/json"}`, rule["headers"], "Filter headers should match input")
+	assertFilterRuleFieldMatches(t, rule["body"], `{"type":"payment"}`, "body")
+	assertFilterRuleFieldMatches(t, rule["headers"], `{"content-type":"application/json"}`, "headers")
 
 	t.Logf("Successfully created and verified connection with filter rule: %s", conn.ID)
 }
@@ -1486,7 +1486,7 @@ func TestConnectionWithMultipleRules(t *testing.T) {
 	assert.Equal(t, "retry", getConn.Rules[2]["type"], "Third rule should be retry (logical order)")
 
 	// Verify filter rule details
-	assert.Equal(t, `{"type":"payment"}`, getConn.Rules[0]["body"], "Filter should have body expression")
+	assertFilterRuleFieldMatches(t, getConn.Rules[0]["body"], `{"type":"payment"}`, "body")
 
 	// Verify delay rule details
 	assert.Equal(t, float64(1000), getConn.Rules[1]["delay"], "Delay should be 1000 milliseconds")
@@ -2069,7 +2069,7 @@ func TestConnectionUpsertReplaceRules(t *testing.T) {
 	replacedRule := upserted.Rules[0]
 	assert.Equal(t, "filter", replacedRule["type"], "Rule should now be filter type")
 	assert.NotEqual(t, "retry", replacedRule["type"], "Retry rule should be replaced")
-	assert.Equal(t, filterBody, replacedRule["body"], "Filter body should match input")
+	assertFilterRuleFieldMatches(t, replacedRule["body"], filterBody, "body")
 
 	// Verify source and destination are preserved
 	assert.Equal(t, sourceName, upserted.Source.Name, "Source should be preserved in upsert output")
@@ -2083,7 +2083,7 @@ func TestConnectionUpsertReplaceRules(t *testing.T) {
 	assert.Len(t, fetched.Rules, 1, "Should have exactly one rule persisted")
 	fetchedRule := fetched.Rules[0]
 	assert.Equal(t, "filter", fetchedRule["type"], "Persisted rule should be filter type")
-	assert.Equal(t, filterBody, fetchedRule["body"], "Persisted filter body should match input")
+	assertFilterRuleFieldMatches(t, fetchedRule["body"], filterBody, "body")
 
 	t.Logf("Successfully replaced rules via upsert: %s", conn.ID)
 }
@@ -2238,9 +2238,9 @@ func TestConnectionCreateRetryResponseStatusCodes(t *testing.T) {
 		if rule["type"] == "retry" {
 			foundRetry = true
 
-			statusCodes, ok := rule["response_status_codes"].([]interface{})
-			require.True(t, ok, "response_status_codes should be an array, got: %T (%v)", rule["response_status_codes"], rule["response_status_codes"])
-			assert.Len(t, statusCodes, 4, "Should have 4 status codes")
+			statusCodes, ok := rule["response_status_codes"]
+			require.True(t, ok, "response_status_codes should be present")
+			assertResponseStatusCodesMatch(t, statusCodes, "500", "502", "503", "504")
 			break
 		}
 	}

test/acceptance/connection_update_test.go

@@ -271,7 +271,7 @@ func TestConnectionUpdateFilterRule(t *testing.T) {
 	for _, rule := range updated.Rules {
 		if rule["type"] == "filter" {
 			foundFilter = true
-			assert.Equal(t, filterBody, rule["body"], "Filter body should match")
+			assertFilterRuleFieldMatches(t, rule["body"], filterBody, "body")
 			break
 		}
 	}
@@ -351,9 +351,9 @@ func TestConnectionUpdateRetryResponseStatusCodes(t *testing.T) {
 		if rule["type"] == "retry" {
 			foundRetry = true
 
-			statusCodes, ok := rule["response_status_codes"].([]interface{})
-			require.True(t, ok, "response_status_codes should be an array, got: %T (%v)", rule["response_status_codes"], rule["response_status_codes"])
-			assert.Len(t, statusCodes, 3, "Should have 3 status codes")
+			statusCodes, ok := rule["response_status_codes"]
+			require.True(t, ok, "response_status_codes should be present")
+			assertResponseStatusCodesMatch(t, statusCodes, "500", "502", "503")
 			break
 		}
 	}

test/acceptance/connection_upsert_test.go

@@ -732,17 +732,9 @@ func TestConnectionUpsertPartialUpdates(t *testing.T) {
 			assert.Equal(t, float64(5), rule["count"], "count should be 5")
 			assert.Equal(t, float64(10000), rule["interval"], "interval should be 10000")
 
-			statusCodes, ok := rule["response_status_codes"].([]interface{})
-			require.True(t, ok, "response_status_codes should be an array, got %T: %v",
-				rule["response_status_codes"], rule["response_status_codes"])
-			require.Len(t, statusCodes, 4, "Should have exactly 4 status codes")
-
-			expectedCodes := []float64{500, 502, 503, 504}
-			for i, expected := range expectedCodes {
-				actual, ok := statusCodes[i].(float64)
-				require.True(t, ok, "status code [%d] should be a number, got %T", i, statusCodes[i])
-				assert.Equal(t, expected, actual, "status code [%d] should be %v", i, expected)
-			}
+			statusCodes, ok := rule["response_status_codes"]
+			require.True(t, ok, "response_status_codes should be present")
+			assertResponseStatusCodesMatch(t, statusCodes, "500", "502", "503", "504")
 			break
 		}
 		assert.True(t, foundRetry, "Should have a retry rule")

test/acceptance/helpers.go

@@ -13,6 +13,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -194,6 +195,47 @@ func (r *CLIRunner) RunJSON(result interface{}, args ...string) error {
 	return nil
 }
 
+// assertFilterRuleFieldMatches asserts that a filter rule field (body or headers) matches the expected JSON.
+// The API may return the field as either a string or a parsed map; both are accepted.
+func assertFilterRuleFieldMatches(t *testing.T, actual interface{}, expectedJSON string, fieldName string) {
+	t.Helper()
+	var expectedMap map[string]interface{}
+	require.NoError(t, json.Unmarshal([]byte(expectedJSON), &expectedMap), "expectedJSON should be valid JSON")
+	var actualMap map[string]interface{}
+	switch v := actual.(type) {
+	case string:
+		require.NoError(t, json.Unmarshal([]byte(v), &actualMap), "actual string should be valid JSON")
+	case map[string]interface{}:
+		actualMap = v
+	default:
+		t.Fatalf("%s should be string or map, got %T", fieldName, actual)
+	}
+	assert.Equal(t, expectedMap, actualMap, "%s should match expected JSON", fieldName)
+}
+
+// assertResponseStatusCodesMatch asserts that response_status_codes from the API match expected values.
+// The API may return codes as strings or numbers; both are accepted.
+func assertResponseStatusCodesMatch(t *testing.T, statusCodes interface{}, expected ...string) {
+	t.Helper()
+	slice, ok := statusCodes.([]interface{})
+	require.True(t, ok, "response_status_codes should be an array, got %T", statusCodes)
+	require.Len(t, slice, len(expected), "response_status_codes length")
+	for i, exp := range expected {
+		var actual string
+		switch v := slice[i].(type) {
+		case string:
+			actual = v
+		case float64:
+			actual = fmt.Sprintf("%.0f", v)
+		case int:
+			actual = fmt.Sprintf("%d", v)
+		default:
+			actual = fmt.Sprintf("%v", slice[i])
+		}
+		assert.Equal(t, exp, actual, "response_status_codes[%d]", i)
+	}
+}
+
 // generateTimestamp returns a timestamp string in the format YYYYMMDDHHMMSS plus microseconds
 // This is used for creating unique test resource names
 func generateTimestamp() string {