@@ -13,6 +13,55 @@ const mocks = vi.hoisted(() => ({
1313pickGatewaySelfPresence: vi.fn(),
1414}));
151516+type GatewayCall = {
17+clientName?: string;
18+config?: unknown;
19+deviceIdentity?: unknown;
20+method?: string;
21+mode?: string;
22+password?: string;
23+timeoutMs?: number;
24+token?: string;
25+};
26+27+type GatewayProbeCall = {
28+auth?: unknown;
29+detailLevel?: string;
30+preauthHandshakeTimeoutMs?: number;
31+timeoutMs?: number;
32+url?: string;
33+};
34+35+type MemorySearchManagerCall = {
36+agentId?: string;
37+cfg: {
38+plugins?: {
39+slots?: unknown;
40+};
41+};
42+purpose?: string;
43+};
44+45+function readGatewayCall(): GatewayCall {
46+expect(mocks.callGateway).toHaveBeenCalledOnce();
47+const calls = mocks.callGateway.mock.calls as unknown as Array<[unknown]>;
48+const call = calls[0]?.[0];
49+if (!call) {
50+throw new Error("Expected gateway call");
51+}
52+return call as GatewayCall;
53+}
54+55+function readProbeCall(): GatewayProbeCall {
56+expect(mocks.probeGateway).toHaveBeenCalledOnce();
57+const calls = mocks.probeGateway.mock.calls as unknown as Array<[unknown]>;
58+const call = calls[0]?.[0];
59+if (!call) {
60+throw new Error("Expected gateway probe call");
61+}
62+return call as GatewayProbeCall;
63+}
64+1665vi.mock("../gateway/connection-details.js", () => ({
1766buildGatewayConnectionDetailsWithResolvers: mocks.buildGatewayConnectionDetailsWithResolvers,
1867}));
@@ -66,20 +115,18 @@ describe("resolveGatewayProbeSnapshot", () => {
6611567116expect(mocks.resolveGatewayProbeAuthResolution).not.toHaveBeenCalled();
68117expect(mocks.probeGateway).not.toHaveBeenCalled();
69-expect(result).toEqual({
70-gatewayConnection: expect.objectContaining({ url: "ws://127.0.0.1:18789" }),
71-remoteUrlMissing: true,
72-gatewayMode: "remote",
73-gatewayProbeAuth: {},
74-gatewayProbeAuthWarning: undefined,
75-gatewayProbe: null,
76-gatewayReachable: false,
77-gatewaySelf: null,
78-gatewayCallOverrides: {
79-url: "ws://127.0.0.1:18789",
80-token: undefined,
81-password: undefined,
82-},
118+expect(result.gatewayConnection.url).toBe("ws://127.0.0.1:18789");
119+expect(result.remoteUrlMissing).toBe(true);
120+expect(result.gatewayMode).toBe("remote");
121+expect(result.gatewayProbeAuth).toEqual({});
122+expect(result.gatewayProbeAuthWarning).toBeUndefined();
123+expect(result.gatewayProbe).toBeNull();
124+expect(result.gatewayReachable).toBe(false);
125+expect(result.gatewaySelf).toBeNull();
126+expect(result.gatewayCallOverrides).toEqual({
127+url: "ws://127.0.0.1:18789",
128+token: undefined,
129+password: undefined,
83130});
84131});
85132@@ -106,13 +153,10 @@ describe("resolveGatewayProbeSnapshot", () => {
106153});
107154108155expect(mocks.resolveGatewayProbeAuthResolution).toHaveBeenCalled();
109-expect(mocks.probeGateway).toHaveBeenCalledWith(
110-expect.objectContaining({
111-url: "ws://127.0.0.1:18789",
112-auth: { token: "tok", password: "pw" },
113-detailLevel: "full",
114-}),
115-);
156+const probeCall = readProbeCall();
157+expect(probeCall.url).toBe("ws://127.0.0.1:18789");
158+expect(probeCall.auth).toEqual({ token: "tok", password: "pw" });
159+expect(probeCall.detailLevel).toBe("full");
116160expect(result.gatewayReachable).toBe(true);
117161expect(result.gatewaySelf).toEqual({ host: "box" });
118162expect(result.gatewayCallOverrides).toEqual({
@@ -216,25 +260,20 @@ describe("resolveGatewayProbeSnapshot", () => {
216260},
217261});
218262219-expect(mocks.callGateway).toHaveBeenCalledWith(
220-expect.objectContaining({
221-config: {},
222-method: "status",
223-token: "tok",
224-password: "pw",
225-timeoutMs: 2000,
226-mode: "backend",
227-clientName: "gateway-client",
228-}),
229-);
230-expect(mocks.callGateway.mock.calls[0]?.[0]).not.toHaveProperty("deviceIdentity");
263+const gatewayCall = readGatewayCall();
264+expect(gatewayCall.config).toEqual({});
265+expect(gatewayCall.method).toBe("status");
266+expect(gatewayCall.token).toBe("tok");
267+expect(gatewayCall.password).toBe("pw");
268+expect(gatewayCall.timeoutMs).toBe(2000);
269+expect(gatewayCall.mode).toBe("backend");
270+expect(gatewayCall.clientName).toBe("gateway-client");
271+expect(gatewayCall).not.toHaveProperty("deviceIdentity");
231272expect(result.gatewayReachable).toBe(true);
232-expect(result.gatewayProbe).toMatchObject({
233-ok: true,
234-error: "timeout",
235-status: { sessions: 1 },
236-auth: { capability: "read_only" },
237-});
273+expect(result.gatewayProbe?.ok).toBe(true);
274+expect(result.gatewayProbe?.error).toBe("timeout");
275+expect(result.gatewayProbe?.status).toEqual({ sessions: 1 });
276+expect(result.gatewayProbe?.auth?.capability).toBe("read_only");
238277expect(result.gatewayProbeAuthWarning).toBe("warn");
239278});
240279@@ -267,18 +306,12 @@ describe("resolveGatewayProbeSnapshot", () => {
267306opts: {},
268307});
269308270-expect(mocks.probeGateway).toHaveBeenCalledWith(
271-expect.objectContaining({
272-preauthHandshakeTimeoutMs: 30_000,
273-timeoutMs: 30_000,
274-}),
275-);
276-expect(mocks.callGateway).toHaveBeenCalledWith(
277-expect.objectContaining({
278-config: { gateway: { handshakeTimeoutMs: 30_000 } },
279-timeoutMs: 30_000,
280-}),
281-);
309+const probeCall = readProbeCall();
310+expect(probeCall.preauthHandshakeTimeoutMs).toBe(30_000);
311+expect(probeCall.timeoutMs).toBe(30_000);
312+const gatewayCall = readGatewayCall();
313+expect(gatewayCall.config).toEqual({ gateway: { handshakeTimeoutMs: 30_000 } });
314+expect(gatewayCall.timeoutMs).toBe(30_000);
282315});
283316284317it("does not raise an explicit local status RPC fallback timeout", async () => {
@@ -310,17 +343,10 @@ describe("resolveGatewayProbeSnapshot", () => {
310343opts: { timeoutMs: 1000 },
311344});
312345313-expect(mocks.probeGateway).toHaveBeenCalledWith(
314-expect.objectContaining({
315-preauthHandshakeTimeoutMs: 30_000,
316-timeoutMs: 1000,
317-}),
318-);
319-expect(mocks.callGateway).toHaveBeenCalledWith(
320-expect.objectContaining({
321-timeoutMs: 1000,
322-}),
323-);
346+const probeCall = readProbeCall();
347+expect(probeCall.preauthHandshakeTimeoutMs).toBe(30_000);
348+expect(probeCall.timeoutMs).toBe(1000);
349+expect(readGatewayCall().timeoutMs).toBe(1000);
324350});
325351326352it("lets callGateway reuse paired-device auth for local status RPC fallback", async () => {
@@ -356,17 +382,14 @@ describe("resolveGatewayProbeSnapshot", () => {
356382opts: {},
357383});
358384359-expect(mocks.callGateway).toHaveBeenCalledWith(
360-expect.objectContaining({
361-config: {},
362-method: "status",
363-token: undefined,
364-password: undefined,
365-mode: "backend",
366-clientName: "gateway-client",
367-}),
368-);
369-expect(mocks.callGateway.mock.calls[0]?.[0]).not.toHaveProperty("deviceIdentity");
385+const gatewayCall = readGatewayCall();
386+expect(gatewayCall.config).toEqual({});
387+expect(gatewayCall.method).toBe("status");
388+expect(gatewayCall.token).toBeUndefined();
389+expect(gatewayCall.password).toBeUndefined();
390+expect(gatewayCall.mode).toBe("backend");
391+expect(gatewayCall.clientName).toBe("gateway-client");
392+expect(gatewayCall).not.toHaveProperty("deviceIdentity");
370393expect(result.gatewayReachable).toBe(true);
371394});
372395@@ -442,15 +465,14 @@ describe("resolveSharedMemoryStatusSnapshot", () => {
442465443466expect(resolveMemoryConfig).not.toHaveBeenCalled();
444467expect(requireDefaultStore).not.toHaveBeenCalled();
445-expect(getMemorySearchManager).toHaveBeenCalledWith({
446-cfg: expect.objectContaining({
447-plugins: expect.objectContaining({
448-slots: { memory: "memory-lancedb-pro" },
449-}),
450-}),
451-agentId: "main",
452-purpose: "status",
453-});
468+expect(getMemorySearchManager).toHaveBeenCalledOnce();
469+const managerCalls = getMemorySearchManager.mock.calls as unknown as Array<
470+[MemorySearchManagerCall]
471+>;
472+const managerCall = managerCalls[0]?.[0];
473+expect(managerCall?.cfg.plugins?.slots).toEqual({ memory: "memory-lancedb-pro" });
474+expect(managerCall?.agentId).toBe("main");
475+expect(managerCall?.purpose).toBe("status");
454476expect(manager.probeVectorStoreAvailability).toHaveBeenCalled();
455477expect(manager.probeVectorAvailability).not.toHaveBeenCalled();
456478expect(manager.status).toHaveBeenCalled();
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。