SnowLuma v2.4.2 source snapshot

packages/bridge/tests/hook-reconnect-no-login.test.ts

@@ -0,0 +1,146 @@
+// Regression test for the Docker "QQ-never-logs-in + pipe keeps reconnecting" leak hypothesis.
+//
+// User-reported pattern (Docker, idle login screen):
+//   02:41:23  [Hook] pipe connected: PID=61
+//   04:37:55  [Hook] pipe connected: PID=61   (same PID, ~2h later)
+//   04:40:44  [Hook] pipe connected: PID=61
+//   04:43:48  [Hook] pipe connected: PID=61   → eventual OOM-kill
+//
+// Hypothesis (H2): every onPipeDown → onPipeUp cycle leaks the prior
+// QqHookClient (listeners or socket-ref keeping it pinned in memory),
+// so repeated reconnect drives unbounded growth.
+//
+// This test drives N up/down cycles against a HookSession with a FakeClient
+// factory and asserts:
+//   - at most one client is alive at any point
+//   - every prior client's EventEmitter listener count drops to 0 after teardown
+
+import { describe, it, expect, onTestFinished, vi } from 'vitest';
+import { EventEmitter } from 'events';
+import { HookSession } from '../src/hook-session';
+import type { ManualMapHandle } from '../src/injector';
+import type { QqHookClient } from '../src/qq-hook-client';
+
+const DUMMY_HANDLE: ManualMapHandle = { base: 0n, entry: 0n, exceptionTable: 0n, size: 0 };
+
+class FakeClient extends EventEmitter {
+    isClosed = false;
+    isLoggedIn = false;
+    private loginState = { loggedIn: false, uin: '0', uinNumber: 0n };
+
+    async connectAll(_opts: { recv: boolean }): Promise<void> {
+        if (this.isClosed) {
+            throw new Error('client is closed');
+        }
+    }
+    getLoginState() {
+        return { ...this.loginState };
+    }
+    close(): void {
+        if (this.isClosed) {
+            return;
+        }
+
+        this.isClosed = true;
+        this.emit('close');
+    }
+}
+
+function totalListenerCount(emitter: EventEmitter): number {
+    return emitter.eventNames().reduce((n, evt) => n + emitter.listenerCount(evt), 0);
+}
+
+const flush = () => new Promise<void>((r) => setImmediate(r));
+
+describe('HookSession — pipe reconnect with QQ never logging in', () => {
+    it('does not accumulate live FakeClient instances across N pipe up/down cycles', async () => {
+        let pipeLive = true;
+        const clients: FakeClient[] = [];
+        const session = new HookSession(61, {
+            detectLoginUin: async () => null,
+            injector: {
+                inject: vi.fn(async () => ({
+                    method: 'loadModuleManual' as const,
+                    handle: DUMMY_HANDLE,
+                })),
+                unload: vi.fn(async () => {}),
+            },
+            makeClient: () => {
+                const c = new FakeClient();
+                clients.push(c);
+                return c as unknown as QqHookClient;
+            },
+            pipeWatcher: { isPipeLive: () => pipeLive },
+        });
+        onTestFinished(() => session.dispose());
+
+        await session.load();
+        session.onPipeUp();
+        await flush();
+
+        const CYCLES = 50;
+
+        for (let i = 0; i < CYCLES; i++) {
+            pipeLive = false;
+            session.onPipeDown();
+            await flush();
+            pipeLive = true;
+            session.onPipeUp();
+            await flush();
+        }
+
+        const alive = clients.filter((c) => !c.isClosed);
+        expect.soft(clients.length).toBeGreaterThan(1);
+        expect(
+            alive.length,
+            `expected ≤1 live client after ${CYCLES} reconnects, got ${alive.length}`,
+        ).toBeLessThanOrEqual(1);
+    });
+
+    it('drops all listeners from each torn-down client', async () => {
+        let pipeLive = true;
+        const clients: FakeClient[] = [];
+        const session = new HookSession(61, {
+            detectLoginUin: async () => null,
+            injector: {
+                inject: vi.fn(async () => ({
+                    method: 'loadModuleManual' as const,
+                    handle: DUMMY_HANDLE,
+                })),
+                unload: vi.fn(async () => {}),
+            },
+            makeClient: () => {
+                const c = new FakeClient();
+                clients.push(c);
+                return c as unknown as QqHookClient;
+            },
+            pipeWatcher: { isPipeLive: () => pipeLive },
+        });
+        onTestFinished(() => session.dispose());
+
+        await session.load();
+        session.onPipeUp();
+        await flush();
+
+        const CYCLES = 20;
+
+        for (let i = 0; i < CYCLES; i++) {
+            pipeLive = false;
+            session.onPipeDown();
+            await flush();
+            pipeLive = true;
+            session.onPipeUp();
+            await flush();
+        }
+
+        // Every client except the current one should have 0 listeners attached.
+        // (HookSession.tearDownClient does client.removeAllListeners().)
+        for (let i = 0; i < clients.length - 1; i++) {
+            const lc = totalListenerCount(clients[i]);
+            expect(
+                lc,
+                `client #${i} of ${clients.length} still has ${lc} listeners after teardown`,
+            ).toBe(0);
+        }
+    });
+});