feat: Implement unit test ✅

Author: lethemanh

packages/cozy-search/package.json

@@ -83,7 +83,7 @@
     "directory": "packages/cozy-search"
   },
   "scripts": {
-    "build": "yarn build:clean && yarn build:types && babel --extensions .ts,.tsx,.js,.jsx --ignore '**/*.spec.tsx','**/*.spec.ts','**/*.d.ts' ./src -d ./dist --copy-files",
+    "build": "yarn build:clean && yarn build:types && babel --extensions .ts,.tsx,.js,.jsx --ignore '**/*.spec.tsx','**/*.spec.ts','**/*.spec.js','**/*.spec.jsx','**/*.d.ts' ./src -d ./dist --copy-files",
     "build:clean": "rm -rf ./dist",
     "build:types": "tsc -p tsconfig-build.json",
     "build:watch": "yarn build --watch",

packages/cozy-search/src/components/Search/helpers.spec.js

@@ -0,0 +1,71 @@
+import { groupConversationsByDate } from './helpers'
+
+describe('groupConversationsByDate', () => {
+  let OriginalDate
+
+  beforeEach(() => {
+    OriginalDate = global.Date
+    global.Date = class extends OriginalDate {
+      constructor(...args) {
+        if (args.length) return new OriginalDate(...args)
+        return new OriginalDate('2023-11-20T12:00:00Z')
+      }
+    }
+    global.Date.now = jest.fn(() =>
+      new OriginalDate('2023-11-20T12:00:00Z').getTime()
+    )
+  })
+
+  afterEach(() => {
+    global.Date = OriginalDate
+  })
+
+  it('returns empty groups for null or undefined input', () => {
+    expect(groupConversationsByDate(null)).toEqual({ today: [], older: [] })
+    expect(groupConversationsByDate(undefined)).toEqual({
+      today: [],
+      older: []
+    })
+  })
+
+  it('groups conversations into today and older', () => {
+    const mockConversations = [
+      {
+        id: '1',
+        cozyMetadata: {
+          updatedAt: new OriginalDate(2023, 10, 20, 14, 0).toISOString()
+        }
+      }, // Today
+      {
+        id: '2',
+        cozyMetadata: {
+          updatedAt: new OriginalDate(2023, 10, 20, 8, 0).toISOString()
+        }
+      }, // Today
+      {
+        id: '3',
+        cozyMetadata: {
+          updatedAt: new OriginalDate(2023, 10, 19, 23, 59).toISOString()
+        }
+      }, // Older
+      {
+        id: '4',
+        cozyMetadata: {
+          updatedAt: new OriginalDate(2022, 0, 1, 12, 0).toISOString()
+        }
+      }, // Older
+      { id: '5' } // Missing cozyMetadata (Date.now() fallback -> Today)
+    ]
+
+    const result = groupConversationsByDate(mockConversations)
+
+    expect(result.today).toHaveLength(3)
+    expect(result.today[0].id).toBe('1')
+    expect(result.today[1].id).toBe('2')
+    expect(result.today[2].id).toBe('5')
+
+    expect(result.older).toHaveLength(2)
+    expect(result.older[0].id).toBe('3')
+    expect(result.older[1].id).toBe('4')
+  })
+})

packages/cozy-search/src/components/adapters/StreamBridge.spec.ts

@@ -0,0 +1,82 @@
+import { StreamBridge } from './StreamBridge'
+
+describe('StreamBridge', () => {
+  let bridge: StreamBridge
+
+  beforeEach(() => {
+    bridge = new StreamBridge()
+  })
+
+  it('should create an async iterable iterator', () => {
+    const iterator = bridge.createStream('convo_1')
+    expect(typeof iterator.next).toBe('function')
+    expect(iterator[Symbol.asyncIterator]).toBeDefined()
+  })
+
+  it('should push deltas and yield them from the iterator', async () => {
+    const iterator = bridge.createStream('convo_1')
+
+    bridge.onDelta('convo_1', 'Hello ')
+    bridge.onDelta('convo_1', 'world!')
+
+    const first = await iterator.next()
+    expect(first).toEqual({ value: 'Hello ', done: false })
+
+    const second = await iterator.next()
+    expect(second).toEqual({ value: 'world!', done: false })
+  })
+
+  it('should mark the stream as done when complete is called', async () => {
+    const iterator = bridge.createStream('convo_1')
+
+    bridge.onDelta('convo_1', 'done chunk')
+    bridge.onDone('convo_1')
+
+    const first = await iterator.next()
+    expect(first).toEqual({ value: 'done chunk', done: false })
+
+    const second = await iterator.next()
+    expect(second.done).toBe(true)
+  })
+
+  it('should reject the iterator when an error occurs', async () => {
+    const iterator = bridge.createStream('convo_1')
+    const error = new Error('Socket disconnected')
+
+    bridge.onError('convo_1', error)
+
+    await expect(iterator.next()).rejects.toThrow('Socket disconnected')
+  })
+
+  it('should call the cleanup callback and mark the stream complete on cleanup', async () => {
+    const cleanupSpy = jest.fn()
+    bridge.setCleanupCallback(cleanupSpy)
+
+    const iterator = bridge.createStream('convo_1')
+    bridge.cleanup('convo_1')
+
+    expect(cleanupSpy).toHaveBeenCalledTimes(1)
+    expect(bridge.hasStream('convo_1')).toBe(false)
+
+    // The iterator should be marked done
+    const result = await iterator.next()
+    expect(result.done).toBe(true)
+  })
+
+  it('multiple unresolved next calls should reject to prevent concurrency issues', async () => {
+    const iterator = bridge.createStream('convo_1')
+
+    // Call next twice concurrently
+    const p1 = iterator.next()
+    const p2 = iterator.next()
+
+    await expect(p2).rejects.toThrow(
+      'StreamBridge: concurrent next() calls are not supported'
+    )
+
+    // Fulfill the first one
+    bridge.onDelta('convo_1', 'ok')
+    const res1 = await p1
+    expect(res1).toEqual({ value: 'ok', done: false })
+  })
+})

packages/cozy-search/src/components/helpers.spec.js

@@ -1,4 +1,11 @@
-import { sanitizeChatContent } from './helpers'
+import {
+  sanitizeChatContent,
+  formatConversationDate,
+  getNameOfConversation,
+  getDescriptionOfConversation
+} from './helpers'
+
+jest.mock('cozy-flags', () => jest.fn(() => true), { virtual: true })
 
 describe('sanitizeChatContent', () => {
   it('should return empty string for empty content', () => {
@@ -41,3 +48,92 @@ describe('sanitizeChatContent', () => {
     expect(sanitizeChatContent(text)).toBe(text)
   })
 })
+
+describe('formatConversationDate', () => {
+  const mockT = jest.fn(key => key)
+  const mockDate = new Date('2023-11-20T12:00:00Z')
+  let OriginalDate
+  let dateSpy
+
+  beforeEach(() => {
+    OriginalDate = global.Date
+    dateSpy = jest.spyOn(global, 'Date').mockImplementation(function (...args) {
+      if (args.length) {
+        return new OriginalDate(...args)
+      }
+      return mockDate
+    })
+    dateSpy.now = jest.fn(() => mockDate.getTime())
+  })
+
+  afterEach(() => {
+    dateSpy.mockRestore()
+    mockT.mockClear()
+  })
+
+  it('returns empty string for invalid dates', () => {
+    expect(formatConversationDate(null, mockT, 'en-US')).toBe('')
+    expect(formatConversationDate('not date', mockT, 'en-US')).toBe('')
+  })
+
+  it('formats today as "Today, HH:mm"', () => {
+    const today = new Date('2023-11-20T08:30:00Z').toISOString()
+    const result = formatConversationDate(today, mockT, 'en-US')
+
+    expect(result).toMatch(/assistant\.time\.today/)
+    expect(result).toMatch(/\d{1,2}:\d{2}/)
+  })
+
+  it('formats yesterday as "Yesterday, HH:mm"', () => {
+    const yesterday = new Date('2023-11-19T14:45:00Z').toISOString()
+    const result = formatConversationDate(yesterday, mockT, 'en-US')
+
+    expect(result).toMatch(/assistant\.time\.yesterday/)
+    expect(result).toMatch(/\d{1,2}:\d{2}/)
+  })
+
+  it('formats older dates as formatted short date strings', () => {
+    const older = new Date('2022-01-05T10:00:00Z').toISOString()
+    const result = formatConversationDate(older, mockT, 'en-US')
+
+    expect(result).toContain('2022')
+    expect(result).toContain('Jan')
+  })
+})
+
+describe('getNameOfConversation', () => {
+  it('returns undefined if messages array is empty or missing', () => {
+    expect(getNameOfConversation({})).toBeUndefined()
+    expect(getNameOfConversation({ messages: [] })).toBeUndefined()
+    expect(
+      getNameOfConversation({ messages: [{ content: 'Hi' }] })
+    ).toBeUndefined()
+  })
+
+  it('returns the content of the second to last message', () => {
+    const convo = {
+      messages: [
+        { role: 'user', content: 'What is the sum?' },
+        { role: 'assistant', content: 'It is 4' }
+      ]
+    }
+    expect(getNameOfConversation(convo)).toBe('What is the sum?')
+  })
+})
+
+describe('getDescriptionOfConversation', () => {
+  it('returns undefined if messages array is empty or missing', () => {
+    expect(getDescriptionOfConversation({})).toBeUndefined()
+    expect(getDescriptionOfConversation({ messages: [] })).toBeUndefined()
+  })
+
+  it('returns the content of the last message', () => {
+    const convo = {
+      messages: [
+        { role: 'user', content: 'What is the sum?' },
+        { role: 'assistant', content: 'It is 4' }
+      ]
+    }
+    expect(getDescriptionOfConversation(convo)).toBe('It is 4')
+  })
+})

packages/cozy-search/src/hooks/useConversation.spec.jsx

@@ -0,0 +1,121 @@
+import { renderHook, act } from '@testing-library/react-hooks'
+
+import useConversation from './useConversation'
+
+const mockNavigate = jest.fn()
+let mockLocation = {
+  pathname: '/',
+  search: '',
+  hash: ''
+}
+
+jest.mock('react-router-dom', () => ({
+  useNavigate: () => mockNavigate,
+  useLocation: () => mockLocation
+}))
+
+const mockSetIsOpenSearchConversation = jest.fn()
+jest.mock('../components/AssistantProvider', () => ({
+  useAssistant: () => ({
+    setIsOpenSearchConversation: mockSetIsOpenSearchConversation
+  })
+}))
+
+jest.mock('../components/helpers', () => ({
+  makeConversationId: () => 'mock-id-123'
+}))
+
+describe('useConversation', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockLocation = {
+      pathname: '/',
+      search: '',
+      hash: ''
+    }
+  })
+
+  describe('goToConversation', () => {
+    it('appends /assistant/id to a base url', () => {
+      mockLocation.pathname = '/drive/folders/123'
+      const { result } = renderHook(() => useConversation())
+
+      act(() => {
+        result.current.goToConversation('convo-456')
+      })
+
+      expect(mockSetIsOpenSearchConversation).toHaveBeenCalledWith(false)
+      expect(mockNavigate).toHaveBeenCalledWith({
+        pathname: '/drive/folders/123/assistant/convo-456',
+        search: '',
+        hash: ''
+      })
+    })
+
+    it('replaces existing /assistant/... path intelligently', () => {
+      mockLocation.pathname = '/drive/folders/123/assistant/old-convo-789'
+      const { result } = renderHook(() => useConversation())
+
+      act(() => {
+        result.current.goToConversation('new-convo-000')
+      })
+
+      expect(mockNavigate).toHaveBeenCalledWith({
+        pathname: '/drive/folders/123/assistant/new-convo-000',
+        search: '',
+        hash: ''
+      })
+    })
+
+    it('handles trailing slashes on base path correctly', () => {
+      mockLocation.pathname = '/drive/folders/123/'
+      const { result } = renderHook(() => useConversation())
+
+      act(() => {
+        result.current.goToConversation('convo-456')
+      })
+
+      expect(mockNavigate).toHaveBeenCalledWith({
+        pathname: '/drive/folders/123/assistant/convo-456',
+        search: '',
+        hash: ''
+      })
+    })
+
+    it('preserves search query and hash fragments', () => {
+      mockLocation = {
+        pathname: '/base',
+        search: '?foo=bar',
+        hash: '#section1'
+      }
+      const { result } = renderHook(() => useConversation())
+
+      act(() => {
+        result.current.goToConversation('convo-1')
+      })
+
+      expect(mockNavigate).toHaveBeenCalledWith({
+        pathname: '/base/assistant/convo-1',
+        search: '?foo=bar',
+        hash: '#section1'
+      })
+    })
+  })
+
+  describe('createNewConversation', () => {
+    it('creates a new conversation using makeConversationId', () => {
+      mockLocation.pathname = '/docs'
+      const { result } = renderHook(() => useConversation())
+
+      act(() => {
+        result.current.createNewConversation()
+      })
+
+      expect(mockNavigate).toHaveBeenCalledWith({
+        pathname: '/docs/assistant/mock-id-123',
+        search: '',
+        hash: ''
+      })
+    })
+  })
+})