@mingxy/ocosay 1.0.0

package/tests/speaker.test.ts

@@ -0,0 +1,232 @@
+import { Speaker, getDefaultSpeaker, speak, stop, pause, resume, listVoices } from '../src/core/speaker'
+import { TTSError, TTSErrorCode, TTSCapabilities, Voice } from '../src/core/types'
+import { registerProvider, unregisterProvider, BaseTTSProvider } from '../src/providers/base'
+import { AudioPlayer } from '../src/core/player'
+
+jest.mock('../src/core/player')
+
+const MockAudioPlayer = AudioPlayer as jest.MockedClass<typeof AudioPlayer>
+
+class MockProvider extends BaseTTSProvider {
+  name = 'mock'
+  capabilities: TTSCapabilities = { speak: true, stream: true }
+  
+  protected async doSpeak(text: string, voice: string | undefined, model: any) {
+    if (text === 'error') {
+      throw new TTSError('Provider error', TTSErrorCode.UNKNOWN, this.name)
+    }
+    return {
+      audioData: Buffer.from([1, 2, 3]),
+      format: 'mp3',
+      isStream: model === 'stream',
+      duration: 1.0
+    }
+  }
+
+  async listVoices(): Promise<Voice[]> {
+    return [
+      { id: 'voice1', name: 'Voice 1', language: 'zh-CN' },
+      { id: 'voice2', name: 'Voice 2', language: 'en-US', gender: 'male' as const }
+    ]
+  }
+}
+
+describe('Speaker', () => {
+  let speaker: Speaker
+  let mockPlayer: any
+  let capturedEvents: any
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    registerProvider('mock', new MockProvider())
+    
+    capturedEvents = {}
+    mockPlayer = {
+      play: jest.fn().mockImplementation(() => {
+        capturedEvents.onStart?.()
+        return Promise.resolve()
+      }),
+      pause: jest.fn().mockImplementation(() => { capturedEvents.onPause?.() }),
+      resume: jest.fn().mockImplementation(() => { capturedEvents.onResume?.() }),
+      stop: jest.fn().mockImplementation(() => {
+        capturedEvents.onStop?.()
+        return Promise.resolve()
+      })
+    }
+    MockAudioPlayer.mockImplementation((events?: any) => {
+      Object.assign(capturedEvents, events)
+      return mockPlayer
+    })
+    
+    speaker = new Speaker({ defaultProvider: 'mock', defaultModel: 'stream' })
+  })
+
+  afterEach(() => {
+    unregisterProvider('mock')
+  })
+
+  describe('initialization', () => {
+    it('should create speaker with options', () => {
+      const s = new Speaker({ defaultProvider: 'mock', defaultModel: 'sync' })
+      expect(s.getProviders()).toContain('mock')
+    })
+
+    it('should create speaker with all options', () => {
+      const s = new Speaker({
+        defaultProvider: 'mock',
+        defaultModel: 'stream',
+        defaultVoice: 'voice1',
+        onEvent: jest.fn()
+      })
+      expect(s.getProviders()).toContain('mock')
+    })
+  })
+
+  describe('speak', () => {
+    it('should throw on empty text', async () => {
+      await expect(speaker.speak('')).rejects.toThrow(TTSError)
+    })
+
+    it('should throw on whitespace-only text', async () => {
+      await expect(speaker.speak('   ')).rejects.toThrow(TTSError)
+    })
+
+    it('should stop current playback before new speak', async () => {
+      await speaker.speak('First')
+      await speaker.speak('Second')
+      expect(mockPlayer.stop).toHaveBeenCalled()
+    })
+
+    it('should play audio data', async () => {
+      await speaker.speak('Hello')
+      expect(mockPlayer.play).toHaveBeenCalledWith(Buffer.from([1, 2, 3]), 'mp3')
+    })
+
+    it('should throw on provider error', async () => {
+      await expect(speaker.speak('error')).rejects.toThrow()
+    })
+
+    it('should throw when provider not found', async () => {
+      await expect(speaker.speak('Hello', { provider: 'non-existent' })).rejects.toThrow()
+    })
+  })
+
+  describe('control methods', () => {
+    it('should pause without error', () => {
+      expect(() => speaker.pause()).not.toThrow()
+    })
+
+    it('should resume without error', () => {
+      expect(() => speaker.resume()).not.toThrow()
+    })
+
+    it('should stop without error', async () => {
+      await expect(speaker.stop()).resolves.toBeUndefined()
+    })
+  })
+
+  describe('listVoices', () => {
+    it('should return voices from provider', async () => {
+      const voices = await speaker.listVoices('mock')
+      expect(Array.isArray(voices)).toBe(true)
+      expect(voices.length).toBe(2)
+    })
+
+    it('should use default provider when none specified', async () => {
+      const voices = await speaker.listVoices()
+      expect(Array.isArray(voices)).toBe(true)
+    })
+  })
+
+  describe('getCapabilities', () => {
+    it('should return provider capabilities', () => {
+      const caps = speaker.getCapabilities('mock')
+      expect(caps.speak).toBe(true)
+    })
+
+    it('should use default provider when none specified', () => {
+      const caps = speaker.getCapabilities()
+      expect(caps.speak).toBe(true)
+    })
+  })
+
+  describe('getProviders', () => {
+    it('should return list of registered providers', () => {
+      const providers = speaker.getProviders()
+      expect(providers).toContain('mock')
+    })
+  })
+
+  describe('isPlaying', () => {
+    it('should return false initially', () => {
+      expect(speaker.isPlaying()).toBe(false)
+    })
+
+    it('should return true while speaking', async () => {
+      const speakPromise = speaker.speak('Hello')
+      expect(speaker.isPlaying()).toBe(true)
+      await speakPromise
+    })
+
+    it('should return false after stop', async () => {
+      await speaker.speak('Hello')
+      await speaker.stop()
+      expect(speaker.isPlaying()).toBe(false)
+    })
+  })
+
+  describe('isPausedState', () => {
+    it('should return false initially', () => {
+      expect(speaker.isPausedState()).toBe(false)
+    })
+  })
+
+  describe('destroy', () => {
+    it('should stop player on destroy', async () => {
+      await speaker.destroy()
+      expect(mockPlayer.stop).toHaveBeenCalled()
+    })
+
+    it('should set isSpeaking to false', async () => {
+      await speaker.speak('Hello')
+      await speaker.destroy()
+      expect(speaker.isPlaying()).toBe(false)
+    })
+
+    it('should be callable multiple times', async () => {
+      await speaker.destroy()
+      await expect(speaker.destroy()).resolves.not.toThrow()
+    })
+  })
+
+  describe('events', () => {
+    it('should emit start event', async () => {
+      const startCallback = jest.fn()
+      speaker.on('start', startCallback)
+      await speaker.speak('Hello')
+      expect(startCallback).toHaveBeenCalled()
+    })
+
+    it('should emit stop event on stop', async () => {
+      const stopCallback = jest.fn()
+      speaker.on('stop', stopCallback)
+      await speaker.stop()
+      expect(stopCallback).toHaveBeenCalled()
+    })
+  })
+})
+
+describe('getDefaultSpeaker', () => {
+  beforeEach(() => {
+    registerProvider('mock', new MockProvider())
+  })
+
+  afterEach(() => {
+    unregisterProvider('mock')
+  })
+
+  it('should return a Speaker instance', () => {
+    const speaker = getDefaultSpeaker()
+    expect(speaker).toBeInstanceOf(Speaker)
+  })
+})

