Kit Langton
82 lines
2.6 KiB
TypeScript
82 lines
2.6 KiB
TypeScript
import { test } from "bun:test"
|
|
import { createRoot } from "solid-js"
|
|
import { createData, type CreateDataInput } from "../src/solid"
|
|
import { OpenCode, type OpenCodeEvent, type SessionInfo } from "../src/promise"
|
|
|
|
const session = (viewed: number): SessionInfo => ({
|
|
id: "ses_refresh",
|
|
projectID: "project",
|
|
cost: 0,
|
|
tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
|
|
outcome: "succeeded",
|
|
time: { created: 0, updated: 0, idle: 2, viewed },
|
|
location: { directory: "/project" },
|
|
})
|
|
|
|
test("revalidates after an event overtakes an active session read", async () => {
|
|
let release!: () => void
|
|
const gate = new Promise<void>((resolve) => (release = resolve))
|
|
const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>()
|
|
let requests = 0
|
|
const api = OpenCode.make({
|
|
baseUrl: "http://opencode.local",
|
|
fetch: async (input, init) => {
|
|
const request = input instanceof Request ? input : new Request(input, init)
|
|
if (!request.url.endsWith("/api/session/ses_refresh")) throw new Error(`Unexpected request: ${request.url}`)
|
|
requests++
|
|
if (requests === 1) {
|
|
await gate
|
|
return Response.json({ data: session(1) })
|
|
}
|
|
return Response.json({ data: session(2) })
|
|
},
|
|
})
|
|
const event: CreateDataInput["event"] = {
|
|
on:
|
|
<Type extends OpenCodeEvent["type"]>(
|
|
_type: Type,
|
|
_handler: (event: Extract<OpenCodeEvent, { type: Type }>) => void,
|
|
) =>
|
|
() => {},
|
|
listen(handler) {
|
|
listeners.add(handler)
|
|
return () => listeners.delete(handler)
|
|
},
|
|
}
|
|
const setup = createRoot((dispose) => ({
|
|
data: createData({ api: () => api, directory: "/project", event, connection: { status: () => "connected" } }),
|
|
dispose,
|
|
}))
|
|
|
|
try {
|
|
setup.data.session.remember(session(1))
|
|
setup.data.session.invalidate("ses_refresh")
|
|
const initial = setup.data.session.sync("ses_refresh")
|
|
await wait(() => requests === 1)
|
|
|
|
const viewed: OpenCodeEvent = {
|
|
id: "evt_viewed",
|
|
created: 2,
|
|
type: "session.viewed",
|
|
durable: { aggregateID: "ses_refresh", seq: 1, version: 1 },
|
|
data: { sessionID: "ses_refresh", idle: 2 },
|
|
}
|
|
listeners.forEach((listener) => listener({ name: viewed.type, details: viewed }))
|
|
await Bun.sleep(20)
|
|
release()
|
|
await initial
|
|
|
|
await wait(() => requests === 2 && setup.data.session.get("ses_refresh")?.time.viewed === 2)
|
|
} finally {
|
|
setup.dispose()
|
|
}
|
|
})
|
|
|
|
async function wait(check: () => boolean) {
|
|
const started = Date.now()
|
|
while (!check()) {
|
|
if (Date.now() - started > 2_000) throw new Error("Timed out waiting for condition")
|
|
await Bun.sleep(10)
|
|
}
|
|
}
|