SnowLuma v2.4.2 source snapshot

packages/core/tests/notifications-config.test.ts

@@ -0,0 +1,413 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import {
+    DEFAULT_WEBHOOK_BODY,
+    DEFAULT_EMAIL_BODY,
+    DEFAULT_EMAIL_SUBJECT,
+} from '@snowluma/common/notification-templates';
+import {
+    DEFAULT_DEBOUNCE_SECONDS,
+    defaultNotificationsConfig,
+    normalizeNotificationsConfig,
+    renderTemplate,
+} from '../src/notifications/config';
+
+describe('renderTemplate — mechanical {key} substitution', () => {
+    it('replaces present variables', () => {
+        expect(
+            renderTemplate('{nickname}({uin}) {event} @ {time}', {
+                nickname: 'Bob',
+                uin: '123',
+                event: 'offline',
+                time: '12:00',
+            }),
+        ).toBe('Bob(123) offline @ 12:00');
+    });
+
+    it('leaves missing placeholders untouched (原样)', () => {
+        expect(renderTemplate('{a}-{b}', { a: 'x' })).toBe('x-{b}');
+    });
+
+    it('replaces repeated occurrences', () => {
+        expect(renderTemplate('{x}{x}', { x: 'ab' })).toBe('abab');
+    });
+
+    it('leaves text with no placeholders unchanged', () => {
+        expect(renderTemplate('hello', { x: '1' })).toBe('hello');
+    });
+
+    it('does no logic — an empty value substitutes as empty', () => {
+        expect(renderTemplate('[{x}]', { x: '' })).toBe('[]');
+    });
+
+    it('is total — a non-string template yields an empty string', () => {
+        expect(renderTemplate(undefined as unknown as string, {})).toBe('');
+    });
+
+    it('does NOT re-expand a substituted value that itself contains a placeholder', () => {
+        // Load-bearing invariant: replacement text is never re-scanned. A refactor
+        // to a recursive/loop replace would break this while passing every other test.
+        expect(renderTemplate('{a}', { a: '{b}', b: 'NESTED' })).toBe('{b}');
+    });
+
+    it('escapes backslashes and quotes when template is JSON-like', () => {
+        const tmpl = '{"text": "{val}"}';
+        expect(renderTemplate(tmpl, { val: 'a"b\\c' })).toBe('{"text": "a\\"b\\\\c"}');
+    });
+
+    it('does NOT escape when template is plain text', () => {
+        expect(renderTemplate('{val}', { val: 'a"b\\c' })).toBe('a"b\\c');
+    });
+
+    it('preserves control characters as JSON string escapes', () => {
+        const value = 'line\nnext\r\t\b\f\0"\\';
+        const rendered = renderTemplate('{"text":"{value}"}', { value });
+        expect(JSON.parse(rendered)).toEqual({ text: value });
+    });
+});
+
+describe('normalizeNotificationsConfig — total normalize', () => {
+    it('collapses garbage / non-objects to the full default', () => {
+        const d = defaultNotificationsConfig();
+
+        for (const junk of [undefined, null, 42, 'nope', []]) {
+            expect(normalizeNotificationsConfig(junk)).toEqual(d);
+        }
+    });
+
+    it('forces version to 1 regardless of input', () => {
+        expect(normalizeNotificationsConfig({ version: 99 }).version).toBe(1);
+    });
+
+    it('clamps + truncates debounceSeconds into [0, 3600]', () => {
+        expect(normalizeNotificationsConfig({ debounceSeconds: -5 }).debounceSeconds).toBe(0);
+        expect(normalizeNotificationsConfig({ debounceSeconds: 99999 }).debounceSeconds).toBe(3600);
+        expect(normalizeNotificationsConfig({ debounceSeconds: 30.9 }).debounceSeconds).toBe(30);
+        expect(normalizeNotificationsConfig({ debounceSeconds: '45' }).debounceSeconds).toBe(45);
+        expect(normalizeNotificationsConfig({ debounceSeconds: 'x' }).debounceSeconds).toBe(
+            DEFAULT_DEBOUNCE_SECONDS,
+        );
+    });
+
+    it('drops a non-array channels value', () => {
+        expect(normalizeNotificationsConfig({ channels: 'nope' }).channels).toEqual([]);
+    });
+
+    it('keeps a valid channel and strips unknown fields', () => {
+        const { channels } = normalizeNotificationsConfig({
+            channels: [
+                {
+                    id: 'dingtalk',
+                    name: 'DingTalk',
+                    url: 'https://oapi.dingtalk.com/robot/send',
+                    bodyTemplate: '{event}',
+                    enabled: true,
+                    evil: 'x',
+                    extra: 1,
+                },
+            ],
+        });
+        expect(channels).toEqual([
+            {
+                id: 'dingtalk',
+                name: 'DingTalk',
+                type: 'webhook',
+                url: 'https://oapi.dingtalk.com/robot/send',
+                bodyTemplate: '{event}',
+                enabled: true,
+            },
+        ]);
+    });
+
+    it('drops channels lacking a valid id or http(s) url', () => {
+        const { channels } = normalizeNotificationsConfig({
+            channels: [
+                { id: '', url: 'https://a.com' }, // empty id
+                { id: 'bad id!', url: 'https://a.com' }, // invalid slug
+                { id: 'noUrl' }, // missing url
+                { id: 'ftp', url: 'ftp://a.com' }, // non-http scheme
+                { id: 'ok', url: 'http://a.com' }, // valid
+            ],
+        });
+        expect(channels.map((c) => c.id)).toEqual(['ok']);
+    });
+
+    it('dedupes channels by id (first occurrence wins)', () => {
+        const { channels } = normalizeNotificationsConfig({
+            channels: [
+                { id: 'dup', url: 'https://a.com', name: 'first' },
+                { id: 'dup', url: 'https://b.com', name: 'second' },
+            ],
+        });
+        expect(channels).toHaveLength(1);
+        expect(channels[0].name).toBe('first');
+        expect(channels[0].url).toBe('https://a.com');
+    });
+
+    it('defaults enabled=true, name→id, type=webhook, and bodyTemplate→default', () => {
+        const { channels } = normalizeNotificationsConfig({
+            channels: [{ id: 'c1', url: 'https://a.com' }],
+        });
+        expect(channels[0].enabled).toBe(true);
+        expect(channels[0].name).toBe('c1');
+        expect(channels[0].type).toBe('webhook');
+        expect(channels[0].bodyTemplate).toBe(DEFAULT_WEBHOOK_BODY);
+        expect(channels[0].headers).toBeUndefined();
+    });
+
+    it('keeps valid request headers and drops unsafe or empty ones', () => {
+        const { channels } = normalizeNotificationsConfig({
+            channels: [
+                {
+                    id: 'feishu',
+                    url: 'https://open.feishu.cn/hook',
+                    headers: {
+                        Authorization: 'Bearer secret',
+                        'X-Custom': 'ok',
+                        'Bad Name': 'x',
+                        '': 'x',
+                        Inject: 'line\r\nX-Evil: 1',
+                        Empty: '  ',
+                        NotString: 1,
+                    } as Record<string, unknown>,
+                },
+            ],
+        });
+        expect(channels[0].headers).toEqual({
+            Authorization: 'Bearer secret',
+            'X-Custom': 'ok',
+        });
+    });
+
+    it('omits an empty headers object after normalize', () => {
+        const { channels } = normalizeNotificationsConfig({
+            channels: [{ id: 'c1', url: 'https://a.com', headers: { 'Bad Name': 'x' } }],
+        });
+        expect(channels[0].headers).toBeUndefined();
+    });
+
+    it('keeps an email channel without a webhook url and fills SMTP defaults', () => {
+        const { channels } = normalizeNotificationsConfig({
+            channels: [
+                {
+                    id: 'ops-mail',
+                    type: 'email',
+                    smtpHost: 'smtp.qq.com',
+                    from: 'SnowLuma <bot@qq.com>',
+                    to: 'a@example.com; b@example.com, a@example.com',
+                },
+            ],
+        });
+        expect(channels).toEqual([
+            {
+                id: 'ops-mail',
+                name: 'ops-mail',
+                type: 'email',
+                url: '',
+                bodyTemplate: DEFAULT_EMAIL_BODY,
+                enabled: true,
+                smtpHost: 'smtp.qq.com',
+                smtpPort: 465,
+                smtpSecure: true,
+                from: 'SnowLuma <bot@qq.com>',
+                to: 'a@example.com, b@example.com',
+                subjectTemplate: DEFAULT_EMAIL_SUBJECT,
+            },
+        ]);
+    });
+
+    it('defaults port 587 when smtpSecure is explicitly false', () => {
+        const { channels } = normalizeNotificationsConfig({
+            channels: [
+                {
+                    id: 'relay',
+                    type: 'email',
+                    smtpHost: 'relay.internal',
+                    smtpSecure: false,
+                    from: 'bot@internal',
+                    to: 'ops@internal',
+                },
+            ],
+        });
+        expect(channels[0]).toMatchObject({ smtpPort: 587, smtpSecure: false });
+    });
+
+    it('treats port 587 without smtpSecure as STARTTLS (secure=false)', () => {
+        const { channels } = normalizeNotificationsConfig({
+            channels: [
+                {
+                    id: 'gmail',
+                    type: 'email',
+                    smtpHost: 'smtp.gmail.com',
+                    smtpPort: 587,
+                    from: 'bot@gmail.com',
+                    to: 'ops@gmail.com',
+                },
+            ],
+        });
+        expect(channels[0]).toMatchObject({ smtpPort: 587, smtpSecure: false });
+    });
+
+    it('drops email channels missing host / from / to, and unknown types', () => {
+        const { channels } = normalizeNotificationsConfig({
+            channels: [
+                { id: 'no-host', type: 'email', from: 'a@b.com', to: 'c@d.com' },
+                { id: 'no-from', type: 'email', smtpHost: 'smtp.example.com', to: 'c@d.com' },
+                {
+                    id: 'bad-to',
+                    type: 'email',
+                    smtpHost: 'smtp.example.com',
+                    from: 'a@b.com',
+                    to: 'not-an-email',
+                },
+                { id: 'sms', type: 'sms', url: 'https://a.com' },
+                {
+                    id: 'ok',
+                    type: 'email',
+                    smtpHost: 'smtp.example.com',
+                    from: 'a@b.com',
+                    to: 'c@d.com',
+                    smtpUser: 'a@b.com',
+                    smtpPass: 'p',
+                },
+            ],
+        });
+        expect(channels.map((c) => c.id)).toEqual(['ok']);
+        expect(channels[0]).toMatchObject({ smtpUser: 'a@b.com', smtpPass: 'p' });
+    });
+
+    it('does not keep webhook-only fields on an email channel', () => {
+        const { channels } = normalizeNotificationsConfig({
+            channels: [
+                {
+                    id: 'mail',
+                    type: 'email',
+                    url: 'https://should.be.ignored',
+                    headers: { Authorization: 'Bearer x' },
+                    smtpHost: 'smtp.example.com',
+                    from: 'a@b.com',
+                    to: 'c@d.com',
+                    evil: 'x',
+                },
+            ],
+        });
+        expect(channels[0].url).toBe('');
+        expect(channels[0].headers).toBeUndefined();
+        expect(channels[0]).not.toHaveProperty('evil');
+    });
+});
+
+describe('loadNotificationsConfig / saveNotificationsConfig (fs-backed)', () => {
+    let tmp: string;
+    let prevCwd: string;
+
+    beforeEach(() => {
+        prevCwd = process.cwd();
+        tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'sl-notif-'));
+        process.chdir(tmp);
+        vi.resetModules();
+    });
+
+    afterEach(() => {
+        process.chdir(prevCwd);
+        fs.rmSync(tmp, { recursive: true, force: true });
+    });
+
+    it('creates a default config file when absent', async () => {
+        const mod = await import('../src/notifications/config');
+        const cfg = mod.loadNotificationsConfig();
+        expect(cfg).toEqual(mod.defaultNotificationsConfig());
+        const file = path.join('config', 'notifications.json');
+        expect(fs.existsSync(file)).toBe(true);
+
+        if (process.platform !== 'win32') {
+            expect(fs.statSync(file).mode & 0o777).toBe(0o600);
+        }
+    });
+
+    it('round-trips a saved config across a fresh module load', async () => {
+        const mod = await import('../src/notifications/config');
+        const saved = mod.saveNotificationsConfig({
+            debounceSeconds: 60,
+            channels: [
+                {
+                    id: 'c1',
+                    name: 'C1',
+                    url: 'https://a.com/hook',
+                    bodyTemplate: '{event}',
+                    enabled: false,
+                },
+            ],
+        });
+        expect(saved.debounceSeconds).toBe(60);
+        expect(saved.channels).toHaveLength(1);
+
+        vi.resetModules();
+        const mod2 = await import('../src/notifications/config');
+        expect(mod2.loadNotificationsConfig()).toEqual(saved);
+    });
+
+    it('repairs permissive permissions on an existing sensitive config', async () => {
+        const file = path.join('config', 'notifications.json');
+        fs.mkdirSync('config', { recursive: true });
+        fs.writeFileSync(
+            file,
+            JSON.stringify({
+                version: 1,
+                debounceSeconds: 30,
+                channels: [{ id: 'ops', url: 'https://example.com/private-hook' }],
+            }),
+            { encoding: 'utf8', mode: 0o644 },
+        );
+
+        if (process.platform !== 'win32') {
+            fs.chmodSync(file, 0o644);
+        }
+
+        const mod = await import('../src/notifications/config');
+        expect(mod.loadNotificationsConfig().channels).toHaveLength(1);
+
+        if (process.platform !== 'win32') {
+            expect(fs.statSync(file).mode & 0o777).toBe(0o600);
+        }
+    });
+
+    it('keeps restrictive permissions after replacing an existing config', async () => {
+        const file = path.join('config', 'notifications.json');
+        fs.mkdirSync('config', { recursive: true });
+        fs.writeFileSync(file, JSON.stringify({ version: 1, debounceSeconds: 30, channels: [] }), {
+            encoding: 'utf8',
+            mode: 0o644,
+        });
+
+        if (process.platform !== 'win32') {
+            fs.chmodSync(file, 0o644);
+        }
+
+        const mod = await import('../src/notifications/config');
+        mod.saveNotificationsConfig({
+            channels: [{ id: 'ops', url: 'https://example.com/private-hook' }],
+        });
+
+        if (process.platform !== 'win32') {
+            expect(fs.statSync(file).mode & 0o777).toBe(0o600);
+        }
+    });
+
+    it('section-merges partial saves (debounce-only keeps channels)', async () => {
+        const mod = await import('../src/notifications/config');
+        mod.saveNotificationsConfig({ channels: [{ id: 'c1', url: 'https://a.com' }] });
+        const after = mod.saveNotificationsConfig({ debounceSeconds: 120 });
+        expect(after.debounceSeconds).toBe(120);
+        expect(after.channels.map((c) => c.id)).toEqual(['c1']);
+    });
+
+    it('self-heals an unreadable file on load', async () => {
+        fs.mkdirSync('config', { recursive: true });
+        fs.writeFileSync(path.join('config', 'notifications.json'), '{ not valid json', 'utf8');
+        const mod = await import('../src/notifications/config');
+        expect(mod.loadNotificationsConfig()).toEqual(mod.defaultNotificationsConfig());
+    });
+});