feat: manually mirror opencoze's code from bytedance

Change-Id: I09a73aadda978ad9511264a756b2ce51f5761adf

frontend/packages/common/auth/__tests__/project/calc-permission.test.ts

@@ -0,0 +1,393 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+import { describe, it, expect } from 'vitest';
+import { SpaceRoleType, SpaceType } from '@coze-arch/idl/developer_api';
+
+import {
+  ProjectRoleType,
+  EProjectPermission,
+} from '../../src/project/constants';
+import { calcPermission } from '../../src/project/calc-permission';
+
+describe('Project Calc Permission', () => {
+  describe('个人空间权限', () => {
+    it('应该为个人空间返回正确的权限', () => {
+      const params = {
+        projectRoles: [],
+        spaceRoles: [],
+        spaceType: SpaceType.Personal,
+      };
+
+      // 个人空间应该有查看权限
+      expect(calcPermission(EProjectPermission.View, params)).toBe(true);
+
+      // 个人空间应该有编辑信息权限
+      expect(calcPermission(EProjectPermission.EDIT_INFO, params)).toBe(true);
+
+      // 个人空间应该有删除权限
+      expect(calcPermission(EProjectPermission.DELETE, params)).toBe(true);
+
+      // 个人空间应该有发布权限
+      expect(calcPermission(EProjectPermission.PUBLISH, params)).toBe(true);
+
+      // 个人空间应该有创建资源权限
+      expect(calcPermission(EProjectPermission.CREATE_RESOURCE, params)).toBe(
+        true,
+      );
+
+      // 个人空间应该有复制资源权限
+      expect(calcPermission(EProjectPermission.COPY_RESOURCE, params)).toBe(
+        true,
+      );
+
+      // 个人空间应该有复制项目权限
+      expect(calcPermission(EProjectPermission.COPY, params)).toBe(true);
+
+      // 个人空间应该有测试运行插件权限
+      expect(calcPermission(EProjectPermission.TEST_RUN_PLUGIN, params)).toBe(
+        true,
+      );
+
+      // 个人空间应该有测试运行工作流权限
+      expect(calcPermission(EProjectPermission.TEST_RUN_WORKFLOW, params)).toBe(
+        true,
+      );
+    });
+
+    it('应该为个人空间返回正确的无效权限', () => {
+      const params = {
+        projectRoles: [],
+        spaceRoles: [],
+        spaceType: SpaceType.Personal,
+      };
+
+      // 个人空间不应该有添加协作者权限
+      expect(calcPermission(EProjectPermission.ADD_COLLABORATOR, params)).toBe(
+        false,
+      );
+
+      // 个人空间不应该有删除协作者权限
+      expect(
+        calcPermission(EProjectPermission.DELETE_COLLABORATOR, params),
+      ).toBe(false);
+    });
+  });
+
+  describe('团队空间项目角色权限', () => {
+    it('应该为项目所有者角色返回正确的权限', () => {
+      const params = {
+        projectRoles: [ProjectRoleType.Owner],
+        spaceRoles: [],
+        spaceType: SpaceType.Team,
+      };
+
+      // 项目所有者应该有查看权限
+      expect(calcPermission(EProjectPermission.View, params)).toBe(true);
+
+      // 项目所有者应该有编辑信息权限
+      expect(calcPermission(EProjectPermission.EDIT_INFO, params)).toBe(true);
+
+      // 项目所有者应该有删除权限
+      expect(calcPermission(EProjectPermission.DELETE, params)).toBe(true);
+
+      // 项目所有者应该有发布权限
+      expect(calcPermission(EProjectPermission.PUBLISH, params)).toBe(true);
+
+      // 项目所有者应该有创建资源权限
+      expect(calcPermission(EProjectPermission.CREATE_RESOURCE, params)).toBe(
+        true,
+      );
+
+      // 项目所有者应该有复制资源权限
+      expect(calcPermission(EProjectPermission.COPY_RESOURCE, params)).toBe(
+        true,
+      );
+
+      // 项目所有者应该有复制项目权限
+      expect(calcPermission(EProjectPermission.COPY, params)).toBe(true);
+
+      // 项目所有者应该有测试运行插件权限
+      expect(calcPermission(EProjectPermission.TEST_RUN_PLUGIN, params)).toBe(
+        true,
+      );
+
+      // 项目所有者应该有测试运行工作流权限
+      expect(calcPermission(EProjectPermission.TEST_RUN_WORKFLOW, params)).toBe(
+        true,
+      );
+
+      // 项目所有者应该有添加协作者权限
+      expect(calcPermission(EProjectPermission.ADD_COLLABORATOR, params)).toBe(
+        true,
+      );
+
+      // 项目所有者应该有删除协作者权限
+      expect(
+        calcPermission(EProjectPermission.DELETE_COLLABORATOR, params),
+      ).toBe(true);
+    });
+
+    it('应该为项目编辑者角色返回正确的权限', () => {
+      const params = {
+        projectRoles: [ProjectRoleType.Editor],
+        spaceRoles: [],
+        spaceType: SpaceType.Team,
+      };
+
+      // 项目编辑者应该有查看权限
+      expect(calcPermission(EProjectPermission.View, params)).toBe(true);
+
+      // 项目编辑者应该有编辑信息权限
+      expect(calcPermission(EProjectPermission.EDIT_INFO, params)).toBe(true);
+
+      // 项目编辑者应该有创建资源权限
+      expect(calcPermission(EProjectPermission.CREATE_RESOURCE, params)).toBe(
+        true,
+      );
+
+      // 项目编辑者应该有复制资源权限
+      expect(calcPermission(EProjectPermission.COPY_RESOURCE, params)).toBe(
+        true,
+      );
+
+      // 项目编辑者应该有复制项目权限
+      expect(calcPermission(EProjectPermission.COPY, params)).toBe(true);
+
+      // 项目编辑者应该有测试运行插件权限
+      expect(calcPermission(EProjectPermission.TEST_RUN_PLUGIN, params)).toBe(
+        true,
+      );
+
+      // 项目编辑者应该有测试运行工作流权限
+      expect(calcPermission(EProjectPermission.TEST_RUN_WORKFLOW, params)).toBe(
+        true,
+      );
+
+      // 项目编辑者应该有添加协作者权限
+      expect(calcPermission(EProjectPermission.ADD_COLLABORATOR, params)).toBe(
+        true,
+      );
+
+      // 项目编辑者不应该有删除权限
+      expect(calcPermission(EProjectPermission.DELETE, params)).toBe(false);
+
+      // 项目编辑者不应该有发布权限
+      expect(calcPermission(EProjectPermission.PUBLISH, params)).toBe(false);
+
+      // 项目编辑者不应该有删除协作者权限
+      expect(
+        calcPermission(EProjectPermission.DELETE_COLLABORATOR, params),
+      ).toBe(false);
+    });
+  });
+
+  describe('团队空间角色权限', () => {
+    it('应该为空间成员角色返回正确的权限', () => {
+      const params = {
+        projectRoles: [],
+        spaceRoles: [SpaceRoleType.Member],
+        spaceType: SpaceType.Team,
+      };
+
+      // 空间成员应该有查看权限
+      expect(calcPermission(EProjectPermission.View, params)).toBe(true);
+
+      // 空间成员应该有复制项目权限
+      expect(calcPermission(EProjectPermission.COPY, params)).toBe(true);
+
+      // 空间成员应该有测试运行工作流权限
+      expect(calcPermission(EProjectPermission.TEST_RUN_WORKFLOW, params)).toBe(
+        true,
+      );
+
+      // 空间成员不应该有编辑信息权限
+      expect(calcPermission(EProjectPermission.EDIT_INFO, params)).toBe(false);
+
+      // 空间成员不应该有删除权限
+      expect(calcPermission(EProjectPermission.DELETE, params)).toBe(false);
+
+      // 空间成员不应该有发布权限
+      expect(calcPermission(EProjectPermission.PUBLISH, params)).toBe(false);
+
+      // 空间成员不应该有创建资源权限
+      expect(calcPermission(EProjectPermission.CREATE_RESOURCE, params)).toBe(
+        false,
+      );
+
+      // 空间成员不应该有复制资源权限
+      expect(calcPermission(EProjectPermission.COPY_RESOURCE, params)).toBe(
+        false,
+      );
+
+      // 空间成员不应该有测试运行插件权限
+      expect(calcPermission(EProjectPermission.TEST_RUN_PLUGIN, params)).toBe(
+        false,
+      );
+
+      // 空间成员不应该有添加协作者权限
+      expect(calcPermission(EProjectPermission.ADD_COLLABORATOR, params)).toBe(
+        false,
+      );
+
+      // 空间成员不应该有删除协作者权限
+      expect(
+        calcPermission(EProjectPermission.DELETE_COLLABORATOR, params),
+      ).toBe(false);
+    });
+
+    it('应该为空间所有者角色返回正确的权限', () => {
+      const params = {
+        projectRoles: [],
+        spaceRoles: [SpaceRoleType.Owner],
+        spaceType: SpaceType.Team,
+      };
+
+      // 空间所有者应该有查看权限
+      expect(calcPermission(EProjectPermission.View, params)).toBe(true);
+
+      // 空间所有者应该有复制项目权限
+      expect(calcPermission(EProjectPermission.COPY, params)).toBe(true);
+
+      // 空间所有者应该有测试运行工作流权限
+      expect(calcPermission(EProjectPermission.TEST_RUN_WORKFLOW, params)).toBe(
+        true,
+      );
+    });
+
+    it('应该为空间管理员角色返回正确的权限', () => {
+      const params = {
+        projectRoles: [],
+        spaceRoles: [SpaceRoleType.Admin],
+        spaceType: SpaceType.Team,
+      };
+
+      // 空间管理员应该有查看权限
+      expect(calcPermission(EProjectPermission.View, params)).toBe(true);
+
+      // 空间管理员应该有复制项目权限
+      expect(calcPermission(EProjectPermission.COPY, params)).toBe(true);
+
+      // 空间管理员应该有测试运行工作流权限
+      expect(calcPermission(EProjectPermission.TEST_RUN_WORKFLOW, params)).toBe(
+        true,
+      );
+    });
+
+    it('应该为默认角色返回正确的权限', () => {
+      const params = {
+        projectRoles: [],
+        spaceRoles: [SpaceRoleType.Default],
+        spaceType: SpaceType.Team,
+      };
+
+      // 默认角色不应该有任何权限
+      expect(calcPermission(EProjectPermission.View, params)).toBe(false);
+      expect(calcPermission(EProjectPermission.EDIT_INFO, params)).toBe(false);
+      expect(calcPermission(EProjectPermission.DELETE, params)).toBe(false);
+      expect(calcPermission(EProjectPermission.PUBLISH, params)).toBe(false);
+      expect(calcPermission(EProjectPermission.CREATE_RESOURCE, params)).toBe(
+        false,
+      );
+      expect(calcPermission(EProjectPermission.COPY_RESOURCE, params)).toBe(
+        false,
+      );
+      expect(calcPermission(EProjectPermission.COPY, params)).toBe(false);
+      expect(calcPermission(EProjectPermission.TEST_RUN_PLUGIN, params)).toBe(
+        false,
+      );
+      expect(calcPermission(EProjectPermission.TEST_RUN_WORKFLOW, params)).toBe(
+        false,
+      );
+      expect(calcPermission(EProjectPermission.ADD_COLLABORATOR, params)).toBe(
+        false,
+      );
+      expect(
+        calcPermission(EProjectPermission.DELETE_COLLABORATOR, params),
+      ).toBe(false);
+    });
+  });
+
+  describe('混合角色权限', () => {
+    it('应该在同时拥有项目角色和空间角色时返回正确的权限', () => {
+      const params = {
+        projectRoles: [ProjectRoleType.Editor],
+        spaceRoles: [SpaceRoleType.Member],
+        spaceType: SpaceType.Team,
+      };
+
+      // 应该有项目编辑者的所有权限
+      expect(calcPermission(EProjectPermission.View, params)).toBe(true);
+      expect(calcPermission(EProjectPermission.EDIT_INFO, params)).toBe(true);
+      expect(calcPermission(EProjectPermission.CREATE_RESOURCE, params)).toBe(
+        true,
+      );
+      expect(calcPermission(EProjectPermission.COPY_RESOURCE, params)).toBe(
+        true,
+      );
+      expect(calcPermission(EProjectPermission.COPY, params)).toBe(true);
+      expect(calcPermission(EProjectPermission.TEST_RUN_PLUGIN, params)).toBe(
+        true,
+      );
+      expect(calcPermission(EProjectPermission.TEST_RUN_WORKFLOW, params)).toBe(
+        true,
+      );
+      expect(calcPermission(EProjectPermission.ADD_COLLABORATOR, params)).toBe(
+        true,
+      );
+
+      // 不应该有项目编辑者没有的权限
+      expect(calcPermission(EProjectPermission.DELETE, params)).toBe(false);
+      expect(calcPermission(EProjectPermission.PUBLISH, params)).toBe(false);
+      expect(
+        calcPermission(EProjectPermission.DELETE_COLLABORATOR, params),
+      ).toBe(false);
+    });
+
+    it('应该在没有有效角色时返回 false', () => {
+      const params = {
+        projectRoles: [],
+        spaceRoles: [],
+        spaceType: SpaceType.Team,
+      };
+
+      // 没有角色不应该有任何权限
+      expect(calcPermission(EProjectPermission.View, params)).toBe(false);
+      expect(calcPermission(EProjectPermission.EDIT_INFO, params)).toBe(false);
+      expect(calcPermission(EProjectPermission.DELETE, params)).toBe(false);
+      expect(calcPermission(EProjectPermission.PUBLISH, params)).toBe(false);
+      expect(calcPermission(EProjectPermission.CREATE_RESOURCE, params)).toBe(
+        false,
+      );
+      expect(calcPermission(EProjectPermission.COPY_RESOURCE, params)).toBe(
+        false,
+      );
+      expect(calcPermission(EProjectPermission.COPY, params)).toBe(false);
+      expect(calcPermission(EProjectPermission.TEST_RUN_PLUGIN, params)).toBe(
+        false,
+      );
+      expect(calcPermission(EProjectPermission.TEST_RUN_WORKFLOW, params)).toBe(
+        false,
+      );
+      expect(calcPermission(EProjectPermission.ADD_COLLABORATOR, params)).toBe(
+        false,
+      );
+      expect(
+        calcPermission(EProjectPermission.DELETE_COLLABORATOR, params),
+      ).toBe(false);
+    });
+  });
+});

frontend/packages/common/auth/__tests__/project/constants.test.ts

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+import { describe, it, expect } from 'vitest';
+
+import {
+  ProjectRoleType,
+  EProjectPermission,
+} from '../../src/project/constants';
+
+describe('Project Constants', () => {
+  describe('ProjectRoleType', () => {
+    it('应该定义所有必要的角色类型', () => {
+      // 验证所有角色类型都已定义
+      expect(ProjectRoleType.Owner).toBeDefined();
+      expect(ProjectRoleType.Editor).toBeDefined();
+
+      // 验证角色类型的值
+      expect(ProjectRoleType.Owner).toBe('owner');
+      expect(ProjectRoleType.Editor).toBe('editor');
+    });
+
+    it('应该包含正确数量的角色类型', () => {
+      // 验证角色类型的数量
+      const roleTypeCount = Object.keys(ProjectRoleType).filter(key =>
+        isNaN(Number(key)),
+      ).length;
+
+      expect(roleTypeCount).toBe(2); // Owner 和 Editor
+    });
+  });
+
+  describe('EProjectPermission', () => {
+    it('应该定义所有必要的权限点', () => {
+      // 验证所有权限点都已定义
+      expect(EProjectPermission.View).toBeDefined();
+      expect(EProjectPermission.EDIT_INFO).toBeDefined();
+      expect(EProjectPermission.DELETE).toBeDefined();
+      expect(EProjectPermission.PUBLISH).toBeDefined();
+      expect(EProjectPermission.CREATE_RESOURCE).toBeDefined();
+      expect(EProjectPermission.COPY_RESOURCE).toBeDefined();
+      expect(EProjectPermission.COPY).toBeDefined();
+      expect(EProjectPermission.TEST_RUN_PLUGIN).toBeDefined();
+      expect(EProjectPermission.TEST_RUN_WORKFLOW).toBeDefined();
+      expect(EProjectPermission.ADD_COLLABORATOR).toBeDefined();
+      expect(EProjectPermission.DELETE_COLLABORATOR).toBeDefined();
+    });
+
+    it('应该为每个权限点分配唯一的值', () => {
+      // 创建一个集合来存储所有权限点的值
+      const permissionValues = new Set();
+
+      // 获取所有权限点的值
+      Object.values(EProjectPermission)
+        .filter(value => typeof value === 'number')
+        .forEach(value => {
+          permissionValues.add(value);
+        });
+
+      // 验证权限点的数量与唯一值的数量相同
+      const numericKeys = Object.keys(EProjectPermission).filter(
+        key => !isNaN(Number(key)),
+      ).length;
+
+      expect(permissionValues.size).toBe(numericKeys);
+    });
+
+    it('应该包含正确数量的权限点', () => {
+      // 验证权限点的数量
+      const permissionCount = Object.keys(EProjectPermission).filter(key =>
+        isNaN(Number(key)),
+      ).length;
+
+      expect(permissionCount).toBe(12); // 11个权限点
+    });
+  });
+});

frontend/packages/common/auth/__tests__/project/index.test.ts

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+import { SpaceRoleType, SpaceType } from '@coze-arch/idl/developer_api';
+
+import {
+  EProjectPermission,
+  ProjectRoleType,
+} from '../../src/project/constants';
+import { calcPermission } from '../../src/project/calc-permission';
+
+describe('calcPermission', () => {
+  it('should return true for personal space with valid permission', () => {
+    const result = calcPermission(EProjectPermission.View, {
+      projectRoles: [],
+      spaceRoles: [],
+      spaceType: SpaceType.Personal,
+    });
+    expect(result).toBe(true);
+  });
+
+  it('should return false for personal space with invalid permission', () => {
+    const result = calcPermission(EProjectPermission.ADD_COLLABORATOR, {
+      projectRoles: [],
+      spaceRoles: [],
+      spaceType: SpaceType.Personal,
+    });
+    expect(result).toBe(false);
+  });
+
+  it('should return true for team space with project role permission', () => {
+    const result = calcPermission(EProjectPermission.DELETE, {
+      projectRoles: [ProjectRoleType.Owner],
+      spaceRoles: [],
+      spaceType: SpaceType.Team,
+    });
+    expect(result).toBe(true);
+  });
+
+  it('should return false for team space with invalid project role permission', () => {
+    const result = calcPermission(EProjectPermission.DELETE, {
+      projectRoles: [ProjectRoleType.Editor],
+      spaceRoles: [],
+      spaceType: SpaceType.Team,
+    });
+    expect(result).toBe(false);
+  });
+
+  it('should return true for team space with space role permission', () => {
+    const result = calcPermission(EProjectPermission.COPY, {
+      projectRoles: [],
+      spaceRoles: [SpaceRoleType.Member],
+      spaceType: SpaceType.Team,
+    });
+    expect(result).toBe(true);
+  });
+
+  it('should return false for team space with invalid space role permission', () => {
+    const result = calcPermission(EProjectPermission.DELETE, {
+      projectRoles: [],
+      spaceRoles: [SpaceRoleType.Member],
+      spaceType: SpaceType.Team,
+    });
+    expect(result).toBe(false);
+  });
+
+  it('should return true for team space with both project and space role permissions', () => {
+    const result = calcPermission(EProjectPermission.PUBLISH, {
+      projectRoles: [ProjectRoleType.Editor],
+      spaceRoles: [SpaceRoleType.Member],
+      spaceType: SpaceType.Team,
+    });
+    expect(result).toBe(false);
+  });
+
+  it('should return false for team space with no valid permissions', () => {
+    const result = calcPermission(EProjectPermission.DELETE, {
+      projectRoles: [ProjectRoleType.Editor],
+      spaceRoles: [SpaceRoleType.Default],
+      spaceType: SpaceType.Team,
+    });
+    expect(result).toBe(false);
+  });
+});

frontend/packages/common/auth/__tests__/project/store.test.ts

@@ -0,0 +1,190 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+import { describe, it, expect, beforeEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react-hooks';
+
+import { ProjectRoleType } from '../../src/project/constants';
+
+vi.stubGlobal('IS_DEV_MODE', true);
+
+describe('Project Auth Store', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.resetAllMocks();
+  });
+
+  describe('setRoles', () => {
+    it('应该正确设置项目角色', async () => {
+      const { useProjectAuthStore } = await vi.importActual(
+        '../../src/project/store',
+      );
+      const { result } = renderHook(() => useProjectAuthStore());
+      const projectId = 'test-project-1';
+      const roles = [ProjectRoleType.Owner];
+
+      await act(() => {
+        result.current.setRoles(projectId, roles);
+      });
+
+      expect(result.current.roles[projectId]).toEqual(roles);
+    });
+
+    it('应该能够更新已存在的项目角色', async () => {
+      const { useProjectAuthStore } = await vi.importActual(
+        '../../src/project/store',
+      );
+      const { result } = renderHook(() => useProjectAuthStore());
+      const projectId = 'test-project-1';
+      const initialRoles = [ProjectRoleType.Owner];
+      const updatedRoles = [ProjectRoleType.Editor];
+
+      await act(() => {
+        result.current.setRoles(projectId, initialRoles);
+      });
+      expect(result.current.roles[projectId]).toEqual(initialRoles);
+
+      await act(() => {
+        result.current.setRoles(projectId, updatedRoles);
+      });
+      expect(result.current.roles[projectId]).toEqual(updatedRoles);
+    });
+
+    it('应该能够同时管理多个项目的角色', async () => {
+      const { useProjectAuthStore } = await vi.importActual(
+        '../../src/project/store',
+      );
+      const { result } = renderHook(() => useProjectAuthStore());
+      const projectId1 = 'test-project-1';
+      const projectId2 = 'test-project-2';
+      const roles1 = [ProjectRoleType.Owner];
+      const roles2 = [ProjectRoleType.Editor];
+
+      await act(() => {
+        result.current.setRoles(projectId1, roles1);
+        result.current.setRoles(projectId2, roles2);
+      });
+
+      expect(result.current.roles[projectId1]).toEqual(roles1);
+      expect(result.current.roles[projectId2]).toEqual(roles2);
+    });
+  });
+
+  describe('setIsReady', () => {
+    it('应该正确设置项目准备状态', async () => {
+      const { useProjectAuthStore } = await vi.importActual(
+        '../../src/project/store',
+      );
+      const { result } = renderHook(() => useProjectAuthStore());
+      const projectId = 'test-project-1';
+
+      await act(() => {
+        result.current.setIsReady(projectId, true);
+      });
+
+      expect(result.current.isReady[projectId]).toBe(true);
+    });
+
+    it('应该能够更新已存在的项目准备状态', async () => {
+      const { useProjectAuthStore } = await vi.importActual(
+        '../../src/project/store',
+      );
+      const { result } = renderHook(() => useProjectAuthStore());
+      const projectId = 'test-project-1';
+
+      await act(() => {
+        result.current.setIsReady(projectId, true);
+      });
+      expect(result.current.isReady[projectId]).toBe(true);
+
+      await act(() => {
+        result.current.setIsReady(projectId, false);
+      });
+      expect(result.current.isReady[projectId]).toBe(false);
+    });
+
+    it('应该能够同时管理多个项目的准备状态', async () => {
+      const { useProjectAuthStore } = await vi.importActual(
+        '../../src/project/store',
+      );
+      const { result } = renderHook(() => useProjectAuthStore());
+      const projectId1 = 'test-project-1';
+      const projectId2 = 'test-project-2';
+
+      await act(() => {
+        result.current.setIsReady(projectId1, true);
+        result.current.setIsReady(projectId2, false);
+      });
+
+      expect(result.current.isReady[projectId1]).toBe(true);
+      expect(result.current.isReady[projectId2]).toBe(false);
+    });
+  });
+
+  describe('destory', () => {
+    it('应该正确清除项目数据', async () => {
+      const { useProjectAuthStore } = await vi.importActual(
+        '../../src/project/store',
+      );
+      const { result } = renderHook(() => useProjectAuthStore());
+      const projectId = 'test-project-1';
+      const roles = [ProjectRoleType.Owner];
+
+      // 设置初始数据
+      await act(() => {
+        result.current.setRoles(projectId, roles);
+        result.current.setIsReady(projectId, true);
+      });
+
+      // 验证数据已设置
+      expect(result.current.roles[projectId]).toEqual(roles);
+      expect(result.current.isReady[projectId]).toBe(true);
+
+      // 销毁数据
+      result.current.destory(projectId);
+
+      // 验证数据已清除
+      expect(result.current.roles[projectId]).toEqual([]);
+      expect(result.current.isReady[projectId]).toBe(false);
+    });
+
+    it('应该只清除指定项目的数据，不影响其他项目', async () => {
+      const { useProjectAuthStore } = await vi.importActual(
+        '../../src/project/store',
+      );
+      const { result } = renderHook(() => useProjectAuthStore());
+      const projectId1 = 'test-project-1';
+      const projectId2 = 'test-project-2';
+      const roles1 = [ProjectRoleType.Owner];
+      const roles2 = [ProjectRoleType.Editor];
+
+      // 设置初始数据
+      result.current.setRoles(projectId1, roles1);
+      result.current.setRoles(projectId2, roles2);
+      result.current.setIsReady(projectId1, true);
+      result.current.setIsReady(projectId2, true);
+
+      // 销毁项目1的数据
+      result.current.destory(projectId1);
+
+      // 验证项目1的数据已清除，项目2的数据保持不变
+      expect(result.current.roles[projectId1]).toEqual([]);
+      expect(result.current.isReady[projectId1]).toBe(false);
+      expect(result.current.roles[projectId2]).toEqual(roles2);
+      expect(result.current.isReady[projectId2]).toBe(true);
+    });
+  });
+});

frontend/packages/common/auth/__tests__/project/use-destory-project.test.ts

@@ -0,0 +1,135 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook } from '@testing-library/react-hooks';
+
+// 模拟 React 的 useEffect
+const cleanupFns = new Map();
+vi.mock('react', () => ({
+  useEffect: vi.fn((fn, deps) => {
+    // 执行 effect 函数并获取清理函数
+    const cleanup = fn();
+    // 存储清理函数，以便在 unmount 时调用
+    cleanupFns.set(fn, cleanup);
+    // 返回清理函数
+    return cleanup;
+  }),
+}));
+
+import { useDestoryProject } from '../../src/project/use-destory-project';
+import { useProjectAuthStore } from '../../src/project/store';
+
+// 模拟 useProjectAuthStore
+vi.mock('../../src/project/store', () => {
+  const destorySpy = vi.fn();
+  return {
+    useProjectAuthStore: vi.fn(() => destorySpy),
+  };
+});
+
+// 创建一个包装函数，确保在 unmount 时调用清理函数
+function renderHookWithCleanup(callback, options = {}) {
+  const result = renderHook(callback, options);
+  const originalUnmount = result.unmount;
+
+  result.unmount = () => {
+    // 调用所有清理函数
+    cleanupFns.forEach(cleanup => {
+      if (typeof cleanup === 'function') {
+        cleanup();
+      }
+    });
+    // 调用原始的 unmount
+    originalUnmount();
+  };
+
+  return result;
+}
+
+describe('useDestoryProject', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    cleanupFns.clear();
+  });
+
+  it('应该在组件卸载时调用 destory 方法', () => {
+    const projectId = 'test-project-id';
+    const destorySpy = vi.fn();
+
+    // 模拟 useProjectAuthStore 返回 destorySpy
+    (useProjectAuthStore as any).mockReturnValue(destorySpy);
+
+    // 渲染 hook
+    const { unmount } = renderHookWithCleanup(() =>
+      useDestoryProject(projectId),
+    );
+
+    // 验证初始状态下 destory 未被调用
+    expect(destorySpy).not.toHaveBeenCalled();
+
+    // 卸载组件
+    unmount();
+
+    // 验证 destory 被调用，且参数正确
+    expect(destorySpy).toHaveBeenCalledTimes(1);
+    expect(destorySpy).toHaveBeenCalledWith(projectId);
+  });
+
+  it('应该在组件卸载时清除正确的项目数据', () => {
+    const projectId1 = 'test-project-id-1';
+    const destorySpy = vi.fn();
+
+    // 模拟 useProjectAuthStore 返回 destorySpy
+    (useProjectAuthStore as any).mockReturnValue(destorySpy);
+
+    // 渲染 hook
+    const { unmount } = renderHookWithCleanup(() =>
+      useDestoryProject(projectId1),
+    );
+
+    // 卸载组件
+    unmount();
+
+    // 验证 destory 被调用，且参数为 projectId1
+    expect(destorySpy).toHaveBeenCalledTimes(1);
+    expect(destorySpy).toHaveBeenCalledWith(projectId1);
+  });
+
+  it('应该为不同的项目ID调用不同的清理函数', () => {
+    const projectId2 = 'test-project-id-2';
+    const destorySpy = vi.fn();
+
+    // 清除之前的所有模拟和清理函数
+    vi.clearAllMocks();
+    cleanupFns.clear();
+
+    // 模拟 useProjectAuthStore 返回 destorySpy
+    (useProjectAuthStore as any).mockReturnValue(destorySpy);
+
+    // 渲染 hook
+    const { unmount } = renderHookWithCleanup(() =>
+      useDestoryProject(projectId2),
+    );
+
+    // 卸载组件
+    unmount();
+
+    // 验证 destory 被调用，且参数为 projectId2
+    expect(destorySpy).toHaveBeenCalledTimes(1);
+    expect(destorySpy).toHaveBeenCalledWith(projectId2);
+  });
+});

frontend/packages/common/auth/__tests__/project/use-project-auth.test.ts

@@ -0,0 +1,148 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook } from '@testing-library/react-hooks';
+import { SpaceType } from '@coze-arch/idl/developer_api';
+import { useSpace } from '@coze-arch/foundation-sdk';
+
+import { useSpaceRole } from '../../src/space/use-space-role';
+import { SpaceRoleType } from '../../src/space/constants';
+import { useProjectRole } from '../../src/project/use-project-role';
+import { useProjectAuth } from '../../src/project/use-project-auth';
+import {
+  EProjectPermission,
+  ProjectRoleType,
+} from '../../src/project/constants';
+import { calcPermission } from '../../src/project/calc-permission';
+
+// 模拟依赖
+vi.mock('@coze-arch/foundation-sdk', () => ({
+  useSpace: vi.fn(),
+}));
+
+vi.mock('../../src/space/use-space-role', () => ({
+  useSpaceRole: vi.fn(),
+}));
+
+vi.mock('../../src/project/use-project-role', () => ({
+  useProjectRole: vi.fn(),
+}));
+
+vi.mock('../../src/project/calc-permission', () => ({
+  calcPermission: vi.fn(),
+}));
+
+describe('useProjectAuth', () => {
+  const projectId = 'test-project-id';
+  const spaceId = 'test-space-id';
+  const permissionKey = EProjectPermission.View;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // 模拟 useSpace 返回空间信息
+    (useSpace as any).mockReturnValue({
+      space_type: SpaceType.Team,
+    });
+
+    // 模拟 useSpaceRole 返回空间角色
+    (useSpaceRole as any).mockReturnValue([SpaceRoleType.Member]);
+
+    // 模拟 useProjectRole 返回项目角色
+    (useProjectRole as any).mockReturnValue([ProjectRoleType.Editor]);
+
+    // 模拟 calcPermission 返回权限结果
+    (calcPermission as any).mockReturnValue(true);
+  });
+
+  it('应该调用 calcPermission 并返回正确的权限结果', () => {
+    // 渲染 hook
+    const { result } = renderHook(() =>
+      useProjectAuth(permissionKey, projectId, spaceId),
+    );
+
+    // 验证 useSpace 被调用
+    expect(useSpace).toHaveBeenCalledWith(spaceId);
+
+    // 验证 useSpaceRole 被调用
+    expect(useSpaceRole).toHaveBeenCalledWith(spaceId);
+
+    // 验证 useProjectRole 被调用
+    expect(useProjectRole).toHaveBeenCalledWith(projectId);
+
+    // 验证 calcPermission 被调用，且参数正确
+    expect(calcPermission).toHaveBeenCalledWith(permissionKey, {
+      projectRoles: [ProjectRoleType.Editor],
+      spaceRoles: [SpaceRoleType.Member],
+      spaceType: SpaceType.Team,
+    });
+
+    // 验证返回值
+    expect(result.current).toBe(true);
+  });
+
+  it('应该在 calcPermission 返回 false 时返回 false', () => {
+    // 模拟 calcPermission 返回 false
+    (calcPermission as any).mockReturnValue(false);
+
+    // 渲染 hook
+    const { result } = renderHook(() =>
+      useProjectAuth(permissionKey, projectId, spaceId),
+    );
+
+    // 验证返回值
+    expect(result.current).toBe(false);
+  });
+
+  it('应该在空间类型不存在时抛出错误', () => {
+    // 模拟 useSpace 返回没有 space_type 的对象
+    (useSpace as any).mockReturnValue({});
+
+    // 使用 vi.spyOn 监听 console.error 以防止测试输出错误信息
+    vi.spyOn(console, 'error').mockImplementation(() => {
+      // 空实现，防止错误输出
+    });
+
+    // 验证抛出错误
+    expect(() => {
+      const { result } = renderHook(() =>
+        useProjectAuth(permissionKey, projectId, spaceId),
+      );
+      // 强制访问 result.current 触发错误
+      console.log(result.current);
+    }).toThrow('useSpaceAuth must be used after space list has been pulled.');
+  });
+
+  it('应该在空间为 null 时抛出错误', () => {
+    // 模拟 useSpace 返回 null
+    (useSpace as any).mockReturnValue(null);
+
+    // 使用 vi.spyOn 监听 console.error 以防止测试输出错误信息
+    vi.spyOn(console, 'error').mockImplementation(() => {
+      // 空实现，防止错误输出
+    });
+
+    // 验证抛出错误
+    expect(() => {
+      const { result } = renderHook(() =>
+        useProjectAuth(permissionKey, projectId, spaceId),
+      );
+      // 强制访问 result.current 触发错误
+      console.log(result.current);
+    }).toThrow('useSpaceAuth must be used after space list has been pulled.');
+  });
+});

frontend/packages/common/auth/__tests__/project/use-project-role.test.ts

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook } from '@testing-library/react-hooks';
+
+import { useProjectRole } from '../../src/project/use-project-role';
+import { useProjectAuthStore } from '../../src/project/store';
+import { ProjectRoleType } from '../../src/project/constants';
+
+// 模拟依赖
+vi.mock('../../src/project/store', () => ({
+  useProjectAuthStore: vi.fn(),
+}));
+
+describe('useProjectRole', () => {
+  const projectId = 'test-project-id';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('应该返回正确的项目角色', () => {
+    const expectedRoles = [ProjectRoleType.Owner];
+
+    // 模拟 useProjectAuthStore 返回项目角色和 ready 状态
+    (useProjectAuthStore as any).mockReturnValue({
+      isReady: true,
+      role: expectedRoles,
+    });
+
+    // 渲染 hook
+    const { result } = renderHook(() => useProjectRole(projectId));
+
+    // 验证 useProjectAuthStore 被调用
+    expect(useProjectAuthStore).toHaveBeenCalled();
+
+    // 验证返回值
+    expect(result.current).toEqual(expectedRoles);
+  });
+
+  it('应该在项目未准备好时抛出错误', () => {
+    // 模拟 useProjectAuthStore 返回未准备好的状态
+    (useProjectAuthStore as any).mockReturnValue({
+      isReady: false,
+      role: [],
+    });
+
+    // 使用 vi.spyOn 监听 console.error 以防止测试输出错误信息
+    vi.spyOn(console, 'error').mockImplementation(() => {
+      // 空实现，防止错误输出
+    });
+
+    // 验证抛出错误
+    expect(() => {
+      const { result } = renderHook(() => useProjectRole(projectId));
+      // 强制访问 result.current 触发错误
+      console.log(result.current);
+    }).toThrow(
+      'useProjectAuth must be used after useInitProjectRole has been completed.',
+    );
+  });
+
+  it('应该在角色为 undefined 时返回空数组', () => {
+    // 模拟 useProjectAuthStore 返回 undefined 角色
+    (useProjectAuthStore as any).mockReturnValue({
+      isReady: true,
+      role: undefined,
+    });
+
+    // 渲染 hook
+    const { result } = renderHook(() => useProjectRole(projectId));
+
+    // 验证返回值为空数组
+    expect(result.current).toEqual([]);
+  });
+
+  it('应该处理多种角色类型', () => {
+    const expectedRoles = [ProjectRoleType.Owner, ProjectRoleType.Editor];
+
+    // 模拟 useProjectAuthStore 返回多种角色
+    (useProjectAuthStore as any).mockReturnValue({
+      isReady: true,
+      role: expectedRoles,
+    });
+
+    // 渲染 hook
+    const { result } = renderHook(() => useProjectRole(projectId));
+
+    // 验证返回值
+    expect(result.current).toEqual(expectedRoles);
+  });
+});

frontend/packages/common/auth/__tests__/space/calc-permission.test.ts

@@ -0,0 +1,238 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+import { describe, it, expect } from 'vitest';
+import { SpaceRoleType } from '@coze-arch/idl/developer_api';
+
+import { ESpacePermisson } from '../../src/space/constants';
+import { calcPermission } from '../../src/space/calc-permission';
+
+describe('Space Calc Permission', () => {
+  describe('calcPermission', () => {
+    it('应该为 Owner 角色返回正确的权限', () => {
+      // Owner 应该有更新空间的权限
+      expect(
+        calcPermission(ESpacePermisson.UpdateSpace, [SpaceRoleType.Owner]),
+      ).toBe(true);
+
+      // Owner 应该有删除空间的权限
+      expect(
+        calcPermission(ESpacePermisson.DeleteSpace, [SpaceRoleType.Owner]),
+      ).toBe(true);
+
+      // Owner 应该有添加成员的权限
+      expect(
+        calcPermission(ESpacePermisson.AddBotSpaceMember, [
+          SpaceRoleType.Owner,
+        ]),
+      ).toBe(true);
+
+      // Owner 应该有移除成员的权限
+      expect(
+        calcPermission(ESpacePermisson.RemoveSpaceMember, [
+          SpaceRoleType.Owner,
+        ]),
+      ).toBe(true);
+
+      // Owner 应该有转移所有权的权限
+      expect(
+        calcPermission(ESpacePermisson.TransferSpace, [SpaceRoleType.Owner]),
+      ).toBe(true);
+
+      // Owner 应该有更新成员的权限
+      expect(
+        calcPermission(ESpacePermisson.UpdateSpaceMember, [
+          SpaceRoleType.Owner,
+        ]),
+      ).toBe(true);
+
+      // Owner 应该有管理 API 的权限
+      expect(calcPermission(ESpacePermisson.API, [SpaceRoleType.Owner])).toBe(
+        true,
+      );
+    });
+
+    it('应该为 Admin 角色返回正确的权限', () => {
+      // Admin 应该有添加成员的权限
+      expect(
+        calcPermission(ESpacePermisson.AddBotSpaceMember, [
+          SpaceRoleType.Admin,
+        ]),
+      ).toBe(true);
+
+      // Admin 应该有移除成员的权限
+      expect(
+        calcPermission(ESpacePermisson.RemoveSpaceMember, [
+          SpaceRoleType.Admin,
+        ]),
+      ).toBe(true);
+
+      // Admin 应该有退出空间的权限
+      expect(
+        calcPermission(ESpacePermisson.ExitSpace, [SpaceRoleType.Admin]),
+      ).toBe(true);
+
+      // Admin 应该有更新成员的权限
+      expect(
+        calcPermission(ESpacePermisson.UpdateSpaceMember, [
+          SpaceRoleType.Admin,
+        ]),
+      ).toBe(true);
+
+      // Admin 不应该有更新空间的权限
+      expect(
+        calcPermission(ESpacePermisson.UpdateSpace, [SpaceRoleType.Admin]),
+      ).toBe(false);
+
+      // Admin 不应该有删除空间的权限
+      expect(
+        calcPermission(ESpacePermisson.DeleteSpace, [SpaceRoleType.Admin]),
+      ).toBe(false);
+
+      // Admin 不应该有转移所有权的权限
+      expect(
+        calcPermission(ESpacePermisson.TransferSpace, [SpaceRoleType.Admin]),
+      ).toBe(false);
+
+      // Admin 不应该有管理 API 的权限
+      expect(calcPermission(ESpacePermisson.API, [SpaceRoleType.Admin])).toBe(
+        false,
+      );
+    });
+
+    it('应该为 Member 角色返回正确的权限', () => {
+      // Member 应该有退出空间的权限
+      expect(
+        calcPermission(ESpacePermisson.ExitSpace, [SpaceRoleType.Member]),
+      ).toBe(true);
+
+      // Member 不应该有更新空间的权限
+      expect(
+        calcPermission(ESpacePermisson.UpdateSpace, [SpaceRoleType.Member]),
+      ).toBe(false);
+
+      // Member 不应该有删除空间的权限
+      expect(
+        calcPermission(ESpacePermisson.DeleteSpace, [SpaceRoleType.Member]),
+      ).toBe(false);
+
+      // Member 不应该有添加成员的权限
+      expect(
+        calcPermission(ESpacePermisson.AddBotSpaceMember, [
+          SpaceRoleType.Member,
+        ]),
+      ).toBe(false);
+
+      // Member 不应该有移除成员的权限
+      expect(
+        calcPermission(ESpacePermisson.RemoveSpaceMember, [
+          SpaceRoleType.Member,
+        ]),
+      ).toBe(false);
+
+      // Member 不应该有转移所有权的权限
+      expect(
+        calcPermission(ESpacePermisson.TransferSpace, [SpaceRoleType.Member]),
+      ).toBe(false);
+
+      // Member 不应该有更新成员的权限
+      expect(
+        calcPermission(ESpacePermisson.UpdateSpaceMember, [
+          SpaceRoleType.Member,
+        ]),
+      ).toBe(false);
+
+      // Member 不应该有管理 API 的权限
+      expect(calcPermission(ESpacePermisson.API, [SpaceRoleType.Member])).toBe(
+        false,
+      );
+    });
+
+    it('应该为 Default 角色返回正确的权限', () => {
+      // Default 不应该有任何权限
+      expect(
+        calcPermission(ESpacePermisson.UpdateSpace, [SpaceRoleType.Default]),
+      ).toBe(false);
+      expect(
+        calcPermission(ESpacePermisson.DeleteSpace, [SpaceRoleType.Default]),
+      ).toBe(false);
+      expect(
+        calcPermission(ESpacePermisson.AddBotSpaceMember, [
+          SpaceRoleType.Default,
+        ]),
+      ).toBe(false);
+      expect(
+        calcPermission(ESpacePermisson.RemoveSpaceMember, [
+          SpaceRoleType.Default,
+        ]),
+      ).toBe(false);
+      expect(
+        calcPermission(ESpacePermisson.ExitSpace, [SpaceRoleType.Default]),
+      ).toBe(false);
+      expect(
+        calcPermission(ESpacePermisson.TransferSpace, [SpaceRoleType.Default]),
+      ).toBe(false);
+      expect(
+        calcPermission(ESpacePermisson.UpdateSpaceMember, [
+          SpaceRoleType.Default,
+        ]),
+      ).toBe(false);
+      expect(calcPermission(ESpacePermisson.API, [SpaceRoleType.Default])).toBe(
+        false,
+      );
+    });
+
+    it('应该处理多个角色的情况', () => {
+      // 当用户同时拥有 Member 和 Admin 角色时，应该有两个角色的所有权限
+      expect(
+        calcPermission(ESpacePermisson.ExitSpace, [
+          SpaceRoleType.Member,
+          SpaceRoleType.Admin,
+        ]),
+      ).toBe(true);
+
+      expect(
+        calcPermission(ESpacePermisson.RemoveSpaceMember, [
+          SpaceRoleType.Member,
+          SpaceRoleType.Admin,
+        ]),
+      ).toBe(true);
+
+      // 即使其中一个角色没有权限，只要有一个角色有权限，就应该返回 true
+      expect(
+        calcPermission(ESpacePermisson.UpdateSpace, [
+          SpaceRoleType.Member,
+          SpaceRoleType.Owner,
+        ]),
+      ).toBe(true);
+    });
+
+    it('应该处理空角色数组', () => {
+      // 当没有角色时，应该返回 false
+      expect(calcPermission(ESpacePermisson.UpdateSpace, [])).toBe(false);
+      expect(calcPermission(ESpacePermisson.ExitSpace, [])).toBe(false);
+    });
+
+    it('应该处理未知角色', () => {
+      // 当角色未知时，应该返回 false
+      expect(
+        calcPermission(ESpacePermisson.UpdateSpace, [
+          'UnknownRole' as unknown as SpaceRoleType,
+        ]),
+      ).toBe(false);
+    });
+  });
+});

frontend/packages/common/auth/__tests__/space/constants.test.ts

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+import { describe, it, expect } from 'vitest';
+import { SpaceRoleType } from '@coze-arch/idl/developer_api';
+
+import { ESpacePermisson } from '../../src/space/constants';
+
+describe('Space Constants', () => {
+  describe('ESpacePermisson', () => {
+    it('应该定义所有必要的权限点', () => {
+      // 验证所有权限点都已定义
+      expect(ESpacePermisson.UpdateSpace).toBeDefined();
+      expect(ESpacePermisson.DeleteSpace).toBeDefined();
+      expect(ESpacePermisson.AddBotSpaceMember).toBeDefined();
+      expect(ESpacePermisson.RemoveSpaceMember).toBeDefined();
+      expect(ESpacePermisson.ExitSpace).toBeDefined();
+      expect(ESpacePermisson.TransferSpace).toBeDefined();
+      expect(ESpacePermisson.UpdateSpaceMember).toBeDefined();
+      expect(ESpacePermisson.API).toBeDefined();
+    });
+
+    it('应该为每个权限点分配唯一的值', () => {
+      // 创建一个集合来存储所有权限点的值
+      const permissionValues = new Set();
+
+      // 获取所有权限点的值
+      Object.values(ESpacePermisson)
+        .filter(value => typeof value === 'number')
+        .forEach(value => {
+          permissionValues.add(value);
+        });
+
+      // 验证权限点的数量与唯一值的数量相同
+      const numericKeys = Object.keys(ESpacePermisson).filter(
+        key => !isNaN(Number(key)),
+      ).length;
+
+      expect(permissionValues.size).toBe(numericKeys);
+    });
+  });
+
+  describe('SpaceRoleType', () => {
+    it('应该正确导出 SpaceRoleType', () => {
+      // 验证 SpaceRoleType 已正确导出
+      expect(SpaceRoleType).toBeDefined();
+
+      // 验证 SpaceRoleType 包含必要的角色
+      expect(SpaceRoleType.Owner).toBeDefined();
+      expect(SpaceRoleType.Admin).toBeDefined();
+      expect(SpaceRoleType.Member).toBeDefined();
+      expect(SpaceRoleType.Default).toBeDefined();
+    });
+  });
+});

frontend/packages/common/auth/__tests__/space/index.test.ts

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+import { SpaceRoleType } from '@coze-arch/idl/developer_api';
+
+import { ESpacePermisson } from '../../src/space/constants';
+import { calcPermission } from '../../src/space/calc-permission';
+
+describe('calcPermission', () => {
+  it('should return true for Owner role with UpdateSpace permission', () => {
+    expect(
+      calcPermission(ESpacePermisson.UpdateSpace, [SpaceRoleType.Owner]),
+    ).toBe(true);
+  });
+
+  it('should return true for Admin role with RemoveSpaceMember permission', () => {
+    expect(
+      calcPermission(ESpacePermisson.RemoveSpaceMember, [SpaceRoleType.Admin]),
+    ).toBe(true);
+  });
+
+  it('should return true for Member role with ExitSpace permission', () => {
+    expect(
+      calcPermission(ESpacePermisson.ExitSpace, [SpaceRoleType.Member]),
+    ).toBe(true);
+  });
+
+  it('should return false for Member role with UpdateSpace permission', () => {
+    expect(
+      calcPermission(ESpacePermisson.UpdateSpace, [SpaceRoleType.Member]),
+    ).toBe(false);
+  });
+
+  it('should return true for multiple roles with overlapping permissions', () => {
+    expect(
+      calcPermission(ESpacePermisson.ExitSpace, [
+        SpaceRoleType.Admin,
+        SpaceRoleType.Member,
+      ]),
+    ).toBe(true);
+  });
+
+  it('should return false for unknown role', () => {
+    expect(
+      calcPermission(ESpacePermisson.UpdateSpace, [
+        'UnknownRole' as unknown as SpaceRoleType,
+      ]),
+    ).toBe(false);
+  });
+
+  it('should return false for no roles', () => {
+    expect(calcPermission(ESpacePermisson.UpdateSpace, [])).toBe(false);
+  });
+});

frontend/packages/common/auth/__tests__/space/store.test.ts

