Skip to content

Spot it. Save it. Free, local-first Chrome extension for images, videos and prompts. Explore 2,000+ curated cases and connect your library to AI Agents via MCP. 提示词导演

8.8 KB
Raw Blame
import test from 'node:test';
import assert from 'node:assert/strict';
import { createCaptureSaveTasks, rebaseCaptureEntries } from '../extension/capture-save-tasks.js';

function fixture(execute) {
  const data = {}, responses = new Map(), events = [];
  const storage = { async get(keys) { return Object.fromEntries(keys.map(key => [key, structuredClone(data[key])])); },
    async set(values) { Object.assign(data, structuredClone(values)); }, async remove(keys) { for (const key of keys) delete data[key]; } };
  const openCache = async () => ({ async match(key) { return responses.get(key)?.clone(); },
    async put(key, value) { responses.set(key, value.clone()); }, async delete(key) { return responses.delete(key); } });
  const create = run => createCaptureSaveTasks({ storage, execute: run, notify: event => events.push(event), openCache });
  return { create, tasks: create(execute), data, responses, events };
}
const aborted = signal => new Promise((_, reject) => signal.addEventListener('abort', () => reject(signal.reason), { once: true }));
const input = { type: 'COMMIT_PAGE_CAPTURE', saveRequestId: 'task-a', batch: { candidates: [{ id: 'original', contentText: '完整原词' }] } };

test('first-time component setup keeps the exact selection, metadata and downloaded originals through restart and auto-resume', async () => {
  let installed = false, downloads = 0, saves = 0;
  const execute = async (request, progress) => {
    const blob = await progress.media('complete-original', () => { downloads++; return new Blob(['original']); });
    assert.equal(await blob.text(), 'original');
    if (!installed) throw Object.assign(new Error('install required'), { code: 'video_component_required' });
    assert.deepEqual(request.batch, input.batch); assert.equal(request.collectionId, 'chosen-project');
    saves++; return { ok: true };
  };
  const f = fixture(execute);
  assert.equal((await f.tasks.run({ ...input, collectionId: 'chosen-project' })).code, 'video_component_required');
  assert.equal((await f.tasks.get()).status, 'waiting-component');
  const restarted = f.create(execute); installed = true;
  assert.equal((await restarted.get()).status, 'waiting-component');
  assert.equal(await restarted.resumeVideo(), true);
  for (let i = 0; i < 30 && (await restarted.get()).status !== 'completed'; i++) await new Promise(setImmediate);
  assert.equal((await restarted.get()).status, 'completed'); assert.equal(downloads, 1); assert.equal(saves, 1);
  assert.equal(await restarted.resumeVideo(), false);
});

test('explicitly cancelling component wait preserves the capture and prevents installation from saving it later', async () => {
  const f = fixture(async () => { throw Object.assign(new Error('install required'), { code: 'video_component_required' }); });
  await f.tasks.run(input); assert.equal((await f.tasks.cancel(input.saveRequestId)).ok, true);
  assert.equal((await f.tasks.get()).status, 'cancelled');
  assert.deepEqual((await f.tasks.get()).input.batch, input.batch);
  assert.equal(await f.tasks.resumeVideo(), false);
});

test('closing the UI leaves a durable save whose next UI can read and cancel it without a write queue wait', async () => {
  let started;
  const began = new Promise(resolve => { started = resolve; });
  const f = fixture(async (_input, progress) => { progress.stage('download'); started(); await aborted(progress.signal); });
  assert.equal((await f.tasks.start(input)).id, input.saveRequestId); await began;
  const task = await f.tasks.get();
  assert.equal(task.status, 'running'); assert.equal(task.input.batch.candidates[0].contentText, '完整原词');
  assert.equal((await f.tasks.cancel(task.id)).ok, true);
  for (let i = 0; i < 20 && (await f.tasks.get()).status !== 'cancelled'; i++) await new Promise(setImmediate);
  assert.equal((await f.tasks.get()).status, 'cancelled');
  assert.equal((await f.tasks.get()).input.batch.candidates.length, 1);
});

test('worker restart retains completed file bytes and an interrupted task; continue does not download that file twice', async () => {
  let checkpointed;
  const prepared = new Promise(resolve => { checkpointed = resolve; });
  const f = fixture(async (_input, progress) => {
    await progress.media('file', async () => new Blob(['original pixels'], { type: 'video/mp4' }));
    checkpointed(); await new Promise(() => {});
  });
  await f.tasks.start(input); await prepared;
  const restarted = f.create(async (_input, progress) => {
    const blob = await progress.media('file', () => { throw new Error('completed original must not be fetched again'); });
    assert.equal(await blob.text(), 'original pixels');
    return { ok: true, results: [{ entryId: 'saved' }] };
  });
  assert.equal((await restarted.get()).status, 'interrupted');
  assert.equal((await restarted.run(input)).ok, true);
  await restarted.acknowledge(input.saveRequestId);
  assert.equal(await restarted.get(), null); assert.equal(f.responses.size, 0);
});

