@eeacms/volto-eea-chatbot 1.0.9 → 1.0.11

package/src/ChatBlock/tests/useChatController.test.jsx

@@ -0,0 +1,268 @@
+import { renderHook, act } from '@testing-library/react-hooks';
+import { PacketType } from '../types/streamingModels';
+
+import { useChatController } from '../hooks/useChatController';
+import { createChatSession } from '../services/streamingService';
+
+// Mock the streaming service with configurable sendMessage behavior
+const mockSendMessage = jest.fn(async function* () {
+  yield [];
+});
+
+jest.mock('../services/streamingService', () => ({
+  sendMessage: (...args) => mockSendMessage(...args),
+  createChatSession: jest.fn().mockResolvedValue('session-123'),
+}));
+
+describe('useChatController', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+    mockSendMessage.mockImplementation(async function* () {
+      yield [];
+    });
+  });
+
+  it('initializes with correct default state', () => {
+    const { result } = renderHook(() => useChatController({ personaId: 1 }));
+
+    expect(result.current.messages).toEqual([]);
+    expect(result.current.isStreaming).toBe(false);
+    expect(result.current.isCancelled).toBe(false);
+    expect(typeof result.current.onSubmit).toBe('function');
+    expect(typeof result.current.clearChat).toBe('function');
+    expect(typeof result.current.cancelStreaming).toBe('function');
+  });
+
+  it('initializes deep research based on config', () => {
+    const { result } = renderHook(() =>
+      useChatController({ personaId: 1, deepResearch: 'always_on' }),
+    );
+
+    expect(result.current.isDeepResearchEnabled).toBe(true);
+  });
+
+  it('initializes deep research as false when not configured', () => {
+    const { result } = renderHook(() =>
+      useChatController({ personaId: 1, deepResearch: 'disabled' }),
+    );
+
+    expect(result.current.isDeepResearchEnabled).toBe(false);
+  });
+
+  it('initializes deep research with user_on', () => {
+    const { result } = renderHook(() =>
+      useChatController({ personaId: 1, deepResearch: 'user_on' }),
+    );
+
+    expect(result.current.isDeepResearchEnabled).toBe(true);
+  });
+
+  it('creates a chat session on first submit', async () => {
+    createChatSession.mockResolvedValue('session-123');
+
+    const { result } = renderHook(() => useChatController({ personaId: 1 }));
+
+    await act(async () => {
+      await result.current.onSubmit({ message: 'Hello' });
+    });
+
+    expect(createChatSession).toHaveBeenCalledWith(1, 'Chat session');
+    expect(result.current.messages.length).toBeGreaterThan(0);
+    // First message should be a user message
+    expect(result.current.messages[0].type).toBe('user');
+    expect(result.current.messages[0].message).toBe('Hello');
+  });
+
+  it('does not submit empty messages', async () => {
+    const { result } = renderHook(() => useChatController({ personaId: 1 }));
+
+    await act(async () => {
+      await result.current.onSubmit({ message: '   ' });
+    });
+
+    // Should only have session creation but no messages since message is blank
+    expect(result.current.messages).toEqual([]);
+  });
+
+  it('clearChat resets all state', async () => {
+    createChatSession.mockResolvedValue('session-123');
+
+    const { result } = renderHook(() => useChatController({ personaId: 1 }));
+
+    await act(async () => {
+      await result.current.onSubmit({ message: 'Hello' });
+    });
+
+    expect(result.current.messages.length).toBeGreaterThan(0);
+
+    act(() => {
+      result.current.clearChat();
+    });
+
+    expect(result.current.messages).toEqual([]);
+    expect(result.current.chatSessionId).toBeNull();
+  });
+
+  it('cancelStreaming sets isCancelled to true', () => {
+    const { result } = renderHook(() => useChatController({ personaId: 1 }));
+
+    act(() => {
+      result.current.cancelStreaming();
+    });
+
+    expect(result.current.isCancelled).toBe(true);
+  });
+
+  it('setIsDeepResearchEnabled toggles deep research', () => {
+    const { result } = renderHook(() =>
+      useChatController({ personaId: 1, deepResearch: 'user_off' }),
+    );
+
+    expect(result.current.isDeepResearchEnabled).toBe(false);
+
+    act(() => {
+      result.current.setIsDeepResearchEnabled(true);
+    });
+
+    expect(result.current.isDeepResearchEnabled).toBe(true);
+  });
+
+  it('handles session creation error gracefully', async () => {
+    createChatSession.mockRejectedValue(new Error('Session creation failed'));
+
+    const consoleSpy = jest
+      .spyOn(console, 'error')
+      .mockImplementation(() => {});
+
+    const { result } = renderHook(() => useChatController({ personaId: 1 }));
+
+    await act(async () => {
+      await result.current.onSubmit({ message: 'Hello' });
+    });
+
+    expect(consoleSpy).toHaveBeenCalled();
+    consoleSpy.mockRestore();
+  });
+
+  it('reuses existing session on subsequent submits', async () => {
+    createChatSession.mockResolvedValue('session-123');
+
+    mockSendMessage.mockImplementation(async function* () {
+      yield [
+        {
+          ind: 1,
+          obj: {
+            type: PacketType.MESSAGE_START,
+            id: 'msg1',
+            content: 'Reply',
+            final_documents: null,
+          },
+        },
+        { ind: 2, obj: { type: PacketType.STOP } },
+      ];
+    });
+
+    const { result } = renderHook(() => useChatController({ personaId: 1 }));
+
+    await act(async () => {
+      await result.current.onSubmit({ message: 'First' });
+    });
+
+    createChatSession.mockClear();
+
+    await act(async () => {
+      await result.current.onSubmit({ message: 'Second' });
+    });
+
+    // Should not create a new session
+    expect(createChatSession).not.toHaveBeenCalled();
+  });
+
+  it('adds user message with deep research type when enabled', async () => {
+    createChatSession.mockResolvedValue('session-123');
+
+    const { result } = renderHook(() =>
+      useChatController({ personaId: 1, deepResearch: 'always_on' }),
+    );
+
+    await act(async () => {
+      await result.current.onSubmit({ message: 'Search deeply' });
+    });
+
+    const userMsg = result.current.messages.find((m) => m.type === 'user');
+    expect(userMsg.researchType).toBe('DEEP');
+  });
+
+  it('adds user message with fast research type when deep research is disabled', async () => {
+    createChatSession.mockResolvedValue('session-123');
+
+    const { result } = renderHook(() =>
+      useChatController({ personaId: 1, deepResearch: 'disabled' }),
+    );
+
+    await act(async () => {
+      await result.current.onSubmit({ message: 'Quick search' });
+    });
+
+    const userMsg = result.current.messages.find((m) => m.type === 'user');
+    expect(userMsg.researchType).toBe('FAST');
+  });
+
+  it('exposes onFetchRelatedQuestions callback', () => {
+    const { result } = renderHook(() =>
+      useChatController({ personaId: 1, enableQgen: true, qgenAsistantId: 2 }),
+    );
+
+    expect(typeof result.current.onFetchRelatedQuestions).toBe('function');
+  });
+
+  it('onFetchRelatedQuestions sets null relatedQuestions when deep research is on', async () => {
+    createChatSession.mockResolvedValue('session-123');
+
+    mockSendMessage.mockImplementation(async function* () {
+      yield [
+        {
+          ind: 1,
+          obj: {
+            type: PacketType.MESSAGE_START,
+            id: 'msg1',
+            content: 'Answer',
+            final_documents: null,
+          },
+        },
+        { ind: 2, obj: { type: PacketType.STOP } },
+      ];
+    });
+
+    const { result } = renderHook(() =>
+      useChatController({
+        personaId: 1,
+        enableQgen: true,
+        qgenAsistantId: 2,
+        deepResearch: 'always_on',
+      }),
+    );
+
+    await act(async () => {
+      await result.current.onSubmit({ message: 'Hello' });
+    });
+
+    await act(async () => {
+      await result.current.onFetchRelatedQuestions();
+    });
+
+    // When deep research is on, relatedQuestions should be set to null
+    const assistantMsg = result.current.messages.find(
+      (m) => m.type === 'assistant',
+    );
+    if (assistantMsg) {
+      expect(assistantMsg.relatedQuestions).toBeNull();
+    }
+  });
+
+  it('exposes isFetchingRelatedQuestions state', () => {
+    const { result } = renderHook(() => useChatController({ personaId: 1 }));
+
+    expect(result.current.isFetchingRelatedQuestions).toBe(false);
+  });
+});

