hw-cloudrobo-workspace 0.2.0__tar.gz

hw_cloudrobo_workspace-0.2.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: hw-cloudrobo-workspace
+Version: 0.2.0
+Summary: CloudRobo Workspace SDK and CLI
+Author-email: Huawei Cloud CloudRobo Team <hwcloudrobo@huawei.com>
+License: Apache-2.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Requires-Dist: click>=8.0
+Requires-Dist: hw-cloudrobo-core>=0.1.0

hw_cloudrobo_workspace-0.2.0/README.md

@@ -0,0 +1,16 @@
+# cloudrobo-workspace
+
+工作空间模块，提供工作空间的创建、查询、更新、删除、成员管理、概览统计及切换等功能。
+
+## 安装
+
+```bash
+pip install -e packages/cloudrobo-workspace
+```
+
+## 文档
+
+- [模块概览](docs/index.md)
+- [CLI 命令](docs/commands.md)
+- [使用示例](docs/examples.md)
+- [开发指南](docs/development.md)

hw_cloudrobo_workspace-0.2.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools==83.0.0", "packaging==26.2", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hw-cloudrobo-workspace"
+version = "0.2.0"
+description = "CloudRobo Workspace SDK and CLI"
+requires-python = ">=3.8"
+authors = [{name = "Huawei Cloud CloudRobo Team", email = "hwcloudrobo@huawei.com"}]
+license = {text = "Apache-2.0"}
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "click>=8.0",
+    "hw-cloudrobo-core>=0.1.0",
+]
+
+[project.entry-points."cloudrobo.groups"]
+workspace = "cloudrobo_workspace.cli:workspace"
+
+[tool.setuptools.packages.find]
+where = ["src"]

hw_cloudrobo_workspace-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

hw_cloudrobo_workspace-0.2.0/src/cloudrobo_workspace/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026-2026. All rights reserved.
+
+from .client import WorkspaceClient
+
+__all__ = ["WorkspaceClient"]

hw_cloudrobo_workspace-0.2.0/src/cloudrobo_workspace/cli.py

