Skip to content

armgit / cua

Public Imported from GitHub
0

Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.

7.9 KB
Raw Blame
"""MCP session/wire tests over the spacesd carrier; not proof of a guest desktop or native effects."""

import asyncio
import json

import httpx
import pytest
from cua_sandbox.interfaces.driver import DriverConnectionError

from ._driver_env_support import McpTransport
from ._driver_env_support import records as _records_fixture
from ._driver_env_support import sandbox
from .test_typed_driver_native import sdk as _sdk_fixture

records = _records_fixture
sdk = _sdk_fixture


@pytest.mark.parametrize("sse", [False, True])
async def test_default_carrier_preserves_canonical_driver_and_sandbox_interfaces(sdk, records, sse):
    transport = McpTransport(sse=sse)
    sb = await sandbox(transport)
    sandbox_transport = sb._transport
    try:
        async with sb.driver.connect() as driver:
            assert type(driver) is sdk.CuaDriver
            assert all(
                interface._t is sandbox_transport for interface in (sb.shell, sb.files, sb.mouse)
            )
            assert sb.driver.session_name(driver) == "session-1"
        assert not transport.sessions
        assert transport.events[-2][3]["method"] == "cua/driver/v1/close"
        assert transport.events[-1][1] == "DELETE"
        assert sandbox_transport._connected
    finally:
        await sb.disconnect()


async def test_old_tools_only_endpoint_fails_before_open_and_cleans_http_session(sdk, records):
    transport = McpTransport(supported=False)
    sb = await sandbox(transport)
    with pytest.raises(sdk.DriverError.Remote):
        async with sb.driver.connect():
            pytest.fail("must not yield a facade")
    assert [event[3]["method"] for event in transport.events if event[3]] == ["initialize"]
    assert not transport.sessions
    await sb.disconnect()


async def test_two_channels_keep_distinct_mcp_sessions_and_close_independently(sdk, records):
    transport = McpTransport()
    sb = await sandbox(transport)
    async with sb.driver.connect() as first:
        async with sb.driver.connect() as second:
            assert first is not second
            assert len(transport.sessions) == 2
        assert len(transport.sessions) == 1
    assert not transport.sessions
    await sb.disconnect()


async def test_unknown_transport_rejected_before_any_service_request(sdk, records):
    transport = McpTransport()
    sb = await sandbox(transport)
    with pytest.raises(DriverConnectionError, match="transport must"):
        async with sb.driver.connect(service="mcp", transport="guess"):
            pass
    assert not transport.events
    await sb.disconnect()


async def test_lost_exchange_never_retries_or_reinitializes(sdk, records, caplog):
    transport = McpTransport()
    sb = await sandbox(transport)
    async with sb.driver.connect() as driver:
        transport.fail_exchange = True
        with pytest.raises(sdk.DriverError.ActionInterrupted) as interrupted:
            await driver.get_screen_size(sdk.GetScreenSizeInput(session=None))
        assert interrupted.value.completion == sdk.ActionCompletion.UNKNOWN
        with pytest.raises(sdk.DriverError.Remote, match="closed"):
            sb.driver.session_name(driver)
        before = len(transport.events)
        with pytest.raises(sdk.DriverError.Remote):
            await driver.get_screen_size(sdk.GetScreenSizeInput(session=None))
        assert not any(
            (event[3] or {}).get("method") == "cua/driver/v1/exchange"
            for event in transport.events[before:]
        )
    methods = [event[3]["method"] for event in transport.events if event[3]]
    assert methods.count("initialize") == 1
    assert methods.count("cua/driver/v1/exchange") == 1
    assert not transport.sessions
    assert "sensitive" not in caplog.text
    await sb.disconnect()


