@eeacms/volto-eea-chatbot 2.0.1 → 2.0.2

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

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

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

@@ -1,121 +0,0 @@
-import { renderHook, act } from '@testing-library/react-hooks';
-import { useScrollonStream } from '../hooks/useScrollonStream';
-
-describe('useScrollonStream', () => {
-  let addEventListenerSpy;
-  let removeEventListenerSpy;
-
-  beforeEach(() => {
-    jest.useFakeTimers();
-    addEventListenerSpy = jest.spyOn(window, 'addEventListener');
-    removeEventListenerSpy = jest.spyOn(window, 'removeEventListener');
-  });
-
-  afterEach(() => {
-    jest.useRealTimers();
-    addEventListenerSpy.mockRestore();
-    removeEventListenerSpy.mockRestore();
-  });
-
-  it('sets up event listeners when enabled and streaming', () => {
-    const bottomRef = { current: document.createElement('div') };
-    renderHook(() =>
-      useScrollonStream({
-        bottomRef,
-        isStreaming: true,
-        enabled: true,
-      }),
-    );
-
-    const eventTypes = addEventListenerSpy.mock.calls.map((c) => c[0]);
-    expect(eventTypes).toContain('wheel');
-    expect(eventTypes).toContain('touchstart');
-    expect(eventTypes).toContain('keydown');
-    expect(eventTypes).toContain('mousedown');
-  });
-
-  it('disables scrolling on user wheel event', () => {
-    const bottomRef = { current: document.createElement('div') };
-    renderHook(() =>
-      useScrollonStream({
-        bottomRef,
-        isStreaming: true,
-        enabled: true,
-      }),
-    );
-
-    act(() => {
-      window.dispatchEvent(new Event('wheel'));
-    });
-
-    // After wheel event, the scroll listener should be removed
-    expect(removeEventListenerSpy).toHaveBeenCalled();
-  });
-
-  it('sets isActive to false after streaming stops with grace period', () => {
-    const bottomRef = { current: document.createElement('div') };
-    const { rerender } = renderHook(
-      ({ isStreaming }) =>
-        useScrollonStream({
-          bottomRef,
-          isStreaming,
-          enabled: true,
-        }),
-      { initialProps: { isStreaming: true } },
-    );
-
-    // Stop streaming
-    rerender({ isStreaming: false });
-
-    // Should still be active before timeout
-    act(() => {
-      jest.advanceTimersByTime(500);
-    });
-  });
-
-  it('does not set up event listeners when disabled', () => {
-    const bottomRef = { current: document.createElement('div') };
-    const callsBefore = addEventListenerSpy.mock.calls.length;
-
-    renderHook(() =>
-      useScrollonStream({
-        bottomRef,
-        isStreaming: true,
-        enabled: false,
-      }),
-    );
-
-    // Only the streaming state listener calls, not user input listeners
-    const newCalls = addEventListenerSpy.mock.calls
-      .slice(callsBefore)
-      .map((c) => c[0]);
-    expect(newCalls).not.toContain('wheel');
-  });
-
-  it('handles missing bottomRef gracefully', () => {
-    const bottomRef = { current: null };
-    expect(() => {
-      renderHook(() =>
-        useScrollonStream({
-          bottomRef,
-          isStreaming: true,
-          enabled: true,
-        }),
-      );
-    }).not.toThrow();
-  });
-
-  it('cleans up on unmount', () => {
-    const bottomRef = { current: document.createElement('div') };
-    const { unmount } = renderHook(() =>
-      useScrollonStream({
-        bottomRef,
-        isStreaming: true,
-        enabled: true,
-      }),
-    );
-
-    unmount();
-    expect(removeEventListenerSpy).toHaveBeenCalled();
-  });
-});

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