@@ -0,0 +1,319 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026-2026. All rights reserved.
+
+import json
+import sys
+import traceback
+from functools import wraps
+
+import click
+
+from cloudrobo_core.cli.cli_utils import get_client, out
+from cloudrobo_core.sdk.exceptions import (
+    CloudRoboError,
+    ResourceConflictError,
+    ResourceNotFoundError,
+)
+from .client import WorkspaceClient, WorkspaceError, is_debug_mode
+from .config import load_workspace, save_workspace
+
+
+def handle_error(func):
+    """装饰器：统一处理工作空间命令的异常"""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except WorkspaceError as e:
+            if is_debug_mode():
+                traceback.print_exc()
+            else:
+                click.echo(e.get_user_message(), err=True)
+            sys.exit(1)
+        except CloudRoboError as e:
+            if is_debug_mode():
+                traceback.print_exc()
+            else:
+                click.echo(f"错误: {e}", err=True)
+            sys.exit(1)
+        except click.exceptions.ClickException:
+            raise
+        except Exception as e:
+            if is_debug_mode():
+                traceback.print_exc()
+            else:
+                click.echo(f"执行失败: {e}", err=True)
+                click.echo("提示: 设置 CLOUDROBO_DEBUG=1 查看详细错误信息", err=True)
+            sys.exit(1)
+
+    return wrapper
+
+
+def _parse_json(value, param_name):
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError as e:
+            raise click.BadParameter(f"{param_name} 不是合法的 JSON: {e}")
+    return value
+
+
+@click.group()
+def workspace():
+    """工作空间命令组"""
+    pass
+
+
+@workspace.command("create")
+@click.option("--name", required=True, help="工作空间名称")
+@click.option("--description", default=None, help="工作空间描述")
+@click.option("--default-obs-path", required=True, help="默认OBS路径")
+@click.option("--tags", default=None, help="标签列表(逗号分隔)")
+@click.option("--member-list", default=None, help="成员列表(JSON字符串)")
+@click.option("--dry-run", is_flag=True)
+@click.pass_context
+@handle_error
+def create(ctx, name, description, default_obs_path, tags, member_list, dry_run):
+    """创建工作空间"""
+    if dry_run:
+        click.echo(f"[DRY-RUN] create_workspace(name={name}, default_obs_path={default_obs_path})")
+        return
+    client = get_client(ctx, WorkspaceClient)
+    req = {"name": name, "default_obs_path": default_obs_path}
+    if description is not None:
+        req["description"] = description
+    if tags is not None:
+        req["tags"] = [t.strip() for t in tags.split(",") if t.strip()]
+    if member_list is not None:
+        req["member_list"] = _parse_json(member_list, "--member-list")
+    try:
+        result = client.create_workspace(req)
+    except ResourceConflictError as e:
+        click.echo(f"创建工作空间失败: 名称 '{name}' 已存在", err=True)
+        if str(e):
+            click.echo(f"  服务端返回: {e}", err=True)
+        sys.exit(1)
+    ws_id = result.get("workspace_id", "") if isinstance(result, dict) else ""
+    if ws_id:
+        click.echo(f"已创建工作空间: {ws_id}")
+    else:
+        click.echo(f"已创建工作空间: {name}")
+
+
+@workspace.command("list")
+@click.option("--limit", type=click.IntRange(1), default=None, help="每页返回数量(>=1)")
+@click.option("--offset", type=click.IntRange(0), default=None, help="偏移量(>=0)")
+@click.pass_context
+@handle_error
+def list_ws(ctx, limit, offset):
+    """列出工作空间"""
+    client = get_client(ctx, WorkspaceClient)
+    params = {}
+    if limit is not None:
+        params["limit"] = limit
+    if offset is not None:
+        params["offset"] = offset
+    result = client.list_workspaces(**params)
+    out(result)
+
+
+@workspace.command("show")
+@click.option("--workspace-id", required=True, help="工作空间ID")
+@click.pass_context
+@handle_error
+def show(ctx, workspace_id):
+    """查看工作空间详情"""
+    client = get_client(ctx, WorkspaceClient)
+    try:
+        result = client.show_workspace(workspace_id)
+    except ResourceNotFoundError:
+        click.echo(f"工作空间 {workspace_id} 不存在", err=True)
+        sys.exit(1)
+    out(result)
+
+
+@workspace.command("update")
+@click.option("--workspace-id", required=True, help="工作空间ID")
+@click.option("--name", default=None, help="工作空间名称")
+@click.option("--description", default=None, help="工作空间描述")
+@click.option("--tags", default=None, help="标签列表(逗号分隔)")
+@click.option("--owner-id", default=None, help="责任人用户ID")
+@click.option("--default-obs-path", default=None, help="默认OBS路径")
+@click.option("--bind-obs-policy", is_flag=True, help="仅绑定OBS桶策略，不更新其他字段")
+@click.option("--dry-run", is_flag=True)
+@click.pass_context
+@handle_error
+def update(ctx, workspace_id, name, description, tags, owner_id, default_obs_path, bind_obs_policy, dry_run):
+    """更新工作空间"""
+    if dry_run:
+        click.echo(f"[DRY-RUN] update_workspace(id={workspace_id})")
+        return
+    client = get_client(ctx, WorkspaceClient)
+    if bind_obs_policy:
+        req = {"bind_obs_policy": True}
+    else:
+        req = {}
+        if name is not None:
+            req["name"] = name
+        if description is not None:
+            req["description"] = description
+        if tags is not None:
+            req["tags"] = [t.strip() for t in tags.split(",") if t.strip()]
+        if owner_id is not None:
+            req["owner_id"] = owner_id
+        if default_obs_path is not None:
+            req["default_obs_path"] = default_obs_path
+        if not req:
+            raise click.UsageError("未提供任何更新字段，请至少指定一个要更新的参数或使用 --bind-obs-policy")
+    try:
+        result = client.update_workspace(workspace_id, req)
+    except ResourceNotFoundError:
+        click.echo(f"工作空间 {workspace_id} 不存在，无法更新", err=True)
+        sys.exit(1)
+    except ResourceConflictError as e:
+        click.echo(f"更新工作空间失败: 名称 '{name}' 已被其他工作空间使用", err=True)
+        if str(e):
+            click.echo(f"  服务端返回: {e}", err=True)
+        sys.exit(1)
+    click.echo(f"已更新工作空间: {workspace_id}")
+
+
+@workspace.command("delete")
+@click.option("--workspace-id", required=True, help="工作空间ID")
+@click.option("--dry-run", is_flag=True)
+@click.pass_context
+@handle_error
+def delete(ctx, workspace_id, dry_run):
+    """删除工作空间"""
+    if dry_run:
+        click.echo(f"[DRY-RUN] delete_workspace(id={workspace_id})")
+        return
+    client = get_client(ctx, WorkspaceClient)
+    try:
+        result = client.delete_workspace(workspace_id)
+    except ResourceNotFoundError:
+        click.echo(f"工作空间 {workspace_id} 不存在，无法删除", err=True)
+        sys.exit(1)
+    click.echo(f"已删除工作空间: {workspace_id}")
+
+
+@workspace.command("list-members")
+@click.option("--workspace-id", required=True, help="工作空间ID")
+@click.pass_context
+@handle_error
+def list_members(ctx, workspace_id):
+    """列出工作空间成员"""
+    client = get_client(ctx, WorkspaceClient)
+    try:
+        result = client.list_workspace_members(workspace_id)
+    except ResourceNotFoundError:
+        click.echo(f"工作空间 {workspace_id} 不存在", err=True)
+        sys.exit(1)
+    out(result)
+
+
+@workspace.command("add-members")
+@click.option("--workspace-id", required=True, help="工作空间ID")
+@click.option("--member-list", required=True, help="成员列表(JSON字符串)")
+@click.pass_context
+@handle_error
+def add_members(ctx, workspace_id, member_list):
+    """添加工作空间成员"""
+    client = get_client(ctx, WorkspaceClient)
+    members = _parse_json(member_list, "--member-list")
+    try:
+        result = client.add_workspace_members(workspace_id, {"member_list": members})
+    except ResourceNotFoundError:
+        click.echo(f"工作空间 {workspace_id} 不存在，无法添加成员", err=True)
+        sys.exit(1)
+    except ResourceConflictError as e:
+        click.echo(f"添加成员失败: 部分成员可能已存在", err=True)
+        if str(e):
+            click.echo(f"  服务端返回: {e}", err=True)
+        sys.exit(1)
+    click.echo(f"已添加 {len(members)} 个成员")
+
+
+@workspace.command("update-member")
+@click.option("--workspace-id", required=True, help="工作空间ID")
+@click.option("--user-id", required=True, help="用户ID")
+@click.option("--role-ids", required=True, help="角色ID列表(逗号分隔)")
+@click.pass_context
+@handle_error
+def update_member(ctx, workspace_id, user_id, role_ids):
+    """更新工作空间成员角色"""
+    client = get_client(ctx, WorkspaceClient)
+    req = {"user_id": user_id, "role_ids": [r.strip() for r in role_ids.split(",") if r.strip()]}
+    try:
+        result = client.update_workspace_member(workspace_id, req)
+    except ResourceNotFoundError:
+        click.echo(f"工作空间 {workspace_id} 或成员 {user_id} 不存在", err=True)
+        sys.exit(1)
+    click.echo(f"已更新成员 {user_id} 的角色")
+
+
+@workspace.command("delete-members")
+@click.option("--workspace-id", required=True, help="工作空间ID")
+@click.option("--user-ids", required=True, help="用户ID列表(逗号分隔)")
+@click.pass_context
+@handle_error
+def delete_members(ctx, workspace_id, user_ids):
+    """删除工作空间成员"""
+    client = get_client(ctx, WorkspaceClient)
+    ids = [x.strip() for x in user_ids.split(",") if x.strip()]
+    try:
+        result = client.delete_workspace_members(workspace_id, ids)
+    except ResourceNotFoundError:
+        click.echo(f"工作空间 {workspace_id} 不存在，无法删除成员", err=True)
+        sys.exit(1)
+    click.echo(f"已删除 {len(ids)} 个成员")
+
+
+@workspace.command("overview")
+@click.pass_context
+@handle_error
+def overview(ctx):
+    """查看工作空间概览统计"""
+    client = get_client(ctx, WorkspaceClient)
+    result = client.get_workspace_overview()
+    out(result)
+
+
+@workspace.command("use")
+@click.option("--workspace-id", required=True, help="工作空间ID")
+@click.pass_context
+@handle_error
+def use(ctx, workspace_id):
+    """使用指定工作空间，验证有效性并保存工作空间信息"""
+    client = get_client(ctx, WorkspaceClient)
+    try:
+        result = client.show_workspace(workspace_id)
+    except ResourceNotFoundError:
+        click.echo(f"工作空间 {workspace_id} 不存在", err=True)
+        sys.exit(1)
+    ws = result.get("workspace", result)
+    name = ws.get("name", "")
+    asset_catalog_id = ws.get("asset_catalog_id", "")
+    default_obs_path = ws.get("default_obs_path", "")
+
+    save_workspace({
+        "workspace_id": workspace_id,
+        "name": name,
+        "asset_catalog_id": asset_catalog_id,
+        "default_obs_path": default_obs_path,
+    })
+
+    click.echo(f"已切换到工作空间: {name} ({workspace_id})")
+    click.echo(f"  asset_catalog_id: {asset_catalog_id}")
+    click.echo(f"  default_obs_path: {default_obs_path}")
+
+
+@workspace.command("current")
+@click.pass_context
+def current(ctx):
+    """显示当前工作空间配置"""
+    ws = load_workspace()
+    if ws:
+        click.echo(json.dumps(ws, ensure_ascii=False, indent=2))
+    else:
+        click.echo("未配置工作空间")

