fix(test): harden Docker resource ceilings

vincentkoc · vincentkoc · commit 98e09e881794 · 2026-05-24T13:38:50.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -11,6 +11,7 @@ Docs: https://docs.openclaw.ai
 - iMessage: mark authorized slash-command turns as text-sourced commands so `/status`, `/new`, and `/restart` acknowledgements return to the source conversation. (#82642) thanks @homer-byte.
 - Crabbox: install Corepack shims into the writable hydration `PNPM_HOME` so local AWS runner hydration no longer tries to overwrite `/usr/local/bin/pnpm`.
 - Live tests: fail Gateway live model sweeps when selected coverage is lost to timeouts or stale high-signal filters instead of reporting false missing-profile coverage, and pin Docker OpenAI gateway coverage to the current `gpt-5.5` lane.
+- Tests: fail Docker resource-ceiling checks when stats samples or configured limits are invalid instead of silently reporting zero peaks.
 
 
 ## 2026.5.24
diff --git a/scripts/e2e/lib/docker-stats/assert-resource-ceiling.mjs b/scripts/e2e/lib/docker-stats/assert-resource-ceiling.mjs
@@ -4,17 +4,29 @@ const [statsFile, maxMemoryRaw, maxCpuRaw, label = "docker"] = process.argv.slic
 const maxMemoryMiB = Number(maxMemoryRaw);
 const maxCpuPercent = Number(maxCpuRaw);
 
+function assertFiniteLimit(value, raw, name) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(`${name} must be a finite non-negative number. Got: ${JSON.stringify(raw)}`);
+  }
+}
+
 function parseMemoryMiB(raw) {
   const value =
     String(raw || "")
       .split("/")[0]
       ?.trim() || "";
   const match = /^([0-9.]+)\s*([KMGT]?i?B)$/iu.exec(value);
   if (!match) {
-    return 0;
+    return undefined;
   }
   const amount = Number(match[1]);
+  if (!Number.isFinite(amount)) {
+    return undefined;
+  }
   const unit = match[2].toLowerCase();
+  if (unit === "b") {
+    return amount / 1024 / 1024;
+  }
   if (unit === "kb" || unit === "kib") {
     return amount / 1024;
   }
@@ -27,33 +39,52 @@ function parseMemoryMiB(raw) {
   if (unit === "tb" || unit === "tib") {
     return amount * 1024 * 1024;
   }
-  return 0;
+  return undefined;
+}
+
+function parseCpuPercent(raw) {
+  const parsed = Number(String(raw || "").replace(/%$/u, ""));
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function assertSampleValue(value, raw, name, label) {
+  if (value === undefined) {
+    throw new Error(
+      `docker stats sample for ${label} had invalid ${name}: ${JSON.stringify(raw)}`,
+    );
+  }
 }
 
 const lines = fs.existsSync(statsFile)
   ? fs.readFileSync(statsFile, "utf8").split(/\r?\n/u).filter(Boolean)
   : [];
 let maxObservedMemoryMiB = 0;
 let maxObservedCpuPercent = 0;
+let parsedSamples = 0;
+
+assertFiniteLimit(maxMemoryMiB, maxMemoryRaw, "max memory MiB");
+assertFiniteLimit(maxCpuPercent, maxCpuRaw, "max CPU percent");
 
 for (const line of lines) {
   let parsed;
   try {
     parsed = JSON.parse(line);
   } catch {
-    continue;
+    throw new Error(`docker stats sample for ${label} was not valid JSON`);
   }
-  maxObservedMemoryMiB = Math.max(maxObservedMemoryMiB, parseMemoryMiB(parsed.MemUsage));
-  maxObservedCpuPercent = Math.max(
-    maxObservedCpuPercent,
-    Number(String(parsed.CPUPerc || "0").replace(/%$/u, "")) || 0,
-  );
+  const observedMemoryMiB = parseMemoryMiB(parsed.MemUsage);
+  const observedCpuPercent = parseCpuPercent(parsed.CPUPerc);
+  assertSampleValue(observedMemoryMiB, parsed.MemUsage, "MemUsage", label);
+  assertSampleValue(observedCpuPercent, parsed.CPUPerc, "CPUPerc", label);
+  parsedSamples += 1;
+  maxObservedMemoryMiB = Math.max(maxObservedMemoryMiB, observedMemoryMiB);
+  maxObservedCpuPercent = Math.max(maxObservedCpuPercent, observedCpuPercent);
 }
 
 console.log(
-  `${label} resource peak: memory=${maxObservedMemoryMiB.toFixed(1)}MiB cpu=${maxObservedCpuPercent.toFixed(1)}% samples=${lines.length}`,
+  `${label} resource peak: memory=${maxObservedMemoryMiB.toFixed(1)}MiB cpu=${maxObservedCpuPercent.toFixed(1)}% samples=${parsedSamples}`,
 );
-if (lines.length === 0) {
+if (parsedSamples === 0) {
   throw new Error(`no docker stats samples captured for ${label}`);
 }
 if (maxObservedMemoryMiB > maxMemoryMiB) {
diff --git a/test/scripts/docker-stats-resource-ceiling.test.ts b/test/scripts/docker-stats-resource-ceiling.test.ts
@@ -0,0 +1,76 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+const SCRIPT_PATH = "scripts/e2e/lib/docker-stats/assert-resource-ceiling.mjs";
+const tempRoots: string[] = [];
+
+function writeStats(contents: string): string {
+  const root = mkdtempSync(join(tmpdir(), "openclaw-docker-stats-"));
+  tempRoots.push(root);
+  const file = join(root, "stats.jsonl");
+  writeFileSync(file, contents);
+  return file;
+}
+
+function runAssert(statsFile: string, maxMemoryMiB = "512", maxCpuPercent = "100") {
+  return spawnSync(process.execPath, [SCRIPT_PATH, statsFile, maxMemoryMiB, maxCpuPercent, "test"], {
+    encoding: "utf8",
+  });
+}
+
+afterEach(() => {
+  for (const root of tempRoots.splice(0)) {
+    rmSync(root, { force: true, recursive: true });
+  }
+});
+
+describe("scripts/e2e/lib/docker-stats/assert-resource-ceiling.mjs", () => {
+  it("fails when the stats log contains no parseable samples", () => {
+    const result = runAssert(writeStats("not-json\n"));
+
+    expect(result.status).not.toBe(0);
+    expect(result.stderr).toContain("was not valid JSON");
+  });
+
+  it("rejects invalid resource limits instead of disabling the ceiling", () => {
+    const result = runAssert(writeStats('{"MemUsage":"128MiB / 2GiB","CPUPerc":"25.0%"}\n'), "nope");
+
+    expect(result.status).not.toBe(0);
+    expect(result.stderr).toContain("max memory MiB must be a finite non-negative number");
+  });
+
+  it("rejects JSON samples without parseable Docker resource fields", () => {
+    const missing = runAssert(writeStats("{}\n"));
+
+    expect(missing.status).not.toBe(0);
+    expect(missing.stderr).toContain("had invalid MemUsage");
+
+    const malformed = runAssert(writeStats('{"MemUsage":"bad","CPUPerc":"bad"}\n'));
+
+    expect(malformed.status).not.toBe(0);
+    expect(malformed.stderr).toContain("had invalid MemUsage");
+  });
+
+  it("reports and enforces parsed Docker resource peaks", () => {
+    const result = runAssert(
+      writeStats('{"MemUsage":"128MiB / 2GiB","CPUPerc":"25.0%"}\n'),
+      "256",
+      "50",
+    );
+
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain("memory=128.0MiB");
+    expect(result.stdout).toContain("cpu=25.0%");
+    expect(result.stdout).toContain("samples=1");
+  });
+
+  it("accepts byte-unit Docker memory samples", () => {
+    const result = runAssert(writeStats('{"MemUsage":"512B / 2GiB","CPUPerc":"0.5%"}\n'));
+
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain("samples=1");
+  });
+});
