92 lines
5.4 KiB
TypeScript
92 lines
5.4 KiB
TypeScript
import assert from "node:assert/strict"
|
|
import { test } from "node:test"
|
|
import { pool } from "../db/index.js"
|
|
import { createProbeStorageHostIo } from "./server-probe-storage-host-io.js"
|
|
import { PROBE_STORAGE_LIMITS } from "../modules/mcp/diagnostic-cancellation-storage.js"
|
|
import { ProbeStorageUnknown } from "./server-probe-journal-maintenance.js"
|
|
|
|
type Result = { rows: Record<string, unknown>[]; command: string }
|
|
function deferred<T>() {
|
|
let resolve!: (value: T) => void
|
|
const promise = new Promise<T>(yes => { resolve = yes })
|
|
return { promise, resolve }
|
|
}
|
|
async function fixture(work: (value: { io: ReturnType<typeof createProbeStorageHostIo>; queries: { query_timeout: number }[]; releases: boolean[]; checkouts: () => number }) => Promise<void>, driver?: () => Promise<Result>) {
|
|
const originalConnect = pool.connect, originalQuery = pool.query
|
|
const queries: { query_timeout: number }[] = [], releases: boolean[] = []; let checkouts = 0
|
|
pool.query = (() => assert.fail("No unbounded pool.query")) as typeof pool.query
|
|
pool.connect = (async () => {
|
|
checkouts++
|
|
return { async query(config: { query_timeout: number }) { queries.push(config); return driver ? driver() : { rows: [{ value: 1 }], command: "SELECT" } }, release(unsafe?: boolean) { releases.push(!!unsafe) } }
|
|
}) as unknown as typeof pool.connect
|
|
try { await work({ io: createProbeStorageHostIo(PROBE_STORAGE_LIMITS, "rest"), queries, releases, checkouts: () => checkouts }) }
|
|
finally { pool.connect = originalConnect; pool.query = originalQuery }
|
|
}
|
|
|
|
test("metadata groups share one bounded backend and copy the request budget", async () => {
|
|
await fixture(async ({ io, queries, releases, checkouts }) => {
|
|
const options = { deadlineAt: Date.now() + 1000 }
|
|
await io.runRequest(options, async () => {
|
|
options.deadlineAt += 300000
|
|
await io.withClient(async client => {
|
|
await client.query("SELECT owner"); await io.query("SELECT source"); await client.query("SELECT settings")
|
|
})
|
|
})
|
|
assert.equal(checkouts(), 1); assert.equal(queries.length, 3); assert.deepEqual(releases, [false])
|
|
assert(queries.every(value => value.query_timeout >= 1 && value.query_timeout <= 1000))
|
|
})
|
|
})
|
|
test("request abort destroys an in-flight metadata backend and absorbs the late driver value", async () => {
|
|
const response = deferred<Result>(), started = deferred<void>()
|
|
await fixture(async ({ io, releases, queries }) => {
|
|
const controller = new AbortController()
|
|
const pending = io.runRequest({ deadlineAt: Date.now() + 10000, signal: controller.signal }, () => io.query("SELECT blocked"))
|
|
const rejected = assert.rejects(pending, ProbeStorageUnknown)
|
|
await started.promise; controller.abort(); await rejected
|
|
assert.deepEqual(releases, [true]); assert.equal(queries.length, 1)
|
|
response.resolve({ rows: [{ value: 1 }], command: "SELECT" }); await new Promise(resolve => setImmediate(resolve))
|
|
assert.deepEqual(releases, [true]); assert.equal(queries.length, 1)
|
|
}, () => { started.resolve(); return response.promise })
|
|
})
|
|
test("abort also bounds a callback waiting between SQL statements and closes its late facade", async () => {
|
|
const entered = deferred<void>(), gate = deferred<void>(), lateDone = deferred<void>()
|
|
await fixture(async ({ io, queries, releases }) => {
|
|
const controller = new AbortController()
|
|
const pending = io.runRequest({ deadlineAt: Date.now() + 10000, signal: controller.signal }, () => io.withClient(async client => {
|
|
entered.resolve(); await gate.promise
|
|
await assert.rejects(client.query("SELECT after-callback-abort"), { code: "STATE_CONFLICT" }); lateDone.resolve()
|
|
}))
|
|
const rejected = assert.rejects(pending, ProbeStorageUnknown)
|
|
await entered.promise; controller.abort(); await rejected
|
|
assert.deepEqual(releases, [true]); assert.equal(queries.length, 0)
|
|
gate.resolve(); await lateDone.promise
|
|
assert.deepEqual(releases, [true]); assert.equal(queries.length, 0)
|
|
})
|
|
})
|
|
for (const kind of ["owned", "borrowed"] as const) test("closed ancestor refuses a detached " + kind + " raw client before SQL", async () => {
|
|
await fixture(async ({ io, queries, releases, checkouts }) => {
|
|
const gate = deferred<void>(), entered = deferred<void>(), options = { deadlineAt: Date.now() + 10000 }
|
|
let rejected: Promise<void> | undefined, borrowedQueries = 0
|
|
await io.runRequest(options, async () => {
|
|
const work = async () => {
|
|
const client = io.currentClient()!; entered.resolve(); await gate.promise
|
|
return client.query("SELECT forbidden-late")
|
|
}
|
|
const child = io.runRequest(options, () => kind === "owned" ? io.withClient(work) : io.withBorrowed({ query: (async () => { borrowedQueries++; return { rows: [] } }) as never }, work))
|
|
rejected = assert.rejects(child, { code: "STATE_CONFLICT" })
|
|
await entered.promise
|
|
})
|
|
gate.resolve(); await rejected
|
|
assert.equal(queries.length, 0); assert.equal(borrowedQueries, 0)
|
|
assert.equal(checkouts(), kind === "owned" ? 1 : 0); assert.deepEqual(releases, kind === "owned" ? [false] : [])
|
|
})
|
|
})
|
|
test("a request cannot open a nested operation while a physical lease is held", async () => {
|
|
await fixture(async ({ io, releases, checkouts }) => {
|
|
await io.withClient(async () => {
|
|
await assert.rejects(io.runRequest({ deadlineAt: Date.now() + 1 }, async () => 1), { code: "STATE_CONFLICT" })
|
|
})
|
|
assert.equal(checkouts(), 1); assert.deepEqual(releases, [false])
|
|
})
|
|
})
|