package/src/ChatBlock/tests/useChatStreaming.test.jsx

@@ -0,0 +1,163 @@
+import { renderHook, act } from '@testing-library/react-hooks';
+
+import { useChatStreaming } from '../hooks/useChatStreaming';
+import { sendMessage } from '../services/streamingService';
+import { PacketType } from '../types/streamingModels';
+
+// Mock the streaming service
+jest.mock('../services/streamingService', () => ({
+  sendMessage: jest.fn(),
+  createChatSession: jest.fn(),
+}));
+
+describe('useChatStreaming', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('initializes with correct default state', () => {
+    const { result } = renderHook(() => useChatStreaming());
+
+    expect(result.current.isStreaming).toBe(false);
+    expect(result.current.currentMessage).toBeNull();
+    expect(typeof result.current.startStreaming).toBe('function');
+    expect(typeof result.current.cancelStreaming).toBe('function');
+  });
+
+  it('starts and completes streaming', async () => {
+    const packets = [
+      {
+        ind: 1,
+        obj: { type: PacketType.MESSAGE_START, content: 'Hello' },
+      },
+    ];
+
+    sendMessage.mockImplementation(async function* () {
+      yield packets;
+    });
+
+    const onMessageUpdate = jest.fn();
+    const onComplete = jest.fn();
+
+    const { result } = renderHook(() =>
+      useChatStreaming({ onMessageUpdate, onComplete }),
+    );
+
+    await act(async () => {
+      await result.current.startStreaming(
+        {
+          message: 'test',
+          chatSessionId: 'session-1',
+          parentMessageId: null,
+          regenerate: false,
+          filters: null,
+          selectedDocumentIds: [],
+        },
+        1,
+        null,
+      );
+    });
+
+    expect(result.current.isStreaming).toBe(false);
+    expect(onMessageUpdate).toHaveBeenCalled();
+  });
+
+  it('handles streaming error', async () => {
+    sendMessage.mockImplementation(async function* () {
+      yield '';
+      throw new Error('Stream failed');
+    });
+
+    const onError = jest.fn();
+
+    const { result } = renderHook(() => useChatStreaming({ onError }));
+
+    await act(async () => {
+      await result.current.startStreaming(
+        {
+          message: 'test',
+          chatSessionId: 'session-1',
+          parentMessageId: null,
+          regenerate: false,
+          filters: null,
+          selectedDocumentIds: [],
+        },
+        1,
+        null,
+      );
+    });
+
+    expect(result.current.isStreaming).toBe(false);
+    expect(onError).toHaveBeenCalledWith(expect.any(Error), expect.anything());
+  });
+
+  it('cancelStreaming aborts the stream', async () => {
+    let resolveStream;
+    const streamPromise = new Promise((resolve) => {
+      resolveStream = resolve;
+    });
+
+    sendMessage.mockImplementation(async function* () {
+      await streamPromise;
+      yield [];
+    });
+
+    const { result } = renderHook(() => useChatStreaming());
+
+    // Start streaming without awaiting
+    act(() => {
+      result.current.startStreaming(
+        {
+          message: 'test',
+          chatSessionId: 'session-1',
+          parentMessageId: null,
+          regenerate: false,
+          filters: null,
+          selectedDocumentIds: [],
+        },
+        1,
+        null,
+      );
+    });
+
+    // Cancel the stream
+    act(() => {
+      result.current.cancelStreaming();
+    });
+
+    expect(result.current.isStreaming).toBe(false);
+
+    // Cleanup
+    resolveStream();
+  });
+
+  it('does not call onError for AbortError', async () => {
+    sendMessage.mockImplementation(async function* () {
+      yield '';
+      const error = new Error('Aborted');
+      error.name = 'AbortError';
+      throw error;
+    });
+
+    const onError = jest.fn();
+
+    const { result } = renderHook(() => useChatStreaming({ onError }));
+
+    await act(async () => {
+      await result.current.startStreaming(
+        {
+          message: 'test',
+          chatSessionId: 'session-1',
+          parentMessageId: null,
+          regenerate: false,
+          filters: null,
+          selectedDocumentIds: [],
+        },
+        1,
+        null,
+      );
+    });
+
+    expect(onError).not.toHaveBeenCalled();
+  });
+});

