diff --git a/src/config/debuggerSessionLimits.test.ts b/src/config/debuggerSessionLimits.test.ts index a8b8036fe5..07691955b9 100644 --- a/src/config/debuggerSessionLimits.test.ts +++ b/src/config/debuggerSessionLimits.test.ts @@ -16,7 +16,6 @@ import { MINIMUM_DEBUGGER_MAX_SESSIONS, MAX_NODE_TIMER_DELAY_MS, } from "../domain/analysisResourceLimits.js"; -import { GdbSessionManager } from "../gdb/GdbSessionManager.js"; import { RizinDebugSessionManager } from "../rizin/RizinDebugSessionManager.js"; import { runWithAnalysisOperationSnapshot } from "../domain/analysisOperationSnapshot.js"; import { parseEnvironment } from "./environment.js"; @@ -192,10 +191,6 @@ it("keeps the command-output maximum inside one Evidence hash string", () => { const expansion = escaped.length - 2; const nodeMaxStringLength = 536_870_888; const envelope = 1024 * 1024; - expect(expansion).toBe(6); - expect(MAXIMUM_DEBUGGER_MAX_COMMAND_OUTPUT_BYTES).toBe( - Math.floor((nodeMaxStringLength - envelope) / expansion), - ); expect(MAXIMUM_DEBUGGER_MAX_COMMAND_OUTPUT_BYTES).toBeGreaterThanOrEqual( DEFAULT_DEBUGGER_MAX_COMMAND_OUTPUT_BYTES, ); @@ -261,28 +256,3 @@ it("enforces each Rizin manager's cap and reports which setting refused a start" await blocked; } }); - -it("defers an invalid GDB deadline until a command reads it", () => { - expect( - () => - new GdbSessionManager({ - environment: { [DEBUGGER_COMMAND_DEADLINE_SETTING]: "0" }, - }), - ).not.toThrow(); - const parsed = parseDebuggerSessionLimits({ - [DEBUGGER_COMMAND_DEADLINE_SETTING]: "0", - }); - if (parsed.ok) throw new Error("invalid deadline was accepted"); - expect(projectAnalysisError(parsed.error)).toMatchObject({ - code: "configuration_invalid", - details: { settings: parsed.error.settings }, - }); - const valid = parseDebuggerSessionLimits({ - [DEBUGGER_COMMAND_DEADLINE_SETTING]: "1500", - }); - if (!valid.ok) throw valid.error; - expect(valid.value.commandDeadline).toMatchObject({ - value: 1500, - source: "setting", - }); -}); diff --git a/tests/boundary/providers/GdbSessionManagers.test.ts b/tests/boundary/providers/GdbSessionManagers.test.ts index 7f51e0e4d5..15e7077279 100644 --- a/tests/boundary/providers/GdbSessionManagers.test.ts +++ b/tests/boundary/providers/GdbSessionManagers.test.ts @@ -93,64 +93,70 @@ describe("persistent debugger session managers", () => { expect(manager.status(started.value.session_id)).toBeUndefined(); }); - it.each([ - ["debugger.command_deadline_ms", "REA_DEBUGGER_COMMAND_DEADLINE_MS", 5000], - [ - "debugger.max_command_output_bytes", - "REA_DEBUGGER_MAX_COMMAND_OUTPUT_BYTES", - 4096, - ], - ] as const)( - "restores a GDB session after resetting invalid %s", - async (setting, environmentName, value) => { - directory = await mkdtemp(join(tmpdir(), "rea-gdb-setting-")); - const provider = join(directory, "fake-gdb.mjs"); - await writeFile(provider, gdbFixture(directory)); - await chmod(provider, 0o700); - const environment = { - REA_GDB_COMMAND: provider, - [environmentName]: "invalid", - }; - const settings = new AnalysisSettings(environment); - const set = () => - settings.update({ changes: [{ setting, action: "set", value }] }); - const reset = () => - settings.update({ changes: [{ setting, action: "reset" }] }); - const affectsControlCommands = setting === "debugger.command_deadline_ms"; - if (affectsControlCommands) expect(set().ok).toBe(true); - const manager = new GdbSessionManager({ - spawnProcess: fixtureOwner.spawnProcess, - platform: "linux", - environment, - }); - managers.push(manager); - const started = await settings.run(() => manager.start()); - if (!started.ok) throw started.error; - const execute = () => - settings.run(() => - manager.execute(started.value.session_id, "show version"), - ); - const expectRefusedCommand = async () => - expect(await execute()).toMatchObject({ - ok: false, - error: { _tag: "ConfigurationError" }, - }); - if (!affectsControlCommands) { - await expectRefusedCommand(); - expect(set().ok).toBe(true); - } - expect((await execute()).ok).toBe(true); - expect(reset().ok).toBe(true); - await expectRefusedCommand(); - expect(set().ok).toBe(true); - expect((await execute()).ok).toBe(true); - - if (!affectsControlCommands) expect(reset().ok).toBe(true); + it("recovers GDB commands after either runtime cap is reset to an invalid seed", async () => { + directory = await mkdtemp(join(tmpdir(), "rea-gdb-setting-")); + const provider = join(directory, "fake-gdb.mjs"); + await writeFile(provider, gdbFixture(directory)); + await chmod(provider, 0o700); + const environment = { + REA_GDB_COMMAND: provider, + REA_DEBUGGER_COMMAND_DEADLINE_MS: "invalid", + REA_DEBUGGER_MAX_COMMAND_OUTPUT_BYTES: "invalid", + REA_DEBUGGER_MAX_PENDING_COMMANDS: "1", + }; + const deadline = { + setting: "debugger.command_deadline_ms", + seed: "REA_DEBUGGER_COMMAND_DEADLINE_MS", + value: 5000, + }; + const output = { + setting: "debugger.max_command_output_bytes", + seed: "REA_DEBUGGER_MAX_COMMAND_OUTPUT_BYTES", + value: 4096, + }; + const settings = new AnalysisSettings(environment); + const set = ({ setting, value }: typeof deadline) => expect( - await settings.run(() => manager.close(started.value.session_id)), - ).toMatchObject({ ok: true, value: { target_state: "none_observed" } }); - }, - ); + settings.update({ changes: [{ setting, action: "set", value }] }).ok, + ).toBe(true); + const reset = ({ setting }: typeof deadline) => + expect( + settings.update({ changes: [{ setting, action: "reset" }] }).ok, + ).toBe(true); + set(deadline); + const manager = new GdbSessionManager({ + spawnProcess: fixtureOwner.spawnProcess, + platform: "linux", + environment, + }); + managers.push(manager); + const started = await settings.run(() => manager.start()); + if (!started.ok) throw started.error; + const { session_id: sessionId } = started.value; + const execute = (command: string) => + settings.run(() => manager.execute(sessionId, command)); + const expectRefusedCommand = async (seed: string) => + expect(await execute("refused")).toMatchObject({ + ok: false, + error: { _tag: "ConfigurationError", settings: [{ setting: seed }] }, + }); + await expectRefusedCommand(output.seed); + set(output); + for (const cap of [deadline, output]) { + reset(cap); + await expectRefusedCommand(cap.seed); + set(cap); + const retried = await execute("show version"); + if (!retried.ok) throw retried.error; + expect(retried.value.result.mi).toMatch(/^\d+\^done/u); + } + + reset(output); + expect(await settings.run(() => manager.close(sessionId))).toMatchObject({ + ok: true, + value: { target_state: "none_observed" }, + }); + }); // A malformed ^done is not a success record: the typed MI parser refuses it // where a ^done prefix match would have accepted the setting. diff --git a/tests/boundary/providers/RizinDebugSessionAdmission.test.ts b/tests/boundary/providers/RizinDebugSessionAdmission.test.ts index e4cf92353a..d43afe9834 100644 --- a/tests/boundary/providers/RizinDebugSessionAdmission.test.ts +++ b/tests/boundary/providers/RizinDebugSessionAdmission.test.ts @@ -51,25 +51,33 @@ it.skipIf(process.platform === "win32")( }, ); -it.skipIf(process.platform === "win32").each([ - ["debugger.command_deadline_ms", "REA_DEBUGGER_COMMAND_DEADLINE_MS", 5000], - [ - "debugger.max_command_output_bytes", - "REA_DEBUGGER_MAX_COMMAND_OUTPUT_BYTES", - 4096, - ], -] as const)( - "releases command capacity after an invalid %s is reset", - async (setting, environmentName, value) => { +it.skipIf(process.platform === "win32")( + "recovers Rizin command capacity after either runtime cap exposes an invalid seed", + async () => { const harness = createRizinCoverageHarness(); const environment = { - [environmentName]: "invalid", + REA_DEBUGGER_COMMAND_DEADLINE_MS: "invalid", + REA_DEBUGGER_MAX_COMMAND_OUTPUT_BYTES: "invalid", REA_DEBUGGER_MAX_PENDING_COMMANDS: "1", }; + const caps = [ + { + setting: "debugger.command_deadline_ms", + seed: "REA_DEBUGGER_COMMAND_DEADLINE_MS", + value: 5000, + }, + { + setting: "debugger.max_command_output_bytes", + seed: "REA_DEBUGGER_MAX_COMMAND_OUTPUT_BYTES", + value: 4096, + }, + ]; const settings = new AnalysisSettings(environment); - const set = () => - settings.update({ changes: [{ setting, action: "set", value }] }); - expect(set().ok).toBe(true); + const set = ({ setting, value }: (typeof caps)[number]) => + expect( + settings.update({ changes: [{ setting, action: "set", value }] }).ok, + ).toBe(true); + for (const cap of caps) set(cap); try { const provider = await harness.makeProvider(`process.stdout.write("\\0"); let input = ""; @@ -80,6 +88,7 @@ process.stdin.on("data", chunk => { const end = input.indexOf("\\n"); if (end < 0) break; const line = input.slice(0,end); input = input.slice(end+1); if (line.startsWith("!echo ")) process.stdout.write(line.slice(6) + "\\0"); + else if (line === "refused") process.stdout.write("unexpected command\\0"); else if (line === "dr") process.stdout.write("ok\\0"); } });`); @@ -88,26 +97,24 @@ process.stdin.on("data", chunk => { {}, environment, ); - expect( - (await settings.run(() => manager.execute(sessionId, "dr"))).ok, - ).toBe(true); - expect( - settings.update({ changes: [{ setting, action: "reset" }] }).ok, - ).toBe(true); - await expect( - settings.run(() => manager.execute(sessionId, "dr")), - ).resolves.toMatchObject({ - ok: false, - error: { _tag: "ConfigurationError" }, - }); - expect(set().ok).toBe(true); - const retried = await settings.run(() => - manager.execute(sessionId, "dr"), + const execute = (command: string) => + settings.run(() => manager.execute(sessionId, command)); + for (const { setting, seed, value } of caps) { + expect( + settings.update({ changes: [{ setting, action: "reset" }] }).ok, + ).toBe(true); + expect(await execute("refused")).toMatchObject({ + ok: false, + error: { _tag: "ConfigurationError", settings: [{ setting: seed }] }, + }); + set({ setting, seed, value }); + const retried = await execute("dr"); + if (!retried.ok) throw retried.error; + expect(retried.value.result.output).toBe("ok"); + } + expect(manager.status(sessionId)?.recent_output).not.toContain( + "unexpected command", ); - expect(retried).toMatchObject({ - ok: true, - value: { result: { output: "ok" } }, - }); } finally { await harness.cleanup(); }