scalebox-sdk 1.0.1__py3-none-any.whl → 1.0.2__py3-none-any.whl

scalebox/test/test_existing_sandbox.py

@@ -0,0 +1,1037 @@
+#!/usr/bin/env python3
+"""
+测试用例：使用已有的sandbox URL和token进行测试（Debug模式）
+跳过创建流程，直接连接已有的sandbox
+
+测试功能包括：
+1. Filesystem操作（读写、列表、存在性检查等）
+2. 命令操作（process/commands）
+3. 上传和下载文件
+
+使用方法：
+1. 设置环境变量：
+   export SANDBOX_ID='your-sandbox-id'
+   export ENVD_ACCESS_TOKEN='your-token'
+   export SBX_DEBUG_HOST='localhost'  # 可选，默认为localhost，可设置为其他host如 '192.168.1.100'
+   export SBX_API_KEY='your-api-key'  # 可选
+
+2. 运行测试：
+   python3 scalebox/test/test_existing_sandbox.py
+
+注意：
+- 此测试用例使用debug模式（debug=True）
+- 在debug模式下，连接地址为 http://{SBX_DEBUG_HOST}:8888
+- 请确保sandbox在指定的host和8888端口上运行
+
+关于后端日志错误：
+- 如果看到 "error adjusting oom score" 错误，这是正常的，表示后端尝试设置进程的OOM score但权限不足
+- 这些错误不影响测试用例的执行和结果
+- 在debug模式下，这些权限相关的错误是可以接受的
+- 如果看到 "exit status 127" (命令未找到) 或 "exit status 1" (非零退出码)，这些是测试用例预期的行为
+"""
+
+import os
+import sys
+import tempfile
+import time
+from io import StringIO, BytesIO
+
+# 确保可以从项目根导入 scalebox
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from scalebox.sandbox_sync.main import Sandbox
+from scalebox.connection_config import ConnectionConfig
+from scalebox.sandbox.commands.command_handle import CommandExitException
+
+
+def test_filesystem_operations(sandbox):
+    """测试filesystem操作"""
+    print("\n" + "=" * 60)
+    print("测试 Filesystem 操作")
+    print("=" * 60)
+
+    # 1. 测试写入文本文件
+    print("\n[1] 测试写入文本文件...")
+    test_content = "Hello, this is a test file!\nCreated at: " + str(time.time())
+    test_path = "/tmp/test_file.txt"
+
+    try:
+        print(f"  文件路径: {test_path}")
+        print(f"  内容长度: {len(test_content)} 字符")
+        print(f"  内容预览: {test_content[:50]}...")
+        result = sandbox.files.write(test_path, test_content)
+        print(f"✓ 文件写入成功")
+        print(f"  写入路径: {result.path}")
+        print(f"  文件类型: {getattr(result, 'type', 'N/A')}")
+    except Exception as e:
+        print(f"✗ 文件写入失败: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+    # 2. 测试检查文件是否存在
+    print("\n[2] 测试检查文件是否存在...")
+    try:
+        exists = sandbox.files.exists(test_path)
+        print(f"✓ 文件存在性检查: {exists}")
+        if not exists:
+            print("✗ 文件应该存在但检查结果为不存在")
+            return False
+    except Exception as e:
+        print(f"✗ 文件存在性检查失败: {e}")
+        return False
+
+    # 3. 测试读取文件（文本格式）
+    print("\n[3] 测试读取文件（文本格式）...")
+    try:
+        print(f"  读取路径: {test_path}")
+        print(f"  格式: text")
+        content = sandbox.files.read(test_path, format="text")
+        print(f"✓ 文件读取成功")
+        print(f"  读取内容长度: {len(content)} 字符")
+        print(f"  内容预览: {content[:50]}...")
+        print(f"  原始内容长度: {len(test_content)} 字符")
+        if content.strip() != test_content.strip():
+            print("✗ 读取的内容与写入的内容不一致")
+            print(f"  原始内容: {test_content[:100]}")
+            print(f"  读取内容: {content[:100]}")
+            return False
+    except Exception as e:
+        print(f"✗ 文件读取失败: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+    # 4. 测试读取文件（字节格式）
+    print("\n[4] 测试读取文件（字节格式）...")
+    try:
+        content_bytes = sandbox.files.read(test_path, format="bytes")
+        print(f"✓ 字节格式读取成功")
+        print(f"  字节数: {len(content_bytes)}")
+        if content_bytes.decode("utf-8").strip() != test_content.strip():
+            print("✗ 字节格式读取的内容与写入的内容不一致")
+            return False
+    except Exception as e:
+        print(f"✗ 字节格式读取失败: {e}")
+        return False
+
+    # 5. 测试获取文件信息
+    print("\n[5] 测试获取文件信息...")
+    try:
+        info = sandbox.files.get_info(test_path)
+        print(f"✓ 文件信息获取成功")
+        print(f"  路径: {info.path}")
+        print(f"  大小: {info.size} 字节")
+        print(f"  类型: {info.type}")
+    except Exception as e:
+        print(f"✗ 文件信息获取失败: {e}")
+        return False
+
+    # 6. 测试写入字节文件
+    print("\n[6] 测试写入字节文件...")
+    binary_content = b"\x00\x01\x02\x03\xff\xfe\xfd"
+    binary_path = "/tmp/test_binary.bin"
+    try:
+        result = sandbox.files.write(binary_path, binary_content)
+        print(f"✓ 字节文件写入成功: {result.path}")
+
+        # 验证字节文件
+        read_binary = sandbox.files.read(binary_path, format="bytes")
+        if read_binary != binary_content:
+            print("✗ 字节文件内容不匹配")
+            return False
+    except Exception as e:
+        print(f"✗ 字节文件写入失败: {e}")
+        return False
+
+    # 7. 测试写入StringIO
+    print("\n[7] 测试写入StringIO...")
+    stringio_content = "Content from StringIO\nLine 2\nLine 3"
+    stringio_path = "/tmp/test_stringio.txt"
+    try:
+        stringio = StringIO(stringio_content)
+        result = sandbox.files.write(stringio_path, stringio)
+        print(f"✓ StringIO写入成功: {result.path}")
+
+        # 验证内容
+        read_content = sandbox.files.read(stringio_path, format="text")
+        if read_content.strip() != stringio_content.strip():
+            print("✗ StringIO内容不匹配")
+            return False
+    except Exception as e:
+        print(f"✗ StringIO写入失败: {e}")
+        return False
+
+    # 8. 测试写入BytesIO
+    print("\n[8] 测试写入BytesIO...")
+    bytesio_content = b"Content from BytesIO\x00\x01\x02"
+    bytesio_path = "/tmp/test_bytesio.bin"
+    try:
+        bytesio = BytesIO(bytesio_content)
+        result = sandbox.files.write(bytesio_path, bytesio)
+        print(f"✓ BytesIO写入成功: {result.path}")
+
+        # 验证内容
+        read_content = sandbox.files.read(bytesio_path, format="bytes")
+        if read_content != bytesio_content:
+            print("✗ BytesIO内容不匹配")
+            return False
+    except Exception as e:
+        print(f"✗ BytesIO写入失败: {e}")
+        return False
+
+    # 9. 测试批量写入文件
+    print("\n[9] 测试批量写入文件...")
+    try:
+        files = [
+            {"path": "/tmp/batch1.txt", "data": "Batch file 1 content"},
+            {"path": "/tmp/batch2.txt", "data": "Batch file 2 content"},
+            {"path": "/tmp/batch3.bin", "data": b"Batch binary content"},
+        ]
+        print(f"  准备批量写入 {len(files)} 个文件:")
+        for i, f in enumerate(files, 1):
+            data_size = len(f["data"]) if isinstance(f["data"], (str, bytes)) else "N/A"
+            data_type = type(f["data"]).__name__
+            print(f"    {i}. {f['path']} ({data_type}, {data_size} 字节)")
+
+        results = sandbox.files.write(files)
+        print(f"✓ 批量写入成功，共 {len(results)} 个文件")
+        for i, result in enumerate(results, 1):
+            print(f"    {i}. {result.path}")
+
+        # 验证所有文件
+        print(f"  验证文件存在性...")
+        for i, file_info in enumerate(files, 1):
+            exists = sandbox.files.exists(file_info["path"])
+            print(f"    {i}. {file_info['path']}: {'存在' if exists else '不存在'}")
+            if not exists:
+                print(f"✗ 批量写入的文件 {file_info['path']} 不存在")
+                return False
+    except Exception as e:
+        print(f"✗ 批量写入失败: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+    # 10. 测试列出目录
+    print("\n[10] 测试列出目录...")
+    try:
+        print(f"  正在列出目录: /tmp, depth=1")
+        entries = sandbox.files.list("/tmp", depth=1)
+        print(f"✓ 目录列表获取成功，共 {len(entries)} 项")
+        test_files_found = [
+            e.path for e in entries if "test_" in e.path or "batch" in e.path
+        ]
+        print(f"  找到测试文件: {len(test_files_found)} 个")
+        print(f"  显示前5项:")
+        for i, entry in enumerate(entries[:5], 1):
+            print(
+                f"    {i}. {entry.path} (类型: {entry.type}, 大小: {getattr(entry, 'size', 'N/A')} 字节)"
+            )
+        if len(entries) > 5:
+            print(f"  ... 还有 {len(entries) - 5} 项未显示")
+    except Exception as e:
+        print(f"✗ 目录列表获取失败: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+    # 11. 测试创建目录
+    print("\n[11] 测试创建目录...")
+    test_dir = "/tmp/test_dir"
+    try:
+        sandbox.files.make_dir(test_dir)
+        print(f"✓ 目录创建成功: {test_dir}")
+
+        # 验证目录是否存在
+        exists = sandbox.files.exists(test_dir)
+        if not exists:
+            print("✗ 目录应该存在但检查结果为不存在")
+            return False
+    except Exception as e:
+        print(f"✗ 目录创建失败: {e}")
+        return False
+
+    # 12. 测试在目录中创建文件
+    print("\n[12] 测试在目录中创建文件...")
+    try:
+        dir_file_path = "/tmp/test_dir/nested_file.txt"
+        dir_file_content = "Nested file content"
+        result = sandbox.files.write(dir_file_path, dir_file_content)
+        print(f"✓ 目录中文件创建成功: {result.path}")
+
+        # 验证文件
+        read_content = sandbox.files.read(dir_file_path, format="text")
+        if read_content.strip() != dir_file_content.strip():
+            print("✗ 目录中文件内容不匹配")
+            return False
+    except Exception as e:
+        print(f"✗ 目录中文件创建失败: {e}")
+        return False
+
+    # 13. 测试删除文件
+    print("\n[13] 测试删除文件...")
+    try:
+        sandbox.files.remove(test_path)
+        print(f"✓ 文件删除成功: {test_path}")
+
+        # 验证文件是否已删除
+        exists = sandbox.files.exists(test_path)
+        if exists:
+            print("✗ 文件应该已删除但检查结果仍存在")
+            return False
+    except Exception as e:
+        print(f"✗ 文件删除失败: {e}")
+        return False
+
+    # 14. 测试覆盖写入文件
+    print("\n[14] 测试覆盖写入文件...")
+    try:
+        original_content = "Original content"
+        overwrite_path = "/tmp/overwrite_test.txt"
+        sandbox.files.write(overwrite_path, original_content)
+
+        new_content = "New overwritten content"
+        sandbox.files.write(overwrite_path, new_content)
+
+        read_content = sandbox.files.read(overwrite_path, format="text")
+        if read_content.strip() != new_content.strip():
+            print("✗ 文件覆盖写入失败")
+            return False
+        print(f"✓ 文件覆盖写入成功")
+    except Exception as e:
+        print(f"✗ 文件覆盖写入失败: {e}")
+        return False
+
+    print("\n✓ 所有 Filesystem 操作测试通过")
+    return True
+
+
+def test_command_operations(sandbox):
+    """测试命令操作（process）"""
+    print("\n" + "=" * 60)
+    print("测试 Command/Process 操作")
+    print("=" * 60)
+    print("\n注意: 后端可能会输出 'error adjusting oom score' 错误")
+    print("      这是权限问题，不影响测试结果，可以忽略")
+
+    # 1. 测试执行简单命令
+    print("\n[1] 测试执行简单命令...")
+    cmd = "echo 'Hello from sandbox'"
+    print(f"  执行命令: {cmd}")
+    try:
+        result = sandbox.commands.run(cmd)
+        print(f"✓ 命令执行成功")
+        print(f"  退出码: {result.exit_code}")
+        print(f"  标准输出: {result.stdout.strip()}")
+        print(f"  标准错误: {result.stderr.strip() if result.stderr else '(空)'}")
+        if result.exit_code != 0:
+            print(f"✗ 命令退出码不为0: {result.exit_code}")
+            return False
+    except Exception as e:
+        print(f"✗ 命令执行失败: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+    # 2. 测试执行带参数的命令
+    print("\n[2] 测试执行带参数的命令...")
+    cmd = "ls -la /tmp | head -5"
+    print(f"  执行命令: {cmd}")
+    try:
+        result = sandbox.commands.run(cmd)
+        print(f"✓ 命令执行成功")
+        print(f"  退出码: {result.exit_code}")
+        output_lines = result.stdout.splitlines()
+        print(f"  输出行数: {len(output_lines)}")
+        print(f"  输出预览 (前3行):")
+        for i, line in enumerate(output_lines[:3], 1):
+            print(f"    {i}. {line[:80]}")
+        if result.exit_code != 0:
+            print(f"✗ 命令退出码不为0: {result.exit_code}")
+            print(f"  stderr: {result.stderr}")
+            return False
+    except Exception as e:
+        print(f"✗ 命令执行失败: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+    # 3. 测试执行带环境变量的命令
+    print("\n[3] 测试执行带环境变量的命令...")
+    try:
+        result = sandbox.commands.run(
+            "echo $TEST_VAR", envs={"TEST_VAR": "test_value_123"}
+        )
+        print(f"✓ 带环境变量的命令执行成功")
+        print(f"  退出码: {result.exit_code}")
+        print(f"  输出: {result.stdout.strip()}")
+        if "test_value_123" not in result.stdout:
+            print("✗ 环境变量未正确传递")
+            return False
+    except Exception as e:
+        print(f"✗ 带环境变量的命令执行失败: {e}")
+        return False
+
+    # 4. 测试执行带工作目录的命令
+    print("\n[4] 测试执行带工作目录的命令...")
+    try:
+        result = sandbox.commands.run("pwd", cwd="/tmp")
+        print(f"✓ 带工作目录的命令执行成功")
+        print(f"  退出码: {result.exit_code}")
+        print(f"  输出: {result.stdout.strip()}")
+        if "/tmp" not in result.stdout:
+            print("✗ 工作目录未正确设置")
+            return False
+    except Exception as e:
+        print(f"✗ 带工作目录的命令执行失败: {e}")
+        return False
+
+    # 5. 测试执行Python命令（尝试多种方式）
+    print("\n[5] 测试执行Python命令...")
+    python_commands = [
+        ("python3", "python3 -c \"import sys; print('Python3:', sys.version[:5])\""),
+        ("python", "python -c \"import sys; print('Python:', sys.version[:5])\""),
+        ("which python3", "which python3 || which python || echo 'Python not found'"),
+    ]
+
+    python_found = False
+    for cmd_name, cmd in python_commands:
+        try:
+            result = sandbox.commands.run(cmd, timeout=10)
+            if result.exit_code == 0 and (
+                "Python" in result.stdout or "/" in result.stdout
+            ):
+                print(f"✓ {cmd_name} 命令执行成功")
+                print(f"  输出: {result.stdout.strip()[:100]}")
+                python_found = True
+                break
+        except Exception as e:
+            continue
+
+    if not python_found:
+        print("⚠ Python未找到，跳过Python相关测试")
+
+    # 6. 测试执行Shell脚本
+    print("\n[6] 测试执行Shell脚本...")
+    try:
+        script_content = """#!/bin/bash
+echo "Script start"
+for i in 1 2 3; do
+    echo "Iteration $i"
+done
+echo "Script end"
+"""
+        script_path = "/tmp/test_script.sh"
+        sandbox.files.write(script_path, script_content)
+
+        # 添加执行权限并运行
+        result = sandbox.commands.run(f"chmod +x {script_path} && {script_path}")
+        print(f"✓ Shell脚本执行成功")
+        print(f"  退出码: {result.exit_code}")
+        if "Script start" not in result.stdout or "Script end" not in result.stdout:
+            print("✗ Shell脚本输出不符合预期")
+            return False
+    except Exception as e:
+        print(f"✗ Shell脚本执行失败: {e}")
+        return False
+
+    # 7. 测试执行带超时的命令
+    print("\n[7] 测试执行带超时的命令...")
+    try:
+        result = sandbox.commands.run("sleep 2 && echo 'Done'", timeout=5)
+        print(f"✓ 带超时的命令执行成功")
+        print(f"  退出码: {result.exit_code}")
+        print(f"  输出: {result.stdout.strip()}")
+        if result.exit_code != 0:
+            print(f"✗ 命令退出码不为0: {result.exit_code}")
+            return False
+    except Exception as e:
+        print(f"✗ 带超时的命令执行失败: {e}")
+        return False
+
+    # 8. 测试执行返回非零退出码的命令
+    print("\n[8] 测试执行返回非零退出码的命令...")
+    print("  执行命令: 'false' (预期退出码: 1)")
+    try:
+        result = sandbox.commands.run("false")  # false命令总是返回1
+        print(f"  实际退出码: {result.exit_code}")
+        print(f"  stdout: {result.stdout}")
+        print(f"  stderr: {result.stderr}")
+        if result.exit_code == 0:
+            print("✗ 命令应该返回非零退出码")
+            return False
+        print(f"✓ 非零退出码命令执行成功，退出码: {result.exit_code}")
+    except CommandExitException as e:
+        # CommandExitException 是正常的，当命令返回非零退出码时会抛出
+        print(f"  捕获到 CommandExitException (这是正常的)")
+        print(f"  退出码: {e.exit_code}")
+        print(f"  stdout: {e.stdout}")
+        print(f"  stderr: {e.stderr}")
+        if e.exit_code == 0:
+            print("✗ 命令应该返回非零退出码")
+            return False
+        print(f"✓ 非零退出码命令执行成功，退出码: {e.exit_code}")
+    except Exception as e:
+        print(f"✗ 非零退出码命令执行失败: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+    # 9. 测试列出运行的进程
+    print("\n[9] 测试列出运行的进程...")
+    try:
+        processes = sandbox.commands.list()
+        print(f"✓ 进程列表获取成功，共 {len(processes)} 个进程")
+        for proc in processes[:3]:  # 只显示前3个
+            print(f"  - PID: {proc.pid}, CMD: {proc.cmd[:50]}")
+    except Exception as e:
+        print(f"✗ 进程列表获取失败: {e}")
+        return False
+
+    # 10. 测试执行命令并捕获stderr
+    print("\n[10] 测试执行命令并捕获stderr...")
+    try:
+        result = sandbox.commands.run(
+            "echo 'stdout message' >&1 && echo 'stderr message' >&2"
+        )
+        print(f"✓ 命令执行成功")
+        print(f"  退出码: {result.exit_code}")
+        print(f"  stdout: {result.stdout.strip()}")
+        if result.stderr:
+            print(f"  stderr: {result.stderr.strip()}")
+    except Exception as e:
+        print(f"✗ 命令执行失败: {e}")
+        return False
+
+    # 11. 测试执行多行命令
+    print("\n[11] 测试执行多行命令...")
+    try:
+        multiline_cmd = """
+        echo "Line 1"
+        echo "Line 2"
+        echo "Line 3"
+        """
+        result = sandbox.commands.run(multiline_cmd)
+        print(f"✓ 多行命令执行成功")
+        print(f"  退出码: {result.exit_code}")
+        output_lines = result.stdout.strip().split("\n")
+        print(f"  输出行数: {len(output_lines)}")
+        if len(output_lines) < 3:
+            print("✗ 多行命令输出行数不足")
+            return False
+    except Exception as e:
+        print(f"✗ 多行命令执行失败: {e}")
+        return False
+
+    # 12. 测试执行管道命令
+    print("\n[12] 测试执行管道命令...")
+    try:
+        result = sandbox.commands.run("echo 'test1\ntest2\ntest3' | grep 'test2'")
+        print(f"✓ 管道命令执行成功")
+        print(f"  退出码: {result.exit_code}")
+        print(f"  输出: {result.stdout.strip()}")
+        if "test2" not in result.stdout:
+            print("✗ 管道命令输出不符合预期")
+            return False
+    except Exception as e:
+        print(f"✗ 管道命令执行失败: {e}")
+        return False
+
+    print("\n✓ 所有 Command/Process 操作测试通过")
+    return True
+
+
+def test_upload_download(sandbox):
+    """测试上传和下载"""
+    print("\n" + "=" * 60)
+    print("测试上传和下载")
+    print("=" * 60)
+
+    # 1. 测试上传文本文件（使用files.write）
+    print("\n[1] 测试上传文本文件...")
+    test_content = "This is a test file for upload/download testing.\n" * 10
+    test_content += f"Timestamp: {time.time()}\n"
+    remote_path = "/tmp/uploaded_test.txt"
+
+    try:
+        print(f"  目标路径: {remote_path}")
+        print(
+            f"  内容大小: {len(test_content)} 字符 ({len(test_content.encode('utf-8'))} 字节)"
+        )
+        result = sandbox.files.write(remote_path, test_content)
+        print(f"✓ 文件上传成功")
+        print(f"  上传路径: {result.path}")
+
+        # 验证文件是否存在
+        print(f"  验证文件是否存在...")
+        exists = sandbox.files.exists(remote_path)
+        print(f"  文件存在: {exists}")
+        if not exists:
+            print("✗ 上传的文件不存在")
+            return False
+    except Exception as e:
+        print(f"✗ 文件上传失败: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+    # 2. 测试下载文件（使用files.read，文本格式）
+    print("\n[2] 测试下载文件（文本格式）...")
+    try:
+        print(f"  下载路径: {remote_path}")
+        print(f"  格式: text")
+        downloaded_content = sandbox.files.read(remote_path, format="text")
+        print(f"✓ 文件下载成功")
+        print(f"  下载内容长度: {len(downloaded_content)} 字符")
+        print(f"  原始内容长度: {len(test_content)} 字符")
+        print(f"  内容预览: {downloaded_content[:50]}...")
+
+        if downloaded_content.strip() != test_content.strip():
+            print("✗ 下载的内容与上传的内容不一致")
+            print(f"  原始内容前100字符: {test_content[:100]}")
+            print(f"  下载内容前100字符: {downloaded_content[:100]}")
+            return False
+        print(f"✓ 内容验证通过")
+    except Exception as e:
+        print(f"✗ 文件下载失败: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+    # 3. 测试下载为字节格式
+    print("\n[3] 测试下载为字节格式...")
+    try:
+        downloaded_bytes = sandbox.files.read(remote_path, format="bytes")
+        print(f"✓ 字节格式下载成功")
+        print(f"  下载字节数: {len(downloaded_bytes)} 字节")
+
+        # 验证字节内容
+        expected_bytes = test_content.encode("utf-8")
+        if downloaded_bytes != expected_bytes:
+            print("✗ 下载的字节内容与上传的内容不一致")
+            return False
+    except Exception as e:
+        print(f"✗ 字节格式下载失败: {e}")
+        return False
+
+    # 4. 测试流式下载
+    print("\n[4] 测试流式下载...")
+    try:
+        stream = sandbox.files.read(remote_path, format="stream")
+        chunks = []
+        for chunk in stream:
+            chunks.append(chunk)
+        streamed_content = b"".join(chunks)
+        print(f"✓ 流式下载成功")
+        print(f"  下载块数: {len(chunks)}")
+        print(f"  总字节数: {len(streamed_content)} 字节")
+
+        if streamed_content != test_content.encode("utf-8"):
+            print("✗ 流式下载内容不匹配")
+            return False
+    except Exception as e:
+        print(f"✗ 流式下载失败: {e}")
+        return False
+
+    # 5. 测试获取下载URL
+    print("\n[5] 测试获取下载URL...")
+    try:
+        print(f"  文件路径: {remote_path}")
+        print(f"  用户: root")
+        print(f"  签名过期时间: 3600秒")
+
+        # 检查是否是debug模式
+        is_debug = sandbox.connection_config.debug
+        print(f"  Debug模式: {is_debug}")
+
+        # 在debug模式下，可能不需要签名URL，或者token可能不存在
+        if is_debug:
+            print(f"  ⚠ Debug模式下，跳过签名URL测试（debug模式通常不需要签名）")
+            print(f"  ✓ Debug模式下URL测试跳过（这是正常的）")
+        else:
+            # 检查是否有访问token
+            has_token = False
+            token = None
+            try:
+                # 尝试通过property访问
+                token = sandbox._envd_access_token
+                has_token = token is not None and token != ""
+                print(
+                    f"  Token存在: {has_token}, 长度: {len(token) if has_token else 0}"
+                )
+            except AttributeError as ae:
+                print(f"  ⚠ 无法通过property访问 _envd_access_token: {ae}")
+                # 尝试直接访问私有属性
+                try:
+                    token = getattr(sandbox, "_Sandbox__envd_access_token", None)
+                    if token is None:
+                        # 尝试其他可能的属性名
+                        token = getattr(sandbox, "__envd_access_token", None)
+                    has_token = token is not None and token != ""
+                    print(
+                        f"  直接访问token: {has_token}, 长度: {len(token) if has_token else 0}"
+                    )
+                except Exception:
+                    print(f"  ⚠ 无法访问token属性，将尝试不使用签名")
+
+            # 尝试获取下载URL
+            try:
+                if has_token:
+                    download_url = sandbox.download_url(
+                        path=remote_path,
+                        user="root",
+                        use_signature_expiration=3600,  # 1小时有效期
+                    )
+                else:
+                    # 如果没有token，尝试不使用签名
+                    print(f"  尝试不使用签名获取URL...")
+                    download_url = sandbox.download_url(path=remote_path, user="root")
+
+                print(f"✓ 下载URL获取成功")
+                print(f"  URL长度: {len(download_url)} 字符")
+                print(f"  URL预览: {download_url[:100]}...")
+                if not download_url.startswith("http"):
+                    print("✗ 下载URL格式不正确")
+                    return False
+            except AttributeError as e:
+                print(f"  ⚠ 获取下载URL失败（可能是debug模式不支持）: {e}")
+                print(f"  ✓ 在debug模式下跳过URL签名测试（这是正常的）")
+    except Exception as e:
+        print(f"✗ 下载URL获取失败: {e}")
+        # 在debug模式下，这个错误可能是可以接受的
+        if sandbox.connection_config.debug:
+            print(f"  ⚠ Debug模式下URL签名功能可能不可用，跳过此测试")
+            print(f"  ✓ Debug模式下URL测试跳过（这是正常的）")
+        else:
+            import traceback
+
+            traceback.print_exc()
+            return False
+
+    # 6. 测试获取上传URL
+    print("\n[6] 测试获取上传URL...")
+    try:
+        # 检查是否是debug模式
+        is_debug = sandbox.connection_config.debug
+        print(f"  Debug模式: {is_debug}")
+
+        if is_debug:
+            print(f"  ⚠ Debug模式下，跳过签名URL测试（debug模式通常不需要签名）")
+            print(f"  ✓ Debug模式下URL测试跳过（这是正常的）")
+        else:
+            try:
+                upload_url = sandbox.upload_url(
+                    path="/tmp/upload_via_url.txt",
+                    user="root",
+                    use_signature_expiration=3600,  # 1小时有效期
+                )
+                print(f"✓ 上传URL获取成功")
+                print(f"  URL长度: {len(upload_url)} 字符")
+                print(f"  URL预览: {upload_url[:100]}...")
+                if not upload_url.startswith("http"):
+                    print("✗ 上传URL格式不正确")
+                    return False
+            except AttributeError as e:
+                print(f"  ⚠ 获取上传URL失败（可能是debug模式不支持）: {e}")
+                print(f"  ✓ 在debug模式下跳过URL签名测试（这是正常的）")
+    except Exception as e:
+        print(f"✗ 上传URL获取失败: {e}")
+        # 在debug模式下，这个错误可能是可以接受的
+        if sandbox.connection_config.debug:
+            print(f"  ⚠ Debug模式下URL签名功能可能不可用，跳过此测试")
+            print(f"  ✓ Debug模式下URL测试跳过（这是正常的）")
+        else:
+            import traceback
+
+            traceback.print_exc()
+            return False
+
+    # 7. 测试上传小文件（1KB）
+    print("\n[7] 测试上传小文件（1KB）...")
+    small_content = b"X" * 1024
+    small_file_path = "/tmp/small_file.bin"
+
+    try:
+        start_time = time.time()
+        result = sandbox.files.write(small_file_path, small_content)
+        upload_time = time.time() - start_time
+        print(f"✓ 小文件上传成功: {result.path}")
+        print(f"  文件大小: {len(small_content)} 字节")
+        print(f"  上传耗时: {upload_time:.3f} 秒")
+
+        # 验证文件大小
+        info = sandbox.files.get_info(small_file_path)
+        if info.size != len(small_content):
+            print(f"✗ 文件大小不匹配: 期望 {len(small_content)}, 实际 {info.size}")
+            return False
+    except Exception as e:
+        print(f"✗ 小文件上传失败: {e}")
+        return False
+
+    # 8. 测试上传中等文件（100KB）
+    print("\n[8] 测试上传中等文件（100KB）...")
+    medium_content = b"Y" * (1024 * 100)
+    medium_file_path = "/tmp/medium_file.bin"
+
+    try:
+        start_time = time.time()
+        result = sandbox.files.write(medium_file_path, medium_content)
+        upload_time = time.time() - start_time
+        print(f"✓ 中等文件上传成功: {result.path}")
+        print(f"  文件大小: {len(medium_content) / 1024:.2f} KB")
+        print(f"  上传耗时: {upload_time:.2f} 秒")
+        if upload_time > 0:
+            print(f"  上传速度: {len(medium_content) / 1024 / upload_time:.2f} KB/s")
+
+        # 验证文件大小
+        info = sandbox.files.get_info(medium_file_path)
+        if info.size != len(medium_content):
+            print(f"✗ 文件大小不匹配: 期望 {len(medium_content)}, 实际 {info.size}")
+            return False
+    except Exception as e:
+        print(f"✗ 中等文件上传失败: {e}")
+        return False
+
+    # 9. 测试下载中等文件
+    print("\n[9] 测试下载中等文件...")
+    try:
+        start_time = time.time()
+        downloaded_medium = sandbox.files.read(medium_file_path, format="bytes")
+        download_time = time.time() - start_time
+        print(f"✓ 中等文件下载成功")
+        print(f"  文件大小: {len(downloaded_medium) / 1024:.2f} KB")
+        print(f"  下载耗时: {download_time:.2f} 秒")
+        if download_time > 0:
+            print(
+                f"  下载速度: {len(downloaded_medium) / 1024 / download_time:.2f} KB/s"
+            )
+
+        if downloaded_medium != medium_content:
+            print("✗ 下载的文件内容与上传的内容不一致")
+            return False
+    except Exception as e:
+        print(f"✗ 中等文件下载失败: {e}")
+        return False
+
+    # 10. 测试上传大文件（1MB）
+    print("\n[10] 测试上传大文件（1MB）...")
+    large_content = b"Z" * (1024 * 1024)
+    large_file_path = "/tmp/large_file.bin"
+
+    try:
+        start_time = time.time()
+        result = sandbox.files.write(large_file_path, large_content)
+        upload_time = time.time() - start_time
+        print(f"✓ 大文件上传成功: {result.path}")
+        print(f"  文件大小: {len(large_content) / (1024*1024):.2f} MB")
+        print(f"  上传耗时: {upload_time:.2f} 秒")
+        if upload_time > 0:
+            print(
+                f"  上传速度: {len(large_content) / (1024*1024) / upload_time:.2f} MB/s"
+            )
+
+        # 验证文件大小
+        info = sandbox.files.get_info(large_file_path)
+        if info.size != len(large_content):
+            print(f"✗ 文件大小不匹配: 期望 {len(large_content)}, 实际 {info.size}")
+            return False
+    except Exception as e:
+        print(f"✗ 大文件上传失败: {e}")
+        return False
+
+    # 11. 测试下载大文件
+    print("\n[11] 测试下载大文件...")
+    try:
+        start_time = time.time()
+        downloaded_large = sandbox.files.read(large_file_path, format="bytes")
+        download_time = time.time() - start_time
+        print(f"✓ 大文件下载成功")
+        print(f"  文件大小: {len(downloaded_large) / (1024*1024):.2f} MB")
+        print(f"  下载耗时: {download_time:.2f} 秒")
+        if download_time > 0:
+            print(
+                f"  下载速度: {len(downloaded_large) / (1024*1024) / download_time:.2f} MB/s"
+            )
+
+        if downloaded_large != large_content:
+            print("✗ 下载的大文件内容与上传的内容不一致")
+            return False
+    except Exception as e:
+        print(f"✗ 大文件下载失败: {e}")
+        return False
+
+    # 12. 测试批量上传和下载
+    print("\n[12] 测试批量上传和下载...")
+    try:
+        batch_files = [
+            {"path": "/tmp/batch_upload1.txt", "data": "Batch file 1"},
+            {"path": "/tmp/batch_upload2.txt", "data": "Batch file 2"},
+            {"path": "/tmp/batch_upload3.txt", "data": "Batch file 3"},
+        ]
+
+        # 批量上传
+        upload_results = sandbox.files.write(batch_files)
+        print(f"✓ 批量上传成功，共 {len(upload_results)} 个文件")
+
+        # 批量下载并验证
+        for file_info in batch_files:
+            downloaded = sandbox.files.read(file_info["path"], format="text")
+            expected = file_info["data"]
+            if downloaded.strip() != expected.strip():
+                print(f"✗ 批量文件 {file_info['path']} 内容不匹配")
+                return False
+
+        print(f"✓ 批量下载验证成功")
+    except Exception as e:
+        print(f"✗ 批量上传下载失败: {e}")
+        return False
+
+    print("\n✓ 所有上传和下载测试通过")
+    return True
+
+
+def main():
+    """主测试函数"""
+    print("=" * 60)
+    print("Sandbox 测试用例")
+    print("使用已有的 sandbox URL 和 token (Debug模式)")
+    print("=" * 60)
+
+    # 从环境变量或直接设置获取sandbox信息
+    # 用户需要设置这些环境变量或直接修改下面的值
+    sandbox_id = os.getenv("SANDBOX_ID")
+    sandbox_domain = os.getenv("SANDBOX_DOMAIN")
+    envd_access_token = os.getenv("ENVD_ACCESS_TOKEN")
+    api_key = os.getenv("SBX_API_KEY")
+    debug_host = os.getenv("SBX_DEBUG_HOST", "localhost")  # 默认使用localhost
+
+    # 如果没有设置环境变量，提示用户
+    if not sandbox_id or not envd_access_token:
+        print("\n错误: 请设置以下环境变量:")
+        print("  - SANDBOX_ID: sandbox的ID")
+        print("  - ENVD_ACCESS_TOKEN: sandbox的访问token")
+        print("  - SBX_DEBUG_HOST: (可选) debug模式下的host，默认为localhost")
+        print("  - SBX_API_KEY: (可选) API密钥")
+        print("\n注意: 在debug模式下，SANDBOX_DOMAIN不是必需的")
+        print("\n或者直接修改脚本中的变量值")
+        print("\n示例:")
+        print("  export SANDBOX_ID='your-sandbox-id'")
+        print("  export ENVD_ACCESS_TOKEN='your-token'")
+        print("  export SBX_DEBUG_HOST='localhost'  # 或自定义host，如 '192.168.1.100'")
+        print("  export SBX_API_KEY='your-api-key'")
+        return
+
+    print(f"\n使用以下配置 (Debug模式):")
+    print(f"  Sandbox ID: {sandbox_id}")
+    print(f"  Debug Host: {debug_host}")
+    print(
+        f"  Access Token: {'*' * 20}...{envd_access_token[-4:] if len(envd_access_token) > 4 else '****'}"
+    )
+    if sandbox_domain:
+        print(f"  Sandbox Domain: {sandbox_domain} (在debug模式下不使用)")
+
+    # 创建连接配置 - 使用debug模式
+    connection_headers = {"Authorization": "Bearer root"}
+    if envd_access_token:
+        connection_headers["X-Access-Token"] = envd_access_token
+
+    connection_config = ConnectionConfig(
+        api_key=api_key,
+        domain=None,  # debug模式下不使用domain
+        debug=True,  # 启用debug模式
+        debug_host=debug_host,  # 设置debug host
+        request_timeout=60.0,
+        headers=connection_headers,
+    )
+
+    # 创建sandbox实例（直接连接，不创建新的）
+    # 在debug模式下，sandbox_domain可以是None或任意值，因为实际使用的是debug_host
+    print("\n正在连接sandbox (Debug模式)...")
+    try:
+        sandbox = Sandbox(
+            sandbox_id=sandbox_id,
+            sandbox_domain=sandbox_domain or "debug-sandbox",  # debug模式下可以是任意值
+            envd_version="v1.0",
+            envd_access_token=envd_access_token,
+            connection_config=connection_config,
+            object_storage=None,
+            network_proxy=None,
+        )
+
+        # 检查sandbox是否运行
+        print(f"  尝试连接到: {sandbox.envd_api_url}")
+        if not sandbox.is_running():
+            print("✗ Sandbox未运行，无法进行测试")
+            print(f"  请确认sandbox在 {debug_host}:8888 上运行")
+            return
+
+        print(f"✓ Sandbox连接成功: {sandbox.sandbox_id}")
+        print(f"  API URL: {sandbox.envd_api_url}")
+
+    except Exception as e:
+        print(f"✗ Sandbox连接失败: {e}")
+        print(f"  请确认:")
+        print(f"    1. Sandbox在 {debug_host}:8888 上运行")
+        print(f"    2. ENVD_ACCESS_TOKEN 正确")
+        print(f"    3. 网络连接正常")
+        import traceback
+
+        traceback.print_exc()
+        return
+
+    # 运行测试
+    results = []
+
+    try:
+        # 测试filesystem操作
+        results.append(("Filesystem操作", test_filesystem_operations(sandbox)))
+
+        # 测试命令操作
+        results.append(("Command/Process操作", test_command_operations(sandbox)))
+
+        # 测试上传和下载
+        results.append(("上传和下载", test_upload_download(sandbox)))
+
+    except Exception as e:
+        print(f"\n✗ 测试过程中发生错误: {e}")
+        import traceback
+
+        traceback.print_exc()
+
+    # 输出测试结果摘要
+    print("\n" + "=" * 60)
+    print("测试结果摘要")
+    print("=" * 60)
+
+    all_passed = True
+    for test_name, result in results:
+        status = "✓ 通过" if result else "✗ 失败"
+        print(f"{test_name}: {status}")
+        if not result:
+            all_passed = False
+
+    print("\n" + "=" * 60)
+    if all_passed:
+        print("✓ 所有测试通过！")
+        print("\n提示:")
+        print("  - 如果后端日志中有 'error adjusting oom score' 错误，这是正常的")
+        print("    这些错误表示后端尝试设置进程OOM score但权限不足，不影响功能")
+        print("  - 在debug模式下，这些权限相关的警告可以安全忽略")
+        print("  - 测试用例的功能验证都已通过")
+    else:
+        print("✗ 部分测试失败")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()