Skip to content

armgit / E2B

Public Imported from GitHub
0

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

7.5 KB
Raw Blame
import asyncio
import json
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from typing import Dict, List, Tuple

import pytest
from e2b import AsyncSecret, AsyncTemplate, AsyncVolume, Secret, Template, Volume
from e2b.sandbox_sync.commands.command import Commands

from e2b_desktop import E2B, Sandbox

API_KEY_A = "e2b_" + "a" * 40
API_KEY_B = "e2b_" + "b" * 40
ENV_API_KEY = "e2b_" + "e" * 40

DOMAIN_A = "client-a.example.com"
DOMAIN_B = "client-b.example.com"
ENV_DOMAIN = "env.example.com"

SANDBOX_RESPONSE = {
    "templateID": "desktop",
    "sandboxID": "sbx-test",
    "clientID": "client-test",
    "envdVersion": "0.2.0",
}

SECRET_RESPONSE = {
    "secretID": "secret-test",
    "name": "secret",
    "currentVersion": 1,
    "metadata": {},
    "createdAt": "2026-01-01T00:00:00Z",
    "updatedAt": "2026-01-01T00:00:00Z",
}


class _Handler(BaseHTTPRequestHandler):
    requests: List[Tuple[str, str, Dict[str, str]]] = []

    def log_message(self, *args):  # noqa: A003 - silence the default stderr log
        pass

    def _record_and_respond(self, status: int, body):
        type(self).requests.append(
            (self.command, self.path, {k.lower(): v for k, v in self.headers.items()})
        )
        payload = json.dumps(body).encode()
        self.send_response(status)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(payload)))
        self.end_headers()
        self.wfile.write(payload)

    def do_POST(self):
        length = int(self.headers.get("Content-Length") or 0)
        if length:
            self.rfile.read(length)

        if self.path.startswith("/v2/sandboxes"):
            self._record_and_respond(201, SANDBOX_RESPONSE)
        elif self.path.startswith("/volumes"):
            self._record_and_respond(
                201,
                {"volumeID": "vol-test", "name": "vol", "token": "vol-token"},
            )
        elif self.path.startswith("/secrets"):
            self._record_and_respond(201, SECRET_RESPONSE)
        else:
            self._record_and_respond(404, {"code": 404, "message": "not found"})

    def do_GET(self):
        if self.path.startswith("/templates/aliases/"):
            self._record_and_respond(
                200,
                {"aliases": [], "templateID": "tmpl-test", "public": False},
            )
        else:
            self._record_and_respond(404, {"code": 404, "message": "not found"})


class _StubHandle:
    def disconnect(self):
        pass


@pytest.fixture
def api_server(monkeypatch):
    """Local API server, with the env config pointed away from any client's."""
    monkeypatch.setenv("E2B_API_KEY", ENV_API_KEY)
    monkeypatch.setenv("E2B_DOMAIN", ENV_DOMAIN)
    monkeypatch.delenv("E2B_DEBUG", raising=False)

    # Starting the desktop environment talks to envd inside the sandbox, which
    # does not exist for a mocked API. All the API calls carrying the bound
    # configuration happen before it.
    monkeypatch.setattr(Commands, "run", lambda *args, **kwargs: _StubHandle())
    monkeypatch.setattr(Sandbox, "_wait_and_verify", lambda *args, **kwargs: True)
    monkeypatch.setattr(Sandbox, "_start_xfce4", lambda self: None)

    _Handler.requests = []
    server = ThreadingHTTPServer(("127.0.0.1", 0), _Handler)
    thread = threading.Thread(target=server.serve_forever, daemon=True)
    thread.start()
    try:
        yield f"http://127.0.0.1:{server.server_port}"
    finally:
        server.shutdown()
        server.server_close()
        thread.join()


def api_keys() -> List[str]:
    return [headers.get("x-api-key", "") for _, _, headers in _Handler.requests]


def test_client_sandbox_uses_client_config(api_server):
    client = E2B(api_key=API_KEY_A, domain=DOMAIN_A, api_url=api_server)

    sandbox = client.Sandbox.create()

    assert api_keys() == [API_KEY_A]
    assert sandbox.connection_config.api_key == API_KEY_A
    assert sandbox.connection_config.domain == DOMAIN_A


