@lobehub/lobehub 2.0.0-next.142 → 2.0.0-next.143

package/apps/desktop/src/main/utils/__tests__/logger.test.ts

@@ -0,0 +1,229 @@
+import debug from 'debug';
+import electronLog from 'electron-log';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { createLogger } from '../logger';
+
+vi.mock('debug');
+vi.mock('electron-log', () => ({
+  default: {
+    transports: {
+      file: { level: 'info' },
+      console: { level: 'warn' },
+    },
+    error: vi.fn(),
+    info: vi.fn(),
+    verbose: vi.fn(),
+    warn: vi.fn(),
+  },
+}));
+
+describe('logger', () => {
+  const mockDebugLogger = vi.fn();
+
+  beforeEach(() => {
+    vi.mocked(debug).mockReturnValue(mockDebugLogger as any);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    delete process.env.NODE_ENV;
+    delete process.env.DEBUG_VERBOSE;
+  });
+
+  describe('createLogger', () => {
+    it('should create logger with correct namespace', () => {
+      const namespace = 'test:logger';
+      createLogger(namespace);
+
+      expect(debug).toHaveBeenCalledWith(namespace);
+    });
+
+    it('should return logger object with all methods', () => {
+      const logger = createLogger('test:logger');
+
+      expect(logger).toHaveProperty('debug');
+      expect(logger).toHaveProperty('error');
+      expect(logger).toHaveProperty('info');
+      expect(logger).toHaveProperty('verbose');
+      expect(logger).toHaveProperty('warn');
+      expect(typeof logger.debug).toBe('function');
+      expect(typeof logger.error).toBe('function');
+      expect(typeof logger.info).toBe('function');
+      expect(typeof logger.verbose).toBe('function');
+      expect(typeof logger.warn).toBe('function');
+    });
+  });
+
+  describe('logger.debug', () => {
+    it('should call debug logger with message and args', () => {
+      const logger = createLogger('test:debug');
+      logger.debug('test message', { data: 'value' });
+
+      expect(mockDebugLogger).toHaveBeenCalledWith('test message', { data: 'value' });
+    });
+
+    it('should handle multiple arguments', () => {
+      const logger = createLogger('test:debug');
+      logger.debug('message', 'arg1', 'arg2', 'arg3');
+
+      expect(mockDebugLogger).toHaveBeenCalledWith('message', 'arg1', 'arg2', 'arg3');
+    });
+  });
+
+  describe('logger.error', () => {
+    it('should use electronLog.error in production', () => {
+      process.env.NODE_ENV = 'production';
+      const logger = createLogger('test:error');
+      logger.error('error message', { error: 'details' });
+
+      expect(electronLog.error).toHaveBeenCalledWith('error message', { error: 'details' });
+      expect(mockDebugLogger).not.toHaveBeenCalled();
+    });
+
+    it('should use console.error in development', () => {
+      process.env.NODE_ENV = 'development';
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const logger = createLogger('test:error');
+      logger.error('error message', { error: 'details' });
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith('error message', { error: 'details' });
+      expect(electronLog.error).not.toHaveBeenCalled();
+
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should default to console.error when NODE_ENV is not set', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const logger = createLogger('test:error');
+      logger.error('error message');
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith('error message');
+      expect(electronLog.error).not.toHaveBeenCalled();
+
+      consoleErrorSpy.mockRestore();
+    });
+  });
+
+  describe('logger.info', () => {
+    it('should use electronLog.info with namespace in production', () => {
+      process.env.NODE_ENV = 'production';
+      const logger = createLogger('test:info');
+      logger.info('info message', { data: 'value' });
+
+      expect(electronLog.info).toHaveBeenCalledWith('[test:info]', 'info message', {
+        data: 'value',
+      });
+      expect(mockDebugLogger).toHaveBeenCalledWith('INFO: info message', { data: 'value' });
+    });
+
+    it('should use debug logger in development', () => {
+      process.env.NODE_ENV = 'development';
+      const logger = createLogger('test:info');
+      logger.info('info message', { data: 'value' });
+
+      expect(electronLog.info).not.toHaveBeenCalled();
+      expect(mockDebugLogger).toHaveBeenCalledWith('INFO: info message', { data: 'value' });
+    });
+
+    it('should always call debug logger regardless of environment', () => {
+      const logger = createLogger('test:info');
+      logger.info('info message');
+
+      expect(mockDebugLogger).toHaveBeenCalledWith('INFO: info message');
+    });
+  });
+
+  describe('logger.verbose', () => {
+    it('should always call electronLog.verbose', () => {
+      const logger = createLogger('test:verbose');
+      logger.verbose('verbose message', { data: 'value' });
+
+      expect(electronLog.verbose).toHaveBeenCalledWith('verbose message', { data: 'value' });
+    });
+
+    it('should call debug logger when DEBUG_VERBOSE is set', () => {
+      process.env.DEBUG_VERBOSE = 'true';
+      const logger = createLogger('test:verbose');
+      logger.verbose('verbose message', { data: 'value' });
+
+      expect(electronLog.verbose).toHaveBeenCalledWith('verbose message', { data: 'value' });
+      expect(mockDebugLogger).toHaveBeenCalledWith('VERBOSE: verbose message', { data: 'value' });
+    });
+
+    it('should not call debug logger when DEBUG_VERBOSE is not set', () => {
+      const logger = createLogger('test:verbose');
+      logger.verbose('verbose message', { data: 'value' });
+
+      expect(electronLog.verbose).toHaveBeenCalledWith('verbose message', { data: 'value' });
+      expect(mockDebugLogger).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('logger.warn', () => {
+    it('should use electronLog.warn in production', () => {
+      process.env.NODE_ENV = 'production';
+      const logger = createLogger('test:warn');
+      logger.warn('warn message', { warning: 'details' });
+
+      expect(electronLog.warn).toHaveBeenCalledWith('warn message', { warning: 'details' });
+      expect(mockDebugLogger).toHaveBeenCalledWith('WARN: warn message', { warning: 'details' });
+    });
+
+    it('should not use electronLog.warn in development', () => {
+      process.env.NODE_ENV = 'development';
+      const logger = createLogger('test:warn');
+      logger.warn('warn message');
+
+      expect(electronLog.warn).not.toHaveBeenCalled();
+      expect(mockDebugLogger).toHaveBeenCalledWith('WARN: warn message');
+    });
+
+    it('should always call debug logger regardless of environment', () => {
+      const logger = createLogger('test:warn');
+      logger.warn('warn message');
+
+      expect(mockDebugLogger).toHaveBeenCalledWith('WARN: warn message');
+    });
+  });
+
+  describe('logger integration', () => {
+    it('should handle empty messages', () => {
+      const logger = createLogger('test:integration');
+      logger.debug('');
+      logger.info('');
+      logger.warn('');
+
+      expect(mockDebugLogger).toHaveBeenCalledWith('');
+      expect(mockDebugLogger).toHaveBeenCalledWith('INFO: ');
+      expect(mockDebugLogger).toHaveBeenCalledWith('WARN: ');
+    });
+
+    it('should handle no additional arguments', () => {
+      const logger = createLogger('test:integration');
+      logger.debug('message');
+      logger.error('message');
+      logger.info('message');
+      logger.verbose('message');
+      logger.warn('message');
+
+      expect(mockDebugLogger).toHaveBeenCalledWith('message');
+    });
+
+    it('should format messages consistently across different log levels', () => {
+      const logger = createLogger('app:test');
+      const message = 'test message';
+      const args = { key: 'value' };
+
+      logger.debug(message, args);
+      logger.info(message, args);
+      logger.warn(message, args);
+      logger.verbose(message, args);
+
+      expect(mockDebugLogger).toHaveBeenCalledWith(message, args);
+      expect(mockDebugLogger).toHaveBeenCalledWith(`INFO: ${message}`, args);
+      expect(mockDebugLogger).toHaveBeenCalledWith(`WARN: ${message}`, args);
+      expect(electronLog.verbose).toHaveBeenCalledWith(message, args);
+    });
+  });
+});

package/apps/desktop/src/preload/electronApi.test.ts

@@ -0,0 +1,142 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+// Mock electron modules
+const mockElectronAPI = { someAPI: 'mock-electron-api' };
+const mockContextBridgeExposeInMainWorld = vi.fn();
+
+vi.mock('electron', () => ({
+  contextBridge: {
+    exposeInMainWorld: mockContextBridgeExposeInMainWorld,
+  },
+}));
+
+vi.mock('@electron-toolkit/preload', () => ({
+  electronAPI: mockElectronAPI,
+}));
+
+// Mock the invoke and streamer modules
+const mockInvoke = vi.fn();
+const mockOnStreamInvoke = vi.fn();
+
+vi.mock('./invoke', () => ({
+  invoke: mockInvoke,
+}));
+
+vi.mock('./streamer', () => ({
+  onStreamInvoke: mockOnStreamInvoke,
+}));
+
+const { setupElectronApi } = await import('./electronApi');
+
+describe('setupElectronApi', () => {
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  it('should expose electron API to main world', () => {
+    setupElectronApi();
+
+    expect(mockContextBridgeExposeInMainWorld).toHaveBeenCalledWith('electron', mockElectronAPI);
+  });
+
+  it('should expose electronAPI with invoke and onStreamInvoke methods', () => {
+    setupElectronApi();
+
+    expect(mockContextBridgeExposeInMainWorld).toHaveBeenCalledWith('electronAPI', {
+      invoke: mockInvoke,
+      onStreamInvoke: mockOnStreamInvoke,
+    });
+  });
+
+  it('should expose both APIs in correct order', () => {
+    setupElectronApi();
+
+    expect(mockContextBridgeExposeInMainWorld).toHaveBeenCalledTimes(2);
+
+    // First call should be for 'electron'
+    expect(mockContextBridgeExposeInMainWorld.mock.calls[0][0]).toBe('electron');
+    expect(mockContextBridgeExposeInMainWorld.mock.calls[0][1]).toBe(mockElectronAPI);
+
+    // Second call should be for 'electronAPI'
+    expect(mockContextBridgeExposeInMainWorld.mock.calls[1][0]).toBe('electronAPI');
+    expect(mockContextBridgeExposeInMainWorld.mock.calls[1][1]).toEqual({
+      invoke: mockInvoke,
+      onStreamInvoke: mockOnStreamInvoke,
+    });
+  });
+
+  it('should handle errors when exposing electron API fails', () => {
+    const error = new Error('Failed to expose electron API');
+    mockContextBridgeExposeInMainWorld.mockImplementationOnce(() => {
+      throw error;
+    });
+
+    setupElectronApi();
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(error);
+    // Should still try to expose electronAPI even if first one fails
+    expect(mockContextBridgeExposeInMainWorld).toHaveBeenCalledTimes(2);
+  });
+
+  it('should continue execution if exposing electronAPI fails', () => {
+    mockContextBridgeExposeInMainWorld
+      .mockImplementationOnce(() => {}) // First call succeeds
+      .mockImplementationOnce(() => {
+        throw new Error('Failed to expose electronAPI');
+      }); // Second call fails
+
+    // The second call throws and is not caught, so it will throw
+    // The error handling only wraps the first contextBridge.exposeInMainWorld call
+    expect(() => setupElectronApi()).toThrow('Failed to expose electronAPI');
+
+    expect(mockContextBridgeExposeInMainWorld).toHaveBeenCalledTimes(2);
+  });
+
+  it('should only catch errors for electron API exposure', () => {
+    const error = new Error('Context bridge error');
+    mockContextBridgeExposeInMainWorld.mockImplementationOnce(() => {
+      throw error;
+    });
+
+    setupElectronApi();
+
+    // Error should be logged, not thrown
+    expect(consoleErrorSpy).toHaveBeenCalledWith(error);
+    expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('should expose correct invoke function reference', () => {
+    setupElectronApi();
+
+    const exposedAPI = mockContextBridgeExposeInMainWorld.mock.calls[1][1];
+    expect(exposedAPI.invoke).toBe(mockInvoke);
+  });
+
+  it('should expose correct onStreamInvoke function reference', () => {
+    setupElectronApi();
+
+    const exposedAPI = mockContextBridgeExposeInMainWorld.mock.calls[1][1];
+    expect(exposedAPI.onStreamInvoke).toBe(mockOnStreamInvoke);
+  });
+
+  it('should not modify the original functions', () => {
+    const originalInvoke = mockInvoke;
+    const originalOnStreamInvoke = mockOnStreamInvoke;
+
+    setupElectronApi();
+
+    expect(mockInvoke).toBe(originalInvoke);
+    expect(mockOnStreamInvoke).toBe(originalOnStreamInvoke);
+  });
+
+  it('should be callable multiple times without side effects', () => {
+    setupElectronApi();
+    setupElectronApi();
+
+    // Should be called 4 times total (2 per setup call)
+    expect(mockContextBridgeExposeInMainWorld).toHaveBeenCalledTimes(4);
+  });
+});

package/apps/desktop/src/preload/invoke.test.ts

@@ -0,0 +1,145 @@
+import { ClientDispatchEventKey } from '@lobechat/electron-client-ipc';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+// Mock electron module
+const mockIpcRendererInvoke = vi.fn();
+
+vi.mock('electron', () => ({
+  ipcRenderer: {
+    invoke: mockIpcRendererInvoke,
+  },
+}));
+
+const { invoke } = await import('./invoke');
+
+describe('invoke', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should invoke ipcRenderer with correct event name and no data', async () => {
+    const expectedResult = { success: true };
+    mockIpcRendererInvoke.mockResolvedValue(expectedResult);
+
+    const result = await invoke('getAppVersion' as ClientDispatchEventKey);
+
+    expect(mockIpcRendererInvoke).toHaveBeenCalledWith('getAppVersion');
+    expect(mockIpcRendererInvoke).toHaveBeenCalledTimes(1);
+    expect(result).toEqual(expectedResult);
+  });
+
+  it('should invoke ipcRenderer with event name and single data parameter', async () => {
+    const eventData = { path: '/settings' };
+    const expectedResult = { navigated: true };
+    mockIpcRendererInvoke.mockResolvedValue(expectedResult);
+
+    const result = await invoke('interceptRoute' as ClientDispatchEventKey, eventData);
+
+    expect(mockIpcRendererInvoke).toHaveBeenCalledWith('interceptRoute', eventData);
+    expect(mockIpcRendererInvoke).toHaveBeenCalledTimes(1);
+    expect(result).toEqual(expectedResult);
+  });
+
+  it('should invoke ipcRenderer with event name and multiple data parameters', async () => {
+    const param1 = 'test-param-1';
+    const param2 = { value: 42 };
+    const param3 = [1, 2, 3];
+    const expectedResult = { processed: true };
+    mockIpcRendererInvoke.mockResolvedValue(expectedResult);
+
+    const result = await invoke('someEvent' as ClientDispatchEventKey, param1, param2, param3);
+
+    expect(mockIpcRendererInvoke).toHaveBeenCalledWith('someEvent', param1, param2, param3);
+    expect(mockIpcRendererInvoke).toHaveBeenCalledTimes(1);
+    expect(result).toEqual(expectedResult);
+  });
+
+  it('should handle ipcRenderer invoke rejection', async () => {
+    const error = new Error('IPC communication failed');
+    mockIpcRendererInvoke.mockRejectedValue(error);
+
+    await expect(invoke('getAppVersion' as ClientDispatchEventKey)).rejects.toThrow(
+      'IPC communication failed',
+    );
+    expect(mockIpcRendererInvoke).toHaveBeenCalledWith('getAppVersion');
+  });
+
+  it('should handle ipcRenderer returning undefined', async () => {
+    mockIpcRendererInvoke.mockResolvedValue(undefined);
+
+    const result = await invoke('someEvent' as ClientDispatchEventKey);
+
+    expect(mockIpcRendererInvoke).toHaveBeenCalledWith('someEvent');
+    expect(result).toBeUndefined();
+  });
+
+  it('should handle ipcRenderer returning null', async () => {
+    mockIpcRendererInvoke.mockResolvedValue(null);
+
+    const result = await invoke('someEvent' as ClientDispatchEventKey);
+
+    expect(mockIpcRendererInvoke).toHaveBeenCalledWith('someEvent');
+    expect(result).toBeNull();
+  });
+
+  it('should preserve complex data structures', async () => {
+    const complexData = {
+      array: [1, 2, 3],
+      nested: {
+        bool: true,
+        null: null,
+        string: 'test',
+        undefined: undefined,
+      },
+      number: 42,
+    };
+    mockIpcRendererInvoke.mockResolvedValue(complexData);
+
+    const result = await invoke('getData' as ClientDispatchEventKey);
+
+    expect(result).toEqual(complexData);
+  });
+
+  it('should maintain type safety with generic return type', async () => {
+    interface TestResponse {
+      message: string;
+      status: number;
+    }
+
+    const expectedResponse: TestResponse = { message: 'success', status: 200 };
+    mockIpcRendererInvoke.mockResolvedValue(expectedResponse);
+
+    const result = await invoke('testEvent' as ClientDispatchEventKey);
+
+    expect(result).toEqual(expectedResponse);
+    expect(typeof result.message).toBe('string');
+    expect(typeof result.status).toBe('number');
+  });
+
+  it('should handle concurrent invocations correctly', async () => {
+    mockIpcRendererInvoke
+      .mockResolvedValueOnce({ id: 1 })
+      .mockResolvedValueOnce({ id: 2 })
+      .mockResolvedValueOnce({ id: 3 });
+
+    const [result1, result2, result3] = await Promise.all([
+      invoke('event1' as ClientDispatchEventKey),
+      invoke('event2' as ClientDispatchEventKey),
+      invoke('event3' as ClientDispatchEventKey),
+    ]);
+
+    expect(result1).toEqual({ id: 1 });
+    expect(result2).toEqual({ id: 2 });
+    expect(result3).toEqual({ id: 3 });
+    expect(mockIpcRendererInvoke).toHaveBeenCalledTimes(3);
+  });
+
+  it('should handle empty string as data parameter', async () => {
+    mockIpcRendererInvoke.mockResolvedValue({ received: '' });
+
+    const result = await invoke('sendData' as ClientDispatchEventKey, '');
+
+    expect(mockIpcRendererInvoke).toHaveBeenCalledWith('sendData', '');
+    expect(result).toEqual({ received: '' });
+  });
+});