Skip to content

armgit / E2B

Public Imported from GitHub
0

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

2.9 KB
Raw Blame
"""Client lifecycle in the sync sandbox modules: the httpx `envd_api`
clients and the connectrpc RPC clients are both cheap stateless wrappers
over shared, process-global pyqwest transports — built once per sandbox and
shared across the modules and across threads."""

from concurrent.futures import ThreadPoolExecutor
from unittest.mock import Mock, sentinel

import httpx
from packaging.version import Version

from e2b.connection_config import ConnectionConfig
from e2b.sandbox_sync.filesystem import filesystem as filesystem_sync
from e2b.sandbox_sync.filesystem.filesystem import Filesystem
import e2b.sandbox_sync.main as sandbox_sync_main


ENVD_API_URL = "https://sandbox.e2b.app"
ENVD_VERSION = Version("0.6.2")


def run_in_worker_thread(fn):
    with ThreadPoolExecutor(max_workers=1) as executor:
        return executor.submit(fn).result()


def test_sync_sandbox_shares_one_envd_api_across_modules(monkeypatch, test_api_key):
    config = ConnectionConfig(api_key=test_api_key)
    main_api = Mock(spec=httpx.Client)
    received = {}

    def record(name):
        def factory(*args, **kwargs):
            received[name] = args[-1]
            return object()

        return factory

    monkeypatch.setattr(
        sandbox_sync_main, "get_envd_api", lambda *_args, **_kwargs: main_api
    )
    for module in ("Filesystem", "Commands", "Pty"):
        monkeypatch.setattr(sandbox_sync_main, module, record(module))
    monkeypatch.setattr(sandbox_sync_main, "Git", lambda *args, **kwargs: object())

    sandbox = sandbox_sync_main.Sandbox(
        sandbox_id="sbx-test",
        sandbox_domain="e2b.app",
        envd_version=ENVD_VERSION,
        envd_access_token="tok",
        traffic_access_token="tok",
        connection_config=config,
    )

    assert sandbox._envd_api is main_api
    assert received == {"Filesystem": main_api, "Commands": main_api, "Pty": main_api}
    assert not hasattr(sandbox, "_transport")


def test_sync_filesystem_clients_are_shared_across_threads(monkeypatch, test_api_key):
    config = ConnectionConfig(api_key=test_api_key)
    shared_api = Mock(spec=httpx.Client)
    streaming_api = Mock(spec=httpx.Client)
    shared_rpc = sentinel.filesystem_rpc

    monkeypatch.setattr(
        filesystem_sync,
        "get_envd_api",
        lambda *_args, **_kwargs: streaming_api,
    )
    monkeypatch.setattr(
        filesystem_sync,
        "create_rpc_client",
        lambda *_args, **_kwargs: shared_rpc,
    )

    fs = Filesystem(
        ENVD_API_URL,
        ENVD_VERSION,
        config,
        shared_api,
    )

    assert fs._envd_api is shared_api
    assert fs._envd_api_streaming is streaming_api
    assert fs._rpc is shared_rpc

    worker_api, worker_streaming, worker_rpc = run_in_worker_thread(
        lambda: (fs._envd_api, fs._envd_api_streaming, fs._rpc)
    )
    assert worker_api is shared_api
    assert worker_streaming is streaming_api
    assert worker_rpc is shared_rpc