root/peoplelib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c5b9072ffd7c75339e909164cd1a770ec6345ae1
peoplelib/src/_test/reader.test.js
T

1045 lines
36 KiB
JavaScript
Raw Blame History

const test = require('node:test');
const assert = require('node:assert');
const fs = require('fs');
const os = require('os');
const path = require('path');
const h = require('./helpers');
h.installFetchStub();
const storePath = require.resolve('../reader/store.js');
const cfgPath = require.resolve('../reader/ai-config.js');
const dirs = [];
function tmp() {
const d = fs.mkdtempSync(path.join(os.tmpdir(), 'peoplelib-reader-'));
dirs.push(d);
return d;
}
test.after(() => {
for (const d of dirs) {
try { fs.rmSync(d, { recursive: true, force: true }); } catch (e) { /* ignore */ }
}
});
function freshStore() {
delete require.cache[storePath];
const s = require(storePath);
s.init(tmp());
return s;
}
function storeAt(dir) {
delete require.cache[storePath];
const s = require(storePath);
s.init(dir);
return s;
}
function fakeStorage(available = true) {
return {
isEncryptionAvailable: () => available,
encryptString: (s) => Buffer.from('ENC:' + Buffer.from(s, 'utf8').toString('base64')),
decryptString: (b) => {
const s = b.toString();
if (!s.startsWith('ENC:')) throw new Error('bad');
return Buffer.from(s.slice(4), 'base64').toString('utf8');
}
};
}
// --- reader/store ---
test('阅读进度可存取，百分比被夹在 0..1', () => {
const s = freshStore();
assert.strictEqual(s.getLastReadAt('e1'), 0);
s.setProgress('e1', { kind: 'pdf', page: 5 }, 2.5);
const st = s.getState('e1');
assert.strictEqual(st.progress.locator.page, 5);
assert.strictEqual(st.progress.percent, 1);
assert.strictEqual(s.getLastReadAt('e1'), st.progress.at);
s.setProgress('e1', { kind: 'pdf', page: 1 }, -3);
assert.strictEqual(s.getState('e1').progress.percent, 0);
});
test('书签与笔记的增删互不干扰', () => {
const s = freshStore();
const b = s.addBookmark('e1', { locator: { kind: 'epub', chapter: 2, offset: 10 }, label: '第 3 章' });
const n = s.addNote('e1', { locator: { kind: 'epub', chapter: 2 }, text: '这是笔记', kind: 'ai' });
let st = s.getState('e1');
assert.strictEqual(st.bookmarks.length, 1);
assert.strictEqual(st.notes.length, 1);
assert.strictEqual(st.notes[0].kind, 'ai');
s.removeBookmark('e1', b.id);
st = s.getState('e1');
assert.strictEqual(st.bookmarks.length, 0);
assert.strictEqual(st.notes.length, 1, '删书签不该动笔记');
assert.strictEqual(s.removeNote('e1', n.id), true);
});
test('缺少定位信息的书签被拒绝', () => {
const s = freshStore();
assert.throws(() => s.addBookmark('e1', { label: 'x' }), /定位/);
assert.throws(() => s.addNote('e1', { text: ' ' }), /内容为空/);
});
test('不同条目的阅读数据互相隔离', () => {
const s = freshStore();
s.addBookmark('a', { locator: { kind: 'pdf', page: 1 } });
s.addBookmark('b', { locator: { kind: 'pdf', page: 2 } });
assert.strictEqual(s.getState('a').bookmarks.length, 1);
assert.strictEqual(s.getState('b').bookmarks[0].locator.page, 2);
s.forget('a');
assert.strictEqual(s.getState('a').bookmarks.length, 0);
assert.strictEqual(s.getState('b').bookmarks.length, 1, 'forget 误删了其它条目');
});
test('孤立阅读资料按笔记数报告并可批量回收', () => {
const s = freshStore();
s.setProgress('kept', { kind: 'pdf', page: 2 }, 0.5);
s.addNote('kept', { text: '保留的笔记' });
s.addNote('gone_a', { text: '甲一' });
s.addNote('gone_a', { text: '甲二' });
s.addBookmark('gone_b', { locator: { kind: 'pdf', page: 3 } });
s.addStandaloneNote({ text: '与书籍无关的独立笔记' });
const orphans = s.orphanReport(['kept']);
assert.deepStrictEqual(orphans.map((o) => o.entryId).sort(), ['gone_a', 'gone_b']);
assert.strictEqual(orphans.find((o) => o.entryId === 'gone_a').notes, 2);
assert.strictEqual(orphans.find((o) => o.entryId === 'gone_b').bookmarks, 1);
// 独立笔记本没有对应书籍，永远不算孤立
assert.ok(!orphans.some((o) => o.entryId === s.STANDALONE_ENTRY_ID));
assert.strictEqual(s.forgetMany(orphans.map((o) => o.entryId)), 2);
assert.strictEqual(s.getState('kept').notes.length, 1);
assert.strictEqual(s.getState('kept').progress.percent, 0.5);
assert.ok(s.listNotes({}).some((n) => n.text === '与书籍无关的独立笔记'));
assert.deepStrictEqual(s.orphanReport(['kept']), []);
assert.strictEqual(s.forgetMany([]), 0);
// 即使显式点名，也不能删掉独立笔记本：它没有对应书籍，永远不是可回收对象
assert.strictEqual(s.forgetMany([s.STANDALONE_ENTRY_ID]), 0);
assert.ok(s.listNotes({}).some((n) => n.text === '与书籍无关的独立笔记'));
});
test('getState 返回副本，外部改动不污染存储', () => {
const s = freshStore();
s.addBookmark('e1', { locator: { kind: 'pdf', page: 1 } });
const st = s.getState('e1');
st.bookmarks.push({ id: 'fake' });
assert.strictEqual(s.getState('e1').bookmarks.length, 1);
});
test('损坏的 reader.json 不会导致崩溃', () => {
const d = tmp();
fs.writeFileSync(path.join(d, 'reader.json'), '{ 这不是 json');
delete require.cache[storePath];
const s = require(storePath);
s.init(d);
assert.deepStrictEqual(s.getState('x').bookmarks, []);
s.setProgress('x', { kind: 'pdf', page: 1 }, 0.1);
assert.ok(s.getState('x').progress);
assert.strictEqual(
fs.readdirSync(d).some((name) => name.startsWith('reader.json.corrupt-')),
true,
'损坏原文件应被隔离保留'
);
assert.doesNotThrow(() => JSON.parse(fs.readFileSync(path.join(d, 'reader.json'), 'utf8')));
});
test('同一条目的进度、书签和笔记按文档标识隔离', () => {
const s = freshStore();
s.setProgress('e1', 'doc-a', { kind: 'pdf', page: 2 }, 0.2);
s.setProgress('e1', 'doc-b', { kind: 'epub', chapter: 3, offset: 20 }, 0.7);
s.addBookmark('e1', {
documentKey: 'doc-a',
locator: { kind: 'pdf', page: 2 },
label: 'PDF'
});
s.addBookmark('e1', {
documentKey: 'doc-b',
locator: { kind: 'epub', chapter: 3, offset: 20 },
label: 'EPUB'
});
s.addNote('e1', { documentKey: 'doc-a', text: 'PDF 笔记' });
s.addNote('e1', { documentKey: 'doc-b', text: 'EPUB 笔记' });
assert.strictEqual(s.getState('e1', 'doc-a').progress.locator.page, 2);
assert.strictEqual(s.getState('e1', 'doc-b').progress.locator.chapter, 3);
assert.deepStrictEqual(s.getState('e1', 'doc-a').bookmarks.map((item) => item.label), ['PDF']);
assert.deepStrictEqual(s.getState('e1', 'doc-b').notes.map((item) => item.text), ['EPUB 笔记']);
});
test('主文件损坏时隔离原件并从有效备份恢复阅读资料', () => {
const d = tmp();
const file = path.join(d, 'reader.json');
fs.writeFileSync(file, '{ broken');
fs.writeFileSync(`${file}.bak`, JSON.stringify({
version: 2,
collections: [],
entries: {
restored: {
progress: null,
bookmarks: [],
notes: [{ id: 'note-1', text: '已恢复', kind: 'user', at: 10 }]
}
}
}));
const s = storeAt(d);
assert.strictEqual(s.getState('restored').notes[0].text, '已恢复');
assert.strictEqual(fs.existsSync(file), true);
assert.strictEqual(
fs.readdirSync(d).some((name) => name.startsWith('reader.json.corrupt-')),
true
);
});
test('迁移会丢弃合法 JSON 中结构损坏的进度和书签', () => {
const d = tmp();
fs.writeFileSync(path.join(d, 'reader.json'), JSON.stringify({
version: 2,
collections: [],
entries: {
broken: {
progress: { locator: null, percent: 2 },
progressByDocument: {
bad: { locator: null },
good: { locator: { kind: 'pdf', page: 2 }, percent: 2 }
},
bookmarks: [
null,
{ id: 'bad', locator: null },
{ id: 'good', locator: { kind: 'pdf', page: 3 }, label: '有效书签' }
],
notes: []
}
}
}));
const s = storeAt(d);
assert.deepStrictEqual(s.getState('broken').bookmarks.map((item) => item.label), ['有效书签']);
assert.doesNotThrow(() => s.bindDocument('broken', 'doc-current'));
const state = s.getState('broken', 'good');
assert.strictEqual(state.progress.percent, 1);
});
test('首次绑定文档把旧版进度和书签安全迁移到该文档', () => {
const s = freshStore();
s.setProgress('legacy', { kind: 'pdf', page: 6 }, 0.5);
s.addBookmark('legacy', { locator: { kind: 'pdf', page: 6 }, label: '旧书签' });
assert.strictEqual(s.bindDocument('legacy', 'doc-key'), true);
const state = s.getState('legacy', 'doc-key');
assert.strictEqual(state.progress.locator.page, 6);
assert.strictEqual(state.bookmarks[0].documentKey, 'doc-key');
});
test('结构化笔记支持纯引用、来源、标签和上下文字段', () => {
const s = freshStore();
const note = s.addNote('e1', {
title: '重点',
quote: '只保存引用也可以',
context: '第二章',
source: 'selection',
documentKey: 'doc-1',
fileIndex: 2,
tags: ['方法', '方法', '研究'],
pinned: true,
locator: { kind: 'pdf', page: 3 }
});
assert.strictEqual(note.text, '');
assert.strictEqual(note.source, 'selection');
assert.strictEqual(note.kind, 'user', '保留旧渲染器使用的兼容别名');
assert.deepStrictEqual(note.tags, ['方法', '研究']);
assert.strictEqual(note.createdAt, note.updatedAt);
note.tags.push('外部修改');
note.locator.page = 99;
const stored = s.getState('e1').notes[0];
assert.deepStrictEqual(stored.tags, ['方法', '研究']);
assert.strictEqual(stored.locator.page, 3);
});
test('富文本笔记保存格式、纯文本索引和内嵌图片', () => {
const s = freshStore();
const image = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAAB';
const richContent = {
version: 1,
blocks: [
{
type: 'text',
style: 'heading1',
runs: [{ text: '富文本标题', bold: true }]
},
{
type: 'text',
style: 'paragraph',
runs: [{ text: '正文' }, { text: '强调', italic: true, underline: true }]
},
{ type: 'image', dataUrl: image, alt: '示例图片' }
]
};
const note = s.addNote('e1', { richContent, source: 'manual' });
assert.strictEqual(note.noteType, 'reading');
assert.strictEqual(note.text, '富文本标题\n正文强调');
assert.deepStrictEqual(note.richContent, {
version: 2,
ops: [
{ insert: '富文本标题', attributes: { bold: true } },
{ insert: '\n', attributes: { header: 1 } },
{ insert: '正文' },
{ insert: '强调', attributes: { italic: true, underline: true } },
{ insert: '\n' },
{ insert: { image } }
]
});
assert.strictEqual(s.listNotes({ query: '正文强调' })[0].id, note.id);
const stored = s.getState('e1').notes[0];
assert.strictEqual(stored.richContent.version, 2);
richContent.blocks[0].runs[0].text = '外部污染';
assert.strictEqual(s.getState('e1').notes[0].text, '富文本标题\n正文强调');
const imageOnly = s.addNote('e1', {
richContent: { version: 1, blocks: [{ type: 'image', dataUrl: image, alt: '' }] }
});
assert.strictEqual(imageOnly.text, '');
assert.strictEqual(imageOnly.richContent.ops[0].insert.image, image);
});
test('富文本笔记拒绝主动内容、远程图片和超限结构', () => {
const s = freshStore();
assert.throws(
() => s.addNote('e1', {
richContent: {
version: 1,
blocks: [{ type: 'image', dataUrl: 'https://example.com/x.png', alt: '' }]
}
}),
/图片格式无效/
);
assert.throws(
() => s.addNote('e1', {
richContent: {
version: 1,
blocks: [{ type: 'html', html: '<script>alert(1)</script>' }]
}
}),
/段落无效/
);
assert.throws(
() => s.addNote('e1', {
richContent: {
version: 1,
blocks: Array.from({ length: 501 }, () => ({
type: 'text', style: 'paragraph', runs: [{ text: 'x' }]
}))
}
}),
/内容过多/
);
});
test('Quill Delta 仅保留受支持格式并拒绝主动嵌入', () => {
const s = freshStore();
const note = s.addNote('e1', {
richContent: {
version: 2,
ops: [
{ insert: '一级标题' },
{ insert: '\n', attributes: { header: 1 } },
{ insert: '正文', attributes: { bold: true, italic: true } },
{ insert: '\n', attributes: { list: 'bullet' } },
{ insert: '代码' },
{ insert: '\n', attributes: { 'code-block': 'plain' } }
]
}
});
assert.strictEqual(note.text, '一级标题\n正文\n代码');
assert.strictEqual(note.richContent.version, 2);
assert.deepStrictEqual(
note.richContent.ops.at(-1),
{ insert: '\n', attributes: { 'code-block': 'plain' } }
);
assert.throws(() => s.addNote('e1', {
richContent: {
version: 2,
ops: [{ insert: '外链', attributes: { link: 'https://example.com' } }]
}
}), /不支持的格式/);
assert.throws(() => s.addNote('e1', {
richContent: {
version: 2,
ops: [{ insert: { video: 'https://example.com/video' } }]
}
}), /嵌入内容无效/);
assert.throws(() => s.addNote('e1', {
richContent: {
version: 2,
ops: [{ retain: 1, attributes: { bold: true } }]
}
}), /操作无效/);
});
test('画布笔记保存分页画布、PDF 底版并支持类型筛选和文本搜索', () => {
const s = freshStore();
const assetId = `pdf_${'a'.repeat(64)}`;
const canvasContent = {
version: 2,
flow: {
version: 1,
ops: [
{ insert: '全局文本关键词', attributes: { bold: true } },
{ insert: '\n' },
{ insert: { canvasPageBreak: 'pg_two' } }
]
},
pages: [
{
id: 'pg_one',
width: 794,
height: 1123,
background: { type: 'template', template: 'grid' },
objects: [{
type: 'IText',
canvasKind: 'text',
text: '画布关键词',
left: 10,
top: 20,
fill: '#222222',
fontSize: 18
}]
},
{
id: 'pg_two',
width: 612,
height: 792,
background: { type: 'pdf', assetId, page: 2 },
objects: []
}
]
};
const note = s.addStandaloneNote({
noteType: 'canvas',
canvasContent
});
assert.strictEqual(note.noteType, 'canvas');
assert.strictEqual(note.text, '全局文本关键词\n画布关键词');
assert.deepStrictEqual(note.canvasContent, canvasContent);
assert.deepStrictEqual(s.noteAssetIds(), [assetId]);
assert.strictEqual(s.listNotes({ query: '画布关键词' })[0].id, note.id);
assert.strictEqual(s.listNotes({ query: '全局文本关键词' })[0].id, note.id);
assert.deepStrictEqual(s.listNotes({ noteType: 'canvas' }).map((item) => item.id), [note.id]);
assert.deepStrictEqual(s.listNotes({ noteType: 'reading' }), []);
assert.strictEqual(s.removeNote(s.STANDALONE_ENTRY_ID, note.id), true);
assert.deepStrictEqual(s.noteAssetIds(), []);
});
test('读书笔记和画布笔记创建后保持独立且类型不可更改', () => {
const s = freshStore();
const canvasContent = {
version: 1,
pages: [{
id: 'pg_type',
width: 794,
height: 1123,
background: { type: 'template', template: 'blank' },
objects: []
}]
};
assert.throws(() => s.addNote('e1', {
noteType: 'unknown',
text: '正文'
}), /笔记类型无效/);
assert.throws(() => s.addNote('e1', {
noteType: 'reading',
richContent: { version: 2, ops: [{ insert: '正文\n' }] },
canvasContent
}), /读书笔记不能包含画布内容/);
assert.throws(() => s.addNote('e1', {
noteType: 'canvas',
richContent: { version: 2, ops: [{ insert: '正文\n' }] },
canvasContent
}), /画布笔记不能包含富文本内容/);
const reading = s.addNote('e1', { noteType: 'reading', text: '正文' });
assert.throws(() => s.updateNote('e1', reading.id, { noteType: 'canvas' }), /不能更改/);
const canvas = s.addNote('e1', { noteType: 'canvas', canvasContent });
assert.throws(() => s.updateNote('e1', canvas.id, {
richContent: { version: 2, ops: [{ insert: '正文\n' }] }
}), /不能包含富文本内容/);
});
test('v4 混合笔记迁移为画布笔记并保留两类旧内容', () => {
const root = tmp();
fs.writeFileSync(path.join(root, 'reader.json'), JSON.stringify({
version: 4,
collections: [],
entries: {
e1: {
notes: [{
id: 'nt_legacy_mixed',
title: '旧混合笔记',
richContent: { version: 2, ops: [{ insert: '旧正文\n' }] },
canvasContent: {
version: 1,
pages: [{
id: 'pg_legacy',
width: 794,
height: 1123,
background: { type: 'template', template: 'grid' },
objects: []
}]
},
source: 'manual',
tags: [],
createdAt: 1,
updatedAt: 1
}, {
id: 'nt_legacy_blank_canvas',
richContent: { version: 2, ops: [{ insert: '仅正文\n' }] },
canvasContent: {
version: 1,
pages: [{
id: 'pg_legacy_blank',
width: 794,
height: 1123,
background: { type: 'template', template: 'blank' },
objects: []
}]
},
source: 'manual',
tags: [],
createdAt: 2,
updatedAt: 2
}]
}
}
}));
const s = storeAt(root);
const notes = s.getState('e1').notes;
const note = notes.find((item) => item.id === 'nt_legacy_mixed');
assert.strictEqual(note.noteType, 'canvas');
assert.strictEqual(note.richContent.ops[0].insert, '旧正文\n');
assert.strictEqual(note.canvasContent.version, 2);
assert.strictEqual(note.canvasContent.pages[0].background.template, 'grid');
const updated = s.updateNote('e1', note.id, {
noteType: 'canvas',
canvasContent: note.canvasContent
});
assert.strictEqual(updated.richContent.ops[0].insert, '旧正文\n');
const blankCanvas = notes.find((item) => item.id === 'nt_legacy_blank_canvas');
assert.strictEqual(blankCanvas.noteType, 'reading');
assert.strictEqual(blankCanvas.richContent.ops[0].insert, '仅正文\n');
assert.strictEqual(blankCanvas.canvasContent.pages[0].background.template, 'blank');
});
test('画布笔记拒绝未知对象、主动属性、远程图片和非法 PDF 引用', () => {
const s = freshStore();
const page = (object, background = { type: 'template', template: 'blank' }) => ({
version: 1,
pages: [{
id: 'pg_safe',
width: 794,
height: 1123,
background,
objects: object ? [object] : []
}]
});
assert.throws(() => s.addNote('e1', {
canvasContent: page({ type: 'Circle', canvasKind: 'circle' })
}), /对象类型无效/);
assert.throws(() => s.addNote('e1', {
canvasContent: page({
type: 'Path',
canvasKind: 'pen',
path: [['M', 0, 0], ['L', 1, 1]],
clipPath: {}
})
}), /不支持的属性/);
assert.throws(() => s.addNote('e1', {
canvasContent: page({
type: 'Path',
canvasKind: 'pen',
path: [['M', 0, 0]],
arbitraryPayload: { type: 'Image' }
})
}), /不支持的属性/);
assert.throws(() => s.addNote('e1', {
canvasContent: page({
type: 'Path',
canvasKind: 'pen',
path: [['M', 0, 0]],
scaleX: 1000
})
}), /缩放无效/);
assert.throws(() => s.addNote('e1', {
canvasContent: page({
type: 'Image',
canvasKind: 'image',
src: 'https://example.com/image.png'
})
}), /图片格式无效/);
assert.throws(() => s.addNote('e1', {
canvasContent: page(null, { type: 'pdf', assetId: '../outside', page: 1 })
}), /PDF 底版资源无效/);
const flowPage = {
version: 2,
pages: [{
id: 'pg_flow',
width: 794,
height: 1123,
background: { type: 'template', template: 'blank' },
objects: []
}, {
id: 'pg_flow_two',
width: 794,
height: 1123,
background: { type: 'template', template: 'blank' },
objects: [],
flowAuto: true
}]
};
assert.throws(() => s.addNote('e1', {
noteType: 'canvas',
canvasContent: {
...flowPage,
flow: { version: 1, ops: [{ insert: { canvasPageBreak: '../outside' } }] }
}
}), /分页符无效/);
assert.throws(() => s.addNote('e1', {
noteType: 'canvas',
canvasContent: {
...flowPage,
flow: { version: 1, ops: [{ insert: { image: 'https://example.com/a.png' } }] }
}
}), /嵌入内容无效/);
const flowNote = s.addNote('e1', {
noteType: 'canvas',
canvasContent: {
...flowPage,
flow: {
version: 1,
ops: [
{ insert: '跨页正文\n', attributes: { header: 1 } },
{ insert: { canvasPageBreak: 'pg_flow_two' } },
{ insert: '第二页正文\n' }
]
}
}
});
assert.strictEqual(flowNote.text, '跨页正文\n第二页正文');
assert.strictEqual(flowNote.canvasContent.pages[1].flowAuto, true);
});
test('笔记可更新且必需保留正文或引用', () => {
const s = freshStore();
const note = s.addNote('e1', { text: '原文', source: 'manual' });
const updated = s.updateNote('e1', note.id, {
text: '',
quote: '新引用',
source: 'ai',
aiTask: '总结',
tags: ['AI'],
pinned: true
});
assert.strictEqual(updated.quote, '新引用');
assert.strictEqual(updated.source, 'ai');
assert.strictEqual(updated.kind, 'ai');
assert.strictEqual(updated.aiTask, '总结');
assert.strictEqual(updated.at, updated.updatedAt);
assert.throws(
() => s.updateNote('e1', note.id, { quote: '', text: '' }),
/内容为空/
);
assert.strictEqual(s.getState('e1').notes[0].quote, '新引用', '失败更新必须回滚');
assert.strictEqual(s.updateNote('e1', 'nt_missing', { title: 'x' }), null);
});
test('普通读书笔记新增与更新均完整保留超长正文', () => {
const d = tmp();
let s = storeAt(d);
const addedText = '新增正文'.repeat(6000);
const updatedText = '更新正文'.repeat(6500);
const note = s.addNote('e1', { text: addedText, source: 'manual' });
assert.strictEqual(note.text, addedText);
assert.strictEqual(s.getState('e1').notes[0].text, addedText);
s = storeAt(d);
assert.strictEqual(s.getState('e1').notes[0].text, addedText);
const updated = s.updateNote('e1', note.id, { text: updatedText });
assert.strictEqual(updated.text, updatedText);
s = storeAt(d);
assert.strictEqual(s.getState('e1').notes[0].text, updatedText);
});
test('富文本派生的普通笔记正文不截断', () => {
const s = freshStore();
const addedText = '富文本新增'.repeat(5000);
const updatedText = '富文本更新'.repeat(5500);
const note = s.addNote('e1', {
richContent: { version: 2, ops: [{ insert: `${addedText}\n` }] }
});
assert.strictEqual(note.text, addedText);
assert.strictEqual(note.richContent.ops[0].insert, `${addedText}\n`);
const updated = s.updateNote('e1', note.id, {
richContent: { version: 2, ops: [{ insert: `${updatedText}\n` }] }
});
assert.strictEqual(updated.text, updatedText);
assert.strictEqual(updated.richContent.ops[0].insert, `${updatedText}\n`);
});
test('笔记本名称不区分大小写去重，删除后笔记移入未分类', () => {
const s = freshStore();
const collection = s.addCollection({ name: 'Research' });
assert.throws(() => s.addCollection({ name: ' research ' }), /已存在/);
const note = s.addNote('e1', { text: '归档笔记', collectionId: collection.id });
assert.strictEqual(s.listCollections()[0].name, 'Research');
assert.strictEqual(s.updateCollection(collection.id, { name: 'Inbox' }).name, 'Inbox');
assert.strictEqual(s.removeCollection(collection.id), true);
assert.strictEqual(s.listCollections().length, 0);
assert.strictEqual(s.getState('e1').notes[0].id, note.id);
assert.strictEqual(s.getState('e1').notes[0].collectionId, null);
assert.strictEqual(s.listNotes({ collectionId: null }).length, 1);
});
test('聚合笔记按置顶与更新时间排序并支持全部筛选', () => {
const s = freshStore();
const work = s.addCollection('Work');
s.setBookSnapshot('book-a', { title: 'Alpha Handbook', authors: ['A. One'] });
s.setBookSnapshot('book-b', { title: 'Beta Notes', authors: ['B. Two'] });
const first = s.addNote('book-a', {
title: 'Ordinary',
text: 'needle in text',
source: 'manual',
tags: ['Blue'],
collectionId: work.id
});
const pinned = s.addNote('book-b', {
quote: 'selected passage',
source: 'selection',
tags: ['Green'],
pinned: true
});
s.updateNote('book-a', first.id, { context: 'changed' });
const all = s.listNotes();
assert.deepStrictEqual(all.map((note) => note.id), [pinned.id, first.id]);
assert.strictEqual(all[0].entryId, 'book-b');
assert.strictEqual(all[0].bookSnapshot.title, 'Beta Notes');
assert.deepStrictEqual(s.listNotes({ entryId: 'book-a' }).map((n) => n.id), [first.id]);
assert.deepStrictEqual(s.listNotes({ collectionId: work.id }).map((n) => n.id), [first.id]);
assert.deepStrictEqual(s.listNotes({ source: 'selection' }).map((n) => n.id), [pinned.id]);
assert.deepStrictEqual(s.listNotes({ tag: 'blue' }).map((n) => n.id), [first.id]);
assert.deepStrictEqual(s.listNotes({ query: 'alpha hand' }).map((n) => n.id), [first.id]);
assert.deepStrictEqual(s.listNotes({ query: 'NEEDLE' }).map((n) => n.id), [first.id]);
assert.deepStrictEqual(s.getNoteCounts(), { 'book-a': 1, 'book-b': 1 });
all[0].bookSnapshot.title = '污染';
all[0].tags.push('污染');
assert.strictEqual(s.listNotes()[0].bookSnapshot.title, 'Beta Notes');
assert.deepStrictEqual(s.listNotes()[0].tags, ['Green']);
});
test('无关联笔记独立持久化且不计入书库卡片笔记数', () => {
const s = freshStore();
const note = s.addStandaloneNote({
title: '独立想法',
text: '不关联任何书籍',
source: 'manual',
tags: ['随想']
});
const listed = s.listNotes().find((item) => item.id === note.id);
assert.strictEqual(listed.entryId, s.STANDALONE_ENTRY_ID);
assert.strictEqual(listed.associated, false);
assert.strictEqual(listed.bookSnapshot, null);
assert.deepStrictEqual(s.getNoteCounts(), {});
assert.strictEqual(
s.updateNote(listed.entryId, note.id, { text: '已编辑' }).text,
'已编辑'
);
assert.strictEqual(s.removeNote(listed.entryId, note.id), true);
});
test('旧版 reader.json 安全迁移为 v6 并保留阅读数据', () => {
const d = tmp();
const file = path.join(d, 'reader.json');
const legacyText = '旧版超长正文'.repeat(4000);
const legacy = {
entries: {
e1: {
progress: { locator: { page: 8 }, percent: 0.4, at: 10 },
bookmarks: [{ id: 'bm_old', locator: { page: 8 }, at: 11 }],
notes: [{
id: 'nt_old',
text: legacyText,
quote: '旧引用',
kind: 'ai',
at: 123,
locator: { page: 8 }
}]
}
}
};
fs.writeFileSync(file, JSON.stringify(legacy), 'utf8');
let s = storeAt(d);
const state = s.getState('e1');
assert.deepStrictEqual(state.progress, legacy.entries.e1.progress);
assert.deepStrictEqual(state.bookmarks, legacy.entries.e1.bookmarks);
assert.strictEqual(state.notes[0].id, 'nt_old');
assert.strictEqual(state.notes[0].text, legacyText);
assert.strictEqual(state.notes[0].source, 'ai');
assert.strictEqual(state.notes[0].createdAt, 123);
assert.strictEqual(state.notes[0].updatedAt, 123);
assert.strictEqual(state.notes[0].collectionId, null);
const migrated = JSON.parse(fs.readFileSync(file, 'utf8'));
assert.strictEqual(migrated.version, 6);
assert.deepStrictEqual(migrated.collections, []);
const bytes = fs.readFileSync(file, 'utf8');
s = storeAt(d);
assert.strictEqual(s.getState('e1').notes.length, 1);
assert.strictEqual(fs.readFileSync(file, 'utf8'), bytes, 'v6 再加载不应重复迁移');
});
test('字段限制、来源校验和安全 ID 校验生效', () => {
const s = freshStore();
assert.throws(() => s.getState('../reader'), /ID无效/);
assert.throws(
() => s.setProgress('e1', 'toString', { kind: 'pdf', page: 1 }, 0.1),
/文档标识无效/
);
assert.throws(() => s.addNote('e1', { text: 'x', source: 'robot' }), /来源无效/);
assert.throws(
() => s.addNote('e1', { text: 'x', collectionId: 'col_missing' }),
/不存在/
);
const note = s.addNote('e1', {
text: 'x'.repeat(25000),
tags: Array.from({ length: 40 }, (_, i) => `tag-${i}`)
});
assert.strictEqual(note.text.length, 25000);
assert.strictEqual(note.tags.length, 30);
});
test('写盘失败时内存和磁盘状态都回滚', () => {
const d = tmp();
let s = storeAt(d);
s.addNote('e1', { text: '已保存' });
const file = path.join(d, 'reader.json');
const before = fs.readFileSync(file, 'utf8');
const originalRename = fs.renameSync;
fs.renameSync = (from, to) => {
if (from === `${file}.tmp` && to === file) throw new Error('模拟写盘失败');
return originalRename(from, to);
};
try {
assert.throws(() => s.addNote('e1', { text: '不应保存' }), /模拟写盘失败/);
} finally {
fs.renameSync = originalRename;
}
assert.strictEqual(s.getState('e1').notes.length, 1);
assert.strictEqual(fs.readFileSync(file, 'utf8'), before);
s = storeAt(d);
assert.strictEqual(s.getState('e1').notes.length, 1);
});
// --- reader/ai-config ---
function freshCfg(storage = fakeStorage()) {
delete require.cache[cfgPath];
const c = require(cfgPath);
c.init(tmp(), storage);
return c;
}
test('AI Key 加密落盘，磁盘无明文', () => {
const d = tmp();
delete require.cache[cfgPath];
const c = require(cfgPath);
c.init(d, fakeStorage());
c.save({ baseUrl: 'https://api.deepseek.com/v1', model: 'deepseek-chat', apiKey: 'sk-SECRET-123' });
for (const f of fs.readdirSync(d)) {
const content = fs.readFileSync(path.join(d, f)).toString();
assert.ok(!content.includes('sk-SECRET-123'), `${f} 出现明文 Key`);
}
assert.strictEqual(c.get().apiKey, 'sk-SECRET-123');
assert.strictEqual(c.status().hasKey, true);
});
test('只改模型时不传 apiKey，不会清掉已存的 Key', () => {
const c = freshCfg();
c.save({
protocol: 'anthropic',
baseUrl: 'https://api.openai.com/v1',
model: 'gpt-4o-mini',
apiKey: 'sk-keep',
vision: true
});
c.save({ baseUrl: 'https://api.openai.com/v1', model: 'gpt-4o' });
assert.strictEqual(c.get().apiKey, 'sk-keep');
assert.strictEqual(c.get().model, 'gpt-4o');
assert.strictEqual(c.status().protocol, 'anthropic');
assert.strictEqual(c.status().vision, true);
});
test('AI 接口类型显式持久化，旧配置默认使用 Chat Completions', () => {
const d = tmp();
fs.writeFileSync(path.join(d, 'ai-config.json'), JSON.stringify({
baseUrl: 'https://api.openai.com/v1',
model: 'legacy'
}));
delete require.cache[cfgPath];
const c = require(cfgPath);
c.init(d, fakeStorage());
assert.strictEqual(c.status().protocol, 'chat-completions');
c.save({
protocol: 'openai-responses',
baseUrl: 'https://api.openai.com/v1',
model: 'gpt-4.1'
});
assert.strictEqual(c.status().protocol, 'openai-responses');
assert.strictEqual(JSON.parse(fs.readFileSync(path.join(d, 'ai-config.json'), 'utf8')).protocol, 'openai-responses');
assert.throws(
() => c.save({ protocol: 'unknown', baseUrl: 'https://api.openai.com/v1', model: 'm' }),
/接口类型/
);
});
test('AI 状态区分模型已配置、缺少 Key 与 Key 无法读取', () => {
const d = tmp();
delete require.cache[cfgPath];
let c = require(cfgPath);
c.init(d, fakeStorage());
let status = c.status();
assert.strictEqual(status.modelConfigured, false);
assert.strictEqual(status.ready, false);
assert.strictEqual(status.keyState, 'missing');
c.save({
protocol: 'anthropic',
baseUrl: 'https://api.anthropic.com/v1',
model: 'claude-sonnet',
vision: true
});
status = c.status();
assert.strictEqual(status.modelConfigured, true);
assert.strictEqual(status.ready, false);
assert.strictEqual(status.keyState, 'missing');
c.save({
protocol: 'anthropic',
baseUrl: 'https://api.anthropic.com/v1',
model: 'claude-sonnet',
apiKey: 'sk-anthropic'
});
assert.strictEqual(c.status().ready, true);
delete require.cache[cfgPath];
c = require(cfgPath);
c.init(d, {
isEncryptionAvailable: () => true,
decryptString: () => { throw new Error('cannot decrypt'); }
});
status = c.status();
assert.strictEqual(status.modelConfigured, true);
assert.strictEqual(status.hasKey, false);
assert.strictEqual(status.ready, false);
assert.strictEqual(status.keyState, 'unreadable');
});
test('图像输入能力必须显式配置并持久化', () => {
const d = tmp();
delete require.cache[cfgPath];
const c = require(cfgPath);
c.init(d, fakeStorage());
c.save({ baseUrl: 'https://api.openai.com/v1', model: 'm' });
assert.strictEqual(c.status().vision, false);
c.save({ baseUrl: 'https://api.openai.com/v1', model: 'm', vision: true });
assert.strictEqual(c.status().vision, true);
assert.strictEqual(JSON.parse(fs.readFileSync(path.join(d, 'ai-config.json'), 'utf8')).vision, true);
});
test('图像输入能力拒绝配置文件中的非布尔真值', () => {
const d = tmp();
fs.writeFileSync(path.join(d, 'ai-config.json'), JSON.stringify({
baseUrl: 'https://api.openai.com/v1',
model: 'm',
vision: 'true'
}));
delete require.cache[cfgPath];
const c = require(cfgPath);
c.init(d, fakeStorage());
assert.strictEqual(c.status().vision, false);
assert.strictEqual(c.get().vision, false);
});
test('显式传空字符串才清除 Key', () => {
const c = freshCfg();
c.save({ baseUrl: 'https://api.openai.com/v1', model: 'm', apiKey: 'sk-x' });
c.save({ baseUrl: 'https://api.openai.com/v1', model: 'm', apiKey: '' });
assert.strictEqual(c.status().hasKey, false);
});
test('切换 AI 接口类型或服务来源时不会复用旧 API Key', () => {
const c = freshCfg();
c.save({
protocol: 'chat-completions',
baseUrl: 'https://api.openai.com/v1',
model: 'm',
apiKey: 'sk-openai'
});
c.save({
protocol: 'anthropic',
baseUrl: 'https://api.anthropic.com/v1',
model: 'claude'
});
assert.strictEqual(c.status().hasKey, false);
c.save({
protocol: 'anthropic',
baseUrl: 'https://api.anthropic.com/v1',
model: 'claude',
apiKey: 'sk-anthropic'
});
c.save({
protocol: 'anthropic',
baseUrl: 'https://proxy.example.com/v1',
model: 'claude'
});
assert.strictEqual(c.status().hasKey, false);
});
test('非法接口地址被拒绝', () => {
const c = freshCfg();
assert.throws(() => c.save({ baseUrl: 'ftp://x/v1', model: 'm' }), /http/);
assert.throws(() => c.save({ baseUrl: '', model: 'm' }), /不能为空/);
assert.throws(() => c.save({ baseUrl: 'https://a/v1', model: '' }), /模型/);
assert.throws(() => c.save({ baseUrl: 'https://a/v1#fragment', model: 'm' }), /片段标识/);
});
test('本地端点识别为无需 Key', () => {
const c = freshCfg();
c.save({ baseUrl: 'http://127.0.0.1:11434/v1', model: 'qwen' });
assert.strictEqual(c.status().isLocal, true);
c.save({ baseUrl: 'https://api.openai.com/v1', model: 'gpt' });
assert.strictEqual(c.status().isLocal, false);
});
test('加密不可用时不落盘 Key', () => {
const d = tmp();
delete require.cache[cfgPath];
const c = require(cfgPath);
c.init(d, fakeStorage(false));
c.save({ baseUrl: 'https://a.com/v1', model: 'm', apiKey: 'sk-plain' });
for (const f of fs.readdirSync(d)) {
assert.ok(!fs.readFileSync(path.join(d, f)).toString().includes('sk-plain'), `${f} 落了明文`);
}
assert.strictEqual(c.get().apiKey, 'sk-plain');
assert.strictEqual(c.status().persistent, false);
});
test('baseUrl 末尾斜杠被规范化', () => {
const c = freshCfg();
c.save({ baseUrl: 'https://api.openai.com/v1///', model: 'm' });
assert.strictEqual(c.status().baseUrl, 'https://api.openai.com/v1');
});
Reference in New Issue View Git Blame Copy Permalink