@eeacms/volto-eea-chatbot 1.0.9

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

@@ -0,0 +1,94 @@
+import '@testing-library/jest-dom';
+import { render, screen, fireEvent } from '@testing-library/react';
+import HalloumiFeedback from '../components/HalloumiFeedback';
+
+jest.mock('../components/Spinner', () => () => (
+  <div data-testid="spinner">Loading...</div>
+));
+
+jest.mock('../components/Icon', () => ({ name }) => (
+  <img src={name} alt="icon" />
+));
+
+jest.mock('../../icons/glasses.svg', () => 'glasses.svg');
+
+jest.mock('@plone/volto-slate/editor/render', () => ({
+  serializeNodes: (nodes) => {
+    const visitTextNodes = (node) => {
+      if (Array.isArray(node)) return node.map(visitTextNodes).join('');
+      if (node && typeof node === 'object') {
+        if (node.text) return node.text;
+        if (node.children) return visitTextNodes(node.children);
+      }
+      return '';
+    };
+    return visitTextNodes(nodes);
+  },
+}));
+
+describe('HalloumiFeedback', () => {
+  const defaultProps = {
+    halloumiMessage: null,
+    isLoadingHalloumi: false,
+    markers: { claims: [{ score: 50, rationale: 'Some rationale' }] },
+    score: 75,
+    scoreColor: 'green',
+    onManualVerify: jest.fn(),
+    showVerifyClaimsButton: false,
+    sources: [],
+  };
+
+  it('renders fact-check button when showVerifyClaimsButton is true', () => {
+    render(<HalloumiFeedback {...defaultProps} showVerifyClaimsButton />);
+    const button = screen.getByRole('button', {
+      name: /Fact-check AI answer/i,
+    });
+    expect(button).toBeInTheDocument();
+    fireEvent.click(button);
+    expect(defaultProps.onManualVerify).toHaveBeenCalled();
+    expect(screen.getByText(/Please allow a few minutes/i)).toBeInTheDocument();
+  });
+
+  it('renders VerifyClaims message when loading and sources exist', () => {
+    render(
+      <HalloumiFeedback
+        {...defaultProps}
+        isLoadingHalloumi
+        sources={['doc1']}
+        showVerifyClaimsButton
+      />,
+    );
+    expect(screen.getByTestId('spinner')).toBeInTheDocument();
+    expect(screen.getByText(/Going through each claim/i)).toBeInTheDocument();
+  });
+
+  it('renders rationale message when no claims score', () => {
+    render(
+      <HalloumiFeedback
+        {...defaultProps}
+        markers={{ claims: [{ score: null, rationale: 'Failed to verify' }] }}
+      />,
+    );
+    expect(screen.getByText('Failed to verify')).toBeInTheDocument();
+  });
+
+  it('renders halloumiMessage with score replaced', () => {
+    const halloumiMessage = [
+      { type: 'paragraph', children: [{ text: 'Score: {score}' }] },
+    ];
+    render(
+      <HalloumiFeedback
+        {...defaultProps}
+        halloumiMessage={halloumiMessage}
+        score={88}
+      />,
+    );
+    expect(screen.getByText('Score: 88%')).toBeInTheDocument();
+  });
+
+  it('does not render anything extra when no special props', () => {
+    render(<HalloumiFeedback {...defaultProps} />);
+    expect(screen.queryByRole('button')).not.toBeInTheDocument();
+    expect(screen.queryByTestId('spinner')).not.toBeInTheDocument();
+  });
+});

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

