metona-ai-desktop/electron/ipc/__tests__/app-data.test.ts

/**
 * IPC App / Data 域测试（v0.7.2 覆盖补齐）
 *
 * 锁定安全与数据完整性契约：
 * 1. app:openExternal 协议白名单（M-12：file:/smb:/javascript: 拒绝）
 * 2. error:report 渲染层错误上报：超长字段截断 + 审计落库
 * 3. audit:query 的 eventType 枚举校验与 limit 边界（M-45）
 * 4. data:export 的导出脱敏双保险（dataUrl 剥离 + 配置掩码 + 会话条数上限）
 * 5. data:clear* 危险操作的事务语义与审计日志
 */

import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';

const ipcMainHandleMock = vi.fn();
const ipcMainOnMock = vi.fn();
vi.mock('electron', () => ({
  ipcMain: {
    handle: (...args: unknown[]) => ipcMainHandleMock(...args),
    on: (...args: unknown[]) => ipcMainOnMock(...args),
  },
  shell: { openExternal: vi.fn(async () => undefined), showItemInFolder: vi.fn() },
  dialog: { showOpenDialog: vi.fn(async () => ({ canceled: true, filePaths: [] })) },
  BrowserWindow: { fromWebContents: vi.fn(() => null) },
  app: {
    getVersion: vi.fn(() => '0.7.2'),
    getPath: vi.fn(() => '/tmp/userdata'),
    relaunch: vi.fn(),
    exit: vi.fn(),
  },
}));

vi.mock('electron-log', () => ({
  default: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
}));

import { registerAppHandlers } from '../app';
import { registerDataHandlers } from '../data';
import type { IPCContext } from '../context';

function getHandler(channel: string): (...args: unknown[]) => Promise<unknown> {
  const call = ipcMainHandleMock.mock.calls.find(([ch]) => ch === channel);
  if (!call) throw new Error(`IPC handler not registered: ${channel}`);
  return call[1] as (...args: unknown[]) => Promise<unknown>;
}

function getListener(channel: string): (...args: unknown[]) => void {
  const call = ipcMainOnMock.mock.calls.find(([ch]) => ch === channel);
  if (!call) throw new Error(`IPC listener not registered: ${channel}`);
  return call[1] as (...args: unknown[]) => void;
}

beforeEach(() => {
  ipcMainHandleMock.mockClear();
  ipcMainOnMock.mockClear();
});

// ===== App 域 =====

describe('app:openExternal — 协议白名单（M-12）', () => {
  function makeCtx(): IPCContext {
    return { configService: { get: vi.fn(() => null) } } as unknown as IPCContext;
  }

  it('http/https/mailto 放行', async () => {
    registerAppHandlers(makeCtx());
    const handler = getHandler('app:openExternal');
    for (const url of ['https://example.com', 'http://example.com/x', 'mailto:a@b.com']) {
      expect(await handler(null, url)).toMatchObject({ success: true });
    }
  });

  it.each([
    'file:///etc/passwd',
    'smb://host/share',
    'javascript:alert(1)',
    'data:text/html,<script>',
    'ftp://host/file',
  ])('%s → 拒绝', async (url) => {
    registerAppHandlers(makeCtx());
    const result = (await getHandler('app:openExternal')(null, url)) as {
      success: boolean;
      error?: string;
    };
    expect(result.success).toBe(false);
    expect(result.error).toContain('not allowed');
  });

  it('非字符串/空 URL 拒绝', async () => {
    registerAppHandlers(makeCtx());
    expect(await getHandler('app:openExternal')(null, '')).toMatchObject({ success: false });
    expect(await getHandler('app:openExternal')(null, 123)).toMatchObject({ success: false });
  });
});

describe('audit 域 — 校验矩阵（M-45）', () => {
  function makeCtx(): { ctx: IPCContext; query: Mock } {
    const query = vi.fn(() => []);
    return {
      ctx: {
        auditService: {
          query,
          log: vi.fn(),
          verifyChain: vi.fn(() => ({
            valid: true,
            totalRecords: 0,
            verifiedRecords: 0,
            tamperedId: null,
          })),
        },
      } as unknown as IPCContext,
      query,
    };
  }

  it('audit:query 非法 eventType 拒绝（枚举白名单）', async () => {
    const { ctx } = makeCtx();
    registerAppHandlers(ctx);
    const result = (await getHandler('audit:query')(null, { eventType: 'DROP TABLE' })) as {
      success: boolean;
      error?: string;
    };
    expect(result.success).toBe(false);
    expect(result.error).toContain('Invalid eventType');
  });

  it('audit:query limit 边界（1-1000 之外拒绝，防超大查询）', async () => {
    const { ctx, query } = makeCtx();
    registerAppHandlers(ctx);
    const handler = getHandler('audit:query');

    expect(await handler(null, { limit: 0 })).toMatchObject({ success: false });
    expect(await handler(null, { limit: 1001 })).toMatchObject({ success: false });
    expect(await handler(null, { limit: Number.NaN })).toMatchObject({ success: false });
    await handler(null, { limit: 500 });
    expect(query).toHaveBeenCalledWith(expect.objectContaining({ limit: 500 }));
  });

  it('audit:verifyChain 透传结果', async () => {
    const { ctx } = makeCtx();
    registerAppHandlers(ctx);
    const result = (await getHandler('audit:verifyChain')(null)) as {
      success: boolean;
      valid: boolean;
    };
    expect(result).toMatchObject({ success: true, valid: true });
  });
});

