mirror of
https://github.com/morluto/rea.git
synced 2026-11-16 19:53:50 +00:00
* fix(desktop)!: preserve build evidence and validate task inputs BREAKING CHANGE: Witnessing requires the current generated verifier. Re-export bundles with older evaluators using the original capture Evidence and task inputs. * test(desktop): match reader source inspection diagnostics Unreadable reader sources now report the source inspection failure, including the operating-system reason, instead of the old file wording. * fix(environment): advertise canonical bundle names (#9939) fix(environment): advertise portable bundle name constraints --------- Co-authored-by: Cursor Agent <cursoragent@cursor.com>
226 lines
8.2 KiB
TypeScript
226 lines
8.2 KiB
TypeScript
import { expect, it } from "vitest";
|
|
|
|
import { ProviderCleanupError } from "../../domain/providerCleanupError.js";
|
|
import { AnalysisCancelledError } from "../../domain/analysisErrorCore.js";
|
|
import { PYTHON_READER_CLEANUP } from "../../domain/desktop/appTaskReaders.js";
|
|
import { DesktopRemoteTaskReaders } from "./DesktopRemoteTaskReaders.js";
|
|
|
|
const reader = {
|
|
id: "note",
|
|
file: "Documents/note",
|
|
argv: ["reader", "{file}"],
|
|
output: "json" as const,
|
|
};
|
|
const success = {
|
|
exit_code: 0,
|
|
timed_out: false,
|
|
stdout: JSON.stringify({ view: { format: "json", view: { value: 7 } } }),
|
|
stderr: "",
|
|
};
|
|
|
|
it("retains a completed view and retries an owned folder when cleanup fails", async () => {
|
|
let cleanups = 0;
|
|
const owner = new DesktopRemoteTaskReaders(async (argv) => {
|
|
if (argv[3] !== PYTHON_READER_CLEANUP) return success;
|
|
cleanups += 1;
|
|
return cleanups === 1
|
|
? { ...success, exit_code: 1, stderr: "permission denied" }
|
|
: success;
|
|
});
|
|
const failure = await owner
|
|
.read([reader], new AbortController().signal)
|
|
.catch((error: unknown) => error);
|
|
expect(failure).toBeInstanceOf(ProviderCleanupError);
|
|
if (!(failure instanceof ProviderCleanupError))
|
|
throw new Error("expected cleanup failure");
|
|
expect(failure.diagnostics).toMatchObject({
|
|
completed_reader_views: { note: { format: "json", view: { value: 7 } } },
|
|
});
|
|
expect(owner.cleanupResources).toHaveLength(2);
|
|
expect(await owner.release()).toMatchObject({ verified: true });
|
|
expect(owner.cleanupResources).toEqual([]);
|
|
expect(failure.cleanupIncomplete).toBe(false);
|
|
});
|
|
|
|
it("waits for an interrupted reader before removing its folder", async () => {
|
|
const controller = new AbortController();
|
|
const calls: { requestId: string | undefined; cleanup: boolean }[] = [];
|
|
let finish: ((value: typeof success) => void) | undefined;
|
|
const owner = new DesktopRemoteTaskReaders(
|
|
async (argv, _timeout, _signal, requestId) => {
|
|
const cleanup = argv[3] === PYTHON_READER_CLEANUP;
|
|
calls.push({ requestId, cleanup });
|
|
return cleanup
|
|
? success
|
|
: new Promise<typeof success>((resolve) => {
|
|
finish = resolve;
|
|
});
|
|
},
|
|
);
|
|
const read = owner
|
|
.read([reader], controller.signal)
|
|
.catch((error: unknown) => error);
|
|
await Promise.resolve();
|
|
controller.abort(new Error("cancelled"));
|
|
const failure = await read;
|
|
expect(failure).toBeInstanceOf(ProviderCleanupError);
|
|
expect(owner.cleanupResources).toHaveLength(2);
|
|
const release = owner.release();
|
|
await Promise.resolve();
|
|
expect(calls.map(({ cleanup }) => cleanup)).toEqual([false]);
|
|
if (finish === undefined) throw new Error("reader did not start");
|
|
finish(success);
|
|
expect(await release).toMatchObject({ verified: true });
|
|
expect(calls.map(({ cleanup }) => cleanup)).toEqual([false, true]);
|
|
if (!(failure instanceof ProviderCleanupError))
|
|
throw new Error("expected cleanup failure");
|
|
expect(failure.diagnostics).toMatchObject({
|
|
completed_reader_views: { note: { view: { value: 7 } } },
|
|
});
|
|
});
|
|
|
|
it("preserves a completed view when cancellation arrives during successful cleanup", async () => {
|
|
const controller = new AbortController();
|
|
const reason = { stage: "reader final cleanup" };
|
|
const owner = new DesktopRemoteTaskReaders(async (argv) => {
|
|
if (argv[3] === PYTHON_READER_CLEANUP) controller.abort(reason);
|
|
return success;
|
|
});
|
|
const failure = await owner
|
|
.read([reader], controller.signal)
|
|
.catch((error: unknown) => error);
|
|
if (!(failure instanceof AnalysisCancelledError))
|
|
throw new Error("expected cancellation");
|
|
expect(failure.cause).toBe(reason);
|
|
expect(failure.diagnostics).toMatchObject({
|
|
completed_reader_views: { note: { view: { value: 7 } } },
|
|
});
|
|
expect(owner.cleanupResources).toEqual([]);
|
|
});
|
|
|
|
it("keeps cancellation and a completed view when final cleanup also fails", async () => {
|
|
const controller = new AbortController();
|
|
const reason = { stage: "reader final cleanup" };
|
|
let fail = true;
|
|
const owner = new DesktopRemoteTaskReaders(async (argv) => {
|
|
if (argv[3] !== PYTHON_READER_CLEANUP) return success;
|
|
if (fail) {
|
|
fail = false;
|
|
controller.abort(reason);
|
|
return { ...success, exit_code: 1, stderr: "denied" };
|
|
}
|
|
return success;
|
|
});
|
|
const failure = await owner
|
|
.read([reader], controller.signal)
|
|
.catch((error: unknown) => error);
|
|
if (!(failure instanceof ProviderCleanupError))
|
|
throw new Error("expected cleanup failure");
|
|
expect(failure.cleanupPrimary).toBeInstanceOf(AnalysisCancelledError);
|
|
expect(failure.cleanupPrimary?.cause).toBe(reason);
|
|
expect(failure.diagnostics).toMatchObject({
|
|
completed_reader_views: { note: { view: { value: 7 } } },
|
|
});
|
|
expect(await owner.release()).toMatchObject({ verified: true });
|
|
});
|
|
|
|
it("retains earlier views when a later reader's cleanup fails", async () => {
|
|
let cleanup = 0;
|
|
const owner = new DesktopRemoteTaskReaders(async (argv) => {
|
|
if (argv[3] !== PYTHON_READER_CLEANUP) return success;
|
|
cleanup += 1;
|
|
return cleanup === 2
|
|
? { ...success, exit_code: 1, stderr: "denied" }
|
|
: success;
|
|
});
|
|
const failure = await owner
|
|
.read([reader, { ...reader, id: "second" }], new AbortController().signal)
|
|
.catch((error: unknown) => error);
|
|
if (!(failure instanceof ProviderCleanupError))
|
|
throw new Error("expected cleanup failure");
|
|
expect(failure.diagnostics).toMatchObject({
|
|
completed_reader_views: {
|
|
note: { view: { value: 7 } },
|
|
second: { view: { value: 7 } },
|
|
},
|
|
});
|
|
expect(await owner.release()).toMatchObject({ verified: true });
|
|
});
|
|
|
|
it("retains an unknown transport outcome without starting the reader again", async () => {
|
|
let calls = 0;
|
|
const owner = new DesktopRemoteTaskReaders(async () => {
|
|
calls += 1;
|
|
throw new Error("connection lost");
|
|
});
|
|
await expect(
|
|
owner.read([reader], new AbortController().signal),
|
|
).rejects.toBeInstanceOf(ProviderCleanupError);
|
|
expect(await owner.release()).toMatchObject({ verified: false });
|
|
expect(calls).toBe(1);
|
|
expect(owner.cleanupResources).toHaveLength(2);
|
|
});
|
|
|
|
it("retains a timed-out runner's folder because its separate reader session may still run", async () => {
|
|
let calls = 0;
|
|
const owner = new DesktopRemoteTaskReaders(async () => {
|
|
calls += 1;
|
|
return { ...success, exit_code: null, timed_out: true };
|
|
});
|
|
await expect(
|
|
owner.read([reader], new AbortController().signal),
|
|
).rejects.toBeInstanceOf(ProviderCleanupError);
|
|
expect(await owner.release()).toMatchObject({ verified: false });
|
|
expect(calls).toBe(1);
|
|
expect(owner.cleanupResources).toHaveLength(2);
|
|
});
|
|
|
|
it("does not start a second cleanup while a timed-out cleanup may still be running", async () => {
|
|
let calls = 0;
|
|
const owner = new DesktopRemoteTaskReaders(async (argv) => {
|
|
if (argv[3] !== PYTHON_READER_CLEANUP) return success;
|
|
calls += 1;
|
|
return { ...success, exit_code: null, timed_out: true };
|
|
});
|
|
await expect(
|
|
owner.read([reader], new AbortController().signal),
|
|
).rejects.toBeInstanceOf(ProviderCleanupError);
|
|
expect(await owner.release()).toMatchObject({ verified: false });
|
|
expect(calls).toBe(1);
|
|
expect(owner.cleanupResources).toHaveLength(2);
|
|
});
|
|
|
|
it.each([
|
|
{ ...success, exit_code: 4, stderr: "reader failed" },
|
|
{ ...success, stdout: "invalid reader answer" },
|
|
])(
|
|
"preserves earlier views and absences when a later runner fails after settling (%#)",
|
|
async (failed) => {
|
|
let readers = 0;
|
|
const owner = new DesktopRemoteTaskReaders(async (argv) => {
|
|
if (argv[3] === PYTHON_READER_CLEANUP) return success;
|
|
readers += 1;
|
|
if (readers === 1) return success;
|
|
if (readers === 2)
|
|
return { ...success, stdout: JSON.stringify({ absent: true }) };
|
|
return failed;
|
|
});
|
|
const failure = await owner
|
|
.read(
|
|
[reader, { ...reader, id: "absent" }, { ...reader, id: "failed" }],
|
|
new AbortController().signal,
|
|
)
|
|
.catch((error: unknown) => error);
|
|
expect(failure).toMatchObject({
|
|
operation: "check_build_task",
|
|
diagnostics: {
|
|
completed_reader_views: {
|
|
note: { format: "json", view: { value: 7 } },
|
|
},
|
|
completed_reader_absent: ["absent"],
|
|
},
|
|
});
|
|
expect(owner.cleanupResources).toEqual([]);
|
|
},
|
|
);
|