@projectcor/maia-components 2.44.4 → 2.44.5-1

package/lib/components/molecules/ChatAIContent/ChatAIContent.spec.js

@@ -0,0 +1,145 @@
+import { renderWithProviders, screen } from '../../../test/test-utils';
+import { options } from '../ChatAIModal/constants';
+import { ChatAIContent } from './ChatAIContent';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('../ChatAIHome', function () {
+  return {
+    ChatAIHome: function ChatAIHome() {
+      return /*#__PURE__*/_jsx("div", {
+        "data-testid": "chat-ai-home"
+      });
+    }
+  };
+});
+jest.mock('./ChatAIContent.skeleton', function () {
+  return {
+    ChatAIHomeSkeleton: function ChatAIHomeSkeleton() {
+      return /*#__PURE__*/_jsx("div", {
+        "data-testid": "chat-home-skeleton"
+      });
+    }
+  };
+});
+jest.mock('../ChatAIMessages', function () {
+  return {
+    ChatAIMessages: function ChatAIMessages() {
+      return /*#__PURE__*/_jsx("div", {
+        "data-testid": "chat-messages"
+      });
+    }
+  };
+});
+jest.mock('../ProjectSummaryContent', function () {
+  return {
+    ProjectSummaryContent: function ProjectSummaryContent() {
+      return /*#__PURE__*/_jsx("div", {
+        "data-testid": "project-summary"
+      });
+    }
+  };
+});
+jest.mock('../ChatAIProjectSelector', function () {
+  return {
+    ChatAIProjectSelector: function ChatAIProjectSelector() {
+      return /*#__PURE__*/_jsx("div", {
+        "data-testid": "project-selector"
+      });
+    }
+  };
+});
+jest.mock('../ChatAIClientSelector', function () {
+  return {
+    ChatAIClientSelector: function ChatAIClientSelector() {
+      return /*#__PURE__*/_jsx("div", {
+        "data-testid": "client-selector"
+      });
+    }
+  };
+});
+jest.mock('../ChatAIMyAgents/ChatAIMyAgents', function () {
+  return {
+    ChatAIMyAgents: function ChatAIMyAgents() {
+      return /*#__PURE__*/_jsx("div", {
+        "data-testid": "my-agents"
+      });
+    }
+  };
+});
+jest.mock('../ChatAIMySkills/ChatAIMySkills', function () {
+  return {
+    ChatAIMySkills: function ChatAIMySkills() {
+      return /*#__PURE__*/_jsx("div", {
+        "data-testid": "my-skills"
+      });
+    }
+  };
+});
+var handlers = {
+  home: jest.fn(),
+  chat: jest.fn(),
+  handleGoHome: jest.fn(),
+  chatsHistory: jest.fn(),
+  projectSummary: jest.fn(),
+  projectSelector: jest.fn(),
+  clientSelector: jest.fn(),
+  myAgents: jest.fn(),
+  mySkills: jest.fn()
+};
+var refs = {
+  userInitialMessage: {
+    message: '',
+    attachments: []
+  },
+  initialChatId: null
+};
+describe('ChatAIContent', function () {
+  it('shows the home skeleton while agents are loading', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(ChatAIContent, {
+      currentOption: options.home,
+      handlers: handlers,
+      onError: jest.fn(),
+      refs: refs,
+      loadingAgents: true
+    }));
+    expect(screen.getByTestId('chat-home-skeleton')).toBeInTheDocument();
+  });
+  it('renders the agent error state on home', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(ChatAIContent, {
+      currentOption: options.home,
+      handlers: handlers,
+      onError: jest.fn(),
+      refs: refs,
+      agentError: "fail"
+    }));
+    expect(screen.getByText('error.title')).toBeInTheDocument();
+  });
+  it('switches content by current option', function () {
+    var _renderWithProviders = renderWithProviders(/*#__PURE__*/_jsx(ChatAIContent, {
+        currentOption: options.chat,
+        handlers: handlers,
+        onError: jest.fn(),
+        refs: refs
+      })),
+      rerender = _renderWithProviders.rerender;
+    expect(screen.getByTestId('chat-messages')).toBeInTheDocument();
+    rerender(/*#__PURE__*/_jsx(ChatAIContent, {
+      currentOption: options.projectSelector,
+      handlers: handlers,
+      onError: jest.fn(),
+      refs: refs
+    }));
+    expect(screen.getByTestId('project-selector')).toBeInTheDocument();
+  });
+  it('renders my skills outside the fade wrapper branch', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(ChatAIContent, {
+      currentOption: options.mySkills,
+      handlers: handlers,
+      onError: jest.fn(),
+      refs: refs,
+      mySkills: [],
+      sharedSkills: []
+    }));
+    expect(screen.getByTestId('my-skills')).toBeInTheDocument();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["renderWithProviders","screen","options","ChatAIContent","jsx","_jsx","jest","mock","ChatAIHome","ChatAIHomeSkeleton","ChatAIMessages","ProjectSummaryContent","ChatAIProjectSelector","ChatAIClientSelector","ChatAIMyAgents","ChatAIMySkills","handlers","home","fn","chat","handleGoHome","chatsHistory","projectSummary","projectSelector","clientSelector","myAgents","mySkills","refs","userInitialMessage","message","attachments","initialChatId","describe","it","currentOption","onError","loadingAgents","expect","getByTestId","toBeInTheDocument","agentError","getByText","_renderWithProviders","rerender","sharedSkills"],"sources":["../../../../src/components/molecules/ChatAIContent/ChatAIContent.spec.tsx"],"sourcesContent":["import { renderWithProviders, screen } from '../../../test/test-utils'\nimport { options } from '../ChatAIModal/constants'\nimport { ChatAIContent } from './ChatAIContent'\n\njest.mock('../ChatAIHome', () => ({\n  ChatAIHome: () => <div data-testid=\"chat-ai-home\" />,\n}))\n\njest.mock('./ChatAIContent.skeleton', () => ({\n  ChatAIHomeSkeleton: () => <div data-testid=\"chat-home-skeleton\" />,\n}))\n\njest.mock('../ChatAIMessages', () => ({\n  ChatAIMessages: () => <div data-testid=\"chat-messages\" />,\n}))\n\njest.mock('../ProjectSummaryContent', () => ({\n  ProjectSummaryContent: () => <div data-testid=\"project-summary\" />,\n}))\n\njest.mock('../ChatAIProjectSelector', () => ({\n  ChatAIProjectSelector: () => <div data-testid=\"project-selector\" />,\n}))\n\njest.mock('../ChatAIClientSelector', () => ({\n  ChatAIClientSelector: () => <div data-testid=\"client-selector\" />,\n}))\n\njest.mock('../ChatAIMyAgents/ChatAIMyAgents', () => ({\n  ChatAIMyAgents: () => <div data-testid=\"my-agents\" />,\n}))\n\njest.mock('../ChatAIMySkills/ChatAIMySkills', () => ({\n  ChatAIMySkills: () => <div data-testid=\"my-skills\" />,\n}))\n\nconst handlers = {\n  home: jest.fn(),\n  chat: jest.fn(),\n  handleGoHome: jest.fn(),\n  chatsHistory: jest.fn(),\n  projectSummary: jest.fn(),\n  projectSelector: jest.fn(),\n  clientSelector: jest.fn(),\n  myAgents: jest.fn(),\n  mySkills: jest.fn(),\n}\n\nconst refs = {\n  userInitialMessage: { message: '', attachments: [] },\n  initialChatId: null,\n}\n\ndescribe('ChatAIContent', () => {\n  it('shows the home skeleton while agents are loading', () => {\n    renderWithProviders(\n      <ChatAIContent currentOption={options.home} handlers={handlers} onError={jest.fn()} refs={refs} loadingAgents />\n    )\n\n    expect(screen.getByTestId('chat-home-skeleton')).toBeInTheDocument()\n  })\n\n  it('renders the agent error state on home', () => {\n    renderWithProviders(\n      <ChatAIContent\n        currentOption={options.home}\n        handlers={handlers}\n        onError={jest.fn()}\n        refs={refs}\n        agentError=\"fail\"\n      />\n    )\n\n    expect(screen.getByText('error.title')).toBeInTheDocument()\n  })\n\n  it('switches content by current option', () => {\n    const { rerender } = renderWithProviders(\n      <ChatAIContent currentOption={options.chat} handlers={handlers} onError={jest.fn()} refs={refs} />\n    )\n    expect(screen.getByTestId('chat-messages')).toBeInTheDocument()\n\n    rerender(\n      <ChatAIContent currentOption={options.projectSelector} handlers={handlers} onError={jest.fn()} refs={refs} />\n    )\n    expect(screen.getByTestId('project-selector')).toBeInTheDocument()\n  })\n\n  it('renders my skills outside the fade wrapper branch', () => {\n    renderWithProviders(\n      <ChatAIContent\n        currentOption={options.mySkills}\n        handlers={handlers}\n        onError={jest.fn()}\n        refs={refs}\n        mySkills={[]}\n        sharedSkills={[]}\n      />\n    )\n\n    expect(screen.getByTestId('my-skills')).toBeInTheDocument()\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/components/molecules/ChatAIHistory/ChatAIHistory.spec.js

@@ -0,0 +1,204 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { ChatAIHistory } from './ChatAIHistory';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+var useChatsMock = jest.fn();
+var triggerEvent = jest.fn();
+jest.mock('../../atoms/Loader', function () {
+  return {
+    Loader: function Loader() {
+      return /*#__PURE__*/_jsx("div", {
+        role: "status",
+        children: "loader"
+      });
+    }
+  };
+});
+jest.mock('../../../hooks/useChats', function () {
+  return {
+    useChats: function useChats() {
+      return useChatsMock.apply(void 0, arguments);
+    }
+  };
+});
+jest.mock('../../../hooks/useEvent', function () {
+  return {
+    EVENTS: {
+      pmAiBackButton: 'PM_AI_BACK_BUTTON',
+      pmAiOpenConversation: 'PM_AI_OPEN_CONVERSATION',
+      pmAiMenuEdit: 'PM_AI_MENU_EDIT',
+      pmAiMenuDelete: 'PM_AI_MENU_DELETE'
+    },
+    useEvent: function useEvent() {
+      return triggerEvent;
+    }
+  };
+});
+jest.mock('../../../lang/utils', function () {
+  return {
+    formatDate: function formatDate(date) {
+      return "formatted-".concat(date.toISOString());
+    }
+  };
+});
+jest.mock('../../atoms/CardMenu', function () {
+  return {
+    CardMenu: function CardMenu(_ref) {
+      var menuItems = _ref.menuItems;
+      return /*#__PURE__*/_jsx("div", {
+        children: menuItems.map(function (item) {
+          return /*#__PURE__*/_jsx("button", {
+            type: "button",
+            onClick: function onClick() {
+              return item.onClick({
+                startLoading: jest.fn()
+              });
+            },
+            children: item.label
+          }, item.label);
+        })
+      });
+    }
+  };
+});
+jest.mock('../../atoms/EditableLabel', function () {
+  return {
+    EditableLabel: function EditableLabel(_ref2) {
+      var value = _ref2.value,
+        onSave = _ref2.onSave,
+        onCancel = _ref2.onCancel;
+      return /*#__PURE__*/_jsxs("div", {
+        children: [/*#__PURE__*/_jsx("input", {
+          "aria-label": "edit-title",
+          defaultValue: value
+        }), /*#__PURE__*/_jsx("button", {
+          type: "button",
+          onClick: function onClick() {
+            return onSave('Renamed chat');
+          },
+          children: "save-title"
+        }), /*#__PURE__*/_jsx("button", {
+          type: "button",
+          onClick: onCancel,
+          children: "cancel-title"
+        })]
+      });
+    }
+  };
+});
+jest.mock('../../atoms/NextPageLoader', function () {
+  return {
+    NextPageLoader: function NextPageLoader(_ref3) {
+      var loadMore = _ref3.loadMore;
+      return /*#__PURE__*/_jsx("button", {
+        type: "button",
+        onClick: loadMore,
+        children: "load-more"
+      });
+    }
+  };
+});
+var baseProps = {
+  onError: jest.fn(),
+  onGoToHome: jest.fn(),
+  onGoToChat: jest.fn()
+};
+describe('ChatAIHistory', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    useChatsMock.mockReturnValue({
+      loadingChats: false,
+      chats: [],
+      deleteChat: jest.fn(),
+      updateChat: jest.fn().mockResolvedValue(undefined),
+      hasMoreChats: false,
+      loadMoreChats: jest.fn(),
+      isLoadingMoreChats: false
+    });
+  });
+  it('shows a loader while chats are loading', function () {
+    useChatsMock.mockReturnValue({
+      loadingChats: true,
+      chats: [],
+      deleteChat: jest.fn(),
+      updateChat: jest.fn(),
+      hasMoreChats: false,
+      loadMoreChats: jest.fn(),
+      isLoadingMoreChats: false
+    });
+    renderWithProviders(/*#__PURE__*/_jsx(ChatAIHistory, _objectSpread({}, baseProps)));
+    expect(screen.getByText('loader')).toBeInTheDocument();
+  });
+  it('shows the empty state when there are no chats', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(ChatAIHistory, _objectSpread({}, baseProps)));
+    expect(screen.getByText('history.title')).toBeInTheDocument();
+    expect(screen.getByText('history.description')).toBeInTheDocument();
+  });
+  it('opens a chat and tracks analytics when clicking a history item', function () {
+    useChatsMock.mockReturnValue({
+      loadingChats: false,
+      chats: [{
+        id: 'chat-1',
+        sessionExternalId: 'session-1',
+        title: 'Weekly sync',
+        date: new Date('2026-01-10T12:00:00.000Z')
+      }],
+      deleteChat: jest.fn(),
+      updateChat: jest.fn().mockResolvedValue(undefined),
+      hasMoreChats: false,
+      loadMoreChats: jest.fn(),
+      isLoadingMoreChats: false
+    });
+    renderWithProviders(/*#__PURE__*/_jsx(ChatAIHistory, _objectSpread({}, baseProps)));
+    fireEvent.click(screen.getByText('Weekly sync'));
+    expect(baseProps.onGoToChat).toHaveBeenCalledWith('session-1');
+    expect(triggerEvent).toHaveBeenCalledWith('PM_AI_OPEN_CONVERSATION');
+  });
+  it('loads more chats when the next page loader is visible', function () {
+    var loadMoreChats = jest.fn();
+    useChatsMock.mockReturnValue({
+      loadingChats: false,
+      chats: [{
+        id: 'chat-1',
+        sessionExternalId: 'session-1',
+        title: 'Weekly sync',
+        date: new Date('2026-01-10T12:00:00.000Z')
+      }],
+      deleteChat: jest.fn(),
+      updateChat: jest.fn().mockResolvedValue(undefined),
+      hasMoreChats: true,
+      loadMoreChats: loadMoreChats,
+      isLoadingMoreChats: false
+    });
+    renderWithProviders(/*#__PURE__*/_jsx(ChatAIHistory, _objectSpread({}, baseProps)));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'load-more'
+    }));
+    expect(loadMoreChats).toHaveBeenCalled();
+  });
+  it('goes back home and tracks analytics from the footer button', function () {
+    useChatsMock.mockReturnValue({
+      loadingChats: false,
+      chats: [{
+        id: 'chat-1',
+        sessionExternalId: 'session-1',
+        title: 'Weekly sync',
+        date: new Date('2026-01-10T12:00:00.000Z')
+      }],
+      deleteChat: jest.fn(),
+      updateChat: jest.fn().mockResolvedValue(undefined),
+      hasMoreChats: false,
+      loadMoreChats: jest.fn(),
+      isLoadingMoreChats: false
+    });
+    renderWithProviders(/*#__PURE__*/_jsx(ChatAIHistory, _objectSpread({}, baseProps)));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'globals.goBack'
+    }));
+    expect(triggerEvent).toHaveBeenCalledWith('PM_AI_BACK_BUTTON');
+    expect(baseProps.onGoToHome).toHaveBeenCalled();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fireEvent","renderWithProviders","screen","ChatAIHistory","jsx","_jsx","jsxs","_jsxs","useChatsMock","jest","fn","triggerEvent","mock","Loader","role","children","useChats","apply","arguments","EVENTS","pmAiBackButton","pmAiOpenConversation","pmAiMenuEdit","pmAiMenuDelete","useEvent","formatDate","date","concat","toISOString","CardMenu","_ref","menuItems","map","item","type","onClick","startLoading","label","EditableLabel","_ref2","value","onSave","onCancel","defaultValue","NextPageLoader","_ref3","loadMore","baseProps","onError","onGoToHome","onGoToChat","describe","beforeEach","clearAllMocks","mockReturnValue","loadingChats","chats","deleteChat","updateChat","mockResolvedValue","undefined","hasMoreChats","loadMoreChats","isLoadingMoreChats","it","_objectSpread","expect","getByText","toBeInTheDocument","id","sessionExternalId","title","Date","click","toHaveBeenCalledWith","getByRole","name","toHaveBeenCalled"],"sources":["../../../../src/components/molecules/ChatAIHistory/ChatAIHistory.spec.tsx"],"sourcesContent":["import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils'\nimport { ChatAIHistory } from './ChatAIHistory'\n\nconst useChatsMock = jest.fn()\nconst triggerEvent = jest.fn()\n\njest.mock('../../atoms/Loader', () => ({\n  Loader: () => <div role=\"status\">loader</div>,\n}))\n\njest.mock('../../../hooks/useChats', () => ({\n  useChats: (...args: unknown[]) => useChatsMock(...args),\n}))\n\njest.mock('../../../hooks/useEvent', () => ({\n  EVENTS: {\n    pmAiBackButton: 'PM_AI_BACK_BUTTON',\n    pmAiOpenConversation: 'PM_AI_OPEN_CONVERSATION',\n    pmAiMenuEdit: 'PM_AI_MENU_EDIT',\n    pmAiMenuDelete: 'PM_AI_MENU_DELETE',\n  },\n  useEvent: () => triggerEvent,\n}))\n\njest.mock('../../../lang/utils', () => ({\n  formatDate: (date: Date) => `formatted-${date.toISOString()}`,\n}))\n\njest.mock('../../atoms/CardMenu', () => ({\n  CardMenu: ({\n    menuItems,\n  }: {\n    menuItems: Array<{ label: string; onClick: (ctx?: { startLoading: () => void }) => void }>\n  }) => (\n    <div>\n      {menuItems.map(item => (\n        <button key={item.label} type=\"button\" onClick={() => item.onClick({ startLoading: jest.fn() })}>\n          {item.label}\n        </button>\n      ))}\n    </div>\n  ),\n}))\n\njest.mock('../../atoms/EditableLabel', () => ({\n  EditableLabel: ({\n    value,\n    onSave,\n    onCancel,\n  }: {\n    value: string\n    onSave: (value: string) => void\n    onCancel: () => void\n  }) => (\n    <div>\n      <input aria-label=\"edit-title\" defaultValue={value} />\n      <button type=\"button\" onClick={() => onSave('Renamed chat')}>\n        save-title\n      </button>\n      <button type=\"button\" onClick={onCancel}>\n        cancel-title\n      </button>\n    </div>\n  ),\n}))\n\njest.mock('../../atoms/NextPageLoader', () => ({\n  NextPageLoader: ({ loadMore }: { loadMore: () => void }) => (\n    <button type=\"button\" onClick={loadMore}>\n      load-more\n    </button>\n  ),\n}))\n\nconst baseProps = {\n  onError: jest.fn(),\n  onGoToHome: jest.fn(),\n  onGoToChat: jest.fn(),\n}\n\ndescribe('ChatAIHistory', () => {\n  beforeEach(() => {\n    jest.clearAllMocks()\n    useChatsMock.mockReturnValue({\n      loadingChats: false,\n      chats: [],\n      deleteChat: jest.fn(),\n      updateChat: jest.fn().mockResolvedValue(undefined),\n      hasMoreChats: false,\n      loadMoreChats: jest.fn(),\n      isLoadingMoreChats: false,\n    })\n  })\n\n  it('shows a loader while chats are loading', () => {\n    useChatsMock.mockReturnValue({\n      loadingChats: true,\n      chats: [],\n      deleteChat: jest.fn(),\n      updateChat: jest.fn(),\n      hasMoreChats: false,\n      loadMoreChats: jest.fn(),\n      isLoadingMoreChats: false,\n    })\n\n    renderWithProviders(<ChatAIHistory {...baseProps} />)\n\n    expect(screen.getByText('loader')).toBeInTheDocument()\n  })\n\n  it('shows the empty state when there are no chats', () => {\n    renderWithProviders(<ChatAIHistory {...baseProps} />)\n\n    expect(screen.getByText('history.title')).toBeInTheDocument()\n    expect(screen.getByText('history.description')).toBeInTheDocument()\n  })\n\n  it('opens a chat and tracks analytics when clicking a history item', () => {\n    useChatsMock.mockReturnValue({\n      loadingChats: false,\n      chats: [\n        {\n          id: 'chat-1',\n          sessionExternalId: 'session-1',\n          title: 'Weekly sync',\n          date: new Date('2026-01-10T12:00:00.000Z'),\n        },\n      ],\n      deleteChat: jest.fn(),\n      updateChat: jest.fn().mockResolvedValue(undefined),\n      hasMoreChats: false,\n      loadMoreChats: jest.fn(),\n      isLoadingMoreChats: false,\n    })\n\n    renderWithProviders(<ChatAIHistory {...baseProps} />)\n\n    fireEvent.click(screen.getByText('Weekly sync'))\n\n    expect(baseProps.onGoToChat).toHaveBeenCalledWith('session-1')\n    expect(triggerEvent).toHaveBeenCalledWith('PM_AI_OPEN_CONVERSATION')\n  })\n\n  it('loads more chats when the next page loader is visible', () => {\n    const loadMoreChats = jest.fn()\n    useChatsMock.mockReturnValue({\n      loadingChats: false,\n      chats: [\n        {\n          id: 'chat-1',\n          sessionExternalId: 'session-1',\n          title: 'Weekly sync',\n          date: new Date('2026-01-10T12:00:00.000Z'),\n        },\n      ],\n      deleteChat: jest.fn(),\n      updateChat: jest.fn().mockResolvedValue(undefined),\n      hasMoreChats: true,\n      loadMoreChats,\n      isLoadingMoreChats: false,\n    })\n\n    renderWithProviders(<ChatAIHistory {...baseProps} />)\n\n    fireEvent.click(screen.getByRole('button', { name: 'load-more' }))\n\n    expect(loadMoreChats).toHaveBeenCalled()\n  })\n\n  it('goes back home and tracks analytics from the footer button', () => {\n    useChatsMock.mockReturnValue({\n      loadingChats: false,\n      chats: [\n        {\n          id: 'chat-1',\n          sessionExternalId: 'session-1',\n          title: 'Weekly sync',\n          date: new Date('2026-01-10T12:00:00.000Z'),\n        },\n      ],\n      deleteChat: jest.fn(),\n      updateChat: jest.fn().mockResolvedValue(undefined),\n      hasMoreChats: false,\n      loadMoreChats: jest.fn(),\n      isLoadingMoreChats: false,\n    })\n\n    renderWithProviders(<ChatAIHistory {...baseProps} />)\n\n    fireEvent.click(screen.getByRole('button', { name: 'globals.goBack' }))\n\n    expect(triggerEvent).toHaveBeenCalledWith('PM_AI_BACK_BUTTON')\n    expect(baseProps.onGoToHome).toHaveBeenCalled()\n  })\n})\n"],"mappings":"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","ignoreList":[]}