Function TestNormalizeForJSONSchema_NestedMap

pkg/parser/schema_test.go:1442–1488

TestNormalizeForJSONSchema_NestedMap verifies recursive normalization of maps.

(t *testing.T)

// TestNormalizeForJSONSchema_NestedMap verifies recursive normalization of maps.
func TestNormalizeForJSONSchema_NestedMap(t *testing.T) {
	input := map[string]any{
		"name":    "test",
		"count":   uint64(42),
		"offset":  int64(-3),
		"enabled": true,
		"nested": map[string]any{
			"port":  uint64(8080),
			"label": "inner",
		},
	}

	result := normalizeForJSONSchema(input)
	resultMap, ok := result.(map[string]any)
	if !ok {
		t.Fatalf("expected map[string]any, got %T", result)
	}

	if resultMap["name"] != "test" {
		t.Errorf("name: got %v, want test", resultMap["name"])
	}
	if resultMap["count"] != float64(42) {
		t.Errorf("count: got %T(%v), want float64(42)", resultMap["count"], resultMap["count"])
	}
	if resultMap["offset"] != float64(-3) {
		t.Errorf("offset: got %T(%v), want float64(-3)", resultMap["offset"], resultMap["offset"])
	}
	if resultMap["enabled"] != true {
		t.Errorf("enabled: got %v, want true", resultMap["enabled"])
	}

	nestedMap, ok := resultMap["nested"].(map[string]any)
	if !ok {
		t.Fatalf("nested: expected map[string]any, got %T", resultMap["nested"])
	}
	if nestedMap["port"] != float64(8080) {
		t.Errorf("nested.port: got %T(%v), want float64(8080)", nestedMap["port"], nestedMap["port"])
	}
	if nestedMap["label"] != "inner" {
		t.Errorf("nested.label: got %v, want inner", nestedMap["label"])
	}

	// Verify the original input is NOT mutated
	if input["count"] != uint64(42) {
		t.Errorf("original input mutated: count is %T(%v), expected uint64(42)", input["count"], input["count"])
	}
}

// TestNormalizeForJSONSchema_Slice verifies recursive normalization of slices.
func TestNormalizeForJSONSchema_Slice(t *testing.T) {