hw_cloudrobo_workspace-0.2.0/src/cloudrobo_workspace/client.py

@@ -0,0 +1,133 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026-2026. All rights reserved.
+
+import logging
+import os
+from typing import Any
+
+from cloudrobo_core.sdk import BaseClient
+from cloudrobo_core.sdk.exceptions import validate_safe_id
+
+logger = logging.getLogger(__name__)
+
+
+def is_debug_mode() -> bool:
+    """检测是否处于 debug 模式"""
+    env_val = os.environ.get("CLOUDROBO_DEBUG", "").lower()
+    if env_val in ("1", "true", "yes"):
+        return True
+    return logger.isEnabledFor(logging.DEBUG)
+
+
+class WorkspaceError(Exception):
+    """工作空间模块自定义异常"""
+
+    def __init__(self, message: str, suggestion: str = ""):
+        self.message = message
+        self.suggestion = suggestion
+        super().__init__(message)
+
+    def get_user_message(self) -> str:
+        """获取用户友好的错误消息"""
+        if self.suggestion:
+            return f"{self.message}\n\n建议: {self.suggestion}"
+        return self.message
+
+
+class WorkspaceClient(BaseClient):
+    SERVICE = "cloudrobo-service"
+
+    def create_workspace(self, req: dict) -> dict:
+        if not isinstance(req, dict) or not req:
+            raise WorkspaceError("创建工作空间失败: 请求体不能为空")
+        name = req.get("name")
+        if not name or not str(name).strip():
+            raise WorkspaceError(
+                "创建工作空间失败: name 不能为空或纯空格",
+                "请通过 --name 指定有效的工作空间名称"
+            )
+        obs_path = req.get("default_obs_path")
+        if not obs_path or not str(obs_path).strip():
+            raise WorkspaceError(
+                "创建工作空间失败: default_obs_path 不能为空或纯空格",
+                "请通过 --default-obs-path 指定有效的OBS路径"
+            )
+        return self._client.post(self._url("/v1/workspaces"), json=req)
+
+    def list_workspaces(self, **params) -> dict:
+        return self._client.get(self._url("/v1/workspaces"), params=params)
+
+    def show_workspace(self, workspace_id: str) -> dict:
+        validate_safe_id(workspace_id, "workspace_id")
+        return self._client.get(self._url(f"/v1/workspaces/{workspace_id}"))
+
+    def update_workspace(self, workspace_id: str, req: dict) -> dict:
+        validate_safe_id(workspace_id, "workspace_id")
+        if not isinstance(req, dict) or not req:
+            raise WorkspaceError(
+                "更新工作空间失败: 请求体不能为空",
+                "请至少指定一个要更新的参数，或使用 --bind-obs-policy"
+            )
+        name = req.get("name")
+        if name is not None and not str(name).strip():
+            raise WorkspaceError(
+                "更新工作空间失败: name 不能为空或纯空格",
+                "请通过 --name 指定有效的工作空间名称"
+            )
+        return self._client.put(self._url(f"/v1/workspaces/{workspace_id}"), json=req)
+
+    def delete_workspace(self, workspace_id: str) -> Any:
+        validate_safe_id(workspace_id, "workspace_id")
+        return self._client.delete(self._url(f"/v1/workspaces/{workspace_id}"))
+
+    def add_workspace_members(self, workspace_id: str, req: dict) -> dict:
+        validate_safe_id(workspace_id, "workspace_id")
+        if not isinstance(req, dict) or not req:
+            raise WorkspaceError("添加成员失败: 请求体不能为空")
+        member_list = req.get("member_list")
+        if not member_list:
+            raise WorkspaceError(
+                "添加成员失败: 缺少 member_list 参数",
+                "请通过 --member-list 提供成员列表(JSON字符串)"
+            )
+        if not isinstance(member_list, list):
+            raise WorkspaceError(
+                "添加成员失败: member_list 必须为列表",
+                "请提供合法的 JSON 数组，例如: [{\"user_id\":\"u1\",\"role_ids\":[\"r1\"]}]"
+            )
+        return self._client.post(self._url(f"/v1/workspaces/{workspace_id}/members"), json=req)
+
+    def list_workspace_members(self, workspace_id: str) -> dict:
+        validate_safe_id(workspace_id, "workspace_id")
+        return self._client.get(self._url(f"/v1/workspaces/{workspace_id}/members"))
+
+    def update_workspace_member(self, workspace_id: str, req: dict) -> dict:
+        validate_safe_id(workspace_id, "workspace_id")
+        if not isinstance(req, dict) or not req:
+            raise WorkspaceError("更新成员失败: 请求体不能为空")
+        user_id = req.get("user_id")
+        if not user_id or not str(user_id).strip():
+            raise WorkspaceError(
+                "更新成员失败: user_id 不能为空或纯空格",
+                "请通过 --user-id 指定有效的用户ID"
+            )
+        if not req.get("role_ids"):
+            raise WorkspaceError(
+                "更新成员失败: 缺少 role_ids 参数",
+                "请通过 --role-ids 指定角色ID列表(逗号分隔)"
+            )
+        return self._client.put(self._url(f"/v1/workspaces/{workspace_id}/members"), json=req)
+
+    def delete_workspace_members(self, workspace_id: str, user_ids: list[str]) -> Any:
+        validate_safe_id(workspace_id, "workspace_id")
+        if not user_ids:
+            raise WorkspaceError(
+                "删除成员失败: user_ids 不能为空",
+                "请通过 --user-ids 指定要删除的用户ID列表(逗号分隔)"
+            )
+        return self._client.delete(
+            self._url(f"/v1/workspaces/{workspace_id}/members"),
+            params={"user_ids": user_ids},
+        )
+
+    def get_workspace_overview(self) -> dict:
+        return self._client.get(self._url("/v1/workspaces/statistic/overview"))

