🐛 fix: fix desktop upload image on macOS (lobehub#7741)

* fix image

* fix

* fix lint

* fix

* add tests

* update testss

* remove tests

* try to fix

* try to fix desktop image issue

* Revert "try to fix desktop image issue"

This reverts commit 8dad8f3.

Author: arvinxx

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,
+      });
+    });
+  });
+}); 

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();
+    });
+  });
+});

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);
+    });
+  });
+}); 

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);
+    });
+  });
+});