1033 lines
40 KiB
JavaScript
1033 lines
40 KiB
JavaScript
// main/file-ops.js 单测（audit #6）
|
||
//
|
||
// 覆盖：
|
||
// - isWithinDataDir: Windows 大小写不敏感 / POSIX 区分 / 边界 .. / 越权 ../etc
|
||
// - assertNotSymlink: 真文件通过 / symlink 拒绝 / ENOENT 不挡
|
||
// - resolveFileName: 空名 / 路径分隔符 / .. / 控制字符 / 重名加 (2)(3)
|
||
// - scanFiles: ENOENT 不再自动 mkdir / 返回 DATA_DIR_NOT_FOUND / .md/.markdown 收录
|
||
// - MAX_FILE_SIZE 数值正确
|
||
//
|
||
// 测试不依赖 electron，纯 Node 即可；用 mkdtempSync 建真实临时目录。
|
||
|
||
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
|
||
import {
|
||
mkdtempSync, rmSync, writeFileSync, mkdirSync, symlinkSync,
|
||
} from 'fs';
|
||
import { tmpdir } from 'os';
|
||
import { join, sep } from 'path';
|
||
|
||
const fileOps = require('../../main/file-ops.js');
|
||
const {
|
||
MAX_FILE_SIZE,
|
||
assertNotSymlink,
|
||
assertNoSymlinkAncestor,
|
||
isWithinDataDir,
|
||
resolveFileName,
|
||
resolveRenameName,
|
||
scanFiles,
|
||
scanDir,
|
||
classifyEntry,
|
||
resolveDirRelative,
|
||
toRelativeDir,
|
||
EDITABLE_EXTS,
|
||
} = fileOps;
|
||
|
||
let dir;
|
||
|
||
beforeEach(() => {
|
||
dir = mkdtempSync(join(tmpdir(), 'notes-fileops-'));
|
||
});
|
||
|
||
afterEach(() => {
|
||
if (dir) rmSync(dir, { recursive: true, force: true });
|
||
});
|
||
|
||
describe('MAX_FILE_SIZE', () => {
|
||
it('是 5 MB', () => {
|
||
expect(MAX_FILE_SIZE).toBe(5 * 1024 * 1024);
|
||
});
|
||
});
|
||
|
||
describe('isWithinDataDir', () => {
|
||
it('正常文件返回 true', () => {
|
||
expect(isWithinDataDir(join(dir, 'a.md'), dir)).toBe(true);
|
||
});
|
||
|
||
it('根目录本身算内部', () => {
|
||
expect(isWithinDataDir(dir, dir)).toBe(true);
|
||
});
|
||
|
||
it('越权路径（../etc/passwd）返回 false', () => {
|
||
expect(isWithinDataDir(join(dir, '..', 'etc', 'passwd'), dir)).toBe(false);
|
||
});
|
||
|
||
it('空参数返回 false（防止误判 true）', () => {
|
||
expect(isWithinDataDir('', dir)).toBe(false);
|
||
expect(isWithinDataDir(join(dir, 'a.md'), '')).toBe(false);
|
||
expect(isWithinDataDir(null, dir)).toBe(false);
|
||
expect(isWithinDataDir(undefined, dir)).toBe(false);
|
||
});
|
||
|
||
it('Windows 大小写不敏感', () => {
|
||
if (process.platform !== 'win32') {
|
||
// 在 POSIX 上人为构造一个 Windows 行为测试跳过
|
||
// （isWithinDataDir 始终走 POSIX 分支，不受测试环境影响）
|
||
const mixed = dir.toUpperCase();
|
||
// 用全路径解析过的 root 来做大小写差异
|
||
const resolved = dir;
|
||
// POSIX 上大小写敏感，A.md 与 a.md 是不同文件 → 视为越权
|
||
expect(isWithinDataDir(`${resolved}${sep}Notes${sep}A.md`, `${resolved}${sep}notes`)).toBe(false);
|
||
return;
|
||
}
|
||
expect(isWithinDataDir(join(dir.toUpperCase(), 'A.MD'), dir.toLowerCase())).toBe(true);
|
||
});
|
||
});
|
||
|
||
describe('assertNotSymlink', () => {
|
||
it('普通文件：返回 ok:true, isFile:true', async () => {
|
||
const p = join(dir, 'normal.md');
|
||
writeFileSync(p, 'hello');
|
||
const r = await assertNotSymlink(p);
|
||
expect(r).toEqual({ ok: true, isFile: true });
|
||
});
|
||
|
||
it('不存在：返回 ok:true, isFile:false（留给调用方走 FILE_NOT_FOUND）', async () => {
|
||
const r = await assertNotSymlink(join(dir, 'missing.md'));
|
||
expect(r).toEqual({ ok: true, isFile: false });
|
||
});
|
||
|
||
it('符号链接：返回 SYMLINK_NOT_ALLOWED', async () => {
|
||
const real = join(dir, 'real.md');
|
||
writeFileSync(real, 'real content');
|
||
const link = join(dir, 'link.md');
|
||
try {
|
||
symlinkSync(real, link);
|
||
} catch {
|
||
// Windows 上非管理员可能不允许创建符号链接 → 跳过
|
||
return;
|
||
}
|
||
const r = await assertNotSymlink(link);
|
||
expect(r.ok).toBe(false);
|
||
expect(r.error).toBe('SYMLINK_NOT_ALLOWED');
|
||
});
|
||
});
|
||
|
||
describe('assertNoSymlinkAncestor (Phase O-H1/H2/H3 防御)', () => {
|
||
// dataRoot 下的子目录是 symlink 指向外部目标盘 —— file:scan-dir / file:watch-dir
|
||
// 必须拒绝（之前只 lstat(absDir) 自身，被祖先链是 symlink 的场景绕过）。
|
||
it('祖先链中是 symlink 的目录 → 拒绝（filePath 在 symlink 子目录下）', async () => {
|
||
// 真实外部目标目录（在 dataRoot 之外）
|
||
const externalTarget = mkdtempSync(join(tmpdir(), 'notes-ext-'));
|
||
writeFileSync(join(externalTarget, 'secret.md'), 'secret');
|
||
// dataRoot 内创建指向外部目标的 symlink
|
||
const linkDir = join(dir, 'links');
|
||
try {
|
||
symlinkSync(externalTarget, linkDir);
|
||
} catch {
|
||
// Windows 上非管理员可能不允许创建符号链接 → 跳过
|
||
return;
|
||
}
|
||
// file:scan-dir 会拿 absDir = dataRoot/links/secret.md 调 assertNoSymlinkAncestor
|
||
// （scan-dir 入参是 dir，但 list 时会拼接文件名；这里我们用 filePath 在 symlink
|
||
// 子树下，让 assertNoSymlinkAncestor 从 filePath 父目录开始向上 lstat）
|
||
const r = await assertNoSymlinkAncestor(join(linkDir, 'secret.md'), dir);
|
||
expect(r.ok).toBe(false);
|
||
expect(r.error).toBe('SYMLINK_NOT_ALLOWED');
|
||
// 目标位置 = 中间 symlink 目录
|
||
expect(r.message).toContain('links');
|
||
rmSync(externalTarget, { recursive: true, force: true });
|
||
});
|
||
|
||
it('filePath 自身是 symlink → 拒绝（Phase O-fix：自身也参与检查）', async () => {
|
||
// audit fix (Phase O-fix)：assertNoSymlinkAncestor 现在也检查 filePath 自身。
|
||
// 之前只走父目录向上 lstat，导致 dataRoot/links（自身是 symlink 指向外部目标）
|
||
// 整条链路：parent = dataRoot（合法）→ break → 漏检。
|
||
// Phase O 把 file:scan-dir / file:watch-dir / file:create 的 lstat(targetDir)
|
||
// 替换成 assertNoSymlinkAncestor(targetDir, dataRoot)，必须让「target 自身是
|
||
// symlink」也被挡下，否则原 lstat 的越权检查失效。
|
||
const externalTarget = mkdtempSync(join(tmpdir(), 'notes-ext-'));
|
||
const linkDir = join(dir, 'links');
|
||
try {
|
||
symlinkSync(externalTarget, linkDir);
|
||
} catch {
|
||
return;
|
||
}
|
||
const r = await assertNoSymlinkAncestor(linkDir, dir);
|
||
expect(r.ok).toBe(false);
|
||
expect(r.error).toBe('SYMLINK_NOT_ALLOWED');
|
||
rmSync(externalTarget, { recursive: true, force: true });
|
||
});
|
||
|
||
it('全是普通目录 → 通过', async () => {
|
||
const sub = join(dir, 'a', 'b', 'c');
|
||
mkdirSync(sub, { recursive: true });
|
||
const r = await assertNoSymlinkAncestor(join(sub, 'foo.md'), dir);
|
||
expect(r.ok).toBe(true);
|
||
});
|
||
|
||
it('父目录不存在（target 尚未创建）→ 允许', async () => {
|
||
const r = await assertNoSymlinkAncestor(join(dir, 'nonexistent', 'foo.md'), dir);
|
||
expect(r.ok).toBe(true);
|
||
});
|
||
|
||
it('空路径 → 拒绝', async () => {
|
||
const r = await assertNoSymlinkAncestor('', dir);
|
||
expect(r.ok).toBe(false);
|
||
expect(r.error).toBe('INVALID_PATH');
|
||
});
|
||
});
|
||
|
||
describe('resolveFileName', () => {
|
||
// 2026-08-28 用户反馈：resolveFileName 不再强制补 .md，与 resolveRenameName 对齐。
|
||
// 用户输入什么就用什么：
|
||
// - "hello" → "hello"（无扩展名）
|
||
// - "hello.md" → "hello.md"
|
||
// - "hello.txt" → "hello.txt"（用户可建纯文本笔记）
|
||
// - "note.markdown"→ "note.markdown"
|
||
// - "NOTE.MD" → "NOTE.MD"（大小写保留）
|
||
// 这样用户新建 .txt 纯文本笔记 / .json 数据笔记不再需要「先建 .md → 重命名」两步。
|
||
it('无扩展名 → 原样保留（不再自动补 .md）', async () => {
|
||
const r = await resolveFileName('hello', dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.name).toBe('hello');
|
||
expect(r.path).toBe(join(dir, 'hello'));
|
||
expect(isWithinDataDir(r.path, dir)).toBe(true);
|
||
});
|
||
|
||
it('.md 后缀原样保留', async () => {
|
||
const r = await resolveFileName('hello.md', dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.name).toBe('hello.md');
|
||
expect(r.path).toBe(join(dir, 'hello.md'));
|
||
});
|
||
|
||
it('.txt 等其他扩展名原样保留（用户可建纯文本笔记）', async () => {
|
||
const r = await resolveFileName('hello.txt', dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.name).toBe('hello.txt');
|
||
expect(r.path).toBe(join(dir, 'hello.txt'));
|
||
});
|
||
|
||
it('.markdown 扩展名原样保留', async () => {
|
||
const r = await resolveFileName('note.markdown', dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.name).toBe('note.markdown');
|
||
});
|
||
|
||
it('大小写保留（不强制小写化）', async () => {
|
||
const r = await resolveFileName('NOTE.MD', dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.name).toBe('NOTE.MD');
|
||
});
|
||
|
||
it('空字符串 / 非字符串 → 拒绝', async () => {
|
||
expect((await resolveFileName('', dir)).ok).toBe(false);
|
||
expect((await resolveFileName(' ', dir)).ok).toBe(false);
|
||
expect((await resolveFileName(null, dir)).ok).toBe(false);
|
||
expect((await resolveFileName(123, dir)).ok).toBe(false);
|
||
});
|
||
|
||
it('包含路径分隔符 → 拒绝', async () => {
|
||
expect((await resolveFileName('a/b.md', dir)).ok).toBe(false);
|
||
expect((await resolveFileName('a\\b.md', dir)).ok).toBe(false);
|
||
});
|
||
|
||
it('包含 .. → 拒绝（含 substring .. 也算，防止视觉混淆）', async () => {
|
||
expect((await resolveFileName('..evil.md', dir)).ok).toBe(false);
|
||
// `a..b.md` 也含 `..` 子串——生产代码故意一并拒绝（更严格，无歧义）
|
||
expect((await resolveFileName('a..b.md', dir)).ok).toBe(false);
|
||
});
|
||
|
||
it('包含 Windows 保留字符 → 拒绝', async () => {
|
||
expect((await resolveFileName('bad|name', dir)).ok).toBe(false);
|
||
expect((await resolveFileName('bad:name', dir)).ok).toBe(false);
|
||
});
|
||
|
||
it('Windows 保留设备名（基础名取最后一个 . 之前）→ 拒绝', async () => {
|
||
// "CON" / "CON.md" / "CON.txt" 都按 NTFS 规则视为设备名
|
||
expect((await resolveFileName('CON', dir)).ok).toBe(false);
|
||
expect((await resolveFileName('CON.md', dir)).ok).toBe(false);
|
||
expect((await resolveFileName('CON.txt', dir)).ok).toBe(false);
|
||
// "foo.CON" 不算 —— 基础名是 foo
|
||
const ok = await resolveFileName('foo.CON', dir);
|
||
expect(ok.ok).toBe(true);
|
||
});
|
||
|
||
it('基础名取最后一个 . 之前（foo.CON.bar 不算保留设备名）', async () => {
|
||
// 基础名取最后一个 . 之前的部分。"foo.CON.bar" 的基础名是 "foo.CON"，
|
||
// 不是保留设备名，应该通过校验。
|
||
const r = await resolveFileName('foo.CON.bar', dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.name).toBe('foo.CON.bar');
|
||
});
|
||
|
||
it('包含控制字符 → 拒绝', async () => {
|
||
expect((await resolveFileName('bad .md', dir)).ok).toBe(false);
|
||
expect((await resolveFileName('bad.md', dir)).ok).toBe(false);
|
||
});
|
||
|
||
it('重名加 (2) —— 扩展名原样保留', async () => {
|
||
writeFileSync(join(dir, 'note.md'), 'a');
|
||
const r = await resolveFileName('note.md', dir);
|
||
expect(r.name).toBe('note (2).md');
|
||
});
|
||
|
||
it('重名加 (2) —— 无扩展名也照样加', async () => {
|
||
writeFileSync(join(dir, 'note'), 'a');
|
||
const r = await resolveFileName('note', dir);
|
||
expect(r.name).toBe('note (2)');
|
||
});
|
||
|
||
it('重名加 (2) —— .txt 等其他扩展名原样保留', async () => {
|
||
writeFileSync(join(dir, 'note.txt'), 'a');
|
||
const r = await resolveFileName('note.txt', dir);
|
||
expect(r.name).toBe('note (2).txt');
|
||
});
|
||
|
||
it('重名加 (2) —— .markdown 也原样保留', async () => {
|
||
writeFileSync(join(dir, 'note.markdown'), 'a');
|
||
const r = await resolveFileName('note.markdown', dir);
|
||
expect(r.name).toBe('note (2).markdown');
|
||
});
|
||
|
||
it('重名计数 < 1000 强制终止', async () => {
|
||
// 不真的造 1000 个文件 —— 改成造一个，然后立即探测高计数，逻辑上足够了
|
||
writeFileSync(join(dir, 'a.md'), 'x');
|
||
// 模拟 (2) 已存在
|
||
writeFileSync(join(dir, 'a (2).md'), 'x');
|
||
const r = await resolveFileName('a.md', dir);
|
||
expect(r.name).toBe('a (3).md');
|
||
});
|
||
});
|
||
|
||
describe('resolveRenameName（用户反馈：重命名不要自动补后缀）', () => {
|
||
// 历史：resolveRenameName 是不强制 .md 后缀的版本。
|
||
// 2026-08-28 反馈后，resolveFileName 也对齐了 —— 两个函数都不再强制补 .md，
|
||
// 用户输入什么就用什么（包括无扩展名 / .txt / .json / .markdown 等）。
|
||
// 本组测试覆盖：保留用户输入的扩展名；.md 也照样保留；大小写保留；
|
||
// 各种校验（路径分隔符 / .. / Windows 保留字符 / 控制字符 / 保留设备名）；
|
||
// 重名避让时扩展名原样保留。
|
||
|
||
it('保留用户输入的扩展名（不改写）', async () => {
|
||
const r = await resolveRenameName('bar.txt', dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.name).toBe('bar.txt');
|
||
});
|
||
|
||
it('允许不带扩展名（不自动补 .md）', async () => {
|
||
const r = await resolveRenameName('bar', dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.name).toBe('bar');
|
||
});
|
||
|
||
it('.md 也照样保留', async () => {
|
||
const r = await resolveRenameName('bar.md', dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.name).toBe('bar.md');
|
||
});
|
||
|
||
it('保留 .markdown 扩展名', async () => {
|
||
const r = await resolveRenameName('note.markdown', dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.name).toBe('note.markdown');
|
||
});
|
||
|
||
it('大小写保留（不强制小写化）', async () => {
|
||
const r = await resolveRenameName('NOTE.MD', dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.name).toBe('NOTE.MD');
|
||
});
|
||
|
||
it('空字符串 / 非字符串 → 拒绝', async () => {
|
||
expect((await resolveRenameName('', dir)).ok).toBe(false);
|
||
expect((await resolveRenameName(' ', dir)).ok).toBe(false);
|
||
expect((await resolveRenameName(null, dir)).ok).toBe(false);
|
||
});
|
||
|
||
it('包含路径分隔符 → 拒绝', async () => {
|
||
expect((await resolveRenameName('a/b', dir)).ok).toBe(false);
|
||
expect((await resolveRenameName('a\\b', dir)).ok).toBe(false);
|
||
});
|
||
|
||
it('包含 .. → 拒绝', async () => {
|
||
expect((await resolveRenameName('..evil', dir)).ok).toBe(false);
|
||
expect((await resolveRenameName('a..b.md', dir)).ok).toBe(false);
|
||
});
|
||
|
||
it('包含 Windows 保留字符 → 拒绝', async () => {
|
||
expect((await resolveRenameName('bad|name', dir)).ok).toBe(false);
|
||
expect((await resolveRenameName('bad:name', dir)).ok).toBe(false);
|
||
});
|
||
|
||
it('包含控制字符 → 拒绝', async () => {
|
||
expect((await resolveRenameName('bad\x00name', dir)).ok).toBe(false);
|
||
expect((await resolveRenameName('bad\x01name', dir)).ok).toBe(false);
|
||
});
|
||
|
||
it('Windows 保留设备名（基础名取最后一个 . 之前）→ 拒绝', async () => {
|
||
// "CON" / "CON.md" / "CON.txt" 都按 NTFS 规则视为设备名
|
||
expect((await resolveRenameName('CON', dir)).ok).toBe(false);
|
||
expect((await resolveRenameName('CON.md', dir)).ok).toBe(false);
|
||
expect((await resolveRenameName('CON.txt', dir)).ok).toBe(false);
|
||
// "foo.CON" 不算 —— 基础名是 foo
|
||
const ok = await resolveRenameName('foo.CON', dir);
|
||
expect(ok.ok).toBe(true);
|
||
});
|
||
|
||
it('重名加 (2) —— 扩展名原样保留', async () => {
|
||
writeFileSync(join(dir, 'note.md'), 'a');
|
||
const r = await resolveRenameName('note.md', dir);
|
||
expect(r.name).toBe('note (2).md');
|
||
});
|
||
|
||
it('重名加 (2) —— 无扩展名也照样加', async () => {
|
||
writeFileSync(join(dir, 'note'), 'a');
|
||
const r = await resolveRenameName('note', dir);
|
||
expect(r.name).toBe('note (2)');
|
||
});
|
||
|
||
it('重名加 (2) —— .txt 等其他扩展名原样保留', async () => {
|
||
writeFileSync(join(dir, 'note.txt'), 'a');
|
||
const r = await resolveRenameName('note.txt', dir);
|
||
expect(r.name).toBe('note (2).txt');
|
||
});
|
||
|
||
it('基础名取最后一个 . 之前（foo.CON.bar 不算保留设备名）', async () => {
|
||
// 基础名取最后一个 . 之前的部分。"foo.CON.bar" 的基础名是 "foo.CON"，
|
||
// 不是保留设备名，应该通过校验。
|
||
const r = await resolveRenameName('foo.CON.bar', dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.name).toBe('foo.CON.bar');
|
||
});
|
||
|
||
it('trim 输入首尾空格', async () => {
|
||
const r = await resolveRenameName(' bar.md ', dir);
|
||
expect(r.name).toBe('bar.md');
|
||
});
|
||
});
|
||
|
||
describe('scanFiles', () => {
|
||
it('正常目录返回 {ok:true, files:[]}', async () => {
|
||
mkdirSync(dir, { recursive: true });
|
||
const r = await scanFiles(dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.files).toEqual([]);
|
||
});
|
||
|
||
it('收录 .md 和 .markdown，排除其他后缀', async () => {
|
||
writeFileSync(join(dir, 'a.md'), 'a');
|
||
writeFileSync(join(dir, 'b.markdown'), 'b');
|
||
writeFileSync(join(dir, 'c.txt'), 'c');
|
||
writeFileSync(join(dir, '.hidden.md'), 'd'); // hidden 也算
|
||
mkdirSync(join(dir, 'subdir'));
|
||
const r = await scanFiles(dir);
|
||
expect(r.ok).toBe(true);
|
||
const names = r.files.map(f => f.name).sort();
|
||
expect(names).toEqual(['.hidden.md', 'a.md', 'b.markdown']);
|
||
});
|
||
|
||
it('目录不存在 → 返回 DATA_DIR_NOT_FOUND，不再自动 mkdir（audit #3）', async () => {
|
||
const missing = join(dir, 'not-created');
|
||
const r = await scanFiles(missing);
|
||
expect(r.ok).toBe(false);
|
||
expect(r.error).toBe('DATA_DIR_NOT_FOUND');
|
||
expect(r.code).toBe('ENOENT');
|
||
// 关键：目录不应被自动重建
|
||
// （用 setTimeout 等一下，确保 fs 没在后台补活）
|
||
await new Promise(res => setTimeout(res, 50));
|
||
// existsSync 不在这里用 —— 改为 readdir，看是否依然 ENOENT
|
||
const fs = await import('fs').then(m => m.promises);
|
||
await expect(fs.readdir(missing)).rejects.toThrow();
|
||
});
|
||
|
||
it('空参数 → 返回 EINVAL', async () => {
|
||
const r = await scanFiles('');
|
||
expect(r.ok).toBe(false);
|
||
expect(r.code).toBe('EINVAL');
|
||
});
|
||
|
||
it('结果包含 size / mtimeMs', async () => {
|
||
writeFileSync(join(dir, 'a.md'), 'hello');
|
||
const r = await scanFiles(dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.files).toHaveLength(1);
|
||
expect(r.files[0].size).toBe(5);
|
||
expect(typeof r.files[0].mtimeMs).toBe('number');
|
||
expect(r.files[0].path).toBe(join(dir, 'a.md'));
|
||
});
|
||
});
|
||
|
||
// =====================================================================
|
||
// Stage 8：Folder Browser（scanDir / classifyEntry / resolveDirRelative）
|
||
// =====================================================================
|
||
|
||
describe('classifyEntry', () => {
|
||
// 表格驱动：每个白名单扩展 → editable；其他 → binary
|
||
// 与 main/file-ops.js 的 EDITABLE_EXTS 同步
|
||
// （2026-08-25 反馈扩到 ~35 种常见编程语言）
|
||
const editableSamples = [
|
||
// Markdown / 纯文本 / 数据 / 配置
|
||
'note.md', 'note.markdown',
|
||
'foo.txt', 'foo.text', 'foo.log',
|
||
'data.csv', 'data.tsv', 'data.json', 'data.xml',
|
||
'config.yaml', 'config.yml', 'config.toml',
|
||
'app.ini', 'app.cfg', 'app.conf', 'app.env',
|
||
// 隐藏文件名 + 白名单扩展（如 .env / .gitconfig）→ editable
|
||
// （旧逻辑因为 dot === 0 误判为 binary，导致列表与 md 链接割裂）
|
||
'.env', '.gitconfig',
|
||
'doc.rst', 'doc.tex',
|
||
// Python
|
||
'app.py', 'types.pyi', 'script.pyw',
|
||
// JS / TS
|
||
'main.js', 'mod.mjs', 'legacy.cjs', 'view.jsx',
|
||
'app.ts', 'view.tsx',
|
||
// Web
|
||
'index.html', 'page.htm', 'styles.css', 'theme.scss', 'vars.sass', 'mixins.less',
|
||
'App.vue', 'Card.svelte',
|
||
// JVM
|
||
'Main.java', 'App.kt', 'build.kts',
|
||
// 其它语言
|
||
'main.go', 'lib.rs', 'app.rb', 'index.php',
|
||
'deploy.sh', 'setup.bash', 'rc.zsh',
|
||
'install.ps1',
|
||
'query.sql',
|
||
'main.c', 'main.h', 'main.cpp', 'main.hpp',
|
||
'App.cs',
|
||
'App.swift',
|
||
'App.scala',
|
||
'main.lua', 'parse.pl', 'stats.r', 'app.dart',
|
||
];
|
||
const binarySamples = [
|
||
'photo.png', 'photo.jpg', 'photo.gif', 'photo.webp',
|
||
'archive.zip', 'archive.tar', 'archive.gz',
|
||
'doc.pdf', 'doc.docx', 'doc.xlsx',
|
||
'app.exe', 'lib.dll',
|
||
'noext', '.hidden', '.gitignore', // 无扩展名 / 点开头的隐藏文件（隐藏且不在白名单）
|
||
// 已知二进制但没显式列：wasm / o / a / so / dylib / class / jar
|
||
'mod.wasm', 'main.o', 'lib.a', 'lib.so', 'lib.dylib',
|
||
'Main.class', 'lib.jar',
|
||
];
|
||
|
||
it.each(editableSamples)('%s 分类为 editable', (name) => {
|
||
expect(classifyEntry(name)).toBe('editable');
|
||
});
|
||
|
||
it.each(binarySamples)('%s 分类为 binary', (name) => {
|
||
expect(classifyEntry(name)).toBe('binary');
|
||
});
|
||
|
||
it('大小写不敏感（README.MD → editable）', () => {
|
||
expect(classifyEntry('README.MD')).toBe('editable');
|
||
expect(classifyEntry('Config.YAML')).toBe('editable');
|
||
expect(classifyEntry('Photo.PNG')).toBe('binary');
|
||
});
|
||
|
||
it('空 / 非字符串 → binary（保守判定）', () => {
|
||
expect(classifyEntry('')).toBe('binary');
|
||
expect(classifyEntry(null)).toBe('binary');
|
||
expect(classifyEntry(undefined)).toBe('binary');
|
||
expect(classifyEntry(123)).toBe('binary');
|
||
});
|
||
|
||
it('EDITABLE_EXTS 是 Set 且包含所有声明的代码扩展', () => {
|
||
expect(EDITABLE_EXTS).toBeInstanceOf(Set);
|
||
// 关键代码扩展全覆盖（避免以后改白名单时漏更新测试）
|
||
const codeExts = [
|
||
'md', 'markdown',
|
||
'py', 'js', 'jsx', 'ts', 'tsx',
|
||
'html', 'css',
|
||
'go', 'rs', 'java', 'kt',
|
||
'rb', 'php', 'sh',
|
||
];
|
||
for (const ext of codeExts) {
|
||
expect(EDITABLE_EXTS.has(ext)).toBe(true);
|
||
}
|
||
});
|
||
|
||
it('EDITABLE_EXTS 不含常见二进制扩展', () => {
|
||
// 防止「把 png 加进白名单」之类的回归
|
||
expect(EDITABLE_EXTS.has('png')).toBe(false);
|
||
expect(EDITABLE_EXTS.has('pdf')).toBe(false);
|
||
expect(EDITABLE_EXTS.has('zip')).toBe(false);
|
||
expect(EDITABLE_EXTS.has('exe')).toBe(false);
|
||
});
|
||
});
|
||
|
||
describe('scanDir', () => {
|
||
it('空目录 → {ok:true, entries:[]}', async () => {
|
||
mkdirSync(dir, { recursive: true });
|
||
const r = await scanDir(dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.entries).toEqual([]);
|
||
expect(r.dir).toBe(dir);
|
||
});
|
||
|
||
it('混合条目：每种 entryType 至少一个样本', async () => {
|
||
writeFileSync(join(dir, 'note.md'), 'md');
|
||
writeFileSync(join(dir, 'data.json'), '{}');
|
||
writeFileSync(join(dir, 'photo.png'), Buffer.from([0, 1, 2]));
|
||
mkdirSync(join(dir, 'subdir'));
|
||
const r = await scanDir(dir);
|
||
expect(r.ok).toBe(true);
|
||
const byType = {};
|
||
for (const e of r.entries) {
|
||
byType[e.entryType] = (byType[e.entryType] || 0) + 1;
|
||
}
|
||
expect(byType.folder).toBe(1);
|
||
expect(byType.editable).toBe(2); // note.md + data.json
|
||
expect(byType.binary).toBe(1); // photo.png
|
||
});
|
||
|
||
it('文件夹排在文件前面（按 zh-CN locale 名称排序）', async () => {
|
||
writeFileSync(join(dir, '笔记.md'), 'a');
|
||
writeFileSync(join(dir, '苹果.png'), 'x');
|
||
mkdirSync(join(dir, '目录'));
|
||
const r = await scanDir(dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.entries.map((e) => e.name)).toEqual(['目录', '笔记.md', '苹果.png']);
|
||
});
|
||
|
||
it('不递归（只列一层）', async () => {
|
||
mkdirSync(join(dir, 'parent'));
|
||
mkdirSync(join(dir, 'parent', 'child'));
|
||
writeFileSync(join(dir, 'parent', 'child', 'deep.md'), 'd');
|
||
const r = await scanDir(dir);
|
||
expect(r.ok).toBe(true);
|
||
const names = r.entries.map((e) => e.name);
|
||
expect(names).toContain('parent');
|
||
expect(names).not.toContain('child');
|
||
expect(names).not.toContain('deep.md');
|
||
});
|
||
|
||
it('目录不存在 → 返回 DATA_DIR_NOT_FOUND', async () => {
|
||
const missing = join(dir, 'no-such-dir');
|
||
const r = await scanDir(missing);
|
||
expect(r.ok).toBe(false);
|
||
expect(r.error).toBe('DATA_DIR_NOT_FOUND');
|
||
expect(r.code).toBe('ENOENT');
|
||
});
|
||
|
||
it('空参数 → EINVAL', async () => {
|
||
const r = await scanDir('');
|
||
expect(r.ok).toBe(false);
|
||
expect(r.code).toBe('EINVAL');
|
||
});
|
||
|
||
// audit fix (Round 12 P2)：非 ENOENT 错误的 e.message（英文 errno + 路径）
|
||
// 不再直接吐出。fs-watcher 把 result.error 推 renderer，renderer 当 toast 文案
|
||
// 显示，用户看到原始英文 + 绝对路径。改走 friendly-fs-error 与 Round 8 统一。
|
||
it('audit fix (Round 12 P2)：权限错误 → 友好中文（不走原始 e.message）', async () => {
|
||
// Windows 上 chmod 000 不会真正阻塞管理员读，路径可能仍可读；
|
||
// 这里只验证代码路径：spy fs.readdir 抛 EACCES，看返回 error 是否走友好化。
|
||
const fsPromises = await import('fs').then((m) => m.promises);
|
||
const realReaddir = fsPromises.readdir;
|
||
fsPromises.readdir = async function boom() {
|
||
const err = new Error("EACCES: permission denied, scandir '/secret/path'");
|
||
err.code = 'EACCES';
|
||
throw err;
|
||
};
|
||
try {
|
||
const r = await scanDir(dir);
|
||
expect(r.ok).toBe(false);
|
||
// 不能是原始 e.message（英文 errno + 路径）
|
||
expect(r.error).not.toMatch(/^EACCES:/);
|
||
expect(r.error).not.toMatch(/scandir/);
|
||
// 必须是友好中文（friendly-fs-error 对 EACCES 给的固定文案）
|
||
expect(typeof r.error).toBe('string');
|
||
expect(r.error.length).toBeGreaterThan(0);
|
||
expect(r.code).toBe('EACCES');
|
||
} finally {
|
||
fsPromises.readdir = realReaddir;
|
||
}
|
||
});
|
||
|
||
it('符号链接文件被跳过（防御越权）', async () => {
|
||
const real = join(dir, 'real.md');
|
||
writeFileSync(real, 'real');
|
||
const link = join(dir, 'link.md');
|
||
try {
|
||
symlinkSync(real, link);
|
||
} catch {
|
||
// Windows 非管理员可能无 symlink 权限 → 跳过这个用例
|
||
return;
|
||
}
|
||
const r = await scanDir(dir);
|
||
expect(r.ok).toBe(true);
|
||
// 真实文件在但符号链接不在
|
||
const names = r.entries.map((e) => e.name);
|
||
expect(names).toContain('real.md');
|
||
expect(names).not.toContain('link.md');
|
||
});
|
||
|
||
it('符号链接文件夹被跳过（防御越权）', async () => {
|
||
const realDir = join(dir, 'real-folder');
|
||
mkdirSync(realDir);
|
||
writeFileSync(join(realDir, 'inside.md'), 'x');
|
||
const link = join(dir, 'linked-folder');
|
||
try {
|
||
symlinkSync(realDir, link, 'dir');
|
||
} catch {
|
||
return; // 同上，权限不足跳过
|
||
}
|
||
const r = await scanDir(dir);
|
||
expect(r.ok).toBe(true);
|
||
const names = r.entries.map((e) => e.name);
|
||
expect(names).toContain('real-folder');
|
||
expect(names).not.toContain('linked-folder');
|
||
});
|
||
|
||
it('结果字段：folder / editable / binary 都带正确 shape', async () => {
|
||
mkdirSync(join(dir, 'sub'));
|
||
writeFileSync(join(dir, 'a.md'), 'a');
|
||
writeFileSync(join(dir, 'b.png'), 'b');
|
||
const r = await scanDir(dir);
|
||
expect(r.ok).toBe(true);
|
||
const folder = r.entries.find((e) => e.entryType === 'folder');
|
||
const editable = r.entries.find((e) => e.entryType === 'editable');
|
||
const binary = r.entries.find((e) => e.entryType === 'binary');
|
||
expect(folder).toMatchObject({
|
||
name: 'sub',
|
||
path: join(dir, 'sub'),
|
||
entryType: 'folder',
|
||
isFolder: true,
|
||
});
|
||
expect(editable).toMatchObject({
|
||
name: 'a.md',
|
||
path: join(dir, 'a.md'),
|
||
entryType: 'editable',
|
||
isFolder: false,
|
||
});
|
||
expect(typeof editable.size).toBe('number');
|
||
expect(typeof editable.mtimeMs).toBe('number');
|
||
expect(binary).toMatchObject({
|
||
name: 'b.png',
|
||
entryType: 'binary',
|
||
isFolder: false,
|
||
});
|
||
});
|
||
});
|
||
|
||
describe('resolveDirRelative', () => {
|
||
it('空字符串 → 根目录（relDir=""）', () => {
|
||
const r = resolveDirRelative('', dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.absDir).toBe(dir);
|
||
expect(r.relDir).toBe('');
|
||
});
|
||
|
||
it('合法相对路径 → 正常解析', () => {
|
||
const r = resolveDirRelative('notes/2026', dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.relDir).toBe('notes/2026');
|
||
// Windows 上 path.join 用 '\\'，POSIX 用 '/'
|
||
expect(r.absDir).toBe(join(dir, 'notes', '2026'));
|
||
});
|
||
|
||
it('Windows 反斜杠统一转正斜杠', () => {
|
||
const r = resolveDirRelative('notes\\2026', dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.relDir).toBe('notes/2026');
|
||
});
|
||
|
||
it('包含 .. 段 → 拒绝', () => {
|
||
expect(resolveDirRelative('..', dir).ok).toBe(false);
|
||
expect(resolveDirRelative('a/../b', dir).ok).toBe(false);
|
||
expect(resolveDirRelative('./a', dir).ok).toBe(false);
|
||
});
|
||
|
||
it('绝对路径 / 盘符 → 拒绝', () => {
|
||
expect(resolveDirRelative('C:\\evil', dir).ok).toBe(false);
|
||
expect(resolveDirRelative('/etc/passwd', dir).ok).toBe(false);
|
||
});
|
||
|
||
it('非字符串 → INVALID_REL_DIR', () => {
|
||
expect(resolveDirRelative(null, dir).ok).toBe(false);
|
||
expect(resolveDirRelative(123, dir).ok).toBe(false);
|
||
});
|
||
|
||
it('尾部正斜杠自动剥除', () => {
|
||
const r = resolveDirRelative('notes/2026/', dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(r.relDir).toBe('notes/2026');
|
||
});
|
||
|
||
it('解析后绝对路径仍必须在 dataRoot 内（防御 path.join 出 ..\\）', () => {
|
||
// 用合法嵌套路径验证 isWithinDataDir 兜底。
|
||
// （'.' / '..' 段在前面已经被显式拒绝，到不了 isWithinDataDir 这一步；
|
||
// 这里只确认合法路径都过得了这层兜底检查，不会误拒。）
|
||
const r = resolveDirRelative('a/b/c', dir);
|
||
expect(r.ok).toBe(true);
|
||
expect(isWithinDataDir(r.absDir, dir)).toBe(true);
|
||
});
|
||
});
|
||
|
||
describe('toRelativeDir', () => {
|
||
it('根目录 → ""', () => {
|
||
expect(toRelativeDir(dir, dir)).toBe('');
|
||
});
|
||
|
||
it('子目录 → POSIX 相对路径', () => {
|
||
const sub = join(dir, 'notes', '2026');
|
||
expect(toRelativeDir(sub, dir)).toBe('notes/2026');
|
||
});
|
||
|
||
it('Windows 反斜杠统一转正斜杠', () => {
|
||
const sub = join(dir, 'notes', 'sub');
|
||
expect(toRelativeDir(sub, dir)).toBe('notes/sub');
|
||
});
|
||
|
||
it('不在 dataRoot 下 → ""（降级到根）', () => {
|
||
expect(toRelativeDir('/etc/passwd', dir)).toBe('');
|
||
expect(toRelativeDir('', dir)).toBe('');
|
||
expect(toRelativeDir(null, dir)).toBe('');
|
||
});
|
||
|
||
it('空 dataRoot → ""', () => {
|
||
expect(toRelativeDir(dir, '')).toBe('');
|
||
});
|
||
|
||
it('toRelativeDir ↔ resolveDirRelative 互逆（同一子目录）', () => {
|
||
const sub = join(dir, 'a', 'b', 'c');
|
||
const rel = toRelativeDir(sub, dir);
|
||
expect(rel).toBe('a/b/c');
|
||
const back = resolveDirRelative(rel, dir);
|
||
expect(back.ok).toBe(true);
|
||
// Windows 上 normalize 后大小写可能不同，不做严格相等；只检查相对路径 round-trip 一致
|
||
expect(toRelativeDir(back.absDir, dir)).toBe(rel);
|
||
});
|
||
});
|
||
|
||
describe('atomicWriteFile（C1/C2/C3 file-IO audit fix）', () => {
|
||
let dir;
|
||
|
||
beforeEach(() => {
|
||
dir = mkdtempSync(join(tmpdir(), 'atomic-write-'));
|
||
});
|
||
afterEach(() => {
|
||
try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
|
||
});
|
||
|
||
it('正常路径：写入新文件后内容完整可读', async () => {
|
||
const dst = join(dir, 'note.md');
|
||
await fileOps.atomicWriteFile(dst, '# hello\n\ncontent');
|
||
const { readFileSync } = await import('fs');
|
||
expect(readFileSync(dst, 'utf-8')).toBe('# hello\n\ncontent');
|
||
});
|
||
|
||
it('覆盖已存在文件：内容被替换且不残留 tmp', async () => {
|
||
const dst = join(dir, 'note.md');
|
||
writeFileSync(dst, 'OLD content');
|
||
await fileOps.atomicWriteFile(dst, 'NEW content');
|
||
const { readFileSync, readdirSync } = await import('fs');
|
||
expect(readFileSync(dst, 'utf-8')).toBe('NEW content');
|
||
// 目录里不应有遗留的 .tmp.<pid>.<ts> 文件
|
||
const leftover = readdirSync(dir).filter((n) => n.includes('.tmp.'));
|
||
expect(leftover).toEqual([]);
|
||
});
|
||
|
||
it('写入失败时不残留 tmp 文件', async () => {
|
||
// 把目录当文件写必失败
|
||
const dst = join(dir);
|
||
await expect(fileOps.atomicWriteFile(dst, 'x')).rejects.toBeTruthy();
|
||
const { readdirSync } = await import('fs');
|
||
const leftover = readdirSync(dir).filter((n) => n.includes('.tmp.'));
|
||
expect(leftover).toEqual([]);
|
||
});
|
||
|
||
it('写入大文件（>64KB）也能完成', async () => {
|
||
const dst = join(dir, 'big.md');
|
||
const big = 'A'.repeat(100_000);
|
||
await fileOps.atomicWriteFile(dst, big);
|
||
const { statSync } = await import('fs');
|
||
expect(statSync(dst).size).toBe(100_000);
|
||
});
|
||
});
|
||
|
||
describe('renameWithRetry（C3 file-IO audit fix）', () => {
|
||
it('正常路径：rename 成功', async () => {
|
||
const tmpDir = mkdtempSync(join(tmpdir(), 'rename-'));
|
||
try {
|
||
const src = join(tmpDir, 'src.tmp');
|
||
const dst = join(tmpDir, 'dst.md');
|
||
writeFileSync(src, 'content');
|
||
await fileOps.renameWithRetry(src, dst);
|
||
const { existsSync, readFileSync } = await import('fs');
|
||
expect(existsSync(src)).toBe(false);
|
||
expect(readFileSync(dst, 'utf-8')).toBe('content');
|
||
} finally {
|
||
rmSync(tmpDir, { recursive: true, force: true });
|
||
}
|
||
});
|
||
});
|
||
|
||
describe('friendlyWriteError（Phase N Q-fix）', () => {
|
||
// file:write catch 在 Phase N Q-fix 之前直接返回 e.message（含英文 errno +
|
||
// 完整路径，会泄露路径细节）。现在走 friendlyWriteError(e) 翻译成中文，
|
||
// 与 _friendlyCreateError / _friendlyRenameError / _friendlyDeleteError
|
||
// / _friendlyReadError 对称。本组测试覆盖每个分支，防止未来重构时改坏
|
||
// mapping（用户会看到误导的「未知错误 / 英文 errno + 路径」）。
|
||
it('EACCES → 没写入权限 / 只读 / 占用提示', () => {
|
||
const r = fileOps.friendlyWriteError({ code: 'EACCES' });
|
||
expect(r).toMatch(/权限/);
|
||
expect(r).toMatch(/独占|占用|只读/);
|
||
});
|
||
|
||
it('EPERM → 与 EACCES 共用文案', () => {
|
||
expect(fileOps.friendlyWriteError({ code: 'EPERM' }))
|
||
.toBe(fileOps.friendlyWriteError({ code: 'EACCES' }));
|
||
});
|
||
|
||
it('ENOSPC → 磁盘空间不足', () => {
|
||
expect(fileOps.friendlyWriteError({ code: 'ENOSPC' })).toBe('磁盘空间不足');
|
||
});
|
||
|
||
it('EROFS → 只读文件系统，无法写入', () => {
|
||
expect(fileOps.friendlyWriteError({ code: 'EROFS' })).toBe('只读文件系统，无法写入');
|
||
});
|
||
|
||
it('EBUSY → 文件被其他程序占用', () => {
|
||
expect(fileOps.friendlyWriteError({ code: 'EBUSY' })).toBe('文件被其他程序占用');
|
||
});
|
||
|
||
it('EIO → 磁盘 I/O 错误', () => {
|
||
expect(fileOps.friendlyWriteError({ code: 'EIO' })).toBe('磁盘 I/O 错误');
|
||
});
|
||
|
||
it('EISDIR → 目标路径是文件夹，无法写入', () => {
|
||
expect(fileOps.friendlyWriteError({ code: 'EISDIR' })).toBe('目标路径是文件夹，无法写入');
|
||
});
|
||
|
||
it('ENAMETOOLONG → 路径过长', () => {
|
||
expect(fileOps.friendlyWriteError({ code: 'ENAMETOOLONG' })).toBe('路径过长');
|
||
});
|
||
|
||
it('ENOTDIR → 父目录不是目录', () => {
|
||
expect(fileOps.friendlyWriteError({ code: 'ENOTDIR' })).toBe('父目录不是目录');
|
||
});
|
||
|
||
it('未知 errno → 返回 e.message 作 fallback', () => {
|
||
// Round 4 收尾：friendlyWriteError(e) 把 e.message 透传给 friendlyFsError
|
||
// 作为 fallback —— 未知 errno 时 e.message 含英文 errno + 路径。
|
||
expect(fileOps.friendlyWriteError({ code: 'EWHOKNOWS', message: 'some error' }))
|
||
.toBe('some error');
|
||
});
|
||
|
||
it('未知 errno + 无 message → 返回「未知错误」', () => {
|
||
expect(fileOps.friendlyWriteError({ code: 'EWHOKNOWS' })).toBe('未知错误');
|
||
});
|
||
|
||
it('e === null → 返回「未知错误」（不让 throw）', () => {
|
||
// 防御性：catch 里 e 可能是 null / undefined（极端情况），不能让翻译函数
|
||
// throw 把主进程 IPC handler 整个挂掉。friendlyFsError 兜底走 fallback||'未知错误'。
|
||
expect(fileOps.friendlyWriteError(null)).toBe('未知错误');
|
||
expect(fileOps.friendlyWriteError(undefined)).toBe('未知错误');
|
||
});
|
||
|
||
it('e.code 缺失 → 返回 e.message 作 fallback', () => {
|
||
// 注意：旧测试期望「写入文件失败」（friendlyWriteError 内部 switch 走 default
|
||
// case），Round 4 后走 friendlyFsError 兜底直接透传 e.message —— 主进程 catch
|
||
// 出来的 e.message 通常含「EPERM: operation not permitted」+ 路径，但 renderer
|
||
// 拿到的是已经走 friendlyFsError 二次翻译过的中文，不应让英文 errno 漏到这里。
|
||
// 这里只断言不 throw + 返回字符串类型。
|
||
const r = fileOps.friendlyWriteError({ message: 'EPERM: operation not permitted' });
|
||
expect(typeof r).toBe('string');
|
||
expect(r.length).toBeGreaterThan(0);
|
||
});
|
||
|
||
it('关键：不再泄露 e.message 中的英文 errno / 路径', () => {
|
||
// 这是 Phase N Q-fix 的核心目标：避免「EPERM: operation not permitted,
|
||
// open 'C:\\Users\\xxx\\file.md'」直接吐到用户面前。
|
||
const e = { code: 'EPERM', message: "EPERM: operation not permitted, open 'C:\\Users\\me\\note.md'" };
|
||
const r = fileOps.friendlyWriteError(e);
|
||
expect(r).not.toMatch(/EPERM/);
|
||
expect(r).not.toMatch(/operation/);
|
||
expect(r).not.toMatch(/Users/);
|
||
expect(r).not.toMatch(/note\.md/);
|
||
});
|
||
});
|
||
|
||
describe('atomicWriteFile fsync 行为 (audit Round 4 P0-1)', () => {
|
||
// POSIX rename(2) 是原子的，但「目录项写入磁盘」的时机由内核控制；不 fsync
|
||
// 父目录就断电，磁盘上可能仍是旧名字 → 新文件彻底丢失。
|
||
// audit 修：atomicWriteFile 在 rename 成功后对父目录做一次 fsync（仅 POSIX，
|
||
// Windows NTFS 文件系统层 journal 元数据不需要且 fs.open 目录会拒绝写操作）。
|
||
//
|
||
// 这里用 spy 钉死「rename 之后调一次目录 open + sync + close」的时序：
|
||
// - sync 必须在 close 之前（先落盘再 close 的原子模式）
|
||
// - 调用次数至少 1 次（不是 0）
|
||
// - 目标路径必须包含目标文件的目录
|
||
|
||
// audit fix: 与 config-store 那条 fsync 测试独立，避免 spy 互相覆盖。
|
||
// 仅在非 Windows 上做严格时序断言（Linux/macOS 走完整流程）；
|
||
// Windows 上目录 fsync 跳过，所以平台无关的部分（基础写入 + rename 成功）
|
||
// 单测也跑一遍。
|
||
const fsPromises = require('fs').promises;
|
||
|
||
it('Linux/macOS：rename 成功后对父目录 fsync（先 sync 再 close）', async function() {
|
||
if (process.platform === 'win32') {
|
||
// Windows 平台跳过严格时序断言（fs-watcher 不走这条路径），
|
||
// 但跑下面的基础写入断言保证兼容性。
|
||
return;
|
||
}
|
||
const target = join(dir, 'note.md');
|
||
writeFileSync(target, 'old content', 'utf-8');
|
||
|
||
/** @type {Array<{method: string, whenMs: number}>} */
|
||
const calls = [];
|
||
let syncCalledAt = -1;
|
||
let closeCalledAt = -1;
|
||
const realOpen = fsPromises.open;
|
||
fsPromises.open = async function spyOpen(p, flags) {
|
||
const fh = await realOpen.call(fsPromises, p, flags);
|
||
// 只 spy 父目录的 fd（路径 = dir 名）
|
||
if (typeof p === 'string' && p === dir && flags === 'r') {
|
||
const realSync = fh.sync.bind(fh);
|
||
const realClose = fh.close.bind(fh);
|
||
fh.sync = async function spySync() {
|
||
syncCalledAt = Date.now();
|
||
calls.push({ method: 'sync' });
|
||
return realSync();
|
||
};
|
||
fh.close = async function spyClose() {
|
||
closeCalledAt = Date.now();
|
||
calls.push({ method: 'close' });
|
||
return realClose();
|
||
};
|
||
}
|
||
return fh;
|
||
};
|
||
try {
|
||
await fileOps.atomicWriteFile(target, 'new content');
|
||
} finally {
|
||
fsPromises.open = realOpen;
|
||
}
|
||
expect(syncCalledAt).toBeGreaterThan(0);
|
||
expect(closeCalledAt).toBeGreaterThan(0);
|
||
expect(syncCalledAt).toBeLessThanOrEqual(closeCalledAt);
|
||
const syncIdx = calls.findIndex((c) => c.method === 'sync');
|
||
const closeIdx = calls.findIndex((c) => c.method === 'close');
|
||
expect(syncIdx).toBeGreaterThanOrEqual(0);
|
||
expect(closeIdx).toBeGreaterThan(syncIdx);
|
||
});
|
||
|
||
it('Windows 上：目录 fsync 跳过（NTFS 不需要）', async function() {
|
||
if (process.platform !== 'win32') return;
|
||
// 在 Windows 上不可能调用 fs.open(dir, 'r') 做 fsync（NTFS 拒绝写）。
|
||
// 本测试仅验证写入仍然成功 + 内容正确，作为 sanity check。
|
||
const target = join(dir, 'note.md');
|
||
await fileOps.atomicWriteFile(target, 'windows content');
|
||
const { readFileSync } = require('fs');
|
||
expect(readFileSync(target, 'utf-8')).toBe('windows content');
|
||
});
|
||
|
||
it('基础写入：原子覆盖 dst，tmp 不残留', async () => {
|
||
const target = join(dir, 'note.md');
|
||
writeFileSync(target, 'before', 'utf-8');
|
||
await fileOps.atomicWriteFile(target, 'after');
|
||
const { readFileSync, readdirSync } = require('fs');
|
||
expect(readFileSync(target, 'utf-8')).toBe('after');
|
||
// tmp 文件必须清理（不留垃圾）
|
||
const leftover = readdirSync(dir).filter((f) => f.includes('.tmp.'));
|
||
expect(leftover).toEqual([]);
|
||
});
|
||
}); |