SnowLuma v2.4.2 source snapshot

packages/core/tests/webui-restore.test.ts

@@ -0,0 +1,468 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+    RestoreTransactionError,
+    restoreBackup,
+    type RestoreOperation,
+} from '../src/webui/restore';
+
+const TS = '2026-06-18T00:00:00.000Z';
+
+function backupWith(files: Record<string, { encoding: 'utf8' | 'base64'; data: string }>) {
+    return { version: 1, app: 'snowluma', files };
+}
+
+function runtime(port: number): { encoding: 'utf8'; data: string } {
+    return { encoding: 'utf8', data: JSON.stringify({ webuiPort: port }) };
+}
+
+function notifications(seconds: number): { encoding: 'utf8'; data: string } {
+    return {
+        encoding: 'utf8',
+        data: JSON.stringify({ version: 1, debounceSeconds: seconds, channels: [] }),
+    };
+}
+
+function validAuth() {
+    return {
+        passwordHash: 'ab'.repeat(64),
+        passwordSalt: 'cd'.repeat(16),
+        mustChangePassword: false,
+        generatedAt: TS,
+        updatedAt: TS,
+    };
+}
+
+describe('restoreBackup transaction', () => {
+    let root: string;
+
+    beforeEach(() => {
+        root = fs.mkdtempSync(path.join(os.tmpdir(), 'snowluma-restore-'));
+    });
+
+    afterEach(() => {
+        fs.rmSync(root, { recursive: true, force: true });
+    });
+
+    const livePath = (name: string) => path.join(root, name);
+
+    const writeLive = (name: string, data: string, mode = 0o644) => {
+        fs.mkdirSync(path.dirname(livePath(name)), { recursive: true });
+        fs.writeFileSync(livePath(name), data, { mode });
+        fs.chmodSync(livePath(name), mode);
+    };
+
+    const readLive = (name: string) => fs.readFileSync(livePath(name), 'utf8');
+    const transactionDirs = () =>
+        fs.readdirSync(root).filter((name) => name.startsWith('.restore-transaction-'));
+
+    function run(
+        files: Record<string, { encoding: 'utf8' | 'base64'; data: string }>,
+        beforeOperation?: (operation: RestoreOperation) => void,
+    ) {
+        return restoreBackup(backupWith(files), {
+            configDir: root,
+            restoreCredentials: true,
+            transactionId: 'test-transaction',
+            beforeOperation,
+        });
+    }
+
+    it('commits every prepared file, enforces credential mode, and removes the temporary snapshot', () => {
+        writeLive('runtime.json', '{"old":true}');
+        writeLive('webui.json', JSON.stringify(validAuth()), 0o644);
+
+        const result = run({
+            'runtime.json': runtime(5100),
+            'webui.json': { encoding: 'utf8', data: JSON.stringify(validAuth()) },
+        });
+
+        expect(JSON.parse(readLive('runtime.json')).webuiPort).toBe(5100);
+        expect(JSON.parse(readLive('webui.json')).passwordHash).toBe(validAuth().passwordHash);
+        expect(fs.statSync(livePath('webui.json')).mode & 0o777).toBe(0o600);
+        expect(result).toEqual(
+            expect.objectContaining({
+                transactionId: 'test-transaction',
+                restored: ['runtime.json', 'webui.json'],
+                skipped: [],
+                restartRequiredToApply: true,
+            }),
+        );
+        expect(transactionDirs()).toEqual([]);
+    });
+
+    it('does not request a restart or create a transaction when nothing is selected', () => {
+        const result = run({});
+
+        expect(result).toEqual(
+            expect.objectContaining({
+                restored: [],
+                skipped: [],
+                migrated: [],
+                restartRequiredToApply: false,
+            }),
+        );
+        expect(transactionDirs()).toEqual([]);
+    });
+
+    it.each([
+        ['snapshot', 'copy-current'],
+        ['stage', 'write-staged'],
+        ['stage', 'chmod-staged'],
+    ] as const)('leaves every live file untouched when %s fails', (phase, operation) => {
+        const oldRuntime = '{"old":"runtime"}';
+        const oldNotifications = '{"old":"notifications"}';
+        writeLive('runtime.json', oldRuntime);
+        writeLive('notifications.json', oldNotifications);
+
+        expect(() =>
+            run(
+                {
+                    'runtime.json': runtime(5101),
+                    'notifications.json': notifications(45),
+                },
+                (point) => {
+                    if (
+                        point.phase === phase &&
+                        point.operation === operation &&
+                        point.file === 'notifications.json'
+                    ) {
+                        throw new Error(`injected ${phase} failure`);
+                    }
+                },
+            ),
+        ).toThrow(RestoreTransactionError);
+
+        expect(readLive('runtime.json')).toBe(oldRuntime);
+        expect(readLive('notifications.json')).toBe(oldNotifications);
+        expect(transactionDirs()).toEqual([]);
+    });
+
+    it('rolls every file back when a later commit rename fails', () => {
+        const oldRuntime = '{"old":"runtime"}';
+        const oldNotifications = '{"old":"notifications"}';
+        writeLive('runtime.json', oldRuntime);
+        writeLive('notifications.json', oldNotifications);
+
+        let thrown: unknown;
+
+        try {
+            run(
+                {
+                    'runtime.json': runtime(5102),
+                    'notifications.json': notifications(60),
+                },
+                (point) => {
+                    if (
+                        point.phase === 'commit' &&
+                        point.operation === 'rename-staged' &&
+                        point.file === 'notifications.json'
+                    ) {
+                        throw new Error('injected commit failure');
+                    }
+                },
+            );
+        } catch (error) {
+            thrown = error;
+        }
+
+        expect(thrown).toEqual(
+            expect.objectContaining({
+                name: 'RestoreTransactionError',
+                phase: 'commit',
+                rollbackSucceeded: true,
+                committed: false,
+            }),
+        );
+        expect(readLive('runtime.json')).toBe(oldRuntime);
+        expect(readLive('notifications.json')).toBe(oldNotifications);
+        expect(transactionDirs()).toEqual([]);
+    });
+
+    it('removes files that did not exist before when rolling a partial commit back', () => {
+        const oldRuntime = '{"old":"runtime"}';
+        const oldUi = '{}';
+        writeLive('runtime.json', oldRuntime);
+        writeLive('ui.json', oldUi);
+
+        expect(() =>
+            run(
+                {
+                    'runtime.json': runtime(5103),
+                    'notifications.json': notifications(75),
+                    'ui.json': { encoding: 'utf8', data: '{}' },
+                },
+                (point) => {
+                    if (
+                        point.phase === 'commit' &&
+                        point.operation === 'rename-staged' &&
+                        point.file === 'ui.json'
+                    ) {
+                        throw new Error('injected final commit failure');
+                    }
+                },
+            ),
+        ).toThrow(RestoreTransactionError);
+
+        expect(readLive('runtime.json')).toBe(oldRuntime);
+        expect(fs.existsSync(livePath('notifications.json'))).toBe(false);
+        expect(readLive('ui.json')).toBe(oldUi);
+        expect(transactionDirs()).toEqual([]);
+    });
+
+    it('retains the snapshot and reports its path only when rollback itself fails', () => {
+        writeLive('runtime.json', '{"old":"runtime"}');
+        writeLive('notifications.json', '{"old":"notifications"}');
+
+        let thrown: unknown;
+
+        try {
+            run(
+                {
+                    'runtime.json': runtime(5104),
+                    'notifications.json': notifications(90),
+                },
+                (point) => {
+                    if (
+                        point.phase === 'commit' &&
+                        point.operation === 'rename-staged' &&
+                        point.file === 'notifications.json'
+                    ) {
+                        throw new Error('injected commit failure');
+                    }
+
+                    if (
+                        point.phase === 'rollback' &&
+                        point.operation === 'restore-current' &&
+                        point.file === 'runtime.json'
+                    ) {
+                        throw new Error('injected rollback failure');
+                    }
+                },
+            );
+        } catch (error) {
+            thrown = error;
+        }
+
+        expect(thrown).toEqual(
+            expect.objectContaining({
+                name: 'RestoreTransactionError',
+                phase: 'rollback',
+                rollbackSucceeded: false,
+                snapshotDir: expect.stringContaining('.restore-transaction-test-transaction'),
+            }),
+        );
+        const snapshotDir = (thrown as RestoreTransactionError).snapshotDir!;
+        expect(fs.existsSync(snapshotDir)).toBe(true);
+        expect(fs.statSync(snapshotDir).mode & 0o777).toBe(0o700);
+        expect(fs.existsSync(path.join(snapshotDir, 'snapshot', 'runtime.json'))).toBe(true);
+        const causes = ((thrown as RestoreTransactionError).cause as AggregateError).errors;
+        expect(
+            causes.map((error: unknown) =>
+                error instanceof Error ? error.message : String(error),
+            ),
+        ).toEqual(['injected commit failure', 'injected rollback failure']);
+    });
+
+    it('performs no filesystem transaction when semantic preflight fails', () => {
+        const oldRuntime = '{"old":"runtime"}';
+        writeLive('runtime.json', oldRuntime);
+        const operations: RestoreOperation[] = [];
+
+        let thrown: unknown;
+
+        try {
+            run(
+                {
+                    'runtime.json': {
+                        encoding: 'utf8',
+                        data: JSON.stringify({ webuiPort: 70_000 }),
+                    },
+                },
+                (operation) => operations.push(operation),
+            );
+        } catch (error) {
+            thrown = error;
+        }
+
+        expect(thrown).toEqual(
+            expect.objectContaining({
+                name: 'RestoreTransactionError',
+                phase: 'preflight',
+                transactionId: 'test-transaction',
+                failedFiles: ['runtime.json'],
+            }),
+        );
+        expect((thrown as RestoreTransactionError).cause).toEqual(
+            expect.objectContaining({
+                name: 'RestorePreflightError',
+                file: 'runtime.json',
+            }),
+        );
+        expect(operations).toEqual([]);
+        expect(readLive('runtime.json')).toBe(oldRuntime);
+        expect(transactionDirs()).toEqual([]);
+    });
+
+    it('fails preflight when a required current OneBot file cannot be read', () => {
+        fs.symlinkSync('onebot.json', livePath('onebot.json'));
+
+        let thrown: unknown;
+
+        try {
+            run({
+                'onebot_12345.json': {
+                    encoding: 'utf8',
+                    data: JSON.stringify({
+                        mode: 'overlay',
+                        httpClients: [{ name: 'remote', url: 'https://example.test/onebot' }],
+                    }),
+                },
+            });
+        } catch (error) {
+            thrown = error;
+        }
+
+        expect(thrown).toEqual(
+            expect.objectContaining({
+                name: 'RestoreTransactionError',
+                phase: 'preflight',
+                failedFiles: ['onebot.json'],
+            }),
+        );
+        expect((thrown as RestoreTransactionError).cause).toEqual(
+            expect.objectContaining({
+                name: 'RestorePreflightError',
+                file: 'onebot.json',
+            }),
+        );
+        expect(transactionDirs()).toEqual([]);
+    });
+
+    it('reports a committed restore distinctly when final cleanup fails', () => {
+        writeLive('runtime.json', '{"old":"runtime"}');
+
+        let thrown: unknown;
+
+        try {
+            run({ 'runtime.json': runtime(5105) }, (point) => {
+                if (point.phase === 'cleanup') {
+                    throw new Error('injected cleanup failure');
+                }
+            });
+        } catch (error) {
+            thrown = error;
+        }
+
+        expect(thrown).toEqual(
+            expect.objectContaining({
+                name: 'RestoreTransactionError',
+                phase: 'cleanup',
+                committed: true,
+                snapshotDir: expect.stringContaining('.restore-transaction-test-transaction'),
+            }),
+        );
+        expect(JSON.parse(readLive('runtime.json')).webuiPort).toBe(5105);
+        expect(fs.existsSync((thrown as RestoreTransactionError).snapshotDir!)).toBe(true);
+    });
+
+    it('never removes an existing transaction directory when id allocation collides', () => {
+        writeLive('runtime.json', '{"old":"runtime"}');
+        const existing = path.join(root, '.restore-transaction-test-transaction');
+        fs.mkdirSync(path.join(existing, 'snapshot'), { recursive: true });
+        const marker = path.join(existing, 'snapshot', 'manual-recovery-marker');
+        fs.writeFileSync(marker, 'keep me');
+
+        expect(() => run({ 'runtime.json': runtime(5106) })).toThrow(RestoreTransactionError);
+
+        expect(fs.readFileSync(marker, 'utf8')).toBe('keep me');
+        expect(readLive('runtime.json')).toBe('{"old":"runtime"}');
+    });
+
+    it('keeps the original stage failure file and both causes when cleanup also fails', () => {
+        writeLive('runtime.json', '{"old":"runtime"}');
+        writeLive('notifications.json', '{"old":"notifications"}');
+
+        let thrown: unknown;
+
+        try {
+            run(
+                {
+                    'runtime.json': runtime(5107),
+                    'notifications.json': notifications(30),
+                },
+                (point) => {
+                    if (
+                        point.phase === 'stage' &&
+                        point.operation === 'write-staged' &&
+                        point.file === 'notifications.json'
+                    ) {
+                        throw new Error('stage-root-cause');
+                    }
+
+                    if (point.phase === 'cleanup') {
+                        throw new Error('cleanup-root-cause');
+                    }
+                },
+            );
+        } catch (error) {
+            thrown = error;
+        }
+
+        expect(thrown).toEqual(
+            expect.objectContaining({
+                phase: 'cleanup',
+                committed: false,
+                failedFiles: ['notifications.json'],
+            }),
+        );
+        const causes = ((thrown as RestoreTransactionError).cause as AggregateError).errors;
+        expect(causes.map((error: unknown) => (error as Error).message)).toEqual([
+            'stage-root-cause',
+            'cleanup-root-cause',
+        ]);
+    });
+
+    it('keeps the failed commit file and both causes when post-rollback cleanup fails', () => {
+        writeLive('runtime.json', '{"old":"runtime"}');
+        writeLive('notifications.json', '{"old":"notifications"}');
+
+        let thrown: unknown;
+
+        try {
+            run(
+                {
+                    'runtime.json': runtime(5108),
+                    'notifications.json': notifications(30),
+                },
+                (point) => {
+                    if (point.phase === 'commit' && point.file === 'notifications.json') {
+                        throw new Error('commit-root-cause');
+                    }
+
+                    if (point.phase === 'cleanup') {
+                        throw new Error('cleanup-root-cause');
+                    }
+                },
+            );
+        } catch (error) {
+            thrown = error;
+        }
+
+        expect(thrown).toEqual(
+            expect.objectContaining({
+                phase: 'cleanup',
+                rollbackSucceeded: true,
+                committed: false,
+                failedFiles: ['notifications.json'],
+            }),
+        );
+        const causes = ((thrown as RestoreTransactionError).cause as AggregateError).errors;
+        expect(causes.map((error: unknown) => (error as Error).message)).toEqual([
+            'commit-root-cause',
+            'cleanup-root-cause',
+        ]);
+    });
+});