fix(tests): handle bytes_iterator + never leave an exhausted body

mateo-berri · mateo-berri · commit 9e2e5b6bf4ce · 2026-05-17T07:29:36.000Z
Follow-up to 8e08272. The previous attempt at coalescing iterable request bodies bailed out (``return`` without writing ``request.body``) whenever it could not classify the chunk type. That was the wrong failure mode for one critical case: vcrpy sometimes presents the body as ``iter(some_bytes)``, whose Python type is ``bytes_iterator`` and which yields ``int`` byte values (0-255), not byte chunks. The old code saw an ``int`` chunk, hit the ``else: return`` branch, and left ``request.body`` pointing at the now-exhausted iterator. The post-fix diagnostic run made this loud: [vcr-safe-body-matcher] request body mismatch body[a]: type='bytes_iterator' length=unknown sha256=N/A body[b]: type='bytes_iterator' length=unknown sha256=N/A Every async image-edit test then ballooned from entries=2 to entries=10 in that single CI run -- the exhausted iterator meant the live multipart upload went out as an empty body, OpenAI returned 400, the SDK + flaky retries fired, each retry got a fresh iterator that my hook exhausted again, and ``new_episodes`` recorded each failed attempt as a new cassette episode. This patch: * Recognizes ``bytes_iterator`` (chunks are ``int``) and reconstructs the buffer via ``bytes(chunks)``. * Keeps the existing ``list_iterator``-over-bytes-chunks handling via ``b"".join(...)``. * **Always writes a bytes value back to ``request.body`` after consuming the iterator.** If the chunk shape is unrecognized, ``request.body`` is set to ``b""`` rather than left as an exhausted iterator. That is wrong in the sense of "we lost the body" but right in the sense of "the failure mode is now visible (live API call sends empty body and fails fast) instead of invisible (corrupt cassette grows silently)". Combined with the matcher diagnostic, any future regression in this code path will surface in the CI log immediately. Local verification covers ``bytes_iterator``, ``list_iterator`` over bytes chunks, generator over bytes chunks, empty iterator, already-bytes (idempotent), identical-content iterator equality in the matcher (now matches), and differing-content iterator inequality (still raises).
diff --git a/tests/_vcr_conftest_common.py b/tests/_vcr_conftest_common.py
@@ -638,18 +638,42 @@ def _materialize_iterable_body(request) -> None:
         chunks = list(body)
     except TypeError:
         return
-    out = bytearray()
-    for chunk in chunks:
-        if isinstance(chunk, (bytes, bytearray)):
-            out.extend(chunk)
-        elif isinstance(chunk, str):
-            out.extend(chunk.encode("utf-8"))
-        else:
-            # Heterogeneous, non-text/binary chunk - bail rather than
-            # silently corrupt the body.
-            return
+
+    # IMPORTANT: ``list(body)`` has already exhausted the original
+    # iterator. From this point we MUST write something bytes-shaped
+    # back to ``request.body`` -- bailing out and leaving the body as
+    # an exhausted iterator makes the next access (cassette
+    # serialization, retry replay, or the actual httpx send) see an
+    # empty stream. In a previous attempt at this fix the bail path
+    # was taken for ``bytes_iterator`` bodies (chunks were ints) and
+    # the live send ended up with an empty multipart upload, which
+    # the SDK retried until the cassette ballooned to ~10 episodes
+    # per test. Fall through to ``out = b""`` rather than ``return``
+    # so an unrecognized chunk shape still leaves a stable body.
+    out = b""
+    if chunks:
+        first = chunks[0]
+        if isinstance(first, int):
+            # ``iter(b"...")`` yields integer byte values (its type
+            # name is ``bytes_iterator``). ``bytes(list_of_ints)`` is
+            # the inverse and reconstructs the original buffer.
+            try:
+                out = bytes(chunks)
+            except (TypeError, ValueError):
+                out = b""
+        elif isinstance(first, (bytes, bytearray)):
+            try:
+                out = b"".join(c if isinstance(c, bytes) else bytes(c) for c in chunks)
+            except (TypeError, ValueError):
+                out = b""
+        elif isinstance(first, str):
+            try:
+                out = "".join(chunks).encode("utf-8")
+            except (TypeError, ValueError):
+                out = b""
+
     try:
-        request.body = bytes(out)
+        request.body = out
     except (AttributeError, TypeError):
         pass
 
