mirror of
https://github.com/morluto/rea.git
synced 2026-11-18 20:53:00 +00:00
682 lines
23 KiB
TypeScript
682 lines
23 KiB
TypeScript
import { createHash } from "node:crypto";
|
|
import { fileURLToPath } from "node:url";
|
|
import { access } from "node:fs/promises";
|
|
import { expect, it, vi } from "vitest";
|
|
import { PrivateRuntimeRootUnavailableError } from "../../../src/domain/privateRuntimeRootUnavailableError.js";
|
|
import { ProviderCleanupError } from "../../../src/domain/providerCleanupError.js";
|
|
import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js";
|
|
import { SourceMapDecoder } from "../../../src/javascript/sourceMaps/SourceMapDecoder.js";
|
|
import type { SourceMapDecoderDependencies } from "../../../src/javascript/sourceMaps/SourceMapCommand.js";
|
|
import { PrivateRuntimeRoot } from "../../../src/process/PrivateRuntimeRoot.js";
|
|
import { spawnOwnedProviderProcess } from "../../../src/process/ProviderProcess.js";
|
|
import { waitForProviderProcessReady } from "../../fixtures/providerProcess.js";
|
|
import {
|
|
webSourceLocationArgs,
|
|
webSourceLocationFixture,
|
|
} from "../../fixtures/webSourceLocation.js";
|
|
|
|
const expectedProcessMemoryLimitBytes =
|
|
process.platform === "win32" && process.versions.bun !== undefined
|
|
? 704 * 1024 * 1024
|
|
: null;
|
|
|
|
const realDecoder = (dependencies: SourceMapDecoderDependencies = {}) =>
|
|
new SourceMapDecoder({
|
|
...dependencies,
|
|
launcher:
|
|
dependencies.launcher ??
|
|
((options) =>
|
|
spawnOwnedProviderProcess({
|
|
...options,
|
|
arguments: options.arguments.map((argument) =>
|
|
argument.endsWith("/SourceMapCodecProcess.js") ||
|
|
argument.endsWith("\\SourceMapCodecProcess.js")
|
|
? fileURLToPath(
|
|
new URL(
|
|
"../../../dist/javascript/sourceMaps/SourceMapCodecProcess.js",
|
|
import.meta.url,
|
|
),
|
|
)
|
|
: argument,
|
|
),
|
|
})),
|
|
});
|
|
|
|
const fixture = webSourceLocationFixture();
|
|
const input = {
|
|
text: fixture.sourceMap.text,
|
|
url: fixture.sourceMap.url,
|
|
path: fixture.sourceMap.file.path,
|
|
position: webSourceLocationArgs.generated_position,
|
|
};
|
|
|
|
it.each([
|
|
{ name: "null", reason: null },
|
|
{
|
|
name: "an opaque cleanup error",
|
|
reason: new ProviderCleanupError("caller", ["caller-owned-resource"], {}),
|
|
},
|
|
])(
|
|
"preserves cancellation during ownership preparation with $name",
|
|
async ({ reason }) => {
|
|
const controller = new AbortController();
|
|
const createRuntime = vi.fn(async () => {
|
|
throw new Error("Cancelled preparation must not acquire a runtime");
|
|
});
|
|
const launcher = vi.fn(async () => {
|
|
throw new Error("Cancelled preparation must not launch a codec");
|
|
});
|
|
const decoder = realDecoder({
|
|
prepareOwnership: async (signal) => {
|
|
controller.abort(reason);
|
|
signal?.throwIfAborted();
|
|
},
|
|
createRuntime,
|
|
launcher,
|
|
});
|
|
const result = await decoder.trace(input, { signal: controller.signal });
|
|
if (result.ok) throw new Error("Expected preparation cancellation");
|
|
expect(result.error).toMatchObject({
|
|
_tag: "AnalysisCancelledError",
|
|
cleanupIncomplete: false,
|
|
cleanupResources: [],
|
|
});
|
|
expect(result.error.cause).toBe(reason);
|
|
await decoder.close();
|
|
if (reason instanceof ProviderCleanupError) {
|
|
expect(reason.cleanupIncomplete).toBe(true);
|
|
expect(reason.cleanupResources).toEqual(["caller-owned-resource"]);
|
|
}
|
|
expect(createRuntime).not.toHaveBeenCalled();
|
|
expect(launcher).not.toHaveBeenCalled();
|
|
},
|
|
);
|
|
|
|
it("retains diagnostics for an unknown ownership preparation failure", async () => {
|
|
const cause = new Error("unexpected ownership failure");
|
|
const createRuntime = vi.fn(async () => {
|
|
throw new Error("Failed preparation must not acquire a runtime");
|
|
});
|
|
const decoder = realDecoder({
|
|
prepareOwnership: async () => {
|
|
throw cause;
|
|
},
|
|
createRuntime,
|
|
});
|
|
const result = await decoder.trace(input);
|
|
if (result.ok) throw new Error("Expected preparation failure");
|
|
expect(result.error).toMatchObject({
|
|
_tag: "ProviderAdapterError",
|
|
cleanupIncomplete: false,
|
|
diagnostics: {
|
|
map_path: input.path,
|
|
error_message: cause.message,
|
|
phase: "process_ownership_preparation",
|
|
},
|
|
});
|
|
expect(result.error.cause).toBe(cause);
|
|
expect(createRuntime).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it.each([
|
|
{ retryable: true, category: "unavailable" },
|
|
{ retryable: false, category: "unsupported_provider" },
|
|
])(
|
|
"preserves private-runtime rejection as $category",
|
|
async ({ retryable, category }) => {
|
|
const reason = "Native runtime self-test failed with a sharing violation";
|
|
const launcher = vi.fn(async () => {
|
|
throw new Error("A refused runtime must not launch a codec");
|
|
});
|
|
const decoder = realDecoder({
|
|
prepareOwnership: async () => {},
|
|
createRuntime: async () => {
|
|
throw new PrivateRuntimeRootUnavailableError(reason, { retryable });
|
|
},
|
|
launcher,
|
|
});
|
|
const result = await decoder.trace(input);
|
|
if (result.ok) throw new Error("Expected runtime refusal");
|
|
expect(projectAnalysisError(result.error)).toMatchObject({
|
|
code: "capability_unavailable",
|
|
category,
|
|
retryable,
|
|
details: {
|
|
provider_id: "source-map-decoder",
|
|
operation: "trace_web_source_location",
|
|
reason,
|
|
},
|
|
});
|
|
expect(result.error.cleanupIncomplete).toBe(false);
|
|
expect(launcher).not.toHaveBeenCalled();
|
|
},
|
|
);
|
|
|
|
it.each([
|
|
{ name: "default", selected: undefined, expectedMs: 20_000 },
|
|
{ name: "selected", selected: 250, expectedMs: 250 },
|
|
])(
|
|
"starts the $name codec deadline after ownership preparation",
|
|
async ({ selected, expectedMs }) => {
|
|
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "performance"] });
|
|
let path: string | undefined;
|
|
try {
|
|
const response = await realDecoder({
|
|
prepareOwnership: async () => {
|
|
await vi.advanceTimersByTimeAsync(20_001);
|
|
},
|
|
createRuntime: async () => {
|
|
const root = await PrivateRuntimeRoot.create();
|
|
path = root.path;
|
|
return root;
|
|
},
|
|
launcher: async ({ signal }) => {
|
|
await vi.advanceTimersByTimeAsync(expectedMs - 1);
|
|
expect(signal?.aborted).toBe(false);
|
|
await vi.advanceTimersByTimeAsync(1);
|
|
expect(signal?.aborted).toBe(true);
|
|
throw new Error("launcher settled after deadline");
|
|
},
|
|
}).trace({
|
|
...input,
|
|
...(selected === undefined ? {} : { decodeTimeoutMs: selected }),
|
|
});
|
|
if (response.ok) throw new Error("expected decode deadline");
|
|
expect(response.error).toMatchObject({
|
|
_tag: "AnalysisTimeoutError",
|
|
userMessage: expect.stringContaining(String(expectedMs)),
|
|
});
|
|
expect(response.error.userMessage).toContain("decode_timeout_ms");
|
|
if (path === undefined) throw new Error("runtime not acquired");
|
|
await expect(access(path)).rejects.toMatchObject({ code: "ENOENT" });
|
|
} finally {
|
|
vi.useRealTimers();
|
|
}
|
|
},
|
|
);
|
|
|
|
it.each([
|
|
{ heap: undefined, effectiveHeap: 192 },
|
|
{ heap: 384, effectiveHeap: 384 },
|
|
])(
|
|
"runs the real pinned codec with selected heap $heap and removes its private request directory",
|
|
async ({ heap, effectiveHeap }) => {
|
|
let path: string | undefined;
|
|
const environment = {
|
|
...process.env,
|
|
NODE_OPTIONS: "--require=/rea-file-that-does-not-exist",
|
|
};
|
|
const decoder = realDecoder({
|
|
environment,
|
|
createRuntime: async () => {
|
|
const root = await PrivateRuntimeRoot.create();
|
|
path = root.path;
|
|
return root;
|
|
},
|
|
});
|
|
const response = await decoder.trace({
|
|
...input,
|
|
...(heap === undefined ? {} : { limits: { codec_heap_mib: heap } }),
|
|
});
|
|
if (!response.ok) throw response.error;
|
|
expect(response.value).toMatchObject({
|
|
engine: { id: "jridgewell-trace-mapping", version: "0.3.31" },
|
|
source_map_sha256: fixture.sourceMap.file.sha256,
|
|
url_context: input.url,
|
|
lookup: { requested: input.position },
|
|
matches: [{ state: "mapped", content: { text: "original" } }],
|
|
});
|
|
if (process.versions.bun === undefined) {
|
|
expect(response.value.runtime).toMatchObject({
|
|
id: "node-v8",
|
|
version: process.version,
|
|
});
|
|
expect(response.value.runtime.v8_heap_limit_bytes).toBeGreaterThan(
|
|
(effectiveHeap - 1) * 1024 * 1024,
|
|
);
|
|
expect(response.value.runtime.v8_heap_limit_bytes).toBeLessThanOrEqual(
|
|
(effectiveHeap + 64) * 1024 * 1024,
|
|
);
|
|
} else
|
|
expect(response.value.runtime).toEqual({
|
|
id: "bun",
|
|
version: process.versions.bun,
|
|
node_compatibility_version: process.versions.node,
|
|
v8_heap_limit_bytes: null,
|
|
// Windows enforces a Job Object commit limit in place of the heap flags.
|
|
process_memory_limit_bytes:
|
|
process.platform === "win32"
|
|
? (effectiveHeap + 512) * 1024 * 1024
|
|
: null,
|
|
});
|
|
expect(environment.NODE_OPTIONS).toBe(
|
|
"--require=/rea-file-that-does-not-exist",
|
|
);
|
|
if (path === undefined) throw new Error("runtime not acquired");
|
|
await expect(access(path)).rejects.toMatchObject({ code: "ENOENT" });
|
|
},
|
|
);
|
|
|
|
it.each([
|
|
{ cancel: true, denyCleanup: false },
|
|
{ cancel: false, denyCleanup: true },
|
|
{ cancel: true, denyCleanup: true },
|
|
])(
|
|
"retains completed real-codec matches through finalization (cancel=$cancel, denied=$denyCleanup)",
|
|
async ({ cancel, denyCleanup }) => {
|
|
const controller = new AbortController();
|
|
const reason = { phase: "source-map root finalization" };
|
|
let path: string | undefined;
|
|
let denyNextClose = denyCleanup;
|
|
const decoder = realDecoder({
|
|
createRuntime: async () => {
|
|
const root = await PrivateRuntimeRoot.create();
|
|
path = root.path;
|
|
return {
|
|
path: root.path,
|
|
close: async () => {
|
|
if (cancel) controller.abort(reason);
|
|
if (denyNextClose) {
|
|
denyNextClose = false;
|
|
throw new Error("controlled source-map cleanup denial");
|
|
}
|
|
await root.close();
|
|
},
|
|
};
|
|
},
|
|
});
|
|
try {
|
|
const response = await decoder.trace(input, {
|
|
signal: controller.signal,
|
|
});
|
|
if (response.ok) throw new Error("Expected interrupted finalization");
|
|
const { error } = response;
|
|
const report = error.partialObservation;
|
|
expect(report).toMatchObject({
|
|
source_map_sha256: fixture.sourceMap.file.sha256,
|
|
url_context: input.url,
|
|
lookup: { requested: input.position },
|
|
matches: [{ state: "mapped", content: { text: "original" } }],
|
|
});
|
|
expect(error).toMatchObject({ operation: "trace_web_source_location" });
|
|
expect(projectAnalysisError(error)).toMatchObject({
|
|
details: { partial_observation: report },
|
|
});
|
|
if (cancel) {
|
|
const primary = error.cleanupPrimary ?? error;
|
|
expect(primary._tag).toBe("AnalysisCancelledError");
|
|
expect(primary.cause).toBe(reason);
|
|
}
|
|
if (path === undefined) throw new Error("runtime not acquired");
|
|
expect(error.cleanupIncomplete).toBe(denyCleanup);
|
|
if (denyCleanup) {
|
|
expect(error.cleanupResources).toEqual([path]);
|
|
await expect(access(path)).resolves.toBeUndefined();
|
|
await decoder.close();
|
|
expect(error.cleanupIncomplete).toBe(false);
|
|
expect(error.cleanupResources).toEqual([]);
|
|
expect(error.partialObservation).toEqual(report);
|
|
}
|
|
await expect(access(path)).rejects.toMatchObject({ code: "ENOENT" });
|
|
} finally {
|
|
await decoder.close();
|
|
}
|
|
},
|
|
);
|
|
|
|
it.each([false, true])(
|
|
"keeps the completed codec refusal primary over late cancellation (denied=%s)",
|
|
async (denyCleanup) => {
|
|
const controller = new AbortController();
|
|
const reason = new Error("cancel after codec refusal");
|
|
let path: string | undefined;
|
|
let denyNextClose = denyCleanup;
|
|
const decoder = realDecoder({
|
|
createRuntime: async () => {
|
|
const root = await PrivateRuntimeRoot.create();
|
|
path = root.path;
|
|
return {
|
|
path: root.path,
|
|
close: async () => {
|
|
controller.abort(reason);
|
|
if (denyNextClose) {
|
|
denyNextClose = false;
|
|
throw new Error("controlled refusal cleanup denial");
|
|
}
|
|
await root.close();
|
|
},
|
|
};
|
|
},
|
|
});
|
|
try {
|
|
const response = await decoder.trace(
|
|
{ ...input, text: "{" },
|
|
{ signal: controller.signal },
|
|
);
|
|
if (response.ok) throw new Error("Expected malformed-map refusal");
|
|
const { error } = response;
|
|
const primary = error.cleanupPrimary ?? error;
|
|
expect(primary).toMatchObject({
|
|
_tag: "AnalysisInputError",
|
|
operation: "trace_web_source_location",
|
|
issues: [{ reason: "invalid_format" }],
|
|
});
|
|
const cancellation = primary.secondaryFailures.find(
|
|
({ _tag }) => _tag === "AnalysisCancelledError",
|
|
);
|
|
expect(cancellation?.cause).toBe(reason);
|
|
expect(error.partialObservation).toBeUndefined();
|
|
if (path === undefined) throw new Error("runtime not acquired");
|
|
expect(error.cleanupIncomplete).toBe(denyCleanup);
|
|
if (denyCleanup) {
|
|
expect(error.cleanupResources).toEqual([path]);
|
|
await expect(access(path)).resolves.toBeUndefined();
|
|
await decoder.close();
|
|
expect(error.cleanupIncomplete).toBe(false);
|
|
expect(error.cleanupResources).toEqual([]);
|
|
}
|
|
await expect(access(path)).rejects.toMatchObject({ code: "ENOENT" });
|
|
} finally {
|
|
await decoder.close();
|
|
}
|
|
},
|
|
);
|
|
|
|
it.each([
|
|
{
|
|
failure: "external section",
|
|
text: JSON.stringify({
|
|
version: 3,
|
|
sections: [
|
|
{
|
|
offset: { line: 0, column: 0 },
|
|
url: "https://app.test/external.map",
|
|
},
|
|
],
|
|
}),
|
|
error: {
|
|
_tag: "AnalysisCapabilityUnavailableError",
|
|
reason: "unsupported_source_map_profile",
|
|
userMessage: expect.stringContaining("https://app.test/external.map"),
|
|
},
|
|
},
|
|
{
|
|
failure: "malformed embedded map before row admission",
|
|
text: JSON.stringify({
|
|
version: 3,
|
|
sections: [
|
|
{
|
|
offset: { line: 1000000000, column: 0 },
|
|
map: { version: "3", sections: [] },
|
|
},
|
|
],
|
|
}),
|
|
error: {
|
|
_tag: "AnalysisInputError",
|
|
issues: [
|
|
{
|
|
reason: "invalid_format",
|
|
message: expect.stringContaining("not a version 3 map"),
|
|
},
|
|
],
|
|
},
|
|
},
|
|
{
|
|
failure: "indexed row limit",
|
|
text: JSON.stringify({
|
|
version: 3,
|
|
sections: [
|
|
{
|
|
offset: { line: 1000000000, column: 0 },
|
|
map: JSON.parse(fixture.sourceMap.text) as unknown,
|
|
},
|
|
],
|
|
}),
|
|
error: {
|
|
_tag: "ArtifactOperationError",
|
|
reason: "limit",
|
|
detail: expect.stringContaining("generated-row decoder budget"),
|
|
},
|
|
},
|
|
{
|
|
failure: "invalid section list with regular-map fields",
|
|
text: JSON.stringify({
|
|
version: 3,
|
|
sections: null,
|
|
sources: ["ignored.ts"],
|
|
mappings: "AAAA",
|
|
}),
|
|
error: {
|
|
_tag: "AnalysisInputError",
|
|
issues: [
|
|
{
|
|
reason: "invalid_format",
|
|
message: expect.stringContaining("sections"),
|
|
},
|
|
],
|
|
},
|
|
},
|
|
{
|
|
failure: "overlapping indexed mappings",
|
|
text: JSON.stringify({
|
|
version: 3,
|
|
sections: [
|
|
{
|
|
offset: { line: 0, column: 0 },
|
|
map: { version: 3, sources: ["a.js"], mappings: "AAAA,EAAA" },
|
|
},
|
|
{
|
|
offset: { line: 0, column: 1 },
|
|
map: { version: 3, sources: ["b.js"], mappings: "AAAA" },
|
|
},
|
|
],
|
|
}),
|
|
error: {
|
|
_tag: "AnalysisInputError",
|
|
issues: [
|
|
{
|
|
reason: "invalid_format",
|
|
message: expect.stringContaining("overlap"),
|
|
},
|
|
],
|
|
},
|
|
},
|
|
])("preserves actual producer failures: $failure", async ({ text, error }) => {
|
|
const response = await realDecoder().trace({ ...input, text });
|
|
if (response.ok) throw new Error("expected failed map");
|
|
expect(response.error).toMatchObject({
|
|
operation: "trace_web_source_location",
|
|
...error,
|
|
});
|
|
});
|
|
|
|
it("cancels a real owned process and removes the runtime request", async () => {
|
|
const reason = { caller: "cancel active codec" };
|
|
const controller = new AbortController();
|
|
let path: string | undefined;
|
|
const response = await realDecoder({
|
|
createRuntime: async () => {
|
|
const root = await PrivateRuntimeRoot.create();
|
|
path = root.path;
|
|
return root;
|
|
},
|
|
launcher: async (options) => {
|
|
const child = await spawnOwnedProviderProcess({
|
|
...options,
|
|
arguments: [
|
|
"-e",
|
|
'process.stdout.write("ready\\n"); setInterval(() => undefined, 1000)',
|
|
],
|
|
});
|
|
await waitForProviderProcessReady(child.process);
|
|
setImmediate(() => controller.abort(reason));
|
|
return child;
|
|
},
|
|
}).trace(input, { signal: controller.signal });
|
|
if (response.ok) throw new Error("expected cancellation");
|
|
expect(response.error._tag).toBe("AnalysisCancelledError");
|
|
expect(response.error.cause).toBe(reason);
|
|
if (path === undefined) throw new Error("runtime not acquired");
|
|
await expect(access(path)).rejects.toMatchObject({ code: "ENOENT" });
|
|
});
|
|
it("returns all point matches when they fit and reports output exhaustion otherwise", async () => {
|
|
const embedded = "a".repeat(1_800);
|
|
const text = `\uFEFF)]}'transport prefix\r${JSON.stringify({
|
|
version: 3,
|
|
sources: ["original.ts"],
|
|
sourcesContent: [embedded],
|
|
names: [],
|
|
mappings: "AAAA,AAAC,AAAC,AAAC",
|
|
})}`;
|
|
const trace = (outputBytes: number) =>
|
|
realDecoder().trace({
|
|
...input,
|
|
text,
|
|
limits: { output_bytes: outputBytes },
|
|
});
|
|
|
|
const complete = await trace(14_000);
|
|
if (!complete.ok) throw complete.error;
|
|
expect(complete.value.source_map_sha256).toBe(
|
|
createHash("sha256").update(text).digest("hex"),
|
|
);
|
|
expect(complete.value.matches).toMatchObject(
|
|
[0, 1, 2, 3].map((column) => ({
|
|
reported_source: "original.ts",
|
|
original_position: { line: 1, column },
|
|
content: { state: "embedded", text: embedded },
|
|
})),
|
|
);
|
|
|
|
const budget = 5_500;
|
|
expect(Buffer.byteLength(JSON.stringify(complete.value))).toBeGreaterThan(
|
|
budget,
|
|
);
|
|
const limited = await trace(budget);
|
|
if (limited.ok) throw new Error("expected complete-evidence budget failure");
|
|
expect(limited.error).toMatchObject({
|
|
_tag: "ArtifactOperationError",
|
|
reason: "limit",
|
|
detail: expect.stringContaining("source_map_limits.output_bytes is 5500"),
|
|
});
|
|
expect(limited.error.partialObservation).toBeUndefined();
|
|
});
|
|
it("rejects a malformed actual subprocess reply", async () => {
|
|
const response = await realDecoder({
|
|
launcher: (options) =>
|
|
spawnOwnedProviderProcess({
|
|
...options,
|
|
arguments: ["-e", 'process.stdout.write("not JSON")'],
|
|
}),
|
|
}).trace(input);
|
|
if (response.ok) throw new Error("expected malformed reply");
|
|
expect(response.error._tag).toBe("AnalysisOutputError");
|
|
expect(response.error.partialObservation).toBeUndefined();
|
|
});
|
|
it("rejects a codec report from a runtime other than the launching one", async () => {
|
|
const actual = await realDecoder().trace(input);
|
|
if (!actual.ok) throw actual.error;
|
|
const replay = (report: unknown) =>
|
|
realDecoder({
|
|
launcher: (options) =>
|
|
spawnOwnedProviderProcess({
|
|
...options,
|
|
arguments: [
|
|
"-e",
|
|
`process.stdout.write(${JSON.stringify(JSON.stringify({ state: "success", report }))})`,
|
|
],
|
|
}),
|
|
}).trace(input);
|
|
const unchanged = await replay(actual.value);
|
|
if (!unchanged.ok) throw unchanged.error;
|
|
expect(unchanged.value).toEqual(actual.value);
|
|
const response = await replay({
|
|
...actual.value,
|
|
runtime:
|
|
actual.value.runtime.id === "bun"
|
|
? { id: "node-v8", version: "v24.18.0", v8_heap_limit_bytes: 1 }
|
|
: {
|
|
id: "bun",
|
|
version: "1.4.2",
|
|
node_compatibility_version: "24.18.0",
|
|
v8_heap_limit_bytes: null,
|
|
process_memory_limit_bytes: null,
|
|
},
|
|
});
|
|
if (response.ok) throw new Error("expected runtime mismatch");
|
|
expect(response.error._tag).toBe("AnalysisOutputError");
|
|
expect(response.error.partialObservation).toBeUndefined();
|
|
if (actual.value.runtime.id !== "bun") return;
|
|
// A Bun codec must report exactly the process limit its launcher enforced.
|
|
const limit = await replay({
|
|
...actual.value,
|
|
runtime: {
|
|
...actual.value.runtime,
|
|
process_memory_limit_bytes:
|
|
expectedProcessMemoryLimitBytes === null ? 4096 : null,
|
|
},
|
|
});
|
|
if (limit.ok) throw new Error("expected process limit mismatch");
|
|
expect(limit.error.message).toContain("process memory limit");
|
|
});
|
|
it.each([true, false])(
|
|
"classifies a codec exit by the job memory notification (reached: %s)",
|
|
async (reached) => {
|
|
const response = await realDecoder({
|
|
launcher: async ({ memoryLimitBytes, ...options }) => {
|
|
expect(memoryLimitBytes).toBe(
|
|
expectedProcessMemoryLimitBytes ?? undefined,
|
|
);
|
|
// Without a job limit any artifact runs the child; its handle reports
|
|
// the notification an owned Windows job records before exit.
|
|
const spawned = await spawnOwnedProviderProcess({
|
|
...options,
|
|
arguments: [
|
|
"-e",
|
|
'process.stderr.write("panic: out of memory"); process.exit(3)',
|
|
],
|
|
});
|
|
let exited = false;
|
|
spawned.process.once("exit", () => {
|
|
exited = true;
|
|
});
|
|
Object.defineProperty(spawned.process, "memoryLimitReached", {
|
|
get: () => reached && exited,
|
|
});
|
|
return spawned;
|
|
},
|
|
}).trace(input);
|
|
if (response.ok) throw new Error("expected codec failure");
|
|
expect(response.error).toMatchObject(
|
|
reached
|
|
? {
|
|
_tag: "AnalysisResourceConstraintError",
|
|
resource: "memory",
|
|
reason: expect.stringContaining("process memory limit"),
|
|
reportedLimits: {
|
|
codec_process_memory_limit_bytes: expectedProcessMemoryLimitBytes,
|
|
},
|
|
capturedOutput: { stderr: "panic: out of memory" },
|
|
}
|
|
: { diagnostics: { exit_code: 3, stderr: "panic: out of memory" } },
|
|
);
|
|
},
|
|
);
|
|
it("removes the private request when launching the codec fails", async () => {
|
|
let path: string | undefined;
|
|
const response = await realDecoder({
|
|
createRuntime: async () => {
|
|
const root = await PrivateRuntimeRoot.create();
|
|
path = root.path;
|
|
return root;
|
|
},
|
|
launcher: () => Promise.reject(new Error("observed launch failure")),
|
|
}).trace(input);
|
|
if (response.ok) throw new Error("expected launch failure");
|
|
expect(response.error).toMatchObject({
|
|
diagnostics: { error_message: "observed launch failure" },
|
|
});
|
|
if (path === undefined) throw new Error("runtime not acquired");
|
|
await expect(access(path)).rejects.toMatchObject({ code: "ENOENT" });
|
|
});
|