d3ro-voice/apps/mobile-rn/__tests__/talk-locale-recorder-regression.test.tsx

217 lines
6.9 KiB
TypeScript

import React from 'react'
import { act, create, type ReactTestInstance, type ReactTestRenderer } from 'react-test-renderer'
import type { Locale } from '@d3ro/i18n/shared'
const USER_ID = '11111111-1111-4111-8111-111111111111'
let mockLocale: Locale = 'fr'
let mockGreeting = 'Bonjour greeting'
const mockAcquire = jest.fn()
const mockRequestPermission = jest.fn(async () => false)
const mockSpeakTalkText = jest.fn(async () => ({ status: 'completed' }))
const mockStopTalkSpeech = jest.fn(async () => true)
const mockShutdownTalkSpeech = jest.fn(async () => undefined)
const mockStreamTalkResponse = jest.fn()
jest.mock('@react-navigation/native', () => {
const ReactValue = require('react') as typeof React
return {
useNavigation: () => ({ goBack: jest.fn() }),
useFocusEffect: (effect: () => void | (() => void)) => {
ReactValue.useEffect(effect, [effect])
},
}
})
jest.mock('react-native-safe-area-context', () => ({
useSafeAreaInsets: () => ({ top: 0, bottom: 0, left: 0, right: 0 }),
}))
jest.mock('@d3ro/i18n', () => ({
useI18n: () => ({
t: (key: string) => (key === 'mobile.talk.greeting' ? mockGreeting : key),
}),
}))
jest.mock('../src/lib/auth-context', () => ({
useAuth: () => ({ session: { user: { id: USER_ID }, access_token: 'tok-1' } }),
}))
jest.mock('../src/lib/preferences-context', () => ({
useMobilePreferences: () => ({
palette: {
bg: { app: 'app', sidebar: 'sidebar', card: 'card', inset: 'inset' },
text: { primary: 'primary', muted: 'muted' },
border: { default: 'border' },
accent: { main: 'accent', dim: 'dim', pressed: 'pressed' },
tag: { red: 'red' },
},
preferences: { preferredLlmModel: 'default', locale: mockLocale },
}),
}))
jest.mock('../src/theme/themed-components', () => {
const { Pressable, Text } = require('react-native') as typeof import('react-native')
return {
ThemeText: ({ children, ...props }: React.PropsWithChildren<Record<string, unknown>>) => (
<Text {...props}>{children}</Text>
),
ThemeButton: ({ label, onPress, ...props }: { label: string; onPress?: () => void }) => (
<Pressable {...props} onPress={onPress}>
<Text>{label}</Text>
</Pressable>
),
}
})
jest.mock('../src/components/ContentReportSheet', () => ({
__esModule: true,
default: () => null,
}))
jest.mock('../src/features/chat/chat-service', () => {
class MockChatServiceError extends Error {
code: string
retryable: boolean
constructor(mockCode: string, mockRetryable: boolean) {
super(mockCode)
this.code = mockCode
this.retryable = mockRetryable
}
}
return { ChatServiceError: MockChatServiceError }
})
jest.mock('../src/features/talk/llm-stream-service', () => ({
streamTalkResponse: (...args: unknown[]) => mockStreamTalkResponse(...args),
}))
jest.mock('../src/features/talk/talk-transcription-service', () => ({
transcribeTalkRecording: jest.fn(),
}))
jest.mock('../src/features/talk/talk-tts', () => {
class MockTalkTtsError extends Error {
code = 'FAILED'
}
return {
shutdownTalkSpeech: () => mockShutdownTalkSpeech(),
speakTalkText: (...args: unknown[]) => mockSpeakTalkText(...args),
stopTalkSpeech: () => mockStopTalkSpeech(),
TalkTtsError: MockTalkTtsError,
}
})
jest.mock('../src/features/talk/talk-debug-audio', () => ({
isDeterministicTalkAudioAvailable: () => false,
synthesizeDeterministicTalkAudio: jest.fn(),
}))
jest.mock('../src/lib/audio-recorder', () => {
class MockRecorderBusyError extends Error {
code = 'recorder_busy'
holder = 'record'
}
return {
RecorderBusyError: MockRecorderBusyError,
audioRecorder: {
acquire: (...args: unknown[]) => mockAcquire(...args),
requestPermission: () => mockRequestPermission(),
},
}
})
import TalkScreen from '../src/screens/TalkScreen'
function byTestId(root: ReactTestInstance, testID: string, prop: string): ReactTestInstance {
const match = root.findAll(
(node) => node.props.testID === testID && typeof node.props[prop] === 'function',
)[0]
if (match === undefined) throw new Error(`Missing ${testID} with ${prop}`)
return match
}
function allText(root: ReactTestInstance): string {
return root.findAll((node) => typeof node.props.children === 'string')
.map((node) => node.props.children as string)
.join('\n')
}
async function flush(): Promise<void> {
for (let index = 0; index < 5; index += 1) {
await act(async () => {
await Promise.resolve()
})
}
}
describe('TalkScreen locale speech & recorder lease cleanup', () => {
let renderer: ReactTestRenderer | null = null
beforeEach(() => {
mockLocale = 'fr'
mockGreeting = 'Bonjour greeting'
mockAcquire.mockReset()
mockRequestPermission.mockReset().mockResolvedValue(false)
mockSpeakTalkText.mockReset().mockResolvedValue({ status: 'completed' })
mockStopTalkSpeech.mockReset().mockResolvedValue(true)
mockShutdownTalkSpeech.mockReset().mockResolvedValue(undefined)
mockStreamTalkResponse.mockReset()
})
afterEach(() => {
if (renderer !== null) {
act(() => renderer!.unmount())
renderer = null
}
})
test('beginRecording_마이크권한거부시_획득한녹음세션을즉시취소하여잠금해제', async () => {
const cancelSession = jest.fn(async () => undefined)
mockAcquire.mockResolvedValue({
start: jest.fn(),
stop: jest.fn(),
cancel: cancelSession,
cleanup: jest.fn(),
})
await act(async () => {
renderer = create(<TalkScreen />)
})
await act(async () => {
byTestId(renderer!.root, 'talk-ptt', 'onPressIn').props.onPressIn()
})
await flush()
expect(cancelSession).toHaveBeenCalledTimes(1)
expect(allText(renderer!.root)).toContain('mobile.talk.error.micPermission')
})
test('TalkScreen_12개지원로케일전환및음성재생시_해당BCP47태그와인사말을동기화', async () => {
mockStreamTalkResponse.mockResolvedValue({ text: 'Réponse vocale', generationId: 'gen-fr-1' })
await act(async () => {
renderer = create(<TalkScreen />)
})
expect(allText(renderer!.root)).toContain('Bonjour greeting')
mockLocale = 'ja'
mockGreeting = 'こんにちは greeting'
await act(async () => {
renderer!.update(<TalkScreen />)
})
expect(allText(renderer!.root)).toContain('こんにちは greeting')
await act(async () => {
byTestId(renderer!.root, 'talk-input', 'onChangeText').props.onChangeText('Test question')
})
await act(async () => {
byTestId(renderer!.root, 'talk-send', 'onPress').props.onPress()
})
await flush()
const speechButton = renderer!.root.findAll(
(node) => typeof node.props.testID === 'string' && node.props.testID.startsWith('talk-speech-'),
)[0]
await act(async () => {
speechButton.props.onPress()
})
await flush()
expect(mockSpeakTalkText).toHaveBeenCalledWith(
expect.objectContaining({
text: 'Réponse vocale',
languageTag: 'ja',
}),
)
})
})