@eeacms/volto-eea-chatbot 2.0.1 → 2.0.2

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

@@ -1,268 +0,0 @@
-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

@@ -1,163 +0,0 @@
-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/useDeepCompareMemoize.test.js

@@ -1,107 +0,0 @@
-import { renderHook } from '@testing-library/react-hooks';
-import '@testing-library/jest-dom';
-import { useDeepCompareMemoize } from '../hooks/useDeepCompareMemoize';
-
-describe('useDeepCompareMemoize', () => {
-  it('returns the same reference for equal objects', () => {
-    const deps1 = { a: 1, b: 2 };
-    const deps2 = { a: 1, b: 2 };
-
-    const { result, rerender } = renderHook(
-      ({ deps }) => useDeepCompareMemoize(deps),
-      { initialProps: { deps: deps1 } },
-    );
-
-    const firstResult = result.current;
-
-    rerender({ deps: deps2 });
-
-    expect(result.current).toBe(firstResult);
-  });
-
-  it('returns new reference for different objects', () => {
-    const deps1 = { a: 1, b: 2 };
-    const deps2 = { a: 1, b: 3 };
-
-    const { result, rerender } = renderHook(
-      ({ deps }) => useDeepCompareMemoize(deps),
-      { initialProps: { deps: deps1 } },
-    );
-
-    const firstResult = result.current;
-
-    rerender({ deps: deps2 });
-
-    expect(result.current).not.toBe(firstResult);
-    expect(result.current).toEqual(deps2);
-  });
-
-  it('handles arrays correctly', () => {
-    const deps1 = [1, 2, 3];
-    const deps2 = [1, 2, 3];
-    const deps3 = [1, 2, 4];
-
-    const { result, rerender } = renderHook(
-      ({ deps }) => useDeepCompareMemoize(deps),
-      { initialProps: { deps: deps1 } },
-    );
-
-    const firstResult = result.current;
-
-    rerender({ deps: deps2 });
-    expect(result.current).toBe(firstResult);
-
-    rerender({ deps: deps3 });
-    expect(result.current).not.toBe(firstResult);
-    expect(result.current).toEqual(deps3);
-  });
-
-  it('handles nested objects', () => {
-    const deps1 = { a: { b: { c: 1 } } };
-    const deps2 = { a: { b: { c: 1 } } };
-    const deps3 = { a: { b: { c: 2 } } };
-
-    const { result, rerender } = renderHook(
-      ({ deps }) => useDeepCompareMemoize(deps),
-      { initialProps: { deps: deps1 } },
-    );
-
-    const firstResult = result.current;
-
-    rerender({ deps: deps2 });
-    expect(result.current).toBe(firstResult);
-
-    rerender({ deps: deps3 });
-    expect(result.current).not.toBe(firstResult);
-  });
-
-  it('handles primitive values', () => {
-    const { result, rerender } = renderHook(
-      ({ deps }) => useDeepCompareMemoize(deps),
-      { initialProps: { deps: 'test' } },
-    );
-
-    const firstResult = result.current;
-
-    rerender({ deps: 'test' });
-    expect(result.current).toBe(firstResult);
-
-    rerender({ deps: 'different' });
-    expect(result.current).not.toBe(firstResult);
-  });
-
-  it('handles null and undefined', () => {
-    const { result, rerender } = renderHook(
-      ({ deps }) => useDeepCompareMemoize(deps),
-      { initialProps: { deps: null } },
-    );
-
-    const firstResult = result.current;
-
-    rerender({ deps: null });
-    expect(result.current).toBe(firstResult);
-
-    rerender({ deps: undefined });
-    expect(result.current).not.toBe(firstResult);
-  });
-});

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

@@ -1,107 +0,0 @@
-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),
-      }),
-    );
-  });
-});