Skip to content

armgit / E2B

Public Imported from GitHub
0

Open-source, secure environment with real-world tools for enterprise-grade agents.

28.0 KB
Raw Blame
import httpx
import pytest

from e2b.retry import (
    AsyncRetryableTransport,
    RetryableTransport,
    parse_retry_after,
)


class FakeTransport(httpx.BaseTransport):
    def __init__(self, outcomes, retry_after="0", should_retry="false"):
        self.outcomes = iter(outcomes)
        self.retry_after = retry_after
        self.should_retry = should_retry
        self.requests = []
        self.responses = []
        self.closed = False

    def handle_request(self, request):
        self.requests.append(request)
        outcome = next(self.outcomes)
        if isinstance(outcome, Exception):
            raise outcome
        headers = {}
        if outcome >= 400 and self.should_retry is not None:
            headers["Should-Retry"] = self.should_retry
        if outcome >= 400 and self.retry_after is not None:
            headers["Retry-After"] = self.retry_after
        response = httpx.Response(
            outcome,
            headers=headers,
            content=b"response",
            request=request,
        )
        self.responses.append(response)
        return response

    def close(self):
        self.closed = True


class FakeAsyncTransport(httpx.AsyncBaseTransport):
    def __init__(self, outcomes, retry_after="0", should_retry="false"):
        self.outcomes = iter(outcomes)
        self.retry_after = retry_after
        self.should_retry = should_retry
        self.requests = []
        self.responses = []
        self.closed = False

    async def handle_async_request(self, request):
        self.requests.append(request)
        outcome = next(self.outcomes)
        if isinstance(outcome, Exception):
            raise outcome
        headers = {}
        if outcome >= 400 and self.should_retry is not None:
            headers["Should-Retry"] = self.should_retry
        if outcome >= 400 and self.retry_after is not None:
            headers["Retry-After"] = self.retry_after
        response = httpx.Response(
            outcome,
            headers=headers,
            content=b"response",
            request=request,
        )
        self.responses.append(response)
        return response

    async def aclose(self):
        self.closed = True


class FakeClock:
    def __init__(self):
        self.now = 0.0
        self.sleeps = []

    def monotonic(self):
        return self.now

    def sleep(self, delay):
        self.sleeps.append(delay)
        self.now += delay


def test_retries_rate_limit_after_server_delay_and_replays_body():
    inner = FakeTransport([429, 200], retry_after="2", should_retry="true")
    sleeps = []
    request = httpx.Request("POST", "https://api.test", content=b"payload")

    response = RetryableTransport(inner, retries=3, sleep=sleeps.append).handle_request(
        request
    )

    assert response.status_code == 200
    assert sleeps == [2]
    assert [item.content for item in inner.requests] == [b"payload", b"payload"]
    assert inner.responses[0].is_closed


def test_exhaustion_returns_final_rate_limit_response():
    inner = FakeTransport([429, 429, 429], should_retry="true")

    response = RetryableTransport(
        inner, retries=2, sleep=lambda _: None
    ).handle_request(httpx.Request("GET", "https://api.test"))

    assert response is inner.responses[-1]
    assert len(inner.requests) == 3
    assert all(item.is_closed for item in inner.responses[:-1])
    assert response.content == b"response"


@pytest.mark.parametrize("retry_after", ["soon", "-1", "+1", "1.5"])
def test_invalid_retry_after_falls_back_to_backoff(retry_after):
    inner = FakeTransport([503, 200], retry_after=retry_after, should_retry="true")
    sleeps = []

    response = RetryableTransport(
        inner, retries=3, sleep=sleeps.append, random_=lambda: 0.0
    ).handle_request(httpx.Request("GET", "https://api.test"))

    assert response.status_code == 200
    assert len(inner.requests) == 2
    assert sleeps == pytest.approx([0.05])


def test_429_without_header_or_retry_after_uses_backoff():
    inner = FakeTransport([429, 200], retry_after=None, should_retry=None)
    sleeps = []

    response = RetryableTransport(
        inner, retries=3, sleep=sleeps.append, random_=lambda: 0.0
    ).handle_request(httpx.Request("GET", "https://api.test"))

    assert response.status_code == 200
    assert len(inner.requests) == 2
    assert sleeps == pytest.approx([0.05])