hw_cloudrobo_workspace-0.2.0/src/cloudrobo_workspace/config.py

@@ -0,0 +1,32 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026-2026. All rights reserved.
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+WORKSPACE_CONFIG_DIR = Path.home() / ".cloudrobo"
+WORKSPACE_PATH = WORKSPACE_CONFIG_DIR / "workspace.json"
+
+
+def load_workspace() -> dict[str, Any]:
+    if WORKSPACE_PATH.exists():
+        try:
+            return json.loads(WORKSPACE_PATH.read_text(encoding="utf-8"))
+        except Exception as e:
+            logger.warning("Failed to load workspace.json: %s", e)
+    return {}
+
+
+def save_workspace(data: dict[str, Any]) -> None:
+    WORKSPACE_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    WORKSPACE_PATH.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+    try:
+        os.chmod(WORKSPACE_PATH, 0o600)
+    except OSError:
+        pass

hw_cloudrobo_workspace-0.2.0/src/hw_cloudrobo_workspace.egg-info/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: hw-cloudrobo-workspace
+Version: 0.2.0
+Summary: CloudRobo Workspace SDK and CLI
+Author-email: Huawei Cloud CloudRobo Team <hwcloudrobo@huawei.com>
+License: Apache-2.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Requires-Dist: click>=8.0
+Requires-Dist: hw-cloudrobo-core>=0.1.0

hw_cloudrobo_workspace-0.2.0/src/hw_cloudrobo_workspace.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/cloudrobo_workspace/__init__.py
+src/cloudrobo_workspace/cli.py
+src/cloudrobo_workspace/client.py
+src/cloudrobo_workspace/config.py
+src/hw_cloudrobo_workspace.egg-info/PKG-INFO
+src/hw_cloudrobo_workspace.egg-info/SOURCES.txt
+src/hw_cloudrobo_workspace.egg-info/dependency_links.txt
+src/hw_cloudrobo_workspace.egg-info/entry_points.txt
+src/hw_cloudrobo_workspace.egg-info/requires.txt
+src/hw_cloudrobo_workspace.egg-info/top_level.txt
+tests/test_workspace_client.py

hw_cloudrobo_workspace-0.2.0/src/hw_cloudrobo_workspace.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hw_cloudrobo_workspace-0.2.0/src/hw_cloudrobo_workspace.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[cloudrobo.groups]
+workspace = cloudrobo_workspace.cli:workspace

hw_cloudrobo_workspace-0.2.0/src/hw_cloudrobo_workspace.egg-info/requires.txt

@@ -0,0 +1,2 @@
+click>=8.0
+hw-cloudrobo-core>=0.1.0

hw_cloudrobo_workspace-0.2.0/src/hw_cloudrobo_workspace.egg-info/top_level.txt

@@ -0,0 +1 @@
+cloudrobo_workspace

hw_cloudrobo_workspace-0.2.0/tests/test_workspace_client.py

