@antelopejs/postgres 0.0.1-stage → 0.2.1

package/dist/test/unit/cursors.spec.js

@@ -0,0 +1,823 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const spec_fixture_1 = require("./spec-fixture");
+const connection_1 = require("../../connection");
+const cursors_1 = require("../../implementations/database/cursors");
+const CURSOR = '"antelopejs_cursor"';
+const SQL = 'SELECT "n" FROM "t" WHERE "n" > ($1::int)';
+const PARAMS = [7];
+const BATCH_SIZE = 3;
+const IDLE_TIMEOUT_MS = 30_000;
+const REAPED_AFTER_MS = 1;
+const REAP_WINDOW_MS = 40;
+const REAPER_PROBE_MS = 987_654;
+const BEGIN = "BEGIN";
+const ROLLBACK = "ROLLBACK";
+const RELEASE = "RELEASE";
+const CLOSE = `CLOSE ${CURSOR}`;
+const DECLARE = `DECLARE ${CURSOR} NO SCROLL CURSOR FOR ${SQL}`;
+const FETCH = `FETCH FORWARD ${BATCH_SIZE} FROM ${CURSOR}`;
+const FETCH_PREFIX = "FETCH FORWARD";
+const PARAM_MARKER = /\$\d/;
+const OPTIONS = {
+    cursorBatchSize: BATCH_SIZE,
+    cursorIdleTimeoutMs: IDLE_TIMEOUT_MS,
+};
+const REAPING = {
+    cursorBatchSize: BATCH_SIZE,
+    cursorIdleTimeoutMs: REAPED_AFTER_MS,
+};
+const PROBING = {
+    cursorBatchSize: BATCH_SIZE,
+    cursorIdleTimeoutMs: REAPER_PROBE_MS,
+};
+const NO_VALUES = [];
+const STUB_FAILURE = "the stub client refused this statement";
+const NEVER_ENDED = "the cursor never answered done";
+const NEVER_REJECTED = "the read was expected to reject";
+const NEVER_ARRIVED = "no read arrived while the sweep was running";
+const NEVER_HELD = "the stub never reached the statement it was told to hold";
+const DOUBLE_RELEASE = "this client was already handed back to the pool";
+const DRAIN_LIMIT = 50;
+const SETTLE_TURNS = 8;
+const NOT_OBSERVED = -1;
+const FORGOTTEN_HINT = "no longer remembered";
+const DESCENDING_CURSORS = 4;
+const DECLARE_POSITION = 1;
+const STALE_TIMER = 0;
+const LAST_TIMER = 1;
+const NEXT_TURN_MS = 0;
+const IDLE_TIMEOUT_OPTION = "cursorIdleTimeoutMs";
+const REMEMBERED_ENDINGS = 1024;
+const FIRST_SPEC_REQ_ID = -1;
+function Recorder() {
+    return { statements: [], bound: [], releases: 0, acquires: 0 };
+}
+function StubClient(log, batches, failing) {
+    let isReleased = false;
+    const stub = {
+        query: (sql, values) => {
+            log.statements.push(sql);
+            log.bound.push(values ?? NO_VALUES);
+            if (sql === failing) {
+                return Promise.reject(new Error(STUB_FAILURE));
+            }
+            if (sql === log.holdsStatement) {
+                log.holdsStatement = undefined;
+                return new Promise((resolve) => {
+                    log.resumeHeld = () => resolve({ rows: [] });
+                });
+            }
+            if (!sql.startsWith(FETCH_PREFIX)) {
+                return Promise.resolve({ rows: [] });
+            }
+            const rows = batches.shift() ?? [];
+            if (!log.holdsNextFetch) {
+                return Promise.resolve({ rows });
+            }
+            log.holdsNextFetch = false;
+            return new Promise((resolve) => {
+                log.resumeFetch = () => resolve({ rows });
+            });
+        },
+        release: () => {
+            log.statements.push(RELEASE);
+            log.bound.push(NO_VALUES);
+            log.releases += 1;
+            if (isReleased) {
+                throw new Error(DOUBLE_RELEASE);
+            }
+            isReleased = true;
+            log.whenReleased?.();
+        },
+    };
+    return stub;
+}
+function Decode(rows) {
+    return rows.map((row) => row.n);
+}
+function Requesting(log, batches, failing) {
+    return () => Promise.resolve({
+        sql: SQL,
+        params: PARAMS,
+        decode: Decode,
+        acquire: () => {
+            log.acquires += 1;
+            return Promise.resolve(StubClient(log, batches, failing));
+        },
+    });
+}
+function Rows(...values) {
+    return values.map((n) => ({ n }));
+}
+function Reopening(log, ...values) {
+    return () => Promise.resolve({
+        sql: SQL,
+        params: PARAMS,
+        decode: Decode,
+        acquire: () => {
+            log.acquires += 1;
+            return Promise.resolve(StubClient(log, [Rows(...values)]));
+        },
+    });
+}
+let lastReqId = FIRST_SPEC_REQ_ID + 1;
+let claimed = [];
+function NextReqId() {
+    lastReqId -= 1;
+    claimed.push(lastReqId);
+    return lastReqId;
+}
+function Read(reqId, open, options = OPTIONS) {
+    return (0, spec_fixture_1.WithOptions)(options, () => (0, cursors_1.ReadCursorRow)(reqId, open));
+}
+async function Drain(reqId, open) {
+    const values = [];
+    while (values.length < DRAIN_LIMIT) {
+        const next = await Read(reqId, open);
+        if (next.done) {
+            return values;
+        }
+        values.push(next.value);
+    }
+    throw new Error(NEVER_ENDED);
+}
+async function Rejection(read) {
+    try {
+        await read;
+    }
+    catch (err) {
+        return err;
+    }
+    throw new Error(NEVER_REJECTED);
+}
+function Delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms).unref();
+    });
+}
+async function Settle() {
+    for (let turn = 0; turn < SETTLE_TURNS; turn += 1) {
+        await Delay(NEXT_TURN_MS);
+    }
+}
+async function WhenHeld(log) {
+    for (let turn = 0; turn < DRAIN_LIMIT; turn += 1) {
+        if (log.resumeHeld) {
+            return log.resumeHeld;
+        }
+        await Delay(NEXT_TURN_MS);
+    }
+    throw new Error(NEVER_HELD);
+}
+async function OverflowEndings() {
+    const filler = Recorder();
+    for (let index = 0; index < REMEMBERED_ENDINGS; index += 1) {
+        await Read(NextReqId(), Requesting(filler, [Rows()]));
+    }
+}
+function TimerRecorder() {
+    return { armed: [], handlers: [], cleared: [] };
+}
+async function CapturingTimers(log, delayMs, body) {
+    const realSet = globalThis.setTimeout;
+    const realClear = globalThis.clearTimeout;
+    globalThis.setTimeout = ((handler, ms, ...rest) => {
+        const timer = realSet(handler, ms, ...rest);
+        if (ms === delayMs) {
+            log.armed.push(timer);
+            log.handlers.push(handler);
+        }
+        return timer;
+    });
+    globalThis.clearTimeout = ((timer) => {
+        if (log.armed.includes(timer)) {
+            log.cleared.push(timer);
+        }
+        realClear(timer);
+    });
+    try {
+        await body();
+    }
+    finally {
+        globalThis.setTimeout = realSet;
+        globalThis.clearTimeout = realClear;
+    }
+}
+function Count(log, statement) {
+    return log.statements.filter((sql) => sql === statement).length;
+}
+describe("the cursor registry", () => {
+    let baseline = 0;
+    beforeEach(() => {
+        baseline = (0, cursors_1.CountOpenCursors)();
+        claimed = [];
+    });
+    afterEach(async () => {
+        const held = (0, cursors_1.CountOpenCursors)();
+        await Promise.all(claimed.map((reqId) => (0, cursors_1.CloseOneCursor)(reqId)));
+        (0, chai_1.expect)(held).to.be.at.most(baseline);
+    });
+    it("refuses both ends of a forgotten range, its highest id evicted first", async () => {
+        const upper = Recorder();
+        const lower = Recorder();
+        const upperId = NextReqId();
+        const lowerId = NextReqId();
+        (0, chai_1.expect)(upperId).to.equal(FIRST_SPEC_REQ_ID);
+        const openUpper = Reopening(upper, 1, 2);
+        const openLower = Reopening(lower, 3, 4);
+        (0, chai_1.expect)(await Drain(upperId, openUpper)).to.deep.equal([1, 2]);
+        (0, chai_1.expect)(await Drain(lowerId, openLower)).to.deep.equal([3, 4]);
+        await OverflowEndings();
+        const refusedUpper = await Rejection(Read(upperId, openUpper));
+        const refusedLower = await Rejection(Read(lowerId, openLower));
+        (0, chai_1.expect)(refusedUpper.message).to.contain(`${upperId}`);
+        (0, chai_1.expect)(refusedUpper.message).to.contain(FORGOTTEN_HINT);
+        (0, chai_1.expect)(refusedLower.message).to.contain(`${lowerId}`);
+        (0, chai_1.expect)(refusedLower.message).to.contain(FORGOTTEN_HINT);
+        (0, chai_1.expect)([upper.acquires, lower.acquires]).to.deep.equal([1, 1]);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+    });
+    it("yields a full batch and then a short one, in order, and then ends", async () => {
+        const log = Recorder();
+        const open = Requesting(log, [Rows(1, 2, 3), Rows(4, 5)]);
+        (0, chai_1.expect)(await Drain(NextReqId(), open)).to.deep.equal([1, 2, 3, 4, 5]);
+        (0, chai_1.expect)(log.statements).to.deep.equal([
+            BEGIN,
+            DECLARE,
+            FETCH,
+            FETCH,
+            CLOSE,
+            ROLLBACK,
+            RELEASE,
+        ]);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+    });
+    it("ends after a short first batch without fetching a second time", async () => {
+        const log = Recorder();
+        const open = Requesting(log, [Rows(1, 2)]);
+        (0, chai_1.expect)(await Drain(NextReqId(), open)).to.deep.equal([1, 2]);
+        (0, chai_1.expect)(log.statements).to.deep.equal([
+            BEGIN,
+            DECLARE,
+            FETCH,
+            CLOSE,
+            ROLLBACK,
+            RELEASE,
+        ]);
+    });
+    it("ends immediately over a cursor that read no rows", async () => {
+        const log = Recorder();
+        const open = Requesting(log, [Rows()]);
+        const next = await Read(NextReqId(), open);
+        (0, chai_1.expect)(next.done).to.equal(true);
+        (0, chai_1.expect)(next.value).to.equal(undefined);
+        (0, chai_1.expect)(log.statements).to.deep.equal([
+            BEGIN,
+            DECLARE,
+            FETCH,
+            CLOSE,
+            ROLLBACK,
+            RELEASE,
+        ]);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+    });
+    it("rolls back after closing the cursor and before handing the client back", async () => {
+        const log = Recorder();
+        const open = Requesting(log, [Rows(1)]);
+        await Drain(NextReqId(), open);
+        const closed = log.statements.indexOf(CLOSE);
+        const rolled = log.statements.indexOf(ROLLBACK);
+        const released = log.statements.indexOf(RELEASE);
+        (0, chai_1.expect)(closed).to.be.lessThan(rolled);
+        (0, chai_1.expect)(rolled).to.be.lessThan(released);
+    });
+    it("holds one registration while iterating and none once exhausted", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1, 2)]);
+        await Read(reqId, open);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline + 1);
+        await Read(reqId, open);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline + 1);
+        (0, chai_1.expect)((await Read(reqId, open)).done).to.equal(true);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+    });
+    it("stays done after exhaustion, acquiring nothing", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1)]);
+        (0, chai_1.expect)(await Drain(reqId, open)).to.deep.equal([1]);
+        const after = await Read(reqId, open);
+        (0, chai_1.expect)(after.done).to.equal(true);
+        (0, chai_1.expect)(after.value).to.equal(undefined);
+        (0, chai_1.expect)(log.acquires).to.equal(1);
+        (0, chai_1.expect)(Count(log, BEGIN)).to.equal(1);
+        (0, chai_1.expect)(Count(log, DECLARE)).to.equal(1);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+    });
+    it("stays done after an explicit close, acquiring nothing", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1, 2, 3), Rows(4)]);
+        (0, chai_1.expect)((await Read(reqId, open)).value).to.equal(1);
+        await (0, cursors_1.CloseOneCursor)(reqId);
+        const after = await Read(reqId, open);
+        (0, chai_1.expect)(after.done).to.equal(true);
+        (0, chai_1.expect)(log.acquires).to.equal(1);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+        (0, chai_1.expect)(Count(log, FETCH)).to.equal(1);
+    });
+    it("answers four concurrent reads over a two-row cursor on one client", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1, 2)]);
+        const answers = await Promise.all([
+            Read(reqId, open),
+            Read(reqId, open),
+            Read(reqId, open),
+            Read(reqId, open),
+        ]);
+        (0, chai_1.expect)(answers.map((answer) => answer.value)).to.deep.equal([
+            1,
+            2,
+            undefined,
+            undefined,
+        ]);
+        (0, chai_1.expect)(answers.map((answer) => answer.done)).to.deep.equal([
+            false,
+            false,
+            true,
+            true,
+        ]);
+        (0, chai_1.expect)(log.acquires).to.equal(1);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+        (0, chai_1.expect)(Count(log, BEGIN)).to.equal(1);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+    });
+    it("throws on a read after the idle reaper reclaimed the cursor", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1, 2, 3), Rows(4)]);
+        (0, chai_1.expect)((await Read(reqId, open, REAPING)).value).to.equal(1);
+        await Delay(REAP_WINDOW_MS);
+        await (0, cursors_1.CloseOneCursor)(reqId);
+        const err = await Rejection(Read(reqId, open));
+        (0, chai_1.expect)(err.message).to.contain(IDLE_TIMEOUT_OPTION);
+        (0, chai_1.expect)(err.message).to.contain(`${REAPED_AFTER_MS} ms`);
+        (0, chai_1.expect)(err.message).to.contain(`${reqId}`);
+        (0, chai_1.expect)(log.acquires).to.equal(1);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+    });
+    it("releases exactly once when closed part-way through", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1, 2, 3), Rows(4)]);
+        (0, chai_1.expect)((await Read(reqId, open)).value).to.equal(1);
+        await (0, cursors_1.CloseOneCursor)(reqId);
+        (0, chai_1.expect)(log.statements).to.deep.equal([
+            BEGIN,
+            DECLARE,
+            FETCH,
+            CLOSE,
+            ROLLBACK,
+            RELEASE,
+        ]);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+    });
+    it("closes behind a read that is still in flight, and answers it first", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1, 2, 3), Rows(4)]);
+        const reading = Read(reqId, open);
+        const closing = (0, cursors_1.CloseOneCursor)(reqId);
+        const first = await reading;
+        await closing;
+        (0, chai_1.expect)(first.value).to.equal(1);
+        (0, chai_1.expect)(log.statements).to.deep.equal([
+            BEGIN,
+            DECLARE,
+            FETCH,
+            CLOSE,
+            ROLLBACK,
+            RELEASE,
+        ]);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+    });
+    it("does nothing on a second close, and nothing on a close after exhaustion", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1, 2)]);
+        await Drain(reqId, open);
+        await (0, cursors_1.CloseOneCursor)(reqId);
+        await (0, cursors_1.CloseOneCursor)(reqId);
+        (0, chai_1.expect)(Count(log, CLOSE)).to.equal(1);
+        (0, chai_1.expect)(Count(log, ROLLBACK)).to.equal(1);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+    });
+    it("acquires nothing on a close for a reqId that never opened", async () => {
+        await (0, cursors_1.CloseOneCursor)(NextReqId());
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+    });
+    it("answers done, acquiring nothing, after a close that preceded every read", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Reopening(log, 1, 2);
+        await (0, cursors_1.CloseOneCursor)(reqId);
+        const after = await Read(reqId, open);
+        (0, chai_1.expect)(after.done).to.equal(true);
+        (0, chai_1.expect)(after.value).to.equal(undefined);
+        (0, chai_1.expect)(log.acquires).to.equal(0);
+        (0, chai_1.expect)(log.statements).to.deep.equal([]);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+    });
+    it("forgets a close that preceded every read, like any other ending", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Reopening(log, 1, 2);
+        await (0, cursors_1.CloseOneCursor)(reqId);
+        await OverflowEndings();
+        const err = await Rejection(Read(reqId, open));
+        (0, chai_1.expect)(err.message).to.contain(`${reqId}`);
+        (0, chai_1.expect)(err.message).to.contain(FORGOTTEN_HINT);
+        (0, chai_1.expect)(log.acquires).to.equal(0);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+    });
+    it("rolls back and releases when the DECLARE is refused, registering nothing", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [], DECLARE);
+        const err = await Rejection(Read(reqId, open));
+        (0, chai_1.expect)(err.message).to.equal(STUB_FAILURE);
+        (0, chai_1.expect)(log.statements).to.deep.equal([BEGIN, DECLARE, ROLLBACK, RELEASE]);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+        (0, chai_1.expect)((await Read(reqId, open)).done).to.equal(true);
+        (0, chai_1.expect)(log.acquires).to.equal(1);
+    });
+    it("releases without rolling back when the BEGIN itself is refused", async () => {
+        const log = Recorder();
+        const open = Requesting(log, [], BEGIN);
+        await Rejection(Read(NextReqId(), open));
+        (0, chai_1.expect)(log.statements).to.deep.equal([BEGIN, RELEASE]);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+    });
+    it("acquires nothing when the statement never compiled", async () => {
+        const log = Recorder();
+        const refused = new Error("this stage array compiles no relation");
+        const err = await Rejection(Read(NextReqId(), () => Promise.reject(refused)));
+        (0, chai_1.expect)(err).to.equal(refused);
+        (0, chai_1.expect)(log.statements).to.deep.equal([]);
+        (0, chai_1.expect)(log.acquires).to.equal(0);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+    });
+    it("rolls back and releases when a FETCH is refused", async () => {
+        const log = Recorder();
+        const open = Requesting(log, [Rows(1, 2, 3)], FETCH);
+        await Rejection(Read(NextReqId(), open));
+        (0, chai_1.expect)(log.statements).to.deep.equal([
+            BEGIN,
+            DECLARE,
+            FETCH,
+            CLOSE,
+            ROLLBACK,
+            RELEASE,
+        ]);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+    });
+    it("answers two concurrent reads consecutive rows, over one open and one fetch", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1, 2, 3)]);
+        const [first, second] = await Promise.all([
+            Read(reqId, open),
+            Read(reqId, open),
+        ]);
+        (0, chai_1.expect)([first.value, second.value]).to.deep.equal([1, 2]);
+        (0, chai_1.expect)(log.statements).to.deep.equal([BEGIN, DECLARE, FETCH]);
+        (0, chai_1.expect)(log.acquires).to.equal(1);
+        await (0, cursors_1.CloseOneCursor)(reqId);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+    });
+    it("arms an unreferenced reaper on every read", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1, 2, 3), Rows(4)]);
+        const timers = TimerRecorder();
+        await CapturingTimers(timers, REAPER_PROBE_MS, async () => {
+            await Read(reqId, open, PROBING);
+            await Read(reqId, open, PROBING);
+            await Read(reqId, open, PROBING);
+        });
+        (0, chai_1.expect)(timers.armed).to.have.length(3);
+        (0, chai_1.expect)(timers.armed.map((timer) => timer.hasRef())).to.deep.equal([
+            false,
+            false,
+            false,
+        ]);
+        await (0, cursors_1.CloseOneCursor)(reqId);
+    });
+    it("clears the reaper it armed on the previous read, and the last one on close", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1, 2, 3), Rows(4)]);
+        const timers = TimerRecorder();
+        await CapturingTimers(timers, REAPER_PROBE_MS, async () => {
+            await Read(reqId, open, PROBING);
+            await Read(reqId, open, PROBING);
+            await Read(reqId, open, PROBING);
+            (0, chai_1.expect)(timers.cleared).to.deep.equal([timers.armed[0], timers.armed[1]]);
+            await (0, cursors_1.CloseOneCursor)(reqId);
+        });
+        (0, chai_1.expect)(timers.cleared).to.deep.equal(timers.armed);
+    });
+    it("ignores a reaper timer that fired before a read re-armed it", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1, 2, 3)]);
+        const timers = TimerRecorder();
+        await CapturingTimers(timers, REAPER_PROBE_MS, async () => {
+            await Read(reqId, open, PROBING);
+            await Read(reqId, open, PROBING);
+        });
+        timers.handlers[STALE_TIMER]();
+        await Delay(REAP_WINDOW_MS);
+        (0, chai_1.expect)(log.statements).to.deep.equal([BEGIN, DECLARE, FETCH]);
+        (0, chai_1.expect)(log.releases).to.equal(0);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline + 1);
+        await (0, cursors_1.CloseOneCursor)(reqId);
+    });
+    it("keeps a reaper that fires mid-read from cutting into the read", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1, 2, 3), Rows(4, 5, 6)]);
+        const timers = TimerRecorder();
+        await CapturingTimers(timers, REAPER_PROBE_MS, async () => {
+            await Read(reqId, open, PROBING);
+            await Read(reqId, open, PROBING);
+            await Read(reqId, open, PROBING);
+            log.holdsNextFetch = true;
+            const held = Read(reqId, open, PROBING);
+            while (!log.resumeFetch) {
+                await Delay(NEXT_TURN_MS);
+            }
+            timers.handlers[timers.handlers.length - LAST_TIMER]();
+            log.resumeFetch();
+            (0, chai_1.expect)((await held).value).to.equal(4);
+        });
+        (0, chai_1.expect)(log.statements).to.deep.equal([BEGIN, DECLARE, FETCH, FETCH]);
+        (0, chai_1.expect)(log.releases).to.equal(0);
+        await (0, cursors_1.CloseOneCursor)(reqId);
+    });
+    it("reclaims a cursor left idle past its timeout, through the same teardown", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1, 2, 3), Rows(4)]);
+        (0, chai_1.expect)((await Read(reqId, open, REAPING)).value).to.equal(1);
+        await Delay(REAP_WINDOW_MS);
+        (0, chai_1.expect)(log.statements).to.deep.equal([
+            BEGIN,
+            DECLARE,
+            FETCH,
+            CLOSE,
+            ROLLBACK,
+            RELEASE,
+        ]);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+    });
+    it("fetches a literal count and binds no parameter to it", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1, 2, 3)]);
+        await Read(reqId, open);
+        await (0, cursors_1.CloseOneCursor)(reqId);
+        const fetched = log.statements.indexOf(FETCH);
+        (0, chai_1.expect)(log.statements[fetched]).to.equal(`FETCH FORWARD 3 FROM "antelopejs_cursor"`);
+        (0, chai_1.expect)(log.statements[fetched]).to.not.match(PARAM_MARKER);
+        (0, chai_1.expect)(log.bound[fetched]).to.deep.equal([]);
+    });
+    it("binds the rendered statement's parameters on the DECLARE", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1)]);
+        await Read(reqId, open);
+        await (0, cursors_1.CloseOneCursor)(reqId);
+        (0, chai_1.expect)(log.statements[DECLARE_POSITION]).to.equal(DECLARE);
+        (0, chai_1.expect)(log.statements[DECLARE_POSITION]).to.match(PARAM_MARKER);
+        (0, chai_1.expect)(log.bound[DECLARE_POSITION]).to.deep.equal(PARAMS);
+    });
+    it("closes every open cursor, and empties the registry", async () => {
+        const first = Recorder();
+        const second = Recorder();
+        await Read(NextReqId(), Requesting(first, [Rows(1, 2, 3)]));
+        await Read(NextReqId(), Requesting(second, [Rows(4, 5, 6)]));
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline + 2);
+        await (0, cursors_1.CloseAllCursors)();
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(0);
+        (0, chai_1.expect)([first.releases, second.releases]).to.deep.equal([1, 1]);
+        (0, chai_1.expect)([Count(first, ROLLBACK), Count(second, ROLLBACK)]).to.deep.equal([
+            1, 1,
+        ]);
+    });
+    it("opens nothing for a read that arrives while the sweep is running", async () => {
+        const held = Recorder();
+        const arriving = Recorder();
+        const heldId = NextReqId();
+        const arrivingId = NextReqId();
+        const openArriving = Requesting(arriving, [Rows(7, 8, 9)]);
+        let late;
+        let isAnswered = false;
+        held.whenReleased = () => {
+            late =
+                late ??
+                    Read(arrivingId, openArriving).then((answer) => {
+                        isAnswered = true;
+                        return answer;
+                    });
+        };
+        const openHeld = Requesting(held, [Rows(1, 2, 3), Rows(4, 5, 6)]);
+        (0, chai_1.expect)((await Read(heldId, openHeld)).value).to.equal(1);
+        await (0, cursors_1.CloseAllCursors)();
+        if (!late) {
+            throw new Error(NEVER_ARRIVED);
+        }
+        (0, chai_1.expect)(isAnswered).to.equal(true);
+        (0, chai_1.expect)((await late).done).to.equal(true);
+        (0, chai_1.expect)(arriving.acquires).to.equal(0);
+        (0, chai_1.expect)(arriving.statements).to.deep.equal([]);
+        (0, chai_1.expect)(held.acquires).to.equal(1);
+        (0, chai_1.expect)(held.releases).to.equal(1);
+    });
+    it("counts a cursor whose teardown is still on the wire as checked out", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1)]);
+        (0, chai_1.expect)((await Read(reqId, open)).value).to.equal(1);
+        log.holdsStatement = CLOSE;
+        const ending = Read(reqId, open);
+        const resume = await WhenHeld(log);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline + 1);
+        (0, chai_1.expect)(log.releases).to.equal(0);
+        resume();
+        (0, chai_1.expect)((await ending).done).to.equal(true);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+    });
+    it("does not resolve the sweep while a self-reclaim is still on the wire", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1)]);
+        (0, chai_1.expect)((await Read(reqId, open)).value).to.equal(1);
+        log.holdsStatement = CLOSE;
+        const ending = Read(reqId, open);
+        const resume = await WhenHeld(log);
+        let isSwept = false;
+        const sweeping = (0, cursors_1.CloseAllCursors)().then(() => {
+            isSwept = true;
+        });
+        await Settle();
+        (0, chai_1.expect)(isSwept).to.equal(false);
+        (0, chai_1.expect)(log.releases).to.equal(0);
+        resume();
+        await sweeping;
+        (0, chai_1.expect)(log.releases).to.equal(1);
+        (0, chai_1.expect)((await ending).done).to.equal(true);
+    });
+    it("does not resolve the sweep while an explicit close is still on the wire", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1, 2, 3), Rows(4)]);
+        (0, chai_1.expect)((await Read(reqId, open)).value).to.equal(1);
+        log.holdsStatement = CLOSE;
+        const closing = (0, cursors_1.CloseOneCursor)(reqId);
+        const resume = await WhenHeld(log);
+        let isSwept = false;
+        const sweeping = (0, cursors_1.CloseAllCursors)().then(() => {
+            isSwept = true;
+        });
+        await Settle();
+        (0, chai_1.expect)(isSwept).to.equal(false);
+        (0, chai_1.expect)(log.releases).to.equal(0);
+        resume();
+        await Promise.all([closing, sweeping]);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+    });
+    it("does not resolve the sweep while a reaper teardown is still on the wire", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1, 2, 3), Rows(4)]);
+        log.holdsStatement = CLOSE;
+        (0, chai_1.expect)((await Read(reqId, open, REAPING)).value).to.equal(1);
+        const resume = await WhenHeld(log);
+        let isSwept = false;
+        const sweeping = (0, cursors_1.CloseAllCursors)().then(() => {
+            isSwept = true;
+        });
+        await Settle();
+        (0, chai_1.expect)(isSwept).to.equal(false);
+        (0, chai_1.expect)(log.releases).to.equal(0);
+        resume();
+        await sweeping;
+        (0, chai_1.expect)(log.releases).to.equal(1);
+    });
+    it("hands every client back before the pool is ended", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [Rows(1)]);
+        (0, chai_1.expect)((await Read(reqId, open)).value).to.equal(1);
+        log.holdsStatement = CLOSE;
+        const ending = Read(reqId, open);
+        const resume = await WhenHeld(log);
+        let checkedOutAtEnd = NOT_OBSERVED;
+        let releasesAtEnd = NOT_OBSERVED;
+        const disconnecting = (0, connection_1.SettleBeforeDisconnect)(() => {
+            checkedOutAtEnd = (0, cursors_1.CountOpenCursors)();
+            releasesAtEnd = log.releases;
+            return Promise.resolve();
+        });
+        await Settle();
+        (0, chai_1.expect)(checkedOutAtEnd).to.equal(NOT_OBSERVED);
+        resume();
+        await disconnecting;
+        (0, chai_1.expect)(checkedOutAtEnd).to.equal(0);
+        (0, chai_1.expect)(releasesAtEnd).to.equal(1);
+        (0, chai_1.expect)((await ending).done).to.equal(true);
+    });
+    it("opens a run of descending ids after an eviction, refusing none of them", async () => {
+        await OverflowEndings();
+        for (let index = 0; index < DESCENDING_CURSORS; index += 1) {
+            const log = Recorder();
+            const rows = await Drain(NextReqId(), Requesting(log, [Rows(1, 2)]));
+            (0, chai_1.expect)(rows).to.deep.equal([1, 2]);
+            (0, chai_1.expect)(log.acquires).to.equal(1);
+            (0, chai_1.expect)(Count(log, BEGIN)).to.equal(1);
+        }
+    });
+    it("refuses a reqId whose exhaustion it has forgotten, rather than re-opening it", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Reopening(log, 1, 2);
+        (0, chai_1.expect)(await Drain(reqId, open)).to.deep.equal([1, 2]);
+        (0, chai_1.expect)((await Read(reqId, open)).done).to.equal(true);
+        await OverflowEndings();
+        const err = await Rejection(Read(reqId, open));
+        (0, chai_1.expect)(err.message).to.contain(`${reqId}`);
+        (0, chai_1.expect)(err.message).to.contain(FORGOTTEN_HINT);
+        (0, chai_1.expect)(log.acquires).to.equal(1);
+        (0, chai_1.expect)(Count(log, BEGIN)).to.equal(1);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+    });
+    it("refuses a reqId whose reaping it has forgotten, rather than re-serving its rows", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Reopening(log, 1, 2);
+        (0, chai_1.expect)((await Read(reqId, open, REAPING)).value).to.equal(1);
+        await Delay(REAP_WINDOW_MS);
+        (0, chai_1.expect)(log.releases).to.equal(1);
+        await OverflowEndings();
+        const err = await Rejection(Read(reqId, open));
+        (0, chai_1.expect)(err.message).to.contain(`${reqId}`);
+        (0, chai_1.expect)(err.message).to.contain(FORGOTTEN_HINT);
+        (0, chai_1.expect)(log.acquires).to.equal(1);
+        (0, chai_1.expect)(Count(log, BEGIN)).to.equal(1);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+    });
+    it("keeps serving a live cursor the forgotten range has grown around", async () => {
+        const live = Recorder();
+        const ended = Recorder();
+        const liveId = NextReqId();
+        const endedId = NextReqId();
+        const openLive = Reopening(live, 1, 2);
+        (0, chai_1.expect)((await Read(liveId, openLive)).value).to.equal(1);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline + 1);
+        (0, chai_1.expect)(await Drain(endedId, Reopening(ended, 3, 4))).to.deep.equal([3, 4]);
+        await OverflowEndings();
+        (0, chai_1.expect)((await Read(liveId, openLive)).value).to.equal(2);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline + 1);
+        (0, chai_1.expect)(live.acquires).to.equal(1);
+        (0, chai_1.expect)(Count(live, BEGIN)).to.equal(1);
+        await (0, cursors_1.CloseOneCursor)(liveId);
+        (0, chai_1.expect)(live.releases).to.equal(1);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+    });
+    it("refuses a reqId whose failed open it has forgotten, rather than answering done", async () => {
+        const log = Recorder();
+        const reqId = NextReqId();
+        const open = Requesting(log, [], DECLARE);
+        (0, chai_1.expect)((await Rejection(Read(reqId, open))).message).to.equal(STUB_FAILURE);
+        await OverflowEndings();
+        const err = await Rejection(Read(reqId, open));
+        (0, chai_1.expect)(err.message).to.contain(`${reqId}`);
+        (0, chai_1.expect)(err.message).to.contain(FORGOTTEN_HINT);
+        (0, chai_1.expect)(log.acquires).to.equal(1);
+        (0, chai_1.expect)((0, cursors_1.CountOpenCursors)()).to.equal(baseline);
+    });
+});
+//# sourceMappingURL=cursors.spec.js.map