SnowLuma/packages/onebot/tests/message-store-migration-task.test.ts

import { EventEmitter } from 'node:events';
import { describe, expect, it, vi } from 'vitest';
import { subscribeLogs } from '@snowluma/common/logger';
import type { DatabaseMigrationCallbacks } from '../src/manager';
import {
    createMessageStoreMigrationTask,
    type MessageStoreMigrationWorkerHandle,
} from '../src/message-store-migration-task';

function fakeWorker(): EventEmitter & MessageStoreMigrationWorkerHandle {
    const worker = new EventEmitter() as EventEmitter & MessageStoreMigrationWorkerHandle;
    worker.postMessage = vi.fn();
    worker.unref = vi.fn();
    return worker;
}

function callbacks(): DatabaseMigrationCallbacks {
    return {
        onReady: vi.fn(),
        onProgress: vi.fn(),
        onFailed: vi.fn(),
    };
}

describe('message-store migration task lifecycle', () => {
    it('records worker preparation through the parent logger with account context', () => {
        const worker = fakeWorker();
        const handlers = callbacks();
        const entries: Array<{ scope: string; uin?: number; message: string }> = [];
        const unsubscribe = subscribeLogs((entry) => entries.push(entry));
        const task = createMessageStoreMigrationTask('10001', () => worker);

        try {
            task.start(handlers);
            worker.emit('message', { kind: 'preparation', progress: { stage: 'started' } });
            worker.emit('message', {
                kind: 'preparation',
                progress: { stage: 'indexed', elapsedMs: 12.5 },
            });
            worker.emit('message', {
                kind: 'preparation',
                progress: { stage: 'counted', total: 3, elapsedMs: 2.1 },
            });
            expect(
                entries.map((entry) => ({
                    scope: entry.scope,
                    uin: entry.uin,
                    message: entry.message,
                })),
            ).toEqual([
                {
                    scope: 'OneBot.MessageMigration',
                    uin: 10001,
                    message: 'preparing message history migration',
                },
                {
                    scope: 'OneBot.MessageMigration',
                    uin: 10001,
                    message: 'message history migration preparation finished in 13ms',
                },
                {
                    scope: 'OneBot.MessageMigration',
                    uin: 10001,
                    message: 'message history migration: pending=3 checked in 2ms',
                },
            ]);
            expect(handlers.onProgress).not.toHaveBeenCalled();
            expect(handlers.onFailed).not.toHaveBeenCalled();
            task.cancel();
            worker.emit('message', { kind: 'preparation', progress: { stage: 'started' } });
            expect(entries).toHaveLength(3);
        } finally {
            unsubscribe();
        }
    });

    it('reports an exit before completion even when its code is zero', () => {
        const worker = fakeWorker();
        const handlers = callbacks();
        const task = createMessageStoreMigrationTask('10001', () => worker);

        task.start(handlers);
        worker.emit('exit', 0);

        expect(handlers.onFailed).toHaveBeenCalledOnce();
    });

    it('accepts a normal exit after completion', () => {
        const worker = fakeWorker();
        const handlers = callbacks();
        const task = createMessageStoreMigrationTask('10001', () => worker);

        task.start(handlers);
        worker.emit('message', {
            kind: 'progress',
            status: { phase: 'complete', processed: 8, total: 8 },
            elapsedMs: 25,
        });
        worker.emit('exit', 0);

        expect(handlers.onProgress).toHaveBeenCalledOnce();
        expect(handlers.onFailed).not.toHaveBeenCalled();
    });

    it('ignores worker exit after cancellation', () => {
        const worker = fakeWorker();
        const handlers = callbacks();
        const task = createMessageStoreMigrationTask('10001', () => worker);

        task.start(handlers);
        task.cancel();
        worker.emit('exit', 1);

        expect(worker.postMessage).toHaveBeenCalledWith('cancel');
        expect(worker.unref).toHaveBeenCalledOnce();
        expect(handlers.onFailed).not.toHaveBeenCalled();
    });
});