diff --git a/src/App.tsx b/src/App.tsx index 2f25114..86dbc8f 100644 --- a/src/App.tsx +++ b/src/App.tsx @@ -390,13 +390,22 @@ function InAppPetOverlay() { }, [clampPosition, position.x, position.y]); useEffect(() => { + let active = true; let unlisten: (() => void) | undefined; - void listen("pet-hide-requested", () => setVisible(false)).then( - (cleanup) => { - unlisten = cleanup; - }, - ); - return () => unlisten?.(); + void listen("pet-hide-requested", () => setVisible(false)) + .then((cleanup) => { + if (active) { + unlisten = cleanup; + } else { + cleanup(); + } + }) + .catch(() => undefined); + return () => { + active = false; + unlisten?.(); + unlisten = undefined; + }; }, []); return visible ? ( diff --git a/src/features/chat/ChatPanel.test.tsx b/src/features/chat/ChatPanel.test.tsx new file mode 100644 index 0000000..37b35ec --- /dev/null +++ b/src/features/chat/ChatPanel.test.tsx @@ -0,0 +1,106 @@ +import { invoke } from "@tauri-apps/api/core"; +import { render, screen, waitFor } from "@testing-library/react"; +import { StrictMode } from "react"; +import { beforeEach, expect, it, vi } from "vitest"; + +import { + activeListeners, + emitTauriEvent, + flushListen, +} from "../../test/tauriEvent"; +import { ChatPanel } from "./ChatPanel"; + +vi.mock("@tauri-apps/api/core", () => ({ + invoke: vi.fn(), +})); + +const PROFILE_ID = "11111111-1111-1111-1111-111111111111"; +const SERVER_INSTANCE_ID = "server-1"; +const SESSION_ID = "session-1"; + +function connectedSnapshot(slot: "companion" | "operations") { + return { + slot, + profileId: PROFILE_ID, + transport: "astr-bot-open-api", + state: "connected", + serverInstanceId: SERVER_INSTANCE_ID, + activeSessionId: SESSION_ID, + lastError: null, + }; +} + +function mockChatCommands() { + vi.mocked(invoke).mockImplementation(async (command: string) => { + switch (command) { + case "connection_runtime_status": + return { + companion: connectedSnapshot("companion"), + operations: connectedSnapshot("operations"), + }; + case "list_chat_sessions": + case "connection_slot_sessions": + case "load_chat_messages": + return []; + case "connection_slot_capabilities": + return { + transport: "astrbot-openapi", + textChat: true, + streaming: true, + modelSelection: false, + fileUpload: false, + imageInput: false, + models: [], + }; + default: + return undefined; + } + }); +} + +function deltaEvent(delta: string) { + return { + profileId: PROFILE_ID, + slot: "companion", + eventId: "astrbot-server-1-stream-1", + eventType: "message.delta", + serverInstanceId: SERVER_INSTANCE_ID, + sessionId: SESSION_ID, + messageId: "message-1", + payload: { delta }, + }; +} + +beforeEach(() => { + mockChatCommands(); +}); + +it("applies each streaming delta once under strict mode", async () => { + render( + + + , + ); + + // StrictMode mounts, cleans up, then mounts again. The first listener used to + // survive that cleanup because `listen()` had not resolved yet, so every + // delta was applied twice. + await flushListen(); + emitTauriEvent("connection-runtime-event", deltaEvent("你好")); + + expect(await screen.findByText("你好")).toBeInTheDocument(); + expect(screen.queryByText("你好你好")).not.toBeInTheDocument(); +}); + +it("releases every listener on unmount", async () => { + const view = render(); + + view.unmount(); + // Settling *after* unmount is the real leak path: the cleanup has already + // run, so the resolved unregister function must be called immediately. + await flushListen(); + + await waitFor(() => { + expect(activeListeners("connection-runtime-event")).toBe(0); + }); +}); diff --git a/src/features/chat/ChatPanel.tsx b/src/features/chat/ChatPanel.tsx index d55e347..5742080 100644 --- a/src/features/chat/ChatPanel.tsx +++ b/src/features/chat/ChatPanel.tsx @@ -143,16 +143,32 @@ export function ChatPanel({ fixedSlot }: ChatPanelProps) { }, []); useEffect(() => { + // `listen()` resolves after the effect may already have been cleaned up. + // Assigning the unregister function unconditionally dropped it in that + // case, and under StrictMode's mount/cleanup/mount the first listener + // leaked permanently — every delta was then applied twice, doubling each + // character of the streamed reply. + let active = true; let unlisten: (() => void) | undefined; void listen("connection-runtime-event", (event) => { const parsed = boundRuntimeEventSchema.safeParse(event.payload); if (parsed.success) { setMessages((current) => applyRuntimeEvents(current, [parsed.data])); } - }).then((cleanup) => { - unlisten = cleanup; - }); - return () => unlisten?.(); + }) + .then((cleanup) => { + if (active) { + unlisten = cleanup; + } else { + cleanup(); + } + }) + .catch(() => undefined); + return () => { + active = false; + unlisten?.(); + unlisten = undefined; + }; }, []); useEffect(() => { diff --git a/src/features/pet/DesktopPetView.tsx b/src/features/pet/DesktopPetView.tsx index 6ca09ed..0c65e4f 100644 --- a/src/features/pet/DesktopPetView.tsx +++ b/src/features/pet/DesktopPetView.tsx @@ -44,13 +44,20 @@ export function DesktopPetView({ embedded = false }: { embedded?: boolean }) { const completionTimerRef = useRef(null); useEffect(() => { + let active = true; let unlisten: (() => void) | undefined; let unlistenRuntime: (() => void) | undefined; void listen("pet-game-mode-toggle", () => setGameMode((current) => !current), - ).then((cleanup) => { - unlisten = cleanup; - }); + ) + .then((cleanup) => { + if (active) { + unlisten = cleanup; + } else { + cleanup(); + } + }) + .catch(() => undefined); void listen("connection-runtime-event", (event) => { const parsed = boundRuntimeEventSchema.safeParse(event.payload); if (!parsed.success || parsed.data.slot !== PET_TARGET_SLOT) return; @@ -68,12 +75,21 @@ export function DesktopPetView({ embedded = false }: { embedded?: boolean }) { }, 2200); } if (parsed.data.eventType === "error") setState("error"); - }).then((cleanup) => { - unlistenRuntime = cleanup; - }); + }) + .then((cleanup) => { + if (active) { + unlistenRuntime = cleanup; + } else { + cleanup(); + } + }) + .catch(() => undefined); return () => { + active = false; unlisten?.(); unlistenRuntime?.(); + unlisten = undefined; + unlistenRuntime = undefined; if (completionTimerRef.current !== null) { window.clearTimeout(completionTimerRef.current); completionTimerRef.current = null; diff --git a/src/test/setup.ts b/src/test/setup.ts index c514d83..1dbed39 100644 --- a/src/test/setup.ts +++ b/src/test/setup.ts @@ -1,13 +1,19 @@ import "@testing-library/jest-dom/vitest"; import { vi } from "vitest"; -vi.mock("@tauri-apps/api/event", () => ({ - listen: vi.fn(async () => () => undefined), -})); +vi.mock("@tauri-apps/api/event", async () => { + const { listenMock } = await import("./tauriEvent"); + return { listen: listenMock }; +}); import { cleanup } from "@testing-library/react"; import { afterEach } from "vitest"; +import { resetTauriEvent } from "./tauriEvent"; + afterEach(() => { cleanup(); + // The registry is plain module state, so `clearMocks` does not reach it. + // Without this, listeners leak across test files. + resetTauriEvent(); }); diff --git a/src/test/tauriEvent.ts b/src/test/tauriEvent.ts new file mode 100644 index 0000000..6c7e10d --- /dev/null +++ b/src/test/tauriEvent.ts @@ -0,0 +1,79 @@ +import { vi } from "vitest"; + +type EventHandler = (event: { payload: unknown }) => void; + +interface Registration { + name: string; + handler: EventHandler; + unlisten: () => void; + settle: (unlisten: () => void) => void; + settled: boolean; + released: boolean; +} + +const registrations: Registration[] = []; + +/** + * A deliberately deferred stand-in for `listen()`. + * + * The real one resolves asynchronously, and that gap is what makes the + * unregister race possible: a cleanup that runs before the promise settles has + * nothing to call. A mock that resolves eagerly would hide the exact defect + * these tests exist to catch, so this one only settles when `flushListen` says + * so. + */ +export const listenMock = vi.fn( + (name: string, handler: EventHandler) => + new Promise<() => void>((resolve) => { + const registration: Registration = { + name, + handler, + unlisten: () => { + registration.released = true; + }, + settle: resolve, + settled: false, + released: false, + }; + registrations.push(registration); + }), +); + +/** Settles every pending `listen()` promise. */ +export async function flushListen(): Promise { + for (const registration of registrations) { + if (registration.settled) continue; + registration.settled = true; + registration.settle(registration.unlisten); + } + await Promise.resolve(); + await Promise.resolve(); +} + +/** + * Dispatches to every handler that has not been unregistered. + * + * A handler is live from the moment `listen()` is called, exactly as it is in + * Tauri — the promise only hands back the unregister function. A leaked + * registration therefore keeps receiving events, which is what turns the race + * into doubled streaming deltas. + */ +export function emitTauriEvent(name: string, payload: unknown): void { + for (const registration of [...registrations]) { + if (registration.name !== name || registration.released) continue; + registration.handler({ payload }); + } +} + +export function activeListeners(name?: string): number { + return registrations.filter( + (registration) => + !registration.released && + (name === undefined || registration.name === name), + ).length; +} + +export function resetTauriEvent(): void { + registrations.length = 0; + listenMock.mockClear(); +}