mirror of
https://github.com/morluto/rea.git
synced 2026-11-13 18:22:42 +00:00
Kaoru0822
4b26f38d6f
* fix(javascript): collect async chunks without call spreads * test(javascript): bound the public checkpoint control
71 lines
2.7 KiB
TypeScript
71 lines
2.7 KiB
TypeScript
import { writeFile } from "node:fs/promises";
|
|
import { join } from "node:path";
|
|
import { expect } from "vitest";
|
|
import { parseEvidence } from "../../src/domain/evidence.js";
|
|
import { javascriptApplicationAnalysisResultSchema } from "../../src/domain/javascript/javascriptApplicationAnalysis.js";
|
|
import { JAVASCRIPT_STATIC_FACT_BYTES } from "../../src/domain/javascript/javascriptAnalysisResourceControls.js";
|
|
import { javascriptAsyncChunkCapacity } from "../fixtures/javascriptAsyncChunkCapacity.js";
|
|
import { createTestTempDirectory } from "../fixtures/temporaryDirectory.js";
|
|
import { cliTest } from "../support/cli/cliFixture.js";
|
|
|
|
cliTest(
|
|
"reports the complete-fact ceiling for wide async chunk metadata",
|
|
{ timeout: 60_000 },
|
|
async ({ cli }) => {
|
|
// This bounded public control exceeds the complete-fact allowance. The
|
|
// forked boundary regression separately owns call-argument capacity.
|
|
const { source } = javascriptAsyncChunkCapacity(50_000);
|
|
const root = await createTestTempDirectory("rea-async-chunk-budget-");
|
|
await writeFile(join(root, "entry.cjs"), source);
|
|
const response = await cli.run({
|
|
arguments: [
|
|
"analyze-javascript-application",
|
|
root,
|
|
"--max-semantic-nodes",
|
|
"1",
|
|
"--max-semantic-nodes-per-file",
|
|
"1",
|
|
"--max-heap-mb",
|
|
"2048",
|
|
"--analysis-timeout-ms",
|
|
"30000",
|
|
"--json",
|
|
],
|
|
timeoutMs: 55_000,
|
|
});
|
|
// Analysis retains the interrupted file rather than failing the command.
|
|
expect(response.exitCode, `${response.stdout}\n${response.stderr}`).toBe(0);
|
|
const result = javascriptApplicationAnalysisResultSchema.parse(
|
|
parseEvidence(response.json).normalized_result,
|
|
);
|
|
const failures = result.graph.nodes.flatMap(({ observations }) =>
|
|
observations.flatMap(({ properties }) =>
|
|
properties.analysis_failure === undefined
|
|
? []
|
|
: [properties.analysis_failure],
|
|
),
|
|
);
|
|
expect(failures).toEqual([
|
|
expect.objectContaining({
|
|
code: "resource_constraint",
|
|
retryable: false,
|
|
message: expect.stringContaining("static checkpoint"),
|
|
remediation: {
|
|
action: expect.stringContaining("no runtime override"),
|
|
},
|
|
details: expect.objectContaining({
|
|
resource: "transport",
|
|
reported_limits: expect.objectContaining({
|
|
checkpoint_bytes: expect.any(Number),
|
|
checkpoint_limit_bytes: JAVASCRIPT_STATIC_FACT_BYTES,
|
|
}),
|
|
}),
|
|
}),
|
|
]);
|
|
expect(JSON.stringify(failures)).not.toContain("call stack");
|
|
expect(JSON.stringify(failures)).toContain(
|
|
"Raising max_heap_mb does not raise it",
|
|
);
|
|
},
|
|
);
|