Skip to content

JiuwenSwarm is an intelligent AI Agent built on openJiuwen. It extends the powerful capabilities of large language models directly to your fingertips through various communication apps you use daily.

Python
24.8 KB
Raw Blame
# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
"""端到端 CLI 集成测试.

仅做端到端: 通过 ``subprocess.run`` 真实拉起已安装的 ``jiuwenbox`` 可执行脚本
(由 ``pyproject.toml`` 的 ``[project.scripts]`` 声明, 类似 ``uvicorn``),
断言 stdout / stderr / 退出码 / HTTP 副作用; 不写单元测试、不 mock httpx。

运行测试前请先在仓库根 (``code_agent/jiuwenbox/``) 安装本包::

    pip install -e .

若 ``jiuwenbox`` 不在 PATH 上, 测试会自动到 ``sys.executable`` 同级目录寻找;
均找不到则在 collect 阶段直接报错并提示安装方式。

假设 jiuwenbox server 已在运行 (与既有 ``test_server_api_default.py`` 一致),
由 ``--server-endpoint`` 或 ``JIUWENBOX_TEST_SERVER`` 指定。
"""

from __future__ import annotations

import json
import os
import shutil
import subprocess
import sys
import time
import uuid
from pathlib import Path

import pytest

pytestmark = pytest.mark.integration


def _resolve_jiuwenbox_bin() -> str:
    """定位已安装的 ``jiuwenbox`` 可执行脚本。

    查找顺序:
    1. ``PATH`` 上的 ``jiuwenbox`` / ``jiuwenbox.exe``;
    2. 当前 Python 解释器同级目录 (venv ``bin/`` 或 ``Scripts/``);
    3. 找不到则报错, 提示先 ``pip install -e .``。
    """
    found = shutil.which("jiuwenbox")
    if found:
        return found
    py_dir = Path(sys.executable).resolve().parent
    candidates = [py_dir / "jiuwenbox", py_dir / "jiuwenbox.exe"]
    # venv 上 ``python`` 可能在 ``bin/``, scripts 也在 ``bin/``; Windows venv
    # 则 ``python.exe`` 与 ``jiuwenbox.exe`` 同在 ``Scripts/``。
    for candidate in candidates:
        if candidate.is_file():
            return str(candidate)
    raise RuntimeError(
        "jiuwenbox CLI is not installed. Run `pip install -e .` from "
        "`code_agent/jiuwenbox/` before running the CLI integration tests.",
    )


_JIUWENBOX_BIN = _resolve_jiuwenbox_bin()


_PROXY_ENV_VARS = (
    "HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY",
    "http_proxy", "https_proxy", "all_proxy",
)


def _subprocess_env(extra_env: dict[str, str] | None = None) -> dict[str, str]:
    """为子进程构造环境变量。

    本测试运行已安装的脚本, 无需再注入 ``PYTHONPATH``;
    保留 ``NO_COLOR`` 以确保 stderr 不含 ANSI 转义码, 便于断言。
    """
    env = os.environ.copy()
    for key in _PROXY_ENV_VARS:
        env.pop(key, None)
    env["NO_PROXY"] = "*"
    env["no_proxy"] = "*"
    env.setdefault("NO_COLOR", "1")
    if extra_env:
        env.update(extra_env)
    return env


def _run_cli(
    args: list[str],
    *,
    base_url: str | None = None,
    extra_env: dict[str, str] | None = None,
    input_bytes: bytes | None = None,
    timeout: float = 60.0,
    check: bool = False,
) -> subprocess.CompletedProcess:
    """运行 CLI 并返回 ``CompletedProcess`` (stdout/stderr 为 bytes)。"""
    cmd: list[str] = [_JIUWENBOX_BIN]
    if base_url is not None:
        cmd += ["--base-url", base_url]
    cmd += args
    return subprocess.run(
        cmd,
        input=input_bytes,
        capture_output=True,
        timeout=timeout,
        check=check,
        env=_subprocess_env(extra_env),
    )


