mirror of
https://github.com/morluto/rea.git
synced 2026-11-16 03:33:25 +00:00
311 lines
8.8 KiB
TypeScript
311 lines
8.8 KiB
TypeScript
import { expect, it, vi, onTestFinished } from "vitest";
|
|
import type {
|
|
ProcessSample,
|
|
TerminalFrame,
|
|
} from "../../domain/process/processCapture.js";
|
|
import { createProcessCaptureJournal } from "./ProcessCaptureJournal.js";
|
|
import {
|
|
createBoundedProcessTextNormalizer,
|
|
createProcessIdentifierLookup,
|
|
} from "./ProcessNormalization.js";
|
|
import { scheduleProcessDelay } from "./ProcessTimer.js";
|
|
import { TerminalRenderer } from "./TerminalRenderer.js";
|
|
import {
|
|
ProcessCaptureError,
|
|
processCaptureCancelled,
|
|
} from "./ProcessCaptureError.js";
|
|
import { AnalysisResourceConstraintError } from "../../domain/analysisErrorCore.js";
|
|
import { projectAnalysisError } from "../../domain/analysisErrorProjection.js";
|
|
import { processScenarioSchema } from "../../domain/process/processScenario.js";
|
|
import {
|
|
createProcessCaptureObservationBuffer,
|
|
resolveProcessResult,
|
|
ProcessCaptureResourceScope,
|
|
captureTerminalFrames,
|
|
} from "./ProcessCaptureLifecycle.js";
|
|
import { createProcessTerminalFinalizer } from "./ProcessTerminalObservation.js";
|
|
|
|
const createTerminalCleanupFixture = () => {
|
|
const scenario = processScenarioSchema.parse({
|
|
executable: "unused",
|
|
terminal: { columns: 80, rows: 4 },
|
|
normalization: { paths: false, ports: false },
|
|
});
|
|
const frames: TerminalFrame[] = [];
|
|
const samples: ProcessSample[] = [];
|
|
const journal = createProcessCaptureJournal();
|
|
const observations = createProcessCaptureObservationBuffer({
|
|
frames,
|
|
samples,
|
|
interactions: [],
|
|
eventJournal: journal.entries,
|
|
before: undefined,
|
|
});
|
|
const identifiers = createProcessIdentifierLookup(samples, () => 100);
|
|
const normalize = createBoundedProcessTextNormalizer(
|
|
scenario,
|
|
"/tmp",
|
|
identifiers,
|
|
);
|
|
const renderer = new TerminalRenderer({
|
|
...scenario.terminal,
|
|
maxBytes: scenario.limits.output_bytes,
|
|
normalize,
|
|
recordEvent: journal.recordEvent,
|
|
});
|
|
const rendererState = { released: false };
|
|
onTestFinished(async () => {
|
|
if (!rendererState.released) await renderer.dispose();
|
|
});
|
|
const events: string[] = [];
|
|
let onData: ((data: string) => void) | undefined;
|
|
const terminal = {
|
|
pid: 100,
|
|
onData: (callback: (data: string) => void) => {
|
|
onData = callback;
|
|
return {
|
|
dispose: () => {
|
|
events.push("input sealed");
|
|
},
|
|
};
|
|
},
|
|
};
|
|
const retention = captureTerminalFrames({
|
|
terminal,
|
|
scenario,
|
|
frames,
|
|
started: 0,
|
|
onOutput: () => undefined,
|
|
renderer,
|
|
normalizeText: normalize,
|
|
identifiers,
|
|
recordEvent: journal.recordEvent,
|
|
});
|
|
const owner = createProcessTerminalFinalizer(
|
|
renderer,
|
|
retention,
|
|
observations,
|
|
);
|
|
return {
|
|
scenario,
|
|
frames,
|
|
samples,
|
|
journal,
|
|
observations,
|
|
renderer,
|
|
rendererState,
|
|
events,
|
|
owner,
|
|
emitOutput: (data: string) => onData?.(data),
|
|
};
|
|
};
|
|
|
|
it("retains completed terminal facts and the typed capacity failure through finalization", async () => {
|
|
const failure = new AnalysisResourceConstraintError(
|
|
"capture_process",
|
|
"capacity",
|
|
"Sampled PID projection exceeded output_bytes",
|
|
{ maximum_output_bytes: 4 },
|
|
);
|
|
const readRetention = vi.fn(() => {
|
|
throw failure;
|
|
});
|
|
const frames = [{ sequence: 0, at_ms: 17, data: "20" }];
|
|
const observations = createProcessCaptureObservationBuffer({
|
|
frames,
|
|
samples: [],
|
|
interactions: [],
|
|
eventJournal: [],
|
|
before: undefined,
|
|
});
|
|
const rendered = [
|
|
{
|
|
sequence: 0,
|
|
at_ms: 17,
|
|
columns: 10,
|
|
rows: 1,
|
|
cursor_x: 0,
|
|
cursor_y: 0,
|
|
active_buffer: "normal" as const,
|
|
lines: [""],
|
|
serialized_state: "",
|
|
},
|
|
];
|
|
const closeFailure = new Error("renderer close failed once");
|
|
const renderer = {
|
|
frames: vi.fn(async () => rendered),
|
|
dispose: vi
|
|
.fn<() => Promise<void>>()
|
|
.mockRejectedValueOnce(closeFailure)
|
|
.mockResolvedValue(undefined),
|
|
};
|
|
const finalize = createProcessTerminalFinalizer(
|
|
renderer,
|
|
readRetention,
|
|
observations,
|
|
);
|
|
const result = await finalize.complete();
|
|
await expect(finalize.dispose()).rejects.toBe(closeFailure);
|
|
await finalize.dispose();
|
|
expect(await finalize.complete()).toBe(result);
|
|
expect(readRetention).toHaveBeenCalledOnce();
|
|
expect(renderer.frames).toHaveBeenCalledOnce();
|
|
if (result.ok) throw new Error("Expected terminal capacity refusal");
|
|
expect(result.error).toBe(failure);
|
|
expect(observations.rendered_frames).toEqual({
|
|
state: "available",
|
|
value: rendered,
|
|
});
|
|
const scenario = processScenarioSchema.parse({
|
|
executable: "unused",
|
|
limits: { output_bytes: 4 },
|
|
});
|
|
const cleanup = { state: "not_required" as const, reason: null };
|
|
expect(() =>
|
|
resolveProcessResult(
|
|
undefined,
|
|
result.error,
|
|
{
|
|
report: {
|
|
owned_process_group: cleanup,
|
|
terminal_renderer: cleanup,
|
|
temporary_root: cleanup,
|
|
},
|
|
cleanupLease: undefined,
|
|
},
|
|
observations,
|
|
{ scenario, rootPid: 100 },
|
|
),
|
|
).toThrow(failure);
|
|
expect(projectAnalysisError(failure)).toMatchObject({
|
|
code: "resource_constraint",
|
|
details: {
|
|
partial_observation: {
|
|
observations: {
|
|
frames: { state: "available", value: frames },
|
|
rendered_frames: { state: "available", value: rendered },
|
|
},
|
|
},
|
|
},
|
|
});
|
|
});
|
|
|
|
it.each(["cancelled", "failed"] as const)(
|
|
"stops pending interactions and the target before sealing %s terminal facts",
|
|
async (outcome) => {
|
|
const {
|
|
scenario,
|
|
frames,
|
|
samples,
|
|
journal,
|
|
observations,
|
|
renderer,
|
|
rendererState,
|
|
events,
|
|
owner,
|
|
emitOutput,
|
|
} = createTerminalCleanupFixture();
|
|
let pendingInteraction: (() => void) | undefined;
|
|
const timer = scheduleProcessDelay(
|
|
100,
|
|
() => {
|
|
events.push("unexpected interaction");
|
|
renderer.resize(40, 4, 2);
|
|
},
|
|
(callback) => {
|
|
pendingInteraction = callback;
|
|
return {
|
|
cancel: () => {
|
|
events.push("timer cancelled");
|
|
},
|
|
};
|
|
},
|
|
);
|
|
emitOutput("root 100\r\n");
|
|
const cleanup = await new ProcessCaptureResourceScope().release({
|
|
timers: new Set([timer]),
|
|
terminal: { pid: 100 },
|
|
renderer: owner,
|
|
runId: "fixture-run",
|
|
temporaryRoot: "/fixture/temporary-root",
|
|
host: {
|
|
platform: "linux",
|
|
cleanupProcessGroup: async () => {
|
|
events.push("target stopped");
|
|
pendingInteraction?.();
|
|
emitOutput("child 200\r\n");
|
|
samples.push({
|
|
at_ms: 1,
|
|
pid: 200,
|
|
parent_pid: 100,
|
|
process_group_id: 100,
|
|
session_id: null,
|
|
command: "child",
|
|
});
|
|
journal.recordEvent("process_samples", 0);
|
|
return { cleaned: true, signaled: true };
|
|
},
|
|
removeTemporaryRoot: async () => {
|
|
events.push("temporary root removed");
|
|
},
|
|
},
|
|
});
|
|
rendererState.released =
|
|
cleanup.report.terminal_renderer.state === "cleaned";
|
|
expect(events).toEqual([
|
|
"timer cancelled",
|
|
"target stopped",
|
|
"input sealed",
|
|
"temporary root removed",
|
|
]);
|
|
const completed = await owner.complete();
|
|
if (!completed.ok) throw completed.error;
|
|
emitOutput("late callback after sealing");
|
|
expect(await owner.complete()).toBe(completed);
|
|
expect(completed.value.retention.raw_terminal).toMatchObject({
|
|
observed_frames: 2,
|
|
retained_frames: 2,
|
|
observed_bytes: 21,
|
|
retained_bytes: 21,
|
|
});
|
|
expect(frames.map(({ data }) => data).join("")).toBe(
|
|
"root <pid>\r\nchild <pid>\r\n",
|
|
);
|
|
expect(frames.map(({ raw_data, data }) => raw_data ?? data).join("")).toBe(
|
|
"root 100\r\nchild 200\r\n",
|
|
);
|
|
expect(completed.value.renderedFrames.at(-1)?.lines).toEqual(
|
|
expect.arrayContaining(["root <pid>", "child <pid>"]),
|
|
);
|
|
const reason = new Error("original capture failure");
|
|
const primary =
|
|
outcome === "cancelled" ? processCaptureCancelled(reason) : reason;
|
|
let failure: unknown;
|
|
try {
|
|
resolveProcessResult(undefined, primary, cleanup, observations, {
|
|
scenario,
|
|
rootPid: 100,
|
|
});
|
|
} catch (cause: unknown) {
|
|
failure = cause;
|
|
}
|
|
if (!(failure instanceof ProcessCaptureError))
|
|
throw new Error("Expected a typed capture failure");
|
|
expect(failure.cause).toBe(reason);
|
|
expect(projectAnalysisError(failure)).toMatchObject({
|
|
code: outcome === "cancelled" ? "cancelled" : "process_capture_failed",
|
|
details: {
|
|
partial_observation: {
|
|
observations: {
|
|
frames: { state: "available", value: frames },
|
|
rendered_frames: {
|
|
state: "available",
|
|
value: completed.value.renderedFrames,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
});
|
|
},
|
|
);
|