def test_retry_after_exceeding_timeout_is_propagated_as_is():
    inner = FakeTransport([429], retry_after="4", should_retry="true")
    sleeps = []
    request = httpx.Request(
        "GET",
        "https://api.test",
        extensions={"timeout": {"connect": 3.0, "read": 3.0}},
    )

    response = RetryableTransport(
        inner, retries=3, sleep=sleeps.append, monotonic=lambda: 0.0
    ).handle_request(request)

    assert response is inner.responses[0]
    assert len(inner.requests) == 1
    assert sleeps == []


def test_retry_wait_is_bounded_when_request_timeout_is_disabled():
    inner = FakeTransport([429], retry_after="60", should_retry="true")
    sleeps = []
    request = httpx.Request(
        "GET",
        "https://api.test",
        extensions={
            "timeout": {"connect": None, "read": None, "write": None, "pool": None}
        },
    )

    response = RetryableTransport(
        inner, retries=3, sleep=sleeps.append, monotonic=lambda: 0.0
    ).handle_request(request)

    assert response is inner.responses[0]
    assert len(inner.requests) == 1
    assert sleeps == []


@pytest.mark.parametrize("status", [429, 502, 503, 504])
def test_retries_retryable_status_when_header_is_absent(status):
    inner = FakeTransport([status, 200], retry_after="0", should_retry=None)
    sleeps = []

    response = RetryableTransport(
        inner, retries=1, sleep=sleeps.append, monotonic=lambda: 0.0
    ).handle_request(httpx.Request("GET", "https://api.test"))

    assert response.status_code == 200
    assert len(inner.requests) == 2
    assert sleeps == [0]


def test_absent_header_429_uses_retry_after():
    inner = FakeTransport([429, 200], retry_after="2", should_retry=None)
    sleeps = []

    response = RetryableTransport(
        inner, retries=1, sleep=sleeps.append, monotonic=lambda: 0.0
    ).handle_request(httpx.Request("GET", "https://api.test"))

    assert response.status_code == 200
    assert len(inner.requests) == 2
    assert sleeps == [2]


@pytest.mark.parametrize(
    ("status", "should_retry"),
    [
        (503, "false"),
        (503, "maybe"),
        (503, ""),
        (500, None),
    ],
)
def test_does_not_retry_explicit_denial_or_non_fallback_status(status, should_retry):
    inner = FakeTransport([status], retry_after="0", should_retry=should_retry)

    response = RetryableTransport(inner, retries=3).handle_request(
        httpx.Request("GET", "https://api.test")
    )

    assert response is inner.responses[0]
    assert len(inner.requests) == 1


@pytest.mark.parametrize("status", [502, 503])
def test_retries_unavailable_status_with_exponential_backoff_and_jitter(status):
    inner = FakeTransport(
        [status, status, status, 200], retry_after=None, should_retry="true"
    )
    sleeps = []
    randoms = iter([0.0, 1.0, 0.5])
    request = httpx.Request(
        "POST", "https://api.test/sandboxes/sbx-1/pause", content=b"payload"
    )

    response = RetryableTransport(
        inner,
        retries=3,
        sleep=sleeps.append,
        monotonic=lambda: 0.0,
        random_=lambda: next(randoms),
    ).handle_request(request)

    assert response.status_code == 200
    assert sleeps == pytest.approx([0.05, 0.2, 0.3])
    assert [item.content for item in inner.requests] == [b"payload"] * 4
    assert all(item.is_closed for item in inner.responses[:-1])


def test_retries_post_500_when_marked_by_server():
    inner = FakeTransport([500, 200], retry_after=None, should_retry="true")

    response = RetryableTransport(
        inner, retries=3, sleep=lambda _: None, monotonic=lambda: 0.0
    ).handle_request(
        httpx.Request("POST", "https://api.test/v2/sandboxes", content=b"p")
    )

    assert response.status_code == 200
    assert len(inner.requests) == 2


