oapi-codegen · bendrucker · Aug 19, 2026 · Aug 19, 2026
@@ -314,6 +314,34 @@ func TestUnionEnumDropsConstants(t *testing.T) {
 	assert.Equal(t, "two", v)
 }
 
+// Union in array-items position: the element carries the permissive mapping,
+// so the component is an `[]any` alias and mixed member values round-trip.
+func TestReadingListUnionItems(t *testing.T) {
+	var r ReadingList
+	require.NoError(t, json.Unmarshal([]byte(`["low",97.5]`), &r))
+	assert.Equal(t, ReadingList{"low", 97.5}, r)
+}
+
+// A union as a oneOf branch keeps the outer schema's standard union
+// machinery, with the branch accessor typed `any`. As... to `any` never
+// fails, so branch discrimination falls to the caller.
+func TestFlexibleIdUnionBranch(t *testing.T) {
+	var f FlexibleId
+	require.NoError(t, json.Unmarshal([]byte(`"user-7"`), &f))
+	v, err := f.AsFlexibleId1()
+	require.NoError(t, err)
+	assert.Equal(t, "user-7", v)
+
+	require.NoError(t, f.FromFlexibleId0(FlexibleId0{Id: "abc"}))
+	obj, err := f.AsFlexibleId0()
+	require.NoError(t, err)
+	assert.Equal(t, "abc", obj.Id)
+
+	v, err = f.AsFlexibleId1()
+	require.NoError(t, err, "the any-typed accessor succeeds even on the object branch's data")
+	assert.Equal(t, map[string]any{"id": "abc"}, v)
+}
+
 // petFieldComments extracts the doc comment text for each field of the Pet
 // struct from a parsed AST. Returns map[fieldName]commentText.
 func petFieldComments(t *testing.T, f *ast.File) map[string]string {

@@ -247,3 +247,22 @@ components:
       enum:
         - 1
         - two
+
+    # Union in array-items position: the element type carries the permissive
+    # mapping, so the component lowers to `[]any`.
+    ReadingList:
+      type: array
+      items:
+        type: [string, number]
+
+    # A union as a oneOf branch. The outer schema keeps the standard oneOf
+    # union machinery. The union branch's accessor is typed `any`, so its
+    # As... conversion never fails, the same as a typeless branch.
+    FlexibleId:
+      oneOf:
+        - type: object
+          required: [id]
+          properties:
+            id:
+              type: string
+        - type: [string, integer]
@@ -3,7 +3,7 @@
 // lowering of unions to `any` is covered in the sibling openapi31 suite;
 // this suite generates a std-http server and client so the emitted
 // bind-option Types lists are exercised against the real runtime binder
-// (runtime >= v1.7.0), in path, query, and header positions:
+// (runtime >= v1.7.0), in path, query, header, and response header positions:
 //
 //   - the value binds to the first union member that parses, trying
 //     boolean, integer, number, then string — so "42" arrives as int64(42)

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -26,6 +27,7 @@ func (s *captureServer) UpdateThing(w http.ResponseWriter, r *http.Request, id a
 	s.body = nil
 	_ = json.NewDecoder(r.Body).Decode(&s.body)
 	w.Header().Set("Content-Type", "application/json")
+	w.Header().Set("X-Echo", fmt.Sprint(id))
 	_ = json.NewEncoder(w).Encode(map[string]any{"id": id})
 }
 
@@ -102,3 +104,27 @@ func TestUnionParamClientRoundTrip(t *testing.T) {
 	require.NoError(t, json.NewDecoder(resp.Body).Decode(&echoed))
 	assert.Equal(t, float64(42), echoed["id"], "response body is plain JSON, so the id comes back as a JSON number")
 }
+
+// The generated ClientWithResponses binds declared response headers through
+// the styled binder with Types, so a union-typed header comes back as the
+// first member that parses.
+func TestUnionResponseHeaderClientBinding(t *testing.T) {
+	capture := &captureServer{}
+	srv := httptest.NewServer(Handler(capture))
+	defer srv.Close()
+
+	client, err := NewClientWithResponses(srv.URL)
+	require.NoError(t, err)
+
+	resp, err := client.UpdateThingWithResponse(context.Background(), 42, nil,
+		UpdateThingJSONRequestBody("x"))
+	require.NoError(t, err)
+	require.NotNil(t, resp.Headers200)
+	assert.Equal(t, int64(42), resp.Headers200.XEcho, "header [integer, string]: integer member wins for a numeric token")
+
+	resp, err = client.UpdateThingWithResponse(context.Background(), "abc", nil,
+		UpdateThingJSONRequestBody("x"))
+	require.NoError(t, err)
+	require.NotNil(t, resp.Headers200)
+	assert.Equal(t, "abc", resp.Headers200.XEcho, "non-numeric token falls to the string member")
+}
@@ -14,10 +14,10 @@ info:
   version: "1.0.0"
   description: |
     Exercises multi-type unions in every parameter position the runtime
-    binds: path, query, and header, plus a union request/response body.
-    Each union parameter lowers to `any`, and the generated bind calls
-    carry Types so runtime >= v1.7.0 picks the first member that parses
-    (boolean, integer, number, string).
+    binds: path, query, header, and response header, plus a union
+    request/response body. Each union parameter lowers to `any`, and the
+    generated bind calls carry Types so runtime >= v1.7.0 picks the first
+    member that parses (boolean, integer, number, string).
 paths:
   /things/{id}:
     post:
@@ -54,6 +54,13 @@ paths:
       responses:
         "200":
           description: echo of what was bound
+          headers:
+            # Response-header position: the generated ClientWithResponses
+            # binds declared headers through the same styled binder, so a
+            # union-typed header needs its Types list too.
+            X-Echo:
+              schema:
+                type: [integer, string]
           content:
             application/json:
               schema: