chore: replace all cn comments of fe to en version by volc api (#320)

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

@@ -23,146 +23,146 @@ import { calcPermission } from '../../src/space/calc-permission';
 describe('Space Calc Permission', () => {
   describe('calcPermission', () => {
     it('应该为 Owner 角色返回正确的权限', () => {
-      // Owner 应该有更新空间的权限
+      // Owner should have permission to update the space
       expect(
         calcPermission(ESpacePermisson.UpdateSpace, [SpaceRoleType.Owner]),
       ).toBe(true);
 
-      // Owner 应该有删除空间的权限
+      // Owner should have permission to delete space
       expect(
         calcPermission(ESpacePermisson.DeleteSpace, [SpaceRoleType.Owner]),
       ).toBe(true);
 
-      // Owner 应该有添加成员的权限
+      // Owner should have permission to add members
       expect(
         calcPermission(ESpacePermisson.AddBotSpaceMember, [
           SpaceRoleType.Owner,
         ]),
       ).toBe(true);
 
-      // Owner 应该有移除成员的权限
+      // Owner should have permission to remove members
       expect(
         calcPermission(ESpacePermisson.RemoveSpaceMember, [
           SpaceRoleType.Owner,
         ]),
       ).toBe(true);
 
-      // Owner 应该有转移所有权的权限
+      // Owner should have the right to transfer ownership
       expect(
         calcPermission(ESpacePermisson.TransferSpace, [SpaceRoleType.Owner]),
       ).toBe(true);
 
-      // Owner 应该有更新成员的权限
+      // Owner should have permission to update members
       expect(
         calcPermission(ESpacePermisson.UpdateSpaceMember, [
           SpaceRoleType.Owner,
         ]),
       ).toBe(true);
 
-      // Owner 应该有管理 API 的权限
+      // Owner should have permission to manage the API
       expect(calcPermission(ESpacePermisson.API, [SpaceRoleType.Owner])).toBe(
         true,
       );
     });
 
     it('应该为 Admin 角色返回正确的权限', () => {
-      // Admin 应该有添加成员的权限
+      // Admin should have permission to add members
       expect(
         calcPermission(ESpacePermisson.AddBotSpaceMember, [
           SpaceRoleType.Admin,
         ]),
       ).toBe(true);
 
-      // Admin 应该有移除成员的权限
+      // Admin should have permission to remove members
       expect(
         calcPermission(ESpacePermisson.RemoveSpaceMember, [
           SpaceRoleType.Admin,
         ]),
       ).toBe(true);
 
-      // Admin 应该有退出空间的权限
+      // Admin should have permission to exit the space
       expect(
         calcPermission(ESpacePermisson.ExitSpace, [SpaceRoleType.Admin]),
       ).toBe(true);
 
-      // Admin 应该有更新成员的权限
+      // Admin should have permission to update members
       expect(
         calcPermission(ESpacePermisson.UpdateSpaceMember, [
           SpaceRoleType.Admin,
         ]),
       ).toBe(true);
 
-      // Admin 不应该有更新空间的权限
+      // Admin should not have permission to update the space
       expect(
         calcPermission(ESpacePermisson.UpdateSpace, [SpaceRoleType.Admin]),
       ).toBe(false);
 
-      // Admin 不应该有删除空间的权限
+      // Admin should not have permission to delete space
       expect(
         calcPermission(ESpacePermisson.DeleteSpace, [SpaceRoleType.Admin]),
       ).toBe(false);
 
-      // Admin 不应该有转移所有权的权限
+      // Admin should not have permission to transfer ownership
       expect(
         calcPermission(ESpacePermisson.TransferSpace, [SpaceRoleType.Admin]),
       ).toBe(false);
 
-      // Admin 不应该有管理 API 的权限
+      // Admin should not have permission to manage APIs
       expect(calcPermission(ESpacePermisson.API, [SpaceRoleType.Admin])).toBe(
         false,
       );
     });
 
     it('应该为 Member 角色返回正确的权限', () => {
-      // Member 应该有退出空间的权限
+      // Members should have permission to exit the space
       expect(
         calcPermission(ESpacePermisson.ExitSpace, [SpaceRoleType.Member]),
       ).toBe(true);
 
-      // Member 不应该有更新空间的权限
+      // Members should not have permission to update space
       expect(
         calcPermission(ESpacePermisson.UpdateSpace, [SpaceRoleType.Member]),
       ).toBe(false);
 
-      // Member 不应该有删除空间的权限
+      // Members should not have permission to delete space
       expect(
         calcPermission(ESpacePermisson.DeleteSpace, [SpaceRoleType.Member]),
       ).toBe(false);
 
-      // Member 不应该有添加成员的权限
+      // Members should not have permission to add members
       expect(
         calcPermission(ESpacePermisson.AddBotSpaceMember, [
           SpaceRoleType.Member,
         ]),
       ).toBe(false);
 
-      // Member 不应该有移除成员的权限
+      // Members should not have permission to remove members
       expect(
         calcPermission(ESpacePermisson.RemoveSpaceMember, [
           SpaceRoleType.Member,
         ]),
       ).toBe(false);
 
-      // Member 不应该有转移所有权的权限
+      // Members should not have permission to transfer ownership
       expect(
         calcPermission(ESpacePermisson.TransferSpace, [SpaceRoleType.Member]),
       ).toBe(false);
 
-      // Member 不应该有更新成员的权限
+      // Members should not have permission to update members
       expect(
         calcPermission(ESpacePermisson.UpdateSpaceMember, [
           SpaceRoleType.Member,
         ]),
       ).toBe(false);
 
-      // Member 不应该有管理 API 的权限
+      // Members should not have permission to manage APIs
       expect(calcPermission(ESpacePermisson.API, [SpaceRoleType.Member])).toBe(
         false,
       );
     });
 
     it('应该为 Default 角色返回正确的权限', () => {
-      // Default 不应该有任何权限
+      // Default should not have any permissions
       expect(
         calcPermission(ESpacePermisson.UpdateSpace, [SpaceRoleType.Default]),
       ).toBe(false);
@@ -196,7 +196,7 @@ describe('Space Calc Permission', () => {
     });
 
     it('应该处理多个角色的情况', () => {
-      // 当用户同时拥有 Member 和 Admin 角色时，应该有两个角色的所有权限
+      // When a user has both the Member and Admin roles, they should have all the permissions of both roles
       expect(
         calcPermission(ESpacePermisson.ExitSpace, [
           SpaceRoleType.Member,
@@ -211,7 +211,7 @@ describe('Space Calc Permission', () => {
         ]),
       ).toBe(true);
 
-      // 即使其中一个角色没有权限，只要有一个角色有权限，就应该返回 true
+      // Even if one of the roles has no permissions, it should return true as long as one of the roles has permissions.
       expect(
         calcPermission(ESpacePermisson.UpdateSpace, [
           SpaceRoleType.Member,
@@ -221,13 +221,13 @@ describe('Space Calc Permission', () => {
     });
 
     it('应该处理空角色数组', () => {
-      // 当没有角色时，应该返回 false
+      // When there is no role, it should return false.
       expect(calcPermission(ESpacePermisson.UpdateSpace, [])).toBe(false);
       expect(calcPermission(ESpacePermisson.ExitSpace, [])).toBe(false);
     });
 
     it('应该处理未知角色', () => {
-      // 当角色未知时，应该返回 false
+      // When the character is unknown, it should return false.
       expect(
         calcPermission(ESpacePermisson.UpdateSpace, [
           'UnknownRole' as unknown as SpaceRoleType,

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

@@ -22,7 +22,7 @@ import { ESpacePermisson } from '../../src/space/constants';
 describe('Space Constants', () => {
   describe('ESpacePermisson', () => {
     it('应该定义所有必要的权限点', () => {
-      // 验证所有权限点都已定义
+      // Verify that all permission spots are defined
       expect(ESpacePermisson.UpdateSpace).toBeDefined();
       expect(ESpacePermisson.DeleteSpace).toBeDefined();
       expect(ESpacePermisson.AddBotSpaceMember).toBeDefined();
@@ -34,17 +34,17 @@ describe('Space Constants', () => {
     });
 
     it('应该为每个权限点分配唯一的值', () => {
-      // 创建一个集合来存储所有权限点的值
+      // Create a collection to store the values of all permission spots
       const permissionValues = new Set();
 
-      // 获取所有权限点的值
+      // Get values for all permission spots
       Object.values(ESpacePermisson)
         .filter(value => typeof value === 'number')
         .forEach(value => {
           permissionValues.add(value);
         });
 
-      // 验证权限点的数量与唯一值的数量相同
+      // The number of validation permission spots is the same as the number of unique values
       const numericKeys = Object.keys(ESpacePermisson).filter(
         key => !isNaN(Number(key)),
       ).length;
@@ -55,10 +55,10 @@ describe('Space Constants', () => {
 
   describe('SpaceRoleType', () => {
     it('应该正确导出 SpaceRoleType', () => {
-      // 验证 SpaceRoleType 已正确导出
+      // Verify that SpaceRoleType has been exported correctly
       expect(SpaceRoleType).toBeDefined();
 
-      // 验证 SpaceRoleType 包含必要的角色
+      // Verify that SpaceRoleType contains the necessary roles
       expect(SpaceRoleType.Owner).toBeDefined();
       expect(SpaceRoleType.Admin).toBeDefined();
       expect(SpaceRoleType.Member).toBeDefined();

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

@@ -18,18 +18,18 @@ import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { renderHook, act } from '@testing-library/react-hooks';
 import { SpaceRoleType } from '@coze-arch/idl/developer_api';
 
-// 模拟全局变量
+// simulated global variable
 vi.stubGlobal('IS_DEV_MODE', true);
 
 describe('Space Auth Store', () => {
   beforeEach(() => {
-    // 重置模块缓存，确保每个测试都使用新的 store 实例
+    // Reset the module cache to ensure that each test uses a new store instance
     vi.resetModules();
   });
 
   describe('setRoles', () => {
     it('应该正确设置空间角色', async () => {
-      // 动态导入 store 模块，确保每次测试都获取新的实例
+      // Dynamically import the store module to ensure that each test gets a new instance
       const { useSpaceAuthStore } = await vi.importActual(
         '../../src/space/store',
       );
@@ -137,22 +137,22 @@ describe('Space Auth Store', () => {
       const { result } = renderHook(() => useSpaceAuthStore());
       const roles = [SpaceRoleType.Owner];
 
-      // 设置初始数据
+      // Set initial data
       await act(() => {
         result.current.setRoles('space1', roles);
         result.current.setIsReady('space1', true);
       });
 
-      // 验证数据已设置
+      // Verify that the data is set
       expect(result.current.roles.space1).toEqual(roles);
       expect(result.current.isReady.space1).toBe(true);
 
-      // 销毁数据
+      // Destroy data
       await act(() => {
         result.current.destory('space1');
       });
 
-      // 验证数据已清除
+      // Verify that the data has been cleared
       expect(result.current.roles.space1).toEqual([]);
       expect(result.current.isReady.space1).toBeUndefined();
     });
@@ -163,7 +163,7 @@ describe('Space Auth Store', () => {
       );
       const { result } = renderHook(() => useSpaceAuthStore());
 
-      // 设置两个空间的数据
+      // Set data for two spaces
       await act(() => {
         result.current.setRoles('space1', [SpaceRoleType.Owner]);
         result.current.setIsReady('space1', true);
@@ -171,16 +171,16 @@ describe('Space Auth Store', () => {
         result.current.setIsReady('space2', true);
       });
 
-      // 只销毁 space1 的数据
+      // Only destroy space1 data
       await act(() => {
         result.current.destory('space1');
       });
 
-      // 验证 space1 的数据已清除
+      // Verify that Space1's data has been cleared
       expect(result.current.roles.space1).toEqual([]);
       expect(result.current.isReady.space1).toBeUndefined();
 
-      // 验证 space2 的数据保持不变
+      // Verify that Space2's data remains unchanged
       expect(result.current.roles.space2).toEqual([SpaceRoleType.Member]);
       expect(result.current.isReady.space2).toBe(true);
     });
@@ -193,14 +193,14 @@ describe('Space Auth Store', () => {
       );
       const { result } = renderHook(() => useSpaceAuthStore());
 
-      // 重置 store 确保测试环境干净
+      // Reset store to ensure testing environment is clean
       await act(() => {
         Object.keys(result.current.roles).forEach(spaceId => {
           result.current.destory(spaceId);
         });
       });
 
-      // 验证初始状态
+      // Verify the initial state
       expect(result.current.roles).toEqual({});
       expect(result.current.isReady).toEqual({});
     });

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

@@ -17,38 +17,38 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { renderHook } from '@testing-library/react-hooks';
 
-// 模拟 React 的 useEffect
+// The useEffect of React
 const cleanupFns = new Map();
 vi.mock('react', () => ({
   useEffect: vi.fn((fn, deps) => {
-    // 执行 effect 函数并获取清理函数
+    // Execute the effect function and get the cleanup function
     const cleanup = fn();
-    // 存储清理函数，以便在 unmount 时调用
+    // Store the cleanup function to call when unmounted
     cleanupFns.set(fn, cleanup);
-    // 返回清理函数
+    // Return cleanup function
     return cleanup;
   }),
 }));
 
-// 模拟 store
+// Simulated store
 const mockDestory = vi.fn();
 vi.mock('../../src/space/store', () => ({
   useSpaceAuthStore: vi.fn(selector => selector({ destory: mockDestory })),
 }));
 
-// 创建一个包装函数，确保在 unmount 时调用清理函数
+// Create a wrapper function to ensure that the cleanup function is called when unmounted
 function renderHookWithCleanup(callback, options = {}) {
   const result = renderHook(callback, options);
   const originalUnmount = result.unmount;
 
   result.unmount = () => {
-    // 调用所有清理函数
+    // Call all cleanup functions
     cleanupFns.forEach(cleanup => {
       if (typeof cleanup === 'function') {
         cleanup();
       }
     });
-    // 调用原始的 unmount
+    // Call the original unmount
     originalUnmount();
   };
 
@@ -66,16 +66,16 @@ describe('useDestorySpace', () => {
   it('应该在组件卸载时调用 destory 方法', () => {
     const spaceId = 'test-space-id';
 
-    // 渲染 hook
+    // Render hook
     const { unmount } = renderHookWithCleanup(() => useDestorySpace(spaceId));
 
-    // 初始时不应调用 destory
+    // Destory should not be called initially
     expect(mockDestory).not.toHaveBeenCalled();
 
-    // 模拟组件卸载
+    // Simulate component uninstall
     unmount();
 
-    // 卸载时应调用 destory 并传入正确的 spaceId
+    // When uninstalling, call destory and pass in the correct spaceId.
     expect(mockDestory).toHaveBeenCalledTimes(1);
     expect(mockDestory).toHaveBeenCalledWith(spaceId);
   });
@@ -84,25 +84,25 @@ describe('useDestorySpace', () => {
     const spaceId1 = 'space-id-1';
     const spaceId2 = 'space-id-2';
 
-    // 渲染第一个 hook 实例
+    // Render the first hook instance
     const { unmount: unmount1 } = renderHookWithCleanup(() =>
       useDestorySpace(spaceId1),
     );
 
-    // 渲染第二个 hook 实例
+    // Render the second hook instance
     const { unmount: unmount2 } = renderHookWithCleanup(() =>
       useDestorySpace(spaceId2),
     );
 
-    // 卸载第一个实例
+    // Uninstall the first instance
     unmount1();
     expect(mockDestory).toHaveBeenCalledWith(spaceId1);
 
-    // 卸载第二个实例
+    // Uninstall the second instance
     unmount2();
     expect(mockDestory).toHaveBeenCalledWith(spaceId2);
 
-    // 总共应调用两次
+    // It should be called twice in total.
     expect(mockDestory).toHaveBeenCalledTimes(4);
   });
 });

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

@@ -20,12 +20,12 @@ import { SpaceRoleType } from '@coze-arch/idl/developer_api';
 
 import { ESpacePermisson } from '../../src/space/constants';
 
-// 模拟 useSpaceRole
+// Simulation useSpaceRole
 vi.mock('../../src/space/use-space-role', () => ({
   useSpaceRole: vi.fn(),
 }));
 
-// 模拟 calcPermission
+// simulated calcPermission
 vi.mock('../../src/space/calc-permission', () => ({
   calcPermission: vi.fn(),
 }));
@@ -40,26 +40,26 @@ describe('useSpaceAuth', () => {
     const permissionKey = ESpacePermisson.UpdateSpace;
     const mockRoles = [SpaceRoleType.Owner];
 
-    // 模拟 useSpaceRole 返回角色
+    // Simulate useSpaceRole return role
     (useSpaceRole as unknown as ReturnType<typeof vi.fn>).mockReturnValue(
       mockRoles,
     );
 
-    // 模拟 calcPermission 返回权限结果
+    // Simulate calcPermission return permission result
     (calcPermission as unknown as ReturnType<typeof vi.fn>).mockReturnValue(
       true,
     );
 
-    // 渲染 hook
+    // Render hook
     const { result } = renderHook(() => useSpaceAuth(permissionKey, spaceId));
 
-    // 验证 useSpaceRole 被调用，并传入正确的 spaceId
+    // Verify that useSpaceRole is called, passing in the correct spaceId.
     expect(useSpaceRole).toHaveBeenCalledWith(spaceId);
 
-    // 验证 calcPermission 被调用，并传入正确的参数
+    // Verify that calcPermission is called, passing in the correct parameters
     expect(calcPermission).toHaveBeenCalledWith(permissionKey, mockRoles);
 
-    // 验证返回值与 calcPermission 的返回值一致
+    // Verify that the return value is consistent with the return value of calcPermission
     expect(result.current).toBe(true);
   });
 
@@ -68,20 +68,20 @@ describe('useSpaceAuth', () => {
     const permissionKey = ESpacePermisson.UpdateSpace;
     const mockRoles = [SpaceRoleType.Member];
 
-    // 模拟 useSpaceRole 返回角色
+    // Simulate useSpaceRole return role
     (useSpaceRole as unknown as ReturnType<typeof vi.fn>).mockReturnValue(
       mockRoles,
     );
 
-    // 模拟 calcPermission 返回权限结果
+    // Simulate calcPermission return permission result
     (calcPermission as unknown as ReturnType<typeof vi.fn>).mockReturnValue(
       false,
     );
 
-    // 渲染 hook
+    // Render hook
     const { result } = renderHook(() => useSpaceAuth(permissionKey, spaceId));
 
-    // 验证返回值与 calcPermission 的返回值一致
+    // Verify that the return value is consistent with the return value of calcPermission
     expect(result.current).toBe(false);
   });
 
@@ -90,23 +90,23 @@ describe('useSpaceAuth', () => {
     const permissionKey = ESpacePermisson.UpdateSpace;
     const mockRoles: SpaceRoleType[] = [];
 
-    // 模拟 useSpaceRole 返回空角色数组
+    // Simulate useSpaceRole returns an empty character array
     (useSpaceRole as unknown as ReturnType<typeof vi.fn>).mockReturnValue(
       mockRoles,
     );
 
-    // 模拟 calcPermission 返回权限结果
+    // Simulate calcPermission return permission result
     (calcPermission as unknown as ReturnType<typeof vi.fn>).mockReturnValue(
       false,
     );
 
-    // 渲染 hook
+    // Render hook
     const { result } = renderHook(() => useSpaceAuth(permissionKey, spaceId));
 
-    // 验证 calcPermission 被调用，并传入正确的参数
+    // Verify that calcPermission is called, passing in the correct parameters
     expect(calcPermission).toHaveBeenCalledWith(permissionKey, mockRoles);
 
-    // 验证返回值与 calcPermission 的返回值一致
+    // Verify that the return value is consistent with the return value of calcPermission
     expect(result.current).toBe(false);
   });
 });

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

@@ -20,23 +20,23 @@ import { SpaceRoleType } from '@coze-arch/idl/developer_api';
 
 import { useSpaceAuthStore } from '../../src/space/store';
 
-// 模拟 zustand
+// Analog zustand
 vi.mock('zustand/react/shallow', () => ({
   useShallow: fn => fn,
 }));
 
-// 模拟 foundation-sdk
+// Simulation foundation-sdk
 const mockUseSpace = vi.fn();
 vi.mock('@coze-arch/foundation-sdk', () => ({
   useSpace: (...args) => mockUseSpace(...args),
 }));
 
-// 模拟 store
+// Simulated store
 vi.mock('../../src/space/store', () => ({
   useSpaceAuthStore: vi.fn(),
 }));
 
-// 导入实际模块，确保在模拟之后导入
+// Import the actual module, make sure to import it after simulation
 import { useSpaceRole } from '../../src/space/use-space-role';
 
 describe('useSpaceRole', () => {
@@ -49,40 +49,40 @@ describe('useSpaceRole', () => {
     const mockSpace = { id: spaceId, name: 'Test Space' };
     const mockRoles = [SpaceRoleType.Owner];
 
-    // 模拟 useSpace 返回 space 对象
+    // Simulate useSpace Return space object
     mockUseSpace.mockReturnValue(mockSpace);
 
-    // 模拟 useSpaceAuthStore 返回 isReady 和 role
+    // Emulate useSpaceAuthStore returns isReady and role
     (useSpaceAuthStore as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
       isReady: true,
       role: mockRoles,
     });
 
-    // 渲染 hook
+    // Render hook
     const { result } = renderHook(() => useSpaceRole(spaceId));
 
-    // 验证 useSpace 被调用，并传入正确的 spaceId
+    // Verify that useSpace is called, passing in the correct spaceId.
     expect(mockUseSpace).toHaveBeenCalledWith(spaceId);
 
-    // 验证 useSpaceAuthStore 被调用，并传入正确的选择器
+    // Verify that useSpaceAuthStore is called, passing in the correct selector
     expect(useSpaceAuthStore).toHaveBeenCalled();
 
-    // 验证返回值与预期一致
+    // Verify that the return value is as expected
     expect(result.current).toEqual(mockRoles);
   });
 
   it('应该在 space 不存在时抛出错误', () => {
     const spaceId = 'test-space-id';
 
-    // 模拟 useSpace 返回 null
+    // Simulate useSpace returns null
     mockUseSpace.mockReturnValue(null);
 
-    // 使用 vi.spyOn 监听 console.error 以防止测试输出错误信息
+    // Use vi.spyOn to listen to console.error to prevent test output error messages
     vi.spyOn(console, 'error').mockImplementation(() => {
-      // 空实现，防止错误输出
+      // Empty implementation to prevent error output
     });
 
-    // 验证渲染 hook 时抛出错误
+    // Error thrown while validating render hook
     expect(() => useSpaceRole(spaceId)).toThrow(
       'useSpaceAuth must be used after space list has been pulled.',
     );
@@ -92,21 +92,21 @@ describe('useSpaceRole', () => {
     const spaceId = 'test-space-id';
     const mockSpace = { id: spaceId, name: 'Test Space' };
 
-    // 模拟 useSpace 返回 space 对象
+    // Simulate useSpace Return space object
     mockUseSpace.mockReturnValue(mockSpace);
 
-    // 模拟 useSpaceAuthStore 返回 isReady 为 false
+    // Emulate useSpaceAuthStore returns isReady to false
     (useSpaceAuthStore as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
       isReady: false,
       role: null,
     });
 
-    // 使用 vi.spyOn 监听 console.error 以防止测试输出错误信息
+    // Use vi.spyOn to listen to console.error to prevent test output error messages
     vi.spyOn(console, 'error').mockImplementation(() => {
-      // 空实现，防止错误输出
+      // Empty implementation to prevent error output
     });
 
-    // 验证渲染 hook 时抛出错误
+    // Error thrown while validating render hook
     expect(() => useSpaceRole(spaceId)).toThrow(
       'useSpaceAuth must be used after useInitSpaceRole has been completed.',
     );
@@ -116,21 +116,21 @@ describe('useSpaceRole', () => {
     const spaceId = 'test-space-id';
     const mockSpace = { id: spaceId, name: 'Test Space' };
 
-    // 模拟 useSpace 返回 space 对象
+    // Simulate useSpace Return space object
     mockUseSpace.mockReturnValue(mockSpace);
 
-    // 模拟 useSpaceAuthStore 返回 isReady 为 true，但 role 为 null
+    // Emulate useSpaceAuthStore returns isReady as true, but role as null
     (useSpaceAuthStore as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
       isReady: true,
       role: null,
     });
 
-    // 使用 vi.spyOn 监听 console.error 以防止测试输出错误信息
+    // Use vi.spyOn to listen to console.error to prevent test output error messages
     vi.spyOn(console, 'error').mockImplementation(() => {
-      // 空实现，防止错误输出
+      // Empty implementation to prevent error output
     });
 
-    // 验证渲染 hook 时抛出错误
+    // Error thrown while validating render hook
     expect(() => useSpaceRole(spaceId)).toThrow(
       `Can not get space role of space: ${spaceId}`,
     );