mirror of
https://github.com/aiclientproxy/proxycast.git
synced 2026-11-22 06:16:12 +08:00
201 lines
5.9 KiB
JavaScript
201 lines
5.9 KiB
JavaScript
import fs from "node:fs";
|
|
|
|
import { describe, expect, it } from "vitest";
|
|
|
|
import {
|
|
assertThreadQueueEvidence,
|
|
parseThreadQueueGateArgs,
|
|
summarizeThreadQueueEvidence,
|
|
THREAD_QUEUE_MARKER,
|
|
THREAD_QUEUE_REQUIRED_METHODS,
|
|
THREAD_QUEUE_TITLE,
|
|
} from "./thread-queue-gate-b.mjs";
|
|
|
|
const THREAD_ID = "thread-queue-gate-b";
|
|
|
|
function setupRequests(transport = "electron-ipc") {
|
|
return [
|
|
{
|
|
command: "app_server_handle_json_lines",
|
|
method: "thread/start",
|
|
transport,
|
|
status: "success",
|
|
params: {},
|
|
},
|
|
{
|
|
command: "app_server_handle_json_lines",
|
|
method: "thread/queue/add",
|
|
transport,
|
|
status: "success",
|
|
params: { threadId: THREAD_ID },
|
|
},
|
|
];
|
|
}
|
|
|
|
function traceRaw(transport = "electron-ipc") {
|
|
const methods = [
|
|
"thread/start",
|
|
"thread/queue/add",
|
|
"thread/queue/list",
|
|
"thread/read",
|
|
];
|
|
return JSON.stringify(
|
|
methods.map((method) => ({
|
|
command: "app_server_handle_json_lines",
|
|
transport,
|
|
status: "success",
|
|
args_preview: {
|
|
request: {
|
|
lines: [
|
|
JSON.stringify({
|
|
jsonrpc: "2.0",
|
|
id: method,
|
|
method,
|
|
params: method === "thread/start" ? {} : { threadId: THREAD_ID },
|
|
}),
|
|
],
|
|
},
|
|
},
|
|
})),
|
|
);
|
|
}
|
|
|
|
function visibleDom() {
|
|
return {
|
|
conversationButtonVisible: true,
|
|
headerTitle: THREAD_QUEUE_TITLE,
|
|
queueStatusVisible: true,
|
|
queueStatusText: "待处理 1",
|
|
queueItemsPresent: false,
|
|
queueStatusContainsMarker: false,
|
|
timelineMarkerCount: 0,
|
|
idle: true,
|
|
};
|
|
}
|
|
|
|
describe("Thread Queue Electron Gate B", () => {
|
|
it("binds current Electron methods and visible queue to one Thread", () => {
|
|
const evidence = summarizeThreadQueueEvidence({
|
|
traceRaw: traceRaw(),
|
|
errorRaw: "[]",
|
|
dom: visibleDom(),
|
|
threadId: THREAD_ID,
|
|
queuedSubmissionId: "queued-1",
|
|
});
|
|
expect(() => assertThreadQueueEvidence(evidence)).not.toThrow();
|
|
expect(evidence.bridge.missingMethods).toEqual([]);
|
|
expect(evidence.identity.queueRequestsMatchThread).toBe(true);
|
|
});
|
|
|
|
it("combines preload setup evidence with GUI safeInvoke trace after reload", () => {
|
|
const guiTrace = JSON.stringify(JSON.parse(traceRaw()).slice(2));
|
|
const evidence = summarizeThreadQueueEvidence({
|
|
traceRaw: guiTrace,
|
|
errorRaw: "[]",
|
|
dom: visibleDom(),
|
|
threadId: THREAD_ID,
|
|
queuedSubmissionId: "queued-1",
|
|
setupRequests: setupRequests(),
|
|
});
|
|
expect(() => assertThreadQueueEvidence(evidence)).not.toThrow();
|
|
expect(evidence.bridge.missingMethods).toEqual([]);
|
|
});
|
|
|
|
it("fails closed for mock transport or mismatched Thread identity", () => {
|
|
const mockEvidence = summarizeThreadQueueEvidence({
|
|
traceRaw: traceRaw("renderer-mock"),
|
|
errorRaw: "[]",
|
|
dom: visibleDom(),
|
|
threadId: THREAD_ID,
|
|
queuedSubmissionId: "queued-1",
|
|
});
|
|
expect(() => assertThreadQueueEvidence(mockEvidence)).toThrow(
|
|
/缺少 Queue current method/,
|
|
);
|
|
|
|
const mismatched = summarizeThreadQueueEvidence({
|
|
traceRaw: traceRaw(),
|
|
errorRaw: "[]",
|
|
dom: visibleDom(),
|
|
threadId: "other-thread",
|
|
queuedSubmissionId: "queued-1",
|
|
});
|
|
expect(() => assertThreadQueueEvidence(mismatched)).toThrow(
|
|
/Thread identity 不一致/,
|
|
);
|
|
});
|
|
|
|
it("fails closed when pending Queue text leaks into collapsed status or transcript", () => {
|
|
const repeatedInStatus = summarizeThreadQueueEvidence({
|
|
traceRaw: traceRaw(),
|
|
errorRaw: "[]",
|
|
dom: {
|
|
...visibleDom(),
|
|
queueStatusContainsMarker: true,
|
|
queueStatusText: `待处理 1 ${THREAD_QUEUE_MARKER}`,
|
|
},
|
|
threadId: THREAD_ID,
|
|
queuedSubmissionId: "queued-1",
|
|
});
|
|
expect(() => assertThreadQueueEvidence(repeatedInStatus)).toThrow(
|
|
/不得重复 submission 正文/,
|
|
);
|
|
|
|
const duplicatedTimeline = summarizeThreadQueueEvidence({
|
|
traceRaw: traceRaw(),
|
|
errorRaw: "[]",
|
|
dom: { ...visibleDom(), timelineMarkerCount: 2 },
|
|
threadId: THREAD_ID,
|
|
queuedSubmissionId: "queued-1",
|
|
});
|
|
expect(() => assertThreadQueueEvidence(duplicatedTimeline)).toThrow(
|
|
/不得进入 canonical 时间线/,
|
|
);
|
|
});
|
|
|
|
it("validates CLI bounds and keeps retired queue paths absent", () => {
|
|
expect(
|
|
parseThreadQueueGateArgs(["--timeout-ms", "60000"], {
|
|
evidenceDir: "/tmp/evidence",
|
|
prefix: "thread-queue",
|
|
timeoutMs: 120_000,
|
|
intervalMs: 250,
|
|
keepTemp: false,
|
|
}),
|
|
).toMatchObject({ timeoutMs: 60_000 });
|
|
expect(() =>
|
|
parseThreadQueueGateArgs(["--prefix", "../unsafe"], {
|
|
evidenceDir: "/tmp/evidence",
|
|
prefix: "thread-queue",
|
|
timeoutMs: 120_000,
|
|
intervalMs: 250,
|
|
keepTemp: false,
|
|
}),
|
|
).toThrow(/invalid evidence prefix/);
|
|
|
|
const content = fs.readFileSync(
|
|
"scripts/electron/thread-queue-gate-b.mjs",
|
|
"utf8",
|
|
);
|
|
const queueComponent = fs.readFileSync(
|
|
"src/components/agent/chat/components/QueuedMessageList.tsx",
|
|
"utf8",
|
|
);
|
|
for (const method of THREAD_QUEUE_REQUIRED_METHODS) {
|
|
expect(content).toContain(method);
|
|
}
|
|
expect(content).toContain("ensureElectronFixtureBuild");
|
|
expect(content).toContain('backendMode: "external"');
|
|
expect(content).toContain("pauseQueueAfterInterruptedTurn");
|
|
expect(content).toContain('data-testid="queued-message-list"');
|
|
expect(content).toContain("runQueuedMessageMutationGate");
|
|
expect(content).toContain('data-testid="thread-queue-items"');
|
|
expect(queueComponent).not.toContain('data-testid="thread-queue-items"');
|
|
expect(content).not.toContain('APP_SERVER_BACKEND_MODE: "mock"');
|
|
expect(content).not.toContain("queuedTurnSnapshot");
|
|
expect(content).not.toContain("mockPriorityCommands");
|
|
expect(content).not.toContain("defaultMocks");
|
|
expect(content).not.toContain("invokeMockOnly");
|
|
});
|
|
});
|