@eeacms/volto-eea-chatbot 1.0.9

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

@@ -0,0 +1,154 @@
+import { MessageProcessor } from '../services/messageProcessor';
+import { PacketType } from '../types/streamingModels';
+
+describe('MessageProcessor', () => {
+  let processor;
+
+  beforeEach(() => {
+    processor = new MessageProcessor();
+  });
+
+  it('should initialize with empty state', () => {
+    const result = processor.getMessage();
+    expect(result.groupedPackets).toEqual([]);
+    expect(result.toolPackets).toEqual([]);
+    expect(result.displayPackets).toEqual([]);
+    expect(result.citations || {}).toEqual({});
+    expect(result.documents).toEqual(null);
+    expect(result.isComplete).toBe(false);
+  });
+
+  it('should process text message packets', () => {
+    const packets = [
+      {
+        ind: 0,
+        obj: {
+          type: PacketType.MESSAGE_START,
+          id: 'msg1',
+          content: 'Hello world',
+          final_documents: null,
+        },
+      },
+    ];
+
+    processor.addPackets(packets);
+    const result = processor.getMessage();
+    expect(result.groupedPackets).toHaveLength(1);
+    expect(result.displayPackets).toContain(0);
+    expect(result.groupedPackets[0].packets[0].obj.content).toBe('Hello world');
+  });
+
+  it('should process search tool packets', () => {
+    const packets = [
+      {
+        ind: 0,
+        obj: {
+          type: PacketType.SEARCH_TOOL_START,
+          search_query: 'test query',
+        },
+      },
+    ];
+
+    processor.addPackets(packets);
+    const result = processor.getMessage();
+    expect(result.groupedPackets).toHaveLength(1);
+    expect(result.toolPackets).toContain(0);
+  });
+
+  it('should process citation packets', () => {
+    const packets = [
+      {
+        ind: 0,
+        obj: {
+          type: PacketType.CITATION_DELTA,
+          citations: [{ citation_num: 1, document_id: 'doc123' }],
+        },
+      },
+    ];
+
+    processor.addPackets(packets);
+    const result = processor.getMessage();
+    expect(result.citations).toEqual({ 1: 'doc123' });
+  });
+
+  it('should process document packets', () => {
+    const packets = [
+      {
+        ind: 0,
+        obj: {
+          type: PacketType.SEARCH_TOOL_DELTA,
+          documents: [
+            {
+              document_id: 'doc123',
+              semantic_identifier: 'Test Document',
+              link: 'https://example.com',
+            },
+          ],
+        },
+      },
+    ];
+
+    processor.addPackets(packets);
+    const result = processor.getMessage();
+    expect(result.documents).toHaveLength(1);
+    expect(result.documents[0].document_id).toBe('doc123');
+  });
+
+  it('should process error packets', () => {
+    const packets = [
+      {
+        ind: 0,
+        obj: {
+          type: PacketType.ERROR,
+          error: 'Something went wrong',
+        },
+      },
+    ];
+
+    processor.addPackets(packets);
+    const result = processor.getMessage();
+    expect(result.error).toBe('Something went wrong');
+  });
+
+  it('should mark as complete when stop packet received', () => {
+    const packets = [
+      {
+        ind: 0,
+        obj: {
+          type: PacketType.MESSAGE_DELTA,
+          content: 'Hello',
+        },
+      },
+      {
+        ind: 1,
+        obj: {
+          type: PacketType.STOP,
+        },
+      },
+    ];
+
+    processor.addPackets(packets);
+    const result = processor.getMessage();
+    expect(result.isComplete).toBe(true);
+  });
+
+  it('should reset processor state', () => {
+    const packets = [
+      {
+        ind: 0,
+        obj: {
+          type: PacketType.MESSAGE_DELTA,
+          content: 'Hello',
+        },
+      },
+    ];
+
+    processor.addPackets(packets);
+    processor.reset();
+
+    const result = processor.getMessage();
+    expect(result.groupedPackets).toEqual([]);
+    expect(result.documents).toEqual(null);
+    expect(result.citations || {}).toEqual({});
+  });
+});

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

