ewilliams28/openclaw
1
0
Fork 0
mirror of https://github.com/openclaw/openclaw.git synced 2026-08-25 11:55:47 -06:00
Code Issues Packages Projects Releases Wiki Activity

refactor(gateway): remove suspension mock replay (#122977)

Browse Source 
* test(gateway): remove suspension mock replay

* test(agents): stabilize headless timeout assertion
This commit is contained in:
Peter Steinberger
2026-08-12 21:24:50 -07:00
committed by GitHub
parent 1facf8f850
commit 9bf9bcebc4
3 changed files with 14 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files
scripts/e2e/lib/gateway-network/client.mts
+4 -6
View File
@@ -280,25 +280,23 @@ function assertAdminSuccess(response: GatewayAdminResponse, message: string) {
return assertRpcSuccess(response.body, message);
}
export async function verifyPreparedSuspensionSocket(
async function verifyPreparedSuspensionSocket(
options: GatewayClientOptions & { deadline: number; suspensionId: string },
deps: Pick<GatewayNetworkDeps, "onceFrame" | "openSocket" | "protocolVersion"> = {},
) {
const { deadline, suspensionId, token, url } = options;
const onceFrameImpl = deps.onceFrame ?? onceFrame;
const ws = await (deps.openSocket ?? openSocket)(url, remainingDeadlineMs(deadline));
const ws = await openSocket(url, remainingDeadlineMs(deadline));
try {
let requestIndex = 0;
const request = async (method: string, params: Record<string, unknown> = {}) => {
const id = `s${++requestIndex}`;
ws.send(JSON.stringify({ type: "req", id, method, params }));
return (await onceFrameImpl(
return (await onceFrame(
ws,
(frame) => frame?.type === "res" && frame?.id === id,
remainingDeadlineMs(deadline),
)) as GatewayFrame;
};
const protocolVersion = deps.protocolVersion ?? (await readProtocolVersion());
const protocolVersion = await readProtocolVersion();
assertRpcSuccess(
await request("connect", {
minProtocol: protocolVersion,
src/agents/code-mode-headless.test.ts
+10 -12
View File
@@ -882,18 +882,16 @@ describe("headless Code Mode", () => {
const ctx = createHeadlessHarness();
expectCompleted(await runCodeModeScriptHeadless({ ctx, code: "return true;" }));
expect(
expectFailed(
await runCodeModeScriptHeadless({
ctx,
code: "while (true) {}",
wallClockMs: 100,
}),
),
).toMatchObject({
code: "timeout",
error: "code mode timeout exceeded",
});
const result = expectFailed(
await runCodeModeScriptHeadless({
ctx,
code: "while (true) {}",
wallClockMs: 100,
}),
);
expect(result.code).toBe("timeout");
expect(result.error).toContain("timeout exceeded");
});
it("classifies syntax errors", async () => {
test/scripts/gateway-network-client.test.ts
-120
View File
@@ -12,7 +12,6 @@ import {
runGatewayNetworkClient,
runGatewaySuspensionPostRestartClient,
runGatewaySuspensionPreRestartClient,
verifyPreparedSuspensionSocket,
} from "../../scripts/e2e/lib/gateway-network/client.mts";
import { readGatewayNetworkClientConnectTimeoutMs } from "../../scripts/e2e/lib/gateway-network/limits.mts";
import { onceFrame } from "../../scripts/e2e/lib/gateway-network/ws-frames.mts";
@@ -499,123 +498,4 @@ describe("gateway network client", () => {
}),
).toThrow("identify gateway-draining");
});
function createPreparedSocketHarness(responses: GatewayFrame[]) {
const frames = [...responses];
const requests: Array<{ method: string; params: Record<string, unknown> }> = [];
let closeCount = 0;
const socket = {
close: () => {
closeCount += 1;
},
send: (payload: string) => {
const frame = JSON.parse(payload) as {
method: string;
params: Record<string, unknown>;
};
requests.push({ method: frame.method, params: frame.params });
},
};
return {
get closeCount() {
return closeCount;
},
requests,
deps: {
onceFrame: async (
_ws: unknown,
predicate: (frame: GatewayFrame) => boolean,
_timeoutMs?: number,
) => {
const response = frames.shift();
expect(response).toBeDefined();
const frame = {
type: "res",
id: `s${requests.length}`,
...response,
};
expect(predicate(frame)).toBe(true);
return frame;
},
openSocket: async () => socket,
protocolVersion: 1,
},
};
}
it("uses one authenticated socket for the prepared suspension control lifecycle", async () => {
const suspending = {
ok: false,
error: {
code: "UNAVAILABLE",
retryable: true,
details: { reason: "gateway-suspending", phase: "prepared" },
},
};
const harness = createPreparedSocketHarness([
{ ok: true },
{ ok: true, payload: { status: "ready" } },
suspending,
{ ok: false, error: { code: "INVALID_REQUEST" } },
{ ok: true, payload: { status: "ready" } },
{ ok: true, payload: { status: "running", resumed: true } },
{ ok: true, payload: { status: "running", resumed: false } },
healthResponse(),
]);
await verifyPreparedSuspensionSocket(
{
deadline: Date.now() + 1_000,
suspensionId: "lease-1",
token: "test-token",
url: "ws://127.0.0.1:12345",
},
harness.deps,
);
expect(harness.requests).toEqual([
{
method: "connect",
params: {
minProtocol: 1,
maxProtocol: 1,
client: {
id: "cli",
displayName: "docker-net-e2e",
version: "dev",
platform: process.platform,
mode: "cli",
},
caps: [],
auth: { token: "test-token" },
role: "operator",
scopes: ["operator.admin"],
},
},
{ method: "gateway.suspend.status", params: { suspensionId: "lease-1" } },
{ method: "health", params: {} },
{
method: "gateway.suspend.resume",
params: { suspensionId: "lease-1-wrong" },
},
{ method: "gateway.suspend.status", params: { suspensionId: "lease-1" } },
{ method: "gateway.suspend.resume", params: { suspensionId: "lease-1" } },
{ method: "gateway.suspend.resume", params: { suspensionId: "lease-1" } },
{ method: "health", params: {} },
]);
expect(harness.closeCount).toBe(1);
const invalidHarness = createPreparedSocketHarness([
{ ok: true },
{ ok: true, payload: { status: "running" } },
]);
await expect(
verifyPreparedSuspensionSocket(
{
deadline: Date.now() + 1_000,
suspensionId: "lease-1",
token: "test-token",
url: "ws://127.0.0.1:12345",
},
invalidHarness.deps,
),
).rejects.toThrow("prepared suspension must remain ready");
expect(invalidHarness.closeCount).toBe(1);
});
});