447 lines
20 KiB
JavaScript
447 lines
20 KiB
JavaScript
// Stage 7 tests: shared/settings-schema.js
|
||
//
|
||
// 覆盖：
|
||
// - DEFAULT_SETTINGS：导出 + 含必要字段
|
||
// - coerceLoadedSettings：未知字段剥除 / 已知字段合并默认值
|
||
// - validateKey：enum / boolean / number clamp / nullable-path
|
||
// - validateAndSanitize：批量校验，遇到非法字段提前失败
|
||
//
|
||
// shared/ 是 CommonJS，直接 require 即可（不像 main/ 需要 _setApp 注入）。
|
||
|
||
import { describe, it, expect } from 'vitest';
|
||
import { readFileSync } from 'node:fs';
|
||
import { fileURLToPath } from 'node:url';
|
||
import { dirname, resolve } from 'node:path';
|
||
|
||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||
const SCHEMA_PATH = resolve(__dirname, '../../shared/settings-schema.js');
|
||
|
||
const schema = require('../../shared/settings-schema.js');
|
||
const {
|
||
DEFAULT_SETTINGS,
|
||
coerceLoadedSettings,
|
||
validateKey,
|
||
validateAndSanitize,
|
||
SETTINGS_SCHEMA,
|
||
} = schema;
|
||
|
||
describe('DEFAULT_SETTINGS', () => {
|
||
it('导出且包含核心字段', () => {
|
||
expect(DEFAULT_SETTINGS).toBeDefined();
|
||
expect(DEFAULT_SETTINGS.theme).toBeDefined();
|
||
expect(DEFAULT_SETTINGS.themePalette).toBeDefined();
|
||
expect(DEFAULT_SETTINGS.dataDir).toBeDefined();
|
||
expect(DEFAULT_SETTINGS.alwaysOnTop).toBe(false);
|
||
});
|
||
|
||
it('AI 默认值：provider = openai；baseUrl / apiKey / model / systemPrompt 空串', () => {
|
||
expect(DEFAULT_SETTINGS.aiProvider).toBe('openai');
|
||
expect(DEFAULT_SETTINGS.aiBaseUrl).toBe('');
|
||
expect(DEFAULT_SETTINGS.aiApiKey).toBe('');
|
||
expect(DEFAULT_SETTINGS.aiModel).toBe('');
|
||
expect(DEFAULT_SETTINGS.aiSystemPrompt).toBe('');
|
||
});
|
||
});
|
||
|
||
describe('coerceLoadedSettings', () => {
|
||
it('非对象 → 默认值', () => {
|
||
expect(coerceLoadedSettings(null)).toEqual({ ...DEFAULT_SETTINGS });
|
||
expect(coerceLoadedSettings('str')).toEqual({ ...DEFAULT_SETTINGS });
|
||
});
|
||
|
||
it('已知字段被 raw 覆盖', () => {
|
||
const out = coerceLoadedSettings({ theme: 'light', readerFontSize: 19 });
|
||
expect(out.theme).toBe('light');
|
||
expect(out.readerFontSize).toBe(19);
|
||
});
|
||
|
||
it('未知字段被剥除', () => {
|
||
const out = coerceLoadedSettings({ theme: 'light', bogus: 'x' });
|
||
expect(out.theme).toBe('light');
|
||
expect(out).not.toHaveProperty('bogus');
|
||
});
|
||
|
||
it('缺省字段用默认值', () => {
|
||
const out = coerceLoadedSettings({ theme: 'light' });
|
||
expect(out.theme).toBe('light');
|
||
expect(out.themePalette).toBe(DEFAULT_SETTINGS.themePalette);
|
||
});
|
||
|
||
it('旧 autoSaveIntervalSec (0) → 迁移到 autoSaveDebounceMs (0)', () => {
|
||
// 旧版 0 = 关闭；新版 0 = 关闭 —— 直接 1:1 映射
|
||
const out = coerceLoadedSettings({ autoSaveIntervalSec: 0 });
|
||
expect(out.autoSaveDebounceMs).toBe(0);
|
||
expect(out).not.toHaveProperty('autoSaveIntervalSec');
|
||
});
|
||
|
||
it('旧 autoSaveIntervalSec (3 / 10) → 迁移到 autoSaveDebounceMs (500)', () => {
|
||
// 旧版「开启」档（3 秒、10 秒轮询）→ 新版「500ms 防抖」
|
||
// 语义从「每隔 X 秒轮询」变成「停打 X ms 后保存」；统一映射到 500ms 默认值。
|
||
expect(coerceLoadedSettings({ autoSaveIntervalSec: 3 }).autoSaveDebounceMs).toBe(500);
|
||
expect(coerceLoadedSettings({ autoSaveIntervalSec: 10 }).autoSaveDebounceMs).toBe(500);
|
||
});
|
||
|
||
it('autoSaveDebounceMs 越界 → clamp 到边界', () => {
|
||
// 验证 number 类型规则生效：超界值被 clamp，不被丢弃
|
||
expect(coerceLoadedSettings({ autoSaveDebounceMs: 99999 }).autoSaveDebounceMs).toBe(60000);
|
||
expect(coerceLoadedSettings({ autoSaveDebounceMs: -100 }).autoSaveDebounceMs).toBe(0);
|
||
});
|
||
|
||
it('string 字段超长 → 丢弃回默认（同步路径用 rule.max）', () => {
|
||
// 同步路径（coerceLoadedSettings / sanitizeSync）一直用 rule.max；本次 audit
|
||
// 修复的是 async validateKey 误写 opts.max 的问题。两条路径必须保持一致。
|
||
const out = coerceLoadedSettings({ aiModel: 'a'.repeat(10_000) });
|
||
expect(out.aiModel).toBe(DEFAULT_SETTINGS.aiModel);
|
||
});
|
||
|
||
it('Phase N 修复：下划线前缀的元数据键（如 _hasAiKey）保留', () => {
|
||
// 主进程 get-settings / save-settings 都会注入 _hasAiKey 作为「是否配置过 API Key」
|
||
// 的只读元数据标记。旧实现只迭代 Object.keys(DEFAULT_SETTINGS)，未知键全 drop，
|
||
// 导致 renderer settingsStore.load() 后拿不到 _hasAiKey，「显示已填 Key」+ reveal
|
||
// 流程全失效。下划线前缀约定为「只读元数据、不写盘」，coerce 阶段需保留。
|
||
const out = coerceLoadedSettings({ theme: 'dark', _hasAiKey: true });
|
||
expect(out.theme).toBe('dark');
|
||
expect(out._hasAiKey).toBe(true);
|
||
});
|
||
|
||
it('非下划线前缀的未知键仍被剥除（确保下划线特判不会过度放行）', () => {
|
||
// 防御：下划线特判只放行 _ 前缀，普通 unknown 字段仍走原剥离路径，
|
||
// 不让攻击者用 _privateName 这种「看上去像元数据」的字段把脏数据灌进内存。
|
||
const out = coerceLoadedSettings({ theme: 'dark', _privateNote: 'secret', bogus: 42 });
|
||
expect(out).not.toHaveProperty('_privateNote');
|
||
expect(out).not.toHaveProperty('bogus');
|
||
});
|
||
|
||
// fix(audit 2026-08)：同步路径（sanitizeSync / coerceLoadedSettings）之前
|
||
// 不校验 format 字段，导致手改 settings.json 写 aiBaseUrl: "ftp://x" /
|
||
// "not-a-url" 会被静默接受，渲染端拿到无效 URL，真正 fetch 时才报 TypeError
|
||
// 错误链很难定位到 settings。
|
||
it('aiBaseUrl 非法 URL（同步路径） → 丢弃回默认空串', () => {
|
||
expect(coerceLoadedSettings({ aiBaseUrl: 'ftp://x.y' }).aiBaseUrl).toBe('');
|
||
expect(coerceLoadedSettings({ aiBaseUrl: 'not-a-url' }).aiBaseUrl).toBe('');
|
||
expect(coerceLoadedSettings({ aiBaseUrl: 'javascript:alert(1)' }).aiBaseUrl).toBe('');
|
||
// http:/missing-slash.com —— URL 构造器能解析但 fetch 行为不一致，必须拒绝
|
||
expect(coerceLoadedSettings({ aiBaseUrl: 'http:/missing-slash.com' }).aiBaseUrl).toBe('');
|
||
});
|
||
|
||
it('aiBaseUrl 合法 http(s) URL（同步路径） → 保留', () => {
|
||
expect(coerceLoadedSettings({ aiBaseUrl: 'https://api.openai.com/v1' }).aiBaseUrl).toBe(
|
||
'https://api.openai.com/v1',
|
||
);
|
||
expect(coerceLoadedSettings({ aiBaseUrl: 'http://10.0.0.1:11434/v1' }).aiBaseUrl).toBe(
|
||
'http://10.0.0.1:11434/v1',
|
||
);
|
||
});
|
||
|
||
// fix(audit 2026-08)：Boolean 输入不应被 Number() 强转。
|
||
// Number(true) === 1、Number(false) === 0，旧版会让 autoSaveDebounceMs: true
|
||
// 静默变 1ms（激进到每个 keystroke 都存），splitRatio: false 变 0（无预览）。
|
||
it('number 字段 Boolean 输入 → 丢弃回默认', () => {
|
||
expect(coerceLoadedSettings({ autoSaveDebounceMs: true }).autoSaveDebounceMs)
|
||
.toBe(DEFAULT_SETTINGS.autoSaveDebounceMs);
|
||
expect(coerceLoadedSettings({ splitRatio: false }).splitRatio)
|
||
.toBe(DEFAULT_SETTINGS.splitRatio);
|
||
expect(coerceLoadedSettings({ readerFontSize: true }).readerFontSize)
|
||
.toBe(DEFAULT_SETTINGS.readerFontSize);
|
||
});
|
||
|
||
// fix(audit 2026-08)：round:1 会把 1.85 静默四舍五入到 1.9。UI 选项列出
|
||
// 的是 [1.5, 1.7, 1.85, 2.0] 两位小数，round:2 才能保留用户的选择。
|
||
it('readerLineHeight 1.85 不会被四舍五入到 1.9', () => {
|
||
expect(coerceLoadedSettings({ readerLineHeight: 1.85 }).readerLineHeight).toBe(1.85);
|
||
expect(coerceLoadedSettings({ readerLineHeight: 1.7 }).readerLineHeight).toBe(1.7);
|
||
expect(coerceLoadedSettings({ readerLineHeight: 2.0 }).readerLineHeight).toBe(2.0);
|
||
});
|
||
});
|
||
|
||
describe('validateKey', () => {
|
||
it('enum 合法值 → ok', async () => {
|
||
const r = await validateKey('theme', 'light');
|
||
expect(r.ok).toBe(true);
|
||
expect(r.value).toBe('light');
|
||
});
|
||
|
||
it('enum 非法值 → 报错', async () => {
|
||
const r = await validateKey('theme', 'rainbow');
|
||
expect(r.ok).toBe(false);
|
||
expect(r.error).toMatch(/theme 取值非法/);
|
||
});
|
||
|
||
it('boolean 非法类型 → 报错', async () => {
|
||
const r = await validateKey('alwaysOnTop', 'yes');
|
||
expect(r.ok).toBe(false);
|
||
});
|
||
|
||
it('number clamp 越界 → clamp 到边界', async () => {
|
||
const tooBig = await validateKey('readerFontSize', 99);
|
||
expect(tooBig.ok).toBe(true);
|
||
expect(tooBig.value).toBe(SETTINGS_SCHEMA.readerFontSize.max);
|
||
|
||
const tooSmall = await validateKey('readerFontSize', 1);
|
||
expect(tooSmall.ok).toBe(true);
|
||
expect(tooSmall.value).toBe(SETTINGS_SCHEMA.readerFontSize.min);
|
||
});
|
||
|
||
it('number 非数字 → 报错', async () => {
|
||
const r = await validateKey('readerFontSize', 'big');
|
||
expect(r.ok).toBe(false);
|
||
});
|
||
|
||
it('nullable-path 空字符串 → null', async () => {
|
||
const r = await validateKey('dataDir', ' ');
|
||
expect(r.ok).toBe(true);
|
||
expect(r.value).toBe(null);
|
||
});
|
||
|
||
// audit fix (Round 9)：nullable-number 与 number 分支对称拒绝空串。
|
||
// 旧版 `case 'nullable-number'` 直接 `Number(raw)` → Number('') === 0 →
|
||
// clamp 到 min，sidebarWidth='' 会被静默改成 200（默认 min）。
|
||
it('nullable-number 空字符串 → 报错（不是 0）', async () => {
|
||
const r = await validateKey('sidebarWidth', '');
|
||
expect(r.ok).toBe(false);
|
||
});
|
||
|
||
it('nullable-number 全空白字符串 → 报错', async () => {
|
||
const r = await validateKey('sidebarWidth', ' ');
|
||
expect(r.ok).toBe(false);
|
||
});
|
||
|
||
it('nullable-number null → null（合法）', async () => {
|
||
const r = await validateKey('sidebarWidth', null);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.value).toBe(null);
|
||
});
|
||
|
||
it('nullable-number undefined → 视为 null（与同步路径一致）', async () => {
|
||
// 审计修复 (Round 11 deep-fix P2-3)：nullable 字段的 undefined 与 null 同义。
|
||
// 旧版 async 路径把 undefined 当作错误（与同步 sanitizeSync 行为不一致），
|
||
// 导致 load() 接受 + update() 拒绝同一字段。
|
||
const r = await validateKey('sidebarWidth', undefined);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.value).toBeNull();
|
||
});
|
||
|
||
it('nullable-path 非字符串 → 报错', async () => {
|
||
const r = await validateKey('dataDir', 123);
|
||
expect(r.ok).toBe(false);
|
||
});
|
||
|
||
it('未知字段 → 报错', async () => {
|
||
const r = await validateKey('unknown', 'anything');
|
||
expect(r.ok).toBe(false);
|
||
expect(r.error).toMatch(/未知设置项/);
|
||
});
|
||
|
||
it('autoSaveDebounceMs 合法值 0 / 500 / 60000', async () => {
|
||
expect((await validateKey('autoSaveDebounceMs', 0)).ok).toBe(true);
|
||
expect((await validateKey('autoSaveDebounceMs', 500)).ok).toBe(true);
|
||
expect((await validateKey('autoSaveDebounceMs', 60000)).ok).toBe(true);
|
||
});
|
||
|
||
it('autoSaveDebounceMs 越界 → clamp', async () => {
|
||
// -1 → 0；99999 → 60000（clamp 行为）
|
||
expect((await validateKey('autoSaveDebounceMs', -1)).value).toBe(0);
|
||
expect((await validateKey('autoSaveDebounceMs', 99999)).value).toBe(60000);
|
||
});
|
||
|
||
it('autoSaveDebounceMs 非数字 → 报错', async () => {
|
||
const r = await validateKey('autoSaveDebounceMs', 'soon');
|
||
expect(r.ok).toBe(false);
|
||
});
|
||
|
||
it('aiProvider openai / anthropic → ok', async () => {
|
||
expect((await validateKey('aiProvider', 'openai')).value).toBe('openai');
|
||
expect((await validateKey('aiProvider', 'anthropic')).value).toBe('anthropic');
|
||
});
|
||
|
||
it('aiProvider 非法值 → 报错', async () => {
|
||
const r = await validateKey('aiProvider', 'gemini');
|
||
expect(r.ok).toBe(false);
|
||
expect(r.error).toMatch(/aiProvider 取值非法/);
|
||
});
|
||
|
||
it('string 字段超过 rule.max → 报错', async () => {
|
||
// audit fix：之前误用 opts.max，导致 aiApiKey/aiBaseUrl/aiModel/aiSystemPrompt
|
||
// 声明的字符上限从未生效。这里锁定 rule.max 路径。
|
||
expect((await validateKey('aiModel', 'a'.repeat(257))).ok).toBe(false);
|
||
expect((await validateKey('aiBaseUrl', 'a'.repeat(4097))).ok).toBe(false);
|
||
expect((await validateKey('aiApiKey', 'k'.repeat(4097))).ok).toBe(false);
|
||
expect((await validateKey('aiSystemPrompt', 'x'.repeat(200_001))).ok).toBe(false);
|
||
});
|
||
|
||
it('string 字段在 rule.max 范围内 → ok', async () => {
|
||
expect((await validateKey('aiModel', 'a'.repeat(256))).ok).toBe(true);
|
||
// aiBaseUrl 现在带 url-https 格式校验 —— 用合法 URL 串代替 'a'.repeat，
|
||
// 否则 URL 校验会拒绝非 URL 字符。最大长度限制的覆盖由上面的「超长」
|
||
// 测试用例保证。12 字符 scheme/host + 4084 字符 path = 4096 总长。
|
||
expect((await validateKey('aiBaseUrl', 'https://a.aa/' + 'a'.repeat(4083))).ok).toBe(true);
|
||
expect((await validateKey('aiApiKey', 'k'.repeat(4096))).ok).toBe(true);
|
||
expect((await validateKey('aiSystemPrompt', 'x'.repeat(200_000))).ok).toBe(true);
|
||
});
|
||
|
||
it('string 字段超长错误信息含上限值', async () => {
|
||
const r = await validateKey('aiModel', 'a'.repeat(257));
|
||
expect(r.error).toMatch(/超过 256 字符/);
|
||
});
|
||
});
|
||
|
||
describe('validateAndSanitize', () => {
|
||
it('合法 batch → 返回 sanitized 对象', async () => {
|
||
const r = await validateAndSanitize({ theme: 'light', readerFontSize: 18 });
|
||
expect(r.ok).toBe(true);
|
||
expect(r.sanitized.theme).toBe('light');
|
||
expect(r.sanitized.readerFontSize).toBe(18);
|
||
});
|
||
|
||
it('任一字段非法 → 整个失败', async () => {
|
||
const r = await validateAndSanitize({ theme: 'light', readerFontSize: 'huge' });
|
||
expect(r.ok).toBe(false);
|
||
});
|
||
|
||
it('非对象 → 报错', async () => {
|
||
expect((await validateAndSanitize(null)).ok).toBe(false);
|
||
expect((await validateAndSanitize('str')).ok).toBe(false);
|
||
expect((await validateAndSanitize([])).ok).toBe(false);
|
||
});
|
||
|
||
it('空对象 → 空 sanitized', async () => {
|
||
const r = await validateAndSanitize({});
|
||
expect(r.ok).toBe(true);
|
||
expect(r.sanitized).toEqual({});
|
||
});
|
||
});
|
||
|
||
// ------------------------------------------------------------------
|
||
// AI 字段的「空串是合法值」契约
|
||
//
|
||
// settings-dialog.js:303-326「清空 AI 配置」按钮依赖此契约：按钮设
|
||
// aiKeyInput.value = ''，保存时 diff 检测 '' !== initial.aiApiKey → patch 含
|
||
// aiApiKey: ''，走 settingsStore.update → settings-schema 校验 → 写盘。
|
||
// 若未来 schema 把 '' 改成 null / undefined 或拒绝空串，清空按钮会无声失效。
|
||
// ------------------------------------------------------------------
|
||
describe('AI 字段空串是合法值（清空按钮依赖此契约）', () => {
|
||
it('aiApiKey: "" → 接受且保留为空串', async () => {
|
||
const r = await validateAndSanitize({ aiApiKey: '' });
|
||
expect(r.ok).toBe(true);
|
||
expect(r.sanitized.aiApiKey).toBe('');
|
||
});
|
||
|
||
it('aiBaseUrl / aiModel / aiSystemPrompt 同时清空 → 全部接受', async () => {
|
||
const r = await validateAndSanitize({
|
||
aiApiKey: '',
|
||
aiBaseUrl: '',
|
||
aiModel: '',
|
||
aiSystemPrompt: '',
|
||
});
|
||
expect(r.ok).toBe(true);
|
||
expect(r.sanitized.aiApiKey).toBe('');
|
||
expect(r.sanitized.aiBaseUrl).toBe('');
|
||
expect(r.sanitized.aiModel).toBe('');
|
||
expect(r.sanitized.aiSystemPrompt).toBe('');
|
||
});
|
||
|
||
it('aiApiKey: 任意非空串 → 接受且原样保留', async () => {
|
||
const r = await validateAndSanitize({ aiApiKey: 'sk-abc-123' });
|
||
expect(r.ok).toBe(true);
|
||
expect(r.sanitized.aiApiKey).toBe('sk-abc-123');
|
||
});
|
||
});
|
||
|
||
// ------------------------------------------------------------------
|
||
// nullable-string 类型支持
|
||
//
|
||
// audit fix：validateKey / sanitizeSync 的 switch 之前没有 nullable-string
|
||
// case，遇到该类型的字符串值会落到 default → 「类型未定义」错误。
|
||
// 当前 schema 没有 nullable-string 字段（aiApiKey 等用 string + 主进程判空），
|
||
// 这里用代码存在性测试锁定修复，避免未来回归。
|
||
// ------------------------------------------------------------------
|
||
describe('nullable-string 类型支持（audit fix）', () => {
|
||
const source = readFileSync(SCHEMA_PATH, 'utf8');
|
||
|
||
it('validateKey 的 switch 含 nullable-string case', () => {
|
||
// 提取 validateKey 函数体的 switch 段，断言其中含 case 'nullable-string'
|
||
const match = source.match(/async function validateKey[\s\S]*?^}/m);
|
||
expect(match, 'validateKey 函数必须存在').toBeTruthy();
|
||
expect(match[0]).toMatch(/case\s+['"]nullable-string['"]\s*:/);
|
||
});
|
||
|
||
it('sanitizeSync 的 switch 含 nullable-string case', () => {
|
||
// sanitizeSync 没有 async/function 关键字前缀 —— 直接匹配函数签名
|
||
const match = source.match(/function sanitizeSync[\s\S]*?^}/m);
|
||
expect(match, 'sanitizeSync 函数必须存在').toBeTruthy();
|
||
expect(match[0]).toMatch(/case\s+['"]nullable-string['"]\s*:/);
|
||
});
|
||
|
||
it('nullable-string 校验含 max 长度检查（与 string 一致）', () => {
|
||
const validateMatch = source.match(/async function validateKey[\s\S]*?^}/m);
|
||
expect(validateMatch).toBeTruthy();
|
||
// nullable-string case 内必须包含 rule.max 长度检查
|
||
const nullableCase = validateMatch[0].match(/case\s+['"]nullable-string['"]\s*:[\s\S]*?(?=\n\s+case\s|\n\s+default|\n\s+\})/);
|
||
expect(nullableCase, 'validateKey 必须有 nullable-string case 体').toBeTruthy();
|
||
expect(nullableCase[0]).toMatch(/rule\.max/);
|
||
});
|
||
});
|
||
|
||
// ------------------------------------------------------------------
|
||
// Round 4 P1-1：nullable-path 同步路径空串归一为 null
|
||
//
|
||
// 之前 sanitizeSync 直接返回 ''，与 validateKey 异步路径归一为 null 不同步。
|
||
// coerceLoadedSettings 把磁盘上残留的 "dataDir": "" 保留为 ''，但 validateKey
|
||
// 会归一为 null → 任何依赖 dataDir === null 判断的代码失配。
|
||
// ------------------------------------------------------------------
|
||
describe('nullable-path 同步路径空串归一为 null（Round 4 P1-1）', () => {
|
||
it('coerceLoadedSettings 把 dataDir: "" 归一为 null', () => {
|
||
const result = coerceLoadedSettings({ ...DEFAULT_SETTINGS, dataDir: '' });
|
||
expect(result.dataDir).toBe(null);
|
||
});
|
||
|
||
it('coerceLoadedSettings 把 dataDir: " "（纯空白）归一为 null', () => {
|
||
const result = coerceLoadedSettings({ ...DEFAULT_SETTINGS, dataDir: ' ' });
|
||
expect(result.dataDir).toBe(null);
|
||
});
|
||
|
||
it('coerceLoadedSettings 把 dataDir: "/some/path" 原样保留', () => {
|
||
const result = coerceLoadedSettings({ ...DEFAULT_SETTINGS, dataDir: '/some/path' });
|
||
expect(result.dataDir).toBe('/some/path');
|
||
});
|
||
|
||
it('dataDir: null 仍是 null（不破坏既有契约）', () => {
|
||
const result = coerceLoadedSettings({ ...DEFAULT_SETTINGS, dataDir: null });
|
||
expect(result.dataDir).toBe(null);
|
||
});
|
||
});
|
||
|
||
// ------------------------------------------------------------------
|
||
// Round 4 P2-3：nullable-number typeof 守卫对称
|
||
//
|
||
// 原版无 typeof 守卫，Number(true) === 1 隐式通过 isFinite。
|
||
// 当前 schema 用 nullable-number 的字段（sidebarWidth / aiWidth）min 检查
|
||
// 会拦下 1，但语义与 number 不一致 —— 加 typeof 守卫保持两条路径对称。
|
||
// ------------------------------------------------------------------
|
||
describe('nullable-number typeof 守卫对称（Round 4 P2-3）', () => {
|
||
it('sidebarWidth: true → 拒绝（typeof 不匹配）', () => {
|
||
const r = coerceLoadedSettings({ ...DEFAULT_SETTINGS, sidebarWidth: true });
|
||
// sidebarWidth 不在 coerce 结果里（或保留 default），绝不能是 1
|
||
expect(r.sidebarWidth).not.toBe(1);
|
||
});
|
||
|
||
it('sidebarWidth: false → 拒绝', () => {
|
||
const r = coerceLoadedSettings({ ...DEFAULT_SETTINGS, sidebarWidth: false });
|
||
expect(r.sidebarWidth).not.toBe(0);
|
||
});
|
||
|
||
it('sidebarWidth: 250 → 接受', () => {
|
||
const r = coerceLoadedSettings({ ...DEFAULT_SETTINGS, sidebarWidth: 250 });
|
||
expect(r.sidebarWidth).toBe(250);
|
||
});
|
||
|
||
it('sidebarWidth: "300" → 接受（字符串数字合法）', () => {
|
||
const r = coerceLoadedSettings({ ...DEFAULT_SETTINGS, sidebarWidth: '300' });
|
||
expect(r.sidebarWidth).toBe(300);
|
||
});
|
||
|
||
it('sidebarWidth: null → 仍是 null', () => {
|
||
const r = coerceLoadedSettings({ ...DEFAULT_SETTINGS, sidebarWidth: null });
|
||
expect(r.sidebarWidth).toBe(null);
|
||
});
|
||
}); |