@@ -1,151 +0,0 @@
-import { renderHook, act } from '@testing-library/react-hooks';
-import { useToolDisplayTiming } from '../hooks/useToolDisplayTiming';
-
-describe('useToolDisplayTiming', () => {
-  beforeEach(() => {
-    jest.useFakeTimers();
-  });
-
-  afterEach(() => {
-    jest.useRealTimers();
-  });
-
-  it('should initialize with all tools visible when not complete', () => {
-    const toolGroups = [
-      { ind: 1, packets: [] },
-      { ind: 2, packets: [] },
-    ];
-
-    const { result } = renderHook(() =>
-      useToolDisplayTiming(toolGroups, false, false),
-    );
-
-    expect(result.current.visibleTools).toEqual(new Set([1, 2]));
-    expect(result.current.allToolsDisplayed).toBe(false);
-  });
-
-  it('should initialize with all tools visible when complete', () => {
-    const toolGroups = [
-      { ind: 1, packets: [] },
-      { ind: 2, packets: [] },
-    ];
-
-    const { result } = renderHook(() =>
-      useToolDisplayTiming(toolGroups, false, true),
-    );
-
-    expect(result.current.visibleTools).toEqual(new Set([1, 2]));
-    expect(result.current.allToolsDisplayed).toBe(false);
-  });
-
-  it('should show first tool immediately', () => {
-    const toolGroups = [{ ind: 1, packets: [] }];
-
-    const { result } = renderHook(() =>
-      useToolDisplayTiming(toolGroups, false, false),
-    );
-
-    expect(result.current.visibleTools.has(1)).toBe(true);
-  });
-
-  it('should handle tool completion without errors', () => {
-    const toolGroups = [
-      { ind: 1, packets: [] },
-      { ind: 2, packets: [] },
-    ];
-
-    const { result } = renderHook(() =>
-      useToolDisplayTiming(toolGroups, false, false),
-    );
-
-    // All tools should be visible
-    expect(result.current.visibleTools.has(1)).toBe(true);
-    expect(result.current.visibleTools.has(2)).toBe(true);
-
-    // Complete first tool - should not throw errors
-    expect(() => {
-      act(() => {
-        result.current.handleToolComplete(1);
-      });
-    }).not.toThrow();
-  });
-
-  it('should handle tool completion with timeout', () => {
-    const toolGroups = [{ ind: 1, packets: [] }];
-
-    const { result } = renderHook(() =>
-      useToolDisplayTiming(toolGroups, false, false),
-    );
-
-    // Complete tool - should schedule timeout if not enough time passed
-    act(() => {
-      result.current.handleToolComplete(1);
-    });
-
-    // Should not throw and tool should still be visible
-    expect(result.current.visibleTools.has(1)).toBe(true);
-  });
-
-  it('should mark all tools as displayed when complete and final message coming', () => {
-    const toolGroups = [{ ind: 1, packets: [] }];
-
-    const { result } = renderHook(() =>
-      useToolDisplayTiming(toolGroups, true, true),
-    );
-
-    // Mark tool as completed
-    act(() => {
-      result.current.handleToolComplete(1);
-    });
-
-    expect(result.current.allToolsDisplayed).toBe(true);
-  });
-
-  it('should not mark all tools as displayed when final message not coming', () => {
-    const toolGroups = [{ ind: 1, packets: [] }];
-
-    const { result } = renderHook(() =>
-      useToolDisplayTiming(toolGroups, false, true),
-    );
-
-    expect(result.current.allToolsDisplayed).toBe(false);
-  });
-
-  it('should handle empty tool groups', () => {
-    const { result } = renderHook(() => useToolDisplayTiming([], false, false));
-
-    expect(result.current.visibleTools).toEqual(new Set());
-    expect(result.current.allToolsDisplayed).toBe(true);
-  });
-
-  it('should not complete tool twice', () => {
-    const toolGroups = [{ ind: 1, packets: [] }];
-
-    const { result } = renderHook(() =>
-      useToolDisplayTiming(toolGroups, false, false),
-    );
-
-    act(() => {
-      result.current.handleToolComplete(1);
-      result.current.handleToolComplete(1);
-    });
-
-    // Should still work without errors
-    expect(result.current.visibleTools.has(1)).toBe(true);
-  });
-
-  it('should clean up timeouts on unmount', () => {
-    const toolGroups = [{ ind: 1, packets: [] }];
-
-    const { result, unmount } = renderHook(() =>
-      useToolDisplayTiming(toolGroups, false, false),
-    );
-
-    act(() => {
-      result.current.handleToolComplete(1);
-    });
-
-    // Unmount should not throw errors
-    expect(() => unmount()).not.toThrow();
-  });
-});

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

