@aster110/cc2wechat 3.0.0 → 3.2.0

package/tests/store.test.ts

@@ -0,0 +1,112 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+// We need to mock the CHANNEL_DIR to use a temp directory
+// Since CHANNEL_DIR is a module-level const, we mock os.homedir before importing
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cc2wechat-test-'));
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+// Since store.ts computes CHANNEL_DIR at module load time using os.homedir(),
+// we need to re-import with a mocked homedir each time.
+async function importStore(homeDir: string) {
+  vi.doMock('node:os', async () => {
+    const actual = await vi.importActual<typeof import('node:os')>('node:os');
+    return { ...actual, default: { ...actual, homedir: () => homeDir }, homedir: () => homeDir };
+  });
+  // Force fresh import
+  const mod = await import('../src/store.js');
+  return mod;
+}
+
+describe('store', () => {
+  let store: Awaited<ReturnType<typeof importStore>>;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    store = await importStore(tmpDir);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('saveAccount / getActiveAccount / loadAccounts', () => {
+    it('returns null when no accounts saved', () => {
+      expect(store.getActiveAccount()).toBeNull();
+    });
+
+    it('saves and retrieves an account', () => {
+      const account = {
+        accountId: 'acc1',
+        token: 'tok_abc',
+        baseUrl: 'https://example.com',
+        savedAt: '2026-01-01T00:00:00Z',
+      };
+      store.saveAccount(account);
+      const active = store.getActiveAccount();
+      expect(active).not.toBeNull();
+      expect(active!.accountId).toBe('acc1');
+      expect(active!.token).toBe('tok_abc');
+      expect(active!.baseUrl).toBe('https://example.com');
+    });
+
+    it('returns the last saved account as active', () => {
+      store.saveAccount({ accountId: 'a1', token: 't1', savedAt: '2026-01-01' });
+      store.saveAccount({ accountId: 'a2', token: 't2', savedAt: '2026-01-02' });
+      const active = store.getActiveAccount();
+      expect(active!.accountId).toBe('a2');
+    });
+
+    it('deduplicates by accountId on save', () => {
+      store.saveAccount({ accountId: 'a1', token: 'old', savedAt: '2026-01-01' });
+      store.saveAccount({ accountId: 'a1', token: 'new', savedAt: '2026-01-02' });
+      const accounts = store.loadAccounts();
+      expect(accounts).toHaveLength(1);
+      expect(accounts[0]!.token).toBe('new');
+    });
+  });
+
+  describe('removeAccount', () => {
+    it('removes an existing account', () => {
+      store.saveAccount({ accountId: 'a1', token: 't1', savedAt: '2026-01-01' });
+      store.saveAccount({ accountId: 'a2', token: 't2', savedAt: '2026-01-02' });
+      store.removeAccount('a1');
+      const accounts = store.loadAccounts();
+      expect(accounts).toHaveLength(1);
+      expect(accounts[0]!.accountId).toBe('a2');
+    });
+
+    it('does nothing when removing a non-existent account', () => {
+      store.saveAccount({ accountId: 'a1', token: 't1', savedAt: '2026-01-01' });
+      store.removeAccount('nonexistent');
+      const accounts = store.loadAccounts();
+      expect(accounts).toHaveLength(1);
+    });
+  });
+
+  describe('loadSyncBuf / saveSyncBuf', () => {
+    it('returns empty string when no buf saved', () => {
+      expect(store.loadSyncBuf('nonexistent')).toBe('');
+    });
+
+    it('saves and loads sync buf consistently', () => {
+      store.saveSyncBuf('acc1', 'some_cursor_data_12345');
+      expect(store.loadSyncBuf('acc1')).toBe('some_cursor_data_12345');
+    });
+
+    it('overwrites previous buf', () => {
+      store.saveSyncBuf('acc1', 'first');
+      store.saveSyncBuf('acc1', 'second');
+      expect(store.loadSyncBuf('acc1')).toBe('second');
+    });
+  });
+});

