From 43ff21d291dfc4d938773ee83e43ce2f6cf1369d Mon Sep 17 00:00:00 2001 From: Kevin Wooten Date: Mon, 9 Nov 2026 07:50:54 -0800 Subject: [PATCH 1/6] Refactor token ownership and HTTPX request/response adapters --- README.md | 160 ++- docs/adapter-lifecycle-audit.md | 106 ++ src/sunday/__init__.py | 13 +- src/sunday/client_settings.py | 18 +- src/sunday/httpx/__init__.py | 8 + src/sunday/httpx/_async.py | 105 ++ src/sunday/httpx/_oauth.py | 29 +- src/sunday/httpx/_requests.py | 113 ++ src/sunday/httpx/_response_cleanup.py | 60 + src/sunday/httpx/_security.py | 46 +- src/sunday/httpx/_sse.py | 296 +++-- src/sunday/httpx/_transport.py | 284 +++-- src/sunday/httpx/request_adapter.py | 50 + src/sunday/httpx/response_adapter.py | 63 + src/sunday/operations.py | 5 +- src/sunday/request_cancellation_error.py | 13 + src/sunday/token_manager.py | 65 +- src/sunday/token_manager_factory.py | 19 - src/sunday/token_provider.py | 90 +- src/sunday/transport.py | 11 +- tests/test_client_settings.py | 11 +- tests/test_client_settings_persistence.py | 50 +- tests/test_codecs_operations.py | 40 + tests/test_httpx.py | 2 +- tests/test_httpx_adapters.py | 802 ++++++++++++ tests/test_httpx_cleanup.py | 1417 +++++++++++++++++++++ tests/test_httpx_security.py | 125 +- tests/test_httpx_sse.py | 200 ++- tests/test_tokens.py | 95 ++ 29 files changed, 3902 insertions(+), 394 deletions(-) create mode 100644 docs/adapter-lifecycle-audit.md create mode 100644 src/sunday/httpx/_async.py create mode 100644 src/sunday/httpx/_requests.py create mode 100644 src/sunday/httpx/_response_cleanup.py create mode 100644 src/sunday/httpx/request_adapter.py create mode 100644 src/sunday/httpx/response_adapter.py create mode 100644 src/sunday/request_cancellation_error.py delete mode 100644 src/sunday/token_manager_factory.py create mode 100644 tests/test_httpx_adapters.py create mode 100644 tests/test_httpx_cleanup.py diff --git a/README.md b/README.md index 7dbedb1..d50b420 100644 --- a/README.md +++ b/README.md @@ -90,8 +90,9 @@ Sunday transports expose the same high-level workflow as the Kotlin, Swift, and | Decode result only | `result()` | `BaseTransport` implements this orchestration for custom adapters. Implementations provide protected `_prepare_request()`, -`_send()`, and `_decode_response()` hooks. Preparation applies ordered request adapters once; generated request- and -response-exchange methods are async and return the exact adapted request or native response used by execution. +`_send()`, and `_decode_response()` hooks. HTTPX preparation only builds the request; managed execution adapts immediately before each send. +Request export adapts once and hands execution to the consumer (for example, `await client.send(exported)`). +Calling `transport_response()` explicitly starts a new managed execution and applies its adapters. Generated clients expose their `transport`, `default_content_types`, and `default_accept_types`. Operation-specific media declarations take precedence when they cannot use the client defaults, and an explicit Content-Type header remains @@ -100,7 +101,7 @@ authoritative. ## Profiled credentials Generated operations carry selected `SecurityBinding` metadata in `RequestSpec.security`. Applications -register providers on a shared `TokenManager` and pass it to `HttpxTransport(token_manager=...)`. +pass named providers directly to `HttpxTransport(token_providers=...)`. Providers and token storage stay in the application; generated code contains no credentials. ```python @@ -120,7 +121,7 @@ def create_transport(client: httpx.AsyncClient, client_secret: str) -> HttpxTran ) return HttpxTransport( client, - token_manager=TokenManager({"service-identity": provider}), + token_providers={"service-identity": TokenManager(provider)}, ) ``` @@ -219,7 +220,8 @@ Typed `EventStream[T]` values retain the async-iterator lifecycle. Raw `EventSou a running AsyncIO loop: assign `on_open`, `on_error`, or `on_message`, register event-specific listeners, call `connect()`, and call `close()` when finished. `connect()` returns immediately in the connecting state. The source exposes `ready_state` and its current `retry_time`; closing is idempotent and immediately changes the state to closed while -response cleanup completes on the loop. +response cleanup completes on the loop. Calling `connect()` immediately after `close()` starts +a new run with its own stream; transport shutdown also waits for any retiring runs. HTTPX applications can construct a raw source from a declarative request with `HttpxTransport.event_source()` or from a synchronous or asynchronous native request factory with `event_source_from()`. Reconnect requests receive the SSE headers @@ -286,33 +288,133 @@ is a typed, copyable, picklable singleton; it is omitted from JSON Schema and se field configuration above. A literal string `"UNSET"` remains an ordinary string value. Keep the `default_factory` and `exclude_if` configuration when defining patch models manually. -## Application-owned token persistence +## Application-owned token lifecycle + +Transports accept named `TokenProvider` instances directly. Settings preserve supplied providers and +never add a token cache. Every managed network attempt asks its provider for current credentials. +An external framework (for example Auth0) remains responsible for storage, renewal and logout. +Return only its access token and optional expiry; keep its refresh token inside that framework. + +For Sunday's caching and refresh lifecycle, explicitly supply a `TokenManager` as the provider: ```python +tokens = TokenManager(oauth_provider, store=application_store, expiry_skew=30, now=application_clock) settings = ClientSettings.resolve( - base_url, alternatives, credentials, - token_manager_factory=lambda providers: TokenManager( - providers, store=application_store, expiry_skew=30, now=application_clock, - ), + base_url, alternatives, {"identity": ProviderCredentials(tokens)}, +) +# Supply an external framework's provider directly instead to keep its lifecycle authoritative. +transport = HttpxTransport.from_settings(settings, client) +``` + +Managers retain expiry skew, coalesced renewal, refresh rotation and application-selected persistence. +Use a manager on one asyncio loop; cancel and await requests before discarding it. +Transport closure does not erase the store or close a shared provider. Separate managers do not +coordinate refreshes merely because they share a store. Reuse the same manager across clients that +share a credential lifecycle, and distinguish users/environments with provider and grant identities. + +Providers can implement `reject` to handle an invalid bearer token. It receives the original request +context and rejected access token, and returns whether recovery can proceed. Compare the rejected +credential with the current session before renewing: a late rejection must not invalidate a newer token +or a new login. Providers without this capability raise `TokenRejectedError`, a `RequestCancellationError`, on explicit invalid-token rejection. Acquisition and rejection +must not start interactive login automatically; return an authorization-required failure to the caller. +For an Auth0 adapter, retrieve through its credentials manager and force renewal through that same +manager on rejection, serializing concurrent rejection handling without maintaining a second token cache. + +Request export materializes an optionally authorized native request once and hands its lifecycle to +the consumer. Exported requests retain no Sunday-managed recovery state. Executing an operation through +Sunday acquires once per attempt and retains the bounded safe-request recovery and SSE reconnect budget. + +Migration: replace transport `tokenManager`/`token_manager` arguments with named +`tokenProviders`/`token_providers` maps. Replace `TokenManagerFactory` hooks with explicitly constructed +managers supplied through provider credentials. Direct built-in OAuth providers are not implicitly cached; +wrap them explicitly when Sunday should retain and refresh their tokens. For logout, stop outstanding +requests and settle refresh commits before clearing the owning framework's or application's storage. + +Custom transports implementing the `Transport` protocol must provide `execute_request(spec)` for +operation execution. `BaseTransport` implements it through `_prepare_request` and `_send`. +Keep `transport_request(spec)` as the caller-owned export path; do not route operation execution +through an export override. + + +## Request and response adapters + +`RequestAdapter` and `ResponseAdapter` are independent ABCs in `sunday.httpx`. Implement +`async adapt(request) -> httpx.Request` or `async adapt(response, request) -> httpx.Response`. +Each provides `chain_to(next_adapter)`. `RequestAdapters` and `ResponseAdapters` also accept +async functions and flatten nested chains once at construction: + +```python +from sunday.httpx import HttpxTransport, RequestAdapters, ResponseAdapters, copy_request + +async def add_header(request): + return copy_request(request, headers=[*request.headers.multi_items(), ("X-Client", "example")]) + +async def inspect_response(response, request): + # Headers are available before Sunday reads the body. + return response + +transport = HttpxTransport( + client, + request_adapter=RequestAdapters(add_header), + response_adapter=ResponseAdapters(inspect_response), ) ``` -The same optional `token_manager_factory: TokenManagerFactory | None` keyword is available on the -settings initializer. Clock values and expiry skew are seconds. Use the manager on its application's -asyncio loop. The native manager has no close/reset method: cancel/await application requests and -discard the manager at session end; it does not own HTTPX clients or close application storage. - -The hook is invoked once with the resolved provider map, after security validation, and is skipped -when no providers are selected. It must only construct a manager: do not acquire tokens or read -storage in the hook. Omitting it keeps the existing in-memory default. Settings retain the returned -manager, not the factory. All operations on those settings share it; generated aggregate children -therefore retain the same cache and single-flight renewal. Independently created managers do not -coordinate concurrent refreshes, even if their stores are the same. Reuse a client/aggregate within -an active session; use successive managers to reopen saved sessions. - -The application owns persistence, encryption, store access and session boundaries. Provider/client, -grant, profile and endpoint identities must distinguish environments and users; the API base URL -alone is not an implicit store namespace. Use a new grant identity for a fresh authorization session. -For logout, stop requests and wait for pending refresh/persistence to finish before removing the -session's store entries, then construct fresh settings. `invalidate` expires an access token for -renewal; it is not logout and deliberately retains refresh state. No disk storage is enabled automatically. +Managed attempts prepare and authorize, adapt the request, send, adapt the response, then +apply normal response handling and bounded recovery. No response capability is inferred from +a request adapter. Provider rejection feedback is independent of custom response adapters and +runs even for unsafe methods or exhausted retry budgets. Only the token actually sent is rejected. +Security receipts and retry counts are local to execution, never attached to exported requests. + +Adapters surround each native HTTPX call. Borrowed-client event hooks, authentication flows, +and transport-level connection recovery retain their native behavior; intermediate native +responses are not guaranteed to reach Sunday adapters. Credentialed calls suppress native auth. +Sunday handles allowed redirects after response adaptation, rerunning request adapters on each +follow-up without accumulating header mutations. Buffered bodies and `StreamingBody` factories +can be replayed for redirects; arbitrary one-shot request streams are not replayed. Credentialed +redirects remain disabled. Allowed follow-ups use the native cookie jar, including its domain, +path, and secure-cookie rules. Returned responses retain redirect and native authentication +history; intermediate redirect bodies are buffered as in HTTPX, including during streaming +execution. Native clients and connection pools are reused without reconfiguration. + +An adapter that consumes or replaces a resource must close it and provide a replacement. +HTTPX responses and headers are mutable; `await response.aread()` retains buffered content for +subsequent readers. Return a new `httpx.Response` to replace the body. `copy_request()` preserves +native extensions and shares an unread stream without consuming it; pass `content=b""` to remove +a body. Changing the URL authority updates `Host` unless the supplied `headers` explicitly +override it. Replacing headers preserves an unread body's framing unless `Content-Length` or +`Transfer-Encoding` is explicitly supplied; streams without known framing use chunked encoding. +Use asynchronous streams; synchronous factories must not block the event loop. + +Subclass `sunday.RequestCancellationError` to veto retries and SSE reconnects. Sunday propagates +the original exception, including when it also subclasses an HTTPX error or `Problem`; encoding +fallbacks and nullable operations never suppress it. This is distinct from +`asyncio.CancelledError`: task cancellation follows Python semantics and is never swallowed. +Cleanup waits for the response to close even when asyncio cancellation is pending or repeated, +then propagates the original error. A cleanup failure does not replace an existing failure. +Explicit closure and HTTPX's automatic EOF closure share one protected stream-close operation; +concurrent closers join it until it finishes. Native sends and reads run behind a cancellation +boundary that allows HTTPX/httpcore to finish internal cleanup before the original cancellation +is rethrown. This also covers OAuth discovery and token exchanges. Transport shutdown shares +one completion task across callers and waits for retiring EventSource runs before closing an +owned client. A cancelled shutdown waiter does not cancel that shared cleanup. When an owned +EventSource's adapter or native hook calls `transport.aclose()`, it requests shutdown without +joining its own run; external callers still wait for cleanup to finish. This also applies to +retiring runs after an immediate reconnect. +Buffered collection uses HTTPX's bulk `aread()` with one owner task for the entire body; SSE uses +its asynchronous byte iterator with cancellation bounded to each read. +Use `async with stream` or explicitly await `stream.aclose()` when ending iteration early. +Closing a stream interrupts and joins its active I/O, including header reception and response +adaptation before the stream receives the response. It then joins response cleanup without waiting +for application work between yielded events. Context cleanup preserves the consumer's original +exception if cleanup fails. A close called inside that stream's own adapter or native hook requests +closure without waiting on itself; external close callers wait for completion. + +The existing `adapters=` argument remains supported for legacy `(transport, request)` adapters; +it runs before the new request-adapter chain. Prefer the independent `request_adapter=` and +`response_adapter=` arguments for new code. Generated code continues to use managed +`execute_request()`/`response()` operations; generator migration is a separate step. + + +The [adapter lifecycle audit](docs/adapter-lifecycle-audit.md) records the recurring failure +patterns, native-framework boundaries, and regression coverage used for this refactor. diff --git a/docs/adapter-lifecycle-audit.md b/docs/adapter-lifecycle-audit.md new file mode 100644 index 0000000..f604d5a --- /dev/null +++ b/docs/adapter-lifecycle-audit.md @@ -0,0 +1,106 @@ +# Adapter refactor lifecycle audit + +## Assessment + +The repeated findings were not independent corner cases. Earlier fixes and reviews were too +focused on individual call sites, especially explicit response closure. The design needed an +inventory of all native I/O and ownership transitions, plus tests of actual connection-pool +release rather than only mock `aclose()` calls. + +Comparison with the Python worktree's pre-refactor `HEAD` confirms inherited problems: an AnyIO +cancel scope spanned SSE yields; EventSource retirement read mutable `self._stream`; shutdown +blanket-suppressed `CancelledError`; and `_closed` indicated that shutdown had started, not that +it had finished. The refactor added its own incomplete fixes: the first cleanup helper missed +HTTPX's EOF close, the stream-close wrapper then missed httpcore's internal read-error cleanup, +and clearing `_response` before awaiting cleanup let concurrent closers return early. A later +response-only join still missed closure before header reception/response adaptation had transferred +response ownership to the stream. Those intermediate changes should not be treated as independent proof of lifecycle correctness. + +This audit covers the Python implementation and the issue families identified during the +Swift/Kotlin/Python work in this thread. It does not claim a fresh source review of the other +runtimes or the generator. + +## Recurring issue families and checks + +| Issue family identified in the refactor | Shared cause | Python invariant and evidence | +| --- | --- | --- | +| Mandatory TokenManager wrapping, competing caches, duplicate authorization | Two owners for one credential lifecycle | External providers are called directly; TokenManager explicitly opts into caching. Export adapts once. Security tests cover rotation, logout, rejection and acquisition counts. | +| Request adapter implicitly supplying response behavior; an explicit observer disabling invalidation | Hidden composition | Independent request/response chains, explicit flattening and no inferred response adapter. Adapter tests verify order, independent invocation and replacement ownership. | +| Nested pipelines and request-attached execution state | Reconstructing state instead of defining its owner | One flattened chain per transport. Attempt/recovery state is local to execution, and exported requests carry no hidden recovery state. | +| Replay errors wrapped or replaced; cancellation swallowed by encoding, nullable results, OAuth or retry handling | Broad exception handling crosses the stop-signal contract | A RequestCancellationError remains the same object and bypasses retry/reconnect/fallback. Regression coverage includes body factories, codec selection, provider errors, RFC problems, diagnostics and response history. | +| Swift continuation registration/completion races; Kotlin constrained-dispatcher cancellation | Completion notification confused with completed ownership | Python uses ordinary task completion. Shared cleanup has one task and every closer waits for it; it does not depend on a flag, a discarded pointer, or a blocking bridge. | +| Adapter/delegate body replacement lost on redirects; unsafe replay of consumed bodies | Native request reconstruction loses information or duplicates side effects | `copy_request` retains extensions and unchanged streams; adapters own consumed resources. Managed attempts rebuild and reapply adapters without accumulating headers. Arbitrary one-shot bodies are not replayed. | +| Missing/stale Host, discarded streaming-body framing, missing cookies or redirect history | Native constructor/follow-up semantics were only partially reproduced | TCP framing/Host tests, native HTTPX cookie comparisons, merged native-auth/redirect history and buffered intermediate bodies cover these separately. | +| Status substitution observable by caches/events in OkHttp | Trying to hide a policy change from the native stack | No status sentinels. Native recovery inside a native call is allowed; only Sunday-managed attempts promise adapter invocation. | +| Byte-at-a-time buffered collection; framework trailer behavior | Forcing cross-runtime implementation parity rather than contract parity | HTTPX retains bulk `aread()` and native byte iteration. A multi-chunk TCP regression verifies one owner task for a whole buffered body. Kotlin trailer behavior remains a native-framework concern, not a Python emulation. | +| SSE early exit, cancellation leaking into consumer work, cleanup replacing the consumer's error | Cancel scopes and resource scopes crossed yielded values | Cancel scopes are bounded to active I/O. Context exit preserves the original error and joins cleanup; existing early-exit tests verify the consumer task remains usable. | +| Pending/repeated cancellation, EOF cleanup, read-error cleanup and shutdown | AnyIO shielding mistaken for protection from direct repeated `Task.cancel()` | Native sends/reads use `run_io`; cleanup uses `complete`. TCP tests gate real native cleanup and prove a one-connection pool is usable before client shutdown. | +| Immediate EventSource reconnect closes the replacement; retiring tasks disappear from shutdown | Shared mutable generation pointers | Each run owns its stream; callbacks and state updates check ownership. Retirement is tracked until all runs finish. Tests cover restart before start, restart while active, and old cleanup finishing after the replacement. | +| Concurrent `aclose()` returns early | “Closing” state treated as “closed” | Response references survive until shared cleanup completes. Transport shutdown has a shared completion task. Cancelled waiters cannot cancel that work. | +| Abandoned token persistence reported twice on Python 3.14 | Shield/wait ownership and failure observation were conflated | TokenManager uses `asyncio.wait()` without forwarding cancellation; its existing completion callback retrieves failures. A regression reproduces the former duplicate event-loop report. | + +## Consolidated implementation + +`httpx/_async.py` defines two distinct operations: + +- `run_io` runs native I/O in an owner task with an AnyIO cancellation scope. Caller cancellation + signals that scope; repeated raw cancellations stay in the waiting caller. Native shielded + cleanup can therefore finish. The original caller cancellation is rethrown, while native + RequestCancellationError objects remain unconditional stop signals. A result produced during + cancellation is disposed when ownership cannot be transferred to the caller. +- `complete` waits for shared cleanup without forwarding cancellation. It joins the task before + propagating the waiter's original cancellation. Cleanup failure does not replace an existing + primary error at response or transport context boundaries. + +The response stream wrapper delegates protected reads and owns one close task. Each active SSE +I/O block has a completion event paired with its cancel scope. External close callers join that +block before response cleanup, even when no response has yet been handed to the stream. I/O +ownership is cleared before yielding events, so close never joins application work between events. +Callbacks within the same I/O ownership chain only request closure to avoid waiting on themselves. +Each I/O record identifies its initiating task, so transport shutdown can recognize an owned +EventSource callback even inside a native child task or a retiring run. Shutdown signals source +closure immediately; reentrant callers do not join their own run, while external callers still +join the shared cleanup. The transport owns one shutdown task. EventSource retirement uses `asyncio.wait()` to join source tasks without +confusing independently cancelled sources with cancellation of the shutdown caller. There is no +new public adapter API, request-attached state, retry policy, custom dispatcher or HTTP stack. + +Bulk response collection uses one native I/O owner task for the complete `aread()`. A task-local +identity check avoids nested task creation for its raw chunks. SSE uses one operation per requested +chunk, without read-ahead queues or a persistent producer task. The identity check compares the +actual task, so child tasks inheriting context do not incorrectly bypass protection. + +## Native I/O and ownership inventory + +| Boundary | Owner / cancellation behavior | Coverage | +| --- | --- | --- | +| Upload and response-header wait | Native send owner; cancelled scope permits internal connection cleanup | TCP buffered/streaming upload and header cancellation | +| Response delivery races cancellation | Send owner disposes an undelivered response | TCP response-hook handoff race, buffered/streaming | +| Buffered body and redirect-history reads | Bulk read owner; no per-chunk tasks | TCP read cancellation, existing history/error tests, multi-chunk collection test | +| Response adapter consumes a body | Protected stream iteration when no outer native owner exists | TCP adapter reads and existing consume/replace tests | +| SSE body read, timeout, EOF, error and reconnect | Per-read native owner; consumer is outside cancel scopes between yields | TCP repeated cancellation, EOF, early exit, keepalive/reconnect tests | +| Concurrent stream/context closure | External callers join active I/O before shared response cleanup; response reference retained until completion | TCP header/response-adapter close before handoff, concurrent cancellation, context/decoder/stop identity, and pool reuse before waiting for the consumer | +| Close inside the stream's own adapter/native hook | Requests cancellation without joining its own callback | Adapter and native-hook self-close regressions | +| Decoding an operation response | Execution has already buffered and closed it; decoding uses `response.content` directly | TCP decoding verifies complete/closed response and preserves stop/cancellation identity | +| OAuth discovery, acquisition and refresh | Same native send boundary, preserving the isolated OAuth request contract | TCP cancellation in all three paths, OAuth interoperability replay suite | +| EventSource shutdown and immediate reconnect | Run-local streams; native task join includes retiring runs | TCP reconnect and retirement tests | +| Transport shutdown | Shared completion, owned client closed only after sources finish; active owned callbacks request shutdown without self-joining | TCP owned/borrowed client, concurrent shutdown, independently cancelled source, scope/raw cancellation, request/response adapter and native-hook reentrancy, retiring runs, stop and external cancellation identity | +| Transport context cleanup fails during an existing error | Cleanup adds a note; original object propagates | Stop, CancelledError and ordinary-error identity tests | +| Token acquisition and persistence | Waiter counting remains separate from the shared renewal task | Coalescing, last-waiter cancellation, persistence-after-cancellation and duplicate-report tests | + +The TCP cancellation cases use HTTPX's documented trace extension to hold an actual httpcore +cleanup operation open. They then cancel again and verify completion, original error identity or +original cancellation reason, server disconnect and pool reuse. Mock transports remain useful +for adapter transformations and error types, but are not evidence that a native socket was released. + +## Carry-forward rules + +Before porting the model, enumerate native cleanup triggered by send failure, read failure, EOF, +redirect/auth follow-ups, explicit close and cancellation. Test ownership handoff and concurrent +close at each asynchronous boundary. Do not infer completed cleanup from native “closed” flags. +Keep adapters independent and stop signals unconditional. Match each platform's native recovery, +body replay and response-metadata behavior instead of introducing invisible policy bridges. + +Framework references: [HTTPX asynchronous streaming](https://www.python-httpx.org/async/), +[HTTPX trace extension](https://www.python-httpx.org/advanced/extensions/#trace), +[AnyIO cancellation semantics](https://anyio.readthedocs.io/en/stable/cancellation.html), and +[Python task waiting and cancellation](https://docs.python.org/3.14/library/asyncio-task.html). diff --git a/src/sunday/__init__.py b/src/sunday/__init__.py index 8586d09..84623a4 100644 --- a/src/sunday/__init__.py +++ b/src/sunday/__init__.py @@ -67,21 +67,25 @@ from .patch import MergePatch, PatchDocument, PatchOperation, PatchOperationKind from .patch_model import SundayPatchModel from .problems import Problem, ProblemPayload, ProblemRegistry +from .request_cancellation_error import RequestCancellationError from .security import SecurityBinding, SecurityEndpoints, SecurityTransport from .specs import NullifySpec, OperationSpec, RequestPayloadSpec, RequestSpec, ResponseHeaderSpec, ResponseSpec from .sse import EventParser, EventStreamOptions, ServerSentEvent from .streaming import StreamingBody, StreamingBodyChunk, StreamingBodyClose, StreamingBodyContent -from .token_manager import TokenLease, TokenManager -from .token_manager_factory import TokenManagerFactory +from .token_manager import TokenManager from .token_provider import ( AuthorizationRequiredError, RefreshingTokenProvider, + RejectingTokenProvider, TokenConfiguration, + TokenLease, TokenProvider, TokenProviderError, + TokenRejectedError, TokenRequest, TokenSet, TokenStore, + provider_credentials, ) from .transport import BaseTransport, EventStream, ProblemRegistrar, Transport from .unknown_model import UnknownModel @@ -144,6 +148,8 @@ "ProblemRegistry", "ProviderCredentials", "RefreshingTokenProvider", + "RejectingTokenProvider", + "RequestCancellationError", "RequestEncodingError", "RequestPayloadSpec", "RequestSpec", @@ -169,9 +175,9 @@ "TokenConfiguration", "TokenLease", "TokenManager", - "TokenManagerFactory", "TokenProvider", "TokenProviderError", + "TokenRejectedError", "TokenRequest", "TokenSet", "TokenStore", @@ -191,4 +197,5 @@ "is_unset", "parameter_object", "parameter_value", + "provider_credentials", ] diff --git a/src/sunday/client_settings.py b/src/sunday/client_settings.py index ec09686..8eb9aad 100644 --- a/src/sunday/client_settings.py +++ b/src/sunday/client_settings.py @@ -25,8 +25,6 @@ validate_credentials, ) from .security import SecurityBinding, SecurityEndpoints -from .token_manager import TokenManager -from .token_manager_factory import TokenManagerFactory from .token_provider import TokenConfiguration, TokenProvider, TokenRequest, TokenSet @@ -37,15 +35,13 @@ class ClientSettings: base_url: str bindings: Mapping[str, tuple[SecurityBinding, ...]] _credentials: Mapping[str, Credentials] = field(repr=False) - token_manager: TokenManager | None = field(repr=False) + token_providers: Mapping[str, TokenProvider] = field(repr=False) def __init__( self, base_url: str, bindings: Mapping[str, Sequence[SecurityBinding]] | None = None, credentials: Mapping[str, Credentials] | None = None, - *, - token_manager_factory: TokenManagerFactory | None = None, ) -> None: endpoint = urlsplit(base_url) if ( @@ -80,7 +76,7 @@ def __init__( object.__setattr__(self, "base_url", base_url) object.__setattr__(self, "bindings", MappingProxyType(values)) object.__setattr__(self, "_credentials", MappingProxyType(supplied)) - object.__setattr__(self, "token_manager", self._prepare_token_manager(token_manager_factory)) + object.__setattr__(self, "token_providers", self._prepare_token_providers()) @staticmethod def server_url(template: str, variables: Mapping[str, str], document_base_url: str | None = None) -> str: @@ -107,8 +103,6 @@ def resolve( credentials: Mapping[str, Credentials], selection: Mapping[str, Sequence[str]] | None = None, alternative_selection: Mapping[str, int] | None = None, - *, - token_manager_factory: TokenManagerFactory | None = None, ) -> ClientSettings: """Choose complete alternatives; alternative_selection selects a zero-based candidate including scopes.""" if (set(selection or {}) | set(alternative_selection or {})) - alternatives.keys(): @@ -132,9 +126,9 @@ def resolve( if len(usable) != 1: raise ValueError(f"Operation '{operation}' requires one complete security alternative") bindings[operation] = usable[0] - return cls(base_url, bindings, credentials, token_manager_factory=token_manager_factory) + return cls(base_url, bindings, credentials) - def _prepare_token_manager(self, factory: TokenManagerFactory | None) -> TokenManager | None: + def _prepare_token_providers(self) -> Mapping[str, TokenProvider]: """Prepare providers through the selected transport module without acquiring tokens.""" owners: dict[str, str] = {} providers: dict[str, TokenProvider] = {} @@ -166,9 +160,7 @@ def _prepare_token_manager(self, factory: TokenManagerFactory | None) -> TokenMa providers[binding.provider] = credential.provider_factory(resolved) else: providers[binding.provider] = _StaticProvider(credential) - if not providers: - return None - return factory(MappingProxyType(providers)) if factory is not None else TokenManager(providers) + return MappingProxyType(providers) class _StaticProvider: diff --git a/src/sunday/httpx/__init__.py b/src/sunday/httpx/__init__.py index 2618f52..f0c0ebd 100644 --- a/src/sunday/httpx/__init__.py +++ b/src/sunday/httpx/__init__.py @@ -10,6 +10,7 @@ try: from ._oauth import AuthorizationGrant, HttpxOAuthTokenProvider + from ._requests import copy_request from ._transport import ( HttpxEventSource, HttpxEventSourceRequestFactory, @@ -18,6 +19,8 @@ HttpxRequestAdapterCallable, HttpxTransport, ) + from .request_adapter import RequestAdapter, RequestAdapters + from .response_adapter import ResponseAdapter, ResponseAdapters except ModuleNotFoundError as error: if error.name not in {"anyio", "httpx"}: raise @@ -32,4 +35,9 @@ "HttpxRequestAdapter", "HttpxRequestAdapterCallable", "HttpxTransport", + "RequestAdapter", + "RequestAdapters", + "ResponseAdapter", + "ResponseAdapters", + "copy_request", ] diff --git a/src/sunday/httpx/_async.py b/src/sunday/httpx/_async.py new file mode 100644 index 0000000..ca6ed32 --- /dev/null +++ b/src/sunday/httpx/_async.py @@ -0,0 +1,105 @@ +# Copyright 2026 Outfox, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. + +from __future__ import annotations + +import asyncio +from collections.abc import Awaitable, Callable +from contextvars import ContextVar +from typing import Any + +import anyio + +from ..request_cancellation_error import RequestCancellationError + +_operation_task: ContextVar[asyncio.Task[Any] | None] = ContextVar("sunday_httpx_operation_task", default=None) + + +def in_operation() -> bool: + """Return whether this task already owns a protected native I/O operation.""" + return _operation_task.get() is asyncio.current_task() + + +async def _wait_done(task: asyncio.Task[Any]) -> asyncio.CancelledError | None: + failure: asyncio.CancelledError | None = None + with anyio.CancelScope(shield=True): + while not task.done(): + try: + await asyncio.wait((task,)) + except asyncio.CancelledError as cancellation: + if failure is None: + failure = cancellation + try: + await anyio.lowlevel.checkpoint_if_cancelled() + except asyncio.CancelledError as cancellation: + if failure is None: + failure = cancellation + return failure + + +async def complete[T](task: asyncio.Task[T]) -> T: + """Join shared cleanup without forwarding cancellation, then rethrow the first cancellation.""" + failure = await _wait_done(task) + try: + result = task.result() + except BaseException: + if failure is None: + raise + failure.add_note("Cleanup also failed") + if failure is not None: + raise failure + return result + + +async def run_io[T]( + operation: Callable[[], Awaitable[T]], *, discard: Callable[[T], Awaitable[None]] | None = None +) -> T: + """Cancel native I/O through an AnyIO scope, allowing its shielded cleanup to finish. + + Raw repeated Task.cancel() calls bypass HTTPX/httpcore's AnyIO shields. The + caller waits separately so only the scope reaches native I/O. Nested calls on + the owner task run directly, keeping bulk reads free of per-chunk tasks. + """ + if in_operation(): + return await operation() + + scope = anyio.CancelScope() + + async def run() -> T: + token = _operation_task.set(asyncio.current_task()) + try: + with scope: + return await operation() + raise asyncio.CancelledError() + finally: + _operation_task.reset(token) + + task = asyncio.create_task(run()) + try: + await asyncio.wait((task,)) + return task.result() + except RequestCancellationError: + raise + except asyncio.CancelledError as error: + scope.cancel() + with anyio.CancelScope(shield=True): + await _wait_done(task) + try: + result = task.result() + except RequestCancellationError: + raise + except asyncio.CancelledError: + pass + except BaseException: + error.add_note("Native I/O also failed while cancelling") + else: + # Cancellation can race with successful response delivery. Ownership + # must be released here when the caller will never receive the result. + if discard is not None: + try: + await discard(result) + except BaseException: + error.add_note("Closing the undelivered result also failed") + raise error diff --git a/src/sunday/httpx/_oauth.py b/src/sunday/httpx/_oauth.py index 17798ec..009974a 100644 --- a/src/sunday/httpx/_oauth.py +++ b/src/sunday/httpx/_oauth.py @@ -20,10 +20,13 @@ from authlib.oauth2.rfc6749.parameters import prepare_token_request # type: ignore[import-untyped] from ..credentials import AuthorizationGrant as AuthorizationGrant +from ..request_cancellation_error import RequestCancellationError from ..security import SecurityBinding, SecurityEndpoints from ..token_provider import AuthorizationRequiredError, TokenConfiguration, TokenProviderError, TokenRequest, TokenSet +from ._async import run_io from ._oauth_wire import DiscoveryMetadata, TokenErrorResponse, TokenSuccessResponse from ._oauth_wire import endpoint as _endpoint +from ._response_cleanup import close_response class HttpxOAuthTokenProvider: @@ -103,7 +106,7 @@ async def acquire(self, request: TokenRequest) -> TokenSet: else: raise TokenProviderError() return await self._exchange(request, request.token_url, form) - except (AuthorizationRequiredError, TokenProviderError): + except (RequestCancellationError, TokenProviderError): raise except httpx.TransportError: raise TokenProviderError("temporary") from None @@ -119,7 +122,7 @@ async def refresh(self, request: TokenRequest, refresh_token: str) -> TokenSet: request.refresh_url or request.token_url, {"grant_type": "refresh_token", "refresh_token": refresh_token}, ) - except (AuthorizationRequiredError, TokenProviderError): + except (RequestCancellationError, TokenProviderError): raise except httpx.TransportError: raise TokenProviderError("temporary") from None @@ -131,10 +134,13 @@ async def _resolve_endpoints(self, request: TokenRequest) -> TokenRequest: return request if not self._issuer: raise TokenProviderError() - response = await self._client.send( - httpx.Request("GET", _endpoint(request.discovery_url), headers={"Accept": "application/json"}), - auth=None, - follow_redirects=False, + response = await run_io( + lambda: self._client.send( + httpx.Request("GET", _endpoint(request.discovery_url), headers={"Accept": "application/json"}), + auth=None, + follow_redirects=False, + ), + discard=close_response, ) _check_availability(response.status_code) if response.status_code != 200: @@ -177,10 +183,13 @@ async def _exchange(self, request: TokenRequest, endpoint: str | None, form: dic {"Accept": "application/json", "Content-Type": "application/x-www-form-urlencoded"}, body, ) - response = await self._client.send( - httpx.Request("POST", url, content=body, headers=headers), - auth=None, - follow_redirects=False, + response = await run_io( + lambda: self._client.send( + httpx.Request("POST", url, content=body, headers=headers), + auth=None, + follow_redirects=False, + ), + discard=close_response, ) _check_availability(response.status_code) if response.status_code != 200: diff --git a/src/sunday/httpx/_requests.py b/src/sunday/httpx/_requests.py new file mode 100644 index 0000000..22920b6 --- /dev/null +++ b/src/sunday/httpx/_requests.py @@ -0,0 +1,113 @@ +# Copyright 2026 Outfox, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. + +from __future__ import annotations + +from collections.abc import AsyncIterable, AsyncIterator, Mapping, Sequence +from contextlib import suppress + +import httpx + +from ..streaming import StreamingBody + + +def copy_request( + request: httpx.Request, + *, + method: str | None = None, + url: str | httpx.URL | None = None, + headers: httpx.Headers | Mapping[str, str] | Sequence[tuple[str, str]] | None = None, + content: bytes | None = None, +) -> httpx.Request: + """Copy native fields without consuming a body; unchanged streams remain shared. + + Pass ``content=b""`` to remove a body. Timeout and other native extensions are + retained. Changing authority updates Host unless ``headers`` explicitly supplies + it. Unchanged streams retain their framing unless explicitly overridden. + A caller consuming a shared stream must replace it before returning. + """ + target_url = request.url if url is None else httpx.URL(url) + copied_headers = httpx.Headers(request.headers if headers is None else headers) + # Preserving a stream bypasses HTTPX's automatic Host header population. + if "host" not in copied_headers or (headers is None and target_url.netloc != request.url.netloc): + copied_headers["host"] = target_url.netloc.decode("ascii") + if content is not None: + copied_headers.pop("content-length", None) + copied_headers.pop("transfer-encoding", None) + else: + with suppress(httpx.RequestNotRead): + content = request.content + if content is not None: + return httpx.Request( + method or request.method, + target_url, + headers=copied_headers, + content=content, + extensions=dict(request.extensions), + ) + if "content-length" not in copied_headers and "transfer-encoding" not in copied_headers: + if "content-length" in request.headers: + copied_headers["content-length"] = request.headers["content-length"] + else: + copied_headers["transfer-encoding"] = request.headers.get("transfer-encoding", "chunked") + return httpx.Request( + method or request.method, + target_url, + headers=copied_headers, + stream=request.stream, + extensions=dict(request.extensions), + ) + + +class BodyStream(httpx.AsyncByteStream): + """Let HTTPX consume a fresh Sunday body factory for each transmission.""" + + def __init__(self, body: StreamingBody) -> None: + self.body = body + + async def __aiter__(self) -> AsyncIterator[bytes]: + content = self.body.content() + if isinstance(content, bytes): + yield content + elif isinstance(content, AsyncIterable): + async for chunk in content: + yield chunk + else: + for chunk in content: + yield chunk + + +def is_credentialed(request: httpx.Request) -> bool: + return "authorization" in request.headers or "cookie" in request.headers + + +def redirect_request(prepared: httpx.Request, sent: httpx.Request, response: httpx.Response) -> httpx.Request | None: + """Apply HTTPX's method semantics to adapted redirect headers without consuming bodies.""" + if is_credentialed(sent) or response.status_code not in {301, 302, 303, 307, 308}: + return None + if "location" not in response.headers: + return None + url = sent.url.join(response.headers["location"]) + if url.scheme not in {"http", "https"}: + return None + if not url.fragment and sent.url.fragment: + url = url.copy_with(fragment=sent.url.fragment) + get = (response.status_code in {302, 303} and sent.method != "HEAD") or ( + response.status_code == 301 and sent.method == "POST" + ) + if not get and ( + not isinstance(sent.stream, (httpx.ByteStream, BodyStream)) + or not isinstance(prepared.stream, (httpx.ByteStream, BodyStream)) + ): + return None + headers = httpx.Headers(prepared.headers) + headers.pop("host", None) + headers.pop("cookie", None) + if get: + for name in ("content-type", "content-length", "transfer-encoding"): + headers.pop(name, None) + return copy_request( + prepared, method="GET" if get else prepared.method, url=url, headers=headers, content=b"" if get else None + ) diff --git a/src/sunday/httpx/_response_cleanup.py b/src/sunday/httpx/_response_cleanup.py new file mode 100644 index 0000000..db435db --- /dev/null +++ b/src/sunday/httpx/_response_cleanup.py @@ -0,0 +1,60 @@ +# Copyright 2026 Outfox, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. + +from __future__ import annotations + +import asyncio +from collections.abc import AsyncIterator + +import httpx + +from ._async import complete, in_operation, run_io + + +class _ClosingStream(httpx.AsyncByteStream): + """Protect native cleanup, including closure initiated by HTTPX at EOF.""" + + def __init__(self, stream: httpx.AsyncByteStream) -> None: + self._stream = stream + self._cleanup: asyncio.Task[None] | None = None + + def __aiter__(self) -> AsyncIterator[bytes]: + return self._stream.__aiter__() if in_operation() else self._iterate() + + async def _iterate(self) -> AsyncIterator[bytes]: + iterator = self._stream.__aiter__() + while True: + try: + chunk = await run_io(lambda: anext(iterator)) + except StopAsyncIteration: + return + yield chunk + + async def aclose(self) -> None: + if self._cleanup is None: + self._cleanup = asyncio.create_task(self._stream.aclose()) + await complete(self._cleanup) + + +def protect_response(response: httpx.Response) -> None: + """Keep explicit and automatic response closure on the same protected path.""" + if not response.is_closed and not isinstance(response.stream, _ClosingStream): + assert isinstance(response.stream, httpx.AsyncByteStream) + response.stream = _ClosingStream(response.stream) + + +async def close_response(response: httpx.Response, error: BaseException | None = None) -> None: + """Finish response cleanup without replacing an existing failure.""" + try: + protect_response(response) + if response.is_closed and isinstance(response.stream, _ClosingStream): + # HTTPX sets is_closed before awaiting the stream's cleanup. + await response.stream.aclose() + else: + await response.aclose() + except BaseException: + if error is None: + raise + error.add_note("Closing the HTTP response also failed") diff --git a/src/sunday/httpx/_security.py b/src/sunday/httpx/_security.py index c7853c4..90ef43b 100644 --- a/src/sunday/httpx/_security.py +++ b/src/sunday/httpx/_security.py @@ -8,14 +8,15 @@ from __future__ import annotations import re +from collections.abc import Mapping from dataclasses import dataclass from urllib.parse import quote import httpx from ..security import SecurityBinding -from ..token_manager import TokenLease, TokenManager -from ..token_provider import TokenProviderError +from ..token_provider import TokenLease, TokenProvider, TokenProviderError, provider_credentials +from ._requests import copy_request @dataclass(frozen=True, slots=True) @@ -25,12 +26,10 @@ class RequestSecurity: bindings: tuple[SecurityBinding, ...] leases: tuple[TokenLease, ...] = () - async def authorize(self, request: httpx.Request, manager: TokenManager | None) -> RequestSecurity: + async def authorize(self, request: httpx.Request, providers: Mapping[str, TokenProvider]) -> RequestSecurity: """Attach the entire credential set after every provider succeeds.""" if not self.bindings: return self - if manager is None: - raise TokenProviderError() url, headers = request.url, httpx.Headers(request.headers) if "authorization" in headers and not any( binding.transport.location == "header" and binding.transport.name.lower() == "authorization" @@ -52,7 +51,9 @@ async def authorize(self, request: httpx.Request, manager: TokenManager | None) ): raise TokenProviderError() # Acquiring sequentially avoids leaving sibling tasks running when one provider fails. - leases = tuple([await manager.credentials(binding) for binding in self.bindings]) + if any(binding.provider not in providers for binding in self.bindings): + raise TokenProviderError() + leases = tuple([await provider_credentials(providers[binding.provider], binding) for binding in self.bindings]) for binding, lease in zip(self.bindings, leases, strict=True): transport = binding.transport credential = lease.tokens.access_token @@ -71,13 +72,8 @@ async def authorize(self, request: httpx.Request, manager: TokenManager | None) return RequestSecurity(self.bindings, leases) def rejected_leases(self, request: httpx.Request, response: httpx.Response) -> tuple[TokenLease, ...]: - """Recover only safe bodyless requests with an explicit invalid bearer token challenge.""" - if response.status_code != 401 or request.method not in {"GET", "HEAD", "OPTIONS"}: - return () - try: - if request.content: - return () - except httpx.RequestNotRead: + """Identify rejected receipts regardless of method safety or remaining retries.""" + if response.status_code != 401: return () if not _invalid_bearer_challenge(response.headers.get("www-authenticate", "")): return () @@ -87,6 +83,7 @@ def rejected_leases(self, request: httpx.Request, response: httpx.Response) -> t if binding.transport.location == "header" and binding.transport.name.lower() == "authorization" and (binding.transport.prefix or "").lower() == "bearer" + and _bearer_token(request) == lease.tokens.access_token ) def diagnostic_request(self, request: httpx.Request) -> httpx.Request: @@ -100,7 +97,7 @@ def diagnostic_request(self, request: httpx.Request) -> httpx.Request: headers[transport.name] = "[redacted]" else: headers["cookie"] = "[redacted]" - return httpx.Request(request.method, url, headers=headers) + return copy_request(request, url=url, headers=headers) def _cookies(headers: httpx.Headers) -> list[tuple[str, str]]: @@ -146,8 +143,29 @@ class AuthenticationRecoveryBudget: def __init__(self) -> None: self._used = False + def should_retry(self, request: httpx.Request, response: httpx.Response) -> bool: + """Allow one bodyless safe-method retry after explicit token rejection.""" + if ( + request.method not in {"GET", "HEAD", "OPTIONS"} + or response.status_code != 401 + or _bearer_token(request) is None + or not _invalid_bearer_challenge(response.headers.get("www-authenticate", "")) + ): + return False + try: + if request.content: + return False + except httpx.RequestNotRead: + return False + return self.consume() + def consume(self) -> bool: if self._used: return False self._used = True return True + + +def _bearer_token(request: httpx.Request) -> str | None: + parts = request.headers.get("authorization", "").split() + return parts[1] if len(parts) == 2 and parts[0].lower() == "bearer" else None diff --git a/src/sunday/httpx/_sse.py b/src/sunday/httpx/_sse.py index 931647a..689b264 100644 --- a/src/sunday/httpx/_sse.py +++ b/src/sunday/httpx/_sse.py @@ -7,10 +7,13 @@ import asyncio import inspect -from collections.abc import AsyncIterator, Callable -from contextlib import suppress +import sys +from collections.abc import AsyncGenerator, AsyncIterator, Callable, Iterator +from contextlib import contextmanager +from contextvars import ContextVar +from dataclasses import dataclass, field from types import TracebackType -from typing import TYPE_CHECKING +from typing import TYPE_CHECKING, Any from uuid import UUID, uuid4 import anyio @@ -19,21 +22,33 @@ from ..errors import TransportError, UnexpectedResponse from ..event_source import EventSourceErrorHandler, EventSourceMessageHandler, EventSourceOpenHandler, EventSourceState from ..media import MediaType +from ..request_cancellation_error import RequestCancellationError from ..specs import RequestSpec from ..sse import EventParser, EventStreamOptions, ServerSentEvent from ..token_provider import TokenProviderError +from ._async import complete, run_io from ._reconnect import _ReconnectPolicy -from ._security import AuthenticationRecoveryBudget +from ._response_cleanup import close_response +from ._security import AuthenticationRecoveryBudget, RequestSecurity if TYPE_CHECKING: from ._transport import HttpxEventSourceRequestFactory, HttpxTransport _KEEPALIVE_TIMEOUT_FLOOR = 1.0 +_io_owners: ContextVar[tuple[HttpxEventStream._IO, ...]] = ContextVar("sunday_event_stream_io_owners", default=()) class HttpxEventStream[EventT]: """Reconnectable HTTPX server-sent event stream.""" + @dataclass(frozen=True, slots=True) + class _IO: + """Completion of an I/O block, independent of the consumer's lifetime.""" + + scope: anyio.CancelScope + task: asyncio.Task[Any] | None = field(default_factory=asyncio.current_task) + done: anyio.Event = field(default_factory=anyio.Event) + def __init__( self, transport: HttpxTransport, @@ -57,7 +72,7 @@ def __init__( self._closed = False self._running = False self._response: httpx.Response | None = None - self._cancel_scope: anyio.CancelScope | None = None + self._active_io: HttpxEventStream._IO | None = None self._close_event: anyio.Event | None = None self._retry_time = self._options.retry @@ -82,24 +97,71 @@ async def __aexit__( traceback: TracebackType | None, ) -> None: """Close the event stream when leaving its lifecycle scope.""" - del exc_type, exc_value, traceback - await self.aclose() + del exc_type, traceback + await self._close(exc_value) async def aclose(self) -> None: - """Close the active response and interrupt reads or retry waits.""" + """Interrupt active work and wait for its I/O and response cleanup. + + A call from within this stream's active adapter or native hook requests + closure without waiting on itself; external callers join completion. + """ + await self._close() + + async def _close(self, error: BaseException | None = None) -> None: self._close_nowait() - if self._response is not None: - with anyio.CancelScope(shield=True): - await self._response.aclose() + active = self._active_io + # Adapter and native-hook child tasks inherit their I/O ownership. They + # cannot join an attempt that is waiting for that same callback to return. + if active is not None and any(owner is active for owner in _io_owners.get()): + return + try: + if active is None: + await self._release_response() + else: + await complete(asyncio.create_task(self._finish_close(active))) + except BaseException: + if error is None: + raise + error.add_note("Closing the HTTP response also failed") + + async def _finish_close(self, active: _IO) -> None: + await active.done.wait() + await self._release_response() + + async def _release_response(self, error: BaseException | None = None) -> None: + response = self._response + if response is not None: + try: + await close_response(response, error) + finally: + if self._response is response: + self._response = None + + @contextmanager + def _interruptible(self) -> Iterator[None]: + """Interrupt active I/O without leaving a cancel scope around a yielded event.""" + with anyio.CancelScope() as scope: + active = self._IO(scope) + self._active_io = active + token = _io_owners.set((*_io_owners.get(), active)) + try: + if self._closed: + scope.cancel() + yield + finally: + _io_owners.reset(token) + self._active_io = None + active.done.set() def _close_nowait(self) -> None: self._closed = True if self._close_event is not None: self._close_event.set() - if self._cancel_scope is not None: - self._cancel_scope.cancel() + if self._active_io is not None: + self._active_io.scope.cancel() - async def events(self) -> AsyncIterator[EventT]: + async def events(self) -> AsyncGenerator[EventT, None]: """Connect, reconnect, and yield decoded server-sent events.""" if self._running: raise TransportError("An event stream supports only one active consumer") @@ -110,12 +172,11 @@ async def events(self) -> AsyncIterator[EventT]: recovery_budget = AuthenticationRecoveryBudget() try: - with anyio.CancelScope() as cancel_scope: - self._cancel_scope = cancel_scope - while not self._closed: - response: httpx.Response | None = None - connected = False - try: + while not self._closed: + response: httpx.Response | None = None + connected = False + try: + with self._interruptible(): headers = [("Accept", "text/event-stream"), ("Cache-Control", "no-store")] if last_event_id is not None: headers.append(("Last-Event-ID", last_event_id)) @@ -124,72 +185,76 @@ async def events(self) -> AsyncIterator[EventT]: else: request_value = self._request_factory(tuple(headers)) request = await request_value if inspect.isawaitable(request_value) else request_value - request = await self._transport._adapt_request(request) self._disable_httpx_read_timeout(request) - response = await self._transport._send_event_stream(request, recovery_budget=recovery_budget) + response = await self._transport._send_event_stream( + request, + recovery_budget=recovery_budget, + security=RequestSecurity(self._spec.security) if self._spec.security is not None else None, + ) self._response = response if response.status_code == 204: return if not 200 <= response.status_code < 300: - body = await response.aread() + body = await run_io(response.aread) self._transport.raise_problem(response, body) self._validate_content_type(response) - connected = True - reconnect.opened() - if self._on_open is not None: - self._on_open() - - parser = EventParser() - timeout_state: list[float | None] = [None] - - def current_timeout(state: list[float | None] = timeout_state) -> float | None: - return state[0] - - async for chunk in self._chunks(response, current_timeout): - for event in parser.feed(chunk): - timeout_state[0], last_event_id = self._apply_controls( - event, - reconnect, - timeout_state[0], - last_event_id, - ) - if event.data is not None: - decoded = self._decoder(event) - if decoded is not None: - yield decoded - for event in parser.finalize(): + if self._closed: + return + connected = True + reconnect.opened() + if self._on_open is not None: + self._on_open() + + parser = EventParser() + timeout_state: list[float | None] = [None] + + def current_timeout(state: list[float | None] = timeout_state) -> float | None: + return state[0] + + async for chunk in self._chunks(response, current_timeout): + for event in parser.feed(chunk): timeout_state[0], last_event_id = self._apply_controls( - event, - reconnect, - timeout_state[0], - last_event_id, + event, reconnect, timeout_state[0], last_event_id ) if event.data is not None: decoded = self._decoder(event) if decoded is not None: yield decoded - except (httpx.TransportError, TimeoutError, TokenProviderError) as error: - if isinstance(error, TokenProviderError) and error.reason != "temporary": - raise - if self._closed: - return - if self._on_error is not None: - self._on_error(error) - finally: - if response is not None: - with anyio.CancelScope(shield=True): - await response.aclose() - self._response = None - + if self._closed: + return if self._closed: return - if self._on_connecting is not None: - self._on_connecting() - delay = reconnect.next_delay(failed=not connected) - await self._wait_for_retry(delay) + for event in parser.finalize(): + timeout_state[0], last_event_id = self._apply_controls( + event, reconnect, timeout_state[0], last_event_id + ) + if event.data is not None: + decoded = self._decoder(event) + if decoded is not None: + yield decoded + if self._closed: + return + except RequestCancellationError: + raise + except (httpx.TransportError, TimeoutError, TokenProviderError) as error: + if isinstance(error, TokenProviderError) and error.reason != "temporary": + raise + if self._closed: + return + if self._on_error is not None: + self._on_error(error) + finally: + await self._release_response(sys.exception()) + + if self._closed: + return + if self._on_connecting is not None: + self._on_connecting() + delay = reconnect.next_delay(failed=not connected) + await self._wait_for_retry(delay) finally: - self._cancel_scope = None + self._active_io = None self._close_event = None self._running = False @@ -199,16 +264,19 @@ async def _chunks( timeout: Callable[[], float | None], ) -> AsyncIterator[bytes]: iterator = response.aiter_bytes().__aiter__() - while True: + while not self._closed: try: - current_timeout = timeout() - if current_timeout is None: - chunk = await anext(iterator) - else: - with anyio.fail_after(current_timeout): - chunk = await anext(iterator) + with self._interruptible(): + current_timeout = timeout() + if current_timeout is None: + chunk = await run_io(lambda: anext(iterator)) + else: + with anyio.fail_after(current_timeout): + chunk = await run_io(lambda: anext(iterator)) except StopAsyncIteration: return + if self._closed: + return yield chunk async def _wait_for_retry(self, delay: float) -> None: @@ -265,13 +333,15 @@ def __init__( request_factory: HttpxEventSourceRequestFactory, *, options: EventStreamOptions | None = None, + spec: RequestSpec[None] | None = None, ) -> None: self._transport = transport self._request_factory = request_factory self._options = options or EventStreamOptions() + self._spec = spec or RequestSpec("GET", "/") self._ready_state = EventSourceState.CLOSED self._stream: HttpxEventStream[ServerSentEvent] | None = None - self._task: asyncio.Task[None] | None = None + self._tasks: set[asyncio.Task[None]] = set() self._listeners: dict[str, dict[UUID, EventSourceMessageHandler]] = {} self.on_open: EventSourceOpenHandler | None = None self.on_error: EventSourceErrorHandler | None = None @@ -311,59 +381,73 @@ def connect(self) -> None: raise TransportError("HttpxTransport is closed") self._ready_state = EventSourceState.CONNECTING self._transport._event_source_started(self) - self._stream = HttpxEventStream( + stream = HttpxEventStream( self._transport, - RequestSpec("GET", "/"), + self._spec, lambda event: event, options=self._options, request_factory=self._request_factory, - on_open=self._opened, - on_error=self._retrying, - on_connecting=self._connecting, + on_open=lambda: self._opened(stream), + on_error=lambda error: self._retrying(stream, error), + on_connecting=lambda: self._connecting(stream), ) - self._task = loop.create_task(self._run(), name="sunday-httpx-event-source") + self._stream = stream + task = loop.create_task(self._run(stream), name="sunday-httpx-event-source") + self._tasks.add(task) + task.add_done_callback(self._finished) def close(self) -> None: """Close the source and interrupt active reads or reconnect waits.""" self._ready_state = EventSourceState.CLOSED if self._stream is not None: self._stream._close_nowait() - if self._task is not None: - self._task.cancel() - else: + if not self._tasks: self._transport._event_source_closed(self) + def _owns_current_io(self) -> bool: + # Native hook child tasks inherit the initiating run's I/O record. Include + # retiring runs, whose streams may no longer be self._stream. + return any(owner.task in self._tasks and not owner.done.is_set() for owner in _io_owners.get()) + async def _wait_closed(self) -> None: - task = self._task - if task is not None: - with suppress(asyncio.CancelledError): - await task + if self._tasks: + await asyncio.wait(tuple(self._tasks)) - async def _run(self) -> None: + async def _run(self, stream: HttpxEventStream[ServerSentEvent]) -> None: try: - assert self._stream is not None - async for event in self._stream: - self._dispatch(event) + if not stream._closed: + async with stream: + async for event in stream: + if self._stream is stream: + self._dispatch(event) except asyncio.CancelledError: raise except BaseException as error: - self._invoke(self.on_error, error) + if self._stream is stream: + self._invoke(self.on_error, error) finally: - if self._stream is not None: - await self._stream.aclose() - self._ready_state = EventSourceState.CLOSED + if self._stream is stream: + self._ready_state = EventSourceState.CLOSED + + def _finished(self, task: asyncio.Task[None]) -> None: + # Retiring runs still own resources even after a replacement has connected. + self._tasks.discard(task) + if not self._tasks: self._transport._event_source_closed(self) - def _opened(self) -> None: - self._ready_state = EventSourceState.OPEN - self._invoke(self.on_open) + def _opened(self, stream: HttpxEventStream[ServerSentEvent]) -> None: + if self._stream is stream: + self._ready_state = EventSourceState.OPEN + self._invoke(self.on_open) - def _retrying(self, error: BaseException) -> None: - self._ready_state = EventSourceState.CONNECTING - self._invoke(self.on_error, error) + def _retrying(self, stream: HttpxEventStream[ServerSentEvent], error: BaseException) -> None: + if self._stream is stream: + self._ready_state = EventSourceState.CONNECTING + self._invoke(self.on_error, error) - def _connecting(self) -> None: - self._ready_state = EventSourceState.CONNECTING + def _connecting(self, stream: HttpxEventStream[ServerSentEvent]) -> None: + if self._stream is stream: + self._ready_state = EventSourceState.CONNECTING def _dispatch(self, event: ServerSentEvent) -> None: self._invoke(self.on_message, event) diff --git a/src/sunday/httpx/_transport.py b/src/sunday/httpx/_transport.py index bd8f122..215f268 100644 --- a/src/sunday/httpx/_transport.py +++ b/src/sunday/httpx/_transport.py @@ -5,13 +5,12 @@ from __future__ import annotations -from collections.abc import AsyncIterable, Awaitable, Callable, Iterable, Mapping, Sequence +import asyncio +from collections.abc import Awaitable, Callable, Mapping, Sequence from time import monotonic -from types import TracebackType +from types import MappingProxyType, TracebackType from typing import Any, Protocol, TypeVar -from weakref import WeakKeyDictionary -import anyio import httpx from ..client_settings import ClientSettings @@ -29,13 +28,19 @@ from ..operations import OperationResponse from ..parameters import encode_parameters from ..problems import Problem, ProblemRegistry +from ..request_cancellation_error import RequestCancellationError from ..specs import RequestSpec, ResponseSpec from ..sse import EventStreamOptions, ServerSentEvent from ..streaming import StreamingBody -from ..token_manager import TokenManager +from ..token_provider import TokenProvider, TokenRejectedError from ..transport import BaseTransport from ..uri import URITemplate +from ._async import complete, run_io +from ._requests import BodyStream, copy_request, is_credentialed, redirect_request +from ._response_cleanup import close_response, protect_response from ._security import AuthenticationRecoveryBudget, RequestSecurity +from .request_adapter import RequestAdapterLike, RequestAdapters +from .response_adapter import ResponseAdapterLike, ResponseAdapters ResponseT = TypeVar("ResponseT") @@ -71,9 +76,11 @@ def __init__( encoders: MediaTypeEncoders | None = None, decoders: MediaTypeDecoders | None = None, adapters: Sequence[HttpxRequestAdapter | HttpxRequestAdapterCallable] = (), + request_adapter: RequestAdapterLike | None = None, + response_adapter: ResponseAdapterLike | None = None, observers: Sequence[TransportObserver] = (), sensitive_headers: Sequence[str] = (), - token_manager: TokenManager | None = None, + token_providers: Mapping[str, TokenProvider] | None = None, ) -> None: if client is not None and base_url is not None: raise TransportError("base_url cannot be provided with a borrowed HTTPX client") @@ -85,9 +92,14 @@ def __init__( self.adapters = tuple(adapters) self.observers = tuple(observers) self.sensitive_headers = tuple(sensitive_headers) - self.token_manager = token_manager - self._request_security: WeakKeyDictionary[httpx.Request, RequestSecurity] = WeakKeyDictionary() + self.token_providers = MappingProxyType(dict(token_providers or {})) + self._request_adapter = RequestAdapters( + *((self._adapt_legacy_request,) if self.adapters else ()), + *((request_adapter,) if request_adapter is not None else ()), + ) + self._response_adapter = ResponseAdapters(*((response_adapter,) if response_adapter is not None else ())) self._closed = False + self._cleanup: asyncio.Task[None] | None = None self._event_sources: set[HttpxEventSource] = set() @classmethod @@ -95,30 +107,39 @@ def from_settings(cls, settings: ClientSettings, client: httpx.AsyncClient) -> H """Use a borrowed application client for API and isolated OAuth requests. The client's base URL must match the resolved endpoint. The caller owns its lifetime. - For other transport options, pass ``settings.token_manager`` to the normal constructor. + For other transport options, pass ``settings.token_providers`` to the normal constructor. """ if str(client.base_url).rstrip("/") != str(httpx.URL(settings.base_url)).rstrip("/"): raise ValueError("HTTPX client base URL must match resolved settings") - return cls(client, token_manager=settings.token_manager) + return cls(client, token_providers=settings.token_providers) def register_problem(self, type_uri: str, problem_type: type[Problem]) -> None: """Register a generated problem exception for response decoding.""" self.problem_registry.register(type_uri, problem_type) + async def transport_request(self, spec: RequestSpec[Any]) -> httpx.Request: + """Materialize an optionally authorized request, handing its lifecycle to the consumer.""" + request = await self._prepare_request(spec) + if spec.security is not None: + await RequestSecurity(spec.security).authorize(request, self.token_providers) + return await self._request_adapter.adapt(request) + async def _prepare_request(self, spec: RequestSpec[Any]) -> httpx.Request: - """Build and adapt an HTTPX request from a declarative specification.""" + """Build without adapting; execution and export each own their adaptation step.""" if self._closed: raise TransportError("HttpxTransport is closed") - request = self._build_request(spec) - adapted = await self._adapt_request(request) - if adapted is not request and request in self._request_security: - self._request_security[adapted] = self._request_security[request] - return adapted + return self._build_request(spec) + + async def execute_request(self, spec: RequestSpec[Any]) -> httpx.Response: + """Execute with invocation-local security receipts and no request-attached state.""" + request = await self._prepare_request(spec) + security = RequestSecurity(spec.security) if spec.security is not None else None + return await self._execute(request, stream=False, security=security) def _build_request(self, spec: RequestSpec[Any]) -> httpx.Request: try: return self._build_validated_request(spec) - except RequestEncodingError: + except (RequestEncodingError, RequestCancellationError): raise except (TypeError, ValueError) as error: raise RequestEncodingError( @@ -193,17 +214,7 @@ def _build_validated_request(self, spec: RequestSpec[Any]) -> httpx.Request: content = body.content() headers["content-type"] = str(body.content_type) elif isinstance(body, StreamingBody): - streaming_content = body.content() - if isinstance(streaming_content, (bytes, AsyncIterable)): - content = streaming_content - else: - iterable_content: Iterable[bytes] = streaming_content - - async def async_content() -> AsyncIterable[bytes]: - for chunk in iterable_content: - yield chunk - - content = async_content() + content = BodyStream(body) content_type = self._raw_content_type(headers, content_types) if content_type is not None and "content-type" not in headers: headers["content-type"] = str(content_type) @@ -215,6 +226,8 @@ async def async_content() -> AsyncIterable[bytes]: ) try: content_type, encoder = self._encoded_content_type(headers, content_types, default) + except RequestCancellationError: + raise except RequestEncodingError: if not isinstance(body, (bytes, bytearray, memoryview)): raise @@ -223,6 +236,8 @@ async def async_content() -> AsyncIterable[bytes]: else: try: content = encoder.encode(body) + except RequestCancellationError: + raise except (TypeError, ValueError) as error: raise RequestEncodingError( "Request body encoding failed", @@ -232,11 +247,11 @@ async def async_content() -> AsyncIterable[bytes]: headers["content-type"] = str(content_type) request = self.client.build_request(spec.method.upper(), path, headers=headers, content=content) - if spec.security is not None: - if spec.security and "authorization" not in headers: - # A borrowed client's default credentials are not part of the selected alternative. - request.headers.pop("authorization", None) - self._request_security[request] = RequestSecurity(spec.security) + if isinstance(content, BodyStream): + request.stream = content + if spec.security and "authorization" not in headers: + # A borrowed client's default credentials are not part of the selected alternative. + request.headers.pop("authorization", None) return request def _header_media_type(self, headers: httpx.Headers, name: str) -> MediaType | None: @@ -276,67 +291,95 @@ def _encoded_content_type( details={"content_types": tuple(str(item) for item in candidates)}, ) - async def _adapt_request(self, request: httpx.Request) -> httpx.Request: + async def _adapt_legacy_request(self, request: httpx.Request) -> httpx.Request: for adapter in self.adapters: adapt = getattr(adapter, "adapt", None) adapted = await adapt(self, request) if adapt is not None else await adapter(self, request) # type: ignore[operator] if adapted is not None: - if adapted is not request and request in self._request_security: - self._request_security[adapted] = self._request_security[request] request = adapted return request - async def _authorize_request(self, request: httpx.Request) -> RequestSecurity | None: - security = self._request_security.get(request) - if security is not None: - security = await security.authorize(request, self.token_manager) - self._request_security[request] = security - return security - async def _send(self, request: httpx.Request, *, stream: bool = False) -> httpx.Response: - """Send a native HTTPX request.""" - return await self._send_authorized(request, stream=stream) + return await self._execute(request, stream=stream) async def _send_event_stream( - self, request: httpx.Request, *, recovery_budget: AuthenticationRecoveryBudget + self, + request: httpx.Request, + *, + recovery_budget: AuthenticationRecoveryBudget, + security: RequestSecurity | None = None, ) -> httpx.Response: - return await self._send_authorized(request, stream=True, follow_redirects=True, recovery_budget=recovery_budget) + return await self._execute( + request, stream=True, follow_redirects=True, recovery_budget=recovery_budget, security=security + ) - async def _send_authorized( + async def _execute( self, request: httpx.Request, *, stream: bool, follow_redirects: bool | None = None, recovery_budget: AuthenticationRecoveryBudget | None = None, + security: RequestSecurity | None = None, ) -> httpx.Response: budget = recovery_budget or AuthenticationRecoveryBudget() - security = await self._authorize_request(request) - # This is the sole owner of authentication replay for one transport invocation. - response = await self._send_httpx(request, stream=stream, follow_redirects=follow_redirects) - rejected = security.rejected_leases(request, response) if security is not None else () - if rejected and self.token_manager is not None and budget.consume(): - with anyio.CancelScope(shield=True): - await response.aclose() - for lease in rejected: - await self.token_manager.invalidate(lease) - await self._authorize_request(request) - response = await self._send_httpx(request, stream=stream, follow_redirects=follow_redirects) - if security is not None and security.bindings: - response.request = security.diagnostic_request(request) - return response + follow = self.client.follow_redirects if follow_redirects is None else follow_redirects + prepared = request + redirects = 0 + history: list[httpx.Response] = [] + while True: + sent = copy_request(prepared) + authorized = await security.authorize(sent, self.token_providers) if security is not None else None + sent = await self._request_adapter.adapt(sent) + response = await self._send_httpx(sent, security=authorized) + try: + response.history = [*history, *response.history] + effective = copy_request(response.request) + if authorized is not None: + recoverable = True + for lease in authorized.rejected_leases(effective, response): + recoverable = await lease.invalidate() and recoverable + if not recoverable: + raise TokenRejectedError() + response = await self._response_adapter.adapt(response, effective) + if budget.should_retry(effective, response): + await close_response(response) + continue + next_request = ( + redirect_request(prepared, effective, response) + if follow and not (authorized is not None and authorized.bindings) + else None + ) + if next_request is not None: + self.client.cookies.set_cookie_header(next_request) + redirects += 1 + if redirects > self.client.max_redirects: + raise httpx.TooManyRedirects("Exceeded maximum allowed redirects", request=effective) + # HTTPX buffers intermediate redirect bodies even when the final response streams. + await run_io(response.aread) + await close_response(response) + history = [*response.history, response] + prepared = next_request + continue + if authorized is not None and authorized.bindings: + response.request = authorized.diagnostic_request(effective) + if not stream: + await run_io(response.aread) + await close_response(response) + return response + except BaseException as error: + await close_response(response, error) + raise async def _send_httpx( self, request: httpx.Request, *, - stream: bool, - follow_redirects: bool | None = None, + security: RequestSecurity | None = None, ) -> httpx.Response: if self._closed: raise TransportError("HttpxTransport is closed") started = monotonic() - security = self._request_security.get(request) diagnostic = security.diagnostic_request(request) if security is not None and security.bindings else request self._observe( TransportEvent( @@ -347,38 +390,52 @@ async def _send_httpx( ) ) try: - if security is not None and security.bindings: - # HTTPX only strips standard Authorization on cross-origin redirects. Managed API keys - # must not follow redirects or allow native auth to overwrite a selected alternative. - response = await self.client.send(request, stream=stream, follow_redirects=False, auth=None) - elif follow_redirects is None: - response = await self.client.send(request, stream=stream) + if (security is not None and security.bindings) or is_credentialed(request): + response = await run_io( + lambda: self.client.send(request, stream=True, follow_redirects=False, auth=None), + discard=close_response, + ) else: - response = await self.client.send(request, stream=stream, follow_redirects=follow_redirects) + response = await run_io( + lambda: self.client.send(request, stream=True, follow_redirects=False), + discard=close_response, + ) except BaseException as error: - if diagnostic is not request and isinstance(error, httpx.RequestError): + if ( + diagnostic is not request + and isinstance(error, httpx.RequestError) + and not isinstance(error, RequestCancellationError) + ): error = type(error)("HTTP request failed", request=diagnostic) + try: + self._observe( + TransportEvent( + TransportEventKind.FAILURE, + request.method, + str(diagnostic.url), + (), + elapsed=monotonic() - started, + error=error, + ) + ) + except BaseException: + error.add_note("Reporting the HTTP request failure also failed") + raise error from None + protect_response(response) + try: self._observe( TransportEvent( - TransportEventKind.FAILURE, + TransportEventKind.RESPONSE, request.method, str(diagnostic.url), - (), + redact_headers(response.headers.multi_items(), self.sensitive_headers), + status=response.status_code, elapsed=monotonic() - started, - error=error, ) ) - raise error from None - self._observe( - TransportEvent( - TransportEventKind.RESPONSE, - request.method, - str(diagnostic.url), - redact_headers(response.headers.multi_items(), self.sensitive_headers), - status=response.status_code, - elapsed=monotonic() - started, - ) - ) + except BaseException as error: + await close_response(response, error) + raise return response async def _decode_response( @@ -387,19 +444,7 @@ async def _decode_response( responses: Sequence[ResponseSpec[Any]], ) -> OperationResponse[Any, httpx.Response]: """Decode a successful response or raise its typed problem.""" - body = await response.aread() - try: - return self._decode_buffered_response(response, body, responses) - finally: - with anyio.CancelScope(shield=True): - await response.aclose() - - def _decode_buffered_response( - self, - response: httpx.Response, - body: bytes, - responses: Sequence[ResponseSpec[Any]], - ) -> OperationResponse[Any, httpx.Response]: + body = response.content if not 200 <= response.status_code < 300: self.raise_problem(response, body) @@ -432,6 +477,8 @@ def _decode_buffered_response( try: decoded = decoder.decode(body, content_type) if decoder is not None else body result = response_spec.decoder(decoded) if response_spec.decoder is not None else decoded + except RequestCancellationError: + raise except (TypeError, ValueError) as error: raise ResponseDecodingError( "Response body decoding failed", @@ -459,6 +506,8 @@ def _decode_headers( continue try: converted = tuple(header.decoder(value) if header.decoder is not None else value for value in values) + except RequestCancellationError: + raise except (TypeError, ValueError) as error: raise self._unexpected(response, body, f"Invalid response header {header.name}: {error}") from error decoded[header.name] = converted if header.repeated else converted[0] @@ -507,7 +556,11 @@ def event_source( async def request_factory(headers: tuple[tuple[str, str], ...]) -> httpx.Request: return self._build_request(spec.with_headers(*headers)) - return self.event_source_from(request_factory, options=options) + from ._sse import HttpxEventSource + + source = HttpxEventSource(self, request_factory, options=options, spec=spec) + self._event_sources.add(source) + return source def event_source_from( self, @@ -542,13 +595,23 @@ def _observe(self, event: TransportEvent) -> None: observer.observe(event) async def aclose(self) -> None: - """Close owned event sources and the internal HTTPX client exactly once.""" - if self._closed: + """Close owned event sources and the internal HTTPX client exactly once. + + Calls from an owned EventSource's active adapter or native hook request + shutdown without joining their own run. External callers await completion. + """ + if self._cleanup is None: + self._closed = True + sources = tuple(self._event_sources) + for source in sources: + source.close() + self._cleanup = asyncio.create_task(self._close()) + if any(source._owns_current_io() for source in self._event_sources): return - self._closed = True + await complete(self._cleanup) + + async def _close(self) -> None: sources = tuple(self._event_sources) - for source in sources: - source.close() for source in sources: await source._wait_closed() if self._owns_client: @@ -567,8 +630,13 @@ async def __aexit__( traceback: TracebackType | None, ) -> None: """Close transport-owned resources when leaving a lifecycle scope.""" - del exc_type, exc_value, traceback - await self.aclose() + del exc_type, traceback + try: + await self.aclose() + except BaseException: + if exc_value is None: + raise + exc_value.add_note("Closing the HTTP transport also failed") from ._sse import HttpxEventSource as HttpxEventSource # noqa: E402 diff --git a/src/sunday/httpx/request_adapter.py b/src/sunday/httpx/request_adapter.py new file mode 100644 index 0000000..a6a4d9e --- /dev/null +++ b/src/sunday/httpx/request_adapter.py @@ -0,0 +1,50 @@ +# Copyright 2026 Outfox, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. + +from __future__ import annotations + +from abc import ABC, abstractmethod +from collections.abc import Awaitable, Callable + +import anyio +import httpx + + +class RequestAdapter(ABC): + """Adapt once before each Sunday-managed native call, or once for export. + + Consumed resources must be replaced before returning. Native client recovery + inside a call may resend the adapted request without invoking this adapter. + """ + + @abstractmethod + async def adapt(self, request: httpx.Request) -> httpx.Request: + """Return the request to send; raising stops the remaining adapters.""" + + def chain_to(self, next_adapter: RequestAdapterLike) -> RequestAdapters: + """Compose adapters in order, flattening existing chains.""" + return RequestAdapters(self, next_adapter) + + +type RequestAdapterLike = RequestAdapter | Callable[[httpx.Request], Awaitable[httpx.Request]] + + +class RequestAdapters(RequestAdapter): + """An immutable ordered chain of adapters or asynchronous functions.""" + + def __init__(self, *adapters: RequestAdapterLike) -> None: + self.adapters: tuple[RequestAdapterLike, ...] = tuple( + child + for adapter in adapters + for child in (adapter.adapters if isinstance(adapter, RequestAdapters) else (adapter,)) + ) + + async def adapt(self, request: httpx.Request) -> httpx.Request: + """Run each adapter once, preserving native task cancellation.""" + for adapter in self.adapters: + await anyio.lowlevel.checkpoint_if_cancelled() + request = await adapter.adapt(request) if isinstance(adapter, RequestAdapter) else await adapter(request) + await anyio.lowlevel.checkpoint_if_cancelled() + return request diff --git a/src/sunday/httpx/response_adapter.py b/src/sunday/httpx/response_adapter.py new file mode 100644 index 0000000..dff38d7 --- /dev/null +++ b/src/sunday/httpx/response_adapter.py @@ -0,0 +1,63 @@ +# Copyright 2026 Outfox, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. + +from __future__ import annotations + +from abc import ABC, abstractmethod +from collections.abc import Awaitable, Callable + +import anyio +import httpx + +from ._response_cleanup import close_response, protect_response + + +class ResponseAdapter(ABC): + """Adapt returned headers before Sunday reads the body or applies retry policy. + + Native recovery's intermediate responses are not delivered. The request is + the effective request associated with the returned response. An adapter that + consumes or replaces a resource must close it and provide its replacement. + """ + + @abstractmethod + async def adapt(self, response: httpx.Response, request: httpx.Request) -> httpx.Response: + """Return the response to handle; raising stops the remaining adapters.""" + + def chain_to(self, next_adapter: ResponseAdapterLike) -> ResponseAdapters: + """Compose response adapters independently of request adapters.""" + return ResponseAdapters(self, next_adapter) + + +type ResponseAdapterLike = ResponseAdapter | Callable[[httpx.Response, httpx.Request], Awaitable[httpx.Response]] + + +class ResponseAdapters(ResponseAdapter): + """An immutable ordered chain of adapters or asynchronous functions.""" + + def __init__(self, *adapters: ResponseAdapterLike) -> None: + self.adapters: tuple[ResponseAdapterLike, ...] = tuple( + child + for adapter in adapters + for child in (adapter.adapters if isinstance(adapter, ResponseAdapters) else (adapter,)) + ) + + async def adapt(self, response: httpx.Response, request: httpx.Request) -> httpx.Response: + """Run the chain, closing the current response if an adapter fails.""" + protect_response(response) + try: + for adapter in self.adapters: + await anyio.lowlevel.checkpoint_if_cancelled() + response = ( + await adapter.adapt(response, request) + if isinstance(adapter, ResponseAdapter) + else await adapter(response, request) + ) + protect_response(response) + await anyio.lowlevel.checkpoint_if_cancelled() + return response + except BaseException as error: + await close_response(response, error) + raise diff --git a/src/sunday/operations.py b/src/sunday/operations.py index 574de45..fe1c8c6 100644 --- a/src/sunday/operations.py +++ b/src/sunday/operations.py @@ -12,6 +12,7 @@ from .headers import ResponseHeaders from .media import MediaType from .problems import Problem +from .request_cancellation_error import RequestCancellationError from .specs import NullifySpec, OperationSpec if TYPE_CHECKING: @@ -68,7 +69,7 @@ async def transport_request(self) -> TransportRequestT: async def transport_response(self) -> TransportResponseT: """Send a fresh native request and return its native response.""" - return await self.transport.transport_response(await self.transport_request()) + return await self.transport.execute_request(self.spec.request) class StreamingOperation[ResponseT, TransportRequestT, TransportResponseT]( @@ -105,6 +106,8 @@ async def response_or_none(self) -> OperationResponse[ResponseT, TransportRespon """Return ``None`` when a configured problem is raised.""" try: return await self.response() + except RequestCancellationError: + raise except Problem as problem: if self._matches(problem): return None diff --git a/src/sunday/request_cancellation_error.py b/src/sunday/request_cancellation_error.py new file mode 100644 index 0000000..262cda0 --- /dev/null +++ b/src/sunday/request_cancellation_error.py @@ -0,0 +1,13 @@ +# Copyright 2026 Outfox, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. + + +class RequestCancellationError(Exception): + """Stop this request without wrapping, retrying, or reconnecting. + + Subclass this exception (optionally alongside a framework exception) to veto + further work. Ordinary errors still follow the transport's normal policy. + This does not cancel the caller's asyncio task. + """ diff --git a/src/sunday/token_manager.py b/src/sunday/token_manager.py index e2995d4..f3d60c3 100644 --- a/src/sunday/token_manager.py +++ b/src/sunday/token_manager.py @@ -11,30 +11,27 @@ import math from collections.abc import AsyncIterator, Callable, Mapping from contextlib import asynccontextmanager -from dataclasses import dataclass, field, fields, replace +from dataclasses import dataclass, field, replace from time import time from typing import cast +from uuid import uuid4 +from .request_cancellation_error import RequestCancellationError from .security import SecurityBinding from .token_provider import ( AuthorizationRequiredError, RefreshingTokenProvider, + TokenConfiguration, + TokenLease, TokenProvider, TokenProviderError, TokenRequest, TokenSet, TokenStore, + _resolve_token_request, ) -@dataclass(frozen=True, slots=True) -class TokenLease: - """Receipt for invalidating only the credential that a server rejected.""" - - key: str = field(repr=False) - tokens: TokenSet = field(repr=False) - - @dataclass(slots=True) class _Renewal: task: asyncio.Task[TokenLease] @@ -58,7 +55,7 @@ class TokenManager: def __init__( self, - providers: Mapping[str, TokenProvider], + providers: Mapping[str, TokenProvider] | TokenProvider, *, store: TokenStore | None = None, expiry_skew: float = 30, @@ -66,7 +63,9 @@ def __init__( ) -> None: if not math.isfinite(expiry_skew) or expiry_skew < 0: raise ValueError("Invalid token expiry skew") - self._providers = dict(providers) + self._provider = None if isinstance(providers, Mapping) else providers + self._providers = dict(providers) if isinstance(providers, Mapping) else {} + self.identity = self._provider.identity if self._provider is not None else str(uuid4()) self._store = store if store is not None else _MemoryTokenStore() self._skew = expiry_skew self._now = now @@ -74,6 +73,15 @@ def __init__( self._locks: dict[str, _Lock] = {} self._authorization_attempts: set[bytes] = set() + def configure(self, binding: SecurityBinding) -> TokenConfiguration: + """Forward configuration to the explicitly managed provider.""" + provider = self._provider if self._provider is not None else self._providers[binding.provider] + return provider.configure(binding) + + async def acquire(self, request: TokenRequest) -> TokenSet: + """Acquire managed credentials; transports use receipts to preserve rejection identity.""" + return (await self.credentials(request)).tokens + async def credentials(self, binding: SecurityBinding) -> TokenLease: """Obtain current credentials without reusing a failed or consumed authorization grant.""" # Honor a pending caller cancellation before creating work in an independent task. @@ -87,7 +95,14 @@ async def credentials(self, binding: SecurityBinding) -> TokenLease: task.add_done_callback(lambda completed: self._finished(key, completed)) renewal.waiters += 1 try: - return await asyncio.shield(renewal.task) + await asyncio.wait((renewal.task,)) + lease = renewal.task.result() + + async def reject() -> bool: + await self.invalidate(lease) + return True + + return replace(lease, rejection=reject) finally: renewal.waiters -= 1 if renewal.waiters == 0 and not renewal.committing and not renewal.task.done(): @@ -100,27 +115,17 @@ async def invalidate(self, lease: TokenLease) -> None: current = await self._store.load(lease.key) if current is not None and current.access_token == lease.tokens.access_token: await self._store.save(lease.key, replace(current, expires_at=0)) + except RequestCancellationError: + raise except Exception: raise TokenProviderError() from None def _resolve(self, binding: SecurityBinding) -> tuple[TokenProvider, TokenRequest, str]: try: - provider = self._providers[binding.provider] - config = provider.configure(binding) - if not provider.identity.strip() or not config.client_identity.strip(): - raise TokenProviderError() - if binding.flow == "authorizationCode" and not (config.grant_identity or "").strip(): + provider = self._provider if self._provider is not None else self._providers[binding.provider] + request = _resolve_token_request(provider, binding) + if request.flow == "authorizationCode" and not (request.grant_identity or "").strip(): raise TokenProviderError() - values = {item.name: getattr(binding, item.name) for item in fields(binding)} - if config.endpoints is not None: - for item in fields(config.endpoints): - value = getattr(config.endpoints, item.name) - if value is not None: - values[item.name] = value - values["scopes"] = tuple(sorted(set(binding.scopes))) - request = TokenRequest( - **values, client_identity=config.client_identity, grant_identity=config.grant_identity - ) key = json.dumps( [ request.scheme, @@ -141,6 +146,8 @@ def _resolve(self, binding: SecurityBinding) -> tuple[TokenProvider, TokenReques separators=(",", ":"), ) return provider, request, key + except RequestCancellationError: + raise except Exception: raise TokenProviderError() from None @@ -169,6 +176,8 @@ async def _renew(self, key: str, provider: TokenProvider, request: TokenRequest) if tokens.refresh_token is None: tokens = replace(tokens, refresh_token=stored.refresh_token) except TokenProviderError as error: + if isinstance(error, RequestCancellationError): + raise if error.reason != "invalid_grant" or request.flow != "clientCredentials": raise await asyncio.sleep(0) @@ -205,6 +214,8 @@ async def _renew(self, key: str, provider: TokenProvider, request: TokenRequest) return TokenLease(key, tokens) except (AuthorizationRequiredError, TokenProviderError): raise + except RequestCancellationError: + raise except Exception: raise TokenProviderError() from None diff --git a/src/sunday/token_manager_factory.py b/src/sunday/token_manager_factory.py deleted file mode 100644 index 6d9374c..0000000 --- a/src/sunday/token_manager_factory.py +++ /dev/null @@ -1,19 +0,0 @@ -# Copyright 2026 Outfox, Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. - -"""Application hook for the manager of resolved providers. - -Factories must not acquire tokens or perform storage I/O. They may supply the native -manager's store, expiry_skew and now options. Called once for secured settings and -never for settings without selected providers. The application owns the manager, -store and session lifecycle on its asyncio event loop. -""" - -from collections.abc import Callable, Mapping - -from .token_manager import TokenManager -from .token_provider import TokenProvider - -type TokenManagerFactory = Callable[[Mapping[str, TokenProvider]], TokenManager] diff --git a/src/sunday/token_provider.py b/src/sunday/token_provider.py index 796ec19..d065a8a 100644 --- a/src/sunday/token_provider.py +++ b/src/sunday/token_provider.py @@ -5,9 +5,16 @@ """Application credential acquisition and storage contracts.""" -from dataclasses import dataclass, field -from typing import Literal, Protocol +from __future__ import annotations +import asyncio +import math +from collections.abc import Awaitable, Callable +from dataclasses import dataclass, field, fields +from time import time +from typing import Literal, Protocol, cast + +from .request_cancellation_error import RequestCancellationError from .security import SecurityBinding, SecurityEndpoints @@ -78,7 +85,7 @@ async def remove(self, key: str) -> None: ... -class AuthorizationRequiredError(Exception): +class AuthorizationRequiredError(RequestCancellationError): """The application must obtain fresh authorization and supply a new grant identity.""" def __init__(self) -> None: @@ -91,3 +98,80 @@ class TokenProviderError(Exception): def __init__(self, reason: Literal["unavailable", "temporary", "invalid_grant"] = "unavailable") -> None: self.reason = reason super().__init__("The credential provider could not supply usable credentials") + + +class TokenRejectedError(RequestCancellationError): + """The credential owner declined automatic recovery of a rejected token.""" + + def __init__(self) -> None: + super().__init__("The credential owner requires application recovery") + + +@dataclass(frozen=True, slots=True) +class TokenLease: + """Receipt retaining only the original credential's rejection context.""" + + key: str = field(repr=False) + tokens: TokenSet = field(repr=False) + rejection: Callable[[], Awaitable[bool]] | None = field(default=None, repr=False, compare=False) + + async def invalidate(self) -> bool: + """Reject this credential through its owner, preserving concurrent replacements.""" + try: + return await self.rejection() if self.rejection is not None else False + except (RequestCancellationError, TokenProviderError): + raise + except Exception: + raise TokenProviderError() from None + + +class RejectingTokenProvider(TokenProvider, Protocol): + """Optional capability for external frameworks that own rejection recovery.""" + + async def reject(self, request: TokenRequest, rejected_token: str) -> bool: + """Reject only this token in its original session; return false if recovery is unsupported.""" + ... + + +async def provider_credentials(provider: TokenProvider, binding: SecurityBinding) -> TokenLease: + """Acquire once without adding a token cache or managing refresh credentials.""" + await asyncio.sleep(0) + credentials = getattr(provider, "credentials", None) + if callable(credentials): + return cast(TokenLease, await credentials(binding)) + try: + request = _resolve_token_request(provider, binding) + tokens = await provider.acquire(request) + await asyncio.sleep(0) + if not tokens.access_token or ( + tokens.expires_at is not None and (not math.isfinite(tokens.expires_at) or tokens.expires_at <= time()) + ): + raise TokenProviderError() + + async def reject() -> bool: + hook = getattr(provider, "reject", None) + return bool(await hook(request, tokens.access_token)) if callable(hook) else False + + return TokenLease("", tokens, reject) + except (RequestCancellationError, TokenProviderError): + raise + except Exception: + raise TokenProviderError() from None + + +def _resolve_token_request(provider: TokenProvider, binding: SecurityBinding) -> TokenRequest: + """Resolve provider configuration without applying cache or grant-reuse policy.""" + config = provider.configure(binding) + if not provider.identity.strip() or not config.client_identity.strip(): + raise TokenProviderError() + values = {item.name: getattr(binding, item.name) for item in fields(SecurityBinding)} + if config.endpoints is not None: + values.update( + { + item.name: value + for item in fields(config.endpoints) + if (value := getattr(config.endpoints, item.name)) is not None + } + ) + values["scopes"] = tuple(sorted(set(binding.scopes))) + return TokenRequest(**values, client_identity=config.client_identity, grant_identity=config.grant_identity) diff --git a/src/sunday/transport.py b/src/sunday/transport.py index ccdc8d8..105fe64 100644 --- a/src/sunday/transport.py +++ b/src/sunday/transport.py @@ -61,6 +61,10 @@ async def transport_response(self, request: TransportRequestT) -> TransportRespo """Send a native request and return the native response.""" ... + async def execute_request(self, spec: RequestSpec[Any]) -> TransportResponseT: + """Execute a specification with transport-owned authorization and recovery.""" + ... + async def response[ResponseT]( self, spec: OperationSpec[Any, ResponseT], @@ -120,13 +124,16 @@ async def transport_response(self, request: TransportRequestT) -> TransportRespo """Send a native request and return the native response.""" return await self._send(request) + async def execute_request(self, spec: RequestSpec[Any]) -> TransportResponseT: + """Execute a specification without exporting its internal request state.""" + return await self.transport_response(await self._prepare_request(spec)) + async def response[ResponseT]( self, spec: OperationSpec[Any, ResponseT], ) -> OperationResponse[ResponseT, TransportResponseT]: """Execute an operation and return its decoded response with metadata.""" - request = await self.transport_request(spec.request) - response = await self.transport_response(request) + response = await self.execute_request(spec.request) decoded = await self._decode_response(response, spec.responses) return cast(OperationResponse[ResponseT, TransportResponseT], decoded) diff --git a/tests/test_client_settings.py b/tests/test_client_settings.py index 5102502..d17ee21 100644 --- a/tests/test_client_settings.py +++ b/tests/test_client_settings.py @@ -20,6 +20,7 @@ TokenConfiguration, TokenRequest, TokenSet, + provider_credentials, ) from sunday.httpx import AuthorizationGrant, HttpxTransport @@ -42,8 +43,8 @@ async def check() -> None: async with httpx.AsyncClient(base_url=settings.base_url) as client: transport = HttpxTransport.from_settings(settings, client) assert transport.client is client - assert transport.token_manager is not None - lease = await transport.token_manager.credentials(BINDING) + assert transport.token_providers + lease = await provider_credentials(transport.token_providers[BINDING.provider], BINDING) assert lease.tokens.access_token == "private-token" asyncio.run(check()) @@ -125,9 +126,9 @@ async def run() -> None: "https://api.example", {"list": [BINDING]}, {"identity": BearerCredentials(token)} ) - manager = settings.token_manager + manager = settings.token_providers.get(BINDING.provider) assert manager is not None - assert (await manager.credentials(BINDING)).tokens.access_token == token + assert (await provider_credentials(manager, BINDING)).tokens.access_token == token asyncio.run(run()) @@ -165,7 +166,7 @@ def factory(credentials: OAuthCredentials) -> Provider: settings = ClientSettings.resolve( "https://api.example/v1", {"list": [[oauth]], "read": [[oauth]]}, {"identity": credentials} ) - assert settings.token_manager is not None + assert settings.token_providers.get(BINDING.provider) is not None assert len(calls) == 1 assert credentials.endpoints is not None assert credentials.endpoints.token_url == "oauth/token" diff --git a/tests/test_client_settings_persistence.py b/tests/test_client_settings_persistence.py index 69db4da..78ce804 100644 --- a/tests/test_client_settings_persistence.py +++ b/tests/test_client_settings_persistence.py @@ -1,22 +1,20 @@ """Application-owned manager storage survives settings instances without eager I/O.""" import asyncio -from collections.abc import Mapping from dataclasses import replace import pytest from sunday import ( - BearerCredentials, ClientSettings, ProviderCredentials, SecurityBinding, SecurityTransport, TokenConfiguration, TokenManager, - TokenProvider, TokenRequest, TokenSet, + provider_credentials, ) BINDING = SecurityBinding( @@ -74,33 +72,30 @@ async def refresh(self, request: TokenRequest, refresh_token: str) -> TokenSet: provider = Provider() - def factory(providers: Mapping[str, TokenProvider]) -> TokenManager: - nonlocal factories - factories += 1 - assert dict(providers) == {"resolved-provider": provider} - return TokenManager(providers, store=store, expiry_skew=5, now=lambda: time) + nonlocal factories + factories += 1 + manager = TokenManager(provider, store=store, expiry_skew=5, now=lambda: time) selected = replace(BINDING, profile=profile) - credentials = {"identity": ProviderCredentials(provider)} + credentials = {"identity": ProviderCredentials(manager)} if direct: - return ClientSettings( - "https://api.example", {"read": [selected]}, credentials, token_manager_factory=factory - ) + return ClientSettings("https://api.example", {"read": [selected]}, credentials) return ClientSettings.resolve( "https://api.example", {"read": [[selected]], "other": [[selected]], "public": [[]]}, credentials, - token_manager_factory=factory, ) async def token(settings: ClientSettings) -> TokenSet: - assert settings.token_manager is not None - return (await settings.token_manager.credentials(settings.bindings["read"][0])).tokens + assert settings.token_providers + return ( + await provider_credentials(settings.token_providers["resolved-provider"], settings.bindings["read"][0]) + ).tokens first = settings(0) assert (reads, saves, acquisitions, factories) == (0, 0, 0, 1) - assert first.token_manager is not None - lease = await first.token_manager.credentials(first.bindings["read"][0]) + assert first.token_providers + lease = await provider_credentials(first.token_providers["resolved-provider"], first.bindings["read"][0]) assert lease.tokens.access_token == "initial" assert (await token(settings(0, direct=True))).access_token == "initial" assert acquisitions == 1 @@ -122,21 +117,8 @@ async def token(settings: ClientSettings) -> TokenSet: asyncio.run(run()) -def test_public_invalid_and_failing_factory() -> None: - def factory(providers: Mapping[str, TokenProvider]) -> TokenManager: - raise RuntimeError("application factory failed") - - assert ClientSettings("https://api.example", token_manager_factory=factory).token_manager is None - assert ( - ClientSettings.resolve("https://api.example", {"public": [[]]}, {}, token_manager_factory=factory).token_manager - is None - ) +def test_public_settings_and_missing_credentials() -> None: + assert not ClientSettings("https://api.example").token_providers + assert not ClientSettings.resolve("https://api.example", {"public": [[]]}, {}).token_providers with pytest.raises(ValueError, match="Missing credentials"): - ClientSettings("https://api.example", {"read": [BINDING]}, token_manager_factory=factory) - with pytest.raises(RuntimeError, match="application factory failed"): - ClientSettings( - "https://api.example", - {"read": [replace(BINDING, flow="static")]}, - {"identity": BearerCredentials("secret")}, - token_manager_factory=factory, - ) + ClientSettings("https://api.example", {"read": [BINDING]}) diff --git a/tests/test_codecs_operations.py b/tests/test_codecs_operations.py index eafac9a..7ebd1ee 100644 --- a/tests/test_codecs_operations.py +++ b/tests/test_codecs_operations.py @@ -314,6 +314,32 @@ async def test_operation_builds_fresh_requests_and_returns_metadata() -> None: assert await operation.transport_response() == ((4, spec.request), False) +@pytest.mark.anyio +async def test_operation_execution_preserves_send_overrides_without_exporting() -> None: + class ExportingTransport(FakeTransport): + exports = 0 + sends = 0 + + async def transport_request(self, spec: RequestSpec[Any]) -> tuple[int, RequestSpec[Any]]: + self.exports += 1 + return await super().transport_request(spec) + + async def transport_response( + self, request: tuple[int, RequestSpec[Any]] + ) -> tuple[tuple[int, RequestSpec[Any]], bool]: + self.sends += 1 + return await super().transport_response(request) + + transport = ExportingTransport() + spec: OperationSpec[None, str] = OperationSpec(RequestSpec("GET", "/projects"), (ResponseSpec(200),)) + operation = Operation(transport, spec) + await operation.transport_response() + await operation.execute() + assert (transport.exports, transport.sends) == (0, 2) + await operation.transport_request() + assert (transport.exports, transport.sends) == (1, 2) + + @pytest.mark.anyio async def test_streaming_body_creates_fresh_sync_and_async_content() -> None: sync_body = StreamingBody.iterable(lambda: [b"one", bytearray(b"two")]) @@ -467,3 +493,17 @@ def validate_parameters() -> None: with pytest.raises(RequestEncodingError): await transport.transport_request(spec) assert validations == 2 + + +@pytest.mark.anyio +async def test_base_transport_decoding_uses_managed_execution_override() -> None: + class ManagedTransport(FakeTransport): + async def execute_request(self, spec: RequestSpec[Any]) -> tuple[tuple[int, RequestSpec[Any]], bool]: + self.calls.append("managed") + return await super().execute_request(spec) + + transport = ManagedTransport() + spec = OperationSpec[None, str](RequestSpec("GET", "/value"), (ResponseSpec(200),)) + response = await transport.response(spec) + assert response.result == "result" + assert transport.calls == ["managed", "transport_request", "transport_response", "response"] diff --git a/tests/test_httpx.py b/tests/test_httpx.py index 4a7c097..1571a70 100644 --- a/tests/test_httpx.py +++ b/tests/test_httpx.py @@ -215,7 +215,7 @@ def handler(request: httpx.Request) -> httpx.Response: accept_types=(MediaType("application/xml"), MediaType("application/json")), ) ) - await transport.transport_response(request) + await client.send(request) assert adaptations == 1 diff --git a/tests/test_httpx_adapters.py b/tests/test_httpx_adapters.py new file mode 100644 index 0000000..47a2cbd --- /dev/null +++ b/tests/test_httpx_adapters.py @@ -0,0 +1,802 @@ +# Copyright 2026 Outfox, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. + +from __future__ import annotations + +import asyncio +from collections.abc import AsyncGenerator, AsyncIterator +from typing import Any + +import anyio +import httpx +import pytest + +from sunday import ( + EventStreamOptions, + MediaType, + MediaTypeEncoders, + NullableOperation, + NullifySpec, + OperationSpec, + Problem, + ProblemPayload, + RequestCancellationError, + RequestSpec, + SecurityBinding, + SecurityTransport, + StreamingBody, + TokenConfiguration, + TokenRequest, + TokenSet, + TransportEvent, + TransportEventKind, +) +from sunday.httpx import ( + HttpxEventStream, + HttpxTransport, + RequestAdapter, + RequestAdapters, + ResponseAdapter, + ResponseAdapters, + copy_request, +) +from sunday.httpx._security import AuthenticationRecoveryBudget, RequestSecurity + +pytestmark = pytest.mark.anyio + + +class Stop(httpx.ReadError, RequestCancellationError): + pass + + +class Body(httpx.AsyncByteStream): + def __init__( + self, + content: bytes = b"payload", + *, + error: BaseException | None = None, + close_error: BaseException | None = None, + ) -> None: + self.content = content + self.error = error + self.close_error = close_error + self.reads = 0 + self.closes = 0 + + async def __aiter__(self) -> AsyncIterator[bytes]: + self.reads += 1 + if self.error is not None: + raise self.error + yield self.content + + async def aclose(self) -> None: + await anyio.sleep(0) + self.closes += 1 + if self.close_error is not None: + raise self.close_error + + +async def perform(transport: HttpxTransport, streaming: bool, spec: RequestSpec[Any] | None = None) -> httpx.Response: + spec = spec or RequestSpec("GET", "/value") + if not streaming: + return await transport.execute_request(spec) + request = await transport._prepare_request(spec) + response = await transport._send_event_stream( + request, + recovery_budget=AuthenticationRecoveryBudget(), + security=RequestSecurity(spec.security) if spec.security is not None else None, + ) + try: + await response.aread() + return response + finally: + await response.aclose() + + +@pytest.mark.parametrize("streaming", [False, True]) +async def test_independent_flat_chains_and_early_response_adaptation(streaming: bool) -> None: + calls: list[str] = [] + body = Body(b"x" * (4 * 1024 * 1024)) + + class First(RequestAdapter): + async def adapt(self, request: httpx.Request) -> httpx.Request: + calls.append("request-first") + request.headers["X-Adapted"] = "yes" + return request + + async def second(request: httpx.Request) -> httpx.Request: + calls.append("request-second") + return copy_request(request) + + class FirstResponse(ResponseAdapter): + async def adapt(self, response: httpx.Response, request: httpx.Request) -> httpx.Response: + calls.append("response-first") + assert request.headers["X-Adapted"] == "yes" + assert body.reads == 0 + response.status_code = 200 + return response + + async def second_response(response: httpx.Response, request: httpx.Request) -> httpx.Response: + calls.append("response-second") + assert response.status_code == 200 + return response + + async with httpx.AsyncClient( + base_url="https://api.example", transport=httpx.MockTransport(lambda _: httpx.Response(400, stream=body)) + ) as client: + transport = HttpxTransport( + client, + request_adapter=First().chain_to(RequestAdapters(second)), + response_adapter=FirstResponse().chain_to(ResponseAdapters(second_response)), + ) + result = await perform(transport, streaming) + assert result.content == body.content + assert calls == ["request-first", "request-second", "response-first", "response-second"] + assert body.reads == body.closes == 1 + + +async def test_export_adapts_once_and_has_no_hidden_execution_state() -> None: + calls: list[str] = [] + + async def request_adapter(request: httpx.Request) -> httpx.Request: + calls.append("request") + return request + + async def response_adapter(response: httpx.Response, request: httpx.Request) -> httpx.Response: + calls.append("response") + return response + + async with httpx.AsyncClient( + base_url="https://api.example", transport=httpx.MockTransport(lambda _: httpx.Response(204)) + ) as client: + transport = HttpxTransport(client, request_adapter=request_adapter, response_adapter=response_adapter) + exported = await transport.transport_request(RequestSpec("GET", "/value")) + await client.send(exported) + assert calls == ["request"] + assert set(exported.extensions) == {"timeout"} + await transport.execute_request(RequestSpec("GET", "/value")) + assert calls == ["request", "request", "response"] + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("stage", ["request", "response", "read"]) +async def test_stop_identity_and_cleanup(streaming: bool, stage: str) -> None: + stop = Stop("stop") + cleanup = RuntimeError("cleanup failed") + body = Body(error=stop if stage == "read" else None, close_error=cleanup) + sends = 0 + + async def request_adapter(request: httpx.Request) -> httpx.Request: + if stage == "request": + raise stop + return request + + async def response_adapter(response: httpx.Response, request: httpx.Request) -> httpx.Response: + if stage == "response": + raise stop + return response + + def handle(request: httpx.Request) -> httpx.Response: + nonlocal sends + sends += 1 + return httpx.Response(200, stream=body) + + async with httpx.AsyncClient(base_url="https://api.example", transport=httpx.MockTransport(handle)) as client: + transport = HttpxTransport(client, request_adapter=request_adapter, response_adapter=response_adapter) + if streaming and stage == "read": + # The event-stream consumer owns read cleanup and must retain the stop over close failures. + async def sse_headers(response: httpx.Response, request: httpx.Request) -> httpx.Response: + response.headers["Content-Type"] = "text/event-stream" + return response + + transport = HttpxTransport(client, response_adapter=sse_headers) + events = transport.event_stream(RequestSpec("GET", "/value"), lambda event: event) + with pytest.raises(Stop) as failure: + await anext(aiter(events)) + else: + with pytest.raises(Stop) as failure: + await perform(transport, streaming) + assert failure.value is stop + assert sends == (0 if stage == "request" else 1) + assert body.closes == sends + + +@pytest.mark.parametrize("streaming", [False, True]) +async def test_response_adapter_consumes_and_replaces_body(streaming: bool) -> None: + body = Body() + + async def replace(response: httpx.Response, request: httpx.Request) -> httpx.Response: + assert await response.aread() == b"payload" + return httpx.Response(200, content=b"replacement", request=request, extensions=response.extensions) + + async with httpx.AsyncClient( + base_url="https://api.example", transport=httpx.MockTransport(lambda _: httpx.Response(200, stream=body)) + ) as client: + result = await perform(HttpxTransport(client, response_adapter=replace), streaming) + assert result.content == b"replacement" + assert body.closes == 1 + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("read_in_adapter", [False, True]) +async def test_native_cancellation_interrupts_reads_and_shields_cleanup(streaming: bool, read_in_adapter: bool) -> None: + reading = anyio.Event() + + class WaitingBody(Body): + async def __aiter__(self) -> AsyncIterator[bytes]: + reading.set() + await anyio.sleep_forever() + yield b"unreachable" + + body = WaitingBody() + + async def adapter(response: httpx.Response, request: httpx.Request) -> httpx.Response: + if read_in_adapter: + await response.aread() + return response + + async with httpx.AsyncClient( + base_url="https://api.example", + transport=httpx.MockTransport( + lambda _: httpx.Response(200, headers={"Content-Type": "text/event-stream"}, stream=body) + ), + ) as client: + transport = HttpxTransport(client, response_adapter=adapter) + + async def execute() -> None: + if streaming: + events = transport.event_stream(RequestSpec("GET", "/value"), lambda event: event) + await anext(aiter(events)) + else: + await perform(transport, False) + + task = asyncio.create_task(execute()) + with anyio.fail_after(1): + await reading.wait() + task.cancel() + with pytest.raises(asyncio.CancelledError): + await task + assert body.closes == 1 + + +@pytest.mark.parametrize("streaming", [False, True]) +async def test_adapted_redirects_reprepare_without_accumulating_headers(streaming: bool) -> None: + seen: list[httpx.Request] = [] + + async def request_adapter(request: httpx.Request) -> httpx.Request: + request.headers["X-Attempt"] = request.headers.get("X-Attempt", "") + "one" + return request + + async def response_adapter(response: httpx.Response, request: httpx.Request) -> httpx.Response: + if request.url.path == "/value": + response.status_code = 303 + response.headers["Location"] = "/redirected" + return response + + def handle(request: httpx.Request) -> httpx.Response: + seen.append(request) + return httpx.Response(200) + + async with httpx.AsyncClient( + base_url="https://api.example", follow_redirects=True, transport=httpx.MockTransport(handle) + ) as client: + transport = HttpxTransport(client, request_adapter=request_adapter, response_adapter=response_adapter) + await perform(transport, streaming, RequestSpec("POST", "/value", body=b"original")) + assert [r.method for r in seen] == ["POST", "GET"] + assert seen[1].content == b"" + assert "content-type" not in seen[1].headers + assert [r.headers["X-Attempt"] for r in seen] == ["one", "one"] + assert seen[1].extensions["timeout"] == seen[0].extensions["timeout"] + + +@pytest.mark.parametrize("streaming", [False, True]) +async def test_replay_body_factory_failure_retains_identity(streaming: bool) -> None: + stop = Stop("factory failed") + opens = 0 + + def content() -> bytes: + nonlocal opens + opens += 1 + if opens == 2: + raise stop + return b"payload" + + async with httpx.AsyncClient( + base_url="https://api.example", + follow_redirects=True, + transport=httpx.MockTransport(lambda _: httpx.Response(307, headers={"Location": "/next"})), + ) as client: + with pytest.raises(Stop) as failure: + await perform(HttpxTransport(client), streaming, RequestSpec("POST", "/value", body=StreamingBody(content))) + assert failure.value is stop + assert opens == 2 + + +BINDING = SecurityBinding( + scheme="token", + provider="identity", + profile="external", + flow="external", + transport=SecurityTransport(location="header", name="Authorization", prefix="Bearer"), +) + + +class Provider: + identity = "external" + + def __init__(self) -> None: + self.acquisitions = 0 + self.rejections: list[str] = [] + + def configure(self, binding: SecurityBinding) -> TokenConfiguration: + return TokenConfiguration("client") + + async def acquire(self, request: TokenRequest) -> TokenSet: + self.acquisitions += 1 + return TokenSet(f"token-{self.acquisitions}") + + async def reject(self, request: TokenRequest, rejected_token: str) -> bool: + self.rejections.append(rejected_token) + return True + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("method,expected", [("POST", 1), ("GET", 2)]) +@pytest.mark.parametrize("rewrite", [False, True]) +async def test_feedback_is_independent_of_retry_budget_and_matches_wire_token( + streaming: bool, + method: str, + expected: int, + rewrite: bool, +) -> None: + provider = Provider() + observations: list[tuple[str, tuple[str, ...]]] = [] + + async def observe(response: httpx.Response, request: httpx.Request) -> httpx.Response: + observations.append((request.headers["authorization"], tuple(provider.rejections))) + return response + + async def hook(request: httpx.Request) -> None: + if rewrite: + request.headers["Authorization"] = "Bearer unrelated" + + async with httpx.AsyncClient( + base_url="https://api.example", + event_hooks={"request": [hook]}, + transport=httpx.MockTransport( + lambda _: httpx.Response(401, headers={"WWW-Authenticate": "Bearer error=invalid_token"}) + ), + ) as client: + transport = HttpxTransport(client, token_providers={"identity": provider}, response_adapter=observe) + response = await perform(transport, streaming, RequestSpec(method, "/value", security=(BINDING,))) + assert response.status_code == 401 + assert provider.acquisitions == expected + assert provider.rejections == ([] if rewrite else [f"token-{i + 1}" for i in range(expected)]) + + assert len(observations) == expected + assert observations[-1][1] == tuple(provider.rejections) + assert observations[-1][0] == ("Bearer unrelated" if rewrite else f"Bearer token-{expected}") + + +@pytest.mark.parametrize("stage", ["request", "response", "decoder"]) +async def test_sse_stop_never_reconnects(stage: str) -> None: + stop = Stop("stop SSE") + sends = 0 + + async def request_adapter(request: httpx.Request) -> httpx.Request: + if stage == "request": + raise stop + return request + + async def response_adapter(response: httpx.Response, request: httpx.Request) -> httpx.Response: + if stage == "response": + raise stop + return response + + def handle(request: httpx.Request) -> httpx.Response: + nonlocal sends + sends += 1 + return httpx.Response(200, headers={"Content-Type": "text/event-stream"}, content="data: value\n\n") + + def decode(event: Any) -> None: + raise stop + + async with httpx.AsyncClient(base_url="https://api.example", transport=httpx.MockTransport(handle)) as client: + transport = HttpxTransport(client, request_adapter=request_adapter, response_adapter=response_adapter) + events: HttpxEventStream[None] = transport.event_stream( + RequestSpec("GET", "/value"), decode, options=EventStreamOptions(retry=0) + ) + with anyio.fail_after(1), pytest.raises(Stop) as failure: + await anext(aiter(events)) + assert failure.value is stop + assert sends == (0 if stage == "request" else 1) + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("stage", ["acquire", "reject", "upload"]) +async def test_secured_execution_never_sanitizes_stop_errors(streaming: bool, stage: str) -> None: + stop = Stop("application-owned stop") + + class FailingObserver: + def observe(self, event: TransportEvent) -> None: + if event.kind is TransportEventKind.FAILURE: + raise ValueError("observer failure") + + class StoppingProvider(Provider): + async def acquire(self, request: TokenRequest) -> TokenSet: + if stage == "acquire": + raise stop + return await super().acquire(request) + + async def reject(self, request: TokenRequest, rejected_token: str) -> bool: + raise stop + + def content() -> bytes: + raise stop + + async with httpx.AsyncClient( + base_url="https://api.example", + transport=httpx.MockTransport( + lambda _: httpx.Response(401, headers={"WWW-Authenticate": "Bearer error=invalid_token"}) + ), + ) as client: + transport = HttpxTransport( + client, token_providers={"identity": StoppingProvider()}, observers=(FailingObserver(),) + ) + spec = RequestSpec( + "POST", "/value", security=(BINDING,), body=StreamingBody(content) if stage == "upload" else None + ) + with pytest.raises(Stop) as failure: + await perform(transport, streaming, spec) + assert failure.value is stop + + +@pytest.mark.parametrize("streaming", [False, True]) +async def test_failed_response_chain_closes_the_replacement(streaming: bool) -> None: + original, replacement = Body(), Body() + stop = Stop("later adapter") + + async def replace(response: httpx.Response, request: httpx.Request) -> httpx.Response: + await response.aclose() + return httpx.Response(200, stream=replacement, request=request) + + async def fail(response: httpx.Response, request: httpx.Request) -> httpx.Response: + raise stop + + async with httpx.AsyncClient( + base_url="https://api.example", transport=httpx.MockTransport(lambda _: httpx.Response(200, stream=original)) + ) as client: + transport = HttpxTransport(client, response_adapter=ResponseAdapters(replace, fail)) + with pytest.raises(Stop) as failure: + await perform(transport, streaming) + assert failure.value is stop + assert original.closes == replacement.closes == 1 + assert original.reads == replacement.reads == 0 + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("read_in_adapter", [False, True]) +async def test_cancellation_releases_a_stalled_native_tcp_response(streaming: bool, read_in_adapter: bool) -> None: + from anyio.abc import SocketAttribute, SocketStream + + received = anyio.Event() + disconnected = anyio.Event() + + async def serve(socket: SocketStream) -> None: + async with socket: + await socket.receive() + await socket.send(b"HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nContent-Length: 100\r\n\r\n") + try: + await socket.receive() + except anyio.EndOfStream: + disconnected.set() + + async def adapt(response: httpx.Response, request: httpx.Request) -> httpx.Response: + received.set() + if read_in_adapter: + await response.aread() + return response + + listener = await anyio.create_tcp_listener(local_host="127.0.0.1") + port = listener.extra(SocketAttribute.local_port) + async with listener, anyio.create_task_group() as group: + group.start_soon(listener.serve, serve) + async with httpx.AsyncClient(base_url=f"http://127.0.0.1:{port}", timeout=None, trust_env=False) as client: + transport = HttpxTransport(client, response_adapter=adapt) + + async def execute() -> None: + if streaming: + events = transport.event_stream(RequestSpec("GET", "/value"), lambda event: event) + await anext(aiter(events)) + else: + await transport.execute_request(RequestSpec("GET", "/value")) + + task = asyncio.create_task(execute()) + try: + with anyio.fail_after(2): + await received.wait() + task.cancel() + with pytest.raises(asyncio.CancelledError): + await task + # Prove cancellation released the socket before closing the borrowed client. + await disconnected.wait() + finally: + task.cancel() + group.cancel_scope.cancel() + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("status", [307, 308]) +async def test_streamed_upload_redirect_preserves_native_host(streaming: bool, status: int) -> None: + from anyio.abc import SocketAttribute, SocketStream + + received: list[bytes] = [] + opens = 0 + + def content() -> bytes: + nonlocal opens + opens += 1 + return b"payload" + + async def serve(socket: SocketStream) -> None: + async with socket: + data = bytearray() + while b"\r\n\r\n" not in data: + data.extend(await socket.receive()) + headers, body = bytes(data).split(b"\r\n\r\n", 1) + while len(body) < len(b"payload"): + body += await socket.receive() + assert body == b"payload" + received.append(headers) + response = ( + f"HTTP/1.1 {status} Redirect\r\nLocation: /next\r\n" if len(received) == 1 else "HTTP/1.1 200 OK\r\n" + ) + await socket.send((response + "Content-Length: 0\r\nConnection: close\r\n\r\n").encode()) + + listener = await anyio.create_tcp_listener(local_host="127.0.0.1") + port = listener.extra(SocketAttribute.local_port) + async with listener, anyio.create_task_group() as group: + group.start_soon(listener.serve, serve) + try: + async with httpx.AsyncClient( + base_url=f"http://127.0.0.1:{port}", follow_redirects=True, trust_env=False + ) as client: + spec = RequestSpec("POST", "/value", body=StreamingBody(content), headers=(("Content-Length", "7"),)) + with anyio.fail_after(2): + response = await perform(HttpxTransport(client), streaming, spec) + assert response.status_code == 200 + finally: + group.cancel_scope.cancel() + assert opens == 2 + assert len(received) == 2 + assert received[1].startswith(b"POST /next HTTP/1.1\r\n") + assert f"host: 127.0.0.1:{port}\r\n".encode() in received[1].lower() + b"\r\n" + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize( + ("location", "cookie", "expected"), + [ + ("/next", "session=accepted; Path=/", "session=accepted"), + ("/elsewhere", "session=accepted; Path=/next", None), + ("https://other.example/next", "session=accepted; Path=/", None), + ("http://api.example/next", "session=accepted; Path=/; Secure", None), + ], +) +async def test_redirect_cookies_match_native_httpx( + streaming: bool, location: str, cookie: str, expected: str | None +) -> None: + async def execute(managed: bool) -> list[str | None]: + seen: list[str | None] = [] + adapted: list[str | None] = [] + + def handle(request: httpx.Request) -> httpx.Response: + seen.append(request.headers.get("cookie")) + if request.url.path == "/value": + return httpx.Response(302, headers={"Location": location, "Set-Cookie": cookie}) + return httpx.Response(204) + + async def adapt(request: httpx.Request) -> httpx.Request: + adapted.append(request.headers.get("cookie")) + return request + + async with httpx.AsyncClient( + base_url="https://api.example", follow_redirects=True, transport=httpx.MockTransport(handle) + ) as client: + response = ( + await perform(HttpxTransport(client, request_adapter=adapt), streaming) + if managed + else await client.get("/value") + ) + assert response.status_code == 204 + if managed: + assert adapted == seen + return seen + + assert await execute(True) == await execute(False) == [None, expected] + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("body", [b"payload", bytearray(b"payload"), memoryview(b"payload")]) +async def test_binary_encoder_selection_preserves_stop_identity(streaming: bool, body: object) -> None: + stop = Stop("stop selecting encoder") + sends = 0 + + class Encoder: + @property + def media_types(self) -> tuple[MediaType, ...]: + raise stop + + def encode(self, value: object) -> bytes: + raise AssertionError("Encoding must not follow cancellation") + + def handle(request: httpx.Request) -> httpx.Response: + nonlocal sends + sends += 1 + return httpx.Response(204) + + async with httpx.AsyncClient(base_url="https://api.example", transport=httpx.MockTransport(handle)) as client: + transport = HttpxTransport(client, encoders=MediaTypeEncoders([Encoder()])) + with pytest.raises(Stop) as failure: + await perform(transport, streaming, RequestSpec("POST", "/value", body=body)) + assert failure.value is stop + assert sends == 0 + + +@pytest.mark.parametrize("execution", ["buffered", "streaming", "nullable-result", "nullable-response"]) +@pytest.mark.parametrize("stage", ["request", "response"]) +async def test_problem_stop_is_never_nullified_or_reconnected(execution: str, stage: str) -> None: + class StopProblem(Problem, RequestCancellationError): + pass + + stop = StopProblem(ProblemPayload(status=404, title="Stop the request")) + body = Body(b"data: value\n\n") + sends = 0 + + async def adapt_request(request: httpx.Request) -> httpx.Request: + if stage == "request": + raise stop + return request + + async def adapt_response(response: httpx.Response, request: httpx.Request) -> httpx.Response: + if stage == "response": + raise stop + return response + + def handle(request: httpx.Request) -> httpx.Response: + nonlocal sends + sends += 1 + return httpx.Response(200, headers={"Content-Type": "text/event-stream"}, stream=body) + + async with httpx.AsyncClient(base_url="https://api.example", transport=httpx.MockTransport(handle)) as client: + transport = HttpxTransport(client, request_adapter=adapt_request, response_adapter=adapt_response) + spec: RequestSpec[None] = RequestSpec("GET", "/value") + operation = NullableOperation[None, httpx.Request, httpx.Response]( + transport, OperationSpec(spec, ()), NullifySpec(statuses=(404,), problem_types=(StopProblem,)) + ) + with anyio.fail_after(1), pytest.raises(StopProblem) as failure: + if execution == "buffered": + await transport.execute_request(spec) + elif execution == "streaming": + async with transport.event_stream(spec, lambda event: event) as events: + await anext(aiter(events)) + elif execution == "nullable-result": + await operation.execute_or_none() + else: + await operation.response_or_none() + assert failure.value is stop + assert sends == (0 if stage == "request" else 1) + assert body.closes == sends + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("streamed_body", [False, True]) +@pytest.mark.parametrize( + ("url", "headers", "host"), + [ + ("https://edge.example:8443/target", None, "edge.example:8443"), + ("https://edge.example:8443/target", {"X-Client": "value"}, "edge.example:8443"), + ("https://edge.example:8443/target", {"Host": "override.example"}, "override.example"), + ("https://api.example/target", None, "virtual.example"), + ], +) +async def test_request_copy_updates_host_unless_explicitly_overridden( + streaming: bool, streamed_body: bool, url: str, headers: dict[str, str] | None, host: str +) -> None: + seen: list[httpx.Request] = [] + + async def adapt(request: httpx.Request) -> httpx.Request: + copied = copy_request(request, url=url, headers=headers) + assert copied.extensions == request.extensions + return copied + + def handle(request: httpx.Request) -> httpx.Response: + seen.append(request) + return httpx.Response(204) + + async with httpx.AsyncClient( + base_url="https://api.example", headers={"Host": "virtual.example"}, transport=httpx.MockTransport(handle) + ) as client: + body = StreamingBody.bytes(b"payload") if streamed_body else b"payload" + response = await perform( + HttpxTransport(client, request_adapter=adapt), streaming, RequestSpec("POST", "/value", body=body) + ) + assert response.status_code == 204 + assert len(seen) == 1 + assert str(seen[0].url) == url + assert seen[0].headers["host"] == host + assert seen[0].content == b"payload" + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("native_auth", [False, True]) +async def test_redirect_history_preserves_native_authentication_and_buffered_bodies( + streaming: bool, native_auth: bool +) -> None: + class ChallengeAuth(httpx.Auth): + async def async_auth_flow(self, request: httpx.Request) -> AsyncGenerator[httpx.Request, httpx.Response]: + response = yield request + if response.status_code == 401: + request.headers["X-Native-Auth"] = "accepted" + yield request + + bodies: list[Body] = [] + observed: list[list[int]] = [] + + def handle(request: httpx.Request) -> httpx.Response: + if native_auth and "X-Native-Auth" not in request.headers: + status, headers = 401, {} + elif request.url.path == "/value": + status, headers = 302, {"Location": "/middle"} + elif request.url.path == "/middle": + status, headers = 307, {"Location": "/final"} + else: + status, headers = 200, {} + body = Body(f"body-{status}".encode()) + bodies.append(body) + return httpx.Response(status, headers=headers, stream=body) + + async def adapt(response: httpx.Response, request: httpx.Request) -> httpx.Response: + observed.append([previous.status_code for previous in response.history]) + assert bodies[-1].reads == 0 + assert all(previous.is_closed for previous in response.history) + return response + + async with httpx.AsyncClient( + base_url="https://api.example", + follow_redirects=True, + transport=httpx.MockTransport(handle), + auth=ChallengeAuth() if native_auth else None, + ) as client: + response = await perform(HttpxTransport(client, response_adapter=adapt), streaming) + expected = [401, 302, 401, 307, 401] if native_auth else [302, 307] + assert [previous.status_code for previous in response.history] == expected + assert [previous.content for previous in response.history] == [f"body-{status}".encode() for status in expected] + assert observed == ([[401], [401, 302, 401], expected] if native_auth else [[], [302], expected]) + assert response.content == b"body-200" + assert all(body.reads == body.closes == 1 for body in bodies) + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("stage", ["read", "close"]) +async def test_redirect_history_collection_preserves_stop_identity(streaming: bool, stage: str) -> None: + stop = Stop("stop redirect collection") + body = Body( + error=stop if stage == "read" else None, close_error=stop if stage == "close" else RuntimeError("close") + ) + sends = 0 + + def handle(request: httpx.Request) -> httpx.Response: + nonlocal sends + sends += 1 + return httpx.Response(302, headers={"Location": "/next"}, stream=body) + + async with httpx.AsyncClient( + base_url="https://api.example", follow_redirects=True, transport=httpx.MockTransport(handle) + ) as client: + with pytest.raises(Stop) as failure: + await perform(HttpxTransport(client), streaming) + assert failure.value is stop + assert sends == body.reads == body.closes == 1 diff --git a/tests/test_httpx_cleanup.py b/tests/test_httpx_cleanup.py new file mode 100644 index 0000000..493ee22 --- /dev/null +++ b/tests/test_httpx_cleanup.py @@ -0,0 +1,1417 @@ +# Copyright 2026 Outfox, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. + +from __future__ import annotations + +import asyncio +from collections.abc import AsyncIterator +from contextlib import suppress +from dataclasses import dataclass, field +from typing import Any + +import anyio +import h11 +import httpx +import pytest +from anyio.abc import SocketAttribute, SocketStream + +from sunday import ( + EventSourceState, + MediaType, + OperationSpec, + RequestCancellationError, + RequestSpec, + ResponseSpec, + SecurityTransport, + StreamingBody, + TokenRequest, +) +from sunday.httpx import HttpxOAuthTokenProvider, HttpxTransport, copy_request +from sunday.httpx._security import AuthenticationRecoveryBudget + +pytestmark = pytest.mark.anyio + + +@dataclass +class Server: + url: str + disconnected: anyio.Event = field(default_factory=anyio.Event) + uploads: list[tuple[httpx.Headers, bytes]] = field(default_factory=list) + + async def serve(self, socket: SocketStream) -> None: + async with socket: + connection = h11.Connection(h11.SERVER) + request: h11.Request | None = None + body = bytearray() + while True: + event = connection.next_event() + if event is h11.NEED_DATA: + try: + connection.receive_data(await socket.receive()) + except anyio.EndOfStream: + self.disconnected.set() + return + elif isinstance(event, h11.Request): + request = event + elif isinstance(event, h11.Data): + body.extend(event.data) + elif isinstance(event, h11.EndOfMessage): + break + assert request is not None + if request.target == b"/upload": + self.uploads.append((httpx.Headers(request.headers), bytes(body))) + if request.target in {b"/upload", b"/after"}: + await socket.send(b"HTTP/1.1 204 No Content\r\nConnection: close\r\n\r\n") + return + if request.target == b"/headers": + with pytest.raises(anyio.EndOfStream): + await socket.receive() + self.disconnected.set() + return + if request.target == b"/bulk": + payload = b"x" * (1024 * 1024) + await socket.send( + b"HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\nContent-Length: " + + str(len(payload)).encode() + + b"\r\nConnection: close\r\n\r\n" + + payload + ) + elif request.target == b"/eof": + await socket.send( + b"HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\n" + b"Content-Length: 13\r\nConnection: close\r\n\r\ndata: first\n\n" + ) + else: + await socket.send( + b"HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nContent-Length: 1024\r\n\r\ndata: first\n\n" + ) + with pytest.raises(anyio.EndOfStream): + await socket.receive() + self.disconnected.set() + + +@pytest.fixture +async def server() -> AsyncIterator[Server]: + listener = await anyio.create_tcp_listener(local_host="127.0.0.1") + state = Server(f"http://127.0.0.1:{listener.extra(SocketAttribute.local_port)}") + async with listener, anyio.create_task_group() as group: + group.start_soon(listener.serve, state.serve) + try: + yield state + finally: + group.cancel_scope.cancel() + + +async def execute(transport: HttpxTransport, streaming: bool, spec: RequestSpec[Any]) -> httpx.Response: + if not streaming: + return await transport.execute_request(spec) + response = await transport._send_event_stream( + await transport._prepare_request(spec), recovery_budget=AuthenticationRecoveryBudget() + ) + try: + await response.aread() + return response + finally: + await response.aclose() + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("original", ["length", "chunked", "missing"]) +@pytest.mark.parametrize("override", [None, "length", "chunked"]) +async def test_copy_preserves_valid_streaming_framing_over_tcp( + server: Server, streaming: bool, original: str, override: str | None +) -> None: + async def adapt(request: httpx.Request) -> httpx.Request: + if original == "missing": + request.headers.pop("transfer-encoding", None) + headers = {"X-Custom": "value"} + if override == "length": + headers["Content-Length"] = "7" + elif override == "chunked": + headers["Transfer-Encoding"] = "chunked" + copied = copy_request(request, headers=headers) + assert copied.stream is request.stream + return copied + + async with httpx.AsyncClient(base_url=server.url, trust_env=False) as client: + spec = RequestSpec( + "POST", + "/upload", + body=StreamingBody.bytes(b"payload"), + headers=(("Content-Length", "7"),) if original == "length" else (), + ) + with anyio.fail_after(2): + response = await execute(HttpxTransport(client, request_adapter=adapt), streaming, spec) + assert response.status_code == 204 + assert len(server.uploads) == 1 + headers, body = server.uploads[0] + expected = override or ("length" if original == "length" else "chunked") + assert body == b"payload" + assert headers["x-custom"] == "value" + if expected == "length": + assert headers["content-length"] == "7" + assert "transfer-encoding" not in headers + else: + assert headers["transfer-encoding"] == "chunked" + assert "content-length" not in headers + + +class Stop(httpx.ReadError, RequestCancellationError): + pass + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("primary", ["stop", "cancellation"]) +@pytest.mark.parametrize("close_fails", [False, True]) +async def test_repeated_cancellation_waits_for_native_cleanup_and_preserves_identity( + server: Server, streaming: bool, primary: str, close_fails: bool +) -> None: + closing, release = anyio.Event(), anyio.Event() + stop = Stop("original stop") + observed: list[BaseException] = [] + closes = 0 + + class GatedClose(httpx.AsyncByteStream): + def __init__(self, wrapped: httpx.AsyncByteStream) -> None: + self.wrapped = wrapped + + async def __aiter__(self) -> AsyncIterator[bytes]: + async for chunk in self.wrapped: + yield chunk + + async def aclose(self) -> None: + nonlocal closes + closes += 1 + closing.set() + await release.wait() + await self.wrapped.aclose() + if close_fails: + raise RuntimeError("cleanup failed after releasing the native connection") + + async def adapt(response: httpx.Response, request: httpx.Request) -> httpx.Response: + assert isinstance(response.stream, httpx.AsyncByteStream) + response.stream = GatedClose(response.stream) + owner = asyncio.current_task() + assert owner is not None + owner.cancel("first cancellation") + if primary == "stop": + raise stop + try: + await anyio.sleep(0) + except asyncio.CancelledError as error: + observed.append(error) + raise + raise AssertionError("Pending cancellation was not delivered") + + async with httpx.AsyncClient( + base_url=server.url, trust_env=False, limits=httpx.Limits(max_connections=1), timeout=1 + ) as client: + transport = HttpxTransport(client, response_adapter=adapt) + task = asyncio.create_task(execute(transport, streaming, RequestSpec("GET", "/events"))) + try: + with anyio.fail_after(3): + await closing.wait() + task.cancel("second cancellation") + await anyio.sleep(0) + task.cancel("third cancellation") + await anyio.sleep(0) + assert not task.done() + release.set() + with pytest.raises(Stop if primary == "stop" else asyncio.CancelledError) as failure: + await task + expected = stop if primary == "stop" else observed[0] + assert failure.value is expected + if close_fails: + assert "Closing the HTTP response also failed" in expected.__notes__ + await server.disconnected.wait() + # Prove pool release before closing the borrowed client. + assert (await client.get("/after")).status_code == 204 + finally: + release.set() + if not task.done(): + task.cancel() + with suppress(Stop, asyncio.CancelledError): + await task + assert closes == 1 + + +async def test_pending_cancellation_during_stream_context_exit_releases_native_pool(server: Server) -> None: + observed: list[BaseException] = [] + async with httpx.AsyncClient( + base_url=server.url, trust_env=False, limits=httpx.Limits(max_connections=1), timeout=1 + ) as client: + transport = HttpxTransport(client) + + async def consume() -> None: + stream = transport.event_stream(RequestSpec("GET", "/events"), lambda event: event.data) + iterator = stream.events() + try: + async with stream: + assert await anext(iterator) == "first" + owner = asyncio.current_task() + assert owner is not None + owner.cancel("pending at context exit") + except asyncio.CancelledError as error: + observed.append(error) + raise + finally: + await iterator.aclose() + + with anyio.fail_after(3): + with pytest.raises(asyncio.CancelledError) as failure: + await asyncio.create_task(consume()) + assert failure.value is observed[0] + assert failure.value.args == ("pending at context exit",) + await server.disconnected.wait() + assert (await transport.execute_request(RequestSpec("GET", "/after"))).status_code == 204 + + +async def test_event_source_callback_close_releases_native_pool_without_task_cancellation(server: Server) -> None: + received = anyio.Event() + tasks: list[asyncio.Task[Any]] = [] + async with httpx.AsyncClient( + base_url=server.url, trust_env=False, limits=httpx.Limits(max_connections=1), timeout=1 + ) as client: + transport = HttpxTransport(client) + source = transport.event_source(RequestSpec("GET", "/events")) + + def on_message(event: object) -> None: + task = asyncio.current_task() + assert task is not None + tasks.append(task) + source.close() + received.set() + + source.on_message = on_message + source.connect() + with anyio.fail_after(3): + await received.wait() + await source._wait_closed() + assert len(tasks) == 1 and not tasks[0].cancelled() + await server.disconnected.wait() + assert (await transport.execute_request(RequestSpec("GET", "/after"))).status_code == 204 + + +async def consume_eof(transport: HttpxTransport, streaming: bool) -> None: + if not streaming: + await transport.execute_request(RequestSpec("GET", "/eof")) + return + async with transport.event_stream(RequestSpec("GET", "/eof"), lambda event: event.data) as stream: + async for event in stream: + assert event == "first" + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("cancellation", ["task", "scope"]) +async def test_eof_cancellation_finishes_native_cleanup_before_propagating( + server: Server, streaming: bool, cancellation: str +) -> None: + closing, release = anyio.Event(), anyio.Event() + completed = 0 + observed: list[asyncio.CancelledError] = [] + scope = anyio.CancelScope() + + async def trace(name: str, info: dict[str, Any]) -> None: + nonlocal completed + if name == "http11.response_closed.started": + closing.set() + await release.wait() + elif name == "http11.response_closed.complete": + completed += 1 + + async def adapt(request: httpx.Request) -> httpx.Request: + request.extensions["trace"] = trace + return request + + async with httpx.AsyncClient( + base_url=server.url, trust_env=False, limits=httpx.Limits(max_connections=1), timeout=1 + ) as client: + transport = HttpxTransport(client, request_adapter=adapt) + + async def run() -> None: + with scope: + try: + await consume_eof(transport, streaming) + await anyio.lowlevel.checkpoint() + except asyncio.CancelledError as error: + observed.append(error) + raise + + task = asyncio.create_task(run()) + try: + with anyio.fail_after(3): + await closing.wait() + if cancellation == "task": + task.cancel("first EOF cancellation") + await anyio.sleep(0) + task.cancel("second EOF cancellation") + else: + scope.cancel() + await anyio.sleep(0) + assert not task.done() + assert completed == 0 + release.set() + if cancellation == "task": + with pytest.raises(asyncio.CancelledError) as failure: + await task + assert failure.value is observed[0] + assert failure.value.args == ("first EOF cancellation",) + else: + await task + assert scope.cancelled_caught and len(observed) == 1 + assert completed == 1 + await server.disconnected.wait() + assert (await client.get("/after")).status_code == 204 + finally: + release.set() + if not task.done(): + task.cancel() + with suppress(asyncio.CancelledError): + await task + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("error_type", [Stop, asyncio.CancelledError, RuntimeError]) +async def test_eof_cleanup_preserves_original_error_identity( + server: Server, streaming: bool, error_type: type[BaseException] +) -> None: + error = error_type("original EOF cleanup failure") + closes = 0 + + class FailingClose(httpx.AsyncByteStream): + def __init__(self, stream: httpx.AsyncByteStream) -> None: + self.stream = stream + + def __aiter__(self) -> AsyncIterator[bytes]: + return self.stream.__aiter__() + + async def aclose(self) -> None: + nonlocal closes + closes += 1 + await self.stream.aclose() + raise error + + async def adapt(response: httpx.Response, request: httpx.Request) -> httpx.Response: + assert isinstance(response.stream, httpx.AsyncByteStream) + response.stream = FailingClose(response.stream) + return response + + async with httpx.AsyncClient( + base_url=server.url, trust_env=False, limits=httpx.Limits(max_connections=1), timeout=1 + ) as client: + with anyio.fail_after(3): + with pytest.raises(error_type) as failure: + await consume_eof(HttpxTransport(client, response_adapter=adapt), streaming) + assert failure.value is error + assert closes == 1 + await server.disconnected.wait() + assert (await client.get("/after")).status_code == 204 + + +@pytest.mark.parametrize("before_start", [False, True]) +async def test_event_source_immediate_reconnect_keeps_new_run_open(server: Server, before_start: bool) -> None: + received = anyio.Event() + tasks: list[asyncio.Task[Any]] = [] + errors: list[BaseException | None] = [] + async with httpx.AsyncClient(base_url=server.url, trust_env=False) as client: + transport = HttpxTransport(client) + source = transport.event_source(RequestSpec("GET", "/events")) + + def on_message(event: object) -> None: + task = asyncio.current_task() + assert task is not None + tasks.append(task) + received.set() + + source.on_message = on_message + source.on_error = errors.append + source.connect() + try: + with anyio.fail_after(3): + if not before_start: + await received.wait() + received = anyio.Event() + source.close() + source.connect() + await received.wait() + if not before_start: + await tasks[0] + # Let the retired run's completion callback execute. + await anyio.sleep(0) + assert source.ready_state is EventSourceState.OPEN + assert not tasks[-1].done() + assert source in transport._event_sources + assert errors == [] + await transport.aclose() + assert all(task.done() and not task.cancelled() for task in tasks) + assert str(source.ready_state) == "closed" + assert source not in transport._event_sources + finally: + await transport.aclose() + + +async def test_transport_shutdown_waits_for_retiring_event_source_cleanup(server: Server) -> None: + closing, release, received = anyio.Event(), anyio.Event(), anyio.Event() + connections = 0 + + async def trace(name: str, info: dict[str, Any]) -> None: + if name == "http11.response_closed.started": + closing.set() + await release.wait() + + async def adapt(request: httpx.Request) -> httpx.Request: + nonlocal connections + connections += 1 + if connections == 1: + request.extensions["trace"] = trace + return request + + async with httpx.AsyncClient(base_url=server.url, trust_env=False) as client: + transport = HttpxTransport(client, request_adapter=adapt) + source = transport.event_source(RequestSpec("GET", "/events")) + source.on_message = lambda event: received.set() + source.connect() + shutdown: asyncio.Task[None] | None = None + try: + with anyio.fail_after(3): + await received.wait() + received = anyio.Event() + source.close() + source.connect() + await closing.wait() + await received.wait() + source.close() + # The new run can finish while the old run still owns its connection. + while len(source._tasks) > 1: + await anyio.sleep(0) + assert source in transport._event_sources + shutdown = asyncio.create_task(transport.aclose()) + await anyio.sleep(0) + assert not shutdown.done() + release.set() + await shutdown + assert not source._tasks + assert source not in transport._event_sources + assert (await client.get("/after")).status_code == 204 + finally: + release.set() + if shutdown is not None: + await shutdown + else: + await transport.aclose() + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("stage", ["read", "headers", "adapter"]) +@pytest.mark.parametrize("cancellation", ["task", "scope"]) +async def test_native_io_cancellation_waits_for_internal_cleanup( + server: Server, streaming: bool, stage: str, cancellation: str +) -> None: + entered, closing, release = anyio.Event(), anyio.Event(), anyio.Event() + scope = anyio.CancelScope() + observed: list[asyncio.CancelledError] = [] + + async def trace(name: str, info: dict[str, Any]) -> None: + entry = ( + "http11.receive_response_body.started" if stage != "headers" else "http11.receive_response_headers.started" + ) + closure = "http11.response_closed.started" + if name == entry: + entered.set() + elif name == closure: + closing.set() + await release.wait() + + async def adapt(request: httpx.Request) -> httpx.Request: + request.extensions["trace"] = trace + return request + + async with httpx.AsyncClient( + base_url=server.url, trust_env=False, limits=httpx.Limits(max_connections=1), timeout=1 + ) as client: + + async def read_response(response: httpx.Response, request: httpx.Request) -> httpx.Response: + await response.aread() + return response + + transport = HttpxTransport( + client, request_adapter=adapt, response_adapter=read_response if stage == "adapter" else None + ) + spec: RequestSpec[None] = RequestSpec("GET", "/headers" if stage == "headers" else "/events") + + async def run() -> None: + with scope: + try: + if streaming: + async with transport.event_stream(spec, lambda event: event.data) as stream: + async for event in stream: + assert event == "first" + else: + await transport.execute_request(spec) + except asyncio.CancelledError as error: + observed.append(error) + raise + + task = asyncio.create_task(run()) + try: + with anyio.fail_after(3): + await entered.wait() + if cancellation == "task": + task.cancel("original I/O cancellation") + else: + scope.cancel() + await closing.wait() + task.cancel("second I/O cancellation") + await anyio.sleep(0) + task.cancel("third I/O cancellation") + await anyio.sleep(0) + assert not task.done() + release.set() + if cancellation == "task": + with pytest.raises(asyncio.CancelledError) as failure: + await task + assert failure.value is observed[0] + assert failure.value.args == ("original I/O cancellation",) + else: + await task + assert scope.cancelled_caught and len(observed) == 1 + await server.disconnected.wait() + assert (await client.get("/after")).status_code == 204 + finally: + release.set() + if not task.done(): + task.cancel() + with suppress(asyncio.CancelledError): + await task + + +@pytest.mark.parametrize("owned", [False, True]) +@pytest.mark.parametrize("cancellation", ["task", "scope"]) +async def test_shutdown_shares_cleanup_and_preserves_caller_cancellation( + server: Server, owned: bool, cancellation: str +) -> None: + opened, closing, release = anyio.Event(), anyio.Event(), anyio.Event() + observed: list[asyncio.CancelledError] = [] + scope = anyio.CancelScope() + + async def trace(name: str, info: dict[str, Any]) -> None: + if name == "http11.response_closed.started": + closing.set() + await release.wait() + + async def adapt(request: httpx.Request) -> httpx.Request: + request.extensions["trace"] = trace + return request + + async with httpx.AsyncClient( + base_url=server.url, trust_env=False, limits=httpx.Limits(max_connections=1), timeout=1 + ) as client: + transport = ( + HttpxTransport(base_url=server.url, request_adapter=adapt) + if owned + else HttpxTransport(client, request_adapter=adapt) + ) + source = transport.event_source(RequestSpec("GET", "/events")) + source.on_message = lambda event: opened.set() + source.connect() + await opened.wait() + + async def shutdown() -> None: + with scope: + try: + await transport.aclose() + except asyncio.CancelledError as error: + observed.append(error) + raise + + task = asyncio.create_task(shutdown()) + other: asyncio.Task[None] | None = None + try: + with anyio.fail_after(3): + await closing.wait() + other = asyncio.create_task(transport.aclose()) + if cancellation == "task": + task.cancel("original shutdown cancellation") + else: + scope.cancel() + await anyio.sleep(0) + if cancellation == "task": + task.cancel("second shutdown cancellation") + else: + scope.cancel() + await anyio.sleep(0) + assert not task.done() and not other.done() + release.set() + if cancellation == "task": + with pytest.raises(asyncio.CancelledError) as failure: + await task + assert failure.value is observed[0] + assert failure.value.args == ("original shutdown cancellation",) + else: + await task + assert scope.cancelled_caught and len(observed) == 1 + await other + await server.disconnected.wait() + assert not source._tasks + assert transport.client.is_closed is owned + if not owned: + assert (await client.get("/after")).status_code == 204 + finally: + release.set() + with suppress(asyncio.CancelledError): + await task + if other is not None: + await other + await transport.aclose() + + +@pytest.mark.parametrize("error_type", [Stop, ValueError]) +async def test_concurrent_stream_closers_join_consumer_cleanup(server: Server, error_type: type[Exception]) -> None: + closing, release = anyio.Event(), anyio.Event() + original = error_type("original decoder failure") + observed: list[asyncio.CancelledError] = [] + + async def trace(name: str, info: dict[str, Any]) -> None: + if name == "http11.response_closed.started": + closing.set() + await release.wait() + + async def adapt(request: httpx.Request) -> httpx.Request: + request.extensions["trace"] = trace + return request + + def decode(event: object) -> str: + raise original + + async with httpx.AsyncClient( + base_url=server.url, trust_env=False, limits=httpx.Limits(max_connections=1), timeout=1 + ) as client: + transport = HttpxTransport(client, request_adapter=adapt) + stream = transport.event_stream(RequestSpec("GET", "/events"), decode) + + async def consume() -> None: + async with stream: + async for _event in stream: + raise AssertionError("Decoder must fail") + + async def close() -> None: + try: + await stream.aclose() + except asyncio.CancelledError as error: + observed.append(error) + raise + + consumer = asyncio.create_task(consume()) + closers: list[asyncio.Task[None]] = [] + try: + with anyio.fail_after(3): + await closing.wait() + closers = [asyncio.create_task(close()), asyncio.create_task(stream.aclose())] + await anyio.sleep(0) + closers[0].cancel("original close cancellation") + await anyio.sleep(0) + closers[0].cancel("second close cancellation") + await anyio.sleep(0) + assert not consumer.done() and all(not task.done() for task in closers) + release.set() + with pytest.raises(error_type) as failure: + await consumer + assert failure.value is original + with pytest.raises(asyncio.CancelledError) as cancelled: + await closers[0] + assert cancelled.value is observed[0] + assert cancelled.value.args == ("original close cancellation",) + await closers[1] + await server.disconnected.wait() + assert (await client.get("/after")).status_code == 204 + finally: + release.set() + for task in [consumer, *closers]: + with suppress(error_type, asyncio.CancelledError): + await task + + +@pytest.mark.parametrize("streaming", [False, True]) +async def test_native_stop_during_read_keeps_identity_despite_later_cancellation( + server: Server, streaming: bool +) -> None: + closing, release = anyio.Event(), anyio.Event() + original = Stop("original native stop") + + async def trace(name: str, info: dict[str, Any]) -> None: + if name == "http11.receive_response_body.started": + raise original + if name == "http11.response_closed.started": + closing.set() + await release.wait() + + async def adapt(request: httpx.Request) -> httpx.Request: + request.extensions["trace"] = trace + return request + + async with httpx.AsyncClient( + base_url=server.url, trust_env=False, limits=httpx.Limits(max_connections=1), timeout=1 + ) as client: + task = asyncio.create_task( + execute(HttpxTransport(client, request_adapter=adapt), streaming, RequestSpec("GET", "/events")) + ) + try: + with anyio.fail_after(3): + await closing.wait() + task.cancel("late cancellation") + await anyio.sleep(0) + assert not task.done() + release.set() + with pytest.raises(Stop) as failure: + await task + assert failure.value is original + await server.disconnected.wait() + assert (await client.get("/after")).status_code == 204 + finally: + release.set() + with suppress(Stop, asyncio.CancelledError): + await task + + +@pytest.mark.parametrize("streaming", [False, True]) +async def test_cancellation_racing_response_delivery_releases_undelivered_response( + server: Server, streaming: bool +) -> None: + closing, release = anyio.Event(), anyio.Event() + owner: asyncio.Task[httpx.Response] | None = None + + async def delivered(response: httpx.Response) -> None: + if response.request.url.path == "/events": + assert owner is not None + owner.cancel("cancel response handoff") + + async def trace(name: str, info: dict[str, Any]) -> None: + if name == "http11.response_closed.started": + closing.set() + await release.wait() + + async def adapt(request: httpx.Request) -> httpx.Request: + request.extensions["trace"] = trace + return request + + async with httpx.AsyncClient( + base_url=server.url, + trust_env=False, + limits=httpx.Limits(max_connections=1), + timeout=1, + event_hooks={"response": [delivered]}, + ) as client: + owner = asyncio.create_task( + execute(HttpxTransport(client, request_adapter=adapt), streaming, RequestSpec("GET", "/events")) + ) + try: + with anyio.fail_after(3): + await closing.wait() + owner.cancel("second handoff cancellation") + await anyio.sleep(0) + assert not owner.done() + release.set() + with pytest.raises(asyncio.CancelledError) as failure: + await owner + assert failure.value.args == ("cancel response handoff",) + await server.disconnected.wait() + assert (await client.get("/after")).status_code == 204 + finally: + release.set() + with suppress(asyncio.CancelledError): + await owner + + +@pytest.mark.parametrize("operation", ["acquire", "refresh", "discovery"]) +async def test_oauth_native_cleanup_preserves_cancellation_and_releases_pool(server: Server, operation: str) -> None: + reading, closing, release = anyio.Event(), anyio.Event(), anyio.Event() + + async def trace(name: str, info: dict[str, Any]) -> None: + if name == "http11.receive_response_body.started": + reading.set() + if name == "http11.response_closed.started": + closing.set() + await release.wait() + + async def prepare(request: httpx.Request) -> None: + if request.url.path != "/after": + request.extensions["trace"] = trace + + async with httpx.AsyncClient( + base_url=server.url, + trust_env=False, + limits=httpx.Limits(max_connections=1), + timeout=1, + event_hooks={"request": [prepare]}, + ) as client: + provider = HttpxOAuthTokenProvider( + client, + identity="test", + client_id="test", + client_secret="test", + authentication="client_secret_basic", + issuer=server.url, + ) + request = TokenRequest( + scheme="test", + provider="test", + flow="clientCredentials", + client_identity="test", + token_url=f"{server.url}/events", + discovery_url=f"{server.url}/events" if operation == "discovery" else None, + transport=SecurityTransport(location="header", name="Authorization", prefix="Bearer"), + ) + task = asyncio.create_task( + provider.refresh(request, "refresh") if operation == "refresh" else provider.acquire(request) + ) + try: + with anyio.fail_after(3): + await reading.wait() + task.cancel("original OAuth cancellation") + await closing.wait() + task.cancel("second OAuth cancellation") + await anyio.sleep(0) + assert not task.done() + release.set() + with pytest.raises(asyncio.CancelledError) as failure: + await task + assert failure.value.args == ("original OAuth cancellation",) + await server.disconnected.wait() + assert (await client.get("/after")).status_code == 204 + finally: + release.set() + with suppress(asyncio.CancelledError): + await task + + +async def test_buffered_body_collection_uses_one_owner_task(server: Server) -> None: + owners: set[asyncio.Task[Any] | None] = set() + chunks = 0 + + class TrackedBody(httpx.AsyncByteStream): + def __init__(self, stream: httpx.AsyncByteStream) -> None: + self.stream = stream + + async def __aiter__(self) -> AsyncIterator[bytes]: + nonlocal chunks + async for chunk in self.stream: + owners.add(asyncio.current_task()) + chunks += 1 + yield chunk + + async def aclose(self) -> None: + await self.stream.aclose() + + async def adapt(response: httpx.Response, request: httpx.Request) -> httpx.Response: + assert isinstance(response.stream, httpx.AsyncByteStream) + response.stream = TrackedBody(response.stream) + return response + + async with httpx.AsyncClient(base_url=server.url, trust_env=False) as client: + response = await HttpxTransport(client, response_adapter=adapt).execute_request(RequestSpec("GET", "/bulk")) + assert response.content == b"x" * (1024 * 1024) + assert chunks > 1 and len(owners) == 1 + + +@pytest.mark.parametrize("error_type", [Stop, asyncio.CancelledError, ValueError]) +async def test_transport_context_preserves_original_failure(error_type: type[BaseException]) -> None: + original = error_type("original context failure") + + class FailingCloseTransport(HttpxTransport): + async def _close(self) -> None: + await super()._close() + raise RuntimeError("native client cleanup failed") + + transport = FailingCloseTransport() + with pytest.raises(error_type) as failure: + async with transport: + raise original + assert failure.value is original + assert transport.client.is_closed + assert "Closing the HTTP transport also failed" in original.__notes__ + + +@pytest.mark.parametrize("streaming", [False, True]) +async def test_upload_cancellation_finishes_native_cleanup(server: Server, streaming: bool) -> None: + uploading, closing, release = anyio.Event(), anyio.Event(), anyio.Event() + + async def content() -> AsyncIterator[bytes]: + yield b"first" + uploading.set() + await anyio.sleep_forever() + + async def trace(name: str, info: dict[str, Any]) -> None: + if name == "http11.response_closed.started": + closing.set() + await release.wait() + + async def adapt(request: httpx.Request) -> httpx.Request: + request.extensions["trace"] = trace + return request + + async with httpx.AsyncClient( + base_url=server.url, trust_env=False, limits=httpx.Limits(max_connections=1), timeout=1 + ) as client: + task = asyncio.create_task( + execute( + HttpxTransport(client, request_adapter=adapt), + streaming, + RequestSpec("POST", "/upload", body=StreamingBody(content)), + ) + ) + try: + with anyio.fail_after(3): + await uploading.wait() + task.cancel("original upload cancellation") + await closing.wait() + task.cancel("second upload cancellation") + await anyio.sleep(0) + assert not task.done() + release.set() + with pytest.raises(asyncio.CancelledError) as failure: + await task + assert failure.value.args == ("original upload cancellation",) + await server.disconnected.wait() + assert (await client.get("/after")).status_code == 204 + finally: + release.set() + with suppress(asyncio.CancelledError): + await task + + +async def test_shutdown_joins_an_independently_cancelled_source(server: Server) -> None: + closing, release = anyio.Event(), anyio.Event() + tasks: list[asyncio.Task[Any]] = [] + + async def trace(name: str, info: dict[str, Any]) -> None: + if name == "http11.response_closed.started": + closing.set() + await release.wait() + + async def adapt(request: httpx.Request) -> httpx.Request: + request.extensions["trace"] = trace + return request + + transport = HttpxTransport(base_url=server.url, request_adapter=adapt) + source = transport.event_source(RequestSpec("GET", "/events")) + + def cancel_source(event: object) -> None: + task = asyncio.current_task() + assert task is not None + tasks.append(task) + task.cancel("source cancelled independently") + + source.on_message = cancel_source + source.connect() + shutdown: asyncio.Task[None] | None = None + try: + with anyio.fail_after(3): + await closing.wait() + shutdown = asyncio.create_task(transport.aclose()) + await anyio.sleep(0) + assert not shutdown.done() + release.set() + await shutdown + assert tasks[0].cancelled() + assert transport.client.is_closed + await server.disconnected.wait() + finally: + release.set() + if shutdown is not None: + await shutdown + await transport.aclose() + + +@pytest.mark.parametrize("stage", ["headers", "response-adapter"]) +@pytest.mark.parametrize("failure_kind", ["none", "task-cancel", "context-stop", "context-error", "context-cancel"]) +async def test_stream_close_joins_attempt_before_response_handoff( + server: Server, stage: str, failure_kind: str +) -> None: + entered, closing, release, consumer_release = (anyio.Event() for _ in range(4)) + original = { + "context-stop": Stop("original close-context stop"), + "context-error": ValueError("original close-context error"), + "context-cancel": asyncio.CancelledError("original close-context cancellation"), + }.get(failure_kind) + observed: list[asyncio.CancelledError] = [] + + async def trace(name: str, info: dict[str, Any]) -> None: + if stage == "headers" and name == "http11.receive_response_headers.started": + entered.set() + if name == "http11.response_closed.started": + closing.set() + await release.wait() + + async def adapt_request(request: httpx.Request) -> httpx.Request: + request.extensions["trace"] = trace + return request + + async def adapt_response(response: httpx.Response, request: httpx.Request) -> httpx.Response: + if stage == "response-adapter": + entered.set() + await anyio.sleep_forever() + return response + + async with httpx.AsyncClient( + base_url=server.url, trust_env=False, limits=httpx.Limits(max_connections=1), timeout=1 + ) as client: + transport = HttpxTransport(client, request_adapter=adapt_request, response_adapter=adapt_response) + stream = transport.event_stream( + RequestSpec("GET", "/headers" if stage == "headers" else "/events"), lambda event: event.data + ) + + async def consume() -> None: + assert [event async for event in stream] == [] + # Closure must finish without joining application work after iteration. + await consumer_release.wait() + + async def close() -> None: + if original is not None: + async with stream: + raise original + else: + try: + await stream.aclose() + except asyncio.CancelledError as error: + observed.append(error) + raise + + consumer = asyncio.create_task(consume()) + closers: list[asyncio.Task[None]] = [] + try: + with anyio.fail_after(3): + await entered.wait() + closers = [asyncio.create_task(close()), asyncio.create_task(stream.aclose())] + await closing.wait() + if failure_kind != "none": + closers[0].cancel("original close cancellation") + await anyio.sleep(0) + closers[0].cancel("later close cancellation") + await anyio.sleep(0) + assert all(not task.done() for task in closers) + release.set() + if original is not None: + with pytest.raises(type(original)) as failure: + await closers[0] + assert failure.value is original + elif failure_kind == "task-cancel": + with pytest.raises(asyncio.CancelledError) as failure: + await closers[0] + assert failure.value is observed[0] + assert failure.value.args == ("original close cancellation",) + else: + await closers[0] + await closers[1] + # Prove cleanup via the borrowed pool before awaiting the consumer. + assert not consumer.done() + assert (await client.get("/after")).status_code == 204 + await server.disconnected.wait() + consumer_release.set() + await consumer + finally: + release.set() + consumer_release.set() + await asyncio.gather(consumer, *closers, return_exceptions=True) + + +async def test_close_during_response_adaptation_preserves_consumer_stop(server: Server) -> None: + entered, closing, release = anyio.Event(), anyio.Event(), anyio.Event() + original = Stop("original adapter stop") + + async def trace(name: str, info: dict[str, Any]) -> None: + if name == "http11.response_closed.started": + closing.set() + await release.wait() + + async def adapt_request(request: httpx.Request) -> httpx.Request: + request.extensions["trace"] = trace + return request + + async def adapt_response(response: httpx.Response, request: httpx.Request) -> httpx.Response: + entered.set() + try: + await anyio.sleep_forever() + except asyncio.CancelledError: + raise original from None + raise AssertionError("Adapter must be interrupted") + + async with httpx.AsyncClient( + base_url=server.url, trust_env=False, limits=httpx.Limits(max_connections=1), timeout=1 + ) as client: + stream = HttpxTransport(client, request_adapter=adapt_request, response_adapter=adapt_response).event_stream( + RequestSpec("GET", "/events"), lambda event: event.data + ) + + async def consume() -> None: + async with stream: + async for _event in stream: + raise AssertionError("Adapter must fail before delivery") + + consumer = asyncio.create_task(consume()) + closer: asyncio.Task[None] | None = None + try: + with anyio.fail_after(3): + await entered.wait() + closer = asyncio.create_task(stream.aclose()) + await closing.wait() + assert not closer.done() + release.set() + await closer + assert (await client.get("/after")).status_code == 204 + with pytest.raises(Stop) as failure: + await consumer + assert failure.value is original + finally: + release.set() + await asyncio.gather(consumer, *([closer] if closer is not None else []), return_exceptions=True) + + +@pytest.mark.parametrize("stage", ["request-adapter", "response-adapter", "native-hook"]) +async def test_close_from_own_adapter_or_hook_does_not_join_itself(server: Server, stage: str) -> None: + async def adapt_request(request: httpx.Request) -> httpx.Request: + if stage == "request-adapter": + await stream.aclose() + return request + + async def adapt_response(response: httpx.Response, request: httpx.Request) -> httpx.Response: + if stage == "response-adapter": + await stream.aclose() + return response + + async def native_hook(response: httpx.Response) -> None: + if stage == "native-hook" and response.request.url.path == "/events": + await stream.aclose() + + async with httpx.AsyncClient( + base_url=server.url, + trust_env=False, + limits=httpx.Limits(max_connections=1), + timeout=1, + event_hooks={"response": [native_hook]}, + ) as client: + stream = HttpxTransport(client, request_adapter=adapt_request, response_adapter=adapt_response).event_stream( + RequestSpec("GET", "/events"), lambda event: event.data + ) + with anyio.fail_after(3): + async with stream: + assert [event async for event in stream] == [] + assert (await client.get("/after")).status_code == 204 + + +@pytest.mark.parametrize("failure_kind", ["none", "stop", "cancellation"]) +async def test_decode_uses_collected_response_and_preserves_error_identity(server: Server, failure_kind: str) -> None: + native: list[httpx.Response] = [] + original = { + "stop": Stop("original decoder stop"), + "cancellation": asyncio.CancelledError("original decoder cancellation"), + }.get(failure_kind) + + async def capture(response: httpx.Response, request: httpx.Request) -> httpx.Response: + native.append(response) + return response + + def decode(value: object) -> int: + assert value == b"x" * (1024 * 1024) + assert native[0].is_closed and native[0].is_stream_consumed + if original is not None: + raise original + return len(value) if isinstance(value, bytes) else 0 + + async with httpx.AsyncClient( + base_url=server.url, trust_env=False, limits=httpx.Limits(max_connections=1), timeout=1 + ) as client: + transport = HttpxTransport(client, response_adapter=capture) + operation: OperationSpec[None, int] = OperationSpec( + RequestSpec("GET", "/bulk"), + (ResponseSpec(200, (MediaType("application/octet-stream"),), decode, binary_body=True),), + ) + if original is None: + result = await transport.response(operation) + assert result.result == 1024 * 1024 + else: + with pytest.raises(type(original)) as failure: + await transport.response(operation) + assert failure.value is original + assert (await client.get("/after")).status_code == 204 + + +@pytest.mark.parametrize("stage", ["request-adapter", "response-adapter", "request-hook", "response-hook"]) +@pytest.mark.parametrize("external_first", [False, True]) +@pytest.mark.parametrize("failure_kind", ["none", "stop"]) +@pytest.mark.parametrize("owned", [False, True]) +async def test_reentrant_transport_shutdown_joins_from_external_callers( + server: Server, stage: str, external_first: bool, failure_kind: str, owned: bool +) -> None: + opened, entered, proceed, returned, closing, release = (anyio.Event() for _ in range(6)) + original = Stop("original shutdown adapter stop") if failure_kind == "stop" else None + errors: list[BaseException | None] = [] + cancellations: list[asyncio.CancelledError] = [] + + async def shutdown_from_callback() -> None: + # Cleanup callbacks may finish under a shield after external shutdown has + # interrupted the attempt. They must not join the run they belong to. + with anyio.CancelScope(shield=True): + entered.set() + await proceed.wait() + await transport.aclose() + returned.set() + if original is not None: + raise original + + async def trace(name: str, info: dict[str, Any]) -> None: + if name == "http11.response_closed.started": + closing.set() + await release.wait() + + async def adapt_request(request: httpx.Request) -> httpx.Request: + if request.url.path == "/events": + request.extensions["trace"] = trace + elif stage == "request-adapter": + await shutdown_from_callback() + return request + + async def adapt_response(response: httpx.Response, request: httpx.Request) -> httpx.Response: + if request.url.path == "/shutdown" and stage == "response-adapter": + await shutdown_from_callback() + return response + + async def request_hook(request: httpx.Request) -> None: + if request.url.path == "/shutdown" and stage == "request-hook": + await shutdown_from_callback() + + async def response_hook(response: httpx.Response) -> None: + if response.request.url.path == "/shutdown" and stage == "response-hook": + await shutdown_from_callback() + + async def shutdown_externally() -> None: + try: + await transport.aclose() + except asyncio.CancelledError as error: + cancellations.append(error) + raise + + async with httpx.AsyncClient(base_url=server.url, trust_env=False, timeout=1) as client: + transport = HttpxTransport( + None if owned else client, + base_url=server.url if owned else None, + request_adapter=adapt_request, + response_adapter=adapt_response, + ) + transport.client.event_hooks = {"request": [request_hook], "response": [response_hook]} + peer = transport.event_source(RequestSpec("GET", "/events")) + peer.on_message = lambda event: opened.set() + peer.connect() + source = transport.event_source(RequestSpec("GET", "/shutdown")) + source.on_error = errors.append + closers: list[asyncio.Task[None]] = [] + run: asyncio.Task[None] | None = None + try: + with anyio.fail_after(3): + # Even request-adapter shutdown must release a real active socket. + await opened.wait() + source.connect() + (run,) = source._tasks + await entered.wait() + if external_first: + closers = [asyncio.create_task(shutdown_externally()), asyncio.create_task(transport.aclose())] + await closing.wait() + proceed.set() + await returned.wait() + if not external_first: + await closing.wait() + closers = [asyncio.create_task(shutdown_externally()), asyncio.create_task(transport.aclose())] + await anyio.sleep(0) + closers[0].cancel("first external shutdown cancellation") + await anyio.sleep(0) + closers[0].cancel("later external shutdown cancellation") + await anyio.sleep(0) + assert all(not closer.done() for closer in closers) + assert not transport.client.is_closed + release.set() + with pytest.raises(asyncio.CancelledError) as failure: + await closers[0] + assert failure.value is cancellations[0] + assert failure.value.args == ("first external shutdown cancellation",) + await closers[1] + assert run.done() + run.result() + assert errors == ([] if original is None else [original]) + if original is not None: + assert errors[0] is original + await server.disconnected.wait() + assert not peer._tasks and not source._tasks + assert transport.client.is_closed is owned + if not owned: + assert (await client.get("/after")).status_code == 204 + finally: + proceed.set() + release.set() + await asyncio.gather(*closers, return_exceptions=True) + await transport.aclose() + + +@pytest.mark.parametrize("stage", ["request-adapter", "response-adapter", "request-hook", "response-hook"]) +async def test_retiring_event_source_can_request_transport_shutdown(server: Server, stage: str) -> None: + entered, proceed, returned, replacement_opened = (anyio.Event() for _ in range(4)) + attempts = 0 + + async def shutdown() -> None: + with anyio.CancelScope(shield=True): + entered.set() + await proceed.wait() + await transport.aclose() + returned.set() + + async def adapt_request(request: httpx.Request) -> httpx.Request: + if request.url.path == "/retiring" and stage == "request-adapter": + await shutdown() + return request + + async def adapt_response(response: httpx.Response, request: httpx.Request) -> httpx.Response: + if request.url.path == "/retiring" and stage == "response-adapter": + await shutdown() + return response + + async def request_hook(request: httpx.Request) -> None: + if request.url.path == "/retiring" and stage == "request-hook": + await shutdown() + + async def response_hook(response: httpx.Response) -> None: + if response.request.url.path == "/retiring" and stage == "response-hook": + await shutdown() + + async with httpx.AsyncClient( + base_url=server.url, + trust_env=False, + timeout=1, + event_hooks={"request": [request_hook], "response": [response_hook]}, + ) as client: + transport = HttpxTransport(client, request_adapter=adapt_request, response_adapter=adapt_response) + + def factory(headers: tuple[tuple[str, str], ...]) -> httpx.Request: + nonlocal attempts + attempts += 1 + return client.build_request("GET", "/retiring" if attempts == 1 else "/events", headers=headers) + + source = transport.event_source_from(factory) + source.on_message = lambda event: replacement_opened.set() + source.connect() + try: + with anyio.fail_after(3): + await entered.wait() + source.close() + source.connect() + await replacement_opened.wait() + assert len(source._tasks) == 2 + proceed.set() + await returned.wait() + await transport.aclose() + assert not source._tasks + assert source.ready_state is EventSourceState.CLOSED + assert attempts == 2 + assert (await client.get("/after")).status_code == 204 + finally: + proceed.set() + await transport.aclose() diff --git a/tests/test_httpx_security.py b/tests/test_httpx_security.py index 265c835..725d30a 100644 --- a/tests/test_httpx_security.py +++ b/tests/test_httpx_security.py @@ -3,6 +3,7 @@ # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. +from collections.abc import AsyncIterator from dataclasses import replace from typing import Any @@ -19,6 +20,7 @@ TokenConfiguration, TokenManager, TokenProviderError, + TokenRejectedError, TokenRequest, TokenSet, TransportEvent, @@ -65,7 +67,7 @@ def observe(self, event: TransportEvent) -> None: async def send(transport: HttpxTransport, spec: RequestSpec[Any]) -> httpx.Response: - return await transport.transport_response(await transport.transport_request(spec)) + return await transport.execute_request(spec) @pytest.mark.anyio @@ -80,7 +82,7 @@ def handle(request: httpx.Request) -> httpx.Response: return httpx.Response(204) async with httpx.AsyncClient(base_url="https://api.example", transport=httpx.MockTransport(handle)) as client: - transport = HttpxTransport(client, token_manager=TokenManager({"identity": provider})) + transport = HttpxTransport(client, token_providers={"identity": TokenManager(provider)}) response = await send(transport, RequestSpec("GET", "/value", security=(BINDING,))) assert response.status_code == 204 assert response.request.headers["authorization"] == "[redacted]" @@ -117,7 +119,7 @@ def handle(request: httpx.Request) -> httpx.Response: return httpx.Response(status, headers={"WWW-Authenticate": challenge}) async with httpx.AsyncClient(base_url="https://api.example", transport=httpx.MockTransport(handle)) as client: - transport = HttpxTransport(client, token_manager=TokenManager({"identity": provider})) + transport = HttpxTransport(client, token_providers={"identity": TokenManager(provider)}) operation: Operation[None, httpx.Request, httpx.Response] = Operation( transport, OperationSpec(RequestSpec(method, "/value", security=(BINDING,)), (ResponseSpec(204),)), @@ -129,7 +131,7 @@ def handle(request: httpx.Request) -> httpx.Response: @pytest.mark.anyio -async def test_native_request_rechecks_expiry_and_public_operations_do_not_acquire() -> None: +async def test_native_request_export_delegates_lifecycle_and_public_operations_do_not_acquire() -> None: provider, seen = Provider(), [] def handle(request: httpx.Request) -> httpx.Response: @@ -138,13 +140,14 @@ def handle(request: httpx.Request) -> httpx.Response: manager = TokenManager({"identity": provider}) async with httpx.AsyncClient(base_url="https://api.example", transport=httpx.MockTransport(handle)) as client: - transport = HttpxTransport(client, token_manager=manager) + transport = HttpxTransport(client, token_providers={"identity": manager}) request = await transport.transport_request(RequestSpec("GET", "/value", security=(BINDING,))) await transport.transport_response(request) await manager.invalidate(await manager.credentials(BINDING)) await transport.transport_response(request) await send(transport, RequestSpec("GET", "/public", security=())) - assert seen == ["Bearer access-1", "Bearer renewed-1", None] + assert seen == ["Bearer access-1", "Bearer access-1", None] + assert provider.refreshes == [] @pytest.mark.anyio @@ -180,7 +183,7 @@ def handle(request: httpx.Request) -> httpx.Response: return httpx.Response(204) async with httpx.AsyncClient(base_url="https://api.example", transport=httpx.MockTransport(handle)) as client: - transport = HttpxTransport(client, token_manager=TokenManager({"identity": provider}), observers=(observer,)) + transport = HttpxTransport(client, token_providers={"identity": TokenManager(provider)}, observers=(observer,)) response = await send( transport, RequestSpec( @@ -208,7 +211,7 @@ def handle(_request: httpx.Request) -> httpx.Response: missing = HttpxTransport(client) with pytest.raises(TokenProviderError): await send(missing, RequestSpec("GET", "/value", security=(BINDING,))) - transport = HttpxTransport(client, token_manager=TokenManager({"identity": Provider()})) + transport = HttpxTransport(client, token_providers={"identity": TokenManager(Provider())}) with pytest.raises(TokenProviderError): await send( transport, @@ -233,7 +236,9 @@ def handle(request: httpx.Request) -> httpx.Response: raise httpx.ConnectError(f"failed: {request.url}", request=request) async with httpx.AsyncClient(base_url="https://api.example", transport=httpx.MockTransport(handle)) as client: - transport = HttpxTransport(client, token_manager=TokenManager({"identity": Provider()}), observers=(observer,)) + transport = HttpxTransport( + client, token_providers={"identity": TokenManager(Provider())}, observers=(observer,) + ) with pytest.raises(httpx.ConnectError) as error: await send(transport, RequestSpec("GET", "/value", security=(binding,))) assert "access-" not in str(error.value) @@ -258,7 +263,7 @@ def handle(request: httpx.Request) -> httpx.Response: follow_redirects=True, auth=("unrelated", "credentials"), ) as client: - transport = HttpxTransport(client, token_manager=TokenManager({"identity": Provider()})) + transport = HttpxTransport(client, token_providers={"identity": TokenManager(Provider())}) response = await send(transport, RequestSpec("GET", "/value", security=(binding,))) assert response.status_code == 302 assert sends == ["https://api.example/value"] @@ -278,7 +283,7 @@ def handle(request: httpx.Request) -> httpx.Response: return httpx.Response(401, headers={"WWW-Authenticate": "Bearer error=invalid_token"}) async with httpx.AsyncClient(base_url="https://api.example", transport=httpx.MockTransport(handle)) as client: - transport = HttpxTransport(client, token_manager=TokenManager({"identity": provider})) + transport = HttpxTransport(client, token_providers={"identity": TokenManager(provider)}) stream = transport.event_stream( RequestSpec("GET", "/events", security=(BINDING,)), lambda event: event.data, @@ -312,7 +317,7 @@ async def acquire(self, request: TokenRequest) -> TokenSet: lambda _: httpx.Response(200, headers={"Content-Type": "text/event-stream"}, content="data: recovered\n\n") ), ) as client: - transport = HttpxTransport(client, token_manager=TokenManager({"identity": provider})) + transport = HttpxTransport(client, token_providers={"identity": TokenManager(provider)}) stream = transport.event_stream( RequestSpec("GET", "/events", security=(BINDING,)), lambda event: event.data, @@ -340,7 +345,7 @@ def handle(request: httpx.Request) -> httpx.Response: transport=httpx.MockTransport(handle), headers={"Authorization": "Bearer ambient"}, ) as client: - transport = HttpxTransport(client, token_manager=TokenManager({"identity": Provider()})) + transport = HttpxTransport(client, token_providers={"identity": TokenManager(Provider())}) await send(transport, RequestSpec("GET", "/managed", security=(binding,))) await send(transport, RequestSpec("GET", "/unmanaged")) assert client.headers["authorization"] == "Bearer ambient" @@ -356,7 +361,7 @@ def handle(request: httpx.Request) -> httpx.Response: @pytest.mark.anyio -async def test_credentials_are_checked_once_at_send_and_again_on_native_request_reuse() -> None: +async def test_credentials_are_acquired_once_at_export_without_hidden_reauthorization() -> None: class CountingProvider(Provider): configurations = 0 @@ -368,11 +373,97 @@ def configure(self, binding: SecurityBinding) -> TokenConfiguration: async with httpx.AsyncClient( base_url="https://api.example", transport=httpx.MockTransport(lambda _: httpx.Response(204)) ) as client: - transport = HttpxTransport(client, token_manager=TokenManager({"identity": provider})) + transport = HttpxTransport(client, token_providers={"identity": TokenManager(provider)}) native = await transport.transport_request(RequestSpec("GET", "/value", security=(BINDING,))) - assert provider.configurations == provider.acquisitions == 0 + assert provider.configurations == provider.acquisitions == 1 await transport.transport_response(native) assert provider.configurations == provider.acquisitions == 1 await transport.transport_response(native) - assert provider.configurations == 2 + assert provider.configurations == 1 assert provider.acquisitions == 1 + + +@pytest.mark.anyio +async def test_external_provider_observes_rotation_logout_and_rejection_without_a_cache() -> None: + class External(Provider): + token: str | None = "first" + rejections = 0 + + async def acquire(self, request: TokenRequest) -> TokenSet: + self.acquisitions += 1 + if self.token is None: + raise TokenProviderError() + return TokenSet(self.token) + + async def reject(self, request: TokenRequest, rejected_token: str) -> bool: + self.rejections += 1 + if self.token == rejected_token: + self.token = "renewed" + return True + + provider = External() + seen: list[str] = [] + + def handle(request: httpx.Request) -> httpx.Response: + value = request.headers["authorization"] + seen.append(value) + if value == "Bearer rejected": + return httpx.Response(401, headers={"WWW-Authenticate": "Bearer error=invalid_token"}) + return httpx.Response(204) + + async with httpx.AsyncClient(base_url="https://api.example", transport=httpx.MockTransport(handle)) as client: + transport = HttpxTransport(client, token_providers={"identity": provider}) + operation: Operation[None, httpx.Request, httpx.Response] = Operation( + transport, OperationSpec(RequestSpec("GET", "/value", security=(BINDING,)), (ResponseSpec(204),)) + ) + await operation.execute() + provider.token = "replacement" + await operation.transport_response() + provider.token = "rejected" + await operation.execute() + assert provider.acquisitions == 4 + assert provider.rejections == 1 + assert seen == ["Bearer first", "Bearer replacement", "Bearer rejected", "Bearer renewed"] + provider.token = None + with pytest.raises(TokenProviderError): + await operation.execute() + assert len(seen) == 4 + + +@pytest.mark.anyio +async def test_external_provider_without_rejection_support_never_replays() -> None: + provider = Provider() + seen: list[httpx.Request] = [] + + def handle(request: httpx.Request) -> httpx.Response: + seen.append(request) + return httpx.Response(401, headers={"WWW-Authenticate": "Bearer error=invalid_token"}) + + async with httpx.AsyncClient(base_url="https://api.example", transport=httpx.MockTransport(handle)) as client: + transport = HttpxTransport(client, token_providers={"identity": provider}) + with pytest.raises(TokenRejectedError): + await transport.execute_request(RequestSpec("GET", "/value", security=(BINDING,))) + assert len(seen) == provider.acquisitions == 1 + assert provider.refreshes == [] + + +@pytest.mark.anyio +async def test_failed_rejection_closes_response_and_sanitizes_provider_error() -> None: + class FailingProvider(Provider): + async def reject(self, request: TokenRequest, rejected_token: str) -> bool: + raise ValueError("private-provider-detail") + + class Body(httpx.AsyncByteStream): + async def __aiter__(self) -> AsyncIterator[bytes]: + yield b"rejected" + + response = httpx.Response(401, headers={"WWW-Authenticate": "Bearer error=invalid_token"}, stream=Body()) + assert not response.is_closed + async with httpx.AsyncClient( + base_url="https://api.example", transport=httpx.MockTransport(lambda _: response) + ) as client: + transport = HttpxTransport(client, token_providers={"identity": FailingProvider()}) + with pytest.raises(TokenProviderError) as failure: + await transport.execute_request(RequestSpec("GET", "/value", security=(BINDING,))) + assert "private-provider-detail" not in str(failure.value) + assert response.is_closed diff --git a/tests/test_httpx_sse.py b/tests/test_httpx_sse.py index 41ad2bc..8153e74 100644 --- a/tests/test_httpx_sse.py +++ b/tests/test_httpx_sse.py @@ -16,6 +16,7 @@ EventSourceState, EventStreamOptions, Problem, + RequestCancellationError, RequestEncodingError, RequestSpec, TransportError, @@ -368,7 +369,7 @@ async def consume() -> None: @pytest.mark.anyio -async def test_event_stream_follows_redirects_without_reapplying_adapters() -> None: +async def test_event_stream_readapts_each_managed_redirect() -> None: requests: list[httpx.Request] = [] adaptations = 0 @@ -394,7 +395,7 @@ def handler(request: httpx.Request) -> httpx.Response: assert [event async for event in stream] == [] assert [request.url.path for request in requests] == ["/events", "/redirected"] - assert adaptations == 1 + assert adaptations == 2 @pytest.mark.anyio @@ -646,3 +647,198 @@ def send(_request: httpx.Request) -> httpx.Response: assert errors[0].__cause__ is failure assert validations == 2 assert sends == 0 + + +class TrackedChunks(Chunks): + def __init__(self, *chunks: bytes, close_error: BaseException | None = None) -> None: + super().__init__(*chunks) + self.closes = 0 + self.close_error = close_error + + async def aclose(self) -> None: + self.closes += 1 + await anyio.sleep(0) + self.closed = True + if self.close_error is not None: + raise self.close_error + + +@pytest.mark.anyio +@pytest.mark.parametrize("close_mode", ["context", "explicit", "external"]) +async def test_early_stream_exit_leaves_consumer_task_usable(close_mode: str) -> None: + body = TrackedChunks(b"data: first\n\ndata: second\n\n") + + def handle(request: httpx.Request) -> httpx.Response: + if request.url.path == "/after": + return httpx.Response(204) + return httpx.Response(200, headers={"Content-Type": "text/event-stream"}, stream=body) + + async with httpx.AsyncClient(base_url="https://api.example", transport=httpx.MockTransport(handle)) as client: + transport = HttpxTransport(client) + stream = transport.event_stream(RequestSpec("GET", "/events"), lambda event: event.data) + iterator = stream.events() + try: + if close_mode == "context": + async with stream: + async for value in iterator: + assert value == "first" + break + else: + assert await anext(iterator) == "first" + if close_mode == "external": + await asyncio.create_task(stream.aclose()) + else: + await stream.aclose() + # Closing an SSE stream must not leave cancellation active in its consumer. + await anyio.sleep(0) + assert (await transport.execute_request(RequestSpec("GET", "/after"))).status_code == 204 + with pytest.raises(StopAsyncIteration): + await anext(iterator) + await stream.aclose() + finally: + await iterator.aclose() + assert body.closed and body.closes == 1 + + +@pytest.mark.anyio +@pytest.mark.parametrize("error_kind", ["stop", "task-cancellation", "ordinary"]) +async def test_stream_context_cleanup_preserves_consumer_error_identity(error_kind: str) -> None: + error = { + "stop": RequestCancellationError("consumer stop"), + "task-cancellation": asyncio.CancelledError("consumer cancellation"), + "ordinary": ValueError("consumer failure"), + }[error_kind] + body = TrackedChunks(b"data: value\n\n", close_error=RuntimeError("cleanup failure")) + async with httpx.AsyncClient( + base_url="https://api.example", + transport=httpx.MockTransport( + lambda _: httpx.Response(200, headers={"Content-Type": "text/event-stream"}, stream=body) + ), + ) as client: + stream = HttpxTransport(client).event_stream(RequestSpec("GET", "/events"), lambda event: event.data) + iterator = stream.events() + try: + with pytest.raises(type(error)) as failure: + async with stream: + assert await anext(iterator) == "value" + raise error + assert failure.value is error + assert "Closing the HTTP response also failed" in error.__notes__ + await anyio.sleep(0) + await stream.aclose() + finally: + await iterator.aclose() + assert body.closes == 1 + + +@pytest.mark.anyio +@pytest.mark.parametrize("error_type", [RequestCancellationError, asyncio.CancelledError, RuntimeError]) +async def test_stream_context_propagates_cleanup_failure_without_primary_error( + error_type: type[BaseException], +) -> None: + error = error_type("cleanup stop") + body = TrackedChunks(b"data: value\n\n", close_error=error) + async with httpx.AsyncClient( + base_url="https://api.example", + transport=httpx.MockTransport( + lambda _: httpx.Response(200, headers={"Content-Type": "text/event-stream"}, stream=body) + ), + ) as client: + stream = HttpxTransport(client).event_stream(RequestSpec("GET", "/events"), lambda event: event.data) + iterator = stream.events() + try: + with pytest.raises(error_type) as failure: + async with stream: + await anext(iterator) + assert failure.value is error + await stream.aclose() + finally: + await iterator.aclose() + assert body.closes == 1 + + +@pytest.mark.anyio +@pytest.mark.parametrize("stage", ["request", "response"]) +async def test_stream_close_interrupts_adapters_without_cancelling_consumer(stage: str) -> None: + entered = anyio.Event() + body = TrackedChunks(b"data: value\n\n") + + async def adapt_request(request: httpx.Request) -> httpx.Request: + if stage == "request": + entered.set() + await anyio.sleep_forever() + return request + + async def adapt_response(response: httpx.Response, request: httpx.Request) -> httpx.Response: + if stage == "response": + entered.set() + await anyio.sleep_forever() + return response + + async with httpx.AsyncClient( + base_url="https://api.example", + transport=httpx.MockTransport( + lambda _: httpx.Response(200, headers={"Content-Type": "text/event-stream"}, stream=body) + ), + ) as client: + transport = HttpxTransport(client, request_adapter=adapt_request, response_adapter=adapt_response) + stream = transport.event_stream(RequestSpec("GET", "/events"), lambda event: event.data) + completed = anyio.Event() + + async def consume() -> None: + assert [event async for event in stream] == [] + await anyio.sleep(0) + completed.set() + + with anyio.fail_after(2): + async with anyio.create_task_group() as group: + group.start_soon(consume) + await entered.wait() + await stream.aclose() + assert body.closes == (1 if stage == "response" else 0) + await completed.wait() + assert body.closes == (1 if stage == "response" else 0) + + +@pytest.mark.anyio +async def test_early_stream_exit_releases_native_connection_before_client_close() -> None: + from anyio.abc import SocketAttribute, SocketStream + + disconnected = anyio.Event() + + async def serve(socket: SocketStream) -> None: + async with socket: + headers = bytearray() + while b"\r\n\r\n" not in headers: + headers.extend(await socket.receive()) + if headers.startswith(b"GET /after "): + await socket.send(b"HTTP/1.1 204 No Content\r\nConnection: close\r\n\r\n") + return + await socket.send( + b"HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nContent-Length: 1024\r\n\r\ndata: value\n\n" + ) + with pytest.raises(anyio.EndOfStream): + await socket.receive() + disconnected.set() + + listener = await anyio.create_tcp_listener(local_host="127.0.0.1") + port = listener.extra(SocketAttribute.local_port) + async with listener, anyio.create_task_group() as group: + group.start_soon(listener.serve, serve) + try: + async with httpx.AsyncClient( + base_url=f"http://127.0.0.1:{port}", trust_env=False, limits=httpx.Limits(max_connections=1) + ) as client: + transport = HttpxTransport(client) + stream = transport.event_stream(RequestSpec("GET", "/events"), lambda event: event.data) + iterator = stream.events() + try: + with anyio.fail_after(2): + async with stream: + assert await anext(iterator) == "value" + await disconnected.wait() + assert (await transport.execute_request(RequestSpec("GET", "/after"))).status_code == 204 + finally: + await iterator.aclose() + finally: + group.cancel_scope.cancel() diff --git a/tests/test_tokens.py b/tests/test_tokens.py index 2463771..ac6d659 100644 --- a/tests/test_tokens.py +++ b/tests/test_tokens.py @@ -9,6 +9,7 @@ import pytest +from sunday.request_cancellation_error import RequestCancellationError from sunday.security import SecurityBinding, SecurityEndpoints, SecurityTransport from sunday.token_manager import TokenManager from sunday.token_provider import ( @@ -17,6 +18,7 @@ TokenProviderError, TokenRequest, TokenSet, + provider_credentials, ) BINDING = SecurityBinding( @@ -340,3 +342,96 @@ async def acquire(self, request: TokenRequest) -> TokenSet: with pytest.raises(TokenProviderError): await fresh.credentials(binding) assert len(provider.acquisitions) == 1025 + + +@pytest.mark.anyio +@pytest.mark.parametrize("managed", [False, True]) +async def test_provider_request_resolution_preserves_configuration(managed: bool) -> None: + provider = Provider() + provider.tokens = TokenSet("token") + provider.configuration = TokenConfiguration( + "client", "session", SecurityEndpoints(token_url="https://override.example/token") + ) + binding = replace(BINDING, scopes=("write", "read", "read"), refresh_url="https://identity.example/refresh") + source = TokenManager(provider) if managed else provider + await provider_credentials(source, binding) + assert provider.acquisitions == [ + TokenRequest( + scheme=binding.scheme, + provider=binding.provider, + profile=binding.profile, + flow=binding.flow, + transport=binding.transport, + token_url="https://override.example/token", + refresh_url="https://identity.example/refresh", + scopes=("read", "write"), + client_identity="client", + grant_identity="session", + ) + ] + + +@pytest.mark.anyio +@pytest.mark.parametrize("managed", [False, True]) +async def test_provider_configuration_stop_preserves_identity(managed: bool) -> None: + stop = RequestCancellationError("stop configuring credentials") + + class StoppingProvider(Provider): + def configure(self, binding: SecurityBinding) -> TokenConfiguration: + raise stop + + provider = StoppingProvider() + source = TokenManager(provider) if managed else provider + with pytest.raises(RequestCancellationError) as failure: + await provider_credentials(source, BINDING) + assert failure.value is stop + assert provider.acquisitions == [] + + +@pytest.mark.anyio +async def test_external_provider_does_not_require_managed_grant_identity() -> None: + provider = Provider() + provider.tokens = TokenSet("token") + provider.configuration = TokenConfiguration("client") + binding = replace(BINDING, flow="authorizationCode") + assert (await provider_credentials(provider, binding)).tokens.access_token == "token" + with pytest.raises(TokenProviderError): + await provider_credentials(TokenManager(provider), binding) + assert len(provider.acquisitions) == 1 + + +@pytest.mark.anyio +async def test_abandoned_persistence_failure_is_retrieved_without_duplicate_loop_reporting() -> None: + saving, finish = asyncio.Event(), asyncio.Event() + loop = asyncio.get_running_loop() + previous = loop.get_exception_handler() + reported: list[object] = [] + + class Store: + async def load(self, _key: str) -> TokenSet | None: + return None + + async def save(self, _key: str, _tokens: TokenSet) -> None: + saving.set() + await finish.wait() + raise RuntimeError("persistence failed after caller cancellation") + + async def remove(self, _key: str) -> None: + pass + + manager = TokenManager(Provider(), store=Store(), now=lambda: 0) + loop.set_exception_handler(lambda _loop, context: reported.append(context["exception"])) + try: + waiter = asyncio.create_task(manager.credentials(BINDING)) + await saving.wait() + waiter.cancel() + with pytest.raises(asyncio.CancelledError): + await waiter + finish.set() + while manager._renewals: + await asyncio.sleep(0) + await asyncio.sleep(0) + assert reported == [] + finally: + finish.set() + loop.set_exception_handler(previous) From 02826952fb8676ed880a9ef2f9dbf095ebf6f1d3 Mon Sep 17 00:00:00 2001 From: Kevin Wooten Date: Mon, 9 Nov 2026 08:26:38 -0800 Subject: [PATCH 2/6] Prevent response cleanup callbacks from joining themselves --- README.md | 5 +- src/sunday/httpx/_response_cleanup.py | 24 ++++- src/sunday/httpx/_sse.py | 10 +- tests/test_httpx_cleanup.py | 134 ++++++++++++++++++++++++++ 4 files changed, 166 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index d50b420..badc5df 100644 --- a/README.md +++ b/README.md @@ -407,8 +407,9 @@ Use `async with stream` or explicitly await `stream.aclose()` when ending iterat Closing a stream interrupts and joins its active I/O, including header reception and response adaptation before the stream receives the response. It then joins response cleanup without waiting for application work between yielded events. Context cleanup preserves the consumer's original -exception if cleanup fails. A close called inside that stream's own adapter or native hook requests -closure without waiting on itself; external close callers wait for completion. +exception if cleanup fails. A close called inside that stream's own adapter, native hook, or +response-cleanup callback requests closure without waiting on itself; external close callers +wait for completion, including when callbacks delegate work to child tasks. The existing `adapters=` argument remains supported for legacy `(transport, request)` adapters; it runs before the new request-adapter chain. Prefer the independent `request_adapter=` and diff --git a/src/sunday/httpx/_response_cleanup.py b/src/sunday/httpx/_response_cleanup.py index db435db..a6d5eb6 100644 --- a/src/sunday/httpx/_response_cleanup.py +++ b/src/sunday/httpx/_response_cleanup.py @@ -7,11 +7,14 @@ import asyncio from collections.abc import AsyncIterator +from contextvars import ContextVar import httpx from ._async import complete, in_operation, run_io +_cleanup_owners: ContextVar[tuple[_ClosingStream, ...]] = ContextVar("sunday_httpx_cleanup_owners", default=()) + class _ClosingStream(httpx.AsyncByteStream): """Protect native cleanup, including closure initiated by HTTPX at EOF.""" @@ -32,11 +35,30 @@ async def _iterate(self) -> AsyncIterator[bytes]: return yield chunk + def owns_cleanup(self) -> bool: + return self in _cleanup_owners.get() and (self._cleanup is None or not self._cleanup.done()) + async def aclose(self) -> None: + if self.owns_cleanup(): + return if self._cleanup is None: - self._cleanup = asyncio.create_task(self._stream.aclose()) + self._cleanup = asyncio.create_task(self._close()) await complete(self._cleanup) + async def _close(self) -> None: + # Trace callbacks (and their child tasks) cannot join the cleanup that + # needs them to return. Completed cleanup still exposes its result. + token = _cleanup_owners.set((*_cleanup_owners.get(), self)) + try: + await self._stream.aclose() + finally: + _cleanup_owners.reset(token) + + +def in_response_cleanup(response: httpx.Response) -> bool: + """Return whether this callback belongs to the response's active cleanup.""" + return isinstance(response.stream, _ClosingStream) and response.stream.owns_cleanup() + def protect_response(response: httpx.Response) -> None: """Keep explicit and automatic response closure on the same protected path.""" diff --git a/src/sunday/httpx/_sse.py b/src/sunday/httpx/_sse.py index 689b264..58222cd 100644 --- a/src/sunday/httpx/_sse.py +++ b/src/sunday/httpx/_sse.py @@ -28,7 +28,7 @@ from ..token_provider import TokenProviderError from ._async import complete, run_io from ._reconnect import _ReconnectPolicy -from ._response_cleanup import close_response +from ._response_cleanup import close_response, in_response_cleanup from ._security import AuthenticationRecoveryBudget, RequestSecurity if TYPE_CHECKING: @@ -111,9 +111,11 @@ async def aclose(self) -> None: async def _close(self, error: BaseException | None = None) -> None: self._close_nowait() active = self._active_io - # Adapter and native-hook child tasks inherit their I/O ownership. They - # cannot join an attempt that is waiting for that same callback to return. - if active is not None and any(owner is active for owner in _io_owners.get()): + # Callbacks cannot join the I/O or cleanup waiting for them to return. + # Keep the response reference so external callers still join its cleanup. + if (active is not None and any(owner is active for owner in _io_owners.get())) or ( + self._response is not None and in_response_cleanup(self._response) + ): return try: if active is None: diff --git a/tests/test_httpx_cleanup.py b/tests/test_httpx_cleanup.py index 493ee22..f0df09c 100644 --- a/tests/test_httpx_cleanup.py +++ b/tests/test_httpx_cleanup.py @@ -1415,3 +1415,137 @@ def factory(headers: tuple[tuple[str, str], ...]) -> httpx.Request: finally: proceed.set() await transport.aclose() + + +@pytest.mark.parametrize("child_callback", [False, True]) +@pytest.mark.parametrize("close_target", ["stream", "response"]) +@pytest.mark.parametrize("failure_kind", ["none", "stop", "error", "cancellation"]) +async def test_early_exit_cleanup_can_reenter_close_without_releasing_external_waiters( + server: Server, child_callback: bool, close_target: str, failure_kind: str +) -> None: + from sunday.httpx._response_cleanup import close_response + + reentered, release = anyio.Event(), anyio.Event() + responses: list[httpx.Response] = [] + cancellations: list[asyncio.CancelledError] = [] + original = { + "stop": Stop("original consumer stop"), + "error": ValueError("original consumer error"), + "cancellation": asyncio.CancelledError("original consumer cancellation"), + }.get(failure_kind) + closes = 0 + + async def trace(name: str, info: dict[str, Any]) -> None: + nonlocal closes + if name == "http11.response_closed.started": + closes += 1 + close = stream.aclose() if close_target == "stream" else close_response(responses[0]) + if child_callback: + await asyncio.create_task(close) + else: + await close + reentered.set() + await release.wait() + + async def adapt_request(request: httpx.Request) -> httpx.Request: + request.extensions["trace"] = trace + return request + + async def adapt_response(response: httpx.Response, request: httpx.Request) -> httpx.Response: + responses.append(response) + return response + + async with httpx.AsyncClient( + base_url=server.url, trust_env=False, limits=httpx.Limits(max_connections=1), timeout=1 + ) as client: + stream = HttpxTransport(client, request_adapter=adapt_request, response_adapter=adapt_response).event_stream( + RequestSpec("GET", "/events"), lambda event: event.data + ) + + async def consume() -> None: + async with stream: + async for event in stream: + assert event == "first" + if original is not None: + raise original + break + + async def close_externally() -> None: + try: + await stream.aclose() + except asyncio.CancelledError as error: + cancellations.append(error) + raise + + consumer = asyncio.create_task(consume()) + closers: list[asyncio.Task[None]] = [] + try: + with anyio.fail_after(3): + await reentered.wait() + assert stream._active_io is None + assert stream._response is responses[0] + closers = [asyncio.create_task(close_externally()), asyncio.create_task(stream.aclose())] + await anyio.sleep(0) + closers[0].cancel("first external close cancellation") + await anyio.sleep(0) + closers[0].cancel("later external close cancellation") + await anyio.sleep(0) + assert all(not task.done() for task in [consumer, *closers]) + assert stream._response is responses[0] + release.set() + if original is None: + await consumer + else: + with pytest.raises(type(original)) as failure: + await consumer + assert failure.value is original + with pytest.raises(asyncio.CancelledError) as failure: + await closers[0] + assert failure.value is cancellations[0] + assert failure.value.args == ("first external close cancellation",) + await closers[1] + assert closes == 1 + assert stream._response is None + await server.disconnected.wait() + assert (await client.get("/after")).status_code == 204 + finally: + release.set() + await asyncio.gather(consumer, *closers, return_exceptions=True) + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("child_callback", [False, True]) +async def test_eof_cleanup_can_reenter_response_close(server: Server, streaming: bool, child_callback: bool) -> None: + from sunday.httpx._response_cleanup import close_response + + responses: list[httpx.Response] = [] + closes = 0 + + async def trace(name: str, info: dict[str, Any]) -> None: + nonlocal closes + if name == "http11.response_closed.started": + closes += 1 + close = close_response(responses[0]) + if child_callback: + await asyncio.create_task(close) + else: + await close + + async def adapt_request(request: httpx.Request) -> httpx.Request: + request.extensions["trace"] = trace + return request + + async def adapt_response(response: httpx.Response, request: httpx.Request) -> httpx.Response: + responses.append(response) + return response + + async with httpx.AsyncClient( + base_url=server.url, trust_env=False, limits=httpx.Limits(max_connections=1), timeout=1 + ) as client: + transport = HttpxTransport(client, request_adapter=adapt_request, response_adapter=adapt_response) + with anyio.fail_after(3): + response = await execute(transport, streaming, RequestSpec("GET", "/eof")) + assert response.content == b"data: first\n\n" + assert closes == 1 + await server.disconnected.wait() + assert (await client.get("/after")).status_code == 204 From f4c48dd24605dc1312ca225b49efd698555ef74e Mon Sep 17 00:00:00 2001 From: Kevin Wooten Date: Mon, 9 Nov 2026 08:48:33 -0800 Subject: [PATCH 3/6] Fix cleanup-owned shutdown and buffered upload framing --- README.md | 11 ++- src/sunday/httpx/_requests.py | 16 ++- src/sunday/httpx/_sse.py | 16 +-- src/sunday/httpx/_transport.py | 7 +- tests/test_httpx_cleanup.py | 172 ++++++++++++++++++++++++++++++++- 5 files changed, 199 insertions(+), 23 deletions(-) diff --git a/README.md b/README.md index badc5df..fd91640 100644 --- a/README.md +++ b/README.md @@ -382,8 +382,9 @@ HTTPX responses and headers are mutable; `await response.aread()` retains buffer subsequent readers. Return a new `httpx.Response` to replace the body. `copy_request()` preserves native extensions and shares an unread stream without consuming it; pass `content=b""` to remove a body. Changing the URL authority updates `Host` unless the supplied `headers` explicitly -override it. Replacing headers preserves an unread body's framing unless `Content-Length` or -`Transfer-Encoding` is explicitly supplied; streams without known framing use chunked encoding. +override it. Replacing headers preserves an unchanged body's framing unless `Content-Length` or +`Transfer-Encoding` is explicitly supplied. Buffering a chunked upload before copying it retains +chunked framing without adding `Content-Length`; streams without known framing use chunked encoding. Use asynchronous streams; synchronous factories must not block the event loop. Subclass `sunday.RequestCancellationError` to veto retries and SSE reconnects. Sunday propagates @@ -398,9 +399,9 @@ boundary that allows HTTPX/httpcore to finish internal cleanup before the origin is rethrown. This also covers OAuth discovery and token exchanges. Transport shutdown shares one completion task across callers and waits for retiring EventSource runs before closing an owned client. A cancelled shutdown waiter does not cancel that shared cleanup. When an owned -EventSource's adapter or native hook calls `transport.aclose()`, it requests shutdown without -joining its own run; external callers still wait for cleanup to finish. This also applies to -retiring runs after an immediate reconnect. +EventSource's adapter, native hook, or response-cleanup callback calls `transport.aclose()`, it +requests shutdown without joining its own run; external callers still wait for cleanup to finish. +This also applies to retiring runs after an immediate reconnect. Buffered collection uses HTTPX's bulk `aread()` with one owner task for the entire body; SSE uses its asynchronous byte iterator with cancellation bounded to each read. Use `async with stream` or explicitly await `stream.aclose()` when ending iteration early. diff --git a/src/sunday/httpx/_requests.py b/src/sunday/httpx/_requests.py index 22920b6..8207942 100644 --- a/src/sunday/httpx/_requests.py +++ b/src/sunday/httpx/_requests.py @@ -39,19 +39,25 @@ def copy_request( else: with suppress(httpx.RequestNotRead): content = request.content + if "content-length" not in copied_headers and "transfer-encoding" not in copied_headers: + for name in ("content-length", "transfer-encoding"): + if name in request.headers: + copied_headers[name] = request.headers[name] if content is not None: - return httpx.Request( + copied = httpx.Request( method or request.method, target_url, headers=copied_headers, content=content, extensions=dict(request.extensions), ) + # HTTPX adds Content-Length for cached bytes even when Transfer-Encoding + # already supplies framing. A copy must not introduce both headers. + if "transfer-encoding" in copied.headers: + copied.headers.pop("content-length", None) + return copied if "content-length" not in copied_headers and "transfer-encoding" not in copied_headers: - if "content-length" in request.headers: - copied_headers["content-length"] = request.headers["content-length"] - else: - copied_headers["transfer-encoding"] = request.headers.get("transfer-encoding", "chunked") + copied_headers["transfer-encoding"] = "chunked" return httpx.Request( method or request.method, target_url, diff --git a/src/sunday/httpx/_sse.py b/src/sunday/httpx/_sse.py index 58222cd..cd1161f 100644 --- a/src/sunday/httpx/_sse.py +++ b/src/sunday/httpx/_sse.py @@ -343,7 +343,7 @@ def __init__( self._spec = spec or RequestSpec("GET", "/") self._ready_state = EventSourceState.CLOSED self._stream: HttpxEventStream[ServerSentEvent] | None = None - self._tasks: set[asyncio.Task[None]] = set() + self._tasks: dict[asyncio.Task[None], HttpxEventStream[ServerSentEvent]] = {} self._listeners: dict[str, dict[UUID, EventSourceMessageHandler]] = {} self.on_open: EventSourceOpenHandler | None = None self.on_error: EventSourceErrorHandler | None = None @@ -395,7 +395,7 @@ def connect(self) -> None: ) self._stream = stream task = loop.create_task(self._run(stream), name="sunday-httpx-event-source") - self._tasks.add(task) + self._tasks[task] = stream task.add_done_callback(self._finished) def close(self) -> None: @@ -406,10 +406,12 @@ def close(self) -> None: if not self._tasks: self._transport._event_source_closed(self) - def _owns_current_io(self) -> bool: - # Native hook child tasks inherit the initiating run's I/O record. Include - # retiring runs, whose streams may no longer be self._stream. - return any(owner.task in self._tasks and not owner.done.is_set() for owner in _io_owners.get()) + def _owns_current_work(self) -> bool: + # Cleanup can outlive the I/O block. Retain each run's stream so callbacks + # from retiring runs are recognized as well as the current run's callbacks. + return any(owner.task in self._tasks and not owner.done.is_set() for owner in _io_owners.get()) or any( + stream._response is not None and in_response_cleanup(stream._response) for stream in self._tasks.values() + ) async def _wait_closed(self) -> None: if self._tasks: @@ -433,7 +435,7 @@ async def _run(self, stream: HttpxEventStream[ServerSentEvent]) -> None: def _finished(self, task: asyncio.Task[None]) -> None: # Retiring runs still own resources even after a replacement has connected. - self._tasks.discard(task) + self._tasks.pop(task, None) if not self._tasks: self._transport._event_source_closed(self) diff --git a/src/sunday/httpx/_transport.py b/src/sunday/httpx/_transport.py index 215f268..b8aab97 100644 --- a/src/sunday/httpx/_transport.py +++ b/src/sunday/httpx/_transport.py @@ -597,8 +597,9 @@ def _observe(self, event: TransportEvent) -> None: async def aclose(self) -> None: """Close owned event sources and the internal HTTPX client exactly once. - Calls from an owned EventSource's active adapter or native hook request - shutdown without joining their own run. External callers await completion. + Calls from an owned EventSource's adapter, native hook, or response-cleanup + callback request shutdown without joining their own run. External callers + await completion. """ if self._cleanup is None: self._closed = True @@ -606,7 +607,7 @@ async def aclose(self) -> None: for source in sources: source.close() self._cleanup = asyncio.create_task(self._close()) - if any(source._owns_current_io() for source in self._event_sources): + if any(source._owns_current_work() for source in self._event_sources): return await complete(self._cleanup) diff --git a/tests/test_httpx_cleanup.py b/tests/test_httpx_cleanup.py index f0df09c..8661fed 100644 --- a/tests/test_httpx_cleanup.py +++ b/tests/test_httpx_cleanup.py @@ -120,8 +120,9 @@ async def execute(transport: HttpxTransport, streaming: bool, spec: RequestSpec[ @pytest.mark.parametrize("streaming", [False, True]) @pytest.mark.parametrize("original", ["length", "chunked", "missing"]) @pytest.mark.parametrize("override", [None, "length", "chunked"]) +@pytest.mark.parametrize("buffered", [False, True]) async def test_copy_preserves_valid_streaming_framing_over_tcp( - server: Server, streaming: bool, original: str, override: str | None + server: Server, streaming: bool, original: str, override: str | None, buffered: bool ) -> None: async def adapt(request: httpx.Request) -> httpx.Request: if original == "missing": @@ -131,8 +132,13 @@ async def adapt(request: httpx.Request) -> httpx.Request: headers["Content-Length"] = "7" elif override == "chunked": headers["Transfer-Encoding"] = "chunked" + if buffered: + await request.aread() copied = copy_request(request, headers=headers) - assert copied.stream is request.stream + if buffered: + assert copied.content == request.content + else: + assert copied.stream is request.stream return copied async with httpx.AsyncClient(base_url=server.url, trust_env=False) as client: @@ -147,7 +153,7 @@ async def adapt(request: httpx.Request) -> httpx.Request: assert response.status_code == 204 assert len(server.uploads) == 1 headers, body = server.uploads[0] - expected = override or ("length" if original == "length" else "chunked") + expected = override or ("length" if original == "length" or (buffered and original == "missing") else "chunked") assert body == b"payload" assert headers["x-custom"] == "value" if expected == "length": @@ -1549,3 +1555,163 @@ async def adapt_response(response: httpx.Response, request: httpx.Request) -> ht assert closes == 1 await server.disconnected.wait() assert (await client.get("/after")).status_code == 204 + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("replacement", [None, b"", b"replacement"]) +async def test_buffered_chunked_upload_copy_and_replacement_framing( + server: Server, streaming: bool, replacement: bytes | None +) -> None: + async def adapt(request: httpx.Request) -> httpx.Request: + assert await request.aread() == b"payload" + assert request.headers["transfer-encoding"] == "chunked" + assert "content-length" not in request.headers + return copy_request(request, content=replacement) + + async with httpx.AsyncClient(base_url=server.url, trust_env=False) as client: + response = await execute( + HttpxTransport(client, request_adapter=adapt), + streaming, + RequestSpec("POST", "/upload", body=StreamingBody.bytes(b"payload")), + ) + assert response.status_code == 204 + (upload,) = server.uploads + headers, body = upload + assert body == (b"payload" if replacement is None else replacement) + if replacement is None: + assert headers["transfer-encoding"] == "chunked" + assert "content-length" not in headers + else: + assert headers["content-length"] == str(len(replacement)) + assert "transfer-encoding" not in headers + + +@pytest.mark.parametrize("callback", ["trace", "stream", "stream-stop"]) +@pytest.mark.parametrize("child_callback", [False, True]) +@pytest.mark.parametrize("retiring", [False, True]) +@pytest.mark.parametrize("owned", [False, True]) +async def test_transport_shutdown_recognizes_response_cleanup_callbacks( + server: Server, callback: str, child_callback: bool, retiring: bool, owned: bool +) -> None: + entered, proceed, returned, release, replacement_opened = (anyio.Event() for _ in range(5)) + errors: list[BaseException | None] = [] + cancellations: list[asyncio.CancelledError] = [] + original = Stop("original response cleanup stop") + attempts = 0 + closes = 0 + + async def shutdown_from_cleanup() -> None: + nonlocal closes + closes += 1 + entered.set() + await proceed.wait() + if child_callback: + await asyncio.create_task(transport.aclose()) + else: + await transport.aclose() + returned.set() + await release.wait() + + async def trace(name: str, info: dict[str, Any]) -> None: + if name == "http11.response_closed.started": + await shutdown_from_cleanup() + + async def adapt_request(request: httpx.Request) -> httpx.Request: + if callback == "trace" and request.url.path == "/events": + request.extensions["trace"] = trace + return request + + class ReentrantClose(httpx.AsyncByteStream): + def __init__(self, wrapped: httpx.AsyncByteStream) -> None: + self.wrapped = wrapped + + def __aiter__(self) -> AsyncIterator[bytes]: + return self.wrapped.__aiter__() + + async def aclose(self) -> None: + await shutdown_from_cleanup() + await self.wrapped.aclose() + if callback == "stream-stop": + raise original + + async def adapt_response(response: httpx.Response, request: httpx.Request) -> httpx.Response: + if callback != "trace" and request.url.path == "/events": + assert isinstance(response.stream, httpx.AsyncByteStream) + response.stream = ReentrantClose(response.stream) + return response + + async def close_externally() -> None: + try: + await transport.aclose() + except asyncio.CancelledError as error: + cancellations.append(error) + raise + + async with httpx.AsyncClient( + base_url=server.url, trust_env=False, limits=httpx.Limits(max_connections=2 if retiring else 1), timeout=1 + ) as client: + transport = HttpxTransport( + None if owned else client, + base_url=server.url if owned else None, + request_adapter=adapt_request, + response_adapter=adapt_response, + ) + + def factory(headers: tuple[tuple[str, str], ...]) -> httpx.Request: + nonlocal attempts + attempts += 1 + return transport.client.build_request( + "GET", "/events" if attempts == 1 else "/replacement", headers=headers + ) + + def message(event: Any) -> None: + if attempts == 1: + # Exit at a yielded event: cleanup runs outside the I/O ownership scope. + source.close() + if retiring: + source.connect() + else: + replacement_opened.set() + + source = transport.event_source_from(factory) + source.on_message = message + source.on_error = errors.append + source.connect() + closers: list[asyncio.Task[None]] = [] + try: + with anyio.fail_after(3): + await entered.wait() + if retiring: + await replacement_opened.wait() + closers = [asyncio.create_task(close_externally()), asyncio.create_task(transport.aclose())] + await anyio.sleep(0) + proceed.set() + await returned.wait() + closers[0].cancel("original external shutdown cancellation") + await anyio.sleep(0) + closers[0].cancel("later external shutdown cancellation") + await anyio.sleep(0) + assert all(not task.done() for task in closers) + assert not transport.client.is_closed + release.set() + with pytest.raises(asyncio.CancelledError) as failure: + await closers[0] + assert failure.value is cancellations[0] + assert failure.value.args == ("original external shutdown cancellation",) + await closers[1] + assert not source._tasks + assert closes == 1 + assert attempts == (2 if retiring else 1) + if callback == "stream-stop" and not retiring: + assert len(errors) == 1 and errors[0] is original + else: + assert errors == [] + await server.disconnected.wait() + assert transport.client.is_closed is owned + if not owned: + assert (await client.get("/after")).status_code == 204 + finally: + proceed.set() + release.set() + await asyncio.gather(*closers, return_exceptions=True) + await transport.aclose() From a919c7d41a932ebf65eb9b14af68f50e33155c52 Mon Sep 17 00:00:00 2001 From: Kevin Wooten Date: Mon, 9 Nov 2026 09:08:07 -0800 Subject: [PATCH 4/6] Sanitize managed response execution errors --- src/sunday/httpx/_transport.py | 8 +++++ tests/test_httpx_adapters.py | 62 ++++++++++++++++++++++++++++++++++ 2 files changed, 70 insertions(+) diff --git a/src/sunday/httpx/_transport.py b/src/sunday/httpx/_transport.py index b8aab97..7c26ba1 100644 --- a/src/sunday/httpx/_transport.py +++ b/src/sunday/httpx/_transport.py @@ -332,6 +332,7 @@ async def _execute( authorized = await security.authorize(sent, self.token_providers) if security is not None else None sent = await self._request_adapter.adapt(sent) response = await self._send_httpx(sent, security=authorized) + effective = sent try: response.history = [*history, *response.history] effective = copy_request(response.request) @@ -369,6 +370,13 @@ async def _execute( return response except BaseException as error: await close_response(response, error) + if ( + authorized is not None + and authorized.bindings + and isinstance(error, httpx.RequestError) + and not isinstance(error, RequestCancellationError) + ): + raise type(error)("HTTP request failed", request=authorized.diagnostic_request(effective)) from None raise async def _send_httpx( diff --git a/tests/test_httpx_adapters.py b/tests/test_httpx_adapters.py index 47a2cbd..6bfdbd4 100644 --- a/tests/test_httpx_adapters.py +++ b/tests/test_httpx_adapters.py @@ -7,6 +7,7 @@ import asyncio from collections.abc import AsyncGenerator, AsyncIterator +from dataclasses import replace from typing import Any import anyio @@ -800,3 +801,64 @@ def handle(request: httpx.Request) -> httpx.Response: await perform(HttpxTransport(client), streaming) assert failure.value is stop assert sends == body.reads == body.closes == 1 + + +@pytest.mark.parametrize(("stage", "streaming"), [("adapter", False), ("adapter", True), ("collection", False)]) +@pytest.mark.parametrize("bound_error", [False, True]) +@pytest.mark.parametrize("stop", [False, True]) +@pytest.mark.parametrize("managed", [True, False]) +async def test_managed_read_errors_sanitize_diagnostics_without_rewriting_stop_errors( + stage: str, streaming: bool, bound_error: bool, stop: bool, managed: bool +) -> None: + provider = Provider() + bindings = ( + BINDING, + replace(BINDING, scheme="query", transport=SecurityTransport(location="query", name="api_key")), + replace(BINDING, scheme="cookie", transport=SecurityTransport(location="cookie", name="session")), + ) + sent: list[httpx.Request] = [] + errors: list[httpx.ReadError] = [] + bodies: list[Body] = [] + + def handle(request: httpx.Request) -> httpx.Response: + sent.append(request) + error = (Stop if stop else httpx.ReadError)( + f"Read failed for {request.url}: {request.headers}", request=request if bound_error else None + ) + errors.append(error) + body = Body(error=error) + bodies.append(body) + return httpx.Response(200, stream=body) + + async def adapt(response: httpx.Response, request: httpx.Request) -> httpx.Response: + # Adapters need the effective credentials; only escaping diagnostics change. + if managed: + assert request.headers["authorization"] == "Bearer token-1" + assert request.url.params["api_key"] == "token-2" + assert request.headers["cookie"] == "session=token-3" + if stage == "adapter": + await response.aread() + return response + + async with httpx.AsyncClient(base_url="https://api.example", transport=httpx.MockTransport(handle)) as client: + transport = HttpxTransport(client, response_adapter=adapt, token_providers={"identity": provider}) + with pytest.raises(httpx.ReadError) as failure: + await perform(transport, streaming, RequestSpec("GET", "/value", security=bindings if managed else None)) + error = failure.value + assert len(sent) == 1 + assert bodies[0].closes == 1 + if managed and not stop: + assert type(error) is httpx.ReadError + assert error is not errors[0] + assert str(error) == "HTTP request failed" + assert error.request.headers["authorization"] == "[redacted]" + assert error.request.url.params["api_key"] == "[redacted]" + assert error.request.headers["cookie"] == "[redacted]" + assert "token-" not in str(error.request.url) + assert "token-" not in str(error.request.headers) + assert error.__cause__ is None and error.__suppress_context__ + assert sent[0].headers["authorization"] == "Bearer token-1" + assert sent[0].url.params["api_key"] == "token-2" + assert sent[0].headers["cookie"] == "session=token-3" + else: + assert error is errors[0] From 3d429a20a4d1749d50eac82bd595e7da374b8baf Mon Sep 17 00:00:00 2001 From: Kevin Wooten Date: Mon, 9 Nov 2026 09:28:39 -0800 Subject: [PATCH 5/6] Fix eager token renewal startup and consolidate diagnostics --- src/sunday/httpx/_security.py | 7 ++++ src/sunday/httpx/_transport.py | 19 +++------ src/sunday/token_manager.py | 2 + tests/test_httpx_adapters.py | 11 ++++-- tests/test_tokens.py | 71 ++++++++++++++++++++++++++++++++++ 5 files changed, 94 insertions(+), 16 deletions(-) diff --git a/src/sunday/httpx/_security.py b/src/sunday/httpx/_security.py index 90ef43b..2bbbe96 100644 --- a/src/sunday/httpx/_security.py +++ b/src/sunday/httpx/_security.py @@ -14,6 +14,7 @@ import httpx +from ..request_cancellation_error import RequestCancellationError from ..security import SecurityBinding from ..token_provider import TokenLease, TokenProvider, TokenProviderError, provider_credentials from ._requests import copy_request @@ -86,6 +87,12 @@ def rejected_leases(self, request: httpx.Request, response: httpx.Response) -> t and _bearer_token(request) == lease.tokens.access_token ) + def diagnostic_error(self, error: BaseException, request: httpx.Request) -> BaseException: + """Sanitize managed HTTPX failures while preserving cancellation identity.""" + if self.bindings and isinstance(error, httpx.RequestError) and not isinstance(error, RequestCancellationError): + return type(error)("HTTP request failed", request=self.diagnostic_request(request)) + return error + def diagnostic_request(self, request: httpx.Request) -> httpx.Request: """Remove managed credentials from native error/response diagnostics.""" url, headers = request.url, httpx.Headers(request.headers) diff --git a/src/sunday/httpx/_transport.py b/src/sunday/httpx/_transport.py index 7c26ba1..3f70875 100644 --- a/src/sunday/httpx/_transport.py +++ b/src/sunday/httpx/_transport.py @@ -370,13 +370,10 @@ async def _execute( return response except BaseException as error: await close_response(response, error) - if ( - authorized is not None - and authorized.bindings - and isinstance(error, httpx.RequestError) - and not isinstance(error, RequestCancellationError) - ): - raise type(error)("HTTP request failed", request=authorized.diagnostic_request(effective)) from None + if authorized is not None: + diagnostic_error = authorized.diagnostic_error(error, effective) + if diagnostic_error is not error: + raise diagnostic_error from None raise async def _send_httpx( @@ -409,12 +406,8 @@ async def _send_httpx( discard=close_response, ) except BaseException as error: - if ( - diagnostic is not request - and isinstance(error, httpx.RequestError) - and not isinstance(error, RequestCancellationError) - ): - error = type(error)("HTTP request failed", request=diagnostic) + if security is not None: + error = security.diagnostic_error(error, request) try: self._observe( TransportEvent( diff --git a/src/sunday/token_manager.py b/src/sunday/token_manager.py index f3d60c3..a155358 100644 --- a/src/sunday/token_manager.py +++ b/src/sunday/token_manager.py @@ -164,6 +164,8 @@ async def _exclusive(self, key: str) -> AsyncIterator[None]: self._locks.pop(key, None) async def _renew(self, key: str, provider: TokenProvider, request: TokenRequest) -> TokenLease: + # Register the renewal and its waiters before work starts, even with an eager task factory. + await asyncio.sleep(0) authorization_key = hashlib.sha256(key.encode()).digest() try: async with self._exclusive(key): diff --git a/tests/test_httpx_adapters.py b/tests/test_httpx_adapters.py index 6bfdbd4..5bf477a 100644 --- a/tests/test_httpx_adapters.py +++ b/tests/test_httpx_adapters.py @@ -803,11 +803,14 @@ def handle(request: httpx.Request) -> httpx.Response: assert sends == body.reads == body.closes == 1 -@pytest.mark.parametrize(("stage", "streaming"), [("adapter", False), ("adapter", True), ("collection", False)]) +@pytest.mark.parametrize( + ("stage", "streaming"), + [("send", False), ("send", True), ("adapter", False), ("adapter", True), ("collection", False)], +) @pytest.mark.parametrize("bound_error", [False, True]) @pytest.mark.parametrize("stop", [False, True]) @pytest.mark.parametrize("managed", [True, False]) -async def test_managed_read_errors_sanitize_diagnostics_without_rewriting_stop_errors( +async def test_managed_errors_sanitize_diagnostics_without_rewriting_stop_errors( stage: str, streaming: bool, bound_error: bool, stop: bool, managed: bool ) -> None: provider = Provider() @@ -826,6 +829,8 @@ def handle(request: httpx.Request) -> httpx.Response: f"Read failed for {request.url}: {request.headers}", request=request if bound_error else None ) errors.append(error) + if stage == "send": + raise error body = Body(error=error) bodies.append(body) return httpx.Response(200, stream=body) @@ -846,7 +851,7 @@ async def adapt(response: httpx.Response, request: httpx.Request) -> httpx.Respo await perform(transport, streaming, RequestSpec("GET", "/value", security=bindings if managed else None)) error = failure.value assert len(sent) == 1 - assert bodies[0].closes == 1 + assert [body.closes for body in bodies] == ([] if stage == "send" else [1]) if managed and not stop: assert type(error) is httpx.ReadError assert error is not errors[0] diff --git a/tests/test_tokens.py b/tests/test_tokens.py index ac6d659..4110c74 100644 --- a/tests/test_tokens.py +++ b/tests/test_tokens.py @@ -4,6 +4,8 @@ # you may not use this file except in compliance with the License. import asyncio +from collections.abc import Iterator +from contextlib import contextmanager from dataclasses import replace from typing import Literal, cast @@ -435,3 +437,72 @@ async def remove(self, _key: str) -> None: finally: finish.set() loop.set_exception_handler(previous) + + +@contextmanager +def _task_factory(eager: bool) -> Iterator[None]: + loop = asyncio.get_running_loop() + previous = loop.get_task_factory() + loop.set_task_factory(asyncio.eager_task_factory if eager else None) + try: + yield + finally: + loop.set_task_factory(previous) + + +@pytest.mark.anyio +@pytest.mark.parametrize("eager", [False, True], ids=["deferred", "eager"]) +@pytest.mark.parametrize("refresh", [False, True], ids=["acquire", "refresh"]) +async def test_immediate_renewal_is_registered_before_persistence(eager: bool, refresh: bool) -> None: + provider = Provider() + now = 0.0 + manager = TokenManager(provider, now=lambda: now) + if refresh: + await manager.credentials(BINDING) + now = 71 + provider.tokens = TokenSet("second", 200, "refresh-second") + with _task_factory(eager): + first, second = await asyncio.gather(manager.credentials(BINDING), manager.credentials(BINDING)) + assert first.tokens == second.tokens == provider.tokens + assert (await manager.credentials(BINDING)).tokens == provider.tokens + assert len(provider.acquisitions) == 1 + assert provider.refreshes == (["refresh-first"] if refresh else []) + + +@pytest.mark.anyio +@pytest.mark.parametrize("eager", [False, True], ids=["deferred", "eager"]) +@pytest.mark.parametrize("refresh", [False, True], ids=["acquire", "refresh"]) +@pytest.mark.parametrize("native", [False, True], ids=["stop", "cancelled"]) +async def test_immediate_renewal_cancellation_preserves_identity(eager: bool, refresh: bool, native: bool) -> None: + error = asyncio.CancelledError("cancel renewal") if native else RequestCancellationError("stop renewal") + + class StoppingProvider(Provider): + failure: BaseException | None = None + + async def acquire(self, request: TokenRequest) -> TokenSet: + if self.failure is not None: + raise self.failure + return await super().acquire(request) + + async def refresh(self, request: TokenRequest, refresh_token: str) -> TokenSet: + if self.failure is not None: + raise self.failure + return await super().refresh(request, refresh_token) + + provider = StoppingProvider() + now = 0.0 + manager = TokenManager(provider, now=lambda: now) + if refresh: + await manager.credentials(BINDING) + now = 71 + provider.failure = error + with _task_factory(eager): + with pytest.raises(type(error)) as failure: + await manager.credentials(BINDING) + assert failure.value is error + # A failed renewal must not poison the next acquisition or refresh. + provider.failure = None + provider.tokens = TokenSet("recovered", 200) + assert (await manager.credentials(BINDING)).tokens.access_token == "recovered" + assert len(provider.acquisitions) == 1 + assert provider.refreshes == (["refresh-first"] if refresh else []) From 2bfe2266617a60d74cc03ea86fe3726004005ca6 Mon Sep 17 00:00:00 2001 From: Kevin Wooten Date: Mon, 9 Nov 2026 09:44:00 -0800 Subject: [PATCH 6/6] Fix eager EventSource shutdown and managed error diagnostics --- docs/adapter-lifecycle-audit.md | 16 +-- src/sunday/httpx/_security.py | 9 +- src/sunday/httpx/_sse.py | 18 ++-- src/sunday/httpx/_transport.py | 9 +- tests/test_httpx_adapters.py | 173 ++++++++++++++++++++++++++++++-- tests/test_httpx_cleanup.py | 93 +++++++++++++++++ 6 files changed, 294 insertions(+), 24 deletions(-) diff --git a/docs/adapter-lifecycle-audit.md b/docs/adapter-lifecycle-audit.md index f604d5a..9085a43 100644 --- a/docs/adapter-lifecycle-audit.md +++ b/docs/adapter-lifecycle-audit.md @@ -57,11 +57,13 @@ I/O block has a completion event paired with its cancel scope. External close ca block before response cleanup, even when no response has yet been handed to the stream. I/O ownership is cleared before yielding events, so close never joins application work between events. Callbacks within the same I/O ownership chain only request closure to avoid waiting on themselves. -Each I/O record identifies its initiating task, so transport shutdown can recognize an owned -EventSource callback even inside a native child task or a retiring run. Shutdown signals source -closure immediately; reentrant callers do not join their own run, while external callers still -join the shared cleanup. The transport owns one shutdown task. EventSource retirement uses `asyncio.wait()` to join source tasks without -confusing independently cancelled sources with cancellation of the shutdown caller. There is no +Each EventSource retains its active and retiring streams. Stream close and transport shutdown +use the same stream ownership check for active I/O and response cleanup, including native child +tasks. A startup checkpoint registers each run before callbacks can execute under an eager task +factory. Shutdown signals source closure immediately; reentrant callers do not join their own +run, while external callers still join the shared cleanup. The transport owns one shutdown task. +EventSource retirement uses `asyncio.wait()` to join source tasks without confusing independently +cancelled sources with cancellation of the shutdown caller. There is no new public adapter API, request-attached state, retry policy, custom dispatcher or HTTP stack. Bulk response collection uses one native I/O owner task for the complete `aread()`. A task-local @@ -85,7 +87,9 @@ actual task, so child tasks inheriting context do not incorrectly bypass protect | EventSource shutdown and immediate reconnect | Run-local streams; native task join includes retiring runs | TCP reconnect and retirement tests | | Transport shutdown | Shared completion, owned client closed only after sources finish; active owned callbacks request shutdown without self-joining | TCP owned/borrowed client, concurrent shutdown, independently cancelled source, scope/raw cancellation, request/response adapter and native-hook reentrancy, retiring runs, stop and external cancellation identity | | Transport context cleanup fails during an existing error | Cleanup adds a note; original object propagates | Stop, CancelledError and ordinary-error identity tests | -| Token acquisition and persistence | Waiter counting remains separate from the shared renewal task | Coalescing, last-waiter cancellation, persistence-after-cancellation and duplicate-report tests | +| Token acquisition and persistence | Waiter counting remains separate from the shared renewal task | Eager/deferred acquisition and refresh, coalescing, last-waiter cancellation, persistence-after-cancellation and duplicate-report tests | +| EventSource startup | Run registration precedes callbacks under eager and deferred task factories | TCP peer cleanup, reentrant startup shutdown, external close waiting, and stop/native cancellation identity | +| Managed diagnostic errors | One policy redacts HTTPX request and status errors; stop signals retain identity | Request adapters, native sends/hooks, response adapters and collection; buffered/streaming execution, credential redaction, status/body/metadata preservation, and cancellation/unmanaged identity | The TCP cancellation cases use HTTPX's documented trace extension to hold an actual httpcore cleanup operation open. They then cancel again and verify completion, original error identity or diff --git a/src/sunday/httpx/_security.py b/src/sunday/httpx/_security.py index 2bbbe96..d3ae18a 100644 --- a/src/sunday/httpx/_security.py +++ b/src/sunday/httpx/_security.py @@ -89,7 +89,14 @@ def rejected_leases(self, request: httpx.Request, response: httpx.Response) -> t def diagnostic_error(self, error: BaseException, request: httpx.Request) -> BaseException: """Sanitize managed HTTPX failures while preserving cancellation identity.""" - if self.bindings and isinstance(error, httpx.RequestError) and not isinstance(error, RequestCancellationError): + if not self.bindings or isinstance(error, RequestCancellationError): + return error + if isinstance(error, httpx.HTTPStatusError): + diagnostic = self.diagnostic_request(request) + # Preserve the response and its body/metadata, just as on successful execution. + error.response.request = diagnostic + return type(error)("HTTP request failed", request=diagnostic, response=error.response) + if isinstance(error, httpx.RequestError): return type(error)("HTTP request failed", request=self.diagnostic_request(request)) return error diff --git a/src/sunday/httpx/_sse.py b/src/sunday/httpx/_sse.py index cd1161f..89eb03b 100644 --- a/src/sunday/httpx/_sse.py +++ b/src/sunday/httpx/_sse.py @@ -13,7 +13,7 @@ from contextvars import ContextVar from dataclasses import dataclass, field from types import TracebackType -from typing import TYPE_CHECKING, Any +from typing import TYPE_CHECKING from uuid import UUID, uuid4 import anyio @@ -46,7 +46,6 @@ class _IO: """Completion of an I/O block, independent of the consumer's lifetime.""" scope: anyio.CancelScope - task: asyncio.Task[Any] | None = field(default_factory=asyncio.current_task) done: anyio.Event = field(default_factory=anyio.Event) def __init__( @@ -113,9 +112,7 @@ async def _close(self, error: BaseException | None = None) -> None: active = self._active_io # Callbacks cannot join the I/O or cleanup waiting for them to return. # Keep the response reference so external callers still join its cleanup. - if (active is not None and any(owner is active for owner in _io_owners.get())) or ( - self._response is not None and in_response_cleanup(self._response) - ): + if self._owns_current_work(): return try: if active is None: @@ -127,6 +124,11 @@ async def _close(self, error: BaseException | None = None) -> None: raise error.add_note("Closing the HTTP response also failed") + def _owns_current_work(self) -> bool: + return (self._active_io is not None and any(owner is self._active_io for owner in _io_owners.get())) or ( + self._response is not None and in_response_cleanup(self._response) + ) + async def _finish_close(self, active: _IO) -> None: await active.done.wait() await self._release_response() @@ -409,9 +411,7 @@ def close(self) -> None: def _owns_current_work(self) -> bool: # Cleanup can outlive the I/O block. Retain each run's stream so callbacks # from retiring runs are recognized as well as the current run's callbacks. - return any(owner.task in self._tasks and not owner.done.is_set() for owner in _io_owners.get()) or any( - stream._response is not None and in_response_cleanup(stream._response) for stream in self._tasks.values() - ) + return any(stream._owns_current_work() for stream in self._tasks.values()) async def _wait_closed(self) -> None: if self._tasks: @@ -419,6 +419,8 @@ async def _wait_closed(self) -> None: async def _run(self, stream: HttpxEventStream[ServerSentEvent]) -> None: try: + # Register the run before callbacks can request shutdown, even with an eager task factory. + await asyncio.sleep(0) if not stream._closed: async with stream: async for event in stream: diff --git a/src/sunday/httpx/_transport.py b/src/sunday/httpx/_transport.py index 3f70875..2b6c2d5 100644 --- a/src/sunday/httpx/_transport.py +++ b/src/sunday/httpx/_transport.py @@ -330,7 +330,14 @@ async def _execute( while True: sent = copy_request(prepared) authorized = await security.authorize(sent, self.token_providers) if security is not None else None - sent = await self._request_adapter.adapt(sent) + try: + sent = await self._request_adapter.adapt(sent) + except BaseException as error: + if authorized is not None: + diagnostic_error = authorized.diagnostic_error(error, sent) + if diagnostic_error is not error: + raise diagnostic_error from None + raise response = await self._send_httpx(sent, security=authorized) effective = sent try: diff --git a/tests/test_httpx_adapters.py b/tests/test_httpx_adapters.py index 5bf477a..ae2a82d 100644 --- a/tests/test_httpx_adapters.py +++ b/tests/test_httpx_adapters.py @@ -805,7 +805,15 @@ def handle(request: httpx.Request) -> httpx.Response: @pytest.mark.parametrize( ("stage", "streaming"), - [("send", False), ("send", True), ("adapter", False), ("adapter", True), ("collection", False)], + [ + ("request", False), + ("request", True), + ("send", False), + ("send", True), + ("adapter", False), + ("adapter", True), + ("collection", False), + ], ) @pytest.mark.parametrize("bound_error", [False, True]) @pytest.mark.parametrize("stop", [False, True]) @@ -820,15 +828,26 @@ async def test_managed_errors_sanitize_diagnostics_without_rewriting_stop_errors replace(BINDING, scheme="cookie", transport=SecurityTransport(location="cookie", name="session")), ) sent: list[httpx.Request] = [] + failed_requests: list[httpx.Request] = [] errors: list[httpx.ReadError] = [] bodies: list[Body] = [] - def handle(request: httpx.Request) -> httpx.Response: - sent.append(request) + def make_error(request: httpx.Request) -> httpx.ReadError: + failed_requests.append(request) error = (Stop if stop else httpx.ReadError)( f"Read failed for {request.url}: {request.headers}", request=request if bound_error else None ) errors.append(error) + return error + + async def adapt_request(request: httpx.Request) -> httpx.Request: + if stage == "request": + raise make_error(request) + return request + + def handle(request: httpx.Request) -> httpx.Response: + sent.append(request) + error = make_error(request) if stage == "send": raise error body = Body(error=error) @@ -846,12 +865,14 @@ async def adapt(response: httpx.Response, request: httpx.Request) -> httpx.Respo return response async with httpx.AsyncClient(base_url="https://api.example", transport=httpx.MockTransport(handle)) as client: - transport = HttpxTransport(client, response_adapter=adapt, token_providers={"identity": provider}) + transport = HttpxTransport( + client, request_adapter=adapt_request, response_adapter=adapt, token_providers={"identity": provider} + ) with pytest.raises(httpx.ReadError) as failure: await perform(transport, streaming, RequestSpec("GET", "/value", security=bindings if managed else None)) error = failure.value - assert len(sent) == 1 - assert [body.closes for body in bodies] == ([] if stage == "send" else [1]) + assert len(sent) == (0 if stage == "request" else 1) + assert [body.closes for body in bodies] == ([] if stage in {"request", "send"} else [1]) if managed and not stop: assert type(error) is httpx.ReadError assert error is not errors[0] @@ -862,8 +883,144 @@ async def adapt(response: httpx.Response, request: httpx.Request) -> httpx.Respo assert "token-" not in str(error.request.url) assert "token-" not in str(error.request.headers) assert error.__cause__ is None and error.__suppress_context__ + assert failed_requests[0].headers["authorization"] == "Bearer token-1" + assert failed_requests[0].url.params["api_key"] == "token-2" + assert failed_requests[0].headers["cookie"] == "session=token-3" + else: + assert error is errors[0] + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("stage", ["request", "hook", "response"]) +async def test_managed_adapter_and_hook_task_cancellation_keeps_identity(streaming: bool, stage: str) -> None: + cancellation = asyncio.CancelledError("original adapter cancellation") + body = Body() + sends = 0 + + async def adapt_request(request: httpx.Request) -> httpx.Request: + if stage == "request": + raise cancellation + return request + + async def hook(response: httpx.Response) -> None: + if stage == "hook": + raise cancellation + + async def adapt_response(response: httpx.Response, request: httpx.Request) -> httpx.Response: + raise cancellation + + def handle(request: httpx.Request) -> httpx.Response: + nonlocal sends + sends += 1 + return httpx.Response(200, stream=body) + + async with httpx.AsyncClient( + base_url="https://api.example", transport=httpx.MockTransport(handle), event_hooks={"response": [hook]} + ) as client: + transport = HttpxTransport( + client, + request_adapter=adapt_request, + response_adapter=adapt_response, + token_providers={"identity": Provider()}, + ) + with pytest.raises(asyncio.CancelledError) as failure: + await perform(transport, streaming, RequestSpec("GET", "/value", security=(BINDING,))) + assert failure.value is cancellation + assert sends == body.closes == (0 if stage == "request" else 1) + + +@pytest.mark.parametrize("streaming", [False, True]) +@pytest.mark.parametrize("stage", ["hook", "adapter"]) +@pytest.mark.parametrize("buffered", [False, True]) +@pytest.mark.parametrize("stop", [False, True]) +@pytest.mark.parametrize("managed", [False, True]) +async def test_managed_status_errors_preserve_response_and_cancellation_identity( + streaming: bool, stage: str, buffered: bool, stop: bool, managed: bool +) -> None: + class StatusStop(httpx.HTTPStatusError, RequestCancellationError): + pass + + bindings = ( + BINDING, + replace(BINDING, scheme="query", transport=SecurityTransport(location="query", name="api_key")), + replace(BINDING, scheme="cookie", transport=SecurityTransport(location="cookie", name="session")), + ) + body = Body(b"original body") + sent: list[httpx.Request] = [] + responses: list[httpx.Response] = [] + originals: list[httpx.HTTPStatusError] = [] + observed: list[BaseException] = [] + + class Observer: + def observe(self, event: TransportEvent) -> None: + if event.kind is TransportEventKind.FAILURE: + assert event.error is not None + observed.append(event.error) + + async def fail(response: httpx.Response) -> None: + if buffered: + await response.aread() + try: + response.raise_for_status() + except httpx.HTTPStatusError as error: + if stop: + error = StatusStop(str(error), request=error.request, response=error.response) + originals.append(error) + raise error + + async def hook(response: httpx.Response) -> None: + if stage == "hook": + await fail(response) + + async def adapt(response: httpx.Response, request: httpx.Request) -> httpx.Response: + await fail(response) + return response + + def handle(request: httpx.Request) -> httpx.Response: + sent.append(request) + response = httpx.Response( + 403, headers={"X-Detail": "preserved"}, stream=body, extensions={"http_version": b"HTTP/1.1"} + ) + responses.append(response) + return response + + async with httpx.AsyncClient( + base_url="https://api.example", transport=httpx.MockTransport(handle), event_hooks={"response": [hook]} + ) as client: + transport = HttpxTransport( + client, response_adapter=adapt, token_providers={"identity": Provider()}, observers=(Observer(),) + ) + with pytest.raises(httpx.HTTPStatusError) as failure: + await perform(transport, streaming, RequestSpec("GET", "/value", security=bindings if managed else None)) + error = failure.value + assert len(sent) == len(originals) == body.closes == 1 + assert error.response is responses[0] + assert error.response.status_code == 403 + assert error.response.headers["x-detail"] == "preserved" + assert error.response.http_version == "HTTP/1.1" + assert error.response.is_closed + if buffered: + assert error.response.content == b"original body" + else: + assert body.reads == 0 + assert len(observed) == (1 if stage == "hook" else 0) + if managed and not stop: + for diagnostic in [error, *observed]: + assert type(diagnostic) is httpx.HTTPStatusError + assert str(diagnostic) == "HTTP request failed" + assert diagnostic.request.headers["authorization"] == "[redacted]" + assert diagnostic.request.url.params["api_key"] == "[redacted]" + assert diagnostic.request.headers["cookie"] == "[redacted]" + assert diagnostic.response.request is diagnostic.request + assert error is not originals[0] + assert error.__cause__ is None and error.__suppress_context__ + else: + assert error is originals[0] + assert all(item is error for item in observed) + if managed: assert sent[0].headers["authorization"] == "Bearer token-1" assert sent[0].url.params["api_key"] == "token-2" assert sent[0].headers["cookie"] == "session=token-3" - else: - assert error is errors[0] + if stop: + assert error.request is sent[0] + assert error.response.request is sent[0] diff --git a/tests/test_httpx_cleanup.py b/tests/test_httpx_cleanup.py index 8661fed..5d63edd 100644 --- a/tests/test_httpx_cleanup.py +++ b/tests/test_httpx_cleanup.py @@ -1715,3 +1715,96 @@ def message(event: Any) -> None: release.set() await asyncio.gather(*closers, return_exceptions=True) await transport.aclose() + + +@pytest.mark.parametrize("eager", [False, True], ids=["deferred", "eager"]) +@pytest.mark.parametrize("owned", [False, True]) +@pytest.mark.parametrize("failure_kind", ["none", "stop", "cancelled"]) +async def test_event_source_startup_shutdown_waits_for_registered_run( + server: Server, eager: bool, owned: bool, failure_kind: str +) -> None: + opened, entered, release = (anyio.Event() for _ in range(3)) + original = ( + Stop("original startup stop") + if failure_kind == "stop" + else asyncio.CancelledError("original startup cancellation") + if failure_kind == "cancelled" + else None + ) + errors: list[BaseException | None] = [] + cancellations: list[asyncio.CancelledError] = [] + + async def adapt(request: httpx.Request) -> httpx.Request: + if request.url.path == "/shutdown": + with anyio.CancelScope(shield=True): + # No suspension before shutdown: eager startup must already be registered. + await transport.aclose() + entered.set() + await release.wait() + if original is not None: + raise original + return request + + async def close_externally() -> None: + try: + await transport.aclose() + except asyncio.CancelledError as error: + cancellations.append(error) + raise + + async with httpx.AsyncClient(base_url=server.url, trust_env=False) as client: + transport = HttpxTransport( + None if owned else client, base_url=server.url if owned else None, request_adapter=adapt + ) + peer = transport.event_source(RequestSpec("GET", "/events")) + peer.on_message = lambda event: opened.set() + peer.connect() + source = transport.event_source(RequestSpec("GET", "/shutdown")) + source.on_error = errors.append + loop = asyncio.get_running_loop() + previous = loop.get_task_factory() + closers: list[asyncio.Task[None]] = [] + try: + with anyio.fail_after(3): + await opened.wait() + loop.set_task_factory(asyncio.eager_task_factory if eager else None) + source.connect() + (run,) = source._tasks + await entered.wait() + await peer._wait_closed() + await server.disconnected.wait() + closers = [asyncio.create_task(close_externally()), asyncio.create_task(transport.aclose())] + done, _ = await asyncio.wait(closers, timeout=0.02) + assert not done + assert not run.done() + assert source in transport._event_sources + assert not transport.client.is_closed + closers[0].cancel("first shutdown cancellation") + await anyio.sleep(0) + closers[0].cancel("later shutdown cancellation") + await anyio.sleep(0) + assert all(not task.done() for task in closers) + release.set() + with pytest.raises(asyncio.CancelledError) as failure: + await closers[0] + assert failure.value is cancellations[0] + assert failure.value.args == ("first shutdown cancellation",) + await closers[1] + assert run.done() + if failure_kind == "cancelled": + with pytest.raises(asyncio.CancelledError) as failure: + run.result() + assert failure.value is original + else: + run.result() + assert errors == ([original] if failure_kind == "stop" else []) + assert not source._tasks and not peer._tasks + assert transport.client.is_closed is owned + if not owned: + assert (await client.get("/after")).status_code == 204 + finally: + loop.set_task_factory(previous) + release.set() + await asyncio.gather(*closers, return_exceptions=True) + await source._wait_closed() + await transport.aclose()