Files
MikrotikManager/backend/src/services/server-probe-storage-metadata.test.ts
T

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])
})
})