Files
CyberGril/web/tests/inbox.test.ts
T

188 lines
13 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { afterEach, describe, expect, it, vi } from 'vitest';
import { arrivals, fetchAfter, initialSeen, newestId, seenThrough, startAt, storeSeen, storedSeen, unreadOf, type InboxCursor } from '../src/adapters/inbox';
import { loadMessages, type ServerMessage } from '../src/adapters/real';
import type { Message } from '../src/domain/model';
// An isolated copy of the persisted-message contract (api/app.py GET /api/messages + life/public.py message()):
// newest first by id, limit+1 probe, rows returned oldest-first, next_before = oldest id on the page when more exist.
// No model, no embeddings, no network.
class Archive {
rows: ServerMessage[] = []; epoch = 1; calls: string[] = []; down = 0;
add(row: Partial<ServerMessage> & { role: ServerMessage['role'] }) { const id = this.rows.length + 1; this.rows.push({ id, text: `第${id}条`, turn_id: `t${id}`, status: 'sent', lifeIds: [], ...row } as ServerMessage); return id; }
reach(text = '窗外的雨停了,想跟你说一声。') { return this.add({ role: 'companion', text, proactive: true, turn_id: `reach-${this.rows.length + 1}` }); }
fetch = vi.fn(async (url: string) => {
this.calls.push(url);
if (this.down) { this.down--; throw new TypeError('Failed to fetch'); }
const u = new URL(url, 'http://x'), limit = Number(u.searchParams.get('limit') || 200), before = Number(u.searchParams.get('before') || Number.MAX_SAFE_INTEGER);
const desc = this.rows.filter(r => r.id < before).sort((a, b) => b.id - a.id).slice(0, limit + 1), more = desc.length > limit, page = desc.slice(0, limit);
return new Response(JSON.stringify({ messages: [...page].reverse(), next_before: more ? page[page.length - 1].id : null, epoch: this.epoch }));
});
}
function storage() { const data = new Map<string, string>(); vi.stubGlobal('localStorage', { getItem: (k: string) => data.has(k) ? data.get(k)! : null, setItem: (k: string, v: string) => void data.set(k, v) }); return data; }
const signal = () => new AbortController().signal;
// One poll the way RealApp runs it: read after the cursor, commit it only when the read succeeded, keep only what the
// page does not hold.
type Page = { messages: Message[]; cursor: InboxCursor };
async function poll(page: Page) {
const { rows, cursor } = await fetchAfter(page.cursor, signal());
page.cursor = cursor;
const add = arrivals(page.messages, rows); page.messages = [...page.messages, ...add];
return add;
}
// Polls again while a gap is open, as RealApp does a second later; returns everything that arrived, in order.
async function catchUp(page: Page, most = 50) {
const all: Message[] = [];
for (let i = 0; i < most; i++) { all.push(...await poll(page)); if (!page.cursor.gap) return all; }
throw new Error('never caught up');
}
const opened = (messages: Message[]): Page => ({ messages, cursor: startAt(newestId(messages)) });
afterEach(() => vi.unstubAllGlobals());
describe('reach-outs reaching an open page', () => {
it('adds a new reach-out once; repeated reads, a restarted epoch and a reconnect add nothing more', async () => {
const server = new Archive(); vi.stubGlobal('fetch', server.fetch);
server.add({ role: 'user', turn_id: 'a' }); server.add({ role: 'companion', turn_id: 'a' });
const page = opened(await loadMessages());
expect(await poll(page)).toEqual([]);
const id = server.reach();
const first = await poll(page);
expect(first.map(m => [m.id, m.proactive, m.role])).toEqual([[String(id), true, 'companion']]);
expect(await poll(page)).toEqual([]);
server.epoch = 2; expect(await poll(page)).toEqual([]);
server.down = 1; await expect(poll(page)).rejects.toThrow(); expect(await poll(page)).toEqual([]);
expect(page.messages.filter(m => m.id === String(id))).toHaveLength(1);
// Reopening reads the same record in the same order: nothing lost, nothing doubled.
expect((await loadMessages()).map(m => m.id)).toEqual(page.messages.map(m => m.id));
});
it('never re-adds your own turn or her reply to it, and ignores rows still being written', async () => {
const server = new Archive(); vi.stubGlobal('fetch', server.fetch);
// The page holds your message and her streamed reply under local ids; the server has them under row ids.
const page = opened([{ id: 'local-1', role: 'user', text: '在吗', lifeIds: [], turnId: 'turn-x', status: 'sent' }, { id: 'local-2', role: 'companion', text: '在', lifeIds: [], turnId: 'turn-x' }]);
server.add({ role: 'user', turn_id: 'turn-x', text: '在吗' }); server.add({ role: 'companion', turn_id: 'turn-x', text: '在' });
server.add({ role: 'user', turn_id: 'turn-y', status: 'pending' });
server.add({ role: 'companion', proactive: true, turn_id: 'turn-x' });
expect(await poll(page)).toEqual([]);
expect(page.cursor).toEqual(startAt(4));
});
it('pages back after a long absence and keeps the order of what arrived', async () => {
const server = new Archive(); vi.stubGlobal('fetch', server.fetch);
server.add({ role: 'user' });
const page = opened(await loadMessages());
const ids = [server.reach('一')]; for (let i = 0; i < 70; i++) server.add({ role: 'companion' }); ids.push(server.reach('二'));
const added = await poll(page);
expect(added.map(m => m.text)).toEqual(['一', '二']);
expect(added.map(m => m.id)).toEqual(ids.map(String));
expect(server.calls.filter(c => c.includes('limit=50'))).toHaveLength(2);
});
it('reads from an empty record without paging the whole history', async () => {
const server = new Archive(); vi.stubGlobal('fetch', server.fetch);
const page = opened([]);
server.reach();
expect(await poll(page)).toHaveLength(1);
expect(server.calls).toHaveLength(1);
});
});
// HEL-880: a sleeping tab can come back to more rows than one bounded read covers (5 pages × 50).
describe('catching up after a long absence', () => {
it('keeps the oldest reach-out when more than five pages arrived (HEL-875 review fixture)', async () => {
// Exactly the reviewer's case: the page holds id 1; id 2 is her reach-out; plain rows follow up to id 301.
const server = new Archive(); vi.stubGlobal('fetch', server.fetch);
server.add({ role: 'user' });
const page = opened(await loadMessages());
server.reach('最早的那句'); while (server.rows.length < 301) server.add({ role: 'companion' });
const first = await fetchAfter(page.cursor, signal());
expect(first.rows).toEqual([]);
expect(first.cursor).toMatchObject({ through: 1, gap: { before: 52, top: 301 } });
const second = await fetchAfter(first.cursor, signal());
expect(arrivals(page.messages, [...first.rows, ...second.rows]).map(m => m.id)).toEqual(['2']);
expect(second.cursor).toEqual(startAt(301));
});
it('more than 250 rows with reach-outs spread through them: each arrives once, in order, nothing skipped', async () => {
const server = new Archive(); vi.stubGlobal('fetch', server.fetch);
server.add({ role: 'user' });
const page = opened(await loadMessages()), ids: number[] = [];
for (let i = 0; i < 1200; i++) { if (i % 97 === 3) ids.push(server.reach(`第${i}句`)); else server.add({ role: i % 2 ? 'companion' : 'user' }); }
const added = await catchUp(page);
expect(added.map(m => m.id)).toEqual(ids.map(String));
expect(page.cursor).toEqual(startAt(server.rows.length));
expect(await poll(page)).toEqual([]);
expect(page.messages.filter(m => m.proactive)).toHaveLength(ids.length);
});
it('an empty page (cursor 0) facing more than 50 rows reads past the first page', async () => {
const server = new Archive(); vi.stubGlobal('fetch', server.fetch);
const page = opened([]);
const ids = [server.reach('一')]; for (let i = 0; i < 120; i++) server.add({ role: 'user' }); ids.push(server.reach('二'));
expect((await catchUp(page)).map(m => m.id)).toEqual(ids.map(String));
expect(server.calls).toHaveLength(3);
});
it('a read that fails mid-way commits nothing; the next one resumes from the same place', async () => {
const server = new Archive(); vi.stubGlobal('fetch', server.fetch);
server.add({ role: 'user' });
const page = opened(await loadMessages());
const ids = [server.reach('一')]; for (let i = 0; i < 400; i++) server.add({ role: 'user' }); ids.push(server.reach('二'));
expect(await poll(page)).toEqual([]);
const kept = structuredClone(page.cursor);
// Two pages succeed, the third fails: the call throws and the page keeps the cursor it had.
let left = 2; const ok = server.fetch.getMockImplementation()!;
server.fetch.mockImplementation(async (url: string) => { if (left-- <= 0) throw new TypeError('Failed to fetch'); return ok(url); });
await expect(poll(page)).rejects.toThrow();
expect(page.cursor).toEqual(kept);
server.fetch.mockImplementation(ok);
expect((await catchUp(page)).map(m => m.id)).toEqual(ids.map(String));
});
it('rows that arrive while it is catching up are read too, after the older ones, once', async () => {
const server = new Archive(); vi.stubGlobal('fetch', server.fetch);
server.add({ role: 'user' });
const page = opened(await loadMessages());
const ids = [server.reach('久别前')]; for (let i = 0; i < 600; i++) server.add({ role: 'companion' });
expect(await poll(page)).toEqual([]);
ids.push(server.reach('追读时新来的')); for (let i = 0; i < 300; i++) server.add({ role: 'user' }); ids.push(server.reach('最新的'));
const added = await catchUp(page);
expect(added.map(m => m.id)).toEqual(ids.map(String));
expect(page.cursor).toEqual(startAt(server.rows.length));
});
it('repeated reads and a restarted epoch during catch-up add nothing twice', async () => {
const server = new Archive(); vi.stubGlobal('fetch', server.fetch);
server.add({ role: 'user' });
const page = opened(await loadMessages());
const ids = [server.reach()]; for (let i = 0; i < 300; i++) server.add({ role: 'user' }); ids.push(server.reach());
const first = await fetchAfter(page.cursor, signal());
// The same cursor read twice (a retried poll) gives the same answer; the epoch changing does not matter.
server.epoch = 2;
const again = await fetchAfter(page.cursor, signal());
expect(again.cursor).toEqual(first.cursor);
page.cursor = first.cursor;
const added = await catchUp(page);
expect(arrivals(added, added)).toEqual([]);
expect(added.map(m => m.id)).toEqual(ids.map(String));
expect(await poll(page)).toEqual([]);
// A reach-out the page already holds (it came in through a reload) is not added again.
const record = await loadMessages(), page2: Page = { messages: [record[0], record.find(m => m.id === String(ids[1]))!], cursor: startAt(1) };
expect((await catchUp(page2)).map(m => m.id)).toEqual([String(ids[0])]);
});
});
describe('unread', () => {
it('first visit from this browser counts the old record as seen; later arrivals stay unread until seen', () => {
const data = storage();
const history: Message[] = [{ id: '3', role: 'companion', text: '旧的', lifeIds: [], proactive: true }, { id: '4', role: 'user', text: '嗯', lifeIds: [] }];
const seen = initialSeen(history);
expect(seen).toBe(3); expect(unreadOf(history, seen)).toEqual([]); expect(data.get('cg.real.seen')).toBe('3');
const later = [...history, { id: '9', role: 'companion' as const, text: '新的', lifeIds: [], proactive: true }];
expect(unreadOf(later, initialSeen(later)).map(m => m.id)).toEqual(['9']);
storeSeen(seenThrough(later)); expect(unreadOf(later, storedSeen()!)).toEqual([]);
});
it('an empty record on first visit leaves a zero mark, so her first reach-out is unread', () => {
storage();
expect(initialSeen([])).toBe(0);
expect(unreadOf([{ id: '1', role: 'companion', text: '你好', lifeIds: [], proactive: true }], initialSeen([]))).toHaveLength(1);
});
it('a damaged or unavailable mark falls back to treating the record as history', () => {
vi.stubGlobal('localStorage', { getItem: () => 'abc', setItem: () => {} });
expect(initialSeen([{ id: '5', role: 'companion', text: 'x', lifeIds: [], proactive: true }])).toBe(5);
vi.stubGlobal('localStorage', { getItem: () => { throw new Error('denied'); }, setItem: () => { throw new Error('denied'); } });
expect(initialSeen([{ id: '6', role: 'companion', text: 'x', lifeIds: [], proactive: true }])).toBe(6);
});
});