package/tests/utils.test.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect } from 'vitest';
+import { extractText, userIdToSessionUUID, sleep } from '../src/utils.js';
+import { MessageItemType } from '../src/types.js';
+import type { WeixinMessage } from '../src/types.js';
+
+describe('extractText', () => {
+  it('extracts text from a text message', () => {
+    const msg: WeixinMessage = {
+      item_list: [{ type: MessageItemType.TEXT, text_item: { text: 'hello world' } }],
+    };
+    expect(extractText(msg)).toBe('hello world');
+  });
+
+  it('returns [Image] for image messages', () => {
+    const msg: WeixinMessage = {
+      item_list: [{ type: MessageItemType.IMAGE }],
+    };
+    expect(extractText(msg)).toBe('[Image]');
+  });
+
+  it('extracts voice text', () => {
+    const msg: WeixinMessage = {
+      item_list: [{ type: MessageItemType.VOICE, voice_item: { text: 'voice content' } }],
+    };
+    expect(extractText(msg)).toBe('[Voice] voice content');
+  });
+
+  it('returns [Video] for video messages', () => {
+    const msg: WeixinMessage = {
+      item_list: [{ type: MessageItemType.VIDEO }],
+    };
+    expect(extractText(msg)).toBe('[Video]');
+  });
+
+  it('extracts file name', () => {
+    const msg: WeixinMessage = {
+      item_list: [{ type: MessageItemType.FILE, file_item: { file_name: 'doc.pdf' } }],
+    };
+    expect(extractText(msg)).toBe('[File: doc.pdf]');
+  });
+
+  it('returns [Empty message] for empty item_list', () => {
+    const msg: WeixinMessage = { item_list: [] };
+    expect(extractText(msg)).toBe('[Empty message]');
+  });
+
+  it('returns [Empty message] when item_list is undefined', () => {
+    const msg: WeixinMessage = {};
+    expect(extractText(msg)).toBe('[Empty message]');
+  });
+
+  it('joins multiple items with newline', () => {
+    const msg: WeixinMessage = {
+      item_list: [
+        { type: MessageItemType.TEXT, text_item: { text: 'line1' } },
+        { type: MessageItemType.IMAGE },
+      ],
+    };
+    expect(extractText(msg)).toBe('line1\n[Image]');
+  });
+
+  it('returns [Empty message] for VOICE without text', () => {
+    const msg: WeixinMessage = {
+      item_list: [{ type: MessageItemType.VOICE, voice_item: {} }],
+    };
+    expect(extractText(msg)).toBe('[Empty message]');
+  });
+
+  it('returns [Empty message] for FILE without file_name', () => {
+    const msg: WeixinMessage = {
+      item_list: [{ type: MessageItemType.FILE, file_item: {} }],
+    };
+    expect(extractText(msg)).toBe('[Empty message]');
+  });
+
+  it('skips items with unknown type', () => {
+    const msg: WeixinMessage = {
+      item_list: [{ type: 99 }],
+    };
+    expect(extractText(msg)).toBe('[Empty message]');
+  });
+});
+
+describe('userIdToSessionUUID', () => {
+  it('is deterministic (same input same output)', () => {
+    const a = userIdToSessionUUID('user123');
+    const b = userIdToSessionUUID('user123');
+    expect(a).toBe(b);
+  });
+
+  it('returns valid UUID v4 format', () => {
+    const uuid = userIdToSessionUUID('testuser');
+    // UUID format: 8-4-4-4-12
+    expect(uuid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}$/);
+  });
+
+  it('produces different outputs for different inputs', () => {
+    const a = userIdToSessionUUID('user_a');
+    const b = userIdToSessionUUID('user_b');
+    expect(a).not.toBe(b);
+  });
+});
+
+describe('sleep', () => {
+  it('resolves after the specified duration', async () => {
+    const start = Date.now();
+    await sleep(50);
+    const elapsed = Date.now() - start;
+    expect(elapsed).toBeGreaterThanOrEqual(40); // allow small timing variance
+  });
+
+  it('resolves to undefined', async () => {
+    const result = await sleep(1);
+    expect(result).toBeUndefined();
+  });
+});

package/tests/wechat-api.test.ts