def _run_cli_json(args: list[str], *, base_url: str, **kwargs) -> tuple[subprocess.CompletedProcess, object]:
    """运行 CLI, 期待 stdout 是合法 JSON, 返回 (proc, parsed_json)。"""
    proc = _run_cli(args, base_url=base_url, **kwargs)
    assert proc.returncode == 0, (
        f"CLI exited {proc.returncode}\n"
        f"args={args!r}\nstdout={proc.stdout!r}\nstderr={proc.stderr!r}"
    )
    return proc, json.loads(proc.stdout.decode("utf-8"))


def _wait_phase(client, sandbox_id: str, phase: str, *, timeout: float = 10.0) -> dict:
    """轮询直到 ``sandbox.phase == phase`` 或超时, 返回最后一次 state。"""
    deadline = time.monotonic() + timeout
    state: dict = {}
    while time.monotonic() < deadline:
        response = client.get(f"/api/v1/sandboxes/{sandbox_id}")
        if response.status_code == 200:
            state = response.json()
            if state.get("phase") == phase:
                return state
        time.sleep(0.3)
    raise AssertionError(
        f"sandbox {sandbox_id} did not reach phase={phase} within {timeout}s; "
        f"last state: {state}"
    )


@pytest.fixture
def tracking_sandboxes(client):
    """模块内手动登记 sandbox_id, 测试结束兜底删除。"""
    ids: list[str] = []
    yield ids
    for sandbox_id in reversed(ids):
        try:
            client.delete(f"/api/v1/sandboxes/{sandbox_id}")
        except Exception:  # noqa: BLE001
            pass


def _create_sandbox_via_cli(server_url: str, tracking_sandboxes: list[str]) -> str:
    """CLI 创建 sandbox, 登记到 tracking 列表, 返回 sandbox_id。"""
    proc, data = _run_cli_json(["sandbox", "create"], base_url=server_url)
    assert isinstance(data, dict), data
    sandbox_id = data.get("id")
    assert isinstance(sandbox_id, str) and sandbox_id, data
    tracking_sandboxes.append(sandbox_id)
    return sandbox_id


# ────────────────────────────── health ──────────────────────────────


def test_cli_health_ok(server_url):
    proc, data = _run_cli_json(["health"], base_url=server_url)
    assert isinstance(data, dict)
    assert data.get("status") == "ok"


# ────────────────────────────── sandbox ──────────────────────────────


def test_cli_sandbox_create_and_get(server_url, tracking_sandboxes):
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)

    proc, data = _run_cli_json(
        ["sandbox", "get", sandbox_id], base_url=server_url,
    )
    assert data.get("id") == sandbox_id
    assert data.get("phase") in ("ready", "provisioning", "stopped")


def test_cli_sandbox_create_with_custom_id(server_url, tracking_sandboxes):
    custom_id = "my-sb_cli01"
    proc, data = _run_cli_json(
        ["sandbox", "create", "--sandbox-id", custom_id],
        base_url=server_url,
    )
    assert data.get("id") == custom_id
    tracking_sandboxes.append(custom_id)


def test_cli_sandbox_ls(server_url, tracking_sandboxes):
    _create_sandbox_via_cli(server_url, tracking_sandboxes)

    proc, data = _run_cli_json(["sandbox", "ls"], base_url=server_url)
    assert isinstance(data, list)
    assert len(data) >= 1


def test_cli_sandbox_ls_phase_filter(server_url, tracking_sandboxes, client):
    """``--phase`` 在 CLI 侧本地过滤; 不匹配时返回空列表。"""
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    _, ready = _run_cli_json(
        ["sandbox", "ls", "--phase", "ready"], base_url=server_url,
    )
    assert isinstance(ready, list)
    assert sandbox_id in {item.get("id") for item in ready if isinstance(item, dict)}

    _, empty = _run_cli_json(
        ["sandbox", "ls", "--phase", "no_such_phase"], base_url=server_url,
    )
    assert empty == []


def test_cli_sandbox_lifecycle(server_url, tracking_sandboxes, client):
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    _, stopped = _run_cli_json(
        ["sandbox", "stop", sandbox_id], base_url=server_url,
    )
    assert stopped.get("phase") == "stopped"

    _, started = _run_cli_json(
        ["sandbox", "start", sandbox_id], base_url=server_url,
    )
    assert started.get("phase") == "ready"

    _, restarted = _run_cli_json(
        ["sandbox", "restart", sandbox_id], base_url=server_url,
    )
    assert restarted.get("phase") == "ready"


