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.

8.4 KB
Raw Blame
"""Real generated Driver binding over a synthetic MCP carrier (cua-spacesd's ``/mcp``)."""

import asyncio

import pytest

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_actual_generated_driver_and_typed_records_over_mcp(sdk, records, sse):
    transport = McpTransport(sse=sse)
    transport.response_data["result"] = {
        "content": [{"type": "text", "text": "typed-mcp-fixture"}],
        "isError": False,
    }
    sb = await sandbox(transport)
    try:
        async with sb.driver.connect() as driver:
            assert type(driver) is sdk.CuaDriver
            result = await driver.get_screen_size(sdk.GetScreenSizeInput(session=None))
            assert result.text == "typed-mcp-fixture"
            request = transport.events[-1][3]
            assert request["method"] == "cua/driver/v1/exchange"
            assert request["params"]["envelope"]["name"] == "get_screen_size"
            assert request["params"]["envelope"]["arguments"] == {}
            session = sb.driver.session_name(driver)
            await driver.get_agent_cursor_state(sdk.GetAgentCursorStateInput(session=session))
            assert transport.events[-1][3]["params"]["envelope"]["arguments"] == {
                "session": session
            }
            before = len(transport.events)
            with pytest.raises(TypeError):
                await driver.get_screen_size(sdk.GetScreenSizeInput(session=123))
            assert len(transport.events) == before
        assert not transport.sessions
        before = len(transport.events)
        with pytest.raises(sdk.DriverError.Remote, match="closed"):
            await driver.get_screen_size(sdk.GetScreenSizeInput(session=None))
        assert len(transport.events) == before
    finally:
        await sb.disconnect()


async def test_actual_driver_refuses_noncanonical_metadata(sdk, records):
    transport = McpTransport()
    sb = await sandbox(transport)
    try:
        async with sb.driver.connect() as driver:
            # Metadata still uses the canonical envelope instead of disguising
            # an ordinary MCP tools/list result as generated Driver metadata.
            transport.response_data["result"] = {"not": "driver metadata"}
            with pytest.raises(sdk.DriverError.Protocol, match="invalid metadata"):
                await driver.metadata()
    finally:
        await sb.disconnect()


async def test_actual_driver_does_not_gain_trusted_session_binding(sdk, records):
    transport = McpTransport()
    sb = await sandbox(transport)
    try:
        async with sb.driver.connect() as driver:
            options = sdk.TrustedSessionOptions(
                public_session="another-session",
                mode=sdk.SessionPermissionMode.STANDARD,
                ttl_seconds=60,
                idle_ttl_seconds=30,
                capability_manifest_path=None,
                bounded_manifest_path=None,
            )
            before = len(transport.events)
            with pytest.raises(sdk.DriverError.Remote, match="rebinding is unsupported"):
                await sdk.create_remote_trusted_session(driver, options)
            assert len(transport.events) == before
    finally:
        await sb.disconnect()


async def test_actual_native_future_cancellation_reaches_mcp_receiver(sdk, records):
    transport = McpTransport()
    transport.exchange_wait = asyncio.Event()
    sb = await sandbox(transport)
    try:
        async with sb.driver.connect() as driver:
            task = asyncio.create_task(driver.get_screen_size(sdk.GetScreenSizeInput(session=None)))
            await asyncio.wait_for(transport.exchange_started.wait(), 2)
            task.cancel()
            with pytest.raises(asyncio.CancelledError):
                await task

            async def cancellation_received():
                while True:
                    methods = [event[3] for event in transport.events if event[3]]
                    cancel = next(
                        (m for m in methods if m["method"] == "cua/driver/v1/cancel"), None
                    )
                    if cancel:
                        exchange = next(
                            m for m in methods if m["method"] == "cua/driver/v1/exchange"
                        )
                        assert (
                            cancel["params"]["request_id"]
                            == exchange["params"]["envelope"]["request_id"]
                        )
                        return
                    await asyncio.sleep(0.01)

            await asyncio.wait_for(cancellation_received(), 2)
        assert not transport.sessions
        assert not transport.exchange_aborted
        assert transport.exchange_finished.is_set()
    finally:
        transport.exchange_wait.set()
        await sb.disconnect()


@pytest.mark.parametrize("finish", ["cancel", "close"])
async def test_shared_native_teardown_drains_pending_response_before_session_close(
    sdk, records, finish
):
    transport = McpTransport()
    transport.exchange_wait = asyncio.Event()
    transport.cancel_releases_exchange = False
    sb = await sandbox(transport)
    try:
        async with sb.driver.connect() as driver:
            task = asyncio.create_task(driver.get_screen_size(sdk.GetScreenSizeInput(session=None)))
            await asyncio.wait_for(transport.exchange_started.wait(), 2)
            if finish == "cancel":
                task.cancel()
                with pytest.raises(asyncio.CancelledError):
                    await task
                closing = asyncio.create_task(sb.driver.close())
            else:
                closing = asyncio.create_task(sb.driver.close())
            await asyncio.wait_for(transport.cancel_received.wait(), 2)
            assert not transport.exchange_aborted
            assert transport.sessions
            assert not any(
                (event[3] or {}).get("method") == "cua/driver/v1/close"
                for event in transport.events
            )
            transport.exchange_wait.set()
            await asyncio.wait_for(closing, 5)
            if finish == "close":
                with pytest.raises(sdk.DriverError.ActionInterrupted) as error:
                    await task
                assert error.value.completion == sdk.ActionCompletion.UNKNOWN
            assert transport.exchange_finished.is_set()
            assert not transport.exchange_aborted
            assert not transport.sessions
    finally:
        transport.exchange_wait.set()
        await sb.disconnect()


async def test_shared_native_sandbox_rejects_use_from_another_event_loop(sdk, records):
    transport = McpTransport()
    sb = await sandbox(transport)
    try:
        async with sb.driver.connect() as driver:

            def other_loop():
                async def get_session():
                    return sb.driver.session_name(driver)

                return asyncio.run(get_session())

            from cua_sandbox.interfaces.driver import DriverConnectionError

            with pytest.raises(DriverConnectionError, match="different event loop"):
                await asyncio.to_thread(other_loop)
    finally:
        await sb.disconnect()


async def test_shared_native_drain_timeout_is_bounded_and_does_not_abort(sdk, records, caplog):
    transport = McpTransport()
    transport.exchange_wait = asyncio.Event()
    transport.cancel_releases_exchange = False
    sb = await sandbox(transport)
    try:
        async with sb.driver.connect() as driver:
            task = asyncio.create_task(driver.get_screen_size(sdk.GetScreenSizeInput(session=None)))
            await asyncio.wait_for(transport.exchange_started.wait(), 2)
            await asyncio.wait_for(sb.driver.close(), 5)
            assert not transport.exchange_aborted
            assert transport.sessions
            assert "cleanup is unconfirmed" in caplog.text
            assert not any(
                (event[3] or {}).get("method") == "cua/driver/v1/close"
                for event in transport.events
            )
            transport.exchange_wait.set()
            with pytest.raises(sdk.DriverError.ActionInterrupted) as error:
                await task
            assert error.value.completion == sdk.ActionCompletion.UNKNOWN
    finally:
        transport.exchange_wait.set()
        await sb.disconnect()