324 lines
16 KiB
JavaScript
324 lines
16 KiB
JavaScript
// main/fs-watcher.js 单测（Case-M1 audit fix + Round 13 fix 回归）
|
||
//
|
||
// 不在仓库里的测试 —— fs-watcher 600+ 行（数据目录监听 + 事件防抖 + 自写过滤 +
|
||
// 错误闩锁 + 退避重连 + generation token）一直没单元测试。这次先补 case-insensitive
|
||
// self-write filter 这一条（核心 bug 修复的回归锚点），其他路径（轮询 / 重连 / 错误
|
||
// 抑制）需要 jsdom + 真实 fs.watch 集成，留给后续 Story。
|
||
//
|
||
// 覆盖：
|
||
// - markExpectedWrite / isSelfWrite：登记大小写 X 的路径，命中查询大小写 Y 也能识别
|
||
// - 与 case-sensitive 的 Linux 行为对照（platform-based 切换）
|
||
// - 过期条目被惰性 GC
|
||
// - updateSnapshot 轮询路径 push 回归（Round 13 fix fce2d83 修复的 bug）：
|
||
// 旧实现 baseline 在 updateSnapshot 先写、emitFilesChanged 又读，看到同一
|
||
// snapshot 时 if 块不进、safeSend 跳过 —— 2s 轮询（fs.watch 不可靠环境的
|
||
// 唯一兜底）检测到的改动永远不通知 renderer。
|
||
|
||
import { describe, it, expect, vi } from 'vitest';
|
||
const { createFsWatcher } = require('../../main/fs-watcher.js');
|
||
|
||
/**
|
||
* 构造一个最小化的 fsWatcher 实例用于单元测试。
|
||
* 不实际订阅 fs.watch、轮询或 IPC —— 我们只关心 self-write filter 的 Map 行为。
|
||
*/
|
||
function makeWatcher() {
|
||
return createFsWatcher({
|
||
// 不用 —— 只用 mark/isSelfWrite
|
||
getMainWindow: () => null,
|
||
resolveDataDir: () => null,
|
||
scanDir: async () => ({ ok: true, entries: [] }),
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 构造带 ipc spy 的 fsWatcher，用于验证 updateSnapshot regular path 是否
|
||
* 真的把列表变化 push 到 renderer。getMainWindow 返回一个虚拟 BrowserWindow，
|
||
* webContents.send 被替换为 vi.fn()，方便断言调用次数 + payload。
|
||
*/
|
||
function makeWatcherWithIpc(scanResults) {
|
||
const sends = [];
|
||
const fakeWin = {
|
||
isDestroyed: () => false,
|
||
webContents: { send: (channel, payload) => sends.push({ channel, payload }) },
|
||
};
|
||
let scanIdx = 0;
|
||
const w = createFsWatcher({
|
||
getMainWindow: () => fakeWin,
|
||
resolveDataDir: () => '/data',
|
||
scanDir: async () => scanResults[scanIdx++] || { ok: true, entries: [] },
|
||
});
|
||
return { watcher: w, sends, fakeWin };
|
||
}
|
||
|
||
describe('fs-watcher markExpectedWrite / isSelfWrite (Case-M1)', () => {
|
||
it('同 case 命中（sanity）', () => {
|
||
const w = makeWatcher();
|
||
w.markExpectedWrite('C:\\Notes\\foo.md', 1000);
|
||
expect(w.isSelfWrite('C:\\Notes\\foo.md')).toBe(true);
|
||
});
|
||
|
||
it('Windows / darwin：跨 case 命中（Case-M1 修复）', () => {
|
||
// audit fix (Case-M1)：fs.watch 在 Windows 上报的 filename 与 caller 写入的
|
||
// case 可能不一致（取决于 ReadDirectoryChangesW / NTFS 短名 8.3 / 同步盘
|
||
// 大小写敏感层）。strict Map.get 会漏命中 → renderer 把自写当成外部修改
|
||
// 误报，用户选「用磁盘版」会覆盖刚保存的内容。
|
||
const w = makeWatcher();
|
||
const mixed = process.platform;
|
||
// 在 Windows / darwin 上模拟「登记 Foo.md，watcher 上报 foo.md」
|
||
w.markExpectedWrite(`C:\\Notes\\Foo.md`, 1000);
|
||
const lookups = (process.platform === 'win32' || process.platform === 'darwin')
|
||
? [`C:\\Notes\\foo.md`, `C:\\Notes\\FOO.md`, `c:\\notes\\Foo.md`, `C:/Notes/Foo.md`]
|
||
: [`C:\\Notes\\Foo.md`];
|
||
for (const alt of lookups) {
|
||
expect(w.isSelfWrite(alt)).toBe(true);
|
||
}
|
||
expect(mixed).toBeTruthy(); // sanity guard
|
||
});
|
||
|
||
it('Linux（case-sensitive 平台）：跨 case 不命中（旧行为保留）', () => {
|
||
// 仅当跑在 Linux 上才相关：默认模拟 darwin 风格的 expect 命中安全，
|
||
// 但 Linux 上 case-different 路径不应被误当作自写。
|
||
if (process.platform === 'linux') {
|
||
const w = makeWatcher();
|
||
w.markExpectedWrite('/tmp/Foo.md', 1000);
|
||
expect(w.isSelfWrite('/tmp/Foo.md')).toBe(true);
|
||
expect(w.isSelfWrite('/tmp/foo.md')).toBe(false);
|
||
} else {
|
||
// 在非 Linux 上跳过，但保持测试存在以便 CI 多平台矩阵触达。
|
||
expect(true).toBe(true);
|
||
}
|
||
});
|
||
|
||
it('未登记的路径：isSelfWrite 返回 false', () => {
|
||
const w = makeWatcher();
|
||
expect(w.isSelfWrite('C:\\Notes\\unknown.md')).toBe(false);
|
||
w.markExpectedWrite('C:\\Notes\\expected.md', 1000);
|
||
expect(w.isSelfWrite('C:\\Notes\\other.md')).toBe(false);
|
||
});
|
||
|
||
it('clearExpectedWrites 后所有命中失效', () => {
|
||
const w = makeWatcher();
|
||
w.markExpectedWrite('C:\\Notes\\foo.md', 1000);
|
||
expect(w.isSelfWrite('C:\\Notes\\foo.md')).toBe(true);
|
||
// markExpectedWrite 的 expiresAt = Date.now() + 500ms —— 不 clear 也得过 500ms
|
||
// 才失效。clear 是立即清理入口（切目录 / stop 监听时调用）。
|
||
w.clearExpectedWrites();
|
||
expect(w.isSelfWrite('C:\\Notes\\foo.md')).toBe(false);
|
||
});
|
||
});
|
||
|
||
describe('fs-watcher updateSnapshot —— push 决策回归 (Round 13 fix fce2d83)', () => {
|
||
// 关键回归锚点：2s 轮询（OneDrive / SMB fs.watch 不可靠环境唯一兜底）检测
|
||
// 到列表变化，必须把新列表推到 renderer 侧栏刷新。历史 bug 把 skipInitialEmit
|
||
// 透传给 emitFilesChanged + baseline 重复写，导致 safeSend 永远跳过。
|
||
//
|
||
// 测试通过 internal _test_updateSnapshot 触发该路径，避免引入 jsdom + 真 fs.watch。
|
||
|
||
it('startup 路径（skipInitialEmit=true）：同步 baseline 但不 push', async () => {
|
||
// audit fix：startWatchingDir 内部 updateSnapshot(dir, true) 拿到的「真实状态」
|
||
// 只用来同步 baseline，不能误当成「新增变化」推给 renderer —— renderer 会通过
|
||
// 'file:list' 自己拉取启动文件列表，避免「刚加载就 emitFilesChanged 又被 renderer
|
||
// 当 fs:changed 事件 → 触发 scanDir 重复请求」的循环。
|
||
const { watcher: w, sends } = makeWatcherWithIpc([
|
||
{ ok: true, entries: [{ name: 'a.md', size: 10, mtimeMs: 1 }] },
|
||
]);
|
||
await w._test_updateSnapshot('/data', /* skipInitialEmit */ true);
|
||
// startup 只写 baseline 不 push
|
||
const filesChanged = sends.filter((s) => s.channel === 'files:changed');
|
||
expect(filesChanged.length).toBe(0);
|
||
});
|
||
|
||
it('常规路径（skipInitialEmit=false）：检测到变化必须 push', async () => {
|
||
// 关键回归：第一次 startup（不 push）后，第二次常规 updateSnapshot 看到列表变化
|
||
// → 必须 safeSend 通知 renderer。Round 13 fix 之前的实现 silent 失败。
|
||
const { watcher: w, sends } = makeWatcherWithIpc([
|
||
// 1st call: startup snapshot, list = [a.md]
|
||
{ ok: true, entries: [{ name: 'a.md', size: 10, mtimeMs: 1 }] },
|
||
// 2nd call: polling tick, list grew to [a.md, b.md]
|
||
{ ok: true, entries: [
|
||
{ name: 'a.md', size: 10, mtimeMs: 1 },
|
||
{ name: 'b.md', size: 20, mtimeMs: 2 },
|
||
] },
|
||
]);
|
||
await w._test_updateSnapshot('/data', true); // startup
|
||
await w._test_updateSnapshot('/data', false); // polling tick detects new file
|
||
const pushes = sends
|
||
.filter((s) => s.channel === 'files:changed')
|
||
.map((s) => s.payload);
|
||
expect(pushes.length).toBeGreaterThanOrEqual(1);
|
||
const last = pushes[pushes.length - 1];
|
||
expect(last.entries.map((e) => e.name).sort()).toEqual(['a.md', 'b.md']);
|
||
// relOf 没有 toRelDir 注入时返回 null（fs-watcher 契约：可选字段，
|
||
// payload 缺 relDir 仍合法；renderer 走 fallback 不依赖此字段）
|
||
expect(last.relDir == null).toBe(true);
|
||
});
|
||
|
||
it('常规路径但列表未变：不 push（baseline 一致）', async () => {
|
||
// 同一列表连扫两次 → baseline 不变 → emitFilesChanged 内部 if 块不进 → 不 push。
|
||
// 避免 fs.watch + polling 双通道把同一次变化报两遍。
|
||
const { watcher: w, sends } = makeWatcherWithIpc([
|
||
{ ok: true, entries: [{ name: 'a.md', size: 10, mtimeMs: 1 }] },
|
||
{ ok: true, entries: [{ name: 'a.md', size: 10, mtimeMs: 1 }] },
|
||
]);
|
||
await w._test_updateSnapshot('/data', true);
|
||
await w._test_updateSnapshot('/data', false);
|
||
const pushes = sends.filter((s) => s.channel === 'files:changed');
|
||
expect(pushes.length).toBe(0);
|
||
});
|
||
|
||
it('扫描失败（result.ok=false）→ 通过错误通道 push，不走 entries 通道', async () => {
|
||
// 与 change 分支独立 —— 错误走 'files:changed' 但 payload 不带 entries，
|
||
// renderer 用 error 字段弹 toast 并保留旧列表（Round 7 FS-F12 行为）。
|
||
const { watcher: w, sends } = makeWatcherWithIpc([
|
||
{ ok: false, error: 'DATA_DIR_NOT_FOUND', code: 'ENOENT' },
|
||
]);
|
||
await w._test_updateSnapshot('/data', false);
|
||
const pushes = sends.filter((s) => s.channel === 'files:changed');
|
||
expect(pushes.length).toBe(1);
|
||
expect(pushes[0].payload.error).toBe('DATA_DIR_NOT_FOUND');
|
||
expect(pushes[0].payload.entries).toBeUndefined();
|
||
});
|
||
});
|
||
|
||
// audit R7a P1-19：fs-watcher 轮询改为「自适应间隔 + 不 drop」pending
|
||
// 单测覆盖三件事：
|
||
// 1. getPollInterval：lastChangeAt 在 ACTIVE_WINDOW 内 → 500ms，否则 5s
|
||
// 2. markActivity 刷新 lastChangeAt → 立刻切到 active
|
||
// 3. pending 语义：in-flight 期间触发的 tick 不丢，in-flight 完成后立即补一次
|
||
describe('fs-watcher 自适应轮询 (audit R7a P1-19)', () => {
|
||
it('getPollInterval：初始（lastChangeAt=0，距 now 远）→ QUIET 5000ms', () => {
|
||
const w = makeWatcher();
|
||
expect(w._test_getPollInterval()).toBe(5000);
|
||
});
|
||
|
||
it('getPollInterval：markActivity 后立即 → ACTIVE 500ms', () => {
|
||
const w = makeWatcher();
|
||
w._test_markActivity();
|
||
expect(w._test_getPollInterval()).toBe(500);
|
||
});
|
||
|
||
it('getPollInterval：markActivity 后等到 ACTIVE_WINDOW 之外 → QUIET', async () => {
|
||
const w = makeWatcher();
|
||
w._test_markActivity();
|
||
expect(w._test_getPollInterval()).toBe(500);
|
||
// 模拟时间推进 POLL_ACTIVE_WINDOW_MS + 1：用 setTimeout 等真实时间。
|
||
// 2100ms 等得起，测试只跑一次。备选用 vi.useFakeTimers + setSystemTime
|
||
// 也行，但 fake timer + markActivity 内部 Date.now() 兼容性有边角问题。
|
||
await new Promise((r) => setTimeout(r, 2100));
|
||
expect(w._test_getPollInterval()).toBe(5000);
|
||
});
|
||
|
||
it('pending 语义：in-flight 期间触发的 tick 不丢，in-flight 完后立即补', async () => {
|
||
// 设计要点：pendingPoll 是**幂等**标志，不是队列。
|
||
// - in-flight 期间任何 tick 都只把 pendingPoll 置 true（不重复累计）
|
||
// - in-flight 完成后 finally 检查 pendingPoll：true → scheduleNextPoll(0)
|
||
// - 紧跟的「补」是 1 次新 scanDir，不是 N 次
|
||
// 所以「3 次 tick + resolve」→ scanCalls 期望 2（1 原 + 1 补），不是 3。
|
||
//
|
||
// 旧版（fixed 2s + pollInFlight drop）的语义是：3 次 tick 期间全部被 drop，
|
||
// scanCalls 期望 1（且永远不会补）。这条测试是回归锚点：
|
||
// 拿掉 pendingPoll 行为 → scanCalls 在 resolve 后仍为 1，测试失败。
|
||
//
|
||
// 时序坑：test 里 `await new Promise(r => setTimeout(r, 0))` 是先于
|
||
// runPollTick finally 调度的；Node 同 delay 的 setTimeout 严格按调度顺序
|
||
// 触发，test 的会先 fire，导致 scanCalls 还在 1 时 expect(2) 失败。
|
||
// 修：用一个 polling 等待「scanCalls 达到 2」，让事件循环多跑几个 tick。
|
||
let resolveScan;
|
||
const scanCalls = [];
|
||
const w = createFsWatcher({
|
||
getMainWindow: () => null,
|
||
resolveDataDir: () => '/data',
|
||
scanDir: async () => {
|
||
scanCalls.push(Date.now());
|
||
// 慢：等我们手动 resolve
|
||
await new Promise((r) => { resolveScan = r; });
|
||
return { ok: true, entries: [] };
|
||
},
|
||
});
|
||
// 跳过 fs.watch 订阅（测试不依赖真实目录事件）
|
||
w._test_setWatchedDir('/data');
|
||
// 第一次 tick：in-flight 启动，scanDir 进入 await
|
||
w._test_runPollTick();
|
||
// 第二次 tick：in-flight 还在，pendingPoll = true，scanDir 不再调用
|
||
w._test_runPollTick();
|
||
// 第三次 tick：同样 pendingPoll = true（幂等）
|
||
w._test_runPollTick();
|
||
// 期望 1 次 in-flight scanDir，pendingPoll 期间 0 次额外调用
|
||
expect(scanCalls.length).toBe(1);
|
||
// 解除 in-flight：第一次 scanDir 完成 → runPollTick finally 触发「补一次」
|
||
resolveScan({ ok: true, entries: [] });
|
||
// 等「补」的 scanDir 真的发起（scanCalls 长度变 2）。最坏情况：
|
||
// in-flight 微任务 + emitFilesChanged 微任务 + setTimeout(0) 调度 +
|
||
// setTimeout(0) 触发 + 新 runPollTick 进入 + 新 scanDir push —— 几十 ms 内。
|
||
await new Promise((resolve) => {
|
||
const start = Date.now();
|
||
const tick = () => {
|
||
if (scanCalls.length >= 2) return resolve();
|
||
if (Date.now() - start > 200) return resolve(); // 兜底
|
||
setTimeout(tick, 5);
|
||
};
|
||
tick();
|
||
});
|
||
expect(scanCalls.length).toBe(2);
|
||
// 把「补」触发的第 2 次 scanDir 也 resolve 掉，不让它的 in-flight
|
||
// 干扰其它测试
|
||
if (resolveScan) resolveScan({ ok: true, entries: [] });
|
||
// 关键：runPollTick 的 finally 走「无 pending → scheduleNextPoll(
|
||
// getPollInterval())」会挂 5s 后的 timer。不显式清掉的话，timer 触发时
|
||
// 又会调一次 scanDir（scanCalls 变 3），且新 scanDir 等到没人 resolve
|
||
// 会一直挂着 —— watcher + scanCalls 闭包泄漏到进程结束，vitest 报告
|
||
// "tests passed" 但实际上 open handle 没释放。pause 清 dirPollTimer +
|
||
// pollPaused，让 watcher 真正失活。
|
||
w._test_pauseDirPolling();
|
||
});
|
||
|
||
// audit R7a P1-19 bugfix：pauseDirPolling 必须真正停止轮询。回归锚点：
|
||
// - in-flight tick 还在 await scanDir 时调 pause
|
||
// - scanDir 完成后 runPollTick finally 走 scheduleNextPoll(...)
|
||
// - 旧版（无 pollPaused 闸）→ 仍挂 5s 后才退到的定时器
|
||
// - 修后（有 pollPaused 闸）→ 不挂任何新 timer，轮询真停
|
||
// 拿掉 pollPaused 检查 → _test_hasPollTimer() 在 resolveScan 后仍返回 true，
|
||
// 本测试失败。仅查 scanCalls 长度不够 —— 5s 间隔下 50ms 等不出新 tick，
|
||
// 必须直接断言 dirPollTimer 是否被挂。
|
||
it('pause 期间 in-flight runPollTick finally 不 re-schedule', async () => {
|
||
let resolveScan;
|
||
const scanCalls = [];
|
||
const w = createFsWatcher({
|
||
getMainWindow: () => null,
|
||
resolveDataDir: () => '/data',
|
||
scanDir: async () => {
|
||
scanCalls.push(Date.now());
|
||
await new Promise((r) => { resolveScan = r; });
|
||
return { ok: true, entries: [] };
|
||
},
|
||
});
|
||
w._test_setWatchedDir('/data');
|
||
// 启动一个 in-flight tick（scanDir 进入 await）→ runPollTick 被 setTimeout
|
||
// 调度时 dirPollTimer 已被清，所以这一步后 hasPollTimer() = false
|
||
w._test_runPollTick();
|
||
expect(scanCalls.length).toBe(1);
|
||
expect(w._test_hasPollTimer()).toBe(false);
|
||
// 暂停：模拟窗口最小化 → pollPaused = true
|
||
w._test_pauseDirPolling();
|
||
// in-flight scanDir 完成 → runPollTick finally 执行：
|
||
// 旧版：scheduleNextPoll(getPollInterval()) 挂 5s 后的 timer
|
||
// 修后：pollPaused 短路，dirPollTimer 保持 null
|
||
resolveScan({ ok: true, entries: [] });
|
||
// 等 microtask + setTimeout(0) 都跑过。50ms 足够覆盖几轮事件循环。
|
||
await new Promise((r) => setTimeout(r, 50));
|
||
// 核心断言：pause 之后不应该有新的 poll timer 被挂上
|
||
expect(w._test_hasPollTimer()).toBe(false);
|
||
});
|
||
|
||
// 配对测试：resume 后必须能再跑轮询。验证 pollPaused 不会让恢复路径失活。
|
||
it('resume 后轮询可重新启动', () => {
|
||
const w = makeWatcher();
|
||
w._test_setWatchedDir('/data');
|
||
w._test_pauseDirPolling();
|
||
// pause 后调 resume —— 不报错、watchedDir 还在即可（startDirPoll 在
|
||
// makeWatcher 里没有真实 scanDir，所以不验证 emit 次数）。
|
||
expect(() => w._test_resumeDirPolling()).not.toThrow();
|
||
});
|
||
});
|
||
|