def test_retries_post_503_when_marked_by_server():
    inner = FakeTransport([503, 200], retry_after=None, should_retry="true")

    response = RetryableTransport(
        inner, retries=3, sleep=lambda _: None, monotonic=lambda: 0.0
    ).handle_request(
        httpx.Request("POST", "https://api.test/v2/sandboxes", content=b"p")
    )

    assert response.status_code == 200
    assert len(inner.requests) == 2


def test_retries_post_502_without_should_retry_header():
    inner = FakeTransport([502, 200], retry_after="0", should_retry=None)

    response = RetryableTransport(
        inner, retries=1, sleep=lambda _: None, monotonic=lambda: 0.0
    ).handle_request(
        httpx.Request("POST", "https://api.test/v2/sandboxes", content=b"payload")
    )

    assert response.status_code == 200
    assert len(inner.requests) == 2


@pytest.mark.parametrize("should_retry", ["TRUE", " true "])
def test_should_retry_header_is_case_and_whitespace_insensitive(should_retry):
    inner = FakeTransport([503, 200], should_retry=should_retry)

    response = RetryableTransport(
        inner, retries=1, sleep=lambda _: None, monotonic=lambda: 0.0
    ).handle_request(httpx.Request("GET", "https://api.test"))

    assert response.status_code == 200
    assert len(inner.requests) == 2


def test_backoff_is_capped_for_long_retry_sequences():
    inner = FakeTransport([503] * 9, retry_after=None, should_retry="true")
    sleeps = []
    request = httpx.Request(
        "GET",
        "https://api.test",
        extensions={"timeout": {"connect": None, "read": None}},
    )

    RetryableTransport(
        inner,
        retries=8,
        sleep=sleeps.append,
        monotonic=lambda: 0.0,
        random_=lambda: 1.0,
    ).handle_request(request)

    assert sleeps == pytest.approx([0.1, 0.2, 0.4, 0.8, 1.6, 3.2, 6.4, 10.0])


def test_unavailable_status_prefers_retry_after_over_backoff():
    inner = FakeTransport([503, 200], retry_after="3", should_retry="true")
    sleeps = []

    def random_():
        raise AssertionError("backoff should not be used")

    response = RetryableTransport(
        inner, retries=3, sleep=sleeps.append, random_=random_
    ).handle_request(httpx.Request("GET", "https://api.test"))

    assert response.status_code == 200
    assert sleeps == [3]


def test_unavailable_status_exhaustion_returns_final_response():
    inner = FakeTransport([503, 503, 503], retry_after=None, should_retry="true")

    response = RetryableTransport(
        inner, retries=2, sleep=lambda _: None, random_=lambda: 0.0
    ).handle_request(httpx.Request("GET", "https://api.test"))

    assert response is inner.responses[-1]
    assert len(inner.requests) == 3
    assert response.content == b"response"


def test_backoff_exceeding_timeout_is_propagated_as_is():
    inner = FakeTransport([502], retry_after=None, should_retry="true")
    sleeps = []
    request = httpx.Request(
        "GET",
        "https://api.test",
        extensions={"timeout": {"connect": 0.08, "read": 0.08}},
    )

    response = RetryableTransport(
        inner,
        retries=3,
        sleep=sleeps.append,
        monotonic=lambda: 0.0,
        random_=lambda: 1.0,
    ).handle_request(request)

    assert response is inner.responses[0]
    assert sleeps == []


def test_does_not_retry_when_cumulative_wait_reaches_request_timeout():
    inner = FakeTransport([429, 429], retry_after="2", should_retry="true")
    clock = FakeClock()
    request = httpx.Request(
        "GET",
        "https://api.test",
        extensions={
            "timeout": {"connect": 3.0, "read": 3.0, "write": 3.0, "pool": 3.0}
        },
    )

    response = RetryableTransport(
        inner,
        retries=3,
        sleep=clock.sleep,
        monotonic=clock.monotonic,
    ).handle_request(request)

    assert response.status_code == 429
    assert clock.sleeps == [2]
    assert len(inner.requests) == 2


