Skip to content

armgit / E2B

Public Imported from GitHub
0

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

9.9 KB
Raw Blame
import httpx

from e2b.envd.api import (
    acheck_sandbox_health,
    ahandle_envd_api_transport_exception_with_health,
    check_sandbox_health,
    format_envd_api_exception,
    handle_envd_api_transport_exception,
    handle_envd_api_transport_exception_with_health,
)
from e2b.exceptions import (
    AuthenticationException,
    InvalidArgumentException,
    NotEnoughSpaceException,
    NotFoundException,
    RateLimitException,
    SandboxException,
    SandboxNotRunningException,
    SandboxUnreachableException,
    TimeoutException,
)


def test_maps_400_to_invalid_argument():
    err = format_envd_api_exception(400, "Bad request")
    assert isinstance(err, InvalidArgumentException)


def test_maps_401_to_authentication():
    err = format_envd_api_exception(401, "Invalid token")
    assert isinstance(err, AuthenticationException)


def test_maps_404_to_not_found():
    err = format_envd_api_exception(404, "Not found")
    assert isinstance(err, NotFoundException)


def test_maps_429_to_rate_limit():
    err = format_envd_api_exception(429, "Too many requests")
    assert isinstance(err, RateLimitException)
    assert "rate limited" in str(err)


# Body of the proxy's 502 when the sandbox is running but nothing listens on envd's port
PORT_CLOSED = "The sandbox is running but port is not open"


def _port_closed(request: httpx.Request):
    return httpx.Response(
        502, json={"message": PORT_CLOSED, "port": 49983, "code": 502}
    )


def test_maps_502_with_port_closed_to_unreachable():
    err = format_envd_api_exception(502, PORT_CLOSED)
    assert isinstance(err, SandboxUnreachableException)
    assert "could not be reached" in str(err)


def test_maps_502_to_timeout():
    err = format_envd_api_exception(502, "Bad gateway")
    assert isinstance(err, TimeoutException)


def test_maps_507_to_not_enough_space():
    err = format_envd_api_exception(507, "No space left")
    assert isinstance(err, NotEnoughSpaceException)


def test_falls_back_to_sandbox_exception():
    err = format_envd_api_exception(500, "Internal error")
    assert isinstance(err, SandboxException)
    assert "500" in str(err)


def test_returns_raw_remote_protocol_error_without_health_result():
    original = httpx.RemoteProtocolError("peer closed connection")
    err = handle_envd_api_transport_exception(original)
    assert err is original


def test_returns_raw_network_errors():
    original = httpx.ReadError("read failed")
    err = handle_envd_api_transport_exception(original)
    assert err is original


def test_returns_original_when_not_transport_error():
    original = ValueError("not transport")
    err = handle_envd_api_transport_exception(original)
    assert err is original


def test_502_sandbox_not_found_returns_not_running():
    err = format_envd_api_exception(502, "The sandbox was not found")
    assert isinstance(err, SandboxNotRunningException)
    assert isinstance(err, TimeoutException)
    assert not isinstance(err, SandboxUnreachableException)
    assert "The sandbox was not found" in str(err)


def test_health_result_confirms_sandbox_killed():
    err = handle_envd_api_transport_exception(
        httpx.RemoteProtocolError("peer closed connection"), sandbox_running=False
    )
    assert isinstance(err, SandboxNotRunningException)
    assert "sandbox was killed or reached its end of life" in str(err)


def test_health_result_running_returns_raw_error():
    original = httpx.RemoteProtocolError("peer closed connection")
    err = handle_envd_api_transport_exception(original, sandbox_running=True)
    assert err is original


def _health_client(handler) -> httpx.Client:
    return httpx.Client(
        base_url="http://sandbox", transport=httpx.MockTransport(handler)
    )


def _ahealth_client(handler) -> httpx.AsyncClient:
    return httpx.AsyncClient(
        base_url="http://sandbox", transport=httpx.MockTransport(handler)
    )


def _refuse(request: httpx.Request):
    raise httpx.ConnectError("connection refused", request=request)


def _not_found(request: httpx.Request):
    return httpx.Response(502, json={"message": "The sandbox was not found"})


def test_health_check_reports_running():
    with _health_client(lambda request: httpx.Response(204)) as client:
        assert check_sandbox_health(client) is True


def test_health_check_reports_sandbox_gone():
    with _health_client(_not_found) as client:
        assert check_sandbox_health(client) is False


def test_health_check_raises_unreachable_for_other_502():
    with _health_client(lambda request: httpx.Response(502)) as client:
        try:
            check_sandbox_health(client)
        except SandboxUnreachableException:
            pass
        else:
            raise AssertionError("expected the probe to raise")


