vultr/openclaw
1
0
Fork 0
mirror of https://github.com/openclaw/openclaw.git synced 2026-05-02 13:40:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

test: keep vitest on forks only

Browse Source
This commit is contained in:
Tak Hoffman
2026-03-25 12:21:28 -05:00
parent 055ad65896
commit f63c4b0856
9 changed files with 43 additions and 393 deletions
Download Patch File Download Diff File Expand all files Collapse all files

195
scripts/test-find-thread-candidates.mjs
View File

@@ -1,195 +0,0 @@
import { spawnSync } from "node:child_process";
import path from "node:path";
import { pathToFileURL } from "node:url";
import {
booleanFlag,
floatFlag,
intFlag,
parseFlagArgs,
readEnvNumber,
stringFlag,
} from "./lib/arg-utils.mjs";
import { formatMs } from "./lib/vitest-report-cli-utils.mjs";
import { loadTestRunnerBehavior, loadUnitTimingManifest } from "./test-runner-manifest.mjs";
export function parseArgs(argv) {
const envLimit = readEnvNumber("OPENCLAW_TEST_THREAD_CANDIDATE_LIMIT");
return parseFlagArgs(
argv,
{
config: "vitest.unit.config.ts",
limit: Number.isFinite(envLimit) ? Math.max(1, Math.floor(envLimit)) : 20,
minDurationMs: readEnvNumber("OPENCLAW_TEST_THREAD_CANDIDATE_MIN_DURATION_MS") ?? 250,
minGainMs: readEnvNumber("OPENCLAW_TEST_THREAD_CANDIDATE_MIN_GAIN_MS") ?? 100,
minGainPct: readEnvNumber("OPENCLAW_TEST_THREAD_CANDIDATE_MIN_GAIN_PCT") ?? 10,
json: false,
files: [],
},
[
stringFlag("--config", "config"),
intFlag("--limit", "limit", { min: 1 }),
floatFlag("--min-duration-ms", "minDurationMs", { min: 0 }),
floatFlag("--min-gain-ms", "minGainMs", { min: 0 }),
floatFlag("--min-gain-pct", "minGainPct", { min: 0, includeMin: false }),
booleanFlag("--json", "json"),
],
{
ignoreDoubleDash: true,
onUnhandledArg(arg, args) {
if (arg.startsWith("-")) {
throw new Error(`Unknown option: ${arg}`);
}
args.files.push(arg);
return "handled";
},
},
);
}
export function getExistingThreadCandidateExclusions(behavior) {
return new Set([
...(behavior.base?.threadPinned ?? []).map((entry) => entry.file),
...(behavior.base?.threadSingleton ?? []).map((entry) => entry.file),
...(behavior.unit?.isolated ?? []).map((entry) => entry.file),
...(behavior.unit?.threadPinned ?? []).map((entry) => entry.file),
...(behavior.unit?.threadSingleton ?? []).map((entry) => entry.file),
]);
}
export function selectThreadCandidateFiles({
files,
timings,
exclude = new Set(),
limit,
minDurationMs,
includeUnknownDuration = false,
}) {
return files
.map((file) => ({
file,
durationMs: timings.files[file]?.durationMs ?? null,
}))
.filter((entry) => !exclude.has(entry.file))
.filter((entry) =>
entry.durationMs === null ? includeUnknownDuration : entry.durationMs >= minDurationMs,
)
.toSorted((a, b) => b.durationMs - a.durationMs)
.slice(0, limit)
.map((entry) => entry.file);
}
export function summarizeThreadBenchmark({ file, forks, threads, minGainMs, minGainPct }) {
const forkOk = forks.exitCode === 0;
const threadOk = threads.exitCode === 0;
const gainMs = forks.elapsedMs - threads.elapsedMs;
const gainPct = forks.elapsedMs > 0 ? (gainMs / forks.elapsedMs) * 100 : 0;
const recommended =
forkOk &&
threadOk &&
gainMs >= minGainMs &&
gainPct >= minGainPct &&
threads.elapsedMs < forks.elapsedMs;
return {
file,
forks,
threads,
gainMs,
gainPct,
recommended,
};
}
function benchmarkFile({ config, file, pool }) {
const startedAt = process.hrtime.bigint();
const run = spawnSync("pnpm", ["vitest", "run", "--config", config, `--pool=${pool}`, file], {
encoding: "utf8",
env: process.env,
maxBuffer: 20 * 1024 * 1024,
});
const elapsedMs = Number(process.hrtime.bigint() - startedAt) / 1_000_000;
return {
pool,
exitCode: run.status ?? 1,
elapsedMs,
stderr: run.stderr ?? "",
stdout: run.stdout ?? "",
};
}
function buildOutput(results) {
return results.map((result) => ({
file: result.file,
forksMs: Math.round(result.forks.elapsedMs),
threadsMs: Math.round(result.threads.elapsedMs),
gainMs: Math.round(result.gainMs),
gainPct: Number(result.gainPct.toFixed(1)),
forksExitCode: result.forks.exitCode,
threadsExitCode: result.threads.exitCode,
recommended: result.recommended,
}));
}
async function main() {
const opts = parseArgs(process.argv.slice(2));
const behavior = loadTestRunnerBehavior();
const timings = loadUnitTimingManifest();
const exclude = getExistingThreadCandidateExclusions(behavior);
const inputFiles = opts.files.length > 0 ? opts.files : Object.keys(timings.files);
const candidates = selectThreadCandidateFiles({
files: inputFiles,
timings,
exclude,
limit: opts.limit,
minDurationMs: opts.minDurationMs,
includeUnknownDuration: opts.files.length > 0,
});
const results = [];
for (const file of candidates) {
const forks = benchmarkFile({ config: opts.config, file, pool: "forks" });
const threads = benchmarkFile({ config: opts.config, file, pool: "threads" });
results.push(
summarizeThreadBenchmark({
file,
forks,
threads,
minGainMs: opts.minGainMs,
minGainPct: opts.minGainPct,
}),
);
}
if (opts.json) {
console.log(JSON.stringify(buildOutput(results), null, 2));
return;
}
console.log(
`[test-find-thread-candidates] tested=${String(results.length)} minGain=${formatMs(
opts.minGainMs,
0,
)} minGainPct=${String(opts.minGainPct)}%`,
);
for (const result of results) {
const status = result.recommended
? "recommend"
: result.forks.exitCode !== 0
? "forks-failed"
: result.threads.exitCode !== 0
? "threads-failed"
: "skip";
console.log(
`${status.padEnd(14, " ")} ${result.file} forks=${formatMs(
result.forks.elapsedMs,
0,
)} threads=${formatMs(result.threads.elapsedMs, 0)} gain=${formatMs(result.gainMs, 0)} (${result.gainPct.toFixed(1)}%)`,
);
}
}
if (process.argv[1] && pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url) {
main().catch((error) => {
console.error(error);
process.exit(1);
});
}

