@lobehub/chat 1.84.24 → 1.84.25

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+### [Version 1.84.25](https://github.com/lobehub/lobe-chat/compare/v1.84.24...v1.84.25)
+
+<sup>Released on **2025-05-08**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix desktop upload image on macOS.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Fix desktop upload image on macOS, closes [#7741](https://github.com/lobehub/lobe-chat/issues/7741) ([07d5374](https://github.com/lobehub/lobe-chat/commit/07d5374))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ### [Version 1.84.24](https://github.com/lobehub/lobe-chat/compare/v1.84.23...v1.84.24)
 
 <sup>Released on **2025-05-08**</sup>

package/apps/desktop/src/main/controllers/__tests__/BrowserWindowsCtr.test.ts

@@ -0,0 +1,195 @@
+import { beforeEach, describe, expect, it, vi, Mock } from 'vitest';
+import { InterceptRouteParams } from '@lobechat/electron-client-ipc';
+
+import type { App } from '@/core/App';
+import type { IpcClientEventSender } from '@/types/ipcClientEvent';
+import { BrowsersIdentifiers, AppBrowsersIdentifiers } from '@/appBrowsers';
+
+import BrowserWindowsCtr from '../BrowserWindowsCtr';
+
+// 模拟 App 及其依赖项
+const mockToggleVisible = vi.fn();
+const mockShowSettingsWindowWithTab = vi.fn();
+const mockCloseWindow = vi.fn();
+const mockMinimizeWindow = vi.fn();
+const mockMaximizeWindow = vi.fn();
+const mockRetrieveByIdentifier = vi.fn();
+const mockGetMainWindow = vi.fn(() => ({
+  toggleVisible: mockToggleVisible,
+}));
+const mockShow = vi.fn();
+
+// mock findMatchingRoute and extractSubPath
+vi.mock('~common/routes', async () => ({
+  findMatchingRoute: vi.fn(),
+  extractSubPath: vi.fn(),
+}));
+const { findMatchingRoute, extractSubPath } = await import('~common/routes');
+
+const mockApp = {
+  browserManager: {
+    getMainWindow: mockGetMainWindow,
+    showSettingsWindowWithTab: mockShowSettingsWindowWithTab,
+    closeWindow: mockCloseWindow,
+    minimizeWindow: mockMinimizeWindow,
+    maximizeWindow: mockMaximizeWindow,
+    retrieveByIdentifier: mockRetrieveByIdentifier.mockImplementation((identifier: AppBrowsersIdentifiers | string) => {
+      if (identifier === BrowsersIdentifiers.settings || identifier === 'some-other-window') {
+        return { show: mockShow };
+      }
+      return { show: mockShow }; // Default mock for other identifiers
+    }),
+  },
+} as unknown as App;
+
+describe('BrowserWindowsCtr', () => {
+  let browserWindowsCtr: BrowserWindowsCtr;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    browserWindowsCtr = new BrowserWindowsCtr(mockApp);
+  });
+
+  describe('toggleMainWindow', () => {
+    it('should get the main window and toggle its visibility', async () => {
+      await browserWindowsCtr.toggleMainWindow();
+      expect(mockGetMainWindow).toHaveBeenCalled();
+      expect(mockToggleVisible).toHaveBeenCalled();
+    });
+  });
+
+  describe('openSettingsWindow', () => {
+    it('should show the settings window with the specified tab', async () => {
+      const tab = 'appearance';
+      const result = await browserWindowsCtr.openSettingsWindow(tab);
+      expect(mockShowSettingsWindowWithTab).toHaveBeenCalledWith(tab);
+      expect(result).toEqual({ success: true });
+    });
+
+    it('should return error if showing settings window fails', async () => {
+      const errorMessage = 'Failed to show';
+      mockShowSettingsWindowWithTab.mockRejectedValueOnce(new Error(errorMessage));
+      const result = await browserWindowsCtr.openSettingsWindow('display');
+      expect(result).toEqual({ error: errorMessage, success: false });
+    });
+  });
+
+  const testSenderIdentifierString: string = 'test-window-event-id';
+  const sender: IpcClientEventSender = {
+    identifier: testSenderIdentifierString,
+  };
+
+  describe('closeWindow', () => {
+    it('should close the window with the given sender identifier', () => {
+      browserWindowsCtr.closeWindow(undefined, sender);
+      expect(mockCloseWindow).toHaveBeenCalledWith(testSenderIdentifierString);
+    });
+  });
+
+  describe('minimizeWindow', () => {
+    it('should minimize the window with the given sender identifier', () => {
+      browserWindowsCtr.minimizeWindow(undefined, sender);
+      expect(mockMinimizeWindow).toHaveBeenCalledWith(testSenderIdentifierString);
+    });
+  });
+
+  describe('maximizeWindow', () => {
+    it('should maximize the window with the given sender identifier', () => {
+      browserWindowsCtr.maximizeWindow(undefined, sender);
+      expect(mockMaximizeWindow).toHaveBeenCalledWith(testSenderIdentifierString);
+    });
+  });
+
+  describe('interceptRoute', () => {
+    const baseParams = { source: 'link-click' as const };
+
+    it('should not intercept if no matching route is found', async () => {
+      const params: InterceptRouteParams = { ...baseParams, path: '/unknown/route', url: 'app://host/unknown/route' };
+      (findMatchingRoute as Mock).mockReturnValue(undefined);
+      const result = await browserWindowsCtr.interceptRoute(params);
+      expect(findMatchingRoute).toHaveBeenCalledWith(params.path);
+      expect(result).toEqual({ intercepted: false, path: params.path, source: params.source });
+    });
+
+    it('should show settings window if matched route target is settings', async () => {
+      const params: InterceptRouteParams = { ...baseParams, path: '/settings/common', url: 'app://host/settings/common' };
+      const matchedRoute = { targetWindow: BrowsersIdentifiers.settings, pathPrefix: '/settings' };
+      const subPath = 'common';
+      (findMatchingRoute as Mock).mockReturnValue(matchedRoute);
+      (extractSubPath as Mock).mockReturnValue(subPath);
+
+      const result = await browserWindowsCtr.interceptRoute(params);
+
+      expect(findMatchingRoute).toHaveBeenCalledWith(params.path);
+      expect(extractSubPath).toHaveBeenCalledWith(params.path, matchedRoute.pathPrefix);
+      expect(mockShowSettingsWindowWithTab).toHaveBeenCalledWith(subPath);
+      expect(result).toEqual({
+        intercepted: true,
+        path: params.path,
+        source: params.source,
+        subPath,
+        targetWindow: matchedRoute.targetWindow,
+      });
+      expect(mockShow).not.toHaveBeenCalled();
+    });
+
+    it('should open target window if matched route target is not settings', async () => {
+      const params: InterceptRouteParams = { ...baseParams, path: '/other/page', url: 'app://host/other/page' };
+      const targetWindowIdentifier = 'some-other-window' as AppBrowsersIdentifiers;
+      const matchedRoute = { targetWindow: targetWindowIdentifier, pathPrefix: '/other' };
+      (findMatchingRoute as Mock).mockReturnValue(matchedRoute);
+
+      const result = await browserWindowsCtr.interceptRoute(params);
+
+      expect(findMatchingRoute).toHaveBeenCalledWith(params.path);
+      expect(mockRetrieveByIdentifier).toHaveBeenCalledWith(targetWindowIdentifier);
+      expect(mockShow).toHaveBeenCalled();
+      expect(result).toEqual({
+        intercepted: true,
+        path: params.path,
+        source: params.source,
+        targetWindow: matchedRoute.targetWindow,
+      });
+      expect(mockShowSettingsWindowWithTab).not.toHaveBeenCalled();
+    });
+
+    it('should return error if processing route interception fails for settings', async () => {
+      const params: InterceptRouteParams = { ...baseParams, path: '/settings/general', url: 'app://host/settings/general' };
+      const matchedRoute = { targetWindow: BrowsersIdentifiers.settings, pathPrefix: '/settings' };
+      const subPath = 'general';
+      const errorMessage = 'Processing error for settings';
+      (findMatchingRoute as Mock).mockReturnValue(matchedRoute);
+      (extractSubPath as Mock).mockReturnValue(subPath);
+      mockShowSettingsWindowWithTab.mockRejectedValueOnce(new Error(errorMessage));
+
+      const result = await browserWindowsCtr.interceptRoute(params);
+
+      expect(result).toEqual({
+        error: errorMessage,
+        intercepted: false,
+        path: params.path,
+        source: params.source,
+      });
+    });
+
+    it('should return error if processing route interception fails for other window', async () => {
+      const params: InterceptRouteParams = { ...baseParams, path: '/another/custom', url: 'app://host/another/custom' };
+      const targetWindowIdentifier = 'another-custom-window' as AppBrowsersIdentifiers;
+      const matchedRoute = { targetWindow: targetWindowIdentifier, pathPrefix: '/another' };
+      const errorMessage = 'Processing error for other window';
+      (findMatchingRoute as Mock).mockReturnValue(matchedRoute);
+      mockRetrieveByIdentifier.mockImplementationOnce(() => {
+        throw new Error(errorMessage);
+      });
+
+      const result = await browserWindowsCtr.interceptRoute(params);
+
+      expect(result).toEqual({
+        error: errorMessage,
+        intercepted: false,
+        path: params.path,
+        source: params.source,
+      });
+    });
+  });
+}); 