package/tests/stream-player.test.ts

@@ -0,0 +1,303 @@
+import { StreamPlayer } from '../src/core/stream-player'
+import { spawn } from 'child_process'
+import { createWriteStream } from 'fs'
+
+jest.mock('child_process')
+jest.mock('fs')
+
+const mockSpawn = spawn as jest.MockedFunction<typeof spawn>
+const mockCreateWriteStream = createWriteStream as jest.MockedFunction<typeof createWriteStream>
+
+describe('StreamPlayer', () => {
+  let mockWriteStream: any
+  let mockPlayerProcess: any
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    
+    mockWriteStream = {
+      write: jest.fn().mockReturnValue(true),
+      end: jest.fn(),
+      destroy: jest.fn(),
+      on: jest.fn(),
+      once: jest.fn()
+    }
+    
+    mockPlayerProcess = {
+      kill: jest.fn(),
+      on: jest.fn(),
+      stdin: { end: jest.fn() }
+    }
+
+    mockCreateWriteStream.mockReturnValue(mockWriteStream as any)
+    mockSpawn.mockImplementation(() => mockPlayerProcess as any)
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  function createPlayer(options?: any): StreamPlayer {
+    return new StreamPlayer(options)
+  }
+
+  describe('initialization', () => {
+    it('should create StreamPlayer with default options', () => {
+      const player = createPlayer()
+      expect(player).toBeInstanceOf(StreamPlayer)
+    })
+
+    it('should create StreamPlayer with custom format', () => {
+      const player = createPlayer({ format: 'wav' })
+      expect(player).toBeInstanceOf(StreamPlayer)
+    })
+
+    it('should create StreamPlayer with events callback', () => {
+      const events = {
+        onStart: jest.fn(),
+        onEnd: jest.fn(),
+        onProgress: jest.fn(),
+        onError: jest.fn(),
+        onStop: jest.fn()
+      }
+      const player = createPlayer({ events })
+      expect(player).toBeInstanceOf(StreamPlayer)
+    })
+  })
+
+  describe('write', () => {
+    it('should auto-start if not started', () => {
+      const player = createPlayer()
+      player.write(Buffer.from([1, 2, 3]))
+      expect(player.isStarted()).toBe(true)
+    })
+
+    it('should ignore write if stopped', () => {
+      const player = createPlayer()
+      player.start()
+      player.stop()
+      player.write(Buffer.from([1, 2, 3]))
+      expect(player.getBytesWritten()).toBe(0)
+    })
+
+    it('should write chunk to stream', () => {
+      const player = createPlayer()
+      player.write(Buffer.from([1, 2, 3]))
+      expect(mockWriteStream.write).toHaveBeenCalledWith(Buffer.from([1, 2, 3]))
+    })
+
+    it('should increment bytesWritten counter', () => {
+      const player = createPlayer()
+      player.write(Buffer.from([1, 2, 3]))
+      expect(player.getBytesWritten()).toBe(3)
+    })
+
+    it('should call onProgress callback', () => {
+      const onProgress = jest.fn()
+      const player = createPlayer({ events: { onProgress } })
+      player.write(Buffer.from([1, 2, 3]))
+      expect(onProgress).toHaveBeenCalledWith(3)
+    })
+
+    it('should emit progress event', () => {
+      const player = createPlayer()
+      const progressCallback = jest.fn()
+      player.on('progress', progressCallback)
+      player.write(Buffer.from([1, 2, 3]))
+      expect(progressCallback).toHaveBeenCalledWith(3)
+    })
+  })
+
+  describe('start', () => {
+    it('should set started flag to true', () => {
+      const player = createPlayer()
+      player.start()
+      expect(player.isStarted()).toBe(true)
+    })
+
+    it('should not start twice', () => {
+      const player = createPlayer()
+      player.start()
+      player.start()
+      expect(mockCreateWriteStream).toHaveBeenCalledTimes(1)
+    })
+
+    it('should call onStart callback', () => {
+      const onStart = jest.fn()
+      const player = createPlayer({ events: { onStart } })
+      player.start()
+      expect(onStart).toHaveBeenCalled()
+    })
+
+    it('should emit start event', () => {
+      const player = createPlayer()
+      const startCallback = jest.fn()
+      player.on('start', startCallback)
+      player.start()
+      expect(startCallback).toHaveBeenCalled()
+    })
+  })
+
+  describe('stop', () => {
+    it('should set stopped flag to true', () => {
+      const player = createPlayer()
+      player.start()
+      player.stop()
+      expect(player.isStopped()).toBe(true)
+    })
+
+    it('should kill player process', () => {
+      const player = createPlayer()
+      player.start()
+      player.stop()
+      expect(mockPlayerProcess.kill).toHaveBeenCalledWith('SIGTERM')
+    })
+
+    it('should call onStop callback', () => {
+      const onStop = jest.fn()
+      const player = createPlayer({ events: { onStop } })
+      player.start()
+      player.stop()
+      expect(onStop).toHaveBeenCalled()
+    })
+
+    it('should emit stop event', () => {
+      const player = createPlayer()
+      player.start()
+      const stopCallback = jest.fn()
+      player.on('stop', stopCallback)
+      player.stop()
+      expect(stopCallback).toHaveBeenCalled()
+    })
+  })
+
+  describe('pause', () => {
+    it('should set paused flag to true', () => {
+      const player = createPlayer()
+      player.start()
+      player.pause()
+      expect(player.isPaused()).toBe(true)
+    })
+
+    it('should send SIGSTOP to player process', () => {
+      const player = createPlayer()
+      player.start()
+      player.pause()
+      expect(mockPlayerProcess.kill).toHaveBeenCalledWith('SIGSTOP')
+    })
+
+    it('should call onPause callback', () => {
+      const onPause = jest.fn()
+      const player = createPlayer({ events: { onPause } })
+      player.start()
+      player.pause()
+      expect(onPause).toHaveBeenCalled()
+    })
+
+    it('should emit pause event', () => {
+      const player = createPlayer()
+      player.start()
+      const pauseCallback = jest.fn()
+      player.on('pause', pauseCallback)
+      player.pause()
+      expect(pauseCallback).toHaveBeenCalled()
+    })
+
+    it('should not pause if not started', () => {
+      const player = createPlayer()
+      player.pause()
+      expect(mockPlayerProcess.kill).not.toHaveBeenCalled()
+    })
+
+    it('should not pause if already paused', () => {
+      const player = createPlayer()
+      player.start()
+      player.pause()
+      player.pause()
+      expect(mockPlayerProcess.kill).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('resume', () => {
+    it('should set paused flag to false', () => {
+      const player = createPlayer()
+      player.start()
+      player.pause()
+      player.resume()
+      expect(player.isPaused()).toBe(false)
+    })
+
+    it('should send SIGCONT to player process', () => {
+      const player = createPlayer()
+      player.start()
+      player.pause()
+      player.resume()
+      expect(mockPlayerProcess.kill).toHaveBeenCalledWith('SIGCONT')
+    })
+
+    it('should call onResume callback', () => {
+      const onResume = jest.fn()
+      const player = createPlayer({ events: { onResume } })
+      player.start()
+      player.pause()
+      player.resume()
+      expect(onResume).toHaveBeenCalled()
+    })
+
+    it('should emit resume event', () => {
+      const player = createPlayer()
+      player.start()
+      player.pause()
+      const resumeCallback = jest.fn()
+      player.on('resume', resumeCallback)
+      player.resume()
+      expect(resumeCallback).toHaveBeenCalled()
+    })
+
+    it('should not resume if not paused', () => {
+      const player = createPlayer()
+      player.start()
+      player.resume()
+      expect(mockPlayerProcess.kill).not.toHaveBeenCalledWith('SIGCONT')
+    })
+  })
+
+  describe('end', () => {
+    it('should end write stream without stopping player', () => {
+      const player = createPlayer()
+      player.start()
+      player.end()
+      expect(mockWriteStream.end).toHaveBeenCalled()
+    })
+  })
+
+  describe('state queries', () => {
+    it('isStarted should return false initially', () => {
+      const player = createPlayer()
+      expect(player.isStarted()).toBe(false)
+    })
+
+    it('isPaused should return false initially', () => {
+      const player = createPlayer()
+      expect(player.isPaused()).toBe(false)
+    })
+
+    it('isStopped should return false initially', () => {
+      const player = createPlayer()
+      expect(player.isStopped()).toBe(false)
+    })
+
+    it('getBytesWritten should return 0 initially', () => {
+      const player = createPlayer()
+      expect(player.getBytesWritten()).toBe(0)
+    })
+  })
+
+  describe('error handling', () => {
+    it('should have error handler registered', () => {
+      const player = createPlayer()
+      player.start()
+      expect(mockWriteStream.on).toHaveBeenCalledWith('error', expect.any(Function))
+    })
+  })
+})