def test_timeout_after_retry_wait_names_configuration_options():
    inner = FakeTransport([429], should_retry="true")
    clock = FakeClock()

    def sleep(delay):
        clock.sleeps.append(delay)
        clock.now = 4.0

    request = httpx.Request(
        "GET",
        "https://api.test",
        extensions={"timeout": {"read": 3.0}},
    )

    with pytest.raises(httpx.TimeoutException, match=r"request_timeout.*retries"):
        RetryableTransport(
            inner,
            retries=1,
            sleep=sleep,
            monotonic=clock.monotonic,
        ).handle_request(request)


def test_retry_uses_only_the_remaining_request_timeout():
    clock = FakeClock()

    class AdvancingTransport(FakeTransport):
        def handle_request(self, request):
            response = super().handle_request(request)
            if len(self.requests) == 1:
                clock.now = 2.0
            return response

    inner = AdvancingTransport([429, 200], should_retry="true")
    request = httpx.Request(
        "GET",
        "https://api.test",
        extensions={"timeout": {"connect": 3.0, "read": 3.0}},
    )

    response = RetryableTransport(
        inner, retries=1, sleep=clock.sleep, monotonic=clock.monotonic
    ).handle_request(request)

    assert response.status_code == 200
    assert inner.requests[1].extensions["timeout"] == {
        "connect": 1.0,
        "read": 1.0,
    }


def test_retry_preserves_remaining_budget_for_each_timeout_phase():
    clock = FakeClock()

    class AdvancingTransport(FakeTransport):
        def handle_request(self, request):
            response = super().handle_request(request)
            if len(self.requests) == 1:
                clock.now = 2.0
            return response

    inner = AdvancingTransport([429, 200], should_retry="true")
    request = httpx.Request(
        "GET",
        "https://api.test",
        extensions={
            "timeout": {"connect": 3.0, "read": 3.0, "write": 3.0, "pool": 3.0}
        },
    )

    RetryableTransport(
        inner, retries=1, sleep=clock.sleep, monotonic=clock.monotonic
    ).handle_request(request)

    assert inner.requests[1].extensions["timeout"] == {
        "connect": 1.0,
        "read": 1.0,
        "write": 1.0,
        "pool": 1.0,
    }


def test_zero_retries_passes_the_original_request_through():
    inner = FakeTransport([429], retry_after="0")
    request = httpx.Request("GET", "https://api.test")

    response = RetryableTransport(inner, retries=0).handle_request(request)

    assert response.status_code == 429
    assert inner.requests == [request]


def test_does_not_buffer_or_retry_streamed_body():
    class Stream(httpx.SyncByteStream):
        def __iter__(self):
            yield b"payload"

    inner = FakeTransport([429], should_retry="true")
    request = httpx.Request("POST", "https://api.test", content=Stream())

    response = RetryableTransport(inner, retries=3).handle_request(request)

    assert response.status_code == 429
    assert inner.requests == [request]


def test_close_leaves_cached_transport_open():
    inner = FakeTransport([])

    RetryableTransport(inner, retries=1).close()

    assert not inner.closed


@pytest.mark.parametrize(
    "error",
    [
        httpx.ConnectError("refused"),
        httpx.ConnectTimeout("timed out"),
        httpx.ReadTimeout("timed out"),
        httpx.LocalProtocolError("bad request"),
    ],
)
def test_leaves_connect_errors_and_timeouts_to_the_layers_around(error):
    inner = FakeTransport([error, 200])

    with pytest.raises(type(error)):
        RetryableTransport(inner, retries=3, sleep=lambda _: None).handle_request(
            httpx.Request("GET", "https://api.test/sandboxes")
        )

    assert len(inner.requests) == 1


@pytest.mark.asyncio
async def test_async_retries_rate_limit_and_replays_body():
    inner = FakeAsyncTransport([429, 200], retry_after="2", should_retry="true")
    sleeps = []

    async def sleep(delay):
        sleeps.append(delay)

    response = await AsyncRetryableTransport(
        inner, retries=3, sleep=sleep
    ).handle_async_request(
        httpx.Request("POST", "https://api.test", content=b"payload")
    )

    assert response.status_code == 200
    assert sleeps == [2]
    assert [item.content for item in inner.requests] == [b"payload", b"payload"]
    assert inner.responses[0].is_closed