package/src/ChatBlock/tests/useMarked.test.jsx

@@ -0,0 +1,107 @@
+import { renderHook } from '@testing-library/react-hooks';
+import { useMarked } from '../hooks/useMarked';
+
+describe('useMarked', () => {
+  const createMockLibs = () => ({
+    highlightJs: {
+      default: {
+        getLanguage: jest.fn((lang) => (lang === 'javascript' ? true : false)),
+        highlight: jest.fn((lang, code) => ({
+          value: `<highlighted>${code}</highlighted>`,
+        })),
+      },
+    },
+    marked: {
+      marked: {
+        setOptions: jest.fn(),
+        parse: jest.fn((text) => Promise.resolve(`<p>${text}</p>`)),
+      },
+      Renderer: jest.fn().mockImplementation(function () {
+        this.paragraph = null;
+        this.list = null;
+        this.listitem = null;
+        this.code = null;
+      }),
+    },
+  });
+
+  it('returns a parser function', () => {
+    const libs = createMockLibs();
+    const { result } = renderHook(() => useMarked(libs));
+    expect(result.current.parser).toBeDefined();
+    expect(typeof result.current.parser).toBe('function');
+  });
+
+  it('parser calls marked.parse', async () => {
+    const libs = createMockLibs();
+    const { result } = renderHook(() => useMarked(libs));
+
+    await result.current.parser('Hello world');
+    expect(libs.marked.marked.parse).toHaveBeenCalledWith('Hello world');
+  });
+
+  it('sets up renderer with custom paragraph', () => {
+    const libs = createMockLibs();
+    renderHook(() => useMarked(libs));
+
+    // The renderer instance should have custom methods
+    const rendererInstance = libs.marked.Renderer.mock.instances[0];
+    expect(rendererInstance.paragraph).toBeDefined();
+    expect(rendererInstance.paragraph('text')).toBe('text\n');
+  });
+
+  it('sets up renderer with custom list', () => {
+    const libs = createMockLibs();
+    renderHook(() => useMarked(libs));
+
+    const rendererInstance = libs.marked.Renderer.mock.instances[0];
+    expect(rendererInstance.list('items')).toBe('items\n\n');
+  });
+
+  it('sets up renderer with custom listitem', () => {
+    const libs = createMockLibs();
+    renderHook(() => useMarked(libs));
+
+    const rendererInstance = libs.marked.Renderer.mock.instances[0];
+    expect(rendererInstance.listitem('item text')).toBe('\n• item text');
+  });
+
+  it('sets up renderer with custom code highlighting', () => {
+    const libs = createMockLibs();
+    renderHook(() => useMarked(libs));
+
+    const rendererInstance = libs.marked.Renderer.mock.instances[0];
+    const result = rendererInstance.code('const x = 1;', 'javascript');
+
+    expect(result).toContain('<pre');
+    expect(result).toContain('<highlighted>');
+    expect(libs.highlightJs.default.highlight).toHaveBeenCalledWith(
+      'javascript',
+      'const x = 1;',
+    );
+  });
+
+  it('falls back to plaintext for unknown languages', () => {
+    const libs = createMockLibs();
+    renderHook(() => useMarked(libs));
+
+    const rendererInstance = libs.marked.Renderer.mock.instances[0];
+    rendererInstance.code('some code', 'unknownlang');
+
+    expect(libs.highlightJs.default.highlight).toHaveBeenCalledWith(
+      'plaintext',
+      'some code',
+    );
+  });
+
+  it('calls setOptions with the renderer', () => {
+    const libs = createMockLibs();
+    renderHook(() => useMarked(libs));
+
+    expect(libs.marked.marked.setOptions).toHaveBeenCalledWith(
+      expect.objectContaining({
+        renderer: expect.any(Object),
+      }),
+    );
+  });
+});