@@ -1,241 +0,0 @@
-import { act } from '@testing-library/react';
-import { renderHook } from '@testing-library/react-hooks';
-import '@testing-library/jest-dom';
-import {
-  EMAIL_REGEX,
-  transformEmailsToLinks,
-  debounce,
-  useCopyToClipboard,
-  convertToPercentage,
-  createChatMessageFeedback,
-} from '../utils';
-
-describe('utils', () => {
-  describe('EMAIL_REGEX', () => {
-    it('matches valid email addresses', () => {
-      expect('test@example.com').toMatch(EMAIL_REGEX);
-      expect('user.name@domain.org').toMatch(EMAIL_REGEX);
-      expect('user+tag@example.co.uk').toMatch(EMAIL_REGEX);
-    });
-
-    it('does not match invalid email addresses', () => {
-      expect('not-an-email').not.toMatch(EMAIL_REGEX);
-      expect('@missing-local.com').not.toMatch(EMAIL_REGEX);
-    });
-  });
-
-  describe('transformEmailsToLinks', () => {
-    it('transforms email addresses to mailto links', () => {
-      const text = 'Contact us at test@example.com';
-      const result = transformEmailsToLinks(text);
-      // Result includes: ['Contact us at ', <a>email</a>, '']
-      expect(result.length).toBeGreaterThanOrEqual(2);
-      expect(result[0]).toBe('Contact us at ');
-    });
-
-    it('handles text without email addresses', () => {
-      const text = 'No email here';
-      const result = transformEmailsToLinks(text);
-      expect(result).toHaveLength(1);
-      expect(result[0]).toBe('No email here');
-    });
-
-    it('handles multiple email addresses', () => {
-      const text = 'Email one@test.com and two@test.com';
-      const result = transformEmailsToLinks(text);
-      expect(result.length).toBeGreaterThan(1);
-    });
-  });
-
-  describe('debounce', () => {
-    beforeEach(() => {
-      jest.useFakeTimers();
-    });
-
-    afterEach(() => {
-      jest.useRealTimers();
-    });
-
-    it('calls the function immediately on first call', () => {
-      const callable = jest.fn();
-      const clickSignal = { current: null };
-
-      debounce(callable, clickSignal);
-
-      expect(callable).toHaveBeenCalledTimes(1);
-    });
-
-    it('prevents multiple calls within debounce period', () => {
-      const callable = jest.fn();
-      const clickSignal = { current: null };
-
-      debounce(callable, clickSignal);
-      debounce(callable, clickSignal);
-      debounce(callable, clickSignal);
-
-      expect(callable).toHaveBeenCalledTimes(1);
-    });
-
-    it('allows call after debounce period', () => {
-      const callable = jest.fn();
-      const clickSignal = { current: null };
-
-      debounce(callable, clickSignal);
-      expect(callable).toHaveBeenCalledTimes(1);
-
-      jest.advanceTimersByTime(1000);
-
-      debounce(callable, clickSignal);
-      expect(callable).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  describe('useCopyToClipboard', () => {
-    beforeEach(() => {
-      jest.useFakeTimers();
-      Object.assign(navigator, {
-        clipboard: {
-          writeText: jest.fn().mockResolvedValue(undefined),
-        },
-      });
-    });
-
-    afterEach(() => {
-      jest.useRealTimers();
-    });
-
-    it('returns initial state as not copied', () => {
-      const { result } = renderHook(() => useCopyToClipboard('test'));
-      expect(result.current[0]).toBe(false);
-    });
-
-    it('copies text to clipboard when copy is called', async () => {
-      const { result } = renderHook(() => useCopyToClipboard('test text'));
-
-      await act(async () => {
-        result.current[1]();
-      });
-
-      expect(navigator.clipboard.writeText).toHaveBeenCalledWith('test text');
-      expect(result.current[0]).toBe(true);
-    });
-
-    it('resets copied state after timeout', async () => {
-      const { result } = renderHook(() => useCopyToClipboard('test'));
-
-      await act(async () => {
-        result.current[1]();
-      });
-
-      expect(result.current[0]).toBe(true);
-
-      act(() => {
-        jest.advanceTimersByTime(2000);
-      });
-
-      expect(result.current[0]).toBe(false);
-    });
-
-    it('handles clipboard write failure', async () => {
-      navigator.clipboard.writeText = jest.fn().mockRejectedValue(new Error());
-
-      const { result } = renderHook(() => useCopyToClipboard('test'));
-
-      await act(async () => {
-        result.current[1]();
-      });
-
-      expect(result.current[0]).toBe(false);
-    });
-  });
-
-  describe('convertToPercentage', () => {
-    it('converts float to percentage string', () => {
-      expect(convertToPercentage(0.5)).toBe('50.00%');
-      expect(convertToPercentage(0.123)).toBe('12.30%');
-      expect(convertToPercentage(1)).toBe('100.00%');
-      expect(convertToPercentage(0)).toBe('0.00%');
-    });
-
-    it('handles custom digit precision', () => {
-      expect(convertToPercentage(0.5, 0)).toBe('50%');
-      expect(convertToPercentage(0.5, 1)).toBe('50.0%');
-      expect(convertToPercentage(0.123, 1)).toBe('12.3%');
-    });
-
-    it('returns 0% for values outside 0-1 range', () => {
-      expect(convertToPercentage(-0.5)).toBe('0%');
-      expect(convertToPercentage(1.5)).toBe('0%');
-      expect(convertToPercentage(-1)).toBe('0%');
-    });
-  });
-
-  describe('createChatMessageFeedback', () => {
-    beforeEach(() => {
-      global.fetch = jest.fn();
-    });
-
-    afterEach(() => {
-      jest.resetAllMocks();
-    });
-
-    it('sends positive feedback correctly', async () => {
-      const mockResponse = { success: true };
-      global.fetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockResponse),
-      });
-
-      await createChatMessageFeedback({
-        chat_message_id: '123',
-        is_positive: true,
-        feedback_text: 'Great response!',
-      });
-
-      expect(fetch).toHaveBeenCalledWith(
-        '/_da/chat/create-chat-message-feedback',
-        expect.objectContaining({
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-        }),
-      );
-
-      const callBody = JSON.parse(fetch.mock.calls[0][1].body);
-      expect(callBody.chat_message_id).toBe('123');
-      expect(callBody.is_positive).toBe(true);
-      expect(callBody.predefined_feedback).toBeUndefined();
-    });
-
-    it('sends negative feedback with predefined reason', async () => {
-      const mockResponse = { success: true };
-      global.fetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockResponse),
-      });
-
-      await createChatMessageFeedback({
-        chat_message_id: '123',
-        is_positive: false,
-        predefined_feedback: 'Incorrect information',
-      });
-
-      const callBody = JSON.parse(fetch.mock.calls[0][1].body);
-      expect(callBody.is_positive).toBe(false);
-      expect(callBody.predefined_feedback).toBe('Incorrect information');
-    });
-
-    it('throws error on failed request', async () => {
-      global.fetch.mockResolvedValue({
-        ok: false,
-        status: 500,
-      });
-
-      await expect(
-        createChatMessageFeedback({
-          chat_message_id: '123',
-          is_positive: true,
-        }),
-      ).rejects.toThrow('Failed to submit feedback.');
-    });
-  });
-});