def test_health_check_tolerates_non_object_json_502_bodies():
    for body in (["Bad gateway"], 1, {"message": 5}):
        with _health_client(
            lambda request, body=body: httpx.Response(502, json=body)
        ) as client:
            try:
                check_sandbox_health(client)
            except SandboxUnreachableException:
                pass
            else:
                raise AssertionError("expected the probe to raise")


def test_health_check_reports_sandbox_gone_for_plain_text_body():
    with _health_client(
        lambda request: httpx.Response(502, text="The sandbox was not found")
    ) as client:
        assert check_sandbox_health(client) is False


def test_health_check_raises_unreachable_when_port_closed():
    with _health_client(_port_closed) as client:
        try:
            check_sandbox_health(client)
        except SandboxUnreachableException as e:
            assert PORT_CLOSED in str(e)
        else:
            raise AssertionError("expected the probe to raise")


def test_connect_failure_with_port_closed_returns_unreachable():
    original = httpx.ConnectError("connection refused")
    with _health_client(_port_closed) as client:
        err = handle_envd_api_transport_exception_with_health(original, client)
    assert isinstance(err, SandboxUnreachableException)
    assert PORT_CLOSED in str(err)
    assert err.__cause__ is original


def test_health_check_unknown_status_is_inconclusive():
    with _health_client(lambda request: httpx.Response(500)) as client:
        assert check_sandbox_health(client) is None


def test_health_check_raises_when_sandbox_unreachable():
    with _health_client(_refuse) as client:
        try:
            check_sandbox_health(client)
        except httpx.ConnectError:
            pass
        else:
            raise AssertionError("expected the probe to raise")


def test_connect_failure_with_sandbox_killed_returns_not_running():
    with _health_client(_not_found) as client:
        err = handle_envd_api_transport_exception_with_health(
            httpx.ConnectError("connection refused"), client
        )
    assert isinstance(err, SandboxNotRunningException)


def test_connect_failure_with_running_sandbox_returns_raw_error():
    original = httpx.ConnectError("connection refused")
    with _health_client(lambda request: httpx.Response(204)) as client:
        err = handle_envd_api_transport_exception_with_health(original, client)
    assert err is original


def test_connect_failure_with_unreachable_health_returns_unreachable():
    original = httpx.ConnectError("connection refused")
    with _health_client(_refuse) as client:
        err = handle_envd_api_transport_exception_with_health(original, client)
    assert isinstance(err, SandboxUnreachableException)
    assert "could not be reached" in str(err)
    assert "connection refused" in str(err)
    assert err.__cause__ is original


def test_dropped_connection_with_unreachable_health_returns_unreachable():
    original = httpx.RemoteProtocolError("stream reset")
    with _health_client(_refuse) as client:
        err = handle_envd_api_transport_exception_with_health(original, client)
    assert isinstance(err, SandboxUnreachableException)


def test_non_transport_error_skips_health_check():
    def fail(request: httpx.Request):
        raise AssertionError("health check should not run")

    original = httpx.ReadTimeout("timed out")
    with _health_client(fail) as client:
        err = handle_envd_api_transport_exception_with_health(original, client)
    assert err is original


async def test_async_health_check_raises_when_sandbox_unreachable():
    async with _ahealth_client(_refuse) as client:
        try:
            await acheck_sandbox_health(client)
        except httpx.ConnectError:
            pass
        else:
            raise AssertionError("expected the probe to raise")


async def test_async_connect_failure_with_unreachable_health_returns_unreachable():
    original = httpx.ConnectError("connection refused")
    async with _ahealth_client(_refuse) as client:
        err = await ahandle_envd_api_transport_exception_with_health(original, client)
    assert isinstance(err, SandboxUnreachableException)
    assert err.__cause__ is original


async def test_async_connect_failure_with_sandbox_killed_returns_not_running():
    async with _ahealth_client(_not_found) as client:
        err = await ahandle_envd_api_transport_exception_with_health(
            httpx.ConnectError("connection refused"), client
        )
    assert isinstance(err, SandboxNotRunningException)


async def test_async_health_check_raises_unreachable_when_port_closed():
    async with _ahealth_client(_port_closed) as client:
        try:
            await acheck_sandbox_health(client)
        except SandboxUnreachableException as e:
            assert PORT_CLOSED in str(e)
        else:
            raise AssertionError("expected the probe to raise")


async def test_async_connect_failure_with_port_closed_returns_unreachable():
    original = httpx.ConnectError("connection refused")
    async with _ahealth_client(_port_closed) as client:
        err = await ahandle_envd_api_transport_exception_with_health(original, client)
    assert isinstance(err, SandboxUnreachableException)
    assert PORT_CLOSED in str(err)
    assert err.__cause__ is original