package/src/ChatBlock/tests/useQualityMarkers.test.jsx

@@ -0,0 +1,150 @@
+import { renderHook, act } from '@testing-library/react-hooks';
+
+import { useQualityMarkers } from '../hooks/useQualityMarkers';
+
+// Mock loadable before importing the hook
+jest.mock('@loadable/component', () => {
+  const loadable = () => {
+    const MockComponent = ({ children }) => null;
+    return MockComponent;
+  };
+  loadable.lib = () => {
+    const MockLibComponent = () => null;
+    MockLibComponent.load = () =>
+      Promise.resolve({ captureException: jest.fn() });
+    return MockLibComponent;
+  };
+  return { __esModule: true, default: loadable };
+});
+
+describe('useQualityMarkers', () => {
+  beforeEach(() => {
+    global.fetch = jest.fn();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('returns null markers when doQualityControl is false', () => {
+    const { result } = renderHook(() =>
+      useQualityMarkers(false, 'test message', []),
+    );
+
+    expect(result.current.markers).toBeNull();
+    expect(result.current.isLoadingHalloumi).toBe(false);
+  });
+
+  it('returns failure rationale when sources are empty', async () => {
+    let hookResult;
+    await act(async () => {
+      const { result } = renderHook(() =>
+        useQualityMarkers(true, 'test message', []),
+      );
+      // Wait a tick for the async useEffect handler to complete
+      await new Promise((r) => setTimeout(r, 0));
+      hookResult = result;
+    });
+
+    expect(hookResult.current.markers).toBeDefined();
+    expect(hookResult.current.markers.claims[0].rationale).toBe(
+      'Answer cannot be verified due to empty sources.',
+    );
+  });
+
+  it('fetches halloumi response when sources are provided', async () => {
+    global.fetch.mockResolvedValue({
+      json: () =>
+        Promise.resolve({
+          claims: [
+            {
+              startOffset: 0,
+              endOffset: 12,
+              score: 0.9,
+              rationale: 'Supported',
+            },
+          ],
+          segments: {},
+        }),
+    });
+
+    const sources = [{ halloumiContext: 'source text', id: '1' }];
+
+    const { result, waitForValueToChange } = renderHook(() =>
+      useQualityMarkers(true, 'test message', sources),
+    );
+
+    await waitForValueToChange(() => result.current.markers);
+
+    expect(result.current.markers).toBeDefined();
+    expect(result.current.markers.claims).toHaveLength(1);
+    expect(result.current.isLoadingHalloumi).toBe(false);
+  });
+
+  it('retryHalloumi resets response', async () => {
+    global.fetch.mockResolvedValue({
+      json: () =>
+        Promise.resolve({
+          claims: [
+            { startOffset: 0, endOffset: 12, score: 0.9, rationale: 'Ok' },
+          ],
+          segments: {},
+        }),
+    });
+
+    const sources = [{ halloumiContext: 'source text', id: '1' }];
+
+    const { result, waitForValueToChange } = renderHook(() =>
+      useQualityMarkers(true, 'test message', sources),
+    );
+
+    await waitForValueToChange(() => result.current.markers);
+    expect(result.current.markers).not.toBeNull();
+
+    act(() => {
+      result.current.retryHalloumi();
+    });
+
+    expect(result.current.markers).toBeNull();
+  });
+
+  it('filters out claims with special characters and low score', async () => {
+    global.fetch.mockResolvedValue({
+      json: () =>
+        Promise.resolve({
+          claims: [
+            {
+              startOffset: 0,
+              endOffset: 1,
+              score: 0.01,
+              rationale: 'Low',
+            },
+            {
+              startOffset: 0,
+              endOffset: 12,
+              score: 0.9,
+              rationale: 'Ok',
+            },
+          ],
+          segments: {},
+        }),
+    });
+
+    const sources = [{ halloumiContext: 'source text', id: '1' }];
+    const message = '* test message';
+
+    const { result, waitForValueToChange } = renderHook(() =>
+      useQualityMarkers(true, message, sources),
+    );
+
+    await waitForValueToChange(() => result.current.markers);
+    // Claims with special chars only and small score get filtered
+    expect(result.current.markers.claims.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('provides retryHalloumi callback', () => {
+    const { result } = renderHook(() => useQualityMarkers(false, 'test', []));
+
+    expect(typeof result.current.retryHalloumi).toBe('function');
+  });
+});