test('cancel cannot interrupt an atomic case commit or report a saved case as cancelled', async () => {
  let committed, finish;
  const committing = new Promise(resolve => { committed = resolve; });
  const waiting = new Promise(resolve => { finish = resolve; });
  const f = fixture(async (_input, progress) => { await progress.commit(); committed(); await waiting; return { ok: true }; });
  await f.tasks.start(input); await committing;
  assert.equal((await f.tasks.cancel(input.saveRequestId)).ok, false);
  finish(); for (let i = 0; i < 20 && (await f.tasks.get()).status !== 'completed'; i++) await new Promise(setImmediate);
  assert.equal((await f.tasks.get()).status, 'completed');
});

test('partial receipt keeps only pending captures for reopening instead of replaying completed ones', async () => {
  const f = fixture(async () => ({ ok: true })); await f.tasks.run(input);
  const pending = { candidates: [{ id: 'pending', contentText: '未完成原词' }] };
  await f.tasks.acknowledge(input.saveRequestId, pending);
  const task = await f.tasks.get(); assert.equal(task.status, 'pending');
  assert.deepEqual(task.input.batch, pending); assert.equal(task.result, null);
});

test('download commit preserves unrelated concurrent cases and rejects changes or deletion of an affected case', () => {
  const before = [{ id: 'old', text: 'source' }], ready = [...before, { id: 'new', text: 'captured' }];
  const latest = [{ id: 'old', text: 'edited' }, { id: 'user-new', text: 'user work' }];
  assert.deepEqual(rebaseCaptureEntries(before, ready, latest, ['new'], () => false), [...latest, ready[1]]);
  assert.throws(() => rebaseCaptureEntries(before, ready, latest, ['old'], () => false), /已变化/);
  assert.throws(() => rebaseCaptureEntries(before, ready, [], ['old'], () => false), /已变化/);
  assert.throws(() => rebaseCaptureEntries([], ready, latest, ['new'], () => true), /已变化/);
});

test('a new capture cannot silently replace the cancelled task original even when a UI reuses its ID', async () => {
  const original = { ...input, batch: { id: 'original-batch', candidates: [{ contentText: '原始资料' }] } };
  const f = fixture(async () => ({ ok: false, message: 'connection failed' }));
  await f.tasks.run(original);
  await assert.rejects(() => f.tasks.start({ ...original, batch: { id: 'different-batch' } }), /待保存内容/);
  assert.equal((await f.tasks.get()).input.batch.candidates[0].contentText, '原始资料');
});

test('explicit discard releases only the selected unfinished task and checkpoints, retaining saved cases and separate drafts', async () => {
  const f = fixture(async (_input, progress) => {
    await progress.media('original', async () => new Blob(['completed original']));
    return { ok: false, message: 'second download failed' };
  });
  f.data.entries = [{ id: 'saved', text: '已入库内容' }];
  f.data.captureDraft = { text: '另一个待保存草稿' };
  await f.tasks.run(input);
  assert.equal(f.responses.size, 1);
  await assert.rejects(f.tasks.discard('stale-task'), /已变化/);
  assert.equal((await f.tasks.get()).id, input.saveRequestId);
  await f.tasks.discard(input.saveRequestId);
  assert.equal(await f.tasks.get(), null);
  assert.equal(f.responses.size, 0);
  assert.deepEqual(f.data.entries, [{ id: 'saved', text: '已入库内容' }]);
  assert.deepEqual(f.data.captureDraft, { text: '另一个待保存草稿' });
  const next = { ...input, saveRequestId: 'next', batch: { id: 'next-batch' } };
  assert.equal((await f.tasks.start(next)).id, 'next');
});

test('a start queued before stale discard cannot have its durable input removed', async () => {
  const f = fixture(async () => new Promise(() => {}));
  const start = f.tasks.start(input);
  const discard = assert.rejects(f.tasks.discard(input.saveRequestId), /先取消保存/);
  await start; await discard;
  assert.equal((await f.tasks.get()).id, input.saveRequestId);
  assert.deepEqual((await f.tasks.get()).input.batch, input.batch);
});