459 lines
16 KiB
TypeScript
459 lines
16 KiB
TypeScript
|
import { beforeEach, describe, expect, mock, test } from 'bun:test';
|
||
|
|
|
||
|
|
interface NotePayload {
|
||
|
|
id: string;
|
||
|
|
body: string;
|
||
|
|
createdAt: number;
|
||
|
|
updatedAt: number;
|
||
|
|
source: 'manual' | 'selection' | 'agent';
|
||
|
|
pinned: boolean;
|
||
|
|
}
|
||
|
|
|
||
|
|
interface ContextPayload {
|
||
|
|
notes: NotePayload[];
|
||
|
|
todos: { id: string; text: string; completed: boolean; createdAt: number }[];
|
||
|
|
plans: { id: string; file: string; title: string; createdAt: number; pinned: boolean }[];
|
||
|
|
}
|
||
|
|
|
||
|
|
const emptyPayload = (): ContextPayload => ({ notes: [], todos: [], plans: [] });
|
||
|
|
|
||
|
|
const note = (overrides: Partial<NotePayload> = {}): NotePayload => ({
|
||
|
|
id: 'n1',
|
||
|
|
body: 'body',
|
||
|
|
createdAt: 1,
|
||
|
|
updatedAt: 1,
|
||
|
|
source: 'manual',
|
||
|
|
pinned: false,
|
||
|
|
...overrides,
|
||
|
|
});
|
||
|
|
|
||
|
|
const planLink = (overrides: Partial<ContextPayload['plans'][number]> = {}) => ({
|
||
|
|
id: 'p1',
|
||
|
|
file: 'a.md',
|
||
|
|
title: 'A',
|
||
|
|
createdAt: 1,
|
||
|
|
pinned: false,
|
||
|
|
...overrides,
|
||
|
|
});
|
||
|
|
|
||
|
|
// The UI tsconfig does not load bun's test globals, so these tests follow the
|
||
|
|
// local precedent of swapping plain handlers instead of using mock helpers.
|
||
|
|
const handlers = {
|
||
|
|
fetch: async (): Promise<ContextPayload> => emptyPayload(),
|
||
|
|
saveTodos: async (todos: ContextPayload['todos']): Promise<ContextPayload> => ({
|
||
|
|
notes: [],
|
||
|
|
todos,
|
||
|
|
plans: [],
|
||
|
|
}),
|
||
|
|
createNote: async (): Promise<{ note: NotePayload; context: ContextPayload }> => ({
|
||
|
|
note: note(),
|
||
|
|
context: { notes: [note()], todos: [], plans: [] },
|
||
|
|
}),
|
||
|
|
updateNote: async (): Promise<NotePayload | null> => note(),
|
||
|
|
deleteNote: async (): Promise<ContextPayload> => emptyPayload(),
|
||
|
|
create: async (): Promise<{ plan: ContextPayload['plans'][number]; context: ContextPayload }> => ({
|
||
|
|
plan: planLink(),
|
||
|
|
context: { notes: [], todos: [], plans: [planLink()] },
|
||
|
|
}),
|
||
|
|
update: async (): Promise<{ plan: ContextPayload['plans'][number]; raw: string } | null> => ({
|
||
|
|
plan: planLink(),
|
||
|
|
raw: '# A',
|
||
|
|
}),
|
||
|
|
pinPlan: async (): Promise<ContextPayload['plans'][number] | null> => planLink({ pinned: true }),
|
||
|
|
remove: async (): Promise<ContextPayload> => emptyPayload(),
|
||
|
|
};
|
||
|
|
|
||
|
|
const calls = { fetch: 0, saveTodos: 0, createNote: 0, updateNote: 0, deleteNote: 0, create: 0, update: 0, pinPlan: 0, remove: 0 };
|
||
|
|
|
||
|
|
mock.module('@/lib/projectContextApi', () => ({
|
||
|
|
fetchProjectContext: () => {
|
||
|
|
calls.fetch += 1;
|
||
|
|
return handlers.fetch();
|
||
|
|
},
|
||
|
|
saveProjectTodos: (_project: unknown, todos: ContextPayload['todos']) => {
|
||
|
|
calls.saveTodos += 1;
|
||
|
|
return handlers.saveTodos(todos);
|
||
|
|
},
|
||
|
|
createProjectNote: () => {
|
||
|
|
calls.createNote += 1;
|
||
|
|
return handlers.createNote();
|
||
|
|
},
|
||
|
|
updateProjectNote: () => {
|
||
|
|
calls.updateNote += 1;
|
||
|
|
return handlers.updateNote();
|
||
|
|
},
|
||
|
|
deleteProjectNote: () => {
|
||
|
|
calls.deleteNote += 1;
|
||
|
|
return handlers.deleteNote();
|
||
|
|
},
|
||
|
|
setProjectPlanPinned: () => {
|
||
|
|
calls.pinPlan += 1;
|
||
|
|
return handlers.pinPlan();
|
||
|
|
},
|
||
|
|
createProjectPlan: () => {
|
||
|
|
calls.create += 1;
|
||
|
|
return handlers.create();
|
||
|
|
},
|
||
|
|
updateProjectPlan: () => {
|
||
|
|
calls.update += 1;
|
||
|
|
return handlers.update();
|
||
|
|
},
|
||
|
|
deleteProjectPlan: () => {
|
||
|
|
calls.remove += 1;
|
||
|
|
return handlers.remove();
|
||
|
|
},
|
||
|
|
resolveProjectContextId: (project: { path?: string } | null | undefined) => (
|
||
|
|
project?.path ? `path_${project.path}` : ''
|
||
|
|
),
|
||
|
|
}));
|
||
|
|
|
||
|
|
const { useProjectContextStore } = await import('./useProjectContextStore');
|
||
|
|
|
||
|
|
const PROJECT = { id: 'ignored', path: '/repo' };
|
||
|
|
const store = () => useProjectContextStore.getState();
|
||
|
|
const entry = () => store().getEntry(PROJECT);
|
||
|
|
|
||
|
|
const deferred = <T>() => {
|
||
|
|
let resolve!: (value: T) => void;
|
||
|
|
const promise = new Promise<T>((res) => { resolve = res; });
|
||
|
|
return { promise, resolve };
|
||
|
|
};
|
||
|
|
|
||
|
|
const failWith = (message: string) => async (): Promise<never> => {
|
||
|
|
throw new Error(message);
|
||
|
|
};
|
||
|
|
|
||
|
|
beforeEach(() => {
|
||
|
|
store().reset();
|
||
|
|
calls.fetch = 0;
|
||
|
|
calls.saveTodos = 0;
|
||
|
|
calls.createNote = 0;
|
||
|
|
calls.updateNote = 0;
|
||
|
|
calls.deleteNote = 0;
|
||
|
|
calls.create = 0;
|
||
|
|
calls.update = 0;
|
||
|
|
calls.pinPlan = 0;
|
||
|
|
calls.remove = 0;
|
||
|
|
|
||
|
|
handlers.fetch = async () => emptyPayload();
|
||
|
|
handlers.saveTodos = async (todos) => ({ notes: [], todos, plans: [] });
|
||
|
|
handlers.createNote = async () => ({ note: note(), context: { notes: [note()], todos: [], plans: [] } });
|
||
|
|
handlers.updateNote = async () => note();
|
||
|
|
handlers.deleteNote = async () => emptyPayload();
|
||
|
|
handlers.create = async () => ({ plan: planLink(), context: { notes: [], todos: [], plans: [planLink()] } });
|
||
|
|
handlers.update = async () => ({ plan: planLink(), raw: '# A' });
|
||
|
|
handlers.pinPlan = async () => planLink({ pinned: true });
|
||
|
|
handlers.remove = async () => emptyPayload();
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('getEntry', () => {
|
||
|
|
test('returns a stable empty entry for an unknown project', () => {
|
||
|
|
expect(entry()).toEqual({ notes: [], todos: [], plans: [], loaded: false, loading: false, error: null });
|
||
|
|
});
|
||
|
|
|
||
|
|
test('returns the empty entry for a project without a path', () => {
|
||
|
|
expect(store().getEntry({ id: 'x', path: '' }).loaded).toBe(false);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('load', () => {
|
||
|
|
test('populates from the server', async () => {
|
||
|
|
handlers.fetch = async () => ({
|
||
|
|
notes: [note({ body: 'server note' })],
|
||
|
|
todos: [{ id: 't1', text: 'a', completed: false, createdAt: 1 }],
|
||
|
|
plans: [planLink()],
|
||
|
|
});
|
||
|
|
|
||
|
|
await store().load(PROJECT);
|
||
|
|
|
||
|
|
expect(entry().notes.map((entryNote) => entryNote.body)).toEqual(['server note']);
|
||
|
|
expect(entry().todos).toHaveLength(1);
|
||
|
|
expect(entry().plans).toHaveLength(1);
|
||
|
|
expect(entry().loaded).toBe(true);
|
||
|
|
expect(entry().error).toBeNull();
|
||
|
|
});
|
||
|
|
|
||
|
|
test('does not refetch once loaded', async () => {
|
||
|
|
await store().load(PROJECT);
|
||
|
|
await store().load(PROJECT);
|
||
|
|
expect(calls.fetch).toBe(1);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('refetches when forced', async () => {
|
||
|
|
await store().load(PROJECT);
|
||
|
|
await store().load(PROJECT, { force: true });
|
||
|
|
expect(calls.fetch).toBe(2);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('a failed load preserves previously loaded data instead of clearing it', async () => {
|
||
|
|
handlers.fetch = async () => ({ notes: [note({ body: 'kept' })], todos: [], plans: [] });
|
||
|
|
await store().load(PROJECT);
|
||
|
|
|
||
|
|
handlers.fetch = failWith('offline');
|
||
|
|
await store().load(PROJECT, { force: true });
|
||
|
|
|
||
|
|
expect(entry().notes.map((entryNote) => entryNote.body)).toEqual(['kept']);
|
||
|
|
expect(entry().loaded).toBe(true);
|
||
|
|
expect(entry().error).toBe('offline');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('a first-load failure reports the error and stays unloaded', async () => {
|
||
|
|
handlers.fetch = failWith('boom');
|
||
|
|
|
||
|
|
await store().load(PROJECT);
|
||
|
|
|
||
|
|
expect(entry().loaded).toBe(false);
|
||
|
|
expect(entry().notes).toEqual([]);
|
||
|
|
expect(entry().error).toBe('boom');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('concurrent loads issue a single request', async () => {
|
||
|
|
await Promise.all([store().load(PROJECT), store().load(PROJECT), store().load(PROJECT)]);
|
||
|
|
expect(calls.fetch).toBe(1);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('saveTodos', () => {
|
||
|
|
test('applies optimistically before the request resolves', async () => {
|
||
|
|
const gate = deferred<ContextPayload>();
|
||
|
|
handlers.saveTodos = () => gate.promise;
|
||
|
|
|
||
|
|
const pending = store().saveTodos(PROJECT, [{ id: 't1', text: 'typed', completed: false, createdAt: 1 }]);
|
||
|
|
expect(entry().todos).toHaveLength(1);
|
||
|
|
|
||
|
|
gate.resolve({ notes: [], todos: [{ id: 't1', text: 'typed', completed: false, createdAt: 1 }], plans: [] });
|
||
|
|
expect(await pending).toBe(true);
|
||
|
|
expect(entry().todos).toHaveLength(1);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('rolls back and reports the error on failure', async () => {
|
||
|
|
await store().saveTodos(PROJECT, [{ id: 't1', text: 'original', completed: false, createdAt: 1 }]);
|
||
|
|
handlers.saveTodos = failWith('disk full');
|
||
|
|
|
||
|
|
expect(await store().saveTodos(PROJECT, [])).toBe(false);
|
||
|
|
expect(entry().todos.map((todo) => todo.text)).toEqual(['original']);
|
||
|
|
expect(entry().error).toBe('disk full');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('serializes concurrent writes in call order', async () => {
|
||
|
|
const order: string[] = [];
|
||
|
|
handlers.saveTodos = async (todos) => {
|
||
|
|
const label = todos[0]?.text ?? 'empty';
|
||
|
|
order.push(`start:${label}`);
|
||
|
|
await new Promise((resolve) => setTimeout(resolve, 5));
|
||
|
|
order.push(`end:${label}`);
|
||
|
|
return { notes: [], todos, plans: [] };
|
||
|
|
};
|
||
|
|
|
||
|
|
await Promise.all([
|
||
|
|
store().saveTodos(PROJECT, [{ id: '1', text: 'first', completed: false, createdAt: 1 }]),
|
||
|
|
store().saveTodos(PROJECT, [{ id: '2', text: 'second', completed: false, createdAt: 2 }]),
|
||
|
|
]);
|
||
|
|
|
||
|
|
expect(order).toEqual(['start:first', 'end:first', 'start:second', 'end:second']);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('a load resolving during an in-flight write does not clobber it', async () => {
|
||
|
|
const gate = deferred<ContextPayload>();
|
||
|
|
handlers.saveTodos = () => gate.promise;
|
||
|
|
handlers.fetch = async () => ({
|
||
|
|
notes: [note({ body: 'from server' })],
|
||
|
|
todos: [{ id: 'stale', text: 'stale', completed: false, createdAt: 0 }],
|
||
|
|
plans: [],
|
||
|
|
});
|
||
|
|
|
||
|
|
const pending = store().saveTodos(PROJECT, [{ id: 'local', text: 'local', completed: false, createdAt: 1 }]);
|
||
|
|
await store().load(PROJECT);
|
||
|
|
|
||
|
|
expect(entry().todos.map((todo) => todo.id)).toEqual(['local']);
|
||
|
|
// The same snapshot still delivers the fields the write did not touch.
|
||
|
|
expect(entry().notes.map((entryNote) => entryNote.body)).toEqual(['from server']);
|
||
|
|
|
||
|
|
gate.resolve({ notes: [], todos: [{ id: 'local', text: 'local', completed: false, createdAt: 1 }], plans: [] });
|
||
|
|
await pending;
|
||
|
|
});
|
||
|
|
|
||
|
|
test('ignores a project without a resolvable path', async () => {
|
||
|
|
expect(await store().saveTodos({ id: 'x', path: '' }, [])).toBe(false);
|
||
|
|
expect(calls.saveTodos).toBe(0);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('notes', () => {
|
||
|
|
test('createNote adopts the committed list', async () => {
|
||
|
|
handlers.createNote = async () => ({
|
||
|
|
note: note({ id: 'n9', body: 'fresh' }),
|
||
|
|
context: { notes: [note({ id: 'n9', body: 'fresh' })], todos: [], plans: [] },
|
||
|
|
});
|
||
|
|
|
||
|
|
const created = await store().createNote(PROJECT, { body: 'fresh' });
|
||
|
|
expect(created?.id).toBe('n9');
|
||
|
|
expect(entry().notes.map((entryNote) => entryNote.id)).toEqual(['n9']);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('createNote refuses a whitespace-only body without calling the server', async () => {
|
||
|
|
expect(await store().createNote(PROJECT, { body: ' ' })).toBeNull();
|
||
|
|
expect(calls.createNote).toBe(0);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('createNote reports failure without inserting a placeholder row', async () => {
|
||
|
|
handlers.createNote = failWith('no space');
|
||
|
|
|
||
|
|
expect(await store().createNote(PROJECT, { body: 'x' })).toBeNull();
|
||
|
|
expect(entry().notes).toEqual([]);
|
||
|
|
expect(entry().error).toBe('no space');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('saveNoteBody applies optimistically and commits the server copy', async () => {
|
||
|
|
await store().createNote(PROJECT, { body: 'before' });
|
||
|
|
handlers.updateNote = async () => note({ body: 'after', updatedAt: 9 });
|
||
|
|
|
||
|
|
expect(await store().saveNoteBody(PROJECT, 'n1', 'after')).toBe(true);
|
||
|
|
expect(entry().notes[0].body).toBe('after');
|
||
|
|
expect(entry().notes[0].updatedAt).toBe(9);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('saveNoteBody rolls back on failure', async () => {
|
||
|
|
await store().createNote(PROJECT, { body: 'before' });
|
||
|
|
handlers.updateNote = failWith('read only');
|
||
|
|
|
||
|
|
expect(await store().saveNoteBody(PROJECT, 'n1', 'after')).toBe(false);
|
||
|
|
expect(entry().notes[0].body).toBe('body');
|
||
|
|
expect(entry().error).toBe('read only');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('saveNoteBody drops a note the server reports as gone', async () => {
|
||
|
|
await store().createNote(PROJECT, { body: 'before' });
|
||
|
|
handlers.updateNote = async () => null;
|
||
|
|
|
||
|
|
expect(await store().saveNoteBody(PROJECT, 'n1', 'after')).toBe(false);
|
||
|
|
expect(entry().notes).toEqual([]);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('setNotePinned applies optimistically', async () => {
|
||
|
|
await store().createNote(PROJECT, { body: 'x' });
|
||
|
|
const gate = deferred<NotePayload | null>();
|
||
|
|
handlers.updateNote = () => gate.promise;
|
||
|
|
|
||
|
|
const pending = store().setNotePinned(PROJECT, 'n1', true);
|
||
|
|
expect(entry().notes[0].pinned).toBe(true);
|
||
|
|
|
||
|
|
gate.resolve(note({ pinned: true }));
|
||
|
|
expect(await pending).toBe(true);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('setNotePinned rolls back on failure', async () => {
|
||
|
|
await store().createNote(PROJECT, { body: 'x' });
|
||
|
|
handlers.updateNote = failWith('locked');
|
||
|
|
|
||
|
|
expect(await store().setNotePinned(PROJECT, 'n1', true)).toBe(false);
|
||
|
|
expect(entry().notes[0].pinned).toBe(false);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('deleteNote removes optimistically and restores on failure', async () => {
|
||
|
|
await store().createNote(PROJECT, { body: 'x' });
|
||
|
|
handlers.deleteNote = failWith('busy');
|
||
|
|
|
||
|
|
expect(await store().deleteNote(PROJECT, 'n1')).toBe(false);
|
||
|
|
expect(entry().notes.map((entryNote) => entryNote.id)).toEqual(['n1']);
|
||
|
|
expect(entry().error).toBe('busy');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('deleteNote commits the server list on success', async () => {
|
||
|
|
await store().createNote(PROJECT, { body: 'x' });
|
||
|
|
|
||
|
|
expect(await store().deleteNote(PROJECT, 'n1')).toBe(true);
|
||
|
|
expect(entry().notes).toEqual([]);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('plans', () => {
|
||
|
|
test('createPlan commits the server context', async () => {
|
||
|
|
const plan = await store().createPlan(PROJECT, { title: 'A', body: 'x' });
|
||
|
|
|
||
|
|
expect(plan?.id).toBe('p1');
|
||
|
|
expect(entry().plans.map((item) => item.id)).toEqual(['p1']);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('createPlan reports failure without inserting a placeholder row', async () => {
|
||
|
|
handlers.create = failWith('no space');
|
||
|
|
|
||
|
|
expect(await store().createPlan(PROJECT, { title: 'A', body: 'x' })).toBeNull();
|
||
|
|
expect(entry().plans).toEqual([]);
|
||
|
|
expect(entry().error).toBe('no space');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('deletePlan removes optimistically', async () => {
|
||
|
|
await store().createPlan(PROJECT, { title: 'A', body: 'x' });
|
||
|
|
|
||
|
|
const gate = deferred<ContextPayload>();
|
||
|
|
handlers.remove = () => gate.promise;
|
||
|
|
|
||
|
|
const pending = store().deletePlan(PROJECT, 'p1');
|
||
|
|
expect(entry().plans).toEqual([]);
|
||
|
|
|
||
|
|
gate.resolve(emptyPayload());
|
||
|
|
expect(await pending).toBe(true);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('savePlan folds the refreshed title back into the list', async () => {
|
||
|
|
await store().createPlan(PROJECT, { title: 'A', body: 'x' });
|
||
|
|
handlers.update = async () => ({ plan: planLink({ title: 'Renamed' }), raw: '# Renamed' });
|
||
|
|
|
||
|
|
expect(await store().savePlan(PROJECT, 'p1', '# Renamed')).toBe(true);
|
||
|
|
expect(entry().plans[0].title).toBe('Renamed');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('savePlan drops a plan the server reports as gone', async () => {
|
||
|
|
await store().createPlan(PROJECT, { title: 'A', body: 'x' });
|
||
|
|
handlers.update = async () => null;
|
||
|
|
|
||
|
|
expect(await store().savePlan(PROJECT, 'p1', '# X')).toBe(false);
|
||
|
|
expect(entry().plans).toEqual([]);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('savePlan keeps the row and reports the error when the request fails', async () => {
|
||
|
|
await store().createPlan(PROJECT, { title: 'A', body: 'x' });
|
||
|
|
handlers.update = failWith('read only');
|
||
|
|
|
||
|
|
expect(await store().savePlan(PROJECT, 'p1', '# X')).toBe(false);
|
||
|
|
expect(entry().plans.map((item) => item.id)).toEqual(['p1']);
|
||
|
|
expect(entry().error).toBe('read only');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('setPlanPinned applies optimistically and rolls back on failure', async () => {
|
||
|
|
await store().createPlan(PROJECT, { title: 'A', body: 'x' });
|
||
|
|
handlers.pinPlan = failWith('locked');
|
||
|
|
|
||
|
|
expect(await store().setPlanPinned(PROJECT, 'p1', true)).toBe(false);
|
||
|
|
expect(entry().plans[0].pinned).toBe(false);
|
||
|
|
expect(entry().error).toBe('locked');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('setPlanPinned commits the server copy', async () => {
|
||
|
|
await store().createPlan(PROJECT, { title: 'A', body: 'x' });
|
||
|
|
|
||
|
|
expect(await store().setPlanPinned(PROJECT, 'p1', true)).toBe(true);
|
||
|
|
expect(entry().plans[0].pinned).toBe(true);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('deletePlan restores the row when the request fails', async () => {
|
||
|
|
await store().createPlan(PROJECT, { title: 'A', body: 'x' });
|
||
|
|
handlers.remove = failWith('locked');
|
||
|
|
|
||
|
|
expect(await store().deletePlan(PROJECT, 'p1')).toBe(false);
|
||
|
|
expect(entry().plans.map((item) => item.id)).toEqual(['p1']);
|
||
|
|
expect(entry().error).toBe('locked');
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('reset', () => {
|
||
|
|
test('drops every cached project', async () => {
|
||
|
|
await store().load(PROJECT);
|
||
|
|
expect(entry().loaded).toBe(true);
|
||
|
|
|
||
|
|
store().reset();
|
||
|
|
expect(entry().loaded).toBe(false);
|
||
|
|
});
|
||
|
|
});
|