Skip to content

Commit fa6288b

Browse files
committed
test: log-buffer, RWLock concurrency, SSE chunk splitting — 13 new tests
Cover three untested risk areas: dbt ring buffer overflow (ties to #249 TUI corruption fix), reader-writer lock starvation ordering, and SSE event parsing across chunk boundaries and abort signals. Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]> https://claude.ai/code/session_01153R7Dh9BMKiarndEUraBk
1 parent 86a02c4 commit fa6288b

3 files changed

Lines changed: 198 additions & 0 deletions

File tree

Lines changed: 51 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,51 @@
1+
import { describe, test, expect, beforeEach } from "bun:test"
2+
import { bufferLog, getRecentDbtLogs, clearDbtLogs } from "../src/log-buffer"
3+
4+
describe("dbt log-buffer", () => {
5+
beforeEach(() => {
6+
clearDbtLogs()
7+
})
8+
9+
test("buffers log messages in insertion order", () => {
10+
bufferLog("first")
11+
bufferLog("second")
12+
bufferLog("third")
13+
expect(getRecentDbtLogs()).toEqual(["first", "second", "third"])
14+
})
15+
16+
test("evicts oldest entries when buffer exceeds 100", () => {
17+
for (let i = 0; i < 105; i++) {
18+
bufferLog(`msg-${i}`)
19+
}
20+
const logs = getRecentDbtLogs()
21+
expect(logs).toHaveLength(100)
22+
expect(logs[0]).toBe("msg-5")
23+
expect(logs[99]).toBe("msg-104")
24+
})
25+
26+
test("clearDbtLogs empties the buffer", () => {
27+
bufferLog("something")
28+
clearDbtLogs()
29+
expect(getRecentDbtLogs()).toEqual([])
30+
})
31+
32+
test("getRecentDbtLogs returns a copy, not a reference", () => {
33+
bufferLog("original")
34+
const copy = getRecentDbtLogs()
35+
copy.push("injected")
36+
expect(getRecentDbtLogs()).toEqual(["original"])
37+
})
38+
39+
test("handles empty buffer", () => {
40+
expect(getRecentDbtLogs()).toEqual([])
41+
})
42+
43+
test("buffer stays at exactly 100 after repeated overflow", () => {
44+
for (let i = 0; i < 200; i++) {
45+
bufferLog(`msg-${i}`)
46+
}
47+
expect(getRecentDbtLogs()).toHaveLength(100)
48+
expect(getRecentDbtLogs()[0]).toBe("msg-100")
49+
expect(getRecentDbtLogs()[99]).toBe("msg-199")
50+
})
51+
})

‎packages/opencode/test/control-plane/sse.test.ts‎

Lines changed: 79 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -53,4 +53,83 @@ describe("control-plane/sse", () => {
5353
},
5454
])
5555
})
56+
57+
test("handles events split across chunk boundaries", async () => {
58+
const events: unknown[] = []
59+
const stop = new AbortController()
60+
61+
await parseSSE(
62+
stream(['data: {"type":"spl', 'it"}\n\n']),
63+
stop.signal,
64+
(event) => events.push(event),
65+
)
66+
67+
expect(events).toEqual([{ type: "split" }])
68+
})
69+
70+
test("handles double newline split across chunks", async () => {
71+
const events: unknown[] = []
72+
const stop = new AbortController()
73+
74+
await parseSSE(
75+
stream(['data: {"type":"boundary"}\n', '\ndata: {"type":"next"}\n\n']),
76+
stop.signal,
77+
(event) => events.push(event),
78+
)
79+
80+
expect(events).toEqual([{ type: "boundary" }, { type: "next" }])
81+
})
82+
83+
test("ignores empty events (double newline with no data)", async () => {
84+
const events: unknown[] = []
85+
const stop = new AbortController()
86+
87+
await parseSSE(
88+
stream(['\n\ndata: {"type":"real"}\n\n']),
89+
stop.signal,
90+
(event) => events.push(event),
91+
)
92+
93+
expect(events).toEqual([{ type: "real" }])
94+
})
95+
96+
test("abort signal stops processing mid-stream", async () => {
97+
const events: unknown[] = []
98+
const stop = new AbortController()
99+
100+
// Stream that delivers chunks on demand via pull(); abort fires
101+
// between the first and second read.
102+
let pullCount = 0
103+
const body = new ReadableStream<Uint8Array>({
104+
pull(controller) {
105+
const encoder = new TextEncoder()
106+
pullCount++
107+
if (pullCount === 1) {
108+
controller.enqueue(encoder.encode('data: {"type":"first"}\n\n'))
109+
// Abort before next pull delivers second event
110+
stop.abort()
111+
} else {
112+
controller.enqueue(encoder.encode('data: {"type":"second"}\n\n'))
113+
controller.close()
114+
}
115+
},
116+
})
117+
118+
await parseSSE(body, stop.signal, (event) => events.push(event))
119+
120+
expect(events).toEqual([{ type: "first" }])
121+
})
122+
123+
test("handles bare \\r line endings", async () => {
124+
const events: unknown[] = []
125+
const stop = new AbortController()
126+
127+
await parseSSE(
128+
stream(['data: {"type":"cr"}\r\r']),
129+
stop.signal,
130+
(event) => events.push(event),
131+
)
132+
133+
expect(events).toEqual([{ type: "cr" }])
134+
})
56135
})