@@ -0,0 +1,166 @@
+import '@testing-library/jest-dom/extend-expect';
+import { ChatBlockSchema } from '../schema';
+
+describe('ChatBlockSchema', () => {
+  const mockAssistants = [
+    { id: 1, name: 'Assistant 1' },
+    { id: 2, name: 'Assistant 2' },
+  ];
+
+  it('returns schema object with title', () => {
+    const schema = ChatBlockSchema({ assistants: mockAssistants, data: {} });
+    expect(schema.title).toBe('Chatbot');
+  });
+
+  it('returns schema with fieldsets', () => {
+    const schema = ChatBlockSchema({ assistants: mockAssistants, data: {} });
+    expect(schema.fieldsets).toBeDefined();
+    expect(Array.isArray(schema.fieldsets)).toBe(true);
+    expect(schema.fieldsets.length).toBeGreaterThan(0);
+  });
+
+  it('returns schema with properties', () => {
+    const schema = ChatBlockSchema({ assistants: mockAssistants, data: {} });
+    expect(schema.properties).toBeDefined();
+  });
+
+  it('includes assistant choices from assistants array', () => {
+    const schema = ChatBlockSchema({ assistants: mockAssistants, data: {} });
+    expect(schema.properties.assistant.choices).toEqual([
+      ['1', 'Assistant 1'],
+      ['2', 'Assistant 2'],
+    ]);
+  });
+
+  it('handles empty assistants array', () => {
+    const schema = ChatBlockSchema({ assistants: [], data: {} });
+    expect(schema.properties.assistant.choices).toEqual([]);
+  });
+
+  it('handles undefined assistants', () => {
+    const schema = ChatBlockSchema({ assistants: undefined, data: {} });
+    expect(schema.properties.assistant.choices).toEqual([]);
+  });
+
+  it('includes starterPrompts field when enableStarterPrompts is true', () => {
+    const schema = ChatBlockSchema({
+      assistants: mockAssistants,
+      data: { enableStarterPrompts: true },
+    });
+    expect(schema.fieldsets[0].fields).toContain('starterPrompts');
+  });
+
+  it('excludes starterPrompts field when enableStarterPrompts is false', () => {
+    const schema = ChatBlockSchema({
+      assistants: mockAssistants,
+      data: { enableStarterPrompts: false },
+    });
+    expect(schema.fieldsets[0].fields).not.toContain('starterPrompts');
+  });
+
+  it('includes feedbackReasons field when enableFeedback is true', () => {
+    const schema = ChatBlockSchema({
+      assistants: mockAssistants,
+      data: { enableFeedback: true },
+    });
+    expect(schema.fieldsets[0].fields).toContain('feedbackReasons');
+  });
+
+  it('excludes feedbackReasons field when enableFeedback is false', () => {
+    const schema = ChatBlockSchema({
+      assistants: mockAssistants,
+      data: { enableFeedback: false },
+    });
+    expect(schema.fieldsets[0].fields).not.toContain('feedbackReasons');
+  });
+
+  it('includes quality check fields when qualityCheck is enabled', () => {
+    const schema = ChatBlockSchema({
+      assistants: mockAssistants,
+      data: { qualityCheck: 'enabled' },
+    });
+    expect(schema.fieldsets[0].fields).toContain('maxContextSegments');
+    expect(schema.fieldsets[0].fields).toContain('noSupportDocumentsMessage');
+    expect(schema.fieldsets[0].fields).toContain('qualityCheckContext');
+    expect(schema.fieldsets[0].fields).toContain('qualityCheckStages');
+  });
+
+  it('excludes quality check fields when qualityCheck is disabled', () => {
+    const schema = ChatBlockSchema({
+      assistants: mockAssistants,
+      data: { qualityCheck: 'disabled' },
+    });
+    expect(schema.fieldsets[0].fields).not.toContain('maxContextSegments');
+    expect(schema.fieldsets[0].fields).not.toContain('qualityCheckContext');
+  });
+
+  it('includes onDemandInputToggle when qualityCheck is ondemand_toggle', () => {
+    const schema = ChatBlockSchema({
+      assistants: mockAssistants,
+      data: { qualityCheck: 'ondemand_toggle' },
+    });
+    expect(schema.fieldsets[0].fields).toContain('onDemandInputToggle');
+  });
+
+  it('excludes onDemandInputToggle when qualityCheck is not ondemand_toggle', () => {
+    const schema = ChatBlockSchema({
+      assistants: mockAssistants,
+      data: { qualityCheck: 'enabled' },
+    });
+    expect(schema.fieldsets[0].fields).not.toContain('onDemandInputToggle');
+  });
+
+  it('includes totalFailMessage when enableShowTotalFailMessage is true', () => {
+    const schema = ChatBlockSchema({
+      assistants: mockAssistants,
+      data: { enableShowTotalFailMessage: true },
+    });
+    expect(schema.fieldsets[0].fields).toContain('totalFailMessage');
+  });
+
+  it('excludes totalFailMessage when enableShowTotalFailMessage is false', () => {
+    const schema = ChatBlockSchema({
+      assistants: mockAssistants,
+      data: { enableShowTotalFailMessage: false },
+    });
+    expect(schema.fieldsets[0].fields).not.toContain('totalFailMessage');
+  });
+
+  it('has required array', () => {
+    const schema = ChatBlockSchema({ assistants: mockAssistants, data: {} });
+    expect(schema.required).toBeDefined();
+    expect(Array.isArray(schema.required)).toBe(true);
+  });
+
+  it('has default values for key properties', () => {
+    const schema = ChatBlockSchema({ assistants: mockAssistants, data: {} });
+    expect(schema.properties.placeholderPrompt.default).toBe('Ask a question');
+    expect(schema.properties.chatTitle.default).toBe('Online public chat');
+    expect(schema.properties.enableFeedback.default).toBe(true);
+    expect(schema.properties.qualityCheck.default).toBe('disabled');
+  });
+
+  it('has qualityCheckStages with default score ranges', () => {
+    const schema = ChatBlockSchema({ assistants: mockAssistants, data: {} });
+    expect(schema.properties.qualityCheckStages.default).toBeDefined();
+    expect(Array.isArray(schema.properties.qualityCheckStages.default)).toBe(
+      true,
+    );
+    expect(schema.properties.qualityCheckStages.default.length).toBe(5);
+  });
+
+  it('has feedbackReasons with default choices', () => {
+    const schema = ChatBlockSchema({ assistants: mockAssistants, data: {} });
+    expect(schema.properties.feedbackReasons.default).toBeDefined();
+    expect(Array.isArray(schema.properties.feedbackReasons.default)).toBe(true);
+  });
+
+  it('has deepResearch property with choices', () => {
+    const schema = ChatBlockSchema({ assistants: mockAssistants, data: {} });
+    expect(schema.properties.deepResearch.choices).toBeDefined();
+    expect(schema.properties.deepResearch.choices).toContainEqual([
+      'always_on',
+      'Always on',
+    ]);
+  });
+});

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

@@ -0,0 +1,107 @@
+import { renderHook } from '@testing-library/react-hooks';
+import '@testing-library/jest-dom/extend-expect';
+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/useToolDisplayTiming.test.jsx

@@ -0,0 +1,151 @@
+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/types/cssmodules.d.ts

@@ -0,0 +1,7 @@
+declare module '*.less' {}
+
+declare module '*.svg' {
+  const attributes: Record<string, string>;
+  const content: string;
+  export default content;
+}