@pytest.mark.asyncio
async def test_async_429_without_header_or_retry_after_uses_backoff():
    inner = FakeAsyncTransport([429, 200], retry_after=None, should_retry=None)
    sleeps = []

    async def sleep(delay):
        sleeps.append(delay)

    response = await AsyncRetryableTransport(
        inner,
        retries=1,
        sleep=sleep,
        monotonic=lambda: 0.0,
        random_=lambda: 0.0,
    ).handle_async_request(httpx.Request("GET", "https://api.test"))

    assert response.status_code == 200
    assert len(inner.requests) == 2
    assert sleeps == pytest.approx([0.05])


@pytest.mark.asyncio
async def test_async_absent_header_429_uses_retry_after():
    inner = FakeAsyncTransport([429, 200], retry_after="2", should_retry=None)
    sleeps = []

    async def sleep(delay):
        sleeps.append(delay)

    response = await AsyncRetryableTransport(
        inner, retries=1, sleep=sleep, monotonic=lambda: 0.0
    ).handle_async_request(httpx.Request("GET", "https://api.test"))

    assert response.status_code == 200
    assert len(inner.requests) == 2
    assert sleeps == [2]


@pytest.mark.asyncio
async def test_async_does_not_retry_when_wait_reaches_request_timeout():
    inner = FakeAsyncTransport([429], retry_after="3", should_retry="true")
    sleeps = []

    async def sleep(delay):
        sleeps.append(delay)

    response = await AsyncRetryableTransport(
        inner, retries=3, sleep=sleep, monotonic=lambda: 0.0
    ).handle_async_request(
        httpx.Request(
            "GET",
            "https://api.test",
            extensions={"timeout": {"read": 3.0}},
        )
    )

    assert response.status_code == 429
    assert sleeps == []
    assert len(inner.requests) == 1


@pytest.mark.asyncio
async def test_async_timeout_after_retry_wait_names_configuration_options():
    inner = FakeAsyncTransport([429], should_retry="true")
    clock = FakeClock()

    async def sleep(delay):
        clock.sleeps.append(delay)
        clock.now = 4.0

    request = httpx.Request(
        "GET",
        "https://api.test",
        extensions={"timeout": {"read": 3.0}},
    )

    with pytest.raises(httpx.TimeoutException, match=r"request_timeout.*retries"):
        await AsyncRetryableTransport(
            inner,
            retries=1,
            sleep=sleep,
            monotonic=clock.monotonic,
        ).handle_async_request(request)


@pytest.mark.asyncio
async def test_async_retries_unavailable_status_with_backoff():
    inner = FakeAsyncTransport(
        [503, 502, 504, 200], retry_after=None, should_retry=None
    )
    sleeps = []
    randoms = iter([0.0, 1.0, 0.5])

    async def sleep(delay):
        sleeps.append(delay)

    response = await AsyncRetryableTransport(
        inner,
        retries=3,
        sleep=sleep,
        monotonic=lambda: 0.0,
        random_=lambda: next(randoms),
    ).handle_async_request(
        httpx.Request(
            "POST", "https://api.test/sandboxes/sbx-1/pause", content=b"payload"
        )
    )

    assert response.status_code == 200
    assert sleeps == pytest.approx([0.05, 0.2, 0.3])
    assert [item.content for item in inner.requests] == [b"payload"] * 4
    assert all(item.is_closed for item in inner.responses[:-1])


@pytest.mark.asyncio
@pytest.mark.parametrize("status", [500, 503])
async def test_async_retries_post_when_marked_by_server(status):
    inner = FakeAsyncTransport([status, 200], retry_after=None, should_retry="true")

    async def sleep(_):
        pass

    response = await AsyncRetryableTransport(
        inner, retries=1, sleep=sleep, monotonic=lambda: 0.0
    ).handle_async_request(
        httpx.Request("POST", "https://api.test/v2/sandboxes", content=b"payload")
    )

    assert response.status_code == 200
    assert len(inner.requests) == 2