@@ -0,0 +1,223 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import crypto from 'node:crypto';
+import {
+  encryptAesEcb,
+  aesEcbPaddedSize,
+  getUpdates,
+  sendMessage,
+  getQRCode,
+  pollQRStatus,
+  sendTyping,
+  getConfig,
+} from '../src/wechat-api.js';
+
+// ---------------------------------------------------------------------------
+// Mock fetch helpers
+// ---------------------------------------------------------------------------
+
+function mockFetchJson(data: unknown, status = 200) {
+  return vi.fn().mockResolvedValue({
+    ok: status >= 200 && status < 300,
+    status,
+    statusText: status === 200 ? 'OK' : 'Error',
+    text: () => Promise.resolve(JSON.stringify(data)),
+    json: () => Promise.resolve(data),
+    headers: new Headers(),
+  });
+}
+
+function mockFetchText(text: string, status = 200) {
+  return vi.fn().mockResolvedValue({
+    ok: status >= 200 && status < 300,
+    status,
+    statusText: status === 200 ? 'OK' : 'Error',
+    text: () => Promise.resolve(text),
+    json: () => Promise.resolve(JSON.parse(text)),
+    headers: new Headers(),
+  });
+}
+
+function mockFetchAbort() {
+  return vi.fn().mockRejectedValue(Object.assign(new Error('The operation was aborted'), { name: 'AbortError' }));
+}
+
+// ---------------------------------------------------------------------------
+// API function tests
+// ---------------------------------------------------------------------------
+
+describe('getUpdates', () => {
+  afterEach(() => { vi.unstubAllGlobals(); });
+
+  it('returns parsed messages on success', async () => {
+    const resp = { ret: 0, msgs: [{ message_id: 1 }], get_updates_buf: 'buf2' };
+    vi.stubGlobal('fetch', mockFetchText(JSON.stringify(resp)));
+
+    const result = await getUpdates('tok', 'buf1');
+    expect(result.ret).toBe(0);
+    expect(result.msgs).toHaveLength(1);
+    expect(result.get_updates_buf).toBe('buf2');
+  });
+
+  it('returns default value on AbortError (timeout)', async () => {
+    vi.stubGlobal('fetch', mockFetchAbort());
+
+    const result = await getUpdates('tok', 'buf1');
+    expect(result.ret).toBe(0);
+    expect(result.msgs).toEqual([]);
+    expect(result.get_updates_buf).toBe('buf1');
+  });
+});
+
+describe('sendMessage', () => {
+  afterEach(() => { vi.unstubAllGlobals(); });
+
+  it('sends message successfully (no throw)', async () => {
+    vi.stubGlobal('fetch', mockFetchText('{"ret":0}'));
+    await expect(sendMessage('tok', 'user1', 'hello', 'ctx1')).resolves.toBeUndefined();
+  });
+});
+
+describe('getQRCode', () => {
+  afterEach(() => { vi.unstubAllGlobals(); });
+
+  it('returns qrcode and qrcode_img_content', async () => {
+    const data = { qrcode: 'qr123', qrcode_img_content: 'base64img' };
+    vi.stubGlobal('fetch', mockFetchJson(data));
+
+    const result = await getQRCode();
+    expect(result.qrcode).toBe('qr123');
+    expect(result.qrcode_img_content).toBe('base64img');
+  });
+});
+
+describe('pollQRStatus', () => {
+  afterEach(() => { vi.unstubAllGlobals(); });
+
+  it('returns wait status', async () => {
+    vi.stubGlobal('fetch', mockFetchJson({ status: 'wait' }));
+    const result = await pollQRStatus('qr123');
+    expect(result.status).toBe('wait');
+  });
+
+  it('returns confirmed status with token', async () => {
+    const data = { status: 'confirmed', bot_token: 'tok_abc', ilink_bot_id: 'bot1' };
+    vi.stubGlobal('fetch', mockFetchJson(data));
+    const result = await pollQRStatus('qr123');
+    expect(result.status).toBe('confirmed');
+    expect(result.bot_token).toBe('tok_abc');
+  });
+
+  it('returns { status: "wait" } on AbortError (timeout)', async () => {
+    vi.stubGlobal('fetch', mockFetchAbort());
+    const result = await pollQRStatus('qr123');
+    expect(result.status).toBe('wait');
+  });
+});
+
+describe('sendTyping', () => {
+  afterEach(() => { vi.unstubAllGlobals(); });
+
+  it('sends typing successfully (no throw)', async () => {
+    vi.stubGlobal('fetch', mockFetchText('{"ret":0}'));
+    await expect(sendTyping('tok', 'user1', 'ticket1')).resolves.toBeUndefined();
+  });
+});
+
+describe('getConfig', () => {
+  afterEach(() => { vi.unstubAllGlobals(); });
+
+  it('returns typing_ticket', async () => {
+    const data = { ret: 0, typing_ticket: 'ticket_xyz' };
+    vi.stubGlobal('fetch', mockFetchText(JSON.stringify(data)));
+
+    const result = await getConfig('tok', 'user1');
+    expect(result.typing_ticket).toBe('ticket_xyz');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Crypto tests
+// ---------------------------------------------------------------------------
+
+describe('encryptAesEcb', () => {
+  it('encrypt then decrypt produces original plaintext', () => {
+    const key = crypto.randomBytes(16);
+    const plaintext = Buffer.from('Hello, WeChat!');
+
+    const ciphertext = encryptAesEcb(plaintext, key);
+
+    // Decrypt with node:crypto to verify
+    const decipher = crypto.createDecipheriv('aes-128-ecb', key, null);
+    const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+
+    expect(decrypted.toString()).toBe('Hello, WeChat!');
+  });
+
+  it('produces ciphertext different from plaintext', () => {
+    const key = crypto.randomBytes(16);
+    const plaintext = Buffer.from('test data here');
+    const ciphertext = encryptAesEcb(plaintext, key);
+    expect(ciphertext.equals(plaintext)).toBe(false);
+  });
+
+  it('different keys produce different ciphertext', () => {
+    const key1 = crypto.randomBytes(16);
+    const key2 = crypto.randomBytes(16);
+    const plaintext = Buffer.from('same input');
+
+    const c1 = encryptAesEcb(plaintext, key1);
+    const c2 = encryptAesEcb(plaintext, key2);
+    expect(c1.equals(c2)).toBe(false);
+  });
+
+  it('ciphertext length matches aesEcbPaddedSize', () => {
+    const key = crypto.randomBytes(16);
+    const plaintext = Buffer.from('variable length content');
+    const ciphertext = encryptAesEcb(plaintext, key);
+    expect(ciphertext.length).toBe(aesEcbPaddedSize(plaintext.length));
+  });
+
+  it('encrypts empty buffer without error', () => {
+    const key = crypto.randomBytes(16);
+    const ciphertext = encryptAesEcb(Buffer.alloc(0), key);
+    expect(ciphertext.length).toBe(16); // one full padding block
+
+    // Decrypt to verify
+    const decipher = crypto.createDecipheriv('aes-128-ecb', key, null);
+    const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+    expect(decrypted.length).toBe(0);
+  });
+});
+
+describe('aesEcbPaddedSize', () => {
+  it('returns 16 for empty input (0 bytes)', () => {
+    // 0 bytes plaintext → 16 bytes padding (full block of padding)
+    expect(aesEcbPaddedSize(0)).toBe(16);
+  });
+
+  it('returns 16 for 1 byte', () => {
+    expect(aesEcbPaddedSize(1)).toBe(16);
+  });
+
+  it('returns 16 for 15 bytes', () => {
+    // 15 bytes + 1 padding = 16
+    expect(aesEcbPaddedSize(15)).toBe(16);
+  });
+
+  it('returns 32 for 16 bytes (needs full padding block)', () => {
+    // 16 bytes plaintext → needs extra block for PKCS7 padding
+    expect(aesEcbPaddedSize(16)).toBe(32);
+  });
+
+  it('returns 32 for 17 bytes', () => {
+    expect(aesEcbPaddedSize(17)).toBe(32);
+  });
+
+  it('returns 32 for 31 bytes', () => {
+    expect(aesEcbPaddedSize(31)).toBe(32);
+  });
+
+  it('returns 48 for 32 bytes', () => {
+    expect(aesEcbPaddedSize(32)).toBe(48);
+  });
+});

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['tests/**/*.test.ts'],
+  },
+});