72
scripts/test-parallel.mjs
View File

@@ -94,11 +94,8 @@ const testProfile =
const isMacMiniProfile = testProfile === "macmini";
// Vitest executes Node tests through Vite's SSR/module-runner pipeline, so the
// shared unit lane still retains transformed ESM/module state even when the
// tests themselves are not "server rendering" a website. We previously kept
// forks as the default after VM-pool regressions on constrained hosts. On
// 2026-03-22, a direct full-unit threads run finished 1109/1110 green; the sole
// correctness exception stayed on the manifest fork lane, so the wrapper now
// defaults unit runs to threads while preserving explicit fork escapes.
// tests themselves are not "server rendering" a website. Keep forks as the
// only active pool so local and CI behavior stay aligned.
const forceIsolation =
process.env.OPENCLAW_TEST_ISOLATE === "1" || process.env.OPENCLAW_TEST_ISOLATE === "true";
const disableIsolation =
@@ -110,12 +107,6 @@ const includeChannelsSuite = process.env.OPENCLAW_TEST_INCLUDE_CHANNELS === "1";
const includeExtensionsSuite = process.env.OPENCLAW_TEST_INCLUDE_EXTENSIONS === "1";
const noIsolateArgs = disableIsolation ? ["--isolate=false"] : [];
const skipDefaultRuns = process.env.OPENCLAW_TEST_SKIP_DEFAULT === "1";
const parsePoolOverride = (value, fallback) => {
if (value === "threads" || value === "forks") {
return value;
}
return fallback;
};
// Even on low-memory or fully serial hosts, keep the unit lane split so
// long-lived workers do not accumulate the whole unit transform graph.
const shouldSplitUnitRuns = true;
@@ -284,9 +275,9 @@ const channelIsolatedFiles = dedupeFilesPreserveOrder([
),
]);
const channelIsolatedFileSet = new Set(channelIsolatedFiles);
const defaultUnitPool = parsePoolOverride(process.env.OPENCLAW_TEST_UNIT_DEFAULT_POOL, "threads");
const isTargetedIsolatedUnitFile = (fileFilter) =>
unitForkIsolatedFiles.includes(fileFilter) || unitMemoryIsolatedFiles.includes(fileFilter);
const isLegacyBasePinnedFile = (fileFilter) => baseThreadPinnedFiles.includes(fileFilter);
const inferTarget = (fileFilter) => {
const isolated =
isTargetedIsolatedUnitFile(fileFilter) ||
@@ -548,13 +539,13 @@ const unitFastEntries = unitFastBuckets.flatMap((files, index) => {
"run",
"--config",
"vitest.unit.config.ts",
`--pool=${defaultUnitPool}`,
"--pool=forks",
...noIsolateArgs,
],
}));
});
// Shared channel workers retain large transformed module graphs across files on
// threads/non-isolated runs. Recycle that lane in bounded batches so the
// non-isolated runs. Recycle that lane in bounded batches so the
// process gets torn down before unrelated channel files inherit the full graph.
const channelsSharedBatches = splitFilesByDurationBudget(
channelSharedCandidateFiles,
@@ -597,17 +588,17 @@ const unitHeavyEntries = heavyUnitBuckets.map((files, index) => ({
...files,
],
}));
const unitThreadEntries =
const unitPinnedEntries =
unitThreadPinnedFiles.length > 0
? [
{
name: "unit-threads",
name: "unit-pinned",
args: [
"vitest",
"run",
"--config",
"vitest.unit.config.ts",
"--pool=threads",
"--pool=forks",
...noIsolateArgs,
...unitThreadPinnedFiles,
],
@@ -646,7 +637,7 @@ const baseRuns = [
file,
],
})),
...unitThreadEntries,
...unitPinnedEntries,
]
: [
{
@@ -711,8 +702,6 @@ const resolveFilterMatches = (fileFilter) => {
}
return allKnownTestFiles.filter((file) => file.includes(normalizedFilter));
};
const isThreadPinnedUnitFile = (fileFilter) => unitThreadPinnedFiles.includes(fileFilter);
const isBaseThreadPinnedFile = (fileFilter) => baseThreadPinnedFiles.includes(fileFilter);
const createTargetedEntry = (owner, isolated, filters) => {
const name = isolated ? `${owner}-isolated` : owner;
const forceForks = isolated;
@@ -724,27 +713,13 @@ const createTargetedEntry = (owner, isolated, filters) => {
"run",
"--config",
"vitest.unit.config.ts",
`--pool=${forceForks ? "forks" : defaultUnitPool}`,
"--pool=forks",
...noIsolateArgs,
...filters,
],
};
}
if (owner === "unit-threads") {
return {
name,
args: [
"vitest",
"run",
"--config",
"vitest.unit.config.ts",
"--pool=threads",
...noIsolateArgs,
...filters,
],
};
}
if (owner === "base-threads") {
if (owner === "base-pinned") {
return {
name,
args: [
@@ -752,7 +727,7 @@ const createTargetedEntry = (owner, isolated, filters) => {
"run",
"--config",
"vitest.config.ts",
"--pool=threads",
"--pool=forks",
...noIsolateArgs,
...filters,
],
@@ -835,11 +810,7 @@ const formatPerFileEntryName = (owner, file) => {
};
const createPerFileTargetedEntry = (file) => {
const target = inferTarget(file);
const owner = isThreadPinnedUnitFile(file)
? "unit-threads"
: isBaseThreadPinnedFile(file)
? "base-threads"
: target.owner;
const owner = isLegacyBasePinnedFile(file) ? "base-pinned" : target.owner;
return {
...createTargetedEntry(owner, target.isolated, [file]),
name: `${formatPerFileEntryName(owner, file)}${target.isolated ? "-isolated" : ""}`,
@@ -913,11 +884,7 @@ const targetedEntries = (() => {
if (matchedFiles.length === 0) {
const normalizedFile = normalizeRepoPath(fileFilter);
const target = inferTarget(normalizedFile);
const owner = isThreadPinnedUnitFile(normalizedFile)
? "unit-threads"
: isBaseThreadPinnedFile(normalizedFile)
? "base-threads"
: target.owner;
const owner = isLegacyBasePinnedFile(normalizedFile) ? "base-pinned" : target.owner;
const key = `${owner}:${target.isolated ? "isolated" : "default"}`;
const files = acc.get(key) ?? [];
files.push(normalizedFile);
@@ -926,11 +893,7 @@ const targetedEntries = (() => {
}
for (const matchedFile of matchedFiles) {
const target = inferTarget(matchedFile);
const owner = isThreadPinnedUnitFile(matchedFile)
? "unit-threads"
: isBaseThreadPinnedFile(matchedFile)
? "base-threads"
: target.owner;
const owner = isLegacyBasePinnedFile(matchedFile) ? "base-pinned" : target.owner;
const key = `${owner}:${target.isolated ? "isolated" : "default"}`;
const files = acc.get(key) ?? [];
files.push(matchedFile);
@@ -941,7 +904,7 @@ const targetedEntries = (() => {
return Array.from(groups, ([key, filters]) => {
const [owner, mode] = key.split(":");
const uniqueFilters = [...new Set(filters)];
if (mode === "isolated") {
if (mode === "isolated" || owner === "base-pinned") {
return uniqueFilters.map((file) => createPerFileTargetedEntry(file));
}
return [createTargetedEntry(owner, false, uniqueFilters)];
@@ -1142,9 +1105,6 @@ const maxWorkersForRun = (name) => {
if (isCI && isMacOS) {
return 1;
}
if (name.endsWith("-threads")) {
return 1;
}
if (name.endsWith("-isolated")) {
return 1;
}