‎packages/opencode/test/util/lock.test.ts‎

Lines changed: 68 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -69,4 +69,72 @@ describe("util.lock", () => {
6969

7070
reader[Symbol.dispose]()
7171
})
72+
73+
test("concurrent readers: multiple readers can hold the lock simultaneously", async () => {
74+
const key = "lock:" + Math.random().toString(36).slice(2)
75+
const timeline: string[] = []
76+
77+
const r1 = await Lock.read(key)
78+
timeline.push("r1-acquired")
79+
80+
const r2 = await Lock.read(key)
81+
timeline.push("r2-acquired")
82+
83+
// Both acquired without blocking — readers are concurrent
84+
expect(timeline).toEqual(["r1-acquired", "r2-acquired"])
85+
86+
r1[Symbol.dispose]()
87+
r2[Symbol.dispose]()
88+
})
89+
90+
test("writer starvation prevention: waiting writer blocks new readers", async () => {
91+
const key = "lock:" + Math.random().toString(36).slice(2)
92+
const timeline: string[] = []
93+
94+
// Acquire a reader
95+
const r1 = await Lock.read(key)
96+
timeline.push("r1-acquired")
97+
98+
// Queue a writer (blocks because r1 is held)
99+
let writerResolved = false
100+
const writerTask = Lock.write(key).then((w) => {
101+
writerResolved = true
102+
timeline.push("writer-acquired")
103+
return w
104+
})
105+
106+
await flush()
107+
expect(writerResolved).toBe(false)
108+
109+
// Queue a second reader (should block because a writer is waiting —
110+
// the source's process() prioritizes waitingWriters over waitingReaders)
111+
let reader2Resolved = false
112+
const reader2Task = Lock.read(key).then((r) => {
113+
reader2Resolved = true
114+
timeline.push("r2-acquired")
115+
return r
116+
})
117+
118+
await flush()
119+
expect(reader2Resolved).toBe(false)
120+
121+
// Release r1 — writer goes next (not reader2).
122+
// process() calls the writer callback synchronously via shift()+nextWriter(),
123+
// which resolves the writer promise on the next microtask. reader2 remains
124+
// queued in waitingReaders until the writer releases.
125+
r1[Symbol.dispose]()
126+
127+
const writer = await writerTask
128+
expect(writerResolved).toBe(true)
129+
expect(reader2Resolved).toBe(false)
130+
131+
// Release writer — now reader2 can proceed
132+
writer[Symbol.dispose]()
133+
const r2 = await reader2Task
134+
expect(reader2Resolved).toBe(true)
135+
136+
expect(timeline).toEqual(["r1-acquired", "writer-acquired", "r2-acquired"])
137+
138+
r2[Symbol.dispose]()
139+
})
72140
})

0 commit comments

Comments
 (0)