test(debugger): consolidate runtime setting recovery coverage (#13042)

This commit is contained in:
morluto authored and GitHub committed 2026-11-21 08:12:59 +00:00
1 parent 3059921cc6
commit 67f8094efa
3 files changed
+103 -120

No files matched your search

-30
View File
@@ -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",
});
});
@@ -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.
@@ -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();
}