package/apps/desktop/src/main/controllers/__tests__/DevtoolsCtr.test.ts

@@ -0,0 +1,44 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { App } from '@/core/App';
+
+import DevtoolsCtr from '../DevtoolsCtr';
+
+// 模拟 App 及其依赖项
+const mockShow = vi.fn();
+const mockRetrieveByIdentifier = vi.fn(() => ({
+  show: mockShow,
+}));
+
+// 创建一个足够模拟 App 行为的对象，以满足 DevtoolsCtr 的需求
+const mockApp = {
+  browserManager: {
+    retrieveByIdentifier: mockRetrieveByIdentifier,
+  },
+  // 如果 DevtoolsCtr 或其基类在构造或方法调用中使用了 app 的其他属性/方法，
+  // 也需要在这里添加相应的模拟
+} as unknown as App; // 使用类型断言，因为我们只模拟了部分 App 结构
+
+describe('DevtoolsCtr', () => {
+  let devtoolsCtr: DevtoolsCtr;
+
+  beforeEach(() => {
+    vi.clearAllMocks(); // 只清除 vi.fn() 创建的模拟函数的记录，不影响 IoCContainer 状态
+
+    // 实例化 DevtoolsCtr。
+    // 它将继承自真实的 ControllerModule。
+    // 其 @ipcClientEvent 装饰器会执行并与真实的 IoCContainer 交互。
+    devtoolsCtr = new DevtoolsCtr(mockApp);
+  });
+
+  describe('openDevtools', () => {
+    it('should retrieve the devtools browser window using app.browserManager and show it', async () => {
+      await devtoolsCtr.openDevtools();
+
+      // 验证 browserManager.retrieveByIdentifier 是否以 'devtools' 参数被调用
+      expect(mockRetrieveByIdentifier).toHaveBeenCalledWith('devtools');
+      // 验证返回对象的 show 方法是否被调用
+      expect(mockShow).toHaveBeenCalled();
+    });
+  });
+});