@@ -0,0 +1,593 @@
+import json
+import pytest
+from unittest.mock import MagicMock, patch, mock_open
+
+from cloudrobo_core.sdk import Config, HttpClient
+from cloudrobo_core.sdk.exceptions import PathTraversalError
+from cloudrobo_workspace.client import WorkspaceClient, WorkspaceError, is_debug_mode
+
+
+def _make_mock_client():
+    mock = MagicMock(spec=HttpClient)
+    mock.config = MagicMock(spec=Config)
+    mock.config.get_endpoint.side_effect = lambda svc: f"https://api.example.com/{svc}"
+    mock.config.project_id = "proj1"
+    return mock
+
+
+class TestWorkspaceClient:
+    def setup_method(self):
+        self.mock_http = _make_mock_client()
+        self.client = WorkspaceClient(self.mock_http)
+
+    def test_create_workspace(self):
+        self.mock_http.post.return_value = {"workspace": {"workspace_id": "ws1"}}
+        result = self.client.create_workspace({"name": "my-workspace", "default_obs_path": "obs://bucket/path"})
+        assert result["workspace"]["workspace_id"] == "ws1"
+        self.mock_http.post.assert_called_once()
+        args, kwargs = self.mock_http.post.call_args
+        assert args[0].endswith("/v1/workspaces")
+
+    def test_list_workspaces(self):
+        self.mock_http.get.return_value = {"workspaces": [], "page_info": {"total": 0}}
+        result = self.client.list_workspaces()
+        assert "workspaces" in result
+
+    def test_list_workspaces_with_pagination(self):
+        self.mock_http.get.return_value = {"workspaces": [], "page_info": {"total": 0}}
+        result = self.client.list_workspaces(limit=10, offset=0)
+        assert "workspaces" in result
+        args, kwargs = self.mock_http.get.call_args
+        assert kwargs.get("params", {}).get("limit") == 10
+        assert kwargs.get("params", {}).get("offset") == 0
+
+    def test_show_workspace(self):
+        self.mock_http.get.return_value = {"workspace": {"workspace_id": "ws1", "name": "my-workspace"}}
+        result = self.client.show_workspace("ws1")
+        assert result["workspace"]["workspace_id"] == "ws1"
+
+    def test_update_workspace(self):
+        self.mock_http.put.return_value = {"workspace": {"workspace_id": "ws1", "name": "updated"}}
+        result = self.client.update_workspace("ws1", {"name": "updated"})
+        assert result["workspace"]["name"] == "updated"
+        args, kwargs = self.mock_http.put.call_args
+        assert args[0].endswith("/v1/workspaces/ws1")
+
+    def test_delete_workspace(self):
+        self.mock_http.delete.return_value = ""
+        self.client.delete_workspace("ws1")
+        self.mock_http.delete.assert_called_once()
+        args, _ = self.mock_http.delete.call_args
+        assert args[0].endswith("/v1/workspaces/ws1")
+
+    def test_add_workspace_members(self):
+        self.mock_http.post.return_value = {"members": []}
+        result = self.client.add_workspace_members("ws1", {"member_list": [{"user_id": "u1", "role_ids": ["r1"]}]})
+        assert "members" in result
+        args, kwargs = self.mock_http.post.call_args
+        assert args[0].endswith("/v1/workspaces/ws1/members")
+
+    def test_list_workspace_members(self):
+        self.mock_http.get.return_value = {"members": []}
+        result = self.client.list_workspace_members("ws1")
+        assert "members" in result
+
+    def test_update_workspace_member(self):
+        self.mock_http.put.return_value = {"member": {"user_id": "u1"}}
+        result = self.client.update_workspace_member("ws1", {"user_id": "u1", "role_ids": ["r1"]})
+        assert result["member"]["user_id"] == "u1"
+        args, kwargs = self.mock_http.put.call_args
+        assert args[0].endswith("/v1/workspaces/ws1/members")
+
+    def test_delete_workspace_members(self):
+        self.mock_http.delete.return_value = ""
+        self.client.delete_workspace_members("ws1", ["u1", "u2"])
+        self.mock_http.delete.assert_called_once()
+        args, kwargs = self.mock_http.delete.call_args
+        assert args[0].endswith("/v1/workspaces/ws1/members")
+        assert kwargs.get("params", {}).get("user_ids") == ["u1", "u2"]
+
+    def test_get_workspace_overview(self):
+        self.mock_http.get.return_value = {
+            "workspace_capacity": 10,
+            "workspace_used": 3,
+            "workspace_available": 7,
+            "member_capacity": 100,
+            "member_count": 15,
+        }
+        result = self.client.get_workspace_overview()
+        assert result["workspace_capacity"] == 10
+        assert result["member_count"] == 15
+        args, _ = self.mock_http.get.call_args
+        assert args[0].endswith("/v1/workspaces/statistic/overview")
+
+    def test_update_workspace_with_bind_obs_policy(self):
+        self.mock_http.put.return_value = {"workspace": {"workspace_id": "ws1"}}
+        result = self.client.update_workspace("ws1", {"bind_obs_policy": True})
+        assert result["workspace"]["workspace_id"] == "ws1"
+        args, kwargs = self.mock_http.put.call_args
+        assert kwargs["json"] == {"bind_obs_policy": True}
+
+    def test_show_workspace_with_obs_status(self):
+        self.mock_http.get.return_value = {
+            "workspace": {"workspace_id": "ws1", "obs_status": "AVAILABLE"}
+        }
+        result = self.client.show_workspace("ws1")
+        assert result["workspace"]["obs_status"] == "AVAILABLE"
+
+    def test_list_workspaces_with_obs_status(self):
+        self.mock_http.get.return_value = {
+            "workspaces": [
+                {"workspace_id": "ws1", "obs_status": "AVAILABLE"},
+                {"workspace_id": "ws2", "obs_status": "NOT_EXIST"},
+            ],
+            "page_info": {"total": 2},
+        }
+        result = self.client.list_workspaces()
+        assert result["workspaces"][0]["obs_status"] == "AVAILABLE"
+        assert result["workspaces"][1]["obs_status"] == "NOT_EXIST"
+
+    def test_show_workspace_without_obs_status(self):
+        self.mock_http.get.return_value = {
+            "workspace": {"workspace_id": "ws1", "name": "my-workspace"}
+        }
+        result = self.client.show_workspace("ws1")
+        assert "obs_status" not in result["workspace"]
+        assert result["workspace"]["name"] == "my-workspace"
+
+
+class TestWorkspaceConfig:
+    @patch("cloudrobo_workspace.config.WORKSPACE_PATH")
+    def test_load_workspace(self, mock_path):
+        from cloudrobo_workspace.config import load_workspace
+        mock_path.exists.return_value = True
+        mock_path.read_text.return_value = json.dumps({
+            "workspace_id": "ws1",
+            "name": "test",
+            "asset_catalog_id": "cat1",
+            "default_obs_path": "obs://bucket/path",
+        })
+        result = load_workspace()
+        assert result["workspace_id"] == "ws1"
+        assert result["name"] == "test"
+
+    @patch("cloudrobo_workspace.config.WORKSPACE_PATH")
+    def test_load_workspace_file_not_exists(self, mock_path):
+        from cloudrobo_workspace.config import load_workspace
+        mock_path.exists.return_value = False
+        result = load_workspace()
+        assert result == {}
+
+    @patch("cloudrobo_workspace.config.WORKSPACE_PATH")
+    def test_load_workspace_invalid_json(self, mock_path):
+        from cloudrobo_workspace.config import load_workspace
+        mock_path.exists.return_value = True
+        mock_path.read_text.return_value = "invalid json"
+        result = load_workspace()
+        assert result == {}
+
+    @patch("cloudrobo_workspace.config.WORKSPACE_PATH")
+    @patch("cloudrobo_workspace.config.WORKSPACE_CONFIG_DIR")
+    def test_save_workspace(self, mock_dir, mock_path):
+        import os
+        from cloudrobo_workspace.config import save_workspace
+        mock_dir.mkdir = MagicMock()
+        mock_path.write_text = MagicMock()
+        with patch("os.chmod"):
+            save_workspace({
+                "workspace_id": "ws1",
+                "name": "test",
+                "asset_catalog_id": "cat1",
+                "default_obs_path": "obs://bucket/path",
+            })
+        mock_dir.mkdir.assert_called_once_with(parents=True, exist_ok=True)
+        mock_path.write_text.assert_called_once()
+        written = mock_path.write_text.call_args[0][0]
+        parsed = json.loads(written)
+        assert parsed["workspace_id"] == "ws1"
+        assert parsed["name"] == "test"
+
+
+class TestWorkspaceClientValidation:
+    def setup_method(self):
+        self.mock_http = _make_mock_client()
+        self.client = WorkspaceClient(self.mock_http)
+
+    def test_show_workspace_rejects_empty_id(self):
+        with pytest.raises(PathTraversalError, match="workspace_id"):
+            self.client.show_workspace("")
+
+    def test_show_workspace_rejects_none_id(self):
+        with pytest.raises(PathTraversalError, match="workspace_id"):
+            self.client.show_workspace(None)
+
+    def test_show_workspace_rejects_path_traversal(self):
+        for bad in ["../ws1", "ws/1", "ws\\1"]:
+            with pytest.raises(PathTraversalError, match="path traversal"):
+                self.client.show_workspace(bad)
+
+    def test_update_workspace_rejects_empty_id(self):
+        with pytest.raises(PathTraversalError):
+            self.client.update_workspace("", {"name": "x"})
+
+    def test_delete_workspace_rejects_path_traversal(self):
+        with pytest.raises(PathTraversalError):
+            self.client.delete_workspace("../etc")
+
+    def test_list_workspace_members_rejects_empty_id(self):
+        with pytest.raises(PathTraversalError, match="workspace_id"):
+            self.client.list_workspace_members("")
+
+    def test_add_workspace_members_rejects_empty_id(self):
+        with pytest.raises(PathTraversalError):
+            self.client.add_workspace_members("", {"member_list": []})
+
+    def test_add_workspace_members_rejects_empty_member_list(self):
+        with pytest.raises(WorkspaceError, match="member_list"):
+            self.client.add_workspace_members("ws1", {"foo": "bar"})
+
+    def test_add_workspace_members_rejects_none_req(self):
+        with pytest.raises(WorkspaceError, match="请求体不能为空"):
+            self.client.add_workspace_members("ws1", None)
+
+    def test_add_workspace_members_rejects_non_list_member_list(self):
+        with pytest.raises(WorkspaceError, match="member_list 必须为列表"):
+            self.client.add_workspace_members("ws1", {"member_list": "not-a-list"})
+
+    def test_update_workspace_member_rejects_empty_id(self):
+        with pytest.raises(PathTraversalError):
+            self.client.update_workspace_member("", {"user_id": "u1", "role_ids": ["r1"]})
+
+    def test_update_workspace_member_requires_user_id(self):
+        with pytest.raises(WorkspaceError, match="user_id"):
+            self.client.update_workspace_member("ws1", {"role_ids": ["r1"]})
+
+    def test_update_workspace_member_rejects_whitespace_user_id(self):
+        with pytest.raises(WorkspaceError, match="user_id 不能为空或纯空格"):
+            self.client.update_workspace_member("ws1", {"user_id": "   ", "role_ids": ["r1"]})
+
+    def test_update_workspace_member_requires_role_ids(self):
+        with pytest.raises(WorkspaceError, match="role_ids"):
+            self.client.update_workspace_member("ws1", {"user_id": "u1"})
+
+    def test_delete_workspace_members_rejects_empty_id(self):
+        with pytest.raises(PathTraversalError):
+            self.client.delete_workspace_members("", ["u1"])
+
+    def test_delete_workspace_members_rejects_empty_list(self):
+        with pytest.raises(WorkspaceError, match="user_ids"):
+            self.client.delete_workspace_members("ws1", [])
+
+    def test_create_workspace_rejects_empty_req(self):
+        with pytest.raises(WorkspaceError, match="请求体不能为空"):
+            self.client.create_workspace({})
+
+    def test_create_workspace_rejects_none_req(self):
+        with pytest.raises(WorkspaceError, match="请求体不能为空"):
+            self.client.create_workspace(None)
+
+    def test_create_workspace_requires_name(self):
+        with pytest.raises(WorkspaceError, match="name"):
+            self.client.create_workspace({"default_obs_path": "obs://b/p"})
+
+    def test_create_workspace_requires_default_obs_path(self):
+        with pytest.raises(WorkspaceError, match="default_obs_path"):
+            self.client.create_workspace({"name": "n"})
+
+    def test_update_workspace_rejects_empty_req(self):
+        with pytest.raises(WorkspaceError, match="请求体不能为空"):
+            self.client.update_workspace("ws1", {})
+
+    def test_update_workspace_rejects_none_req(self):
+        with pytest.raises(WorkspaceError, match="请求体不能为空"):
+            self.client.update_workspace("ws1", None)
+
+    def test_valid_id_not_blocked(self):
+        self.mock_http.get.return_value = {"workspace": {"workspace_id": "ws-001"}}
+        result = self.client.show_workspace("ws-001")
+        assert result["workspace"]["workspace_id"] == "ws-001"
+        self.mock_http.get.assert_called_once()
+
+    def test_workspace_error_with_suggestion(self):
+        try:
+            self.client.create_workspace({"name": "n"})
+        except WorkspaceError as e:
+            assert e.suggestion
+            assert "建议" in e.get_user_message()
+        else:
+            pytest.fail("Should have raised WorkspaceError")
+
+    def test_is_debug_mode_importable(self):
+        assert callable(is_debug_mode)
+
+    def test_create_workspace_rejects_whitespace_name(self):
+        with pytest.raises(WorkspaceError, match="name 不能为空或纯空格"):
+            self.client.create_workspace({"name": "   ", "default_obs_path": "obs://b/p"})
+
+    def test_create_workspace_rejects_whitespace_obs_path(self):
+        with pytest.raises(WorkspaceError, match="default_obs_path 不能为空或纯空格"):
+            self.client.create_workspace({"name": "n", "default_obs_path": "   "})
+
+    def test_update_workspace_rejects_whitespace_name(self):
+        with pytest.raises(WorkspaceError, match="name 不能为空或纯空格"):
+            self.client.update_workspace("ws1", {"name": "   "})
+
+
+class TestWorkspaceCLI:
+    def _patch_get_client(self, monkeypatch, http_mock=None):
+        if http_mock is None:
+            http_mock = _make_mock_client()
+        client = WorkspaceClient(http_mock)
+
+        def _fake_get_client(ctx, cls):
+            return client
+
+        monkeypatch.setattr("cloudrobo_workspace.cli.get_client", _fake_get_client)
+        return client
+
+    def test_show_command_friendly_error_on_path_traversal(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        self._patch_get_client(monkeypatch)
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["show", "--workspace-id", "../etc"])
+        assert result.exit_code == 1
+        assert "path traversal" in result.output
+
+    def test_show_command_friendly_error_on_not_found(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        from cloudrobo_core.sdk.exceptions import ResourceNotFoundError
+        client = self._patch_get_client(monkeypatch)
+        client._client.get.side_effect = ResourceNotFoundError("workspace not found")
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["show", "--workspace-id", "ws-nope"])
+        assert result.exit_code == 1
+        assert "不存在" in result.output
+
+    def test_list_command_rejects_negative_limit(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        self._patch_get_client(monkeypatch)
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["list", "--limit", "-1"])
+        assert result.exit_code == 2
+
+    def test_list_command_rejects_negative_offset(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        self._patch_get_client(monkeypatch)
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["list", "--offset", "-5"])
+        assert result.exit_code == 2
+
+    def test_create_command_rejects_invalid_json(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        self._patch_get_client(monkeypatch)
+        runner = CliRunner()
+        result = runner.invoke(
+            workspace,
+            ["create", "--name", "n", "--default-obs-path", "obs://b/p", "--member-list", "{bad json"],
+        )
+        assert result.exit_code == 2
+        assert "JSON" in result.output
+
+    def test_update_command_rejects_no_fields(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        self._patch_get_client(monkeypatch)
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["update", "--workspace-id", "ws1"])
+        assert result.exit_code == 2
+        assert "更新字段" in result.output
+
+    def test_use_command_friendly_error_on_not_found(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        from cloudrobo_core.sdk.exceptions import ResourceNotFoundError
+        client = self._patch_get_client(monkeypatch)
+        client._client.get.side_effect = ResourceNotFoundError("not found")
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["use", "--workspace-id", "ws-nope"])
+        assert result.exit_code == 1
+        assert "不存在" in result.output
+
+    def test_service_error_friendly_output(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        from cloudrobo_core.sdk.exceptions import ServiceError
+        client = self._patch_get_client(monkeypatch)
+        client._client.get.side_effect = ServiceError("Server error 500: boom", status_code=500)
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["show", "--workspace-id", "ws1"])
+        assert result.exit_code == 1
+        assert "错误" in result.output
+
+    def test_workspace_error_shows_suggestion(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        self._patch_get_client(monkeypatch)
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["add-members", "--workspace-id", "ws1", "--member-list", "[]"])
+        assert result.exit_code == 1
+        assert "建议" in result.output
+        assert "--member-list" in result.output
+
+    def test_create_command_rejects_whitespace_name(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        self._patch_get_client(monkeypatch)
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["create", "--name", "   ", "--default-obs-path", "obs://test"])
+        assert result.exit_code == 1
+        assert "name 不能为空或纯空格" in result.output
+
+    def test_create_command_friendly_error_on_conflict(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        from cloudrobo_core.sdk.exceptions import ResourceConflictError
+        client = self._patch_get_client(monkeypatch)
+        client._client.post.side_effect = ResourceConflictError("workspace name already exists")
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["create", "--name", "dup", "--default-obs-path", "obs://b/p"])
+        assert result.exit_code == 1
+        assert "已存在" in result.output
+
+    def test_update_command_friendly_error_on_not_found(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        from cloudrobo_core.sdk.exceptions import ResourceNotFoundError
+        client = self._patch_get_client(monkeypatch)
+        client._client.put.side_effect = ResourceNotFoundError("workspace not found")
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["update", "--workspace-id", "ws-nope", "--name", "new"])
+        assert result.exit_code == 1
+        assert "不存在" in result.output
+
+    def test_update_command_friendly_error_on_conflict(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        from cloudrobo_core.sdk.exceptions import ResourceConflictError
+        client = self._patch_get_client(monkeypatch)
+        client._client.put.side_effect = ResourceConflictError("name conflict")
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["update", "--workspace-id", "ws1", "--name", "dup-name"])
+        assert result.exit_code == 1
+        assert "已被" in result.output
+
+    def test_delete_command_friendly_error_on_not_found(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        from cloudrobo_core.sdk.exceptions import ResourceNotFoundError
+        client = self._patch_get_client(monkeypatch)
+        client._client.delete.side_effect = ResourceNotFoundError("not found")
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["delete", "--workspace-id", "ws-nope"])
+        assert result.exit_code == 1
+        assert "不存在" in result.output
+
+    def test_list_members_command_friendly_error_on_not_found(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        from cloudrobo_core.sdk.exceptions import ResourceNotFoundError
+        client = self._patch_get_client(monkeypatch)
+        client._client.get.side_effect = ResourceNotFoundError("not found")
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["list-members", "--workspace-id", "ws-nope"])
+        assert result.exit_code == 1
+        assert "不存在" in result.output
+
+    def test_add_members_command_friendly_error_on_not_found(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        from cloudrobo_core.sdk.exceptions import ResourceNotFoundError
+        client = self._patch_get_client(monkeypatch)
+        client._client.post.side_effect = ResourceNotFoundError("not found")
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["add-members", "--workspace-id", "ws-nope", "--member-list", '[{"user_id":"u1","role_ids":["r1"]}]'])
+        assert result.exit_code == 1
+        assert "不存在" in result.output
+
+    def test_add_members_command_friendly_error_on_conflict(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        from cloudrobo_core.sdk.exceptions import ResourceConflictError
+        client = self._patch_get_client(monkeypatch)
+        client._client.post.side_effect = ResourceConflictError("member already exists")
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["add-members", "--workspace-id", "ws1", "--member-list", '[{"user_id":"u1","role_ids":["r1"]}]'])
+        assert result.exit_code == 1
+        assert "已存在" in result.output or "部分成员" in result.output
+
+    def test_update_member_command_friendly_error_on_not_found(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        from cloudrobo_core.sdk.exceptions import ResourceNotFoundError
+        client = self._patch_get_client(monkeypatch)
+        client._client.put.side_effect = ResourceNotFoundError("not found")
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["update-member", "--workspace-id", "ws-nope", "--user-id", "u1", "--role-ids", "r1"])
+        assert result.exit_code == 1
+        assert "不存在" in result.output
+
+    def test_delete_members_command_friendly_error_on_not_found(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        from cloudrobo_core.sdk.exceptions import ResourceNotFoundError
+        client = self._patch_get_client(monkeypatch)
+        client._client.delete.side_effect = ResourceNotFoundError("not found")
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["delete-members", "--workspace-id", "ws-nope", "--user-ids", "u1"])
+        assert result.exit_code == 1
+        assert "不存在" in result.output
+
+    def test_create_command_success_output(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        client = self._patch_get_client(monkeypatch)
+        client._client.post.return_value = {"workspace_id": "ws-new-123"}
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["create", "--name", "test-ws", "--default-obs-path", "obs://bucket/path"])
+        assert result.exit_code == 0
+        assert "已创建工作空间: ws-new-123" in result.output
+
+    def test_create_command_success_output_without_id(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        client = self._patch_get_client(monkeypatch)
+        client._client.post.return_value = {}
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["create", "--name", "test-ws", "--default-obs-path", "obs://bucket/path"])
+        assert result.exit_code == 0
+        assert "已创建工作空间: test-ws" in result.output
+
+    def test_update_command_success_output(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        client = self._patch_get_client(monkeypatch)
+        client._client.put.return_value = {}
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["update", "--workspace-id", "ws1", "--name", "new-name"])
+        assert result.exit_code == 0
+        assert "已更新工作空间: ws1" in result.output
+
+    def test_delete_command_success_output(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        client = self._patch_get_client(monkeypatch)
+        client._client.delete.return_value = ""
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["delete", "--workspace-id", "ws1"])
+        assert result.exit_code == 0
+        assert "已删除工作空间: ws1" in result.output
+
+    def test_add_members_command_success_output(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        client = self._patch_get_client(monkeypatch)
+        client._client.post.return_value = {}
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["add-members", "--workspace-id", "ws1", "--member-list", '[{"user_id":"u1","role_ids":["r1"]},{"user_id":"u2","role_ids":["r2"]}]'])
+        assert result.exit_code == 0
+        assert "已添加 2 个成员" in result.output
+
+    def test_update_member_command_success_output(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        client = self._patch_get_client(monkeypatch)
+        client._client.put.return_value = {}
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["update-member", "--workspace-id", "ws1", "--user-id", "u1", "--role-ids", "r1,r2"])
+        assert result.exit_code == 0
+        assert "已更新成员 u1 的角色" in result.output
+
+    def test_delete_members_command_success_output(self, monkeypatch):
+        from click.testing import CliRunner
+        from cloudrobo_workspace.cli import workspace
+        client = self._patch_get_client(monkeypatch)
+        client._client.delete.return_value = ""
+        runner = CliRunner()
+        result = runner.invoke(workspace, ["delete-members", "--workspace-id", "ws1", "--user-ids", "u1,u2,u3"])
+        assert result.exit_code == 0
+        assert "已删除 3 个成员" in result.output