217 lines
6.9 KiB
TypeScript
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',
|
|
}),
|
|
)
|
|
})
|
|
})
|