def test_cli_sandbox_exec_stdout_and_exitcode(server_url, tracking_sandboxes, client):
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    proc = _run_cli(
        [
            "sandbox", "exec", sandbox_id, "--",
            "python3", "-c", "print(7); import sys; sys.exit(3)",
        ],
        base_url=server_url,
    )
    assert proc.returncode == 3, (proc.stdout, proc.stderr)
    assert proc.stdout.strip() == b"7"


def test_cli_sandbox_exec_stderr(server_url, tracking_sandboxes, client):
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    proc = _run_cli(
        [
            "sandbox", "exec", sandbox_id, "--",
            "python3", "-c", "import sys; sys.stderr.write('e_marker')",
        ],
        base_url=server_url,
    )
    assert proc.returncode == 0, proc.stderr
    assert b"e_marker" in proc.stderr


def test_cli_sandbox_exec_stdin_dash(server_url, tracking_sandboxes, client):
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    proc = _run_cli(
        [
            "sandbox", "exec", sandbox_id, "--stdin", "-", "--",
            "cat",
        ],
        base_url=server_url,
        input_bytes=b"hello from stdin",
    )
    assert proc.returncode == 0, proc.stderr
    assert proc.stdout == b"hello from stdin"


def test_cli_sandbox_exec_env_cwd(server_url, tracking_sandboxes, client):
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    proc = _run_cli(
        [
            "sandbox", "exec", sandbox_id,
            "--cwd", "/tmp",
            "--env", "MY_TEST_VAR=marker42",
            "--",
            "python3", "-c",
            "import os; print(os.environ.get('MY_TEST_VAR')); print(os.getcwd())",
        ],
        base_url=server_url,
    )
    assert proc.returncode == 0, proc.stderr
    out_text = proc.stdout.decode("utf-8")
    assert "marker42" in out_text
    assert "/tmp" in out_text


def test_cli_sandbox_exec_missing_command(server_url, tracking_sandboxes, client):
    """``sandbox exec`` 不带任何命令时应抛 ``_CliError`` → exit 3。"""
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    proc = _run_cli(
        ["sandbox", "exec", sandbox_id], base_url=server_url,
    )
    assert proc.returncode == 3, (proc.stdout, proc.stderr)
    assert b"missing command" in proc.stderr


def test_cli_sandbox_exec_stdin_inline(server_url, tracking_sandboxes, client):
    """``--stdin <text>``: 直接把命令行参数作为 stdin 喂给沙箱命令。"""
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    proc = _run_cli(
        [
            "sandbox", "exec", sandbox_id,
            "--stdin", "inline-payload",
            "--", "cat",
        ],
        base_url=server_url,
    )
    assert proc.returncode == 0, proc.stderr
    assert proc.stdout == b"inline-payload"


def test_cli_sandbox_exec_timeout_seconds(server_url, tracking_sandboxes, client):
    """``--timeout-seconds`` 透传到沙箱; 极短超时 + 长 sleep → 非零退出。"""
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    proc = _run_cli(
        [
            "sandbox", "exec", sandbox_id,
            "--timeout-seconds", "1",
            "--",
            "python3", "-c", "import time; time.sleep(30); print('should-not-print')",
        ],
        base_url=server_url,
        timeout=30.0,
    )
    # 超时后沙箱 kill 进程; 不绑定具体退出码 (137/124/-9/etc 都可能),
    # 只断言"没有完整执行" + "退出码非零"。
    assert proc.returncode != 0, (proc.stdout, proc.stderr)
    assert b"should-not-print" not in proc.stdout


def test_cli_sandbox_bg_exec(server_url, tracking_sandboxes, client):
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    proc, data = _run_cli_json(
        [
            "sandbox", "bg-exec", sandbox_id, "--",
            "python3", "-c", "import time; time.sleep(60)",
        ],
        base_url=server_url,
    )
    assert isinstance(data, dict)
    assert data.get("started") is True
    job_id = data.get("job_id")
    assert isinstance(job_id, str) and 4 <= len(job_id) <= 16
    assert isinstance(data.get("pid"), int) and data["pid"] > 0