@@ -0,0 +1,208 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { renderHook, act } from '@testing-library/react-hooks';
+import { SpaceRoleType } from '@coze-arch/idl/developer_api';
+
+// 模拟全局变量
+vi.stubGlobal('IS_DEV_MODE', true);
+
+describe('Space Auth Store', () => {
+  beforeEach(() => {
+    // 重置模块缓存，确保每个测试都使用新的 store 实例
+    vi.resetModules();
+  });
+
+  describe('setRoles', () => {
+    it('应该正确设置空间角色', async () => {
+      // 动态导入 store 模块，确保每次测试都获取新的实例
+      const { useSpaceAuthStore } = await vi.importActual(
+        '../../src/space/store',
+      );
+      const { result } = renderHook(() => useSpaceAuthStore());
+
+      const roles = [SpaceRoleType.Owner, SpaceRoleType.Admin];
+      await act(() => {
+        result.current.setRoles('space1', roles);
+      });
+
+      expect(result.current.roles.space1).toEqual(roles);
+    });
+
+    it('应该能够为多个空间设置不同的角色', async () => {
+      const { useSpaceAuthStore } = await vi.importActual(
+        '../../src/space/store',
+      );
+      const { result } = renderHook(() => useSpaceAuthStore());
+
+      const roles1 = [SpaceRoleType.Owner];
+      const roles2 = [SpaceRoleType.Member];
+
+      await act(() => {
+        result.current.setRoles('space1', roles1);
+        result.current.setRoles('space2', roles2);
+      });
+
+      expect(result.current.roles.space1).toEqual(roles1);
+      expect(result.current.roles.space2).toEqual(roles2);
+    });
+
+    it('应该能够更新已存在空间的角色', async () => {
+      const { useSpaceAuthStore } = await vi.importActual(
+        '../../src/space/store',
+      );
+      const { result } = renderHook(() => useSpaceAuthStore());
+
+      const initialRoles = [SpaceRoleType.Owner];
+      const updatedRoles = [SpaceRoleType.Admin];
+
+      await act(() => {
+        result.current.setRoles('space1', initialRoles);
+      });
+      expect(result.current.roles.space1).toEqual(initialRoles);
+
+      await act(() => {
+        result.current.setRoles('space1', updatedRoles);
+      });
+      expect(result.current.roles.space1).toEqual(updatedRoles);
+    });
+  });
+
+  describe('setIsReady', () => {
+    it('应该正确设置空间数据准备状态', async () => {
+      const { useSpaceAuthStore } = await vi.importActual(
+        '../../src/space/store',
+      );
+      const { result } = renderHook(() => useSpaceAuthStore());
+
+      await act(() => {
+        result.current.setIsReady('space1', true);
+      });
+
+      expect(result.current.isReady.space1).toBe(true);
+    });
+
+    it('应该能够为多个空间设置不同的准备状态', async () => {
+      const { useSpaceAuthStore } = await vi.importActual(
+        '../../src/space/store',
+      );
+      const { result } = renderHook(() => useSpaceAuthStore());
+
+      await act(() => {
+        result.current.setIsReady('space1', true);
+        result.current.setIsReady('space2', false);
+      });
+
+      expect(result.current.isReady.space1).toBe(true);
+      expect(result.current.isReady.space2).toBe(false);
+    });
+
+    it('应该能够更新已存在空间的准备状态', async () => {
+      const { useSpaceAuthStore } = await vi.importActual(
+        '../../src/space/store',
+      );
+      const { result } = renderHook(() => useSpaceAuthStore());
+
+      await act(() => {
+        result.current.setIsReady('space1', false);
+      });
+      expect(result.current.isReady.space1).toBe(false);
+
+      await act(() => {
+        result.current.setIsReady('space1', true);
+      });
+      expect(result.current.isReady.space1).toBe(true);
+    });
+  });
+
+  describe('destory', () => {
+    it('应该正确清除空间数据', async () => {
+      const { useSpaceAuthStore } = await vi.importActual(
+        '../../src/space/store',
+      );
+      const { result } = renderHook(() => useSpaceAuthStore());
+      const roles = [SpaceRoleType.Owner];
+
+      // 设置初始数据
+      await act(() => {
+        result.current.setRoles('space1', roles);
+        result.current.setIsReady('space1', true);
+      });
+
+      // 验证数据已设置
+      expect(result.current.roles.space1).toEqual(roles);
+      expect(result.current.isReady.space1).toBe(true);
+
+      // 销毁数据
+      await act(() => {
+        result.current.destory('space1');
+      });
+
+      // 验证数据已清除
+      expect(result.current.roles.space1).toEqual([]);
+      expect(result.current.isReady.space1).toBeUndefined();
+    });
+
+    it('应该只清除指定空间的数据', async () => {
+      const { useSpaceAuthStore } = await vi.importActual(
+        '../../src/space/store',
+      );
+      const { result } = renderHook(() => useSpaceAuthStore());
+
+      // 设置两个空间的数据
+      await act(() => {
+        result.current.setRoles('space1', [SpaceRoleType.Owner]);
+        result.current.setIsReady('space1', true);
+        result.current.setRoles('space2', [SpaceRoleType.Member]);
+        result.current.setIsReady('space2', true);
+      });
+
+      // 只销毁 space1 的数据
+      await act(() => {
+        result.current.destory('space1');
+      });
+
+      // 验证 space1 的数据已清除
+      expect(result.current.roles.space1).toEqual([]);
+      expect(result.current.isReady.space1).toBeUndefined();
+
+      // 验证 space2 的数据保持不变
+      expect(result.current.roles.space2).toEqual([SpaceRoleType.Member]);
+      expect(result.current.isReady.space2).toBe(true);
+    });
+  });
+
+  describe('初始状态', () => {
+    it('应该有正确的初始状态', async () => {
+      const { useSpaceAuthStore } = await vi.importActual(
+        '../../src/space/store',
+      );
+      const { result } = renderHook(() => useSpaceAuthStore());
+
+      // 重置 store 确保测试环境干净
+      await act(() => {
+        Object.keys(result.current.roles).forEach(spaceId => {
+          result.current.destory(spaceId);
+        });
+      });
+
+      // 验证初始状态
+      expect(result.current.roles).toEqual({});
+      expect(result.current.isReady).toEqual({});
+    });
+  });
+});

frontend/packages/common/auth/__tests__/space/use-destory-space.test.ts

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook } from '@testing-library/react-hooks';
+
+// 模拟 React 的 useEffect
+const cleanupFns = new Map();
+vi.mock('react', () => ({
+  useEffect: vi.fn((fn, deps) => {
+    // 执行 effect 函数并获取清理函数
+    const cleanup = fn();
+    // 存储清理函数，以便在 unmount 时调用
+    cleanupFns.set(fn, cleanup);
+    // 返回清理函数
+    return cleanup;
+  }),
+}));
+
+// 模拟 store
+const mockDestory = vi.fn();
+vi.mock('../../src/space/store', () => ({
+  useSpaceAuthStore: vi.fn(selector => selector({ destory: mockDestory })),
+}));
+
+// 创建一个包装函数，确保在 unmount 时调用清理函数
+function renderHookWithCleanup(callback, options = {}) {
+  const result = renderHook(callback, options);
+  const originalUnmount = result.unmount;
+
+  result.unmount = () => {
+    // 调用所有清理函数
+    cleanupFns.forEach(cleanup => {
+      if (typeof cleanup === 'function') {
+        cleanup();
+      }
+    });
+    // 调用原始的 unmount
+    originalUnmount();
+  };
+
+  return result;
+}
+
+import { useDestorySpace } from '../../src/space/use-destory-space';
+
+describe('useDestorySpace', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    cleanupFns.clear();
+  });
+
+  it('应该在组件卸载时调用 destory 方法', () => {
+    const spaceId = 'test-space-id';
+
+    // 渲染 hook
+    const { unmount } = renderHookWithCleanup(() => useDestorySpace(spaceId));
+
+    // 初始时不应调用 destory
+    expect(mockDestory).not.toHaveBeenCalled();
+
+    // 模拟组件卸载
+    unmount();
+
+    // 卸载时应调用 destory 并传入正确的 spaceId
+    expect(mockDestory).toHaveBeenCalledTimes(1);
+    expect(mockDestory).toHaveBeenCalledWith(spaceId);
+  });
+
+  it('应该为不同的 spaceId 调用 destory 方法', () => {
+    const spaceId1 = 'space-id-1';
+    const spaceId2 = 'space-id-2';
+
+    // 渲染第一个 hook 实例
+    const { unmount: unmount1 } = renderHookWithCleanup(() =>
+      useDestorySpace(spaceId1),
+    );
+
+    // 渲染第二个 hook 实例
+    const { unmount: unmount2 } = renderHookWithCleanup(() =>
+      useDestorySpace(spaceId2),
+    );
+
+    // 卸载第一个实例
+    unmount1();
+    expect(mockDestory).toHaveBeenCalledWith(spaceId1);
+
+    // 卸载第二个实例
+    unmount2();
+    expect(mockDestory).toHaveBeenCalledWith(spaceId2);
+
+    // 总共应调用两次
+    expect(mockDestory).toHaveBeenCalledTimes(4);
+  });
+});