package/apps/desktop/src/main/controllers/__tests__/MenuCtr.test.ts

@@ -0,0 +1,82 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { App } from '@/core/App';
+
+import MenuController from '../MenuCtr';
+
+// 模拟 App 及其依赖项
+const mockRefreshMenus = vi.fn();
+const mockShowContextMenu = vi.fn();
+const mockRebuildAppMenu = vi.fn();
+
+const mockApp = {
+  menuManager: {
+    refreshMenus: mockRefreshMenus,
+    showContextMenu: mockShowContextMenu,
+    rebuildAppMenu: mockRebuildAppMenu,
+  },
+} as unknown as App;
+
+describe('MenuController', () => {
+  let menuController: MenuController;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    menuController = new MenuController(mockApp);
+  });
+
+  describe('refreshAppMenu', () => {
+    it('should call menuManager.refreshMenus', () => {
+      // 模拟返回值
+      mockRefreshMenus.mockReturnValueOnce(true);
+      
+      const result = menuController.refreshAppMenu();
+      
+      expect(mockRefreshMenus).toHaveBeenCalled();
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('showContextMenu', () => {
+    it('should call menuManager.showContextMenu with type only', () => {
+      const menuType = 'chat';
+      mockShowContextMenu.mockReturnValueOnce({ shown: true });
+      
+      const result = menuController.showContextMenu(menuType);
+      
+      expect(mockShowContextMenu).toHaveBeenCalledWith(menuType, undefined);
+      expect(result).toEqual({ shown: true });
+    });
+
+    it('should call menuManager.showContextMenu with type and data', () => {
+      const menuType = 'file';
+      const menuData = { fileId: '123', filePath: '/path/to/file.txt' };
+      mockShowContextMenu.mockReturnValueOnce({ shown: true });
+      
+      const result = menuController.showContextMenu(menuType, menuData);
+      
+      expect(mockShowContextMenu).toHaveBeenCalledWith(menuType, menuData);
+      expect(result).toEqual({ shown: true });
+    });
+  });
+
+  describe('setDevMenuVisibility', () => {
+    it('should call menuManager.rebuildAppMenu with showDevItems true', () => {
+      mockRebuildAppMenu.mockReturnValueOnce(true);
+      
+      const result = menuController.setDevMenuVisibility(true);
+      
+      expect(mockRebuildAppMenu).toHaveBeenCalledWith({ showDevItems: true });
+      expect(result).toBe(true);
+    });
+
+    it('should call menuManager.rebuildAppMenu with showDevItems false', () => {
+      mockRebuildAppMenu.mockReturnValueOnce(true);
+      
+      const result = menuController.setDevMenuVisibility(false);
+      
+      expect(mockRebuildAppMenu).toHaveBeenCalledWith({ showDevItems: false });
+      expect(result).toBe(true);
+    });
+  });
+}); 

package/apps/desktop/src/main/controllers/__tests__/ShortcutCtr.test.ts

@@ -0,0 +1,64 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { App } from '@/core/App';
+
+import ShortcutController from '../ShortcutCtr';
+
+// 模拟 App 及其依赖项
+const mockGetShortcutsConfig = vi.fn().mockReturnValue({ 
+  toggleMainWindow: 'CommandOrControl+Shift+L',
+  openSettings: 'CommandOrControl+,'
+});
+const mockUpdateShortcutConfig = vi.fn().mockImplementation((id, accelerator) => {
+  // 简单模拟更新成功
+  return true;
+});
+
+const mockApp = {
+  shortcutManager: {
+    getShortcutsConfig: mockGetShortcutsConfig,
+    updateShortcutConfig: mockUpdateShortcutConfig,
+  },
+} as unknown as App;
+
+describe('ShortcutController', () => {
+  let shortcutController: ShortcutController;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    shortcutController = new ShortcutController(mockApp);
+  });
+
+  describe('getShortcutsConfig', () => {
+    it('should return shortcuts config from shortcutManager', () => {
+      const result = shortcutController.getShortcutsConfig();
+      
+      expect(mockGetShortcutsConfig).toHaveBeenCalled();
+      expect(result).toEqual({
+        toggleMainWindow: 'CommandOrControl+Shift+L',
+        openSettings: 'CommandOrControl+,'
+      });
+    });
+  });
+
+  describe('updateShortcutConfig', () => {
+    it('should call shortcutManager.updateShortcutConfig with correct parameters', () => {
+      const id = 'toggleMainWindow';
+      const accelerator = 'CommandOrControl+Alt+L';
+      
+      const result = shortcutController.updateShortcutConfig(id, accelerator);
+      
+      expect(mockUpdateShortcutConfig).toHaveBeenCalledWith(id, accelerator);
+      expect(result).toBe(true);
+    });
+
+    it('should return the result from shortcutManager.updateShortcutConfig', () => {
+      // 模拟更新失败的情况
+      mockUpdateShortcutConfig.mockReturnValueOnce(false);
+      
+      const result = shortcutController.updateShortcutConfig('invalidKey', 'invalid+combo');
+      
+      expect(result).toBe(false);
+    });
+  });
+}); 