def test_cli_sandbox_bg_exec_custom_job_id(
    server_url, tracking_sandboxes, client,
):
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")
    job_id = f"cli-{uuid.uuid4().hex[:4]}"

    proc, data = _run_cli_json(
        [
            "sandbox", "bg-exec", sandbox_id,
            "--job-id", job_id,
            "--",
            "python3", "-c", "import time; time.sleep(3600)",
        ],
        base_url=server_url,
    )
    assert data.get("started") is True
    assert data.get("job_id") == job_id

    kill = _run_cli(
        ["sandbox", "bg-kill", sandbox_id, job_id],
        base_url=server_url,
    )
    assert kill.returncode == 0, (kill.stdout, kill.stderr)


def test_cli_sandbox_bg_get_instant_task(server_url, tracking_sandboxes, client):
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    _, started = _run_cli_json(
        [
            "sandbox", "bg-exec", sandbox_id, "--job-id", "ver-cli",
            "--", "python3", "--version",
        ],
        base_url=server_url,
    )
    assert started.get("started") is True

    deadline = time.monotonic() + 10.0
    status: dict = {}
    while time.monotonic() < deadline:
        _, status = _run_cli_json(
            ["sandbox", "bg-get", sandbox_id, "ver-cli"],
            base_url=server_url,
        )
        if not status.get("running"):
            break
        time.sleep(0.1)
    assert status.get("running") is False
    assert status.get("exit_code") == 0
    assert (status.get("stdout") or "") == ""


def test_cli_sandbox_bg_list_and_kill(server_url, tracking_sandboxes, client):
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")
    job_id = f"lst-{uuid.uuid4().hex[:4]}"

    _run_cli_json(
        [
            "sandbox", "bg-exec", sandbox_id, "--job-id", job_id,
            "--", "python3", "-c", "import time; time.sleep(3600)",
        ],
        base_url=server_url,
    )

    _, listed = _run_cli_json(
        ["sandbox", "bg-list", sandbox_id],
        base_url=server_url,
    )
    assert isinstance(listed, dict)
    job_ids = [item.get("job_id") for item in listed.get("items", [])]
    assert job_id in job_ids

    _, kill_data = _run_cli_json(
        ["sandbox", "bg-kill", sandbox_id, job_id],
        base_url=server_url,
    )
    assert kill_data.get("killed") is True


def test_cli_sandbox_bg_get_not_found(server_url, tracking_sandboxes, client):
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    proc = _run_cli(
        ["sandbox", "bg-get", sandbox_id, "no-such-job"],
        base_url=server_url,
    )
    assert proc.returncode == 3, (proc.stdout, proc.stderr)


def test_cli_sandbox_upload_download_roundtrip(
    server_url, tracking_sandboxes, client, tmp_path,
):
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    payload = b"hello-roundtrip\n\x00\x01binary\xff"
    local = tmp_path / "src.bin"
    local.write_bytes(payload)
    remote = "/tmp/roundtrip.bin"

    up = _run_cli(
        [
            "sandbox", "upload", sandbox_id,
            str(local), remote,
        ],
        base_url=server_url,
    )
    assert up.returncode == 0, up.stderr

    down = _run_cli(
        ["sandbox", "download", sandbox_id, remote, "-"],
        base_url=server_url,
    )
    assert down.returncode == 0, down.stderr
    assert down.stdout == payload


def test_cli_sandbox_upload_from_stdin(server_url, tracking_sandboxes, client):
    """``upload <id> - <remote>``: 把 host stdin 的内容写入沙箱文件。"""
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    payload = b"from-stdin-content\nbinary:\x00\x7f"
    remote = "/tmp/from-stdin.bin"

    up = _run_cli(
        ["sandbox", "upload", sandbox_id, "-", remote],
        base_url=server_url,
        input_bytes=payload,
    )
    assert up.returncode == 0, up.stderr

    down = _run_cli(
        ["sandbox", "download", sandbox_id, remote, "-"],
        base_url=server_url,
    )
    assert down.returncode == 0, down.stderr
    assert down.stdout == payload


