439 lines
13 KiB
TypeScript
439 lines
13 KiB
TypeScript
/**
|
|
* Contract tests for `TauriAgentGateway`: they assert the exact `invoke()`
|
|
* payload shape, which the mock gateway (used by feature tests) does NOT
|
|
* exercise. This guards the class of "works in mock, broken in the real app"
|
|
* bugs — e.g. forgetting to nest `projectId` inside the command's `request` DTO.
|
|
*/
|
|
|
|
import { describe, it, expect, vi, beforeEach } from "vitest";
|
|
|
|
const invoke = vi.fn();
|
|
vi.mock("@tauri-apps/api/core", () => ({
|
|
invoke: (...args: unknown[]) => invoke(...args),
|
|
Channel: class {
|
|
onmessage: ((c: number[]) => void) | null = null;
|
|
},
|
|
}));
|
|
|
|
import { TauriAgentGateway } from "./agent";
|
|
|
|
describe("TauriAgentGateway invoke payloads", () => {
|
|
beforeEach(() => invoke.mockReset().mockResolvedValue({}));
|
|
|
|
it("create_agent nests projectId inside the request DTO", async () => {
|
|
await new TauriAgentGateway().createAgent("proj-1", {
|
|
name: "Backend",
|
|
profileId: "prof-9",
|
|
});
|
|
expect(invoke).toHaveBeenCalledWith("create_agent", {
|
|
request: {
|
|
projectId: "proj-1",
|
|
name: "Backend",
|
|
profileId: "prof-9",
|
|
initialContent: null,
|
|
},
|
|
});
|
|
});
|
|
|
|
it("update_agent_context wraps fields in the request DTO", async () => {
|
|
await new TauriAgentGateway().updateContext("proj-1", "agent-2", "# ctx");
|
|
expect(invoke).toHaveBeenCalledWith("update_agent_context", {
|
|
request: { projectId: "proj-1", agentId: "agent-2", content: "# ctx" },
|
|
});
|
|
});
|
|
|
|
it("list_agents / read / delete pass top-level args and unwrap read context DTO", async () => {
|
|
const gw = new TauriAgentGateway();
|
|
await gw.listAgents("p");
|
|
expect(invoke).toHaveBeenCalledWith("list_agents", { projectId: "p" });
|
|
|
|
invoke.mockResolvedValueOnce({ content: "# context" });
|
|
await expect(gw.readContext("p", "a")).resolves.toBe("# context");
|
|
expect(invoke).toHaveBeenCalledWith("read_agent_context", {
|
|
projectId: "p",
|
|
agentId: "a",
|
|
});
|
|
|
|
await gw.deleteAgent("p", "a");
|
|
expect(invoke).toHaveBeenCalledWith("delete_agent", {
|
|
projectId: "p",
|
|
agentId: "a",
|
|
});
|
|
});
|
|
|
|
it("attach_live_agent wraps project, agent and target node in the request DTO", async () => {
|
|
invoke.mockResolvedValueOnce({
|
|
agentId: "agent-2",
|
|
nodeId: "node-3",
|
|
sessionId: "session-4",
|
|
kind: "pty",
|
|
});
|
|
const out = await new TauriAgentGateway().attachLiveAgent(
|
|
"proj-1",
|
|
"agent-2",
|
|
"node-3",
|
|
);
|
|
expect(invoke).toHaveBeenCalledWith("attach_live_agent", {
|
|
request: { projectId: "proj-1", agentId: "agent-2", nodeId: "node-3" },
|
|
});
|
|
expect(out.sessionId).toBe("session-4");
|
|
});
|
|
|
|
it("stop_live_agent wraps project and agent in the request DTO", async () => {
|
|
invoke.mockResolvedValueOnce({
|
|
agentId: "agent-2",
|
|
stopped: [{
|
|
sessionId: "session-4",
|
|
nodeId: "node-3",
|
|
kind: "pty",
|
|
runtimeState: "stopped",
|
|
}],
|
|
alreadyStopped: false,
|
|
});
|
|
const out = await new TauriAgentGateway().stopLiveAgent("proj-1", "agent-2");
|
|
expect(invoke).toHaveBeenCalledWith("stop_live_agent", {
|
|
request: { projectId: "proj-1", agentId: "agent-2" },
|
|
});
|
|
expect(out.stopped[0]?.sessionId).toBe("session-4");
|
|
});
|
|
|
|
it("restart_cell_agent_runtime forwards the exact cell presentation", async () => {
|
|
const response = {
|
|
restartId: "restart-1",
|
|
status: "scheduled",
|
|
agentId: "agent-2",
|
|
nodeId: "node-3",
|
|
kind: "structured",
|
|
presentation: "customCli",
|
|
layoutId: "layout-4",
|
|
};
|
|
invoke.mockResolvedValueOnce(response);
|
|
|
|
await expect(
|
|
new TauriAgentGateway().restartCellAgentRuntime({
|
|
projectId: "proj-1",
|
|
nodeId: "node-3",
|
|
agentId: "agent-2",
|
|
presentation: "customCli",
|
|
layoutId: "layout-4",
|
|
}),
|
|
).resolves.toEqual(response);
|
|
expect(invoke).toHaveBeenCalledWith("restart_cell_agent_runtime", {
|
|
request: {
|
|
projectId: "proj-1",
|
|
nodeId: "node-3",
|
|
agentId: "agent-2",
|
|
presentation: "customCli",
|
|
layoutId: "layout-4",
|
|
},
|
|
});
|
|
});
|
|
|
|
it("change_agent_profile wraps all five fields in the request DTO (camelCase)", async () => {
|
|
invoke.mockResolvedValueOnce({ agent: { id: "agent-2" } });
|
|
await new TauriAgentGateway().changeAgentProfile(
|
|
"proj-1",
|
|
"agent-2",
|
|
"prof-9",
|
|
30,
|
|
120,
|
|
);
|
|
expect(invoke).toHaveBeenCalledWith("change_agent_profile", {
|
|
request: {
|
|
projectId: "proj-1",
|
|
agentId: "agent-2",
|
|
profileId: "prof-9",
|
|
rows: 30,
|
|
cols: 120,
|
|
},
|
|
});
|
|
});
|
|
|
|
it("change_agent_profile returns the mutated agent and the relaunched session", async () => {
|
|
const response = {
|
|
agent: { id: "agent-2", profileId: "prof-9" },
|
|
relaunchedSession: { sessionId: "sess-7", cwd: "/p", rows: 30, cols: 120 },
|
|
};
|
|
invoke.mockResolvedValueOnce(response);
|
|
const out = await new TauriAgentGateway().changeAgentProfile(
|
|
"proj-1",
|
|
"agent-2",
|
|
"prof-9",
|
|
30,
|
|
120,
|
|
);
|
|
expect(out.agent.profileId).toBe("prof-9");
|
|
expect(out.relaunchedSession?.sessionId).toBe("sess-7");
|
|
});
|
|
|
|
it("change_agent_profile leaves relaunchedSession undefined when the backend omits it", async () => {
|
|
invoke.mockResolvedValueOnce({ agent: { id: "agent-2" } });
|
|
const out = await new TauriAgentGateway().changeAgentProfile(
|
|
"proj-1",
|
|
"agent-2",
|
|
"prof-9",
|
|
30,
|
|
120,
|
|
);
|
|
expect(out.relaunchedSession).toBeUndefined();
|
|
});
|
|
|
|
it("update_agent_effort wraps the nullable effort override in the request DTO", async () => {
|
|
invoke.mockResolvedValueOnce({ id: "agent-2", effort: { kind: "preset", value: "high" } });
|
|
await new TauriAgentGateway().updateAgentEffort("proj-1", "agent-2", {
|
|
kind: "preset",
|
|
value: "high",
|
|
});
|
|
expect(invoke).toHaveBeenCalledWith("update_agent_effort", {
|
|
request: {
|
|
projectId: "proj-1",
|
|
agentId: "agent-2",
|
|
effort: { kind: "preset", value: "high" },
|
|
},
|
|
});
|
|
|
|
invoke.mockClear().mockResolvedValueOnce({ id: "agent-2" });
|
|
await new TauriAgentGateway().updateAgentEffort("proj-1", "agent-2", null);
|
|
expect(invoke).toHaveBeenCalledWith("update_agent_effort", {
|
|
request: { projectId: "proj-1", agentId: "agent-2", effort: null },
|
|
});
|
|
});
|
|
|
|
it("update_agent_contactable wraps the dedicated boolean in the request DTO", async () => {
|
|
invoke.mockResolvedValueOnce({ id: "agent-2", contactable: true });
|
|
|
|
await new TauriAgentGateway().updateAgentContactable(
|
|
"proj-1",
|
|
"agent-2",
|
|
true,
|
|
);
|
|
|
|
expect(invoke).toHaveBeenCalledWith("update_agent_contactable", {
|
|
request: { projectId: "proj-1", agentId: "agent-2", contactable: true },
|
|
});
|
|
});
|
|
|
|
it("update_project_orchestrator wraps the project and agent in the request DTO", async () => {
|
|
invoke.mockResolvedValueOnce({ orchestratorAgentId: "agent-2" });
|
|
|
|
await expect(
|
|
new TauriAgentGateway().updateProjectOrchestrator("proj-1", "agent-2"),
|
|
).resolves.toEqual({ orchestratorAgentId: "agent-2" });
|
|
|
|
expect(invoke).toHaveBeenCalledWith("update_project_orchestrator", {
|
|
request: { projectId: "proj-1", agentId: "agent-2" },
|
|
});
|
|
});
|
|
|
|
it("cancelAgentChat invokes cancel_agent_chat without closing the session", async () => {
|
|
const response = {
|
|
sessionId: "chat-session-1",
|
|
outcome: "cancelled" as const,
|
|
};
|
|
invoke.mockResolvedValueOnce(response);
|
|
|
|
await expect(
|
|
new TauriAgentGateway().cancelAgentChat("chat-session-1"),
|
|
).resolves.toEqual(response);
|
|
|
|
expect(invoke).toHaveBeenCalledWith("cancel_agent_chat", {
|
|
sessionId: "chat-session-1",
|
|
});
|
|
expect(invoke).not.toHaveBeenCalledWith("close_agent_session", expect.anything());
|
|
});
|
|
|
|
it("detachAgentChat invokes detach_agent_chat without closing the session", async () => {
|
|
await new TauriAgentGateway().detachAgentChat("chat-session-1");
|
|
|
|
expect(invoke).toHaveBeenCalledWith("detach_agent_chat", {
|
|
sessionId: "chat-session-1",
|
|
});
|
|
expect(invoke).not.toHaveBeenCalledWith("close_agent_session", expect.anything());
|
|
});
|
|
|
|
it("sendAgentChat forwards structured clipboard attachments to agent_send", async () => {
|
|
await new TauriAgentGateway().sendAgentChat(
|
|
"chat-session-1",
|
|
"",
|
|
vi.fn(),
|
|
{
|
|
attachments: [
|
|
{
|
|
filename: "clipboard.png",
|
|
contentBase64: "AQID",
|
|
mime: "image/png",
|
|
sourceKind: "clipboard",
|
|
},
|
|
],
|
|
},
|
|
);
|
|
|
|
expect(invoke).toHaveBeenCalledWith("agent_send", {
|
|
sessionId: "chat-session-1",
|
|
prompt: "",
|
|
attachments: [
|
|
{
|
|
filename: "clipboard.png",
|
|
contentBase64: "AQID",
|
|
mime: "image/png",
|
|
sourceKind: "clipboard",
|
|
},
|
|
],
|
|
onReply: expect.anything(),
|
|
});
|
|
});
|
|
|
|
it("listSlashCommands forwards the unified slash-command filter request and unwraps commands", async () => {
|
|
invoke.mockResolvedValueOnce({
|
|
commands: [
|
|
{
|
|
name: "/clean",
|
|
shortDescription: "Clean current conversation",
|
|
requiresConfirmation: false,
|
|
availability: { status: "available" },
|
|
source: "native",
|
|
native: "clean",
|
|
},
|
|
],
|
|
});
|
|
|
|
const out = await new TauriAgentGateway().listSlashCommands("/c");
|
|
|
|
expect(invoke).toHaveBeenCalledWith("list_slash_commands", {
|
|
request: { prefix: "/c" },
|
|
});
|
|
expect(out).toHaveLength(1);
|
|
expect(out[0].name).toBe("/clean");
|
|
});
|
|
|
|
it("executeSlashCommand wraps the selected command and current session id", async () => {
|
|
invoke.mockResolvedValueOnce({
|
|
command: {
|
|
name: "/clean",
|
|
shortDescription: "Clean current conversation",
|
|
requiresConfirmation: false,
|
|
availability: { status: "available" },
|
|
source: "native",
|
|
native: "clean",
|
|
},
|
|
effect: {
|
|
kind: "cleanConversation",
|
|
sessionId: "chat-session-1",
|
|
clearedChunks: 2,
|
|
},
|
|
});
|
|
|
|
const out = await new TauriAgentGateway().executeSlashCommand("/clean", {
|
|
sessionId: "chat-session-1",
|
|
});
|
|
|
|
expect(invoke).toHaveBeenCalledWith("execute_slash_command", {
|
|
request: { name: "/clean", sessionId: "chat-session-1", arguments: [] },
|
|
});
|
|
expect(out.effect.kind).toBe("cleanConversation");
|
|
});
|
|
|
|
it("wraps chat draft persistence commands with the project/layout/node scope", async () => {
|
|
const gateway = new TauriAgentGateway();
|
|
const scope = {
|
|
projectId: "proj-1",
|
|
layoutId: "layout-1",
|
|
nodeId: "node-1",
|
|
};
|
|
invoke.mockResolvedValueOnce({ text: "hello", updatedAtMs: 42 });
|
|
|
|
await expect(gateway.readChatDraft(scope)).resolves.toEqual({
|
|
text: "hello",
|
|
updatedAtMs: 42,
|
|
});
|
|
await gateway.saveChatDraft(scope, "edited");
|
|
await gateway.clearChatDraft(scope);
|
|
|
|
expect(invoke).toHaveBeenNthCalledWith(1, "read_chat_draft", {
|
|
request: scope,
|
|
});
|
|
expect(invoke).toHaveBeenNthCalledWith(2, "save_chat_draft", {
|
|
request: { ...scope, text: "edited" },
|
|
});
|
|
expect(invoke).toHaveBeenNthCalledWith(3, "clear_chat_draft", {
|
|
request: scope,
|
|
});
|
|
});
|
|
|
|
it("launchAgentChat returns a handle only when launch_agent confirms cellKind chat", async () => {
|
|
invoke.mockResolvedValueOnce({
|
|
sessionId: "chat-session-1",
|
|
cwd: "/repo",
|
|
rows: 24,
|
|
cols: 80,
|
|
cellKind: "chat",
|
|
assignedConversationId: "conversation-1",
|
|
transcriptUnavailableReason: "missingTranscript",
|
|
});
|
|
|
|
const out = await new TauriAgentGateway().launchAgentChat("proj-1", "agent-2", {
|
|
cwd: "/repo",
|
|
rows: 24,
|
|
cols: 80,
|
|
conversationId: "conversation-0",
|
|
nodeId: "node-3",
|
|
});
|
|
|
|
expect(invoke).toHaveBeenCalledWith("launch_agent", {
|
|
request: {
|
|
projectId: "proj-1",
|
|
agentId: "agent-2",
|
|
rows: 24,
|
|
cols: 80,
|
|
cellKind: "chat",
|
|
conversationId: "conversation-0",
|
|
freshStart: false,
|
|
nodeId: "node-3",
|
|
},
|
|
onOutput: expect.anything(),
|
|
});
|
|
expect(out).toEqual({
|
|
sessionId: "chat-session-1",
|
|
cellKind: "chat",
|
|
assignedConversationId: "conversation-1",
|
|
transcriptUnavailableReason: "missingTranscript",
|
|
});
|
|
});
|
|
|
|
it("launchAgentChat rejects a PTY-routed launch before returning a fake structured session", async () => {
|
|
const log = vi.spyOn(console, "error").mockImplementation(() => {});
|
|
invoke.mockResolvedValueOnce({
|
|
sessionId: "pty-session-1",
|
|
cwd: "/repo",
|
|
rows: 24,
|
|
cols: 80,
|
|
cellKind: "pty",
|
|
});
|
|
|
|
await expect(
|
|
new TauriAgentGateway().launchAgentChat("proj-1", "agent-2", {
|
|
cwd: "/repo",
|
|
rows: 24,
|
|
cols: 80,
|
|
nodeId: "node-3",
|
|
}),
|
|
).rejects.toEqual({
|
|
code: "STRUCTURED_ROUTED_TO_PTY",
|
|
message:
|
|
"custom CLI launch for agent agent-2 in project proj-1 returned cellKind=pty; expected chat. sessionId=pty-session-1; nodeId=node-3",
|
|
});
|
|
expect(log).toHaveBeenCalledWith(
|
|
"[ticket149] launchAgentChat:routed-to-non-chat",
|
|
expect.objectContaining({
|
|
projectId: "proj-1",
|
|
agentId: "agent-2",
|
|
response: expect.objectContaining({
|
|
sessionId: "pty-session-1",
|
|
cellKind: "pty",
|
|
}),
|
|
}),
|
|
);
|
|
log.mockRestore();
|
|
});
|
|
});
|