package/apps/desktop/src/main/controllers/__tests__/TrayMenuCtr.test.ts

@@ -0,0 +1,256 @@
+import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { 
+  ShowTrayNotificationParams,
+  UpdateTrayIconParams,
+  UpdateTrayTooltipParams
+} from '@lobechat/electron-client-ipc';
+
+import type { App } from '@/core/App';
+
+// 模拟 logger
+vi.mock('@/utils/logger', () => ({
+  createLogger: () => ({
+    debug: vi.fn(),
+    error: vi.fn(),
+  }),
+}));
+
+import TrayMenuCtr from '../TrayMenuCtr';
+
+// 保存原始平台，确保测试结束后能恢复
+const originalPlatform = process.platform;
+
+// 模拟 App 及其依赖项
+const mockToggleVisible = vi.fn();
+const mockGetMainWindow = vi.fn(() => ({
+  toggleVisible: mockToggleVisible,
+}));
+
+const mockDisplayBalloon = vi.fn();
+const mockUpdateIcon = vi.fn();
+const mockUpdateTooltip = vi.fn();
+const mockGetMainTray = vi.fn();
+
+const mockApp = {
+  browserManager: {
+    getMainWindow: mockGetMainWindow,
+  },
+  trayManager: {
+    getMainTray: mockGetMainTray,
+  },
+} as unknown as App;
+
+describe('TrayMenuCtr', () => {
+  let trayMenuCtr: TrayMenuCtr;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // 为每个测试重置 mockedTray
+    mockGetMainTray.mockReset();
+    trayMenuCtr = new TrayMenuCtr(mockApp);
+  });
+
+  // 在所有测试完成后恢复平台设置
+  afterAll(() => {
+    // 恢复原始平台
+    Object.defineProperty(process, 'platform', { value: originalPlatform });
+  });
+
+  describe('toggleMainWindow', () => {
+    it('should get the main window and toggle its visibility', async () => {
+      await trayMenuCtr.toggleMainWindow();
+
+      expect(mockGetMainWindow).toHaveBeenCalled();
+      expect(mockToggleVisible).toHaveBeenCalled();
+    });
+  });
+
+  describe('showNotification', () => {
+    it('should display balloon notification on Windows platform', async () => {
+      // 模拟 Windows 平台
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+      
+      const mockedTray = {
+        displayBalloon: mockDisplayBalloon,
+      };
+      mockGetMainTray.mockReturnValue(mockedTray);
+
+      const options: ShowTrayNotificationParams = {
+        title: 'Test Notification',
+        content: 'This is a test notification',
+        iconType: 'info',
+      };
+
+      const result = await trayMenuCtr.showNotification(options);
+
+      expect(mockGetMainTray).toHaveBeenCalled();
+      expect(mockDisplayBalloon).toHaveBeenCalledWith({
+        title: options.title,
+        content: options.content,
+        iconType: options.iconType,
+      });
+      expect(result).toEqual({ success: true });
+    });
+
+    it('should return error when not on Windows platform', async () => {
+      // 模拟非 Windows 平台
+      Object.defineProperty(process, 'platform', { value: 'darwin' });
+
+      const options: ShowTrayNotificationParams = {
+        title: 'Test Notification',
+        content: 'This is a test notification',
+      };
+
+      const result = await trayMenuCtr.showNotification(options);
+
+      expect(mockGetMainTray).not.toHaveBeenCalled();
+      expect(mockDisplayBalloon).not.toHaveBeenCalled();
+      expect(result).toEqual({
+        error: '托盘通知仅在 Windows 平台支持',
+        success: false,
+      });
+    });
+
+    it('should return error when tray is not available on Windows', async () => {
+      // 模拟 Windows 平台但没有托盘
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+      mockGetMainTray.mockReturnValue(null);
+
+      const options: ShowTrayNotificationParams = {
+        title: 'Test Notification',
+        content: 'This is a test notification',
+      };
+
+      const result = await trayMenuCtr.showNotification(options);
+
+      expect(mockGetMainTray).toHaveBeenCalled();
+      expect(mockDisplayBalloon).not.toHaveBeenCalled();
+      expect(result).toEqual({ 
+        error: '托盘通知仅在 Windows 平台支持',
+        success: false
+      });
+    });
+  });
+
+  describe('updateTrayIcon', () => {
+    it('should update tray icon on Windows platform', async () => {
+      // 模拟 Windows 平台
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+      
+      const mockedTray = {
+        updateIcon: mockUpdateIcon,
+      };
+      mockGetMainTray.mockReturnValue(mockedTray);
+
+      const options: UpdateTrayIconParams = {
+        iconPath: '/path/to/icon.png',
+      };
+
+      const result = await trayMenuCtr.updateTrayIcon(options);
+
+      expect(mockGetMainTray).toHaveBeenCalled();
+      expect(mockUpdateIcon).toHaveBeenCalledWith(options.iconPath);
+      expect(result).toEqual({ success: true });
+    });
+
+    it('should handle errors when updating icon', async () => {
+      // 模拟 Windows 平台
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+      
+      const error = new Error('Failed to update icon');
+      const mockedTray = {
+        updateIcon: vi.fn().mockImplementation(() => {
+          throw error;
+        }),
+      };
+      mockGetMainTray.mockReturnValue(mockedTray);
+
+      const options: UpdateTrayIconParams = {
+        iconPath: '/path/to/icon.png',
+      };
+
+      const result = await trayMenuCtr.updateTrayIcon(options);
+
+      expect(result).toEqual({
+        error: String(error),
+        success: false,
+      });
+    });
+
+    it('should return error when not on Windows platform', async () => {
+      // 模拟非 Windows 平台
+      Object.defineProperty(process, 'platform', { value: 'darwin' });
+
+      const options: UpdateTrayIconParams = {
+        iconPath: '/path/to/icon.png',
+      };
+
+      const result = await trayMenuCtr.updateTrayIcon(options);
+
+      expect(result).toEqual({
+        error: '托盘功能仅在 Windows 平台支持',
+        success: false,
+      });
+    });
+  });
+
+  describe('updateTrayTooltip', () => {
+    it('should update tray tooltip on Windows platform', async () => {
+      // 模拟 Windows 平台
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+      
+      const mockedTray = {
+        updateTooltip: mockUpdateTooltip,
+      };
+      mockGetMainTray.mockReturnValue(mockedTray);
+
+      const options: UpdateTrayTooltipParams = {
+        tooltip: 'New tooltip text',
+      };
+
+      const result = await trayMenuCtr.updateTrayTooltip(options);
+
+      expect(mockGetMainTray).toHaveBeenCalled();
+      expect(mockUpdateTooltip).toHaveBeenCalledWith(options.tooltip);
+      expect(result).toEqual({ success: true });
+    });
+
+    it('should return error when not on Windows platform', async () => {
+      // 模拟非 Windows 平台
+      Object.defineProperty(process, 'platform', { value: 'darwin' });
+
+      const options: UpdateTrayTooltipParams = {
+        tooltip: 'New tooltip text',
+      };
+
+      const result = await trayMenuCtr.updateTrayTooltip(options);
+
+      expect(result).toEqual({
+        error: '托盘功能仅在 Windows 平台支持',
+        success: false,
+      });
+    });
+
+    it('should return error when tooltip is not provided', async () => {
+      // 模拟 Windows 平台
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+      
+      const mockedTray = {
+        updateTooltip: mockUpdateTooltip,
+      };
+      mockGetMainTray.mockReturnValue(mockedTray);
+
+      const options: UpdateTrayTooltipParams = {
+        tooltip: undefined as any,
+      };
+
+      const result = await trayMenuCtr.updateTrayTooltip(options);
+
+      expect(mockUpdateTooltip).not.toHaveBeenCalled();
+      expect(result).toEqual({
+        error: '托盘功能仅在 Windows 平台支持',
+        success: false,
+      });
+    });
+  });
+});