9b531dab65
Removed queued warning toasts from chat queueing flows in `useChat` and `useQuickChat` hooks, with corresponding test coverage for the queueing behavior without the toast. Fusion-Task-Id: FN-4056
1377 lines
47 KiB
TypeScript
1377 lines
47 KiB
TypeScript
import { act, fireEvent, renderHook, waitFor } from "@testing-library/react";
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
|
import type { ChatSession } from "@fusion/core";
|
|
import * as apiModule from "../../api";
|
|
import { FN_AGENT_ID, useQuickChat } from "../useQuickChat";
|
|
|
|
vi.mock("../../api", () => ({
|
|
fetchResumeChatSession: vi.fn(),
|
|
fetchChatSessions: vi.fn(),
|
|
fetchChatSession: vi.fn(),
|
|
createChatSession: vi.fn(),
|
|
fetchChatMessages: vi.fn(),
|
|
streamChatResponse: vi.fn(),
|
|
attachChatStream: vi.fn(),
|
|
cancelChatResponse: vi.fn(),
|
|
}));
|
|
|
|
const mockFetchResumeChatSession = vi.mocked(apiModule.fetchResumeChatSession);
|
|
const mockFetchChatSessions = vi.mocked(apiModule.fetchChatSessions);
|
|
const mockFetchChatSession = vi.mocked(apiModule.fetchChatSession);
|
|
const mockCreateChatSession = vi.mocked(apiModule.createChatSession);
|
|
const mockFetchChatMessages = vi.mocked(apiModule.fetchChatMessages);
|
|
const mockStreamChatResponse = vi.mocked(apiModule.streamChatResponse);
|
|
const mockAttachChatStream = vi.mocked(apiModule.attachChatStream);
|
|
const mockCancelChatResponse = vi.mocked(apiModule.cancelChatResponse);
|
|
|
|
function makeSession(overrides: Partial<ChatSession> & Pick<ChatSession, "id" | "agentId">): ChatSession {
|
|
return {
|
|
id: overrides.id,
|
|
agentId: overrides.agentId,
|
|
title: overrides.title ?? null,
|
|
status: overrides.status ?? "active",
|
|
projectId: overrides.projectId ?? null,
|
|
modelProvider: overrides.modelProvider ?? null,
|
|
modelId: overrides.modelId ?? null,
|
|
createdAt: overrides.createdAt ?? new Date().toISOString(),
|
|
updatedAt: overrides.updatedAt ?? new Date().toISOString(),
|
|
};
|
|
}
|
|
|
|
const setDocumentVisibilityState = (state: DocumentVisibilityState) => {
|
|
Object.defineProperty(document, "visibilityState", {
|
|
configurable: true,
|
|
get: () => state,
|
|
});
|
|
fireEvent(document, new Event("visibilitychange"));
|
|
};
|
|
|
|
describe("useQuickChat", () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
mockFetchResumeChatSession.mockResolvedValue({ session: null });
|
|
mockFetchChatSessions.mockResolvedValue({ sessions: [] });
|
|
mockCreateChatSession.mockResolvedValue({
|
|
session: makeSession({ id: "session-001", agentId: "agent-001" }),
|
|
});
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
mockFetchChatSession.mockResolvedValue({
|
|
session: { ...makeSession({ id: "session-001", agentId: "agent-001" }), isGenerating: false },
|
|
});
|
|
mockStreamChatResponse.mockReturnValue({ close: vi.fn(), isConnected: () => true });
|
|
mockAttachChatStream.mockReturnValue({ close: vi.fn(), isConnected: () => true });
|
|
mockCancelChatResponse.mockResolvedValue({ success: true });
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.clearAllMocks();
|
|
vi.useRealTimers();
|
|
});
|
|
|
|
it("sendMessage returns a promise that resolves on stream completion", async () => {
|
|
const session = makeSession({ id: "session-001", agentId: "agent-001" });
|
|
mockFetchResumeChatSession.mockResolvedValue({ session });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.activeSession).not.toBeNull();
|
|
});
|
|
|
|
mockStreamChatResponse.mockImplementation((_sessionId, _content, handlers) => {
|
|
setTimeout(() => {
|
|
handlers.onDone?.({ messageId: "msg-001" });
|
|
}, 0);
|
|
return { close: vi.fn(), isConnected: () => true };
|
|
});
|
|
|
|
const sendResult = result.current.sendMessage("Hello");
|
|
await expect(sendResult).resolves.toBeUndefined();
|
|
});
|
|
|
|
it("sets isStreaming true during first send and clears on delayed done", async () => {
|
|
const session = makeSession({ id: "session-001", agentId: "agent-001" });
|
|
mockFetchResumeChatSession.mockResolvedValue({ session });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
mockStreamChatResponse.mockImplementation((_sessionId, _content, handlers) => {
|
|
setTimeout(() => {
|
|
handlers.onDone?.({ messageId: "msg-001" });
|
|
}, 200);
|
|
return { close: vi.fn(), isConnected: () => true };
|
|
});
|
|
|
|
void act(() => {
|
|
void result.current.sendMessage("Hello");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(true);
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(false);
|
|
});
|
|
});
|
|
|
|
it("uses done payload assistant snapshot when no text chunks were streamed", async () => {
|
|
const session = makeSession({ id: "session-001", agentId: "agent-001" });
|
|
mockFetchResumeChatSession.mockResolvedValue({ session });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
mockStreamChatResponse.mockImplementation((_sessionId, _content, handlers) => {
|
|
setTimeout(() => {
|
|
handlers.onDone?.({
|
|
messageId: "msg-001",
|
|
message: {
|
|
id: "msg-001",
|
|
sessionId: "session-001",
|
|
role: "assistant",
|
|
content: "Snapshot reply",
|
|
thinkingOutput: null,
|
|
metadata: null,
|
|
createdAt: "2026-01-01T00:00:00.000Z",
|
|
} as any,
|
|
});
|
|
}, 0);
|
|
return { close: vi.fn(), isConnected: () => true };
|
|
});
|
|
|
|
await act(async () => {
|
|
await result.current.sendMessage("Hello");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.messages.at(-1)).toEqual(expect.objectContaining({
|
|
id: "msg-001",
|
|
role: "assistant",
|
|
content: "Snapshot reply",
|
|
}));
|
|
});
|
|
});
|
|
|
|
it("prefers done payload assistant snapshot over streamed text", async () => {
|
|
const session = makeSession({ id: "session-001", agentId: "agent-001" });
|
|
mockFetchResumeChatSession.mockResolvedValue({ session });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
let onText: ((data: string) => void) | undefined;
|
|
let onDone: ((data: { messageId: string; message?: any }) => void) | undefined;
|
|
mockStreamChatResponse.mockImplementation((_sessionId, _content, handlers) => {
|
|
onText = handlers.onText;
|
|
onDone = handlers.onDone as typeof onDone;
|
|
return { close: vi.fn(), isConnected: () => true };
|
|
});
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
act(() => {
|
|
void result.current.sendMessage("Hello");
|
|
onText?.("streamed text");
|
|
onDone?.({
|
|
messageId: "msg-002",
|
|
message: {
|
|
id: "msg-002",
|
|
sessionId: "session-001",
|
|
role: "assistant",
|
|
content: "snapshot wins",
|
|
thinkingOutput: null,
|
|
metadata: null,
|
|
createdAt: "2026-01-01T00:00:00.000Z",
|
|
},
|
|
});
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.messages.at(-1)).toEqual(expect.objectContaining({
|
|
id: "msg-002",
|
|
content: "snapshot wins",
|
|
}));
|
|
});
|
|
});
|
|
|
|
it("startModelChat creates a KB session with provider/model override", async () => {
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.startModelChat("anthropic", "claude-sonnet-4-5");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(mockCreateChatSession).toHaveBeenCalledWith(
|
|
{
|
|
agentId: FN_AGENT_ID,
|
|
modelProvider: "anthropic",
|
|
modelId: "claude-sonnet-4-5",
|
|
},
|
|
"proj-123",
|
|
);
|
|
});
|
|
});
|
|
|
|
it("switchSession with only agentId creates session without model params", async () => {
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(mockCreateChatSession).toHaveBeenCalledWith(
|
|
{ agentId: "agent-001" },
|
|
"proj-123",
|
|
);
|
|
// Ensure model params are not included
|
|
const callArg = mockCreateChatSession.mock.calls[0][0];
|
|
expect(callArg).not.toHaveProperty("modelProvider");
|
|
expect(callArg).not.toHaveProperty("modelId");
|
|
});
|
|
});
|
|
|
|
it("switchSession falls back to KB agent when no explicit agent is provided", async () => {
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("", "openai", "gpt-4o");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(mockCreateChatSession).toHaveBeenCalledWith(
|
|
{
|
|
agentId: FN_AGENT_ID,
|
|
modelProvider: "openai",
|
|
modelId: "gpt-4o",
|
|
},
|
|
"proj-123",
|
|
);
|
|
});
|
|
});
|
|
|
|
it("switchSession with different model selections creates distinct sessions", async () => {
|
|
const modelASession = makeSession({
|
|
id: "session-model-a",
|
|
agentId: "agent-001",
|
|
modelProvider: "anthropic",
|
|
modelId: "claude-sonnet-4-5",
|
|
});
|
|
|
|
mockCreateChatSession
|
|
.mockResolvedValueOnce({ session: modelASession })
|
|
.mockResolvedValueOnce({
|
|
session: makeSession({
|
|
id: "session-model-b",
|
|
agentId: "agent-001",
|
|
modelProvider: "openai",
|
|
modelId: "gpt-4o",
|
|
}),
|
|
});
|
|
|
|
mockFetchResumeChatSession
|
|
.mockResolvedValueOnce({ session: null })
|
|
.mockResolvedValueOnce({ session: null });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001", "anthropic", "claude-sonnet-4-5");
|
|
});
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001", "openai", "gpt-4o");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(mockCreateChatSession).toHaveBeenNthCalledWith(
|
|
1,
|
|
{
|
|
agentId: "agent-001",
|
|
modelProvider: "anthropic",
|
|
modelId: "claude-sonnet-4-5",
|
|
},
|
|
"proj-123",
|
|
);
|
|
|
|
expect(mockCreateChatSession).toHaveBeenNthCalledWith(
|
|
2,
|
|
{
|
|
agentId: "agent-001",
|
|
modelProvider: "openai",
|
|
modelId: "gpt-4o",
|
|
},
|
|
"proj-123",
|
|
);
|
|
});
|
|
});
|
|
|
|
it("switchSession with the same target reloads messages instead of creating a new session", async () => {
|
|
const existingSession = makeSession({
|
|
id: "session-existing",
|
|
agentId: "agent-001",
|
|
modelProvider: "openai",
|
|
modelId: "gpt-4o",
|
|
});
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001", "openai", "gpt-4o");
|
|
});
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001", "openai", "gpt-4o");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(mockCreateChatSession).not.toHaveBeenCalled();
|
|
expect(mockFetchChatMessages).toHaveBeenCalledWith("session-existing", { limit: 50 }, "proj-123");
|
|
});
|
|
});
|
|
|
|
it("switchSession preserves isStreaming when same session is resumed", async () => {
|
|
const existingSession = makeSession({ id: "session-existing", agentId: "agent-001" });
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
mockStreamChatResponse.mockReturnValue({ close: vi.fn(), isConnected: () => true });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
act(() => {
|
|
result.current.sendMessage("Hello");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(true);
|
|
});
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(true);
|
|
expect(mockFetchChatMessages).toHaveBeenCalledWith("session-existing", { limit: 50 }, "proj-123");
|
|
});
|
|
});
|
|
|
|
it("switchSession resets streaming state when switching to a different session", async () => {
|
|
const sessionA = makeSession({ id: "session-a", agentId: "agent-001" });
|
|
const sessionB = makeSession({ id: "session-b", agentId: "agent-002" });
|
|
const closeFn = vi.fn();
|
|
|
|
mockFetchResumeChatSession
|
|
.mockResolvedValueOnce({ session: sessionA })
|
|
.mockResolvedValueOnce({ session: sessionB });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
mockStreamChatResponse.mockReturnValue({ close: closeFn, isConnected: () => true });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
act(() => {
|
|
result.current.sendMessage("Hello");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(true);
|
|
});
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-002");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(closeFn).toHaveBeenCalledTimes(1);
|
|
expect(result.current.isStreaming).toBe(false);
|
|
expect(result.current.streamingText).toBe("");
|
|
expect(result.current.streamingThinking).toBe("");
|
|
expect(result.current.streamingToolCalls).toEqual([]);
|
|
});
|
|
});
|
|
|
|
it("resumes via targeted lookup without loading the full active-session list", async () => {
|
|
const existingSession = makeSession({
|
|
id: "session-targeted",
|
|
agentId: "agent-001",
|
|
modelProvider: "openai",
|
|
modelId: "gpt-4o",
|
|
});
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockFetchChatSessions.mockRejectedValue(new Error("should not enumerate active sessions"));
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001", "openai", "gpt-4o");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.activeSession?.id).toBe("session-targeted");
|
|
expect(mockFetchResumeChatSession).toHaveBeenCalledWith(
|
|
{
|
|
agentId: "agent-001",
|
|
modelProvider: "openai",
|
|
modelId: "gpt-4o",
|
|
},
|
|
"proj-123",
|
|
);
|
|
expect(mockFetchChatSessions).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
it("startFreshSession creates a second session for the same model target", async () => {
|
|
const existingSession = makeSession({
|
|
id: "session-existing",
|
|
agentId: FN_AGENT_ID,
|
|
modelProvider: "openai",
|
|
modelId: "gpt-4o",
|
|
});
|
|
const freshSession = makeSession({
|
|
id: "session-fresh",
|
|
agentId: FN_AGENT_ID,
|
|
modelProvider: "openai",
|
|
modelId: "gpt-4o",
|
|
});
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockCreateChatSession.mockResolvedValueOnce({ session: freshSession });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.startModelChat("openai", "gpt-4o");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.activeSession?.id).toBe("session-existing");
|
|
});
|
|
|
|
await act(async () => {
|
|
await result.current.startFreshSession();
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(mockCreateChatSession).toHaveBeenCalledWith(
|
|
{
|
|
agentId: FN_AGENT_ID,
|
|
modelProvider: "openai",
|
|
modelId: "gpt-4o",
|
|
},
|
|
"proj-123",
|
|
);
|
|
expect(result.current.activeSession?.id).toBe("session-fresh");
|
|
expect(mockFetchChatMessages).toHaveBeenCalledWith("session-fresh", { limit: 50 }, "proj-123");
|
|
});
|
|
});
|
|
|
|
it("startFreshSession clears queued pending message state", async () => {
|
|
const existingSession = makeSession({ id: "session-existing", agentId: "agent-001" });
|
|
const freshSession = makeSession({ id: "session-fresh", agentId: "agent-001" });
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockCreateChatSession.mockResolvedValueOnce({ session: freshSession });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
act(() => {
|
|
result.current.sendMessage("Hello");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(true);
|
|
});
|
|
|
|
act(() => {
|
|
result.current.sendMessage("Queued follow-up");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.pendingMessage).toBe("Queued follow-up");
|
|
});
|
|
|
|
await act(async () => {
|
|
await result.current.startFreshSession();
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.pendingMessage).toBe("");
|
|
expect(result.current.isStreaming).toBe(false);
|
|
expect(result.current.activeSession?.id).toBe("session-fresh");
|
|
});
|
|
});
|
|
|
|
it("stopStreaming aborts stream and resets streaming state", async () => {
|
|
const existingSession = makeSession({ id: "session-existing", agentId: "agent-001" });
|
|
const closeFn = vi.fn();
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
mockStreamChatResponse.mockReturnValue({ close: closeFn, isConnected: () => true });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
act(() => {
|
|
result.current.sendMessage("Hello");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(true);
|
|
});
|
|
|
|
act(() => {
|
|
result.current.stopStreaming();
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(closeFn).toHaveBeenCalled();
|
|
expect(mockCancelChatResponse).toHaveBeenCalledWith("session-existing", "proj-123");
|
|
expect(result.current.isStreaming).toBe(false);
|
|
expect(result.current.streamingText).toBe("");
|
|
expect(result.current.streamingThinking).toBe("");
|
|
});
|
|
});
|
|
|
|
it("sending during streaming queues message without warning toast", async () => {
|
|
const existingSession = makeSession({ id: "session-existing", agentId: "agent-001" });
|
|
const addToast = vi.fn();
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
mockStreamChatResponse.mockReturnValue({ close: vi.fn(), isConnected: () => true });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123", addToast));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
act(() => {
|
|
result.current.sendMessage("Hello");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(true);
|
|
});
|
|
|
|
act(() => {
|
|
result.current.sendMessage("Queued follow-up");
|
|
});
|
|
|
|
expect(result.current.pendingMessage).toBe("Queued follow-up");
|
|
expect(mockStreamChatResponse).toHaveBeenCalledTimes(1);
|
|
expect(addToast).not.toHaveBeenCalledWith("Still waiting for previous response — message queued", "warning");
|
|
});
|
|
|
|
it("starts a fresh stream and shows active state on second turn after first turn completes", async () => {
|
|
const existingSession = makeSession({ id: "session-existing", agentId: "agent-001" });
|
|
const handlers: Array<Parameters<typeof mockStreamChatResponse>[2]> = [];
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
mockStreamChatResponse.mockImplementation((_sessionId, _content, nextHandlers) => {
|
|
handlers.push(nextHandlers);
|
|
return { close: vi.fn(), isConnected: () => true };
|
|
});
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
act(() => {
|
|
void result.current.sendMessage("Turn 1");
|
|
});
|
|
|
|
expect(mockStreamChatResponse).toHaveBeenCalledTimes(1);
|
|
|
|
act(() => {
|
|
handlers[0]?.onDone?.({ messageId: "msg-001" });
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(false);
|
|
});
|
|
|
|
act(() => {
|
|
void result.current.sendMessage("Turn 2");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(mockStreamChatResponse).toHaveBeenCalledTimes(2);
|
|
expect(result.current.isStreaming).toBe(true);
|
|
});
|
|
|
|
act(() => {
|
|
handlers[1]?.onError?.("second turn failed");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("message queue behavior", () => {
|
|
it("queued message is auto-sent after streaming onDone", async () => {
|
|
const existingSession = makeSession({ id: "session-existing", agentId: "agent-001" });
|
|
const handlers: Array<Parameters<typeof mockStreamChatResponse>[2]> = [];
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
mockStreamChatResponse.mockImplementation((_sessionId, _content, nextHandlers) => {
|
|
handlers.push(nextHandlers);
|
|
return { close: vi.fn(), isConnected: () => true };
|
|
});
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
act(() => {
|
|
result.current.sendMessage("Hello");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(true);
|
|
});
|
|
|
|
act(() => {
|
|
result.current.sendMessage("Queued follow-up");
|
|
});
|
|
|
|
act(() => {
|
|
handlers[0]?.onDone?.({ messageId: "msg-001" });
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(mockStreamChatResponse).toHaveBeenCalledTimes(2);
|
|
expect(mockStreamChatResponse.mock.calls[1]?.[1]).toBe("Queued follow-up");
|
|
expect(result.current.pendingMessage).toBe("");
|
|
});
|
|
});
|
|
|
|
it("resolves current send promise and creates a new completion for queued send", async () => {
|
|
const existingSession = makeSession({ id: "session-existing", agentId: "agent-001" });
|
|
const handlers: Array<Parameters<typeof mockStreamChatResponse>[2]> = [];
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
mockStreamChatResponse.mockImplementation((_sessionId, _content, nextHandlers) => {
|
|
handlers.push(nextHandlers);
|
|
return { close: vi.fn(), isConnected: () => true };
|
|
});
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
let firstSend: Promise<void>;
|
|
await act(async () => {
|
|
firstSend = result.current.sendMessage("First");
|
|
});
|
|
|
|
act(() => {
|
|
void result.current.sendMessage("Queued follow-up");
|
|
});
|
|
|
|
await act(async () => {
|
|
handlers[0]?.onDone?.({ messageId: "msg-001" });
|
|
});
|
|
|
|
await expect(firstSend!).resolves.toBeUndefined();
|
|
|
|
await waitFor(() => {
|
|
expect(mockStreamChatResponse).toHaveBeenCalledTimes(2);
|
|
expect(result.current.isStreaming).toBe(true);
|
|
});
|
|
|
|
await act(async () => {
|
|
handlers[1]?.onDone?.({ messageId: "msg-002" });
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(false);
|
|
});
|
|
});
|
|
});
|
|
|
|
it("onError does not remove user message from local state", async () => {
|
|
const existingSession = makeSession({ id: "session-existing", agentId: "agent-001" });
|
|
let onErrorHandler: ((data: string) => void) | undefined;
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockFetchChatMessages
|
|
.mockResolvedValueOnce({ messages: [] })
|
|
.mockResolvedValueOnce({
|
|
messages: [
|
|
{
|
|
id: "msg-user-1",
|
|
sessionId: existingSession.id,
|
|
role: "user",
|
|
content: "Hello",
|
|
thinkingOutput: null,
|
|
metadata: null,
|
|
createdAt: new Date().toISOString(),
|
|
},
|
|
],
|
|
});
|
|
|
|
mockStreamChatResponse.mockImplementation((_sessionId, _content, handlers) => {
|
|
onErrorHandler = handlers.onError;
|
|
return { close: vi.fn(), isConnected: () => true };
|
|
});
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
act(() => {
|
|
result.current.sendMessage("Hello");
|
|
});
|
|
|
|
expect(result.current.messages.some((message) => message.role === "user" && message.content === "Hello")).toBe(true);
|
|
|
|
act(() => {
|
|
onErrorHandler?.("Connection aborted");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.messages.some((message) => message.role === "user" && message.content === "Hello")).toBe(true);
|
|
});
|
|
});
|
|
|
|
it("onError reloads messages from server", async () => {
|
|
const existingSession = makeSession({ id: "session-existing", agentId: "agent-001" });
|
|
let onErrorHandler: ((data: string) => void) | undefined;
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
mockStreamChatResponse.mockImplementation((_sessionId, _content, handlers) => {
|
|
onErrorHandler = handlers.onError;
|
|
return { close: vi.fn(), isConnected: () => true };
|
|
});
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
act(() => {
|
|
result.current.sendMessage("Hello");
|
|
});
|
|
|
|
act(() => {
|
|
onErrorHandler?.("Connection aborted");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(mockFetchChatMessages).toHaveBeenCalledTimes(2);
|
|
expect(mockFetchChatMessages).toHaveBeenLastCalledWith("session-existing", { limit: 50 }, "proj-123");
|
|
});
|
|
});
|
|
|
|
it("onError resets streaming state", async () => {
|
|
const existingSession = makeSession({ id: "session-existing", agentId: "agent-001" });
|
|
let onErrorHandler: ((data: string) => void) | undefined;
|
|
let onTextHandler: ((data: string) => void) | undefined;
|
|
let onThinkingHandler: ((data: string) => void) | undefined;
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
mockStreamChatResponse.mockImplementation((_sessionId, _content, handlers) => {
|
|
onErrorHandler = handlers.onError;
|
|
onTextHandler = handlers.onText;
|
|
onThinkingHandler = handlers.onThinking;
|
|
return { close: vi.fn(), isConnected: () => true };
|
|
});
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
act(() => {
|
|
result.current.sendMessage("Hello");
|
|
onTextHandler?.("Partial answer");
|
|
onThinkingHandler?.("Thinking...");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(true);
|
|
expect(result.current.streamingText).toBe("Partial answer");
|
|
expect(result.current.streamingThinking).toBe("Thinking...");
|
|
});
|
|
|
|
act(() => {
|
|
onErrorHandler?.("Connection aborted");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(false);
|
|
expect(result.current.streamingText).toBe("");
|
|
expect(result.current.streamingThinking).toBe("");
|
|
});
|
|
});
|
|
|
|
it("onError shows the backend error message in the toast", async () => {
|
|
const existingSession = makeSession({ id: "session-existing", agentId: "agent-001" });
|
|
const addToast = vi.fn();
|
|
let onErrorHandler: ((data: string) => void) | undefined;
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
mockStreamChatResponse.mockImplementation((_sessionId, _content, handlers) => {
|
|
onErrorHandler = handlers.onError;
|
|
return { close: vi.fn(), isConnected: () => true };
|
|
});
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123", addToast));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
act(() => {
|
|
result.current.sendMessage("Hello");
|
|
onErrorHandler?.("No API key for provider: openai-codex");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(addToast).toHaveBeenCalledWith("No API key for provider: openai-codex", "error");
|
|
});
|
|
});
|
|
|
|
it("suppresses Load failed toast when tab is hidden", async () => {
|
|
const existingSession = makeSession({ id: "session-existing", agentId: "agent-001" });
|
|
const addToast = vi.fn();
|
|
let onErrorHandler: ((data: string) => void) | undefined;
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
mockStreamChatResponse.mockImplementation((_sessionId, _content, handlers) => {
|
|
onErrorHandler = handlers.onError;
|
|
return { close: vi.fn(), isConnected: () => true };
|
|
});
|
|
|
|
setDocumentVisibilityState("hidden");
|
|
const { result } = renderHook(() => useQuickChat("proj-123", addToast));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
await act(async () => {
|
|
const sendPromise = result.current.sendMessage("Hello");
|
|
onErrorHandler?.("Load failed");
|
|
await sendPromise;
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(addToast).not.toHaveBeenCalledWith("Load failed", "error");
|
|
});
|
|
});
|
|
|
|
it("shows Load failed toast when tab remains visible", async () => {
|
|
const existingSession = makeSession({ id: "session-existing", agentId: "agent-001" });
|
|
const addToast = vi.fn();
|
|
let onErrorHandler: ((data: string) => void) | undefined;
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
mockStreamChatResponse.mockImplementation((_sessionId, _content, handlers) => {
|
|
onErrorHandler = handlers.onError;
|
|
return { close: vi.fn(), isConnected: () => true };
|
|
});
|
|
|
|
setDocumentVisibilityState("visible");
|
|
const { result } = renderHook(() => useQuickChat("proj-123", addToast));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
await expect(act(async () => {
|
|
const sendPromise = result.current.sendMessage("Hello");
|
|
onErrorHandler?.("Load failed");
|
|
await sendPromise;
|
|
})).rejects.toThrow("Load failed");
|
|
|
|
await waitFor(() => {
|
|
expect(addToast).toHaveBeenCalledWith("Load failed", "error");
|
|
});
|
|
});
|
|
|
|
it("suppresses Failed to fetch shortly after hidden to visible transition", async () => {
|
|
const existingSession = makeSession({ id: "session-existing", agentId: "agent-001" });
|
|
const addToast = vi.fn();
|
|
let onErrorHandler: ((data: string) => void) | undefined;
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
mockStreamChatResponse.mockImplementation((_sessionId, _content, handlers) => {
|
|
onErrorHandler = handlers.onError;
|
|
return { close: vi.fn(), isConnected: () => true };
|
|
});
|
|
|
|
setDocumentVisibilityState("hidden");
|
|
const { result } = renderHook(() => useQuickChat("proj-123", addToast));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
await act(async () => {
|
|
setDocumentVisibilityState("visible");
|
|
const sendPromise = result.current.sendMessage("Hello");
|
|
onErrorHandler?.("Failed to fetch");
|
|
await sendPromise;
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(addToast).not.toHaveBeenCalledWith("Failed to fetch", "error");
|
|
});
|
|
});
|
|
|
|
it("still shows toast for non-suspension errors regardless of visibility", async () => {
|
|
const existingSession = makeSession({ id: "session-existing", agentId: "agent-001" });
|
|
const addToast = vi.fn();
|
|
let onErrorHandler: ((data: string) => void) | undefined;
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
mockStreamChatResponse.mockImplementation((_sessionId, _content, handlers) => {
|
|
onErrorHandler = handlers.onError;
|
|
return { close: vi.fn(), isConnected: () => true };
|
|
});
|
|
|
|
setDocumentVisibilityState("hidden");
|
|
const { result } = renderHook(() => useQuickChat("proj-123", addToast));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
await expect(act(async () => {
|
|
const sendPromise = result.current.sendMessage("Hello");
|
|
onErrorHandler?.("Request failed: 500");
|
|
await sendPromise;
|
|
})).rejects.toThrow("Request failed: 500");
|
|
|
|
await waitFor(() => {
|
|
expect(addToast).toHaveBeenCalledWith("Request failed: 500", "error");
|
|
});
|
|
});
|
|
|
|
it("onFallback updates the active model, persists fallback metadata, and shows a warning toast", async () => {
|
|
const existingSession = makeSession({
|
|
id: "session-existing",
|
|
agentId: FN_AGENT_ID,
|
|
modelProvider: "openai-codex",
|
|
modelId: "gpt-5.3-codex",
|
|
});
|
|
const addToast = vi.fn();
|
|
let onFallbackHandler:
|
|
| ((data: { primaryModel: string; fallbackModel: string; triggerPoint: "session-creation" | "prompt-time" }) => void)
|
|
| undefined;
|
|
let onTextHandler: ((data: string) => void) | undefined;
|
|
let onDoneHandler: ((data: { messageId: string }) => void) | undefined;
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
mockStreamChatResponse.mockImplementation((_sessionId, _content, handlers) => {
|
|
onFallbackHandler = handlers.onFallback;
|
|
onTextHandler = handlers.onText;
|
|
onDoneHandler = handlers.onDone;
|
|
return { close: vi.fn(), isConnected: () => true };
|
|
});
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123", addToast));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession(FN_AGENT_ID, "openai-codex", "gpt-5.3-codex");
|
|
});
|
|
|
|
act(() => {
|
|
result.current.sendMessage("Hello");
|
|
onFallbackHandler?.({
|
|
primaryModel: "openai-codex/gpt-5.3-codex",
|
|
fallbackModel: "zai/glm-5.1",
|
|
triggerPoint: "prompt-time",
|
|
});
|
|
onTextHandler?.("Fallback reply");
|
|
onDoneHandler?.({ messageId: "msg-fallback" });
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.activeSession?.modelProvider).toBe("zai");
|
|
expect(result.current.activeSession?.modelId).toBe("glm-5.1");
|
|
expect(addToast).toHaveBeenCalledWith(
|
|
"Primary model unavailable. Switched to fallback zai/glm-5.1.",
|
|
"warning",
|
|
);
|
|
expect(result.current.messages.at(-1)).toEqual(expect.objectContaining({
|
|
id: "msg-fallback",
|
|
role: "assistant",
|
|
content: "Fallback reply",
|
|
fallbackInfo: {
|
|
primaryModel: "openai-codex/gpt-5.3-codex",
|
|
fallbackModel: "zai/glm-5.1",
|
|
triggerPoint: "prompt-time",
|
|
},
|
|
}));
|
|
});
|
|
});
|
|
|
|
describe("regression: init retry limit prevents infinite toast spam", () => {
|
|
it("stops showing error toasts after 3 consecutive initialization failures", async () => {
|
|
const addToast = vi.fn();
|
|
mockFetchResumeChatSession.mockRejectedValue(new Error("API down"));
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123", addToast));
|
|
|
|
// Attempt 1
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
// Attempt 2
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
// Attempt 3
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
// Attempt 4 — should be silently dropped
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-002");
|
|
});
|
|
|
|
// Should have exactly 3 toast calls (one per unique target up to the limit)
|
|
// Each new target resets the retry counter, so agent-001 gets 3 toasts
|
|
// and agent-002 starts fresh. But agent-001 only has 3 switchSession calls
|
|
// each with a different internal retry.
|
|
//
|
|
// Actually: switchSession clears the session each time, so each call
|
|
// goes through initializeSession which increments the counter.
|
|
// The counter resets on success or when startFreshSession is called.
|
|
// With 3 calls for agent-001, that's 3 failures = 3 toasts.
|
|
// Then agent-002 starts a new sequence — retry counter continues
|
|
// because it's the same hook instance.
|
|
expect(addToast).toHaveBeenCalledTimes(3);
|
|
expect(addToast).toHaveBeenNthCalledWith(1, "Failed to initialize chat", "error");
|
|
expect(addToast).toHaveBeenNthCalledWith(2, "Failed to initialize chat", "error");
|
|
expect(addToast).toHaveBeenNthCalledWith(3, "Failed to initialize chat", "error");
|
|
});
|
|
|
|
it("resets retry counter after a successful initialization", async () => {
|
|
const addToast = vi.fn();
|
|
|
|
const session = makeSession({ id: "session-001", agentId: "agent-001" });
|
|
mockFetchResumeChatSession
|
|
.mockRejectedValueOnce(new Error("API down"))
|
|
.mockResolvedValueOnce({ session });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123", addToast));
|
|
|
|
// Fail once
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
expect(addToast).toHaveBeenCalledTimes(1);
|
|
|
|
// Succeed — resets counter
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
expect(result.current.activeSession?.id).toBe("session-001");
|
|
|
|
// Fail again — counter was reset, so toast shows again
|
|
mockFetchResumeChatSession.mockRejectedValue(new Error("API down again"));
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-002");
|
|
});
|
|
expect(addToast).toHaveBeenCalledTimes(2);
|
|
});
|
|
});
|
|
|
|
describe("regression: startFreshSession skip flag prevents useEffect race", () => {
|
|
it("sets skipNextSessionInitRef during startFreshSession and clears it after", async () => {
|
|
const existingSession = makeSession({ id: "session-existing", agentId: "agent-001" });
|
|
const freshSession = makeSession({ id: "session-fresh", agentId: "agent-001" });
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockCreateChatSession.mockResolvedValueOnce({ session: freshSession });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
// Before startFreshSession — flag should be false
|
|
expect(result.current.skipNextSessionInitRef.current).toBe(false);
|
|
|
|
// During startFreshSession — the flag is set then cleared in finally
|
|
await act(async () => {
|
|
await result.current.startFreshSession();
|
|
});
|
|
|
|
// After startFreshSession — flag should be cleared
|
|
expect(result.current.skipNextSessionInitRef.current).toBe(false);
|
|
expect(result.current.activeSession?.id).toBe("session-fresh");
|
|
});
|
|
|
|
it("startFreshSession creates a new session even when an existing one exists for the same agent", async () => {
|
|
const existingSession = makeSession({ id: "session-old", agentId: "agent-001" });
|
|
const freshSession = makeSession({ id: "session-new", agentId: "agent-001" });
|
|
|
|
mockFetchResumeChatSession.mockResolvedValueOnce({ session: existingSession });
|
|
mockCreateChatSession.mockResolvedValueOnce({ session: freshSession });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
// First switchSession resumes existing session
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
expect(result.current.activeSession?.id).toBe("session-old");
|
|
|
|
// startFreshSession should bypass resume and create a new one
|
|
await act(async () => {
|
|
await result.current.startFreshSession();
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.activeSession?.id).toBe("session-new");
|
|
});
|
|
|
|
// createSession was called (not resume)
|
|
expect(mockCreateChatSession).toHaveBeenCalledWith(
|
|
{ agentId: "agent-001" },
|
|
"proj-123",
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("regression: switchSession uses activeSessionRef to avoid cascading re-renders", () => {
|
|
it("switchSession does not re-initialize when activeSession changes", async () => {
|
|
const sessionA = makeSession({ id: "session-a", agentId: "agent-001" });
|
|
|
|
mockFetchResumeChatSession.mockResolvedValue({ session: sessionA });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
expect(result.current.activeSession).not.toBeNull();
|
|
|
|
// Calling switchSession again with the same target should NOT
|
|
// go through initializeSession again — it should just reload
|
|
// messages (because activeSessionRef.current is set, making
|
|
// isSameSession = true). This is the key behavioral fix:
|
|
// even though switchSession gets a new identity from other deps,
|
|
// it reads activeSession from a ref so it correctly detects
|
|
// "same session" and skips re-initialization.
|
|
const resumeCallCount = mockFetchResumeChatSession.mock.calls.length;
|
|
const createCallCount = mockCreateChatSession.mock.calls.length;
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
// No additional API calls for session lookup or creation
|
|
expect(mockFetchResumeChatSession.mock.calls.length).toBe(resumeCallCount);
|
|
expect(mockCreateChatSession.mock.calls.length).toBe(createCallCount);
|
|
|
|
// Messages were reloaded though
|
|
expect(mockFetchChatMessages).toHaveBeenCalled();
|
|
});
|
|
|
|
it("switchSession with same target after activeSession change just reloads messages", async () => {
|
|
const sessionA = makeSession({ id: "session-a", agentId: "agent-001" });
|
|
|
|
mockFetchResumeChatSession.mockResolvedValue({ session: sessionA });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
expect(result.current.activeSession?.id).toBe("session-a");
|
|
|
|
// Calling switchSession again with same target should reload messages,
|
|
// not call fetchResumeChatSession again
|
|
const initialResumeCallCount = mockFetchResumeChatSession.mock.calls.length;
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
// No additional resume lookup — just message reload
|
|
expect(mockFetchResumeChatSession.mock.calls.length).toBe(initialResumeCallCount);
|
|
expect(mockFetchChatMessages).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe("FN-3336: streaming state recovery on reload", () => {
|
|
it("hydrates durable in-flight snapshot and resumes from replay point", async () => {
|
|
const session = {
|
|
...makeSession({ id: "session-001", agentId: "agent-001" }),
|
|
isGenerating: true,
|
|
inFlightGeneration: {
|
|
status: "generating" as const,
|
|
streamingText: "partial text",
|
|
streamingThinking: "partial thinking",
|
|
toolCalls: [{ toolName: "read", status: "running" as const, isError: false }],
|
|
replayFromEventId: 17,
|
|
updatedAt: "2026-04-08T00:00:00.000Z",
|
|
},
|
|
};
|
|
mockFetchResumeChatSession.mockResolvedValue({ session });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(true);
|
|
expect(result.current.streamingText).toBe("partial text");
|
|
expect(result.current.streamingThinking).toBe("partial thinking");
|
|
expect(result.current.streamingToolCalls).toHaveLength(1);
|
|
});
|
|
|
|
expect(mockAttachChatStream).toHaveBeenCalledWith(
|
|
"session-001",
|
|
expect.any(Object),
|
|
"proj-123",
|
|
{ lastEventId: 17 },
|
|
);
|
|
});
|
|
|
|
it("sets isStreaming=true when initializing a session with isGenerating=true", async () => {
|
|
const session = { ...makeSession({ id: "session-001", agentId: "agent-001" }), isGenerating: true };
|
|
mockFetchResumeChatSession.mockResolvedValue({ session });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(true);
|
|
expect(result.current.streamingText).toBe("");
|
|
});
|
|
});
|
|
|
|
it("does not set isStreaming when isGenerating is false", async () => {
|
|
const session = { ...makeSession({ id: "session-001", agentId: "agent-001" }), isGenerating: false };
|
|
mockFetchResumeChatSession.mockResolvedValue({ session });
|
|
mockFetchChatMessages.mockResolvedValue({ messages: [] });
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(false);
|
|
});
|
|
});
|
|
|
|
it("clears recovery streaming state when attach stream completes", async () => {
|
|
const session = { ...makeSession({ id: "session-001", agentId: "agent-001" }), isGenerating: true };
|
|
mockFetchResumeChatSession.mockResolvedValue({ session });
|
|
mockFetchChatMessages.mockResolvedValue({
|
|
messages: [
|
|
{ id: "msg-1", sessionId: "session-001", role: "assistant", content: "Done", thinkingOutput: null, metadata: null, createdAt: new Date().toISOString() },
|
|
],
|
|
});
|
|
mockAttachChatStream.mockImplementation((_sessionId, handlers) => {
|
|
setTimeout(() => handlers.onDone?.({ messageId: "msg-1" }), 0);
|
|
return { close: vi.fn(), isConnected: () => true };
|
|
});
|
|
|
|
const { result } = renderHook(() => useQuickChat("proj-123"));
|
|
|
|
await act(async () => {
|
|
await result.current.switchSession("agent-001");
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(result.current.isStreaming).toBe(false);
|
|
expect(result.current.streamingText).toBe("");
|
|
expect(result.current.messages.some((m) => m.id === "msg-1")).toBe(true);
|
|
});
|
|
});
|
|
});
|
|
});
|