frontend/packages/common/auth/__tests__/space/use-space-auth.test.ts

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+import { describe, it, expect, vi } from 'vitest';
+import { renderHook } from '@testing-library/react-hooks';
+import { SpaceRoleType } from '@coze-arch/idl/developer_api';
+
+import { ESpacePermisson } from '../../src/space/constants';
+
+// 模拟 useSpaceRole
+vi.mock('../../src/space/use-space-role', () => ({
+  useSpaceRole: vi.fn(),
+}));
+
+// 模拟 calcPermission
+vi.mock('../../src/space/calc-permission', () => ({
+  calcPermission: vi.fn(),
+}));
+
+import { useSpaceRole } from '../../src/space/use-space-role';
+import { calcPermission } from '../../src/space/calc-permission';
+import { useSpaceAuth } from '../../src/space/use-space-auth';
+
+describe('useSpaceAuth', () => {
+  it('应该使用 useSpaceRole 获取角色并调用 calcPermission 计算权限', () => {
+    const spaceId = 'test-space-id';
+    const permissionKey = ESpacePermisson.UpdateSpace;
+    const mockRoles = [SpaceRoleType.Owner];
+
+    // 模拟 useSpaceRole 返回角色
+    (useSpaceRole as unknown as ReturnType<typeof vi.fn>).mockReturnValue(
+      mockRoles,
+    );
+
+    // 模拟 calcPermission 返回权限结果
+    (calcPermission as unknown as ReturnType<typeof vi.fn>).mockReturnValue(
+      true,
+    );
+
+    // 渲染 hook
+    const { result } = renderHook(() => useSpaceAuth(permissionKey, spaceId));
+
+    // 验证 useSpaceRole 被调用，并传入正确的 spaceId
+    expect(useSpaceRole).toHaveBeenCalledWith(spaceId);
+
+    // 验证 calcPermission 被调用，并传入正确的参数
+    expect(calcPermission).toHaveBeenCalledWith(permissionKey, mockRoles);
+
+    // 验证返回值与 calcPermission 的返回值一致
+    expect(result.current).toBe(true);
+  });
+
+  it('应该在没有权限时返回 false', () => {
+    const spaceId = 'test-space-id';
+    const permissionKey = ESpacePermisson.UpdateSpace;
+    const mockRoles = [SpaceRoleType.Member];
+
+    // 模拟 useSpaceRole 返回角色
+    (useSpaceRole as unknown as ReturnType<typeof vi.fn>).mockReturnValue(
+      mockRoles,
+    );
+
+    // 模拟 calcPermission 返回权限结果
+    (calcPermission as unknown as ReturnType<typeof vi.fn>).mockReturnValue(
+      false,
+    );
+
+    // 渲染 hook
+    const { result } = renderHook(() => useSpaceAuth(permissionKey, spaceId));
+
+    // 验证返回值与 calcPermission 的返回值一致
+    expect(result.current).toBe(false);
+  });
+
+  it('应该在角色为空数组时返回 false', () => {
+    const spaceId = 'test-space-id';
+    const permissionKey = ESpacePermisson.UpdateSpace;
+    const mockRoles: SpaceRoleType[] = [];
+
+    // 模拟 useSpaceRole 返回空角色数组
+    (useSpaceRole as unknown as ReturnType<typeof vi.fn>).mockReturnValue(
+      mockRoles,
+    );
+
+    // 模拟 calcPermission 返回权限结果
+    (calcPermission as unknown as ReturnType<typeof vi.fn>).mockReturnValue(
+      false,
+    );
+
+    // 渲染 hook
+    const { result } = renderHook(() => useSpaceAuth(permissionKey, spaceId));
+
+    // 验证 calcPermission 被调用，并传入正确的参数
+    expect(calcPermission).toHaveBeenCalledWith(permissionKey, mockRoles);
+
+    // 验证返回值与 calcPermission 的返回值一致
+    expect(result.current).toBe(false);
+  });
+});

frontend/packages/common/auth/__tests__/space/use-space-role.test.ts

@@ -0,0 +1,138 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook } from '@testing-library/react-hooks';
+import { SpaceRoleType } from '@coze-arch/idl/developer_api';
+
+import { useSpaceAuthStore } from '../../src/space/store';
+
+// 模拟 zustand
+vi.mock('zustand/react/shallow', () => ({
+  useShallow: fn => fn,
+}));
+
+// 模拟 foundation-sdk
+const mockUseSpace = vi.fn();
+vi.mock('@coze-arch/foundation-sdk', () => ({
+  useSpace: (...args) => mockUseSpace(...args),
+}));
+
+// 模拟 store
+vi.mock('../../src/space/store', () => ({
+  useSpaceAuthStore: vi.fn(),
+}));
+
+// 导入实际模块，确保在模拟之后导入
+import { useSpaceRole } from '../../src/space/use-space-role';
+
+describe('useSpaceRole', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('应该在 space 存在且 isReady 为 true 时返回角色', () => {
+    const spaceId = 'test-space-id';
+    const mockSpace = { id: spaceId, name: 'Test Space' };
+    const mockRoles = [SpaceRoleType.Owner];
+
+    // 模拟 useSpace 返回 space 对象
+    mockUseSpace.mockReturnValue(mockSpace);
+
+    // 模拟 useSpaceAuthStore 返回 isReady 和 role
+    (useSpaceAuthStore as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      isReady: true,
+      role: mockRoles,
+    });
+
+    // 渲染 hook
+    const { result } = renderHook(() => useSpaceRole(spaceId));
+
+    // 验证 useSpace 被调用，并传入正确的 spaceId
+    expect(mockUseSpace).toHaveBeenCalledWith(spaceId);
+
+    // 验证 useSpaceAuthStore 被调用，并传入正确的选择器
+    expect(useSpaceAuthStore).toHaveBeenCalled();
+
+    // 验证返回值与预期一致
+    expect(result.current).toEqual(mockRoles);
+  });
+
+  it('应该在 space 不存在时抛出错误', () => {
+    const spaceId = 'test-space-id';
+
+    // 模拟 useSpace 返回 null
+    mockUseSpace.mockReturnValue(null);
+
+    // 使用 vi.spyOn 监听 console.error 以防止测试输出错误信息
+    vi.spyOn(console, 'error').mockImplementation(() => {
+      // 空实现，防止错误输出
+    });
+
+    // 验证渲染 hook 时抛出错误
+    expect(() => useSpaceRole(spaceId)).toThrow(
+      'useSpaceAuth must be used after space list has been pulled.',
+    );
+  });
+
+  it('应该在 isReady 为 false 时抛出错误', () => {
+    const spaceId = 'test-space-id';
+    const mockSpace = { id: spaceId, name: 'Test Space' };
+
+    // 模拟 useSpace 返回 space 对象
+    mockUseSpace.mockReturnValue(mockSpace);
+
+    // 模拟 useSpaceAuthStore 返回 isReady 为 false
+    (useSpaceAuthStore as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      isReady: false,
+      role: null,
+    });
+
+    // 使用 vi.spyOn 监听 console.error 以防止测试输出错误信息
+    vi.spyOn(console, 'error').mockImplementation(() => {
+      // 空实现，防止错误输出
+    });
+
+    // 验证渲染 hook 时抛出错误
+    expect(() => useSpaceRole(spaceId)).toThrow(
+      'useSpaceAuth must be used after useInitSpaceRole has been completed.',
+    );
+  });
+
+  it('应该在 role 不存在时抛出错误', () => {
+    const spaceId = 'test-space-id';
+    const mockSpace = { id: spaceId, name: 'Test Space' };
+
+    // 模拟 useSpace 返回 space 对象
+    mockUseSpace.mockReturnValue(mockSpace);
+
+    // 模拟 useSpaceAuthStore 返回 isReady 为 true，但 role 为 null
+    (useSpaceAuthStore as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      isReady: true,
+      role: null,
+    });
+
+    // 使用 vi.spyOn 监听 console.error 以防止测试输出错误信息
+    vi.spyOn(console, 'error').mockImplementation(() => {
+      // 空实现，防止错误输出
+    });
+
+    // 验证渲染 hook 时抛出错误
+    expect(() => useSpaceRole(spaceId)).toThrow(
+      `Can not get space role of space: ${spaceId}`,
+    );
+  });
+});