π OpenHands: AI-Driven Development
test: cover transcript export modal (#17299)
aivong-openhands70319fd65082
diff --git a/__tests__/components/features/conversation/transcript-export-modal.test.tsx b/__tests__/components/features/conversation/transcript-export-modal.test.tsxnew file mode 100644index 0000000000..e17ff54b54--- /dev/null+++ b/__tests__/components/features/conversation/transcript-export-modal.test.tsx@@ -0,0 +1,433 @@+import { act, fireEvent, screen, waitFor } from "@testing-library/react";+import { describe, expect, it, vi } from "vitest";+import { renderWithProviders } from "test-utils";+import { TranscriptExportModal } from "#/components/features/conversation/transcript-export-modal";+import { I18nKey } from "#/i18n/declaration";+import type {+ HookExecutionEvent,+ OpenHandsEvent,+} from "#/types/agent-server/core";++const {+ displayErrorToastMock,+ downloadBlobMock,+ eventStoreState,+ eventsToHtmlMock,+ eventsToMarkdownMock,+ getEventCountMock,+ loadCompleteTranscriptEventsMock,+ searchEventsMock,+ trackConversationExportedMock,+ useTranslationMock,+} = vi.hoisted(() => ({+ displayErrorToastMock: vi.fn(),+ downloadBlobMock: vi.fn(),+ eventStoreState: {+ loadedConversationId: null as string | null,+ events: [] as OpenHandsEvent[],+ },+ eventsToHtmlMock: vi.fn(),+ eventsToMarkdownMock: vi.fn(),+ getEventCountMock: vi.fn(),+ loadCompleteTranscriptEventsMock: vi.fn(),+ searchEventsMock: vi.fn(),+ trackConversationExportedMock: vi.fn(),+ useTranslationMock: vi.fn(),+}));++vi.mock("react-i18next", async (importOriginal) => ({+ ...(await importOriginal<typeof import("react-i18next")>()),+ useTranslation: (namespace: string) => {+ useTranslationMock(namespace);+ return { t: (key: string) => key };+ },+}));++vi.mock("#/utils/utils", async (importOriginal) => ({+ ...(await importOriginal<typeof import("#/utils/utils")>()),+ downloadBlob: (...args: unknown[]) => downloadBlobMock(...args),+}));++vi.mock("#/utils/transcript-export", () => ({+ eventsToHtml: (...args: unknown[]) => eventsToHtmlMock(...args),+ eventsToMarkdown: (...args: unknown[]) => eventsToMarkdownMock(...args),+}));++vi.mock("#/hooks/use-tracking", () => ({+ useTracking: () => ({+ trackConversationExported: (...args: unknown[]) =>+ trackConversationExportedMock(...args),+ }),+}));++vi.mock("#/stores/use-event-store", () => ({+ useEventStore: {+ getState: () => eventStoreState,+ },+}));++vi.mock("#/api/event-service/event-service.api", () => ({+ default: {+ getEventCount: (...args: unknown[]) => getEventCountMock(...args),+ searchEvents: (...args: unknown[]) => searchEventsMock(...args),+ },+}));++vi.mock("#/utils/transcript-export/load-complete-events", () => ({+ loadCompleteTranscriptEvents: (...args: unknown[]) =>+ loadCompleteTranscriptEventsMock(...args),+}));++vi.mock("#/utils/custom-toast-handlers", () => ({+ displayErrorToast: (...args: unknown[]) => displayErrorToastMock(...args),+}));++const makeEvent = (id: string): HookExecutionEvent => ({+ id,+ timestamp: "2026-07-12T00:00:00.000Z",+ source: "hook",+ kind: "HookExecutionEvent",+ hook_event_type: "PreToolUse",+ hook_command: "npm test",+ success: true,+ blocked: false,+ exit_code: 0,+ reason: null,+ tool_name: "terminal",+ action_id: null,+ message_id: null,+ stdout: null,+ stderr: null,+ error: null,+ additional_context: null,+ hook_input: null,+});++function createDeferred<T>() {+ let resolve!: (value: T | PromiseLike<T>) => void;+ let reject!: (reason?: unknown) => void;+ const promise = new Promise<T>((resolvePromise, rejectPromise) => {+ resolve = resolvePromise;+ reject = rejectPromise;+ });+ return { promise, resolve, reject };+}++async function readBlob(blob: Blob): Promise<string> {+ return new Promise((resolve, reject) => {+ const reader = new FileReader();+ reader.onload = () => resolve(String(reader.result));+ reader.onerror = () => reject(reader.error);+ reader.readAsText(blob);+ });+}++interface RenderExportModalOptions {+ loadedConversationId?: string | null;+ loadedEvents?: OpenHandsEvent[];+ conversationUrl?: string | null;+ sessionApiKey?: string | null;+ conversationTitle?: string | null;+ model?: string | null;+}++function renderExportModal({+ loadedConversationId = "conversation-1",+ loadedEvents = [makeEvent("loaded-event")],+ conversationUrl,+ sessionApiKey = null,+ conversationTitle = null,+ model = null,+}: RenderExportModalOptions = {}) {+ [+ displayErrorToastMock,+ downloadBlobMock,+ eventsToHtmlMock,+ eventsToMarkdownMock,+ getEventCountMock,+ loadCompleteTranscriptEventsMock,+ searchEventsMock,+ trackConversationExportedMock,+ useTranslationMock,+ ].forEach((mock) => mock.mockReset());++ eventStoreState.loadedConversationId = loadedConversationId;+ eventStoreState.events = loadedEvents;+ const completeEvents = [makeEvent("complete-event")];+ getEventCountMock.mockResolvedValue(1);+ searchEventsMock.mockResolvedValue({ items: [], next_page_id: null });+ loadCompleteTranscriptEventsMock.mockResolvedValue(completeEvents);+ eventsToMarkdownMock.mockReturnValue("# Markdown transcript");+ eventsToHtmlMock.mockReturnValue("<html>HTML transcript</html>");+ const onClose = vi.fn();+ const view = renderWithProviders(+ <TranscriptExportModal+ conversationId="conversation-1"+ conversationUrl={conversationUrl}+ sessionApiKey={sessionApiKey}+ conversationTitle={conversationTitle}+ model={model}+ onClose={onClose}+ />,+ );++ return { ...view, completeEvents, loadedEvents, onClose };+}++describe("transcript export modal", () => {+ it("exports the current transcript as Markdown with accessible defaults", async () => {+ const scenario = renderExportModal();+ const markdownRadio = screen.getByRole("radio", {+ name: I18nKey.TRANSCRIPT_EXPORT$MARKDOWN,+ });+ const htmlRadio = screen.getByRole("radio", {+ name: I18nKey.TRANSCRIPT_EXPORT$HTML,+ });++ expect(markdownRadio).toBeChecked();+ expect(htmlRadio).not.toBeChecked();+ expect(markdownRadio).toHaveAttribute("name", "transcript-export-format");+ expect(htmlRadio).toHaveAttribute("name", "transcript-export-format");+ expect(+ screen.getByRole("checkbox", {+ name: I18nKey.TRANSCRIPT_EXPORT$INCLUDE_TOOL_DETAILS,+ }),+ ).toBeChecked();+ expect(+ screen.getByRole("checkbox", {+ name: I18nKey.TRANSCRIPT_EXPORT$INCLUDE_TIMESTAMPS,+ }),+ ).toBeChecked();+ expect(useTranslationMock).toHaveBeenNthCalledWith(1, "openhands");++ fireEvent.click(screen.getByTestId("confirm-transcript-export"));++ await waitFor(() => expect(downloadBlobMock).toHaveBeenCalledOnce());+ expect(getEventCountMock).toHaveBeenCalledWith("conversation-1", "", null);+ expect(loadCompleteTranscriptEventsMock).toHaveBeenCalledWith(+ scenario.loadedEvents,+ expect.any(Function),+ 1,+ );+ expect(eventsToMarkdownMock).toHaveBeenCalledWith(scenario.completeEvents, {+ includeToolDetails: true,+ includeTimestamps: true,+ title: null,+ model: null,+ });+ expect(eventsToHtmlMock).not.toHaveBeenCalled();+ const [blob, filename] = downloadBlobMock.mock.calls[0] as [Blob, string];+ expect(filename).toBe("conversation-conversation-1.md");+ expect(blob.type).toBe("text/markdown;charset=utf-8");+ await expect(readBlob(blob)).resolves.toBe("# Markdown transcript");+ expect(trackConversationExportedMock).toHaveBeenCalledWith("markdown");+ expect(scenario.onClose).toHaveBeenCalledOnce();+ });++ it("exports fetched events as HTML with the selected options", async () => {+ const scenario = renderExportModal({+ loadedConversationId: "another-conversation",+ conversationUrl: "wss://runtime.example/ws",+ sessionApiKey: "session-key",+ conversationTitle: "Incident review",+ model: "model-v2",+ });+ const searchOptions = {+ limit: 100,+ sortOrder: "TIMESTAMP_DESC",+ strictPagination: true,+ };+ loadCompleteTranscriptEventsMock.mockImplementation(+ async (+ _loadedEvents: OpenHandsEvent[],+ searchEvents: (options: Record<string, unknown>) => Promise<unknown>,+ ) => {+ await searchEvents(searchOptions);+ return scenario.completeEvents;+ },+ );+ const markdownRadio = screen.getByRole("radio", {+ name: I18nKey.TRANSCRIPT_EXPORT$MARKDOWN,+ });+ const htmlRadio = screen.getByRole("radio", {+ name: I18nKey.TRANSCRIPT_EXPORT$HTML,+ });++ fireEvent.click(htmlRadio);+ expect(htmlRadio).toBeChecked();+ fireEvent.click(markdownRadio);+ expect(markdownRadio).toBeChecked();+ fireEvent.click(htmlRadio);+ fireEvent.click(+ screen.getByRole("checkbox", {+ name: I18nKey.TRANSCRIPT_EXPORT$INCLUDE_TOOL_DETAILS,+ }),+ );+ fireEvent.click(+ screen.getByRole("checkbox", {+ name: I18nKey.TRANSCRIPT_EXPORT$INCLUDE_TIMESTAMPS,+ }),+ );+ fireEvent.click(screen.getByTestId("confirm-transcript-export"));++ await waitFor(() => expect(downloadBlobMock).toHaveBeenCalledOnce());+ expect(loadCompleteTranscriptEventsMock).toHaveBeenCalledWith(+ [],+ expect.any(Function),+ 1,+ );+ expect(searchEventsMock).toHaveBeenCalledWith(+ "conversation-1",+ "wss://runtime.example/ws",+ "session-key",+ searchOptions,+ );+ expect(eventsToHtmlMock).toHaveBeenCalledWith(scenario.completeEvents, {+ includeToolDetails: false,+ includeTimestamps: false,+ title: "Incident review",+ model: "model-v2",+ });+ expect(eventsToMarkdownMock).not.toHaveBeenCalled();+ const [blob, filename] = downloadBlobMock.mock.calls[0] as [Blob, string];+ expect(filename).toBe("conversation-conversation-1.html");+ expect(blob.type).toBe("text/html;charset=utf-8");+ await expect(readBlob(blob)).resolves.toBe("<html>HTML transcript</html>");+ expect(trackConversationExportedMock).toHaveBeenCalledWith("html");+ expect(scenario.onClose).toHaveBeenCalledOnce();+ });++ it("continues without an expected count when that endpoint is unavailable", async () => {+ const scenario = renderExportModal();+ getEventCountMock.mockRejectedValue(new Error("count unavailable"));++ fireEvent.click(screen.getByTestId("confirm-transcript-export"));++ await waitFor(() => expect(downloadBlobMock).toHaveBeenCalledOnce());+ expect(loadCompleteTranscriptEventsMock).toHaveBeenCalledWith(+ scenario.loadedEvents,+ expect.any(Function),+ undefined,+ );+ expect(displayErrorToastMock).not.toHaveBeenCalled();+ });++ it("reports an export error, restores the form, and permits a retry", async () => {+ const scenario = renderExportModal();+ loadCompleteTranscriptEventsMock.mockRejectedValueOnce(+ new Error("history unavailable"),+ );+ const exportButton = screen.getByTestId("confirm-transcript-export");++ fireEvent.click(exportButton);++ await waitFor(() =>+ expect(displayErrorToastMock).toHaveBeenCalledWith(I18nKey.ERROR$GENERIC),+ );+ expect(downloadBlobMock).not.toHaveBeenCalled();+ expect(scenario.onClose).not.toHaveBeenCalled();+ await waitFor(() => expect(exportButton).not.toBeDisabled());+ expect(exportButton).toHaveAttribute("aria-busy", "false");++ fireEvent.click(exportButton);++ await waitFor(() => expect(downloadBlobMock).toHaveBeenCalledOnce());+ expect(getEventCountMock).toHaveBeenCalledTimes(2);+ expect(loadCompleteTranscriptEventsMock).toHaveBeenCalledTimes(2);+ expect(trackConversationExportedMock).toHaveBeenCalledWith("markdown");+ expect(scenario.onClose).toHaveBeenCalledOnce();+ });++ it("cancels before loading history when closed during the count request", async () => {+ const scenario = renderExportModal();+ const count = createDeferred<number>();+ getEventCountMock.mockReturnValue(count.promise);+ const exportButton = screen.getByTestId("confirm-transcript-export");++ fireEvent.click(exportButton);++ expect(exportButton).toBeDisabled();+ expect(exportButton).toHaveAttribute("aria-busy", "true");+ expect(+ screen.getByRole("radio", {+ name: I18nKey.TRANSCRIPT_EXPORT$MARKDOWN,+ }),+ ).toBeDisabled();+ expect(+ screen.getByRole("checkbox", {+ name: I18nKey.TRANSCRIPT_EXPORT$INCLUDE_TOOL_DETAILS,+ }),+ ).toBeDisabled();++ fireEvent.click(screen.getByTestId("cancel-transcript-export"));+ expect(scenario.onClose).toHaveBeenCalledOnce();+ await act(async () => count.resolve(1));++ expect(loadCompleteTranscriptEventsMock).not.toHaveBeenCalled();+ expect(downloadBlobMock).not.toHaveBeenCalled();+ expect(displayErrorToastMock).not.toHaveBeenCalled();+ await waitFor(() => expect(exportButton).not.toBeDisabled());+ });++ it("cancels after history loading without creating a download", async () => {+ const scenario = renderExportModal();+ const history = createDeferred<OpenHandsEvent[]>();+ loadCompleteTranscriptEventsMock.mockReturnValue(history.promise);++ fireEvent.click(screen.getByTestId("confirm-transcript-export"));+ await waitFor(() =>+ expect(loadCompleteTranscriptEventsMock).toHaveBeenCalledOnce(),+ );+ fireEvent.click(screen.getByTestId("close-transcript-export-modal"));+ await act(async () => history.resolve(scenario.completeEvents));++ expect(scenario.onClose).toHaveBeenCalledOnce();+ expect(eventsToMarkdownMock).not.toHaveBeenCalled();+ expect(downloadBlobMock).not.toHaveBeenCalled();+ expect(displayErrorToastMock).not.toHaveBeenCalled();+ });++ it("suppresses late errors and state updates after unmount", async () => {+ const scenario = renderExportModal();+ const history = createDeferred<OpenHandsEvent[]>();+ loadCompleteTranscriptEventsMock.mockReturnValue(history.promise);++ fireEvent.click(screen.getByTestId("confirm-transcript-export"));+ await waitFor(() =>+ expect(loadCompleteTranscriptEventsMock).toHaveBeenCalledOnce(),+ );+ scenario.unmount();+ await act(async () => history.reject(new Error("late failure")));++ expect(displayErrorToastMock).not.toHaveBeenCalled();+ expect(downloadBlobMock).not.toHaveBeenCalled();+ expect(scenario.onClose).not.toHaveBeenCalled();+ });++ it("ignores a second export request while the first is running", async () => {+ const scenario = renderExportModal();+ const count = createDeferred<number>();+ getEventCountMock.mockReturnValue(count.promise);+ const exportButton = screen.getByTestId("confirm-transcript-export");++ act(() => {+ exportButton.click();+ exportButton.click();+ });+ expect(getEventCountMock).toHaveBeenCalledOnce();+ await act(async () => count.resolve(1));++ await waitFor(() => expect(downloadBlobMock).toHaveBeenCalledOnce());+ expect(trackConversationExportedMock).toHaveBeenCalledOnce();+ expect(scenario.onClose).toHaveBeenCalledOnce();+ });++ it("closes immediately without starting an export", () => {+ const scenario = renderExportModal();++ fireEvent.click(screen.getByTestId("close-transcript-export-modal"));++ expect(scenario.onClose).toHaveBeenCalledOnce();+ expect(getEventCountMock).not.toHaveBeenCalled();+ });+});