describe('searxng:testConnection — 连接测试', () => {
  function makeCtx(): IPCContext {
    return { configService: { get: vi.fn(() => null) } } as unknown as IPCContext;
  }

  it('非法 URL 直接拒绝（不发起网络请求）', async () => {
    registerAppHandlers(makeCtx());
    const result = (await getHandler('searxng:testConnection')(null, 'ftp://x', '', '')) as {
      success: boolean;
      error?: string;
    };
    expect(result.success).toBe(false);
    expect(result.error).toContain('http');
  });

  it('Basic 认证 → Authorization 头为 Base64 编码', async () => {
    registerAppHandlers(makeCtx());
    const fetchSpy = vi.fn(async (..._args: unknown[]) => ({
      ok: true,
      status: 200,
      statusText: 'OK',
    }));
    vi.stubGlobal('fetch', fetchSpy);

    await getHandler('searxng:testConnection')(null, 'https://sx.local', 'user:pass', 'basic');
    const headers = (fetchSpy.mock.calls[0][1] as { headers: Record<string, string> }).headers;
    expect(headers['Authorization']).toBe(`Basic ${Buffer.from('user:pass').toString('base64')}`);
    vi.unstubAllGlobals();
  });

  it('网络异常 → success:false + 错误信息', async () => {
    registerAppHandlers(makeCtx());
    vi.stubGlobal(
      'fetch',
      vi.fn(async () => {
        throw new Error('ECONNREFUSED');
      }),
    );
    const result = (await getHandler('searxng:testConnection')(
      null,
      'https://sx.local',
      '',
      '',
    )) as {
      success: boolean;
      error?: string;
    };
    expect(result.success).toBe(false);
    expect(result.error).toContain('ECONNREFUSED');
    vi.unstubAllGlobals();
  });
});

describe('error:report — 渲染层错误上报通道（P0-3）', () => {
  it('超长字段截断 + 审计落库（TOOL 层）', async () => {
    const log = vi.fn();
    registerAppHandlers({ auditService: { log } } as unknown as IPCContext);
    const listener = getListener('error:report');

    listener(null, {
      type: 'render-crash',
      error: 'e'.repeat(2000),
      stack: 's'.repeat(10000),
      componentStack: 'c'.repeat(8000),
      timestamp: Date.now(),
    });

    expect(log).toHaveBeenCalledTimes(1);
    const entry = log.mock.calls[0][0] as { eventType: string; details: Record<string, unknown> };
    expect(entry.eventType).toBe('error');
    expect((entry.details.error as string).length).toBe(1000);
    expect((entry.details.stack as string).length).toBe(4000);
    expect((entry.details.componentStack as string).length).toBe(4000);
  });

  it('非法载荷安全忽略（单向通道不抛错）', () => {
    const log = vi.fn();
    registerAppHandlers({ auditService: { log } } as unknown as IPCContext);
    const listener = getListener('error:report');
    expect(() => listener(null, null)).not.toThrow();
    expect(() => listener(null, 'plain string')).not.toThrow();
    expect(log).not.toHaveBeenCalled();
  });
});

// ===== Data 域 =====