@@ -0,0 +1,105 @@
+import React from 'react';
+import { render, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom/extend-expect';
+import QualityCheckToggle from '../components/QualityCheckToggle';
+
+describe('QualityCheckToggle', () => {
+  const mockSetEnabled = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('renders correctly', () => {
+    const { container } = render(
+      <QualityCheckToggle
+        isEditMode={false}
+        enabled={true}
+        setEnabled={mockSetEnabled}
+      />,
+    );
+
+    expect(
+      container.querySelector('.quality-check-toggle'),
+    ).toBeInTheDocument();
+  });
+
+  it('renders checkbox with correct label', () => {
+    const { getByText } = render(
+      <QualityCheckToggle
+        isEditMode={false}
+        enabled={true}
+        setEnabled={mockSetEnabled}
+      />,
+    );
+
+    expect(getByText('Fact-check AI answer')).toBeInTheDocument();
+  });
+
+  it('checkbox is checked when enabled is true', () => {
+    const { container } = render(
+      <QualityCheckToggle
+        isEditMode={false}
+        enabled={true}
+        setEnabled={mockSetEnabled}
+      />,
+    );
+
+    const checkbox = container.querySelector('input[type="checkbox"]');
+    expect(checkbox.checked).toBe(true);
+  });
+
+  it('checkbox is unchecked when enabled is false', () => {
+    const { container } = render(
+      <QualityCheckToggle
+        isEditMode={false}
+        enabled={false}
+        setEnabled={mockSetEnabled}
+      />,
+    );
+
+    const checkbox = container.querySelector('input[type="checkbox"]');
+    expect(checkbox.checked).toBe(false);
+  });
+
+  it('checkbox is disabled in edit mode', () => {
+    const { container } = render(
+      <QualityCheckToggle
+        isEditMode={true}
+        enabled={true}
+        setEnabled={mockSetEnabled}
+      />,
+    );
+
+    const checkbox = container.querySelector('input[type="checkbox"]');
+    expect(checkbox.disabled).toBe(true);
+  });
+
+  it('checkbox is enabled when not in edit mode', () => {
+    const { container } = render(
+      <QualityCheckToggle
+        isEditMode={false}
+        enabled={true}
+        setEnabled={mockSetEnabled}
+      />,
+    );
+
+    const checkbox = container.querySelector('input[type="checkbox"]');
+    expect(checkbox.disabled).toBe(false);
+  });
+
+  it('calls setEnabled when checkbox is changed', () => {
+    const { container } = render(
+      <QualityCheckToggle
+        isEditMode={false}
+        enabled={true}
+        setEnabled={mockSetEnabled}
+      />,
+    );
+
+    const checkbox = container.querySelector('input[type="checkbox"]');
+    fireEvent.click(checkbox);
+
+    expect(mockSetEnabled).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,215 @@
+import React from 'react';
+import { render, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom/extend-expect';
+import RelatedQuestions from '../components/RelatedQuestions';
+
+import { trackEvent } from '@eeacms/volto-matomo/utils';
+
+// Mock @eeacms/volto-matomo/utils
+jest.mock('@eeacms/volto-matomo/utils', () => ({
+  trackEvent: jest.fn(),
+}));
+
+describe('RelatedQuestions', () => {
+  const mockOnChoice = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('renders nothing when no related questions', () => {
+    const { container } = render(
+      <RelatedQuestions
+        message={{ relatedQuestions: [] }}
+        onChoice={mockOnChoice}
+        isLoading={false}
+      />,
+    );
+    expect(container.querySelector('.chat-related-questions')).toBeNull();
+  });
+
+  it('renders nothing when relatedQuestions is undefined', () => {
+    const { container } = render(
+      <RelatedQuestions
+        message={{}}
+        onChoice={mockOnChoice}
+        isLoading={false}
+      />,
+    );
+    expect(container.querySelector('.chat-related-questions')).toBeNull();
+  });
+
+  it('renders related questions when available', () => {
+    const message = {
+      relatedQuestions: [
+        { question: 'Question 1' },
+        { question: 'Question 2' },
+      ],
+    };
+
+    const { getByText } = render(
+      <RelatedQuestions
+        message={message}
+        onChoice={mockOnChoice}
+        isLoading={false}
+      />,
+    );
+
+    expect(getByText('Related questions:')).toBeInTheDocument();
+    expect(getByText('Question 1')).toBeInTheDocument();
+    expect(getByText('Question 2')).toBeInTheDocument();
+  });
+
+  it('calls onChoice when question is clicked', () => {
+    const message = {
+      relatedQuestions: [{ question: 'Test Question' }],
+    };
+
+    const { getByText } = render(
+      <RelatedQuestions
+        message={message}
+        onChoice={mockOnChoice}
+        isLoading={false}
+      />,
+    );
+
+    fireEvent.click(getByText('Test Question'));
+    expect(mockOnChoice).toHaveBeenCalledWith('Test Question');
+  });
+
+  it('does not call onChoice when loading', () => {
+    const message = {
+      relatedQuestions: [{ question: 'Test Question' }],
+    };
+
+    const { getByText } = render(
+      <RelatedQuestions
+        message={message}
+        onChoice={mockOnChoice}
+        isLoading={true}
+      />,
+    );
+
+    fireEvent.click(getByText('Test Question'));
+    expect(mockOnChoice).not.toHaveBeenCalled();
+  });
+
+  it('tracks event when enableMatomoTracking is true', () => {
+    const message = {
+      relatedQuestions: [{ question: 'Tracked Question' }],
+    };
+    const persona = { name: 'Test Persona' };
+
+    const { getByText } = render(
+      <RelatedQuestions
+        message={message}
+        onChoice={mockOnChoice}
+        isLoading={false}
+        enableMatomoTracking={true}
+        persona={persona}
+      />,
+    );
+
+    fireEvent.click(getByText('Tracked Question'));
+
+    expect(trackEvent).toHaveBeenCalledWith({
+      category: 'Chatbot - Test Persona',
+      action: 'Chatbot: Related question click',
+      name: 'Message submitted',
+    });
+  });
+
+  it('tracks event with default category when no persona name', () => {
+    const message = {
+      relatedQuestions: [{ question: 'Tracked Question' }],
+    };
+
+    const { getByText } = render(
+      <RelatedQuestions
+        message={message}
+        onChoice={mockOnChoice}
+        isLoading={false}
+        enableMatomoTracking={true}
+        persona={{}}
+      />,
+    );
+
+    fireEvent.click(getByText('Tracked Question'));
+
+    expect(trackEvent).toHaveBeenCalledWith({
+      category: 'Chatbot',
+      action: 'Chatbot: Related question click',
+      name: 'Message submitted',
+    });
+  });
+
+  it('does not track event when enableMatomoTracking is false', () => {
+    const message = {
+      relatedQuestions: [{ question: 'Untracked Question' }],
+    };
+
+    const { getByText } = render(
+      <RelatedQuestions
+        message={message}
+        onChoice={mockOnChoice}
+        isLoading={false}
+        enableMatomoTracking={false}
+      />,
+    );
+
+    fireEvent.click(getByText('Untracked Question'));
+
+    expect(trackEvent).not.toHaveBeenCalled();
+  });
+
+  it('handles keyboard Enter key', () => {
+    const message = {
+      relatedQuestions: [{ question: 'Keyboard Question' }],
+    };
+
+    const { getByText } = render(
+      <RelatedQuestions
+        message={message}
+        onChoice={mockOnChoice}
+        isLoading={false}
+      />,
+    );
+
+    fireEvent.keyDown(getByText('Keyboard Question'), { key: 'Enter' });
+    expect(mockOnChoice).toHaveBeenCalledWith('Keyboard Question');
+  });
+
+  it('handles keyboard Space key', () => {
+    const message = {
+      relatedQuestions: [{ question: 'Space Question' }],
+    };
+
+    const { getByText } = render(
+      <RelatedQuestions
+        message={message}
+        onChoice={mockOnChoice}
+        isLoading={false}
+      />,
+    );
+
+    fireEvent.keyDown(getByText('Space Question'), { key: ' ' });
+    expect(mockOnChoice).toHaveBeenCalledWith('Space Question');
+  });
+
+  it('ignores other keyboard keys', () => {
+    const message = {
+      relatedQuestions: [{ question: 'Other Key Question' }],
+    };
+
+    const { getByText } = render(
+      <RelatedQuestions
+        message={message}
+        onChoice={mockOnChoice}
+        isLoading={false}
+      />,
+    );
+
+    fireEvent.keyDown(getByText('Other Key Question'), { key: 'Tab' });
+    expect(mockOnChoice).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,79 @@
+import { MemoryRouter } from 'react-router-dom';
+import configureStore from 'redux-mock-store';
+import renderer from 'react-test-renderer';
+
+import '@testing-library/jest-dom/extend-expect';
+import { Provider } from 'react-intl-redux';
+import SourceDetails from '../components/Source';
+
+const mockStore = configureStore();
+
+jest.mock('@plone/volto/helpers/Loadable/Loadable', () => ({
+  injectLazyLibs: () => (Component) => (props) => (
+    <Component {...props} luxon={require('luxon')} />
+  ),
+}));
+
+describe('SourceDetails', () => {
+  it('should render the component with link type', () => {
+    const store = mockStore({
+      userSession: { token: '1234' },
+      intl: {
+        locale: 'en',
+        messages: {},
+      },
+    });
+
+    const props = {
+      index: '1',
+      source: {
+        blurb: 'Vestibulum purus quam scelerisque ut',
+        link: 'https://www.example.com',
+        source_type: 'web',
+        semantic_identifier: 'Nam at tortor in tellus',
+        updated_at: null,
+      },
+    };
+
+    const component = renderer.create(
+      <Provider store={store}>
+        <MemoryRouter>
+          <SourceDetails {...props} />
+        </MemoryRouter>
+      </Provider>,
+    );
+    const json = component.toJSON();
+    expect(json).toMatchSnapshot();
+  });
+
+  it('should render the component with doc type', () => {
+    const store = mockStore({
+      userSession: { token: '1234' },
+      intl: {
+        locale: 'en',
+        messages: {},
+      },
+    });
+
+    const props = {
+      index: '2',
+      source: {
+        blurb: 'Vestibulum purus quam scelerisque ut',
+        link: 'https://www.example.com',
+        source_type: 'file',
+        semantic_identifier: 'Nam at tortor in tellus',
+        updated_at: null,
+      },
+    };
+
+    const component = renderer.create(
+      <Provider store={store}>
+        <MemoryRouter>
+          <SourceDetails {...props} />
+        </MemoryRouter>
+      </Provider>,
+    );
+    const json = component.toJSON();
+    expect(json).toMatchSnapshot();
+  });
+});

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

@@ -0,0 +1,18 @@
+import React from 'react';
+import renderer from 'react-test-renderer';
+import '@testing-library/jest-dom/extend-expect';
+import Spinner from '../components/Spinner';
+
+describe('Spinner', () => {
+  it('renders correctly', () => {
+    const component = renderer.create(<Spinner />);
+    expect(component.toJSON()).toMatchSnapshot();
+  });
+
+  it('renders a div with spinner class', () => {
+    const component = renderer.create(<Spinner />);
+    const tree = component.toJSON();
+    expect(tree.type).toBe('div');
+    expect(tree.props.className).toBe('spinner');
+  });
+});

package/src/ChatBlock/tests/index.test.js

@@ -0,0 +1,51 @@
+import '@testing-library/jest-dom/extend-expect';
+
+import installChatBlock from '../index';
+
+// Mock @plone/volto/components
+jest.mock('@plone/volto/components', () => ({
+  SidebarPortal: () => null,
+}));
+
+// Mock other dependencies
+jest.mock('../ChatBlockView', () => () => <div>ChatBlockView</div>);
+jest.mock('../ChatBlockEdit', () => () => <div>ChatBlockEdit</div>);
+
+describe('ChatBlock installation', () => {
+  let mockConfig;
+
+  beforeEach(() => {
+    mockConfig = {
+      blocks: {
+        blocksConfig: {},
+      },
+      settings: {},
+    };
+  });
+
+  it('should register eeaChatbot block', () => {
+    installChatBlock(mockConfig);
+
+    expect(mockConfig.blocks.blocksConfig.eeaChatbot).toBeDefined();
+  });
+
+  it('should set correct block properties', () => {
+    installChatBlock(mockConfig);
+
+    const blockConfig = mockConfig.blocks.blocksConfig.eeaChatbot;
+    expect(blockConfig.id).toBe('eeaChatbot');
+    expect(blockConfig.title).toBe('AI Chatbot');
+    expect(blockConfig.group).toBe('common');
+    expect(blockConfig.restricted({ user: null })).toBe(false);
+    expect(blockConfig.mostUsed).toBe(false);
+    expect(blockConfig.sidebarTab).toBe(1);
+  });
+
+  it('should set view and edit components', () => {
+    installChatBlock(mockConfig);
+
+    const blockConfig = mockConfig.blocks.blocksConfig.eeaChatbot;
+    expect(blockConfig.view).toBeDefined();
+    expect(blockConfig.edit).toBeDefined();
+  });
+});