Files
SnowLuma/packages/core/tests/notifications-config.test.ts
T
渡辺鳩P 06c8954881 feat(notifications): default body template → Server酱 JSON (title/desp) (#108)
- Change DEFAULT_BODY_TEMPLATE from plaintext to Server酱-style JSON
- Add JSON-safe escaping in renderTemplate for backslashes and quotes
- Update frontend DEFAULT_TEMPLATE to match backend
- Add tests for JSON escaping behavior

Fixes #106 (targets dev branch)
2026-06-18 16:10:09 +08:00

195 lines
6.9 KiB
TypeScript

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import fs from 'fs';
import os from 'os';
import path from 'path';
import {
DEFAULT_BODY_TEMPLATE,
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');
});
});
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',
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, 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].bodyTemplate).toBe(DEFAULT_BODY_TEMPLATE);
});
});
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());
expect(fs.existsSync(path.join('config', 'notifications.json'))).toBe(true);
});
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('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());
});
});