Files
rea/src/application/javascript/JavaScriptAnalysisControl.test.ts
T
morluto 7bcefead69 test: strengthen and prune audited test coverage (#8573)
* test: strengthen and prune audited test coverage

* test: require delivered DeepSeek skill instructions

* test: keep schema fixture types private

* test: verify Gemini receives skill instructions

* test: bind Qwen skill evidence to its tool result

* test: report NativeAOT verifier checks precisely

* fix: verify Ghidra cleanup paths reliably

* fix: verify Command Code skill activation

* test: tighten cleanup and fixture checks

* test: verify packet capture evidence is recorded

* fix: report HTTP3 capture provenance accurately

* test: preserve resource coverage through MCP

* test: prune repeated assertions and retain cancellation identity

* fix: validate client verifier fixture paths

* test: skip Copilot verifier cases on Windows

* test: keep verifier setup target relative
2026-11-02 02:13:32 +08:00

63 lines
2.1 KiB
TypeScript

import { setImmediate } from "node:timers/promises";
import { describe, expect, it } from "vitest";
import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
import { completeJavaScriptAnalysisSteps } from "./JavaScriptAnalysisControl.js";
describe("JavaScript cooperative computation lifecycle", () => {
it("observes scheduler cancellation and closes abandoned work", async () => {
const controller = new AbortController();
const reason = { request: "caller cancelled computation" };
let released = false;
function* work(): Generator<void, number> {
try {
for (;;) yield;
} finally {
released = true;
}
}
const cancellation = setImmediate().then(() => controller.abort(reason));
const failure = await completeJavaScriptAnalysisSteps(
work(),
controller.signal,
).then(
() => {
throw new Error("Expected cancellation");
},
(cause: unknown) => cause,
);
expect(failure).toBeInstanceOf(ArtifactReaderFailure);
if (!(failure instanceof ArtifactReaderFailure)) throw failure;
expect(failure.reason).toBe("cancelled");
expect(failure.cause).toBe(reason);
await cancellation;
expect(released).toBe(true);
});
it("does not start pre-cancelled work and preserves completed values", async () => {
const controller = new AbortController();
const reason = { request: "caller cancelled computation" };
controller.abort(reason);
let started = false;
function* work(): Generator<void, number> {
started = true;
yield;
return 42;
}
const failure = await completeJavaScriptAnalysisSteps(
work(),
controller.signal,
).then(
() => {
throw new Error("Expected cancellation");
},
(cause: unknown) => cause,
);
expect(failure).toBeInstanceOf(ArtifactReaderFailure);
if (!(failure instanceof ArtifactReaderFailure)) throw failure;
expect(failure.reason).toBe("cancelled");
expect(failure.cause).toBe(reason);
expect(started).toBe(false);
expect(await completeJavaScriptAnalysisSteps(work())).toBe(42);
});
});