describe('data:export — 导出脱敏双保险', () => {
  function makeCtx(
    messages: unknown[],
    sessions?: unknown[],
  ): { ctx: IPCContext; sessionService: Record<string, Mock> } {
    const sessionService = {
      getMessages: vi.fn(() => messages),
      list: vi.fn(() => sessions ?? []),
    };
    const configService = {
      getAll: vi.fn(() => ({ 'llm.apiKey': 'sk-export-raw', 'ui.theme': 'dark' })),
    };
    return {
      ctx: { sessionService, configService } as unknown as IPCContext,
      sessionService,
    };
  }

  it('单会话导出：toolResult.dataUrl 被剥离（view_image base64 防泄漏）', async () => {
    const bigDataUrl = `data:image/png;base64,${'A'.repeat(100)}`;
    const messages = [
      {
        id: 'm1',
        role: 'tool',
        toolResult: { toolCallId: 'tc_1', result: { path: 'x.png', dataUrl: bigDataUrl } },
      },
      {
        id: 'm2',
        role: 'user',
        attachments: [{ name: 'pic.png', preview: 'data:image/jpeg;base64,BBBB' }],
      },
    ];
    const { ctx } = makeCtx(messages);
    registerDataHandlers(ctx);

    const result = (await getHandler('data:export')(null, 's1')) as {
      success: boolean;
      data: unknown[];
    };
    expect(result.success).toBe(true);
    const toolMsg = result.data[0] as { toolResult: { result: Record<string, unknown> } };
    expect(toolMsg.toolResult.result.dataUrl).toBeUndefined();
    expect(toolMsg.toolResult.result.path).toBe('x.png'); // 小字段保留
    expect(toolMsg.toolResult.result._displayNote).toBeDefined();

    const userMsg = result.data[1] as { attachments: Array<Record<string, unknown>> };
    expect(userMsg.attachments[0].preview).toBeUndefined(); // preview 剥离
    expect(userMsg.attachments[0].name).toBe('pic.png');
  });

  it('全量导出：配置敏感值脱敏（S-1），普通字段原样', async () => {
    const { ctx } = makeCtx([], [{ id: 's1', title: 't' }]);
    registerDataHandlers(ctx);

    const result = (await getHandler('data:export')(null, undefined)) as {
      success: boolean;
      data: { config: Record<string, unknown>; sessions: unknown[] };
    };
    expect(result.data.config['llm.apiKey']).toBe('***-raw'); // maskSensitive：后 4 位保留
    expect(result.data.config['ui.theme']).toBe('dark'); // 非敏感原样
    expect(JSON.stringify(result.data.config)).not.toContain('sk-export-raw');
  });

  it('导出失败 → success:false', async () => {
    const { ctx, sessionService } = makeCtx([]);
    sessionService.getMessages.mockImplementation(() => {
      throw new Error('db gone');
    });
    registerDataHandlers(ctx);
    const result = (await getHandler('data:export')(null, 's1')) as {
      success: boolean;
      error?: string;
    };
    expect(result.success).toBe(false);
    expect(result.error).toBe('db gone');
  });
});

describe('data:clear* — 危险操作事务语义', () => {
  function makeDbMock(): { prepare: Mock; exec: Mock } {
    const prepare = vi.fn(() => ({
      run: vi.fn(),
      get: vi.fn(() => ({ c: 2 })),
      all: vi.fn(() => []),
    }));
    const exec = vi.fn();
    return { prepare, exec };
  }

  it('clearSessions：BEGIN/DELETE/COMMIT 事务包裹 + 删除计数', async () => {
    const { prepare, exec } = makeDbMock();
    registerDataHandlers({
      sessionService: { getDB: () => ({ prepare, exec }) },
    } as unknown as IPCContext);

    const result = (await getHandler('data:clearSessions')(null)) as {
      success: boolean;
      deletedSessions: number;
    };
    expect(result).toMatchObject({ success: true, deletedSessions: 2, deletedMessages: 2 });
    const execCalls = exec.mock.calls.map((c) => c[0] as string);
    expect(execCalls).toEqual(expect.arrayContaining(['BEGIN', 'COMMIT']));
  });

  it('clearSessions 失败 → ROLLBACK（消息/会话表一致性）', async () => {
    // DELETE 走 db.exec（非 prepare）—— 失败注入点在 exec 的 sessions 删除
    const prepare = vi.fn(() => ({
      run: vi.fn(),
      get: vi.fn(() => ({ c: 1 })),
      all: vi.fn(() => []),
    }));
    const exec = vi.fn((sql: string) => {
      if (sql.includes('DELETE FROM sessions')) {
        throw new Error('foreign key constraint');
      }
    });
    registerDataHandlers({
      sessionService: { getDB: () => ({ prepare, exec }) },
    } as unknown as IPCContext);

    const result = (await getHandler('data:clearSessions')(null)) as { success: boolean };
    expect(result.success).toBe(false);
    const execCalls = exec.mock.calls.map((c) => c[0] as string);
    expect(execCalls).toContain('ROLLBACK');
  });

  it('clearMemories 三张记忆表事务包裹（M-41 一致性）', async () => {
    const { prepare, exec } = makeDbMock();
    registerDataHandlers({
      sessionService: { getDB: () => ({ prepare, exec }) },
    } as unknown as IPCContext);

    const result = (await getHandler('data:clearMemories')(null)) as {
      success: boolean;
      deletedEpisodic: number;
    };
    expect(result.success).toBe(true);
    const execCalls = exec.mock.calls.map((c) => c[0] as string);
    expect(execCalls).toEqual(expect.arrayContaining(['BEGIN', 'COMMIT']));
  });

  it('clearAuditLogs：先删防篡改触发器再清表，最后重建触发器（INSERT-ONLY 契约）', async () => {
    const { prepare, exec } = makeDbMock();
    registerDataHandlers({
      sessionService: { getDB: () => ({ prepare, exec }) },
    } as unknown as IPCContext);

    const result = (await getHandler('data:clearAuditLogs')(null)) as { success: boolean };
    expect(result.success).toBe(true);
    const execCalls = exec.mock.calls.map((c) => c[0] as string);
    expect(execCalls[0]).toBe('BEGIN');
    expect(execCalls.some((c) => c.includes('DROP TRIGGER IF EXISTS audit_no_delete'))).toBe(true);
    expect(execCalls.some((c) => c.includes('CREATE TRIGGER audit_no_delete BEFORE DELETE'))).toBe(
      true,
    );
    expect(execCalls[execCalls.length - 1]).toBe('COMMIT');
  });
});