@pytest.mark.asyncio
async def test_async_retries_post_502_without_should_retry_header():
    inner = FakeAsyncTransport([502, 200], retry_after="0", should_retry=None)

    async def sleep(_):
        pass

    response = await AsyncRetryableTransport(
        inner, retries=1, sleep=sleep, monotonic=lambda: 0.0
    ).handle_async_request(
        httpx.Request("POST", "https://api.test/v2/sandboxes", content=b"payload")
    )

    assert response.status_code == 200
    assert len(inner.requests) == 2


@pytest.mark.asyncio
@pytest.mark.parametrize("should_retry", ["TRUE", " true "])
async def test_async_should_retry_header_is_case_and_whitespace_insensitive(
    should_retry,
):
    inner = FakeAsyncTransport([503, 200], should_retry=should_retry)

    async def sleep(_):
        pass

    response = await AsyncRetryableTransport(
        inner, retries=1, sleep=sleep, monotonic=lambda: 0.0
    ).handle_async_request(httpx.Request("GET", "https://api.test"))

    assert response.status_code == 200
    assert len(inner.requests) == 2


@pytest.mark.asyncio
@pytest.mark.parametrize("status", [429, 502, 503, 504])
async def test_async_retries_retryable_status_when_header_is_absent(status):
    inner = FakeAsyncTransport([status, 200], retry_after="0", should_retry=None)
    sleeps = []

    async def sleep(delay):
        sleeps.append(delay)

    response = await AsyncRetryableTransport(
        inner, retries=1, sleep=sleep, monotonic=lambda: 0.0
    ).handle_async_request(httpx.Request("GET", "https://api.test"))

    assert response.status_code == 200
    assert len(inner.requests) == 2
    assert sleeps == [0]


@pytest.mark.asyncio
@pytest.mark.parametrize(
    ("status", "should_retry"),
    [
        (503, "false"),
        (503, "maybe"),
        (503, ""),
        (500, None),
    ],
)
async def test_async_does_not_retry_explicit_denial_or_non_fallback_status(
    status, should_retry
):
    inner = FakeAsyncTransport([status], retry_after="0", should_retry=should_retry)

    response = await AsyncRetryableTransport(inner, retries=3).handle_async_request(
        httpx.Request("GET", "https://api.test")
    )

    assert response is inner.responses[0]
    assert len(inner.requests) == 1


@pytest.mark.asyncio
async def test_async_retry_after_exceeding_timeout_is_propagated_as_is():
    inner = FakeAsyncTransport([429], retry_after="4", should_retry="true")
    sleeps = []

    async def sleep(delay):
        sleeps.append(delay)

    response = await AsyncRetryableTransport(
        inner, retries=3, sleep=sleep, monotonic=lambda: 0.0
    ).handle_async_request(
        httpx.Request(
            "GET",
            "https://api.test",
            extensions={"timeout": {"connect": 3.0, "read": 3.0}},
        )
    )

    assert response is inner.responses[0]
    assert len(inner.requests) == 1
    assert sleeps == []


@pytest.mark.asyncio
async def test_async_retry_wait_is_bounded_when_request_timeout_is_disabled():
    inner = FakeAsyncTransport([429], retry_after="60", should_retry="true")
    sleeps = []

    async def sleep(delay):
        sleeps.append(delay)

    response = await AsyncRetryableTransport(
        inner, retries=3, sleep=sleep, monotonic=lambda: 0.0
    ).handle_async_request(
        httpx.Request(
            "GET",
            "https://api.test",
            extensions={
                "timeout": {
                    "connect": None,
                    "read": None,
                    "write": None,
                    "pool": None,
                }
            },
        )
    )

    assert response is inner.responses[0]
    assert len(inner.requests) == 1
    assert sleeps == []