def test_client_sandbox_keeps_the_desktop_api(api_server):
    client = E2B(api_key=API_KEY_A, domain=DOMAIN_A, api_url=api_server)

    assert issubclass(client.Sandbox, Sandbox)
    assert client.Sandbox is not Sandbox
    # Class-level defaults are inherited.
    assert client.Sandbox.default_template == "desktop"

    sandbox = client.Sandbox.create()

    assert isinstance(sandbox, client.Sandbox)
    assert isinstance(sandbox, Sandbox)
    assert callable(sandbox.screenshot)
    assert callable(sandbox.stream.start)


def test_per_call_params_override_the_client(api_server):
    client = E2B(api_key=API_KEY_A, domain=DOMAIN_A, api_url=api_server)

    sandbox = client.Sandbox.create(api_key=API_KEY_B, domain=DOMAIN_B)

    assert api_keys() == [API_KEY_B]
    assert sandbox.connection_config.domain == DOMAIN_B


def test_per_call_params_set_to_none_keep_the_client_config(api_server):
    client = E2B(api_key=API_KEY_A, domain=DOMAIN_A, api_url=api_server)

    sandbox = client.Sandbox.create(api_key=None, domain=None)

    assert api_keys() == [API_KEY_A]
    assert sandbox.connection_config.api_key == API_KEY_A
    assert sandbox.connection_config.domain == DOMAIN_A


def test_client_class_can_be_rebound(api_server):
    client = E2B(api_key=API_KEY_A, domain=DOMAIN_A, api_url=api_server)

    S = client.Sandbox
    sandbox = S.create()

    assert api_keys() == [API_KEY_A]
    assert sandbox.connection_config.api_key == API_KEY_A


def test_two_clients_stay_isolated(api_server):
    client_a = E2B(api_key=API_KEY_A, domain=DOMAIN_A, api_url=api_server)
    client_b = E2B(api_key=API_KEY_B, domain=DOMAIN_B, api_url=api_server)

    sandbox_a = client_a.Sandbox.create()
    sandbox_b = client_b.Sandbox.create()

    assert api_keys() == [API_KEY_A, API_KEY_B]
    assert sandbox_a.connection_config.domain == DOMAIN_A
    assert sandbox_b.connection_config.domain == DOMAIN_B


def test_client_params_are_copied(api_server):
    opts = {"api_key": API_KEY_A, "domain": DOMAIN_A, "api_url": api_server}
    client = E2B(**opts)
    opts["api_key"] = API_KEY_B

    sandbox = client.Sandbox.create()

    assert api_keys() == [API_KEY_A]
    assert sandbox.connection_config.api_key == API_KEY_A


def test_core_resources_are_bound_to_the_client(api_server):
    client = E2B(api_key=API_KEY_A, domain=DOMAIN_A, api_url=api_server)

    volume = client.Volume.create("vol")
    assert isinstance(volume, Volume)
    assert client.Template.exists("tmpl") is True
    client.Secret.create("secret", "value")

    assert api_keys() == [API_KEY_A, API_KEY_A, API_KEY_A]

    async def run():
        await client.AsyncVolume.create("vol")
        assert await client.AsyncTemplate.exists("tmpl") is True
        await client.AsyncSecret.create("secret", "value")

    asyncio.run(run())

    assert issubclass(client.AsyncVolume, AsyncVolume)
    assert issubclass(client.AsyncTemplate, AsyncTemplate)
    assert issubclass(client.AsyncSecret, AsyncSecret)
    assert issubclass(client.Template, Template)
    assert issubclass(client.Secret, Secret)
    assert api_keys() == [API_KEY_A] * 6


def test_top_level_classes_keep_using_the_env_config(api_server):
    client = E2B(api_key=API_KEY_A, domain=DOMAIN_A, api_url=api_server)
    client.Sandbox.create()

    sandbox = Sandbox.create(api_url=api_server)

    assert api_keys()[-1] == ENV_API_KEY
    assert sandbox.connection_config.api_key == ENV_API_KEY
    assert sandbox.connection_config.domain == ENV_DOMAIN
    # Creating clients does not bind anything onto the top-level class.
    assert Sandbox._bound_api_params == {}