xonecas.io
64875
Mc

mini-coder / commit a86e507

test: reduce implementation-coupled assertions

xonecas2026-04-08 a86e507a445b7528b0abe2e7162a841e7993669d parent a00378e

9 files changed

This diff is too big to show in full. The first 1000 lines are below, and every file is listed with its counts.

src/agent.test.ts+55−89
@@ -63,6 +63,38 @@ const ZERO_USAGE: Usage = {
6363 cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
6464 };
6565
66+function isEventType<TType extends AgentEvent["type"]>(
67+ event: AgentEvent,
68+ type: TType,
69+): event is Extract<AgentEvent, { type: TType }> {
70+ return event.type === type;
71+}
72+
73+function expectEvent<TType extends AgentEvent["type"]>(
74+ events: AgentEvent[],
75+ type: TType,
76+): Extract<AgentEvent, { type: TType }> {
77+ const event = events.find((candidate) => isEventType(candidate, type));
78+ if (!event) {
79+ throw new Error(`Expected a ${type} event`);
80+ }
81+ return event;
82+}
83+
84+function expectLastEvent<TType extends AgentEvent["type"]>(
85+ events: AgentEvent[],
86+ type: TType,
87+): Extract<AgentEvent, { type: TType }> {
88+ for (let index = events.length - 1; index >= 0; index -= 1) {
89+ const event = events[index];
90+ if (event && isEventType(event, type)) {
91+ return event;
92+ }
93+ }
94+
95+ throw new Error(`Expected a ${type} event`);
96+}
97+
6698 /** Built-in tool definitions for tests. */
6799 function builtinToolDefs(): Tool[] {
68100 return [shellTool, editTool];
@@ -324,13 +356,9 @@ describe("agent loop", () => {
324356 onEvent: (e) => events.push(e),
325357 });
326358
327- const textDeltas = events.filter((e) => e.type === "text_delta");
359+ const textDeltas = events.filter((event) => event.type === "text_delta");
328360 expect(textDeltas.length).toBeGreaterThan(0);
329- const lastTextDelta = textDeltas.at(-1);
330- expect(lastTextDelta).toBeDefined();
331- if (!lastTextDelta || lastTextDelta.type !== "text_delta") {
332- throw new Error("Expected a text delta event");
333- }
361+ const lastTextDelta = expectLastEvent(events, "text_delta");
334362 expect(lastTextDelta.content).toEqual([fauxText("Hello world")]);
335363
336364 const doneEvents = events.filter((e) => e.type === "done");
@@ -364,13 +392,11 @@ describe("agent loop", () => {
364392 onEvent: (e) => events.push(e),
365393 });
366394
367- const thinkingDeltas = events.filter((e) => e.type === "thinking_delta");
395+ const thinkingDeltas = events.filter(
396+ (event) => event.type === "thinking_delta",
397+ );
368398 expect(thinkingDeltas.length).toBeGreaterThan(0);
369- const lastThinkingDelta = thinkingDeltas.at(-1);
370- expect(lastThinkingDelta).toBeDefined();
371- if (!lastThinkingDelta || lastThinkingDelta.type !== "thinking_delta") {
372- throw new Error("Expected a thinking delta event");
373- }
399+ const lastThinkingDelta = expectLastEvent(events, "thinking_delta");
374400 expect(lastThinkingDelta.content).toEqual([
375401 fauxThinking("Need to inspect the failing test."),
376402 ]);
@@ -506,40 +532,11 @@ describe("agent loop", () => {
506532 onEvent: (event) => events.push(event),
507533 });
508534
509- const toolCallStart = events.find(
510- (event) => event.type === "toolcall_start",
511- );
512- const toolCallDelta = events.find(
513- (event) => event.type === "toolcall_delta",
514- );
515- const toolCallEnd = events.find((event) => event.type === "toolcall_end");
516- const assistantMessage = events.find(
517- (event) => event.type === "assistant_message",
518- );
519- const toolStart = events.find((event) => event.type === "tool_start");
520-
521- expect(toolCallStart).toBeDefined();
522- expect(toolCallDelta).toBeDefined();
523- expect(toolCallEnd).toBeDefined();
524- expect(assistantMessage).toBeDefined();
525- expect(toolStart).toBeDefined();
526-
527- if (
528- !toolCallStart ||
529- toolCallStart.type !== "toolcall_start" ||
530- !toolCallDelta ||
531- toolCallDelta.type !== "toolcall_delta" ||
532- !toolCallEnd ||
533- toolCallEnd.type !== "toolcall_end" ||
534- !assistantMessage ||
535- assistantMessage.type !== "assistant_message" ||
536- !toolStart ||
537- toolStart.type !== "tool_start"
538- ) {
539- throw new Error(
540- "Expected streamed tool-call, assistant-message, and tool-start events",
541- );
542- }
535+ const toolCallStart = expectEvent(events, "toolcall_start");
536+ const toolCallDelta = expectEvent(events, "toolcall_delta");
537+ const toolCallEnd = expectEvent(events, "toolcall_end");
538+ const assistantMessage = expectEvent(events, "assistant_message");
539+ const toolStart = expectEvent(events, "tool_start");
543540
544541 expect(toolCallStart.toolCallId).toBe("tool-1");
545542 expect(toolCallStart.name).toBe("shell");
@@ -853,24 +850,9 @@ describe("agent loop", () => {
853850 onEvent: (e) => events.push(e),
854851 });
855852
856- const toolStart = events.find((event) => event.type === "tool_start");
857- const toolDelta = events.find((event) => event.type === "tool_delta");
858- const toolEnd = events.find((event) => event.type === "tool_end");
859-
860- expect(toolStart).toBeDefined();
861- expect(toolDelta).toBeDefined();
862- expect(toolEnd).toBeDefined();
863-
864- if (
865- !toolStart ||
866- toolStart.type !== "tool_start" ||
867- !toolDelta ||
868- toolDelta.type !== "tool_delta" ||
869- !toolEnd ||
870- toolEnd.type !== "tool_end"
871- ) {
872- throw new Error("Expected tool start, delta, and end events");
873- }
853+ const toolStart = expectEvent(events, "tool_start");
854+ const toolDelta = expectEvent(events, "tool_delta");
855+ const toolEnd = expectEvent(events, "tool_end");
874856
875857 expect(toolDelta.toolCallId).toBe(toolStart.toolCallId);
876858 expect(toolEnd.toolCallId).toBe(toolStart.toolCallId);
@@ -1098,11 +1080,13 @@ describe("agent loop", () => {
10981080 // Should still complete — the error tool result lets the model self-correct
10991081 expect(result.messages.length).toBeGreaterThanOrEqual(4);
11001082 // The tool result should be an error
1101- const toolResult = result.messages.find((m) => m.role === "toolResult");
1102- expect(toolResult).toBeDefined();
1103- if (toolResult?.role === "toolResult") {
1104- expect(toolResult.isError).toBe(true);
1083+ const toolResult = result.messages.find(
1084+ (message) => message.role === "toolResult",
1085+ );
1086+ if (!toolResult || toolResult.role !== "toolResult") {
1087+ throw new Error("Expected tool result message");
11051088 }
1089+ expect(toolResult.isError).toBe(true);
11061090 });
11071091
11081092 test("converts thrown tool handler errors into error tool results", async () => {
@@ -1146,7 +1130,6 @@ describe("agent loop", () => {
11461130 const toolResult = result.messages.find(
11471131 (message) => message.role === "toolResult",
11481132 );
1149- expect(toolResult).toBeDefined();
11501133 if (!toolResult || toolResult.role !== "toolResult") {
11511134 throw new Error("Expected tool result message");
11521135 }
@@ -1155,26 +1138,9 @@ describe("agent loop", () => {
11551138 { type: "text", text: "Tool shell failed: kaboom" },
11561139 ]);
11571140
1158- const toolStart = events.find((event) => event.type === "tool_start");
1159- const toolEnd = events.find((event) => event.type === "tool_end");
1160- const toolResultEvent = events.find(
1161- (event) => event.type === "tool_result",
1162- );
1163-
1164- expect(toolStart).toBeDefined();
1165- expect(toolEnd).toBeDefined();
1166- expect(toolResultEvent).toBeDefined();
1167-
1168- if (
1169- !toolStart ||
1170- toolStart.type !== "tool_start" ||
1171- !toolEnd ||
1172- toolEnd.type !== "tool_end" ||
1173- !toolResultEvent ||
1174- toolResultEvent.type !== "tool_result"
1175- ) {
1176- throw new Error("Expected tool start/end/result events");
1177- }
1141+ const toolStart = expectEvent(events, "tool_start");
1142+ const toolEnd = expectEvent(events, "tool_end");
1143+ const toolResultEvent = expectEvent(events, "tool_result");
11781144
11791145 expect(toolEnd.result.isError).toBe(true);
11801146 expect(toolEnd.result.content).toEqual([
src/git.test.ts+33−27
@@ -25,6 +25,15 @@ afterEach(() => {
2525 rmSync(tmp, { recursive: true, force: true });
2626 });
2727
28+function expectGitState(
29+ state: Awaited<ReturnType<typeof getGitState>>,
30+): NonNullable<Awaited<ReturnType<typeof getGitState>>> {
31+ if (!state) {
32+ throw new Error("Expected a git state snapshot");
33+ }
34+ return state;
35+}
36+
2837 /** Run a git command in the temp directory. */
2938 async function git(args: string, cwd = tmp): Promise<string> {
3039 const proc = Bun.spawn(["git", ...args.split(" ")], {
@@ -64,37 +73,36 @@ describe("getGitState", () => {
6473
6574 test("detects repo root", async () => {
6675 await initRepo();
67- const state = await getGitState(tmp);
68- expect(state).not.toBeNull();
69- expect(state!.root).toBe(canonicalizePath(tmp));
76+ const state = expectGitState(await getGitState(tmp));
77+ expect(state.root).toBe(canonicalizePath(tmp));
7078 });
7179
7280 test("gets current branch name", async () => {
7381 await initRepo();
74- const state = await getGitState(tmp);
75- expect(state!.branch).toBeOneOf(["main", "master"]);
82+ const state = expectGitState(await getGitState(tmp));
83+ expect(state.branch).toBeOneOf(["main", "master"]);
7684 });
7785
7886 test("counts untracked files", async () => {
7987 await initRepo();
8088 writeFileSync(join(tmp, "new.txt"), "untracked");
81- const state = await getGitState(tmp);
82- expect(state!.untracked).toBe(1);
89+ const state = expectGitState(await getGitState(tmp));
90+ expect(state.untracked).toBe(1);
8391 });
8492
8593 test("counts modified files", async () => {
8694 await initRepo();
8795 writeFileSync(join(tmp, "README.md"), "modified\n");
88- const state = await getGitState(tmp);
89- expect(state!.modified).toBe(1);
96+ const state = expectGitState(await getGitState(tmp));
97+ expect(state.modified).toBe(1);
9098 });
9199
92100 test("counts staged files", async () => {
93101 await initRepo();
94102 writeFileSync(join(tmp, "README.md"), "staged\n");
95103 await git("add README.md");
96- const state = await getGitState(tmp);
97- expect(state!.staged).toBe(1);
104+ const state = expectGitState(await getGitState(tmp));
105+ expect(state.staged).toBe(1);
98106 });
99107
100108 test("counts mixed states correctly", async () => {
@@ -107,17 +115,17 @@ describe("getGitState", () => {
107115 // Add a modified (but not staged) file — modify README again after staging
108116 writeFileSync(join(tmp, "README.md"), "staged then modified\n");
109117
110- const state = await getGitState(tmp);
111- expect(state!.staged).toBe(1);
112- expect(state!.modified).toBe(1);
113- expect(state!.untracked).toBe(1);
118+ const state = expectGitState(await getGitState(tmp));
119+ expect(state.staged).toBe(1);
120+ expect(state.modified).toBe(1);
121+ expect(state.untracked).toBe(1);
114122 });
115123
116124 test("returns zero ahead/behind when no upstream", async () => {
117125 await initRepo();
118- const state = await getGitState(tmp);
119- expect(state!.ahead).toBe(0);
120- expect(state!.behind).toBe(0);
126+ const state = expectGitState(await getGitState(tmp));
127+ expect(state.ahead).toBe(0);
128+ expect(state.behind).toBe(0);
121129 });
122130
123131 test("detects ahead count relative to upstream", async () => {
@@ -138,9 +146,9 @@ describe("getGitState", () => {
138146 await git("add .", work);
139147 await git("commit -m second", work);
140148
141- const state = await getGitState(work);
142- expect(state!.ahead).toBe(1);
143- expect(state!.behind).toBe(0);
149+ const state = expectGitState(await getGitState(work));
150+ expect(state.ahead).toBe(1);
151+ expect(state.behind).toBe(0);
144152 });
145153
146154 test("works from a subdirectory", async () => {
@@ -148,9 +156,8 @@ describe("getGitState", () => {
148156 const sub = join(tmp, "src", "deep");
149157 mkdirSync(sub, { recursive: true });
150158
151- const state = await getGitState(sub);
152- expect(state).not.toBeNull();
153- expect(state!.root).toBe(canonicalizePath(tmp));
159+ const state = expectGitState(await getGitState(sub));
160+ expect(state.root).toBe(canonicalizePath(tmp));
154161 });
155162
156163 test("returns the canonical repo root when accessed through a symlink", async () => {
@@ -158,8 +165,7 @@ describe("getGitState", () => {
158165 mkdirSync(join(tmp, "src"), { recursive: true });
159166 symlinkSync(tmp, join(tmp, "alias"));
160167
161- const state = await getGitState(join(tmp, "alias", "src"));
162- expect(state).not.toBeNull();
163- expect(state!.root).toBe(canonicalizePath(tmp));
168+ const state = expectGitState(await getGitState(join(tmp, "alias", "src")));
169+ expect(state.root).toBe(canonicalizePath(tmp));
164170 });
165171 });
src/session.test.ts+27−24
@@ -77,41 +77,46 @@ function makeUiMessage(text: string) {
7777 return createUiMessage(text);
7878 }
7979
80+function loadSessionOrThrow(db: ReturnType<typeof openDatabase>, id: string) {
81+ const session = getSession(db, id);
82+ if (!session) {
83+ throw new Error(`Expected session ${id} to exist`);
84+ }
85+ return session;
86+}
87+
8088 // ---------------------------------------------------------------------------
8189 // Tests
8290 // ---------------------------------------------------------------------------
8391
8492 describe("session persistence", () => {
85- test("openDatabase returns a usable database", () => {
86- const db = openDatabase(":memory:");
87- expect(db).toBeDefined();
88- db.close();
89- });
90-
91- test("createSession inserts a session record", () => {
93+ test("createSession inserts a persisted session record with the requested fields", () => {
9294 const db = openDatabase(":memory:");
9395 const session = createSession(db, {
9496 cwd: "/tmp/test",
9597 model: "anthropic/claude-sonnet-4-20250514",
9698 effort: "medium",
9799 });
98- expect(session.id).toBeString();
99- expect(session.cwd).toBe("/tmp/test");
100- expect(session.model).toBe("anthropic/claude-sonnet-4-20250514");
101- expect(session.effort).toBe("medium");
102- expect(session.forkedFrom).toBeNull();
103- expect(session.createdAt).toBeNumber();
104- expect(session.updatedAt).toBe(session.createdAt);
100+
101+ const loaded = loadSessionOrThrow(db, session.id);
102+
103+ expect(session.id.length).toBeGreaterThan(0);
104+ expect(loaded).toEqual(session);
105+ expect(loaded.cwd).toBe("/tmp/test");
106+ expect(loaded.model).toBe("anthropic/claude-sonnet-4-20250514");
107+ expect(loaded.effort).toBe("medium");
108+ expect(loaded.forkedFrom).toBeNull();
109+ expect(loaded.createdAt).toBeGreaterThan(0);
110+ expect(loaded.updatedAt).toBe(loaded.createdAt);
105111 db.close();
106112 });
107113
108- test("getSession retrieves a session by id", () => {
114+ test("getSession retrieves the stored session for a known id", () => {
109115 const db = openDatabase(":memory:");
110116 const created = createSession(db, { cwd: "/tmp/test" });
111- const loaded = getSession(db, created.id);
112- expect(loaded).not.toBeNull();
113- expect(loaded?.id).toBe(created.id);
114- expect(loaded?.cwd).toBe("/tmp/test");
117+ const loaded = loadSessionOrThrow(db, created.id);
118+ expect(loaded.id).toBe(created.id);
119+ expect(loaded.cwd).toBe("/tmp/test");
115120 db.close();
116121 });
117122
@@ -244,19 +249,17 @@ describe("message persistence and turn numbering", () => {
244249 db.close();
245250 });
246251
247- test("appendMessage updates session updated_at", () => {
252+ test("appendMessage updates the persisted session timestamp", () => {
248253 const db = openDatabase(":memory:");
249254 const session = createSession(db, { cwd: "/tmp/test" });
250255 const before = session.updatedAt;
251256
252- // Small delay to ensure timestamp differs
253257 const msg = makeUser("hello");
254258 msg.timestamp = before + 100;
255259 appendMessage(db, session.id, msg);
256260
257- const updated = getSession(db, session.id);
258- expect(updated).not.toBeNull();
259- expect(updated?.updatedAt).toBeGreaterThanOrEqual(before);
261+ const updated = loadSessionOrThrow(db, session.id);
262+ expect(updated.updatedAt).toBeGreaterThanOrEqual(before);
260263 db.close();
261264 });
262265 });
src/ui.test.ts+83−288
@@ -23,7 +23,6 @@ import {
2323 } from "./session.ts";
2424 import { DEFAULT_SHOW_REASONING, DEFAULT_VERBOSE } from "./settings.ts";
2525 import { DEFAULT_THEME } from "./theme.ts";
26-import * as uiModule from "./ui.ts";
2726 import {
2827 buildConversationLog,
2928 createInputController,
@@ -49,20 +48,28 @@ function collectText(node: Node | null): string[] {
4948 return node.children.flatMap((child) => collectText(child));
5049 }
5150
52-function findNodeWithKeyPress(node: Node | null): ContainerNode | null {
53- if (!node || node.type === "textinput" || node.type === "text") {
54- return null;
51+function expectTextInput(node: Node): Extract<Node, { type: "textinput" }> {
52+ if (node.type !== "textinput") {
53+ throw new Error("Expected input area to render a TextInput");
5554 }
56- if (typeof node.props.onKeyPress === "function") {
57- return node;
58- }
59- for (const child of node.children) {
60- const found = findNodeWithKeyPress(child);
61- if (found) {
62- return found;
63- }
55+ return node;
56+}
57+
58+function expectVStack(node: Node): ContainerNode {
59+ if (node.type !== "vstack") {
60+ throw new Error("Expected app layout to be a vstack");
6461 }
65- return null;
62+ return node;
63+}
64+
65+function createDeferred<T = void>() {
66+ let resolve!: (value: T | PromiseLike<T>) => void;
67+ let reject!: (reason?: unknown) => void;
68+ const promise = new Promise<T>((resolvePromise, rejectPromise) => {
69+ resolve = resolvePromise;
70+ reject = rejectPromise;
71+ });
72+ return { promise, resolve, reject };
6673 }
6774
6875 const tempDirs: string[] = [];
@@ -126,7 +133,7 @@ async function waitFor(
126133 if (predicate()) {
127134 return;
128135 }
129- await Bun.sleep(10);
136+ await new Promise<void>((resolve) => setImmediate(resolve));
130137 }
131138 throw new Error("Timed out waiting for condition");
132139 }
@@ -147,20 +154,6 @@ async function stopRunningTurn(
147154 }
148155
149156 describe("ui rendering", () => {
150- test("ui.ts keeps command and render helpers private", () => {
151- const exports = Object.keys(uiModule);
152-
153- expect(exports).not.toContain("applyEffortSelection");
154- expect(exports).not.toContain("applyModelSelection");
155- expect(exports).not.toContain("buildHelpText");
156- expect(exports).not.toContain("formatPromptHistoryPreview");
157- expect(exports).not.toContain("formatRelativeDate");
158- expect(exports).not.toContain("previewToolRenderLines");
159- expect(exports).not.toContain("renderAssistantMessage");
160- expect(exports).not.toContain("renderStatusBar");
161- expect(exports).not.toContain("renderToolResult");
162- });
163-
164157 test("reasoning defaults on and verbose defaults off", () => {
165158 expect(DEFAULT_SHOW_REASONING).toBe(true);
166159 expect(DEFAULT_VERBOSE).toBe(false);
@@ -210,6 +203,7 @@ describe("ui rendering", () => {
210203 return message;
211204 };
212205
206+ const finishStream = createDeferred<void>();
213207 const buildProviderStream = () => {
214208 const stream = createAssistantMessageEventStream();
215209 const finalMessage = createFinalMessage();
@@ -246,14 +240,14 @@ describe("ui rendering", () => {
246240 ],
247241 },
248242 });
249- setTimeout(() => {
243+ void finishStream.promise.then(() => {
250244 stream.push({
251245 type: "done",
252246 reason: "stop",
253247 message: finalMessage,
254248 });
255249 stream.end(finalMessage);
256- }, 50);
250+ });
257251 });
258252
259253 return stream;
@@ -301,6 +295,7 @@ describe("ui rendering", () => {
301295 const streamedText = streamedLogText.join("\n");
302296 expect(streamedText).toBe("hello\nBefore\nThinking... 2 lines.\nAfter");
303297
298+ finishStream.resolve();
304299 await waitFor(() =>
305300 state.messages.some((message) => message.role === "assistant"),
306301 );
@@ -536,32 +531,31 @@ describe("ui rendering", () => {
536531 timestamp: Date.now(),
537532 });
538533
534+ const abortObserved = createDeferred<void>();
535+ const releaseAbort = createDeferred<void>();
539536 const buildProviderStream = (signal?: AbortSignal) => {
540537 const stream = createAssistantMessageEventStream();
541538
542539 queueMicrotask(() => {
543540 const emitAbort = () => {
544- const abortedMessage = buildAbortMessage();
545- stream.push({
546- type: "error",
547- reason: "aborted",
548- error: abortedMessage,
541+ abortObserved.resolve();
542+ void releaseAbort.promise.then(() => {
543+ const abortedMessage = buildAbortMessage();
544+ stream.push({
545+ type: "error",
546+ reason: "aborted",
547+ error: abortedMessage,
548+ });
549+ stream.end(abortedMessage);
549550 });
550- stream.end(abortedMessage);
551551 };
552552
553553 if (signal?.aborted) {
554- setTimeout(emitAbort, 50);
554+ emitAbort();
555555 return;
556556 }
557557
558- signal?.addEventListener(
559- "abort",
560- () => {
561- setTimeout(emitAbort, 50);
562- },
563- { once: true },
564- );
558+ signal?.addEventListener("abort", emitAbort, { once: true });
565559 });
566560
567561 return stream;
@@ -594,6 +588,10 @@ describe("ui rendering", () => {
594588
595589 handleInput("/undo", state);
596590
591+ await abortObserved.promise;
592+ expect(state.running).toBe(true);
593+
594+ releaseAbort.resolve();
597595 await waitFor(() => !state.running);
598596 await waitFor(() => state.messages.length === 0);
599597
@@ -735,76 +733,6 @@ describe("ui rendering", () => {
735733 }
736734 });
737735
738- test("/session resumes a stored session even when historical assistant usage is missing", () => {
739- const state = createTestState();
740- const now = Date.now();
741- const session = createSession(state.db, {
742- cwd: state.canonicalCwd,
743- model: "test/beta",
744- effort: "high",
745- });
746-
747- try {
748- state.db.run(
749- "INSERT INTO messages (session_id, turn, data, created_at) VALUES (?, ?, ?, ?)",
750- [
751- session.id,
752- 1,
753- JSON.stringify({
754- role: "user",
755- content: "historical prompt",
756- timestamp: now,
757- }),
758- now,
759- ],
760- );
761- state.db.run(
762- "INSERT INTO messages (session_id, turn, data, created_at) VALUES (?, ?, ?, ?)",
763- [
764- session.id,
765- 1,
766- JSON.stringify({
767- role: "assistant",
768- content: [{ type: "text", text: "historical reply" }],
769- api: "anthropic-messages",
770- provider: "anthropic",
771- model: "test/beta",
772- stopReason: "stop",
773- timestamp: now + 1,
774- }),
775- now + 1,
776- ],
777- );
778- state.db.run("UPDATE sessions SET updated_at = ? WHERE id = ?", [
779- now + 1,
780- session.id,
781- ]);
782-
783- handleInput("/session", state);
784-
785- const overlay = renderActiveOverlay(state);
786- const selectNode = findNodeWithKeyPress(overlay);
787-
788- expect(selectNode).not.toBeNull();
789- if (!selectNode) {
790- throw new Error("Expected overlay to contain a Select root");
791- }
792-
793- selectNode.props.onKeyPress?.("enter");
794-
795- expect(renderActiveOverlay(state)).toBeNull();
796- expect(state.session?.id).toBe(session.id);
797-
798- const layout = renderBaseLayout(state, 80, createInputController(state));
799- const text = collectText(layout);
800-
801- expect(text).toContain("historical prompt");
802- expect(text).toContain("historical reply");
803- } finally {
804- state.db.close();
805- }
806- });
807-
808736 test("/new clears the active session and defers replacement session creation", async () => {
809737 const faux = registerFauxProvider();
810738 const state = createTestState();
@@ -970,6 +898,7 @@ describe("ui rendering", () => {
970898 };
971899
972900 let callCount = 0;
901+ const finishFirstStream = createDeferred<void>();
973902 const finalToolCall = fauxToolCall(
974903 "shell",
975904 { command: "echo staged-command" },
@@ -1024,30 +953,26 @@ describe("ui rendering", () => {
1024953 contentIndex: 0,
1025954 partial: partialStart,
1026955 });
1027- setTimeout(() => {
956+ stream.push({
957+ type: "toolcall_delta",
958+ contentIndex: 0,
959+ delta: '{"command":"echo staged-command"}',
960+ partial: partialDelta,
961+ });
962+ stream.push({
963+ type: "toolcall_end",
964+ contentIndex: 0,
965+ toolCall: finalToolCall,
966+ partial: finalMessage,
967+ });
968+ void finishFirstStream.promise.then(() => {
1028969 stream.push({
1029- type: "toolcall_delta",
1030- contentIndex: 0,
1031- delta: '{"command":"echo staged-command"}',
1032- partial: partialDelta,
970+ type: "done",
971+ reason: "toolUse",
972+ message: finalMessage,
1033973 });
1034- setTimeout(() => {
1035- stream.push({
1036- type: "toolcall_end",
1037- contentIndex: 0,
1038- toolCall: finalToolCall,
1039- partial: finalMessage,
1040- });
1041- setTimeout(() => {
1042- stream.push({
1043- type: "done",
1044- reason: "toolUse",
1045- message: finalMessage,
1046- });
1047- stream.end(finalMessage);
1048- }, 150);
1049- }, 30);
1050- }, 30);
974+ stream.end(finalMessage);
975+ });
1051976 });
1052977
1053978 return stream;
@@ -1102,6 +1027,9 @@ describe("ui rendering", () => {
11021027 logText.filter((line) => line === "$ echo staged-command"),
11031028 ).toHaveLength(1);
11041029 expect(logText).not.toContain("Preparing...");
1030+
1031+ finishFirstStream.resolve();
1032+ await waitFor(() => !state.running);
11051033 } finally {
11061034 await stopRunningTurn(state);
11071035 unregisterApiProviders(sourceId);
@@ -1126,6 +1054,7 @@ describe("ui rendering", () => {
11261054 };
11271055
11281056 let callCount = 0;
1057+ const finishSecondStream = createDeferred<void>();
11291058 const buildProviderStream = () => {
11301059 callCount += 1;
11311060 const stream = createAssistantMessageEventStream();
@@ -1199,14 +1128,14 @@ describe("ui rendering", () => {
11991128 delta: "Done streaming",
12001129 partial,
12011130 });
1202- setTimeout(() => {
1131+ void finishSecondStream.promise.then(() => {
12031132 stream.push({
12041133 type: "done",
12051134 reason: "stop",
12061135 message: finalMessage,
12071136 });
12081137 stream.end(finalMessage);
1209- }, 200);
1138+ });
12101139 });
12111140
12121141 return stream;
@@ -1258,6 +1187,9 @@ describe("ui rendering", () => {
12581187 expect(logText).not.toContain("Exit code: 0");
12591188 expect(logText).not.toContain("Preparing...");
12601189 expect(logText).not.toContain("Running...");
1190+
1191+ finishSecondStream.resolve();
1192+ await waitFor(() => !state.running);
12611193 } finally {
12621194 await stopRunningTurn(state);
12631195 process.env.PATH = originalPath;
@@ -1266,42 +1198,6 @@ describe("ui rendering", () => {
12661198 }
12671199 });
12681200
1269- test("renderInputArea returns a direct TextInput with stable handlers", () => {
1270- const state = createTestState();
1271-
1272- try {
1273- const controller = createInputController(state);
1274- const firstInput = renderInputArea(state.theme, controller);
1275- const secondInput = renderInputArea(state.theme, controller);
1276-
1277- expect(firstInput.type).toBe("textinput");
1278- expect(secondInput.type).toBe("textinput");
1279- if (firstInput.type !== "textinput" || secondInput.type !== "textinput") {
1280- throw new Error("Expected direct TextInput nodes");
1281- }
1282-
1283- expect(firstInput.props.placeholder?.props.fgColor).toBe(
1284- state.theme.mutedText,
1285- );
1286- expect(firstInput.props.padding).toEqual({ x: 1 });
1287- expect(firstInput.props.minHeight).toBe(2);
1288- expect(firstInput.props.maxHeight).toBe(10);
1289- expect(firstInput.props.onChange).toBe(controller.onChange);
1290- expect(firstInput.props.onFocus).toBe(controller.onFocus);
1291- expect(firstInput.props.onBlur).toBe(controller.onBlur);
1292- expect(firstInput.props.onKeyPress).toBe(controller.onKeyPress);
1293- expect(secondInput.props.padding).toEqual(firstInput.props.padding);
1294- expect(secondInput.props.minHeight).toBe(firstInput.props.minHeight);
1295- expect(secondInput.props.maxHeight).toBe(firstInput.props.maxHeight);
1296- expect(secondInput.props.onChange).toBe(firstInput.props.onChange);
1297- expect(secondInput.props.onFocus).toBe(firstInput.props.onFocus);
1298- expect(secondInput.props.onBlur).toBe(firstInput.props.onBlur);
1299- expect(secondInput.props.onKeyPress).toBe(firstInput.props.onKeyPress);
1300- } finally {
1301- state.db.close();
1302- }
1303- });
1304-
13051201 test("Tab autocompletes the last file path in normal input mode", () => {
13061202 const state = createTestState();
13071203 const cwd = createTempDir();
@@ -1316,10 +1212,7 @@ describe("ui rendering", () => {
13161212
13171213 expect(controller.onKeyPress("tab")).toBe(false);
13181214
1319- const input = renderInputArea(state.theme, controller);
1320- if (input.type !== "textinput") {
1321- throw new Error("Expected input area to render a TextInput");
1322- }
1215+ const input = expectTextInput(renderInputArea(state.theme, controller));
13231216 expect(input.props.value).toBe("inspect src/ui.ts");
13241217 expect(renderActiveOverlay(state)).toBeNull();
13251218 } finally {
@@ -1341,16 +1234,14 @@ describe("ui rendering", () => {
13411234 });
13421235
13431236 const controller = createInputController(state);
1344- const base = renderBaseLayout(state, 80, controller);
1345-
1346- expect(base.type).toBe("vstack");
1347- if (base.type !== "vstack") {
1348- throw new Error("Expected base layout to be a vstack");
1349- }
1237+ const base = expectVStack(renderBaseLayout(state, 80, controller));
13501238
13511239 base.props.onKeyPress?.("ctrl+r");
13521240
13531241 const overlay = renderActiveOverlay(state);
1242+ if (!overlay) {
1243+ throw new Error("Expected an active input history overlay");
1244+ }
13541245 const text = collectText(overlay);
13551246 const newestIndex = text.findIndex((line) =>
13561247 line.includes("newest prompt"),
@@ -1359,7 +1250,6 @@ describe("ui rendering", () => {
13591250 line.includes("older prompt"),
13601251 );
13611252
1362- expect(overlay).not.toBeNull();
13631253 expect(text).toContain("Input history");
13641254 expect(newestIndex).toBeGreaterThan(-1);
13651255 expect(olderIndex).toBeGreaterThan(-1);
@@ -1369,91 +1259,7 @@ describe("ui rendering", () => {
13691259 }
13701260 });
13711261
1372- test("selecting input history restores the exact raw prompt into the input", () => {
1373- const state = createTestState();
1374- const rawPrompt = "first line\nsecond line";
1375-
1376- try {
1377- appendPromptHistory(state.db, {
1378- text: "older prompt",
1379- cwd: "/tmp/older",
1380- });
1381- appendPromptHistory(state.db, {
1382- text: rawPrompt,
1383- cwd: state.cwd,
1384- });
1385-
1386- const controller = createInputController(state);
1387- const base = renderBaseLayout(state, 80, controller);
1388- if (base.type !== "vstack") {
1389- throw new Error("Expected base layout to be a vstack");
1390- }
1391-
1392- base.props.onKeyPress?.("ctrl+r");
1393-
1394- const overlay = renderActiveOverlay(state);
1395- const selectNode = findNodeWithKeyPress(overlay);
1396-
1397- expect(selectNode).not.toBeNull();
1398- if (!selectNode) {
1399- throw new Error("Expected overlay to contain a Select root");
1400- }
1401-
1402- selectNode.props.onKeyPress?.("enter");
1403-
1404- expect(renderActiveOverlay(state)).toBeNull();
1405- const input = renderInputArea(state.theme, controller);
1406- if (input.type !== "textinput") {
1407- throw new Error("Expected input area to render a TextInput");
1408- }
1409- expect(input.props.value).toBe(rawPrompt);
1410- } finally {
1411- state.db.close();
1412- }
1413- });
1414-
1415- test("dismissing input history keeps the current draft unchanged", () => {
1416- const state = createTestState();
1417- const draft = "draft prompt";
1418-
1419- try {
1420- appendPromptHistory(state.db, {
1421- text: "saved prompt",
1422- cwd: state.cwd,
1423- });
1424-
1425- const controller = createInputController(state);
1426- controller.onChange(draft);
1427-
1428- const base = renderBaseLayout(state, 80, controller);
1429- if (base.type !== "vstack") {
1430- throw new Error("Expected base layout to be a vstack");
1431- }
1432-
1433- base.props.onKeyPress?.("ctrl+r");
1434-
1435- const overlay = renderActiveOverlay(state);
1436- const selectNode = findNodeWithKeyPress(overlay);
1437-
1438- expect(selectNode).not.toBeNull();
1439- if (!selectNode) {
1440- throw new Error("Expected overlay to contain a Select root");
1441- }
1442-
1443- selectNode.props.onBlur?.();
1444-
1445- expect(renderActiveOverlay(state)).toBeNull();
1446- const input = renderInputArea(state.theme, controller);
1447- if (input.type !== "textinput") {
1448- throw new Error("Expected input area to render a TextInput");
1449- }
1450- expect(input.props.value).toBe(draft);
1451- } finally {
1452- state.db.close();
1453- }
1454- });
1455-
1456- test("renderBaseLayout keeps a single divider between the log and input", () => {
1262+ test("renderBaseLayout shows a single divider line between the conversation and input areas", () => {
14571263 const state = createTestState();
14581264 const controller: InputController = {
14591265 onChange: () => {},
@@ -1463,17 +1269,9 @@ describe("ui rendering", () => {
14631269 };
14641270
14651271 try {
1466- const node = renderBaseLayout(state, 80, controller);
1272+ const text = collectText(renderBaseLayout(state, 80, controller));
14671273
1468- expect(node.type).toBe("vstack");
1469- if (node.type !== "vstack") {
1470- throw new Error("Expected app layout to be a VStack");
1471- }
1472- expect(node.children).toHaveLength(4);
1473- expect(node.children[0]?.type).toBe("vstack");
1474- expect(node.children[1]?.type).toBe("text");
1475- expect(node.children[2]?.type).toBe("textinput");
1476- expect(node.children[3]?.type).toBe("hstack");
1274+ expect(text.filter((line) => line === "─")).toHaveLength(1);
14771275 } finally {
14781276 state.db.close();
14791277 }
@@ -1490,14 +1288,11 @@ describe("ui rendering", () => {
14901288 let suspended = false;
14911289
14921290 try {
1493- const node = renderBaseLayout(state, 80, controller, () => {
1494- suspended = true;
1495- });
1496-
1497- expect(node.type).toBe("vstack");
1498- if (node.type !== "vstack") {
1499- throw new Error("Expected app layout to be a VStack");
1500- }
1291+ const node = expectVStack(
1292+ renderBaseLayout(state, 80, controller, () => {
1293+ suspended = true;
1294+ }),
1295+ );
15011296
15021297 node.props.onKeyPress?.("ctrl+z");
15031298 expect(suspended).toBe(true);
src/ui/commands.test.ts+159−43
@@ -6,17 +6,19 @@ import type { ContainerNode, Node } from "@cel-tui/types";
66 import { registerFauxProvider } from "@mariozechner/pi-ai";
77 import type { AppState } from "../index.ts";
88 import { COMMANDS } from "../input.ts";
9-import { appendPromptHistory, openDatabase } from "../session.ts";
9+import {
10+ appendPromptHistory,
11+ createSession,
12+ openDatabase,
13+} from "../session.ts";
1014 import { loadSettings } from "../settings.ts";
1115 import { DEFAULT_THEME } from "../theme.ts";
12-import * as commandsModule from "./commands.ts";
1316 import {
1417 createCommandController,
1518 formatPromptHistoryPreview,
1619 formatRelativeDate,
1720 } from "./commands.ts";
Cut short: this commit's diff is over 1000 lines.
src/ui/conversation.test.ts+12−82
Cut short: this commit's diff is over 1000 lines.
src/ui/input.test.ts+18−15
Cut short: this commit's diff is over 1000 lines.
src/ui/overlay.test.ts+21−28
Cut short: this commit's diff is over 1000 lines.
src/ui/status.test.ts+132−152
Cut short: this commit's diff is over 1000 lines.