@pytest.mark.parametrize("mutation", ["wrong-id", "bad-version", "rpc-error", "wrong-inner-id"])
async def test_malformed_or_failed_response_closes_without_replay(sdk, records, mutation):
    transport = McpTransport()
    sb = await sandbox(transport)

    def mutate(method, response):
        if method != "cua/driver/v1/exchange":
            return response
        if mutation == "wrong-id":
            response["id"] = "other"
        elif mutation == "bad-version":
            response["jsonrpc"] = "1.0"
        elif mutation == "rpc-error":
            response.pop("result")
            response["error"] = {"code": -32409, "message": "private diagnostic"}
        else:
            response["result"]["request_id"] = "wrong-inner-id"
        return response

    async with sb.driver.connect() as driver:
        transport.mutate = mutate
        with pytest.raises(sdk.DriverError.ActionInterrupted) as error:
            await driver.get_screen_size(sdk.GetScreenSizeInput(session=None))
        assert error.value.completion == sdk.ActionCompletion.UNKNOWN
        assert "private" not in str(error.value)
    assert not transport.sessions
    await sb.disconnect()


async def test_malformed_initialize_still_deletes_allocated_session(sdk, records):
    transport = McpTransport()
    transport.mutate = lambda method, response: dict(response, id="wrong")
    sb = await sandbox(transport)
    with pytest.raises(sdk.DriverError.Remote):
        async with sb.driver.connect():
            pass
    assert not transport.sessions
    assert transport.events[-1][1] == "DELETE"
    await sb.disconnect()


async def test_disconnect_during_initialization_cleans_late_session(sdk, records, monkeypatch):
    transport = McpTransport()
    entered, released = asyncio.Event(), asyncio.Event()
    original = transport.request_service

    async def delayed(*args, **kwargs):
        if json.loads(kwargs.get("body") or b"{}").get("method") == "initialize":
            entered.set()
            await released.wait()
        return await original(*args, **kwargs)

    monkeypatch.setattr(transport, "request_service", delayed)
    sb = await sandbox(transport)

    async def connect():
        async with sb.driver.connect():
            pytest.fail("disconnected accessor must not yield")

    opening = asyncio.create_task(connect())
    await asyncio.wait_for(entered.wait(), 2)
    closing = asyncio.create_task(sb.driver.close())
    await asyncio.sleep(0)
    released.set()
    await closing
    with pytest.raises((sdk.DriverError.Remote, DriverConnectionError)):
        await opening
    assert not transport.sessions
    await sb.disconnect()


@pytest.mark.parametrize(
    "body,media",
    [
        ('{"jsonrpc":"2.0","id":"expected","id":"expected","result":{}}', "application/json"),
        ('{"jsonrpc":"2.0","id":"expected","result":NaN}', "application/json"),
        ('data: {"jsonrpc":"2.0","id":"expected","result":{}}\n', "text/event-stream"),
        (
            'data: {"jsonrpc":"2.0","id":"expected","result":{}}\n\ndata: {}\n\n',
            "text/event-stream",
        ),
        ("{}", "text/html"),
        ('{"jsonrpc":"2.0","id":true,"result":{}}', "application/json"),
    ],
)
async def test_shared_decoder_refuses_ambiguous_incomplete_or_non_json_responses(
    sdk, records, monkeypatch, body, media
):
    transport = McpTransport()
    original = transport.request_service

    async def malformed(*args, **kwargs):
        request = json.loads(kwargs.get("body") or b"{}")
        response = await original(*args, **kwargs)
        if request.get("method") == "cua/driver/v1/exchange":
            return httpx.Response(
                200,
                content=body.replace("expected", request["id"]),
                headers={"Content-Type": media},
            )
        return response

    monkeypatch.setattr(transport, "request_service", malformed)
    sb = await sandbox(transport)
    async with sb.driver.connect() as driver:
        with pytest.raises(sdk.DriverError.ActionInterrupted) as error:
            await driver.get_screen_size(sdk.GetScreenSizeInput(session=None))
        assert error.value.completion == sdk.ActionCompletion.UNKNOWN
    assert not transport.sessions
    await sb.disconnect()