Codex
382 lines
16 KiB
TypeScript
382 lines
16 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import { spawnSync } from "node:child_process";
|
|
import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
|
|
import { tmpdir } from "node:os";
|
|
import { join } from "node:path";
|
|
import { test } from "bun:test";
|
|
|
|
import { hwlabRuntimeLaneSpecForNode } from "./hwlab-node-lanes";
|
|
import { nodeWebObserveRunnerSource } from "./hwlab-node-web-observe-runner-source";
|
|
import {
|
|
classifyQuickVerifyCleanupStep,
|
|
createQuickVerifyObserverLifecycle,
|
|
quickVerifyCleanupFindings,
|
|
quickVerifyUnhandledExceptionSummary,
|
|
readAnalysisSummaryFromWorkspace,
|
|
sentinelChildStartMemorySkip,
|
|
sentinelServiceProxyInvocation,
|
|
stopQuickVerifyObserverAfterPartialStart,
|
|
} from "./hwlab-node-web-sentinel-p5-observe";
|
|
import { createWebProbeSentinelService } from "./hwlab-node-web-sentinel-service";
|
|
|
|
test("sentinel service proxy executes its script through trans standard input", () => {
|
|
assert.deepEqual(sentinelServiceProxyInvocation("NC01:k3s", "echo sentinel-service-proxy"), {
|
|
argv: ["trans", "NC01:k3s", "sh"],
|
|
input: "echo sentinel-service-proxy",
|
|
});
|
|
});
|
|
|
|
test("workspace analysis fallback maps report generatedAt to reportUpdatedAt", () => {
|
|
const directory = mkdtempSync(join(tmpdir(), "unidesk-workspace-analysis-"));
|
|
try {
|
|
const stateDir = ".state/web-observe/webobs-fixture-20260712T000000Z";
|
|
mkdirSync(join(directory, stateDir, "analysis"), { recursive: true });
|
|
writeFileSync(join(directory, stateDir, "analysis", "report.json"), JSON.stringify({ generatedAt: "2026-07-12T00:00:00.000Z", findings: [] }));
|
|
const summary = readAnalysisSummaryFromWorkspace({} as never, stateDir, 5, (script) => {
|
|
const result = spawnSync("sh", { cwd: directory, input: script, encoding: "utf8" });
|
|
return {
|
|
command: ["sh"],
|
|
cwd: directory,
|
|
exitCode: result.status,
|
|
stdout: result.stdout ?? "",
|
|
stderr: result.stderr ?? "",
|
|
signal: result.signal,
|
|
timedOut: false,
|
|
};
|
|
});
|
|
assert.equal(summary.ok, true, JSON.stringify(summary));
|
|
assert.equal(summary.reportUpdatedAt, "2026-07-12T00:00:00.000Z", JSON.stringify(summary));
|
|
} finally {
|
|
rmSync(directory, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("recorded sentinel run is available through the latest report index", () => {
|
|
const stateRoot = mkdtempSync(join(tmpdir(), "unidesk-sentinel-index-"));
|
|
const service = createWebProbeSentinelService({
|
|
spec: hwlabRuntimeLaneSpecForNode("v03", "NC01"),
|
|
sentinelId: "nc01-web-probe-sentinel",
|
|
stateRootOverride: stateRoot,
|
|
schedulerEnabled: false,
|
|
});
|
|
try {
|
|
const scenarioId = String(service.config.scenarios[0]?.id);
|
|
const recorded = service.recordRun({
|
|
runId: "sentinel-run-index-test",
|
|
scenarioId,
|
|
status: "succeeded",
|
|
reportJsonSha256: "sha256:index-test",
|
|
summary: { source: "test", valuesRedacted: true },
|
|
views: { summary: { renderedText: "indexed summary" } },
|
|
findingCount: 0,
|
|
artifactCount: 0,
|
|
updatedAt: "2026-07-13T00:00:00.000Z",
|
|
valuesRedacted: true,
|
|
});
|
|
const latest = service.report("summary", null);
|
|
assert.equal(recorded.ok, true);
|
|
assert.equal(latest.ok, true);
|
|
assert.equal((latest.run as Record<string, unknown>).id, "sentinel-run-index-test");
|
|
} finally {
|
|
service.close();
|
|
rmSync(stateRoot, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("latest report selects the newest stored run without a report SHA", () => {
|
|
const stateRoot = mkdtempSync(join(tmpdir(), "unidesk-sentinel-index-"));
|
|
const service = createWebProbeSentinelService({
|
|
spec: hwlabRuntimeLaneSpecForNode("v03", "NC01"),
|
|
sentinelId: "nc01-web-probe-sentinel",
|
|
stateRootOverride: stateRoot,
|
|
schedulerEnabled: false,
|
|
});
|
|
try {
|
|
const scenarioId = String(service.config.scenarios[0]?.id);
|
|
service.recordRun({
|
|
runId: "sentinel-run-old-artifact",
|
|
scenarioId,
|
|
status: "succeeded",
|
|
reportJsonSha256: "sha256:old-artifact",
|
|
summary: { source: "test", valuesRedacted: true },
|
|
views: { summary: { renderedText: "old indexed summary" } },
|
|
findingCount: 0,
|
|
artifactCount: 0,
|
|
updatedAt: "2026-07-13T00:00:00.000Z",
|
|
valuesRedacted: true,
|
|
});
|
|
service.recordRun({
|
|
runId: "sentinel-run-new-stored-finding",
|
|
scenarioId,
|
|
status: "blocked",
|
|
summary: { source: "test", valuesRedacted: true },
|
|
views: { summary: { renderedText: "new stored summary" } },
|
|
findings: [{ id: "quick-verify-observer-start-failed", severity: "error", summary: "observer start failed" }],
|
|
findingCount: 1,
|
|
artifactCount: 0,
|
|
updatedAt: "2026-07-13T00:00:01.000Z",
|
|
valuesRedacted: true,
|
|
});
|
|
|
|
const latest = service.report("summary", null);
|
|
assert.equal(latest.ok, true);
|
|
assert.equal((latest.run as Record<string, unknown>).id, "sentinel-run-new-stored-finding");
|
|
assert.equal((latest.run as Record<string, unknown>).reportJsonSha256, null);
|
|
assert.match(String(latest.renderedText), /run=sentinel-run-new-stored-finding/u);
|
|
assert.match(String(latest.renderedText), /页面观察未启动/u);
|
|
} finally {
|
|
service.close();
|
|
rmSync(stateRoot, { recursive: true, force: true });
|
|
}
|
|
});
|
|
function forceStopStep(observer: Record<string, unknown>): Record<string, unknown> {
|
|
return {
|
|
phase: "observe-stop-after-terminal",
|
|
ok: false,
|
|
payload: {
|
|
ok: false,
|
|
status: "blocked",
|
|
forceReason: "graceful-stop-not-consumed",
|
|
observer: {
|
|
command: "web-probe-observe force-stop",
|
|
...observer,
|
|
},
|
|
valuesRedacted: true,
|
|
},
|
|
valuesRedacted: true,
|
|
};
|
|
}
|
|
|
|
test("quick verify cleanup downgrades abandoned graceful stop when force stop confirms not alive", () => {
|
|
const step = forceStopStep({
|
|
aliveBefore: true,
|
|
aliveAfter: false,
|
|
termSent: true,
|
|
killSent: true,
|
|
pendingAbandoned: 1,
|
|
processingAbandoned: 0,
|
|
});
|
|
|
|
const cleanup = classifyQuickVerifyCleanupStep(step);
|
|
assert.equal(cleanup.cleanupClass, "bounded-force-stop");
|
|
assert.equal(cleanup.gracefulStopOk, false);
|
|
assert.equal(cleanup.forceStopOk, true);
|
|
assert.equal(cleanup.aliveAfter, false);
|
|
assert.equal(cleanup.pendingAbandoned, 1);
|
|
const findings = quickVerifyCleanupFindings(step);
|
|
assert.equal(findings.length, 1);
|
|
assert.equal(findings[0]?.id, "observer-graceful-stop-timeout-force-stop-succeeded");
|
|
assert.equal(findings[0]?.severity, "warning");
|
|
});
|
|
|
|
test("quick verify cleanup reads force-stop evidence from top-level CLI payload", () => {
|
|
const step = {
|
|
phase: "observe-stop-after-terminal",
|
|
ok: false,
|
|
payload: {
|
|
ok: true,
|
|
command: "web-probe-observe force-stop",
|
|
forced: true,
|
|
reason: "graceful-stop-not-consumed",
|
|
aliveBefore: true,
|
|
aliveAfter: false,
|
|
termSent: true,
|
|
killSent: true,
|
|
pendingAbandoned: 1,
|
|
processingAbandoned: 0,
|
|
valuesRedacted: true,
|
|
},
|
|
valuesRedacted: true,
|
|
};
|
|
|
|
const cleanup = classifyQuickVerifyCleanupStep(step);
|
|
const findings = quickVerifyCleanupFindings(step);
|
|
assert.equal(cleanup.cleanupClass, "bounded-force-stop");
|
|
assert.equal(cleanup.forceStopOk, true);
|
|
assert.equal(cleanup.aliveAfter, false);
|
|
assert.deepEqual(cleanup.evidenceSources, ["payload"]);
|
|
assert.equal(findings[0]?.id, "observer-graceful-stop-timeout-force-stop-succeeded");
|
|
});
|
|
|
|
test("quick verify cleanup emits process-alive code when force stop leaves observer alive", () => {
|
|
const step = forceStopStep({
|
|
aliveBefore: true,
|
|
aliveAfter: true,
|
|
termSent: true,
|
|
killSent: false,
|
|
pendingAbandoned: 0,
|
|
processingAbandoned: 1,
|
|
});
|
|
|
|
const cleanup = classifyQuickVerifyCleanupStep(step);
|
|
const findings = quickVerifyCleanupFindings(step);
|
|
assert.equal(cleanup.cleanupClass, "observer-stop-failed");
|
|
assert.equal(cleanup.forceStopOk, false);
|
|
assert.equal(cleanup.aliveAfter, true);
|
|
assert.equal(findings.length, 1);
|
|
assert.equal(findings[0]?.id, "observer-force-stop-left-process-alive");
|
|
assert.match(String(findings[0]?.evidenceSummary), /aliveAfter=true/u);
|
|
});
|
|
|
|
test("quick verify cleanup emits evidence-gap code when stopped state cannot be confirmed", () => {
|
|
const step = forceStopStep({
|
|
aliveBefore: true,
|
|
termSent: true,
|
|
killSent: true,
|
|
pendingAbandoned: 1,
|
|
processingAbandoned: 0,
|
|
});
|
|
|
|
const cleanup = classifyQuickVerifyCleanupStep(step);
|
|
const findings = quickVerifyCleanupFindings(step);
|
|
assert.equal(cleanup.cleanupClass, "observer-stop-failed");
|
|
assert.equal(cleanup.aliveAfter, null);
|
|
assert.deepEqual(cleanup.missingEvidenceFields, ["aliveAfter"]);
|
|
assert.equal(findings.length, 1);
|
|
assert.equal(findings[0]?.id, "observer-cleanup-evidence-missing");
|
|
assert.match(String(findings[0]?.evidenceSummary), /missing=aliveAfter/u);
|
|
});
|
|
|
|
test("quick verify observer lifecycle stops once on success, failure, and exception fallback", () => {
|
|
const cases = [
|
|
{ name: "success", initialPhase: "observe-stop-after-terminal", expectedPhase: "observe-stop-after-terminal" },
|
|
{ name: "failure", initialPhase: "observe-stop-after-failure", expectedPhase: "observe-stop-after-failure" },
|
|
{ name: "exception-fallback", initialPhase: null, expectedPhase: "observe-stop-after-finally" },
|
|
] as const;
|
|
|
|
for (const scenario of cases) {
|
|
const calls: { observerId: string; phase: string }[] = [];
|
|
const lifecycle = createQuickVerifyObserverLifecycle("webobs-fixture", (observerId, phase) => {
|
|
calls.push({ observerId, phase });
|
|
return { phase, ok: true, observerId };
|
|
});
|
|
if (scenario.initialPhase !== null) lifecycle.stop(scenario.initialPhase);
|
|
const cleanupStep = lifecycle.stop("observe-stop-after-finally");
|
|
|
|
assert.deepEqual(calls, [{ observerId: "webobs-fixture", phase: scenario.expectedPhase }], scenario.name);
|
|
assert.equal(cleanupStep.phase, scenario.expectedPhase, scenario.name);
|
|
assert.strictEqual(cleanupStep, lifecycle.cleanupStep, scenario.name);
|
|
}
|
|
});
|
|
|
|
test("quick verify observer lifecycle retries a failed stop again from the bounded finally fallback", () => {
|
|
let calls = 0;
|
|
const lifecycle = createQuickVerifyObserverLifecycle("webobs-stop-throws", () => {
|
|
calls += 1;
|
|
throw new Error("sensitive-stop-error");
|
|
});
|
|
|
|
const first = lifecycle.stop("observe-stop-after-failure");
|
|
const fallback = lifecycle.stop("observe-stop-after-finally");
|
|
|
|
assert.equal(calls, 4);
|
|
assert.notStrictEqual(first, fallback);
|
|
assert.equal(first.failure, "observer-stop-unhandled-exception");
|
|
assert.equal(Array.isArray(fallback.stopAttempts), true);
|
|
assert.equal((fallback.stopAttempts as unknown[]).length, 4);
|
|
assert.equal(JSON.stringify(first).includes("sensitive-stop-error"), false);
|
|
});
|
|
|
|
test("quick verify observer lifecycle retries a failed force-stop and caches the successful fallback", () => {
|
|
let calls = 0;
|
|
const lifecycle = createQuickVerifyObserverLifecycle("webobs-stop-retry", (_observerId, phase) => {
|
|
calls += 1;
|
|
return { phase, ok: calls === 2, observerId: "webobs-stop-retry" };
|
|
});
|
|
const first = lifecycle.stop("observe-stop-after-failure");
|
|
const cached = lifecycle.stop("observe-stop-after-finally");
|
|
assert.equal(calls, 2);
|
|
assert.equal(first.ok, true);
|
|
assert.strictEqual(first, cached);
|
|
assert.equal(Array.isArray(first.stopAttempts), true);
|
|
});
|
|
|
|
test("quick verify cleans a partial start only when start output contains an observer id", () => {
|
|
const calls: { observerId: string; phase: string }[] = [];
|
|
const stopObserver = (observerId: string, phase: string) => {
|
|
calls.push({ observerId, phase });
|
|
return { phase, ok: true, observerId };
|
|
};
|
|
|
|
assert.equal(stopQuickVerifyObserverAfterPartialStart(null, stopObserver), null);
|
|
const cleanupStep = stopQuickVerifyObserverAfterPartialStart("webobs-partial", stopObserver);
|
|
|
|
assert.deepEqual(calls, [{ observerId: "webobs-partial", phase: "observe-stop-after-start-failure" }]);
|
|
assert.equal(cleanupStep?.ok, true);
|
|
});
|
|
|
|
test("quick verify unexpected exception evidence is bounded and redacted", () => {
|
|
const secret = "sensitive-upstream-message";
|
|
const summary = quickVerifyUnhandledExceptionSummary(new Error(secret));
|
|
const serialized = JSON.stringify(summary);
|
|
|
|
assert.equal(summary.errorName, "Error");
|
|
assert.match(String(summary.errorMessageSha256), /^[a-f0-9]{64}$/u);
|
|
assert.equal(summary.errorMessageTruncated, false);
|
|
assert.equal(serialized.includes(secret), false);
|
|
});
|
|
|
|
test("sentinel preserves a child launch-time memory race as skipped instead of observe-start-failed", () => {
|
|
const skip = sentinelChildStartMemorySkip({
|
|
ok: true,
|
|
command: "web-probe observe start",
|
|
data: {
|
|
ok: true,
|
|
status: "skipped-wait-next-round",
|
|
observerCreated: false,
|
|
memoryGuard: {
|
|
mode: "sentinel-cadence",
|
|
status: "skipped",
|
|
memory: {
|
|
metric: "MemAvailable",
|
|
source: "/proc/meminfo",
|
|
swapExcluded: true,
|
|
availableBytes: 4 * 1024 ** 3 - 1,
|
|
thresholdBytes: 4 * 1024 ** 3,
|
|
comparator: "less-than",
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
assert.equal(skip?.status, "skipped-wait-next-round");
|
|
assert.equal(skip?.decision, "skip-observer");
|
|
assert.equal(skip?.observerCreated, false);
|
|
assert.equal((skip?.memoryGuard as Record<string, unknown>).mode, "sentinel-cadence");
|
|
assert.equal(sentinelChildStartMemorySkip({ data: { status: "blocked", observerCreated: false } }), null);
|
|
});
|
|
|
|
test("web observe runner records finite lifecycle policy and closes the browser", () => {
|
|
const source = nodeWebObserveRunnerSource();
|
|
|
|
assert.match(source, /sampling:\s*\{[^}]*maxSamples,[^}]*maxRunMs,[^}]*maxRunSeconds:/u);
|
|
assert.match(source, /observerLifecycle:\s*\{[^}]*maxSamples,[^}]*maxRunMs,[^}]*maxRunSeconds:/u);
|
|
assert.match(source, /if \(maxRunMs > 0 && Date\.now\(\) - startedAtMs >= maxRunMs\)/u);
|
|
assert.match(source, /const maxScreenshots = requiredBoundedInteger\(process\.env\.UNIDESK_WEB_OBSERVE_MAX_SCREENSHOTS/u);
|
|
assert.match(source, /const maxPerformanceEntries = requiredBoundedInteger\(process\.env\.UNIDESK_WEB_OBSERVE_MAX_PERFORMANCE_ENTRIES/u);
|
|
assert.match(source, /const maxRealtimeEventBodyBytes = requiredBoundedInteger\(process\.env\.UNIDESK_WEB_OBSERVE_MAX_REALTIME_EVENT_BODY_BYTES/u);
|
|
assert.match(source, /while \(browserProcessHistory\.length > maxBrowserProcessHistoryEntries\)/u);
|
|
assert.match(source, /while \(browserFreezeSignalHistory\.length > maxBrowserFreezeSignalHistoryEntries\)/u);
|
|
assert.match(source, /if \(screenshotCount >= maxScreenshots\)/u);
|
|
assert.match(source, /const maxBytes = responseBodyMaxBytes/u);
|
|
assert.match(source, /function responseBodyReadContract\(response, maxBytes = responseBodyMaxBytes\)/u);
|
|
assert.match(source, /contentEncoding[\s\S]*?reason: "encoded-body-size-unbounded"/u);
|
|
assert.match(source, /!Number\.isFinite\(contentLength\)[\s\S]*?reason: "content-length-unavailable"/u);
|
|
assert.match(source, /bodyReadSkipped: body\.error\?\.reason \|\| "bounded-response-read-failed"/u);
|
|
assert.match(source, /\.slice\(0, maxProcessScanEntries\)/u);
|
|
assert.match(source, /if \(items\.length > maxEntries\)[\s\S]*?items\.splice/u);
|
|
assert.match(source, /process\.once\(signal,[\s\S]*?closeBrowserResources\("signal:" \+ signal\)/u);
|
|
assert.match(source, /finally \{[\s\S]*?await closeBrowserResources/u);
|
|
assert.match(source, /closingObserverPage\.close\(\)[\s\S]*?closingPage\.close\(\)[\s\S]*?closingContext\.close\(\)[\s\S]*?closingBrowser\.close\(\)/u);
|
|
|
|
const directory = mkdtempSync(join(tmpdir(), "web-observe-runner-check-"));
|
|
try {
|
|
const runner = join(directory, "observer-runner.mjs");
|
|
writeFileSync(runner, source);
|
|
const syntax = spawnSync("node", ["--check", runner], { encoding: "utf8" });
|
|
assert.equal(syntax.status, 0, syntax.stderr);
|
|
} finally {
|
|
rmSync(directory, { recursive: true, force: true });
|
|
}
|
|
});
|