def test_cli_sandbox_upload_local_not_found(
    server_url, tracking_sandboxes, client, tmp_path,
):
    """本地路径不存在 → CLI 抛 ``_CliError`` → exit 3 (不打到 server)。"""
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    missing = tmp_path / "definitely-missing.bin"
    proc = _run_cli(
        ["sandbox", "upload", sandbox_id, str(missing), "/tmp/x.bin"],
        base_url=server_url,
    )
    assert proc.returncode == 3, (proc.stdout, proc.stderr)
    assert b"local file not found" in proc.stderr


def test_cli_sandbox_download_to_file(
    server_url, tracking_sandboxes, client, tmp_path,
):
    """``download <id> <remote> <local_path>``: 写到本地文件而非 stdout。"""
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    payload = b"download-target\x00\xfe"
    src = tmp_path / "src.bin"
    src.write_bytes(payload)
    remote = "/tmp/download-target.bin"
    _run_cli(
        ["sandbox", "upload", sandbox_id, str(src), remote],
        base_url=server_url, check=True,
    )

    dst = tmp_path / "downloaded.bin"
    proc = _run_cli(
        ["sandbox", "download", sandbox_id, remote, str(dst)],
        base_url=server_url,
    )
    assert proc.returncode == 0, proc.stderr
    assert dst.read_bytes() == payload
    # 写文件路径时, 进度提示应落在 stderr 而不是 stdout, stdout 不应有内容。
    assert proc.stdout == b""


def test_cli_sandbox_files(server_url, tracking_sandboxes, client, tmp_path):
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    local = tmp_path / "sample.txt"
    local.write_bytes(b"hello")
    _run_cli(
        [
            "sandbox", "upload", sandbox_id,
            str(local), "/tmp/sample.txt",
        ],
        base_url=server_url, check=True,
    )

    proc, data = _run_cli_json(
        [
            "sandbox", "files", sandbox_id, "/tmp",
            "--recursive", "--max-depth", "2",
        ],
        base_url=server_url,
    )
    assert isinstance(data, list)
    paths = {item.get("path") for item in data if isinstance(item, dict)}
    assert "/tmp/sample.txt" in paths


def test_cli_sandbox_files_no_dirs(
    server_url, tracking_sandboxes, client, tmp_path,
):
    """``--no-dirs`` 只返回文件项, 不包含目录条目。"""
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    local = tmp_path / "only-file.txt"
    local.write_bytes(b"hi")
    _run_cli(
        ["sandbox", "upload", sandbox_id, str(local), "/tmp/only-file.txt"],
        base_url=server_url, check=True,
    )

    proc, data = _run_cli_json(
        [
            "sandbox", "files", sandbox_id, "/tmp",
            "--recursive", "--max-depth", "2",
            "--no-dirs",
        ],
        base_url=server_url,
    )
    assert isinstance(data, list)
    for item in data:
        assert isinstance(item, dict), data
        assert item.get("is_directory") is False, item
    paths = {item.get("path") for item in data}
    assert "/tmp/only-file.txt" in paths


def test_cli_sandbox_find(server_url, tracking_sandboxes, client, tmp_path):
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    local = tmp_path / "hit.txt"
    local.write_bytes(b"x")
    _run_cli(
        [
            "sandbox", "upload", sandbox_id,
            str(local), "/tmp/hit.txt",
        ],
        base_url=server_url, check=True,
    )

    proc, data = _run_cli_json(
        ["sandbox", "find", sandbox_id, "/tmp", "*.txt"],
        base_url=server_url,
    )
    assert isinstance(data, list)
    paths = {item.get("path") for item in data if isinstance(item, dict)}
    assert "/tmp/hit.txt" in paths


def test_cli_sandbox_create_policy_file_not_found(server_url, tmp_path):
    """``--policy-file`` 指向不存在路径 → ``_CliError`` → exit 3。"""
    missing = tmp_path / "no-such.json"
    proc = _run_cli(
        ["sandbox", "create", "--policy-file", str(missing)],
        base_url=server_url,
    )
    assert proc.returncode == 3, (proc.stdout, proc.stderr)
    assert b"policy file not found" in proc.stderr


