d3ro-voice/apps/desktop/tests/main/services/VoiceConversationService.test.ts
Yun Chan fc5d45312c fix(desktop): harden cancellation, dispose, and lifecycle races across main services
Cancel pending result-popup measure timers on hideResultPopup; track CaptionService aux-model load state, stop deduplication, and refine abort epochs across restarts; forward per-call AbortSignal through VoiceModeService and LlmGateway to LocalLLMService and abort pull streams plus availability polling on dispose; clear aborted response pointers and gate stale mic start errors in VoiceConversationService; guard AudioCaptureService stopping resume against exited SoX processes and cleanup failed starts; abort LocalSTTService downloadModel polling on dispose; and fail closed when desktopCapturer.getSources rejects in caption loopback setup.
2026-11-14 15:26:18 +09:00

253 lines
8.2 KiB
TypeScript

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { IPC_CHANNELS } from '@d3ro/core/ipc-channels'
import { ErrorCode } from '@d3ro/core/errors'
import {
getVoiceConversationService,
resetVoiceConversationServiceForTests,
} from '../../../src/main/services/VoiceConversationService'
type ChatOptions = {
signal?: AbortSignal
maxTokens?: number
timeoutMs?: number
keepAlive?: string
}
const mocks = vi.hoisted(() => ({
audioStart: vi.fn(async () => undefined),
audioStop: vi.fn(async () => undefined),
chatStream: vi.fn(),
premiumCancel: vi.fn(),
speakSentences: vi.fn(async () => undefined),
ttsStop: vi.fn(),
send: vi.fn(),
}))
vi.mock('../../../src/main/services/LoggerService', () => ({
getLogger: () => ({ info: vi.fn(), warn: vi.fn(), error: vi.fn() }),
}))
vi.mock('../../../src/main/services/AudioCaptureService', () => ({
getAudioCaptureService: () => ({
start: mocks.audioStart,
stop: mocks.audioStop,
on: vi.fn(),
off: vi.fn(),
}),
}))
vi.mock('../../../src/main/services/LocalSTTService', () => ({
getLocalSTTService: () => ({ initialize: vi.fn(async () => undefined) }),
}))
vi.mock('../../../src/main/services/PremiumLLMService', () => ({
getPremiumLLMService: () => ({
cancelGeneration: mocks.premiumCancel,
isAvailable: () => false,
}),
}))
vi.mock('../../../src/main/services/LocalLLMService', () => ({
getLocalLLMService: () => ({
isAvailable: () => true,
chatStream: mocks.chatStream,
}),
}))
vi.mock('../../../src/main/services/TTSPlaybackService', () => ({
getTTSPlaybackService: () => ({
speakSentences: mocks.speakSentences,
stop: mocks.ttsStop,
}),
}))
vi.mock('../../../src/main/services/SoundEffectService', () => ({
getSoundEffectService: () => ({ play: vi.fn() }),
}))
vi.mock('../../../src/main/services/ConfigService', () => ({
configGet: () => undefined,
}))
vi.mock('../../../src/main/services/LicenseService', () => ({
getLicenseService: () => ({
canUse: () => ({ allowed: true }),
promptUpgrade: vi.fn(),
}),
}))
vi.mock('../../../src/main/windows/WindowManager', () => ({
getMainWindow: () => ({
isDestroyed: () => false,
webContents: { send: mocks.send },
}),
}))
function waitForAbort(signal: AbortSignal): Promise<void> {
if (signal.aborted) return Promise.resolve()
return new Promise((resolve) => signal.addEventListener('abort', () => resolve(), { once: true }))
}
async function* waitUntilAborted(options?: ChatOptions): AsyncGenerator<string, string> {
if (!options?.signal) throw new Error('Expected caller-owned abort signal')
await waitForAbort(options.signal)
return ''
}
describe('VoiceConversationService local response ownership', () => {
beforeEach(() => {
resetVoiceConversationServiceForTests()
vi.clearAllMocks()
mocks.chatStream.mockImplementation((_messages: unknown, options?: ChatOptions) => waitUntilAborted(options))
})
afterEach(() => {
resetVoiceConversationServiceForTests()
})
it('rejects a second send without starting a second local chat or adding duplicate history', async () => {
const service = getVoiceConversationService()
await service.startSession()
const firstResponse = service.sendTextMessage('first')
await vi.waitFor(() => expect(mocks.chatStream).toHaveBeenCalledTimes(1))
await expect(service.sendTextMessage('second')).rejects.toMatchObject({
code: ErrorCode.ConversationLLMFailed,
})
expect(mocks.chatStream).toHaveBeenCalledTimes(1)
expect(service.getHistory().map((message) => message.content)).toEqual(['first'])
service.stopSession()
await firstResponse
})
it.each([
['stopSession', (service: ReturnType<typeof getVoiceConversationService>) => service.stopSession()],
['cancelResponse', (service: ReturnType<typeof getVoiceConversationService>) => service.cancelResponse()],
])('aborts the local stream signal when %s is called', async (_action, cancel) => {
const service = getVoiceConversationService()
await service.startSession()
const response = service.sendTextMessage('cancel me')
await vi.waitFor(() => expect(mocks.chatStream).toHaveBeenCalledTimes(1))
const options = mocks.chatStream.mock.calls[0][1] as ChatOptions
cancel(service)
expect(options.signal?.aborted).toBe(true)
await response
})
it('sets bounded local chat options for voice responses', async () => {
const service = getVoiceConversationService()
await service.startSession()
const response = service.sendTextMessage('options')
await vi.waitFor(() => expect(mocks.chatStream).toHaveBeenCalledTimes(1))
expect(mocks.chatStream).toHaveBeenCalledWith(
expect.any(Array),
expect.objectContaining({
signal: expect.any(AbortSignal),
maxTokens: 512,
timeoutMs: 60_000,
}),
)
service.stopSession()
await response
})
it('does not publish late assistant output or start TTS after cancellation', async () => {
let releaseLateToken: (() => void) | undefined
const lateToken = new Promise<void>((resolve) => {
releaseLateToken = resolve
})
mocks.chatStream.mockImplementation(() => (async function* (): AsyncGenerator<string, string> {
await lateToken
yield 'late answer.'
return 'late answer.'
})())
const service = getVoiceConversationService()
await service.startSession()
const response = service.sendTextMessage('cancel before response')
await vi.waitFor(() => expect(mocks.chatStream).toHaveBeenCalledTimes(1))
service.cancelResponse()
mocks.send.mockClear()
releaseLateToken?.()
await response
const lateConversationEvents = mocks.send.mock.calls.filter(([channel]) => (
channel === IPC_CHANNELS.VOICE_CONVERSATION.ASSISTANT_DELTA
|| channel === IPC_CHANNELS.VOICE_CONVERSATION.ASSISTANT_MESSAGE
|| channel === IPC_CHANNELS.VOICE_CONVERSATION.TTS_STARTED
|| channel === IPC_CHANNELS.VOICE_CONVERSATION.TTS_FINISHED
))
expect(lateConversationEvents).toEqual([])
expect(mocks.speakSentences).not.toHaveBeenCalled()
expect(service.getHistory().map((message) => message.content)).toEqual(['cancel before response'])
})
it('cancelResponse_followedImmediatelyBySendTextMessage_startsNewTurnWithoutConflict', async () => {
let releaseFirstStream: (() => void) | undefined
mocks.chatStream
.mockImplementationOnce(() => (async function* (): AsyncGenerator<string, string> {
await new Promise<void>((resolve) => {
releaseFirstStream = resolve
})
return ''
})())
.mockImplementationOnce(() => (async function* (): AsyncGenerator<string, string> {
yield 'second reply.'
return 'second reply.'
})())
const service = getVoiceConversationService()
await service.startSession()
const firstResponse = service.sendTextMessage('first question')
await vi.waitFor(() => expect(mocks.chatStream).toHaveBeenCalledTimes(1))
service.cancelResponse()
const secondResponse = service.sendTextMessage('second question')
releaseFirstStream?.()
await expect(secondResponse).resolves.toBeUndefined()
await firstResponse
expect(mocks.chatStream).toHaveBeenCalledTimes(2)
expect(service.getHistory().map((m) => m.content)).toEqual([
'first question',
'second question',
'second reply.',
])
})
it('startSession_audioStartRejectsAfterStop_doesNotEmitSttErrorOrClobberNewSessionMic', async () => {
let rejectFirstMic!: (err: Error) => void
mocks.audioStart
.mockImplementationOnce(() => new Promise<void>((_resolve, reject) => {
rejectFirstMic = reject
}))
.mockImplementationOnce(async () => undefined)
const service = getVoiceConversationService()
const errorEvents: Array<{ phase: string; message: string }> = []
service.on('error', (payload) => errorEvents.push(payload))
await service.startSession()
service.stopSession()
await service.startSession()
rejectFirstMic(new Error('stale mic failure'))
await new Promise((r) => setTimeout(r, 0))
expect(errorEvents).toEqual([])
expect(mocks.send.mock.calls.filter(([channel]) => channel === IPC_CHANNELS.VOICE_CONVERSATION.ERROR)).toEqual([])
service.stopSession()
expect(mocks.audioStop).toHaveBeenCalledTimes(2)
})
})