@pytest.mark.asyncio
async def test_async_retry_uses_only_the_remaining_request_timeout():
    clock = FakeClock()

    class AdvancingTransport(FakeAsyncTransport):
        async def handle_async_request(self, request):
            response = await super().handle_async_request(request)
            if len(self.requests) == 1:
                clock.now = 2.0
            return response

    inner = AdvancingTransport([429, 200], should_retry="true")

    async def sleep(delay):
        clock.sleep(delay)

    response = await AsyncRetryableTransport(
        inner, retries=1, sleep=sleep, monotonic=clock.monotonic
    ).handle_async_request(
        httpx.Request(
            "GET",
            "https://api.test",
            extensions={"timeout": {"connect": 3.0, "read": 3.0}},
        )
    )

    assert response.status_code == 200
    assert inner.requests[1].extensions["timeout"] == {
        "connect": 1.0,
        "read": 1.0,
    }


@pytest.mark.asyncio
async def test_async_retry_preserves_remaining_budget_for_each_timeout_phase():
    clock = FakeClock()

    class AdvancingTransport(FakeAsyncTransport):
        async def handle_async_request(self, request):
            response = await super().handle_async_request(request)
            if len(self.requests) == 1:
                clock.now = 2.0
            return response

    inner = AdvancingTransport([429, 200], should_retry="true")

    async def sleep(delay):
        clock.sleep(delay)

    await AsyncRetryableTransport(
        inner, retries=1, sleep=sleep, monotonic=clock.monotonic
    ).handle_async_request(
        httpx.Request(
            "GET",
            "https://api.test",
            extensions={
                "timeout": {
                    "connect": 3.0,
                    "read": 3.0,
                    "write": 3.0,
                    "pool": 3.0,
                }
            },
        )
    )

    assert inner.requests[1].extensions["timeout"] == {
        "connect": 1.0,
        "read": 1.0,
        "write": 1.0,
        "pool": 1.0,
    }


@pytest.mark.asyncio
async def test_async_does_not_retry_streamed_body():
    class Stream(httpx.AsyncByteStream):
        async def __aiter__(self):
            yield b"payload"

    inner = FakeAsyncTransport([429], should_retry="true")
    request = httpx.Request("POST", "https://api.test", content=Stream())

    response = await AsyncRetryableTransport(inner, retries=3).handle_async_request(
        request
    )

    assert response.status_code == 429
    assert inner.requests == [request]


@pytest.mark.asyncio
async def test_async_close_leaves_cached_transport_open():
    inner = FakeAsyncTransport([])

    await AsyncRetryableTransport(inner, retries=1).aclose()

    assert not inner.closed


@pytest.mark.parametrize(
    "error",
    [httpx.ReadError("connection reset"), httpx.RemoteProtocolError("stream reset")],
)
def test_does_not_retry_post_write_network_errors(error):
    inner = FakeTransport([error, 200])

    with pytest.raises(type(error)):
        RetryableTransport(inner, retries=3, sleep=lambda _: None).handle_request(
            httpx.Request("POST", "https://api.test/v2/sandboxes", content=b"payload")
        )

    assert len(inner.requests) == 1


@pytest.mark.asyncio
async def test_async_exhaustion_returns_final_retryable_response():
    inner = FakeAsyncTransport([503, 503, 503], should_retry="true")

    async def sleep(_):
        pass

    response = await AsyncRetryableTransport(
        inner, retries=2, sleep=sleep
    ).handle_async_request(httpx.Request("GET", "https://api.test"))

    assert response is inner.responses[-1]
    assert len(inner.requests) == 3
    assert response.content == b"response"


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "error",
    [httpx.ReadError("connection reset"), httpx.RemoteProtocolError("stream reset")],
)
async def test_async_does_not_retry_post_write_network_errors(error):
    inner = FakeAsyncTransport([error, 200])

    async def sleep(_):
        pass

    with pytest.raises(type(error)):
        await AsyncRetryableTransport(
            inner, retries=3, sleep=sleep
        ).handle_async_request(
            httpx.Request("POST", "https://api.test/v2/sandboxes", content=b"payload")
        )

    assert len(inner.requests) == 1


@pytest.mark.parametrize(
    ("value", "expected"),
    [
        ("0", 0),
        (" 60 ", 60),
        ("2147483648", None),
        ("9" * 10_000, None),
        ("Wed, 21 Oct 2015 07:28:00 GMT", None),
    ],
)
def test_parse_retry_after_delta_seconds(value, expected):
    assert parse_retry_after(value) == expected