def test_cli_sandbox_create_policy_file_invalid_json(server_url, tmp_path):
    """``--policy-file`` 内容非合法 JSON → 本地解析失败 → exit 3。"""
    bad = tmp_path / "bad.json"
    bad.write_text("{not valid json,,,", encoding="utf-8")
    proc = _run_cli(
        ["sandbox", "create", "--policy-file", str(bad)],
        base_url=server_url,
    )
    assert proc.returncode == 3, (proc.stdout, proc.stderr)
    assert b"not valid JSON" in proc.stderr


def test_cli_sandbox_rm_yes(server_url, tracking_sandboxes, client):
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)

    proc = _run_cli(
        ["sandbox", "rm", sandbox_id, "--yes"],
        base_url=server_url,
    )
    assert proc.returncode == 0, proc.stderr
    # 之后 GET 应为 404
    response = client.get(f"/api/v1/sandboxes/{sandbox_id}")
    assert response.status_code == 404


def test_cli_sandbox_rm_not_found(server_url):
    proc = _run_cli(
        ["sandbox", "rm", "nonexistent-id-12345", "--yes"],
        base_url=server_url,
    )
    assert proc.returncode == 1, (proc.stdout, proc.stderr)
    assert b"HTTP 404" in proc.stderr


# ────────────────────────────── policy ──────────────────────────────


def test_cli_policy_get(server_url, tracking_sandboxes, client):
    sandbox_id = _create_sandbox_via_cli(server_url, tracking_sandboxes)
    _wait_phase(client, sandbox_id, "ready")

    proc, data = _run_cli_json(
        ["policy", "get", sandbox_id], base_url=server_url,
    )
    assert isinstance(data, dict)
    # policy 至少含 name 字段
    assert "name" in data


def test_cli_policy_get_not_found(server_url):
    """policy get 不存在的 sandbox → HTTP 404 → exit 1 + stderr 含状态码。"""
    proc = _run_cli(
        ["policy", "get", "nonexistent-policy-target-9999"],
        base_url=server_url,
    )
    assert proc.returncode == 1, (proc.stdout, proc.stderr)
    assert b"HTTP 404" in proc.stderr


# ────────────────────────────── global / parsing ──────────────────────────────


def test_cli_global_env_var_base_url(server_url):
    # 不传 --base-url, 改用 JIUWENBOX_URL 环境变量
    proc = _run_cli(
        ["health"], base_url=None,
        extra_env={"JIUWENBOX_URL": server_url},
    )
    assert proc.returncode == 0, proc.stderr
    data = json.loads(proc.stdout.decode("utf-8"))
    assert data.get("status") == "ok"


def test_cli_invalid_env_token(server_url):
    proc = _run_cli(
        ["sandbox", "create", "--env", "BAD_TOKEN"],
        base_url=server_url,
    )
    assert proc.returncode == 3, (proc.stdout, proc.stderr)
    assert b"KEY=VAL" in proc.stderr


def test_cli_help_exits_zero():
    for args in (["--help"], ["sandbox", "--help"], ["sandbox", "exec", "--help"]):
        proc = _run_cli(args, base_url="http://127.0.0.1:8321")
        assert proc.returncode == 0, (args, proc.stdout, proc.stderr)
        assert proc.stdout, args


def test_cli_unknown_subcommand(server_url):
    """未知顶层子命令 → argparse 报错并以非零退出。"""
    proc = _run_cli(["no_such_group"], base_url=server_url)
    assert proc.returncode != 0, (proc.stdout, proc.stderr)
    # argparse 把错误打到 stderr; 内容里通常含 ``invalid choice`` 或 ``usage:``。
    err = proc.stderr.lower()
    assert (b"invalid choice" in err) or (b"usage:" in err), proc.stderr


def test_cli_verbose_debug_logs(server_url):
    """``-v`` 开启 DEBUG 日志, ``_CliClient`` 的 GET 调试行应出现在 stderr 上。"""
    proc = _run_cli(["-v", "health"], base_url=server_url)
    assert proc.returncode == 0, proc.stderr
    # 至少能看到 DEBUG 标记 (logging.basicConfig 格式: "%(levelname)s") 或 GET 请求行。
    err = proc.stderr
    assert b"DEBUG" in err, err
    assert b"GET" in err and b"/health" in err, err