d3ro-voice/apps/mobile-rn/__tests__/history-detail-unmount-regression.test.tsx
Yun Chan 8d8aaf5794 feat(mobile): share history as Markdown or original audio and harden the E2E gate
Adds history share (Markdown file / original audio) with 12-locale strings, pins Maestro to
the target device with --udid, allows cleartext only for explicit local E2E artifacts, and
fixes small-screen scroll/keyboard races in the Maestro flows.
Evidence: docs/evidence/2026-11-17-backlog-operations.md.
2026-11-20 15:16:13 +09:00

291 lines
9.7 KiB
TypeScript

import React from 'react'
import { act, create, type ReactTestRenderer } from 'react-test-renderer'
import type { HistoryDetail } from '../src/features/history/history-service'
const USER_ID = '11111111-1111-4111-8111-111111111111'
const HISTORY_ID = '22222222-2222-4222-8222-222222222222'
const AUDIO_ID = '33333333-3333-4333-8333-333333333333'
const mockStartPlayer = jest.fn(async () => 'started')
const mockStopPlayer = jest.fn(async () => 'stopped')
const mockPausePlayer = jest.fn(async () => 'paused')
const mockResumePlayer = jest.fn(async () => 'resumed')
const mockGetHistoryDetail = jest.fn<Promise<HistoryDetail>, [string, string]>()
const mockCreateAudioPlaybackUrl = jest.fn<Promise<string>, [string, unknown]>()
const mockGoBack = jest.fn()
const mockT = (key: string): string => key
const mockFormatDate = (): string => '2026-11-14'
const mockAuthValue = { user: { id: USER_ID } }
const { d3roNativeDarkPalette } = jest.requireActual('@d3ro/ui-native') as typeof import('@d3ro/ui-native')
const mockPreferencesValue = { palette: d3roNativeDarkPalette }
jest.mock('react-native-safe-area-context', () => ({
useSafeAreaInsets: () => ({ top: 0, bottom: 0, left: 0, right: 0 }),
}))
jest.mock('react-native-nitro-sound', () => ({
useSoundWithStates: () => ({
state: {
isPlaying: false,
playback: { position: 0, duration: 1_000 },
},
startPlayer: () => mockStartPlayer(),
stopPlayer: () => mockStopPlayer(),
pausePlayer: () => mockPausePlayer(),
resumePlayer: () => mockResumePlayer(),
}),
}))
jest.mock('@d3ro/i18n', () => ({
useI18n: () => ({
t: mockT,
formatDate: mockFormatDate,
}),
}))
jest.mock('../src/lib/auth-context', () => ({
useAuth: () => mockAuthValue,
}))
jest.mock('../src/lib/preferences-context', () => ({
useMobilePreferences: () => mockPreferencesValue,
}))
jest.mock('../src/features/history/history-cache', () => ({
loadHistoryCache: jest.fn(async () => null),
}))
jest.mock('../src/features/history/history-service', () => {
class MockHistoryServiceError extends Error {
code: string
constructor(code: string, message: string) {
super(message)
this.code = code
}
}
return {
HistoryServiceError: MockHistoryServiceError,
getHistoryDetail: (userId: string, historyId: string) => mockGetHistoryDetail(userId, historyId),
createAudioPlaybackUrl: (userId: string, audioFile: unknown) =>
mockCreateAudioPlaybackUrl(userId, audioFile),
updateHistoryRevisionSafe: jest.fn(),
deleteHistoryRevisionSafe: jest.fn(),
}
})
const mockPrepareTranscriptShareFile = jest.fn()
const mockPrepareAudioShareFile = jest.fn()
const mockSharePreparedPortableFile = jest.fn()
const mockDisposePreparedFile = jest.fn(async () => undefined)
const PREPARED_FILE = {
path: '/cache/portable_exports/transcript.md',
uri: 'file:///cache/portable_exports/transcript.md',
fileName: 'transcript.md',
mimeType: 'text/markdown',
format: 'md',
textContent: 'transcript',
dispose: mockDisposePreparedFile,
}
jest.mock('../src/features/history/history-share', () => ({
prepareTranscriptShareFile: (...args: unknown[]) => mockPrepareTranscriptShareFile(...args),
prepareAudioShareFile: (...args: unknown[]) => mockPrepareAudioShareFile(...args),
}))
jest.mock('../src/features/data-portability/portable-file', () => ({
sharePreparedPortableFile: (...args: unknown[]) => mockSharePreparedPortableFile(...args),
}))
import HistoryDetailScreen from '../src/screens/HistoryDetailScreen'
const SAMPLE_DETAIL: HistoryDetail = {
entry: {
id: HISTORY_ID,
user_id: USER_ID,
title: 'Sample Memo',
original_text: 'Original transcript',
polished_text: 'Polished transcript',
focused_app: null,
focused_app_name: null,
focused_app_window_title: null,
mode: 'dictation',
status: 'completed',
error_code: null,
audio_storage_key: 'audio/sample.wav',
duration: 12,
detected_language: 'ko',
mic_device: null,
word_count: 2,
stt_model: 'whisper',
llm_model: null,
stt_latency_ms: null,
llm_latency_ms: null,
app_version: '1.16.5',
summary_text: null,
is_favorite: false,
revision: 1,
created_at: '2026-11-14T00:00:00.000Z',
updated_at: '2026-11-14T00:00:00.000Z',
},
audioFiles: [
{
id: AUDIO_ID,
user_id: USER_ID,
history_id: HISTORY_ID,
meeting_id: null,
storage_bucket: 'audio-files',
storage_key: 'audio/sample.wav',
original_name: 'sample.wav',
mime_type: 'audio/wav',
size_bytes: 2048,
duration_ms: 12_000,
checksum_sha256: 'abc',
upload_status: 'uploaded',
retention_until: null,
created_at: '2026-11-14T00:00:00.000Z',
updated_at: '2026-11-14T00:00:00.000Z',
},
],
jobs: [],
}
describe('HistoryDetailScreen unmount audio & async cleanup', () => {
beforeEach(() => {
mockStartPlayer.mockClear()
mockStopPlayer.mockClear()
mockPausePlayer.mockClear()
mockResumePlayer.mockClear()
mockGetHistoryDetail.mockReset().mockResolvedValue(SAMPLE_DETAIL)
mockCreateAudioPlaybackUrl.mockReset().mockResolvedValue('https://storage.example/signed.wav')
mockPrepareTranscriptShareFile.mockReset().mockResolvedValue(PREPARED_FILE)
mockPrepareAudioShareFile.mockReset().mockResolvedValue(PREPARED_FILE)
mockSharePreparedPortableFile.mockReset().mockResolvedValue(undefined)
mockDisposePreparedFile.mockClear()
mockGoBack.mockClear()
})
test('HistoryDetailScreen_언마운트시_플레이어를중지하고진행중URL응답후재생을시작하지않음', async () => {
let resolveSignedUrl: (url: string) => void = () => undefined
mockCreateAudioPlaybackUrl.mockImplementation(
() => new Promise<string>((resolve) => {
resolveSignedUrl = resolve
}),
)
let renderer!: ReactTestRenderer
await act(async () => {
renderer = create(
<HistoryDetailScreen
route={{
key: 'HistoryDetail-1',
name: 'HistoryDetail',
params: { historyId: HISTORY_ID },
}}
navigation={{ goBack: mockGoBack } as never}
/>,
)
await Promise.resolve()
await Promise.resolve()
})
const audioRow = renderer.root.findByProps({ testID: `history-audio-${AUDIO_ID}` })
const playButton = audioRow.findAll(
(node) => typeof node.props.onPress === 'function'
&& node.props.accessibilityLabel === 'mobile.hist.audioPlay',
)[0]
await act(async () => {
playButton.props.onPress()
await Promise.resolve()
})
expect(mockCreateAudioPlaybackUrl).toHaveBeenCalledTimes(1)
act(() => {
renderer.unmount()
})
expect(mockStopPlayer).toHaveBeenCalledTimes(1)
await act(async () => {
resolveSignedUrl('https://storage.example/signed.wav')
await Promise.resolve()
})
expect(mockStartPlayer).not.toHaveBeenCalled()
})
test('HistoryDetailScreen_Markdown버튼_파일생성및공유호출', async () => {
let renderer!: ReactTestRenderer
await act(async () => {
renderer = create(
<HistoryDetailScreen
route={{ key: 'HistoryDetail-2', name: 'HistoryDetail', params: { historyId: HISTORY_ID } }}
navigation={{ goBack: mockGoBack } as never}
/>,
)
})
await act(async () => {
renderer.root.findByProps({ testID: 'history-detail-share-markdown' }).props.onPress()
await Promise.resolve()
})
expect(mockPrepareTranscriptShareFile).toHaveBeenCalledWith(
SAMPLE_DETAIL.entry,
'md',
'mobile.hist.summaryLabel',
)
expect(mockSharePreparedPortableFile).toHaveBeenCalledWith(PREPARED_FILE, 'mobile.hist.shareMarkdown')
act(() => renderer.unmount())
})
test('HistoryDetailScreen_원본오디오버튼_서명URL다운로드후공유', async () => {
let renderer!: ReactTestRenderer
await act(async () => {
renderer = create(
<HistoryDetailScreen
route={{ key: 'HistoryDetail-3', name: 'HistoryDetail', params: { historyId: HISTORY_ID } }}
navigation={{ goBack: mockGoBack } as never}
/>,
)
})
await act(async () => {
renderer.root.findByProps({ testID: `history-audio-share-${AUDIO_ID}` }).props.onPress()
await Promise.resolve()
})
expect(mockCreateAudioPlaybackUrl).toHaveBeenCalledWith(USER_ID, SAMPLE_DETAIL.audioFiles[0])
expect(mockPrepareAudioShareFile).toHaveBeenCalledWith(
SAMPLE_DETAIL.audioFiles[0],
'https://storage.example/signed.wav',
)
expect(mockSharePreparedPortableFile).toHaveBeenCalledWith(PREPARED_FILE, 'mobile.hist.shareAudio')
act(() => renderer.unmount())
})
test('HistoryDetailScreen_공유준비중언마운트_늦은공유시트를열지않고파일정리', async () => {
let resolvePreparation: (file: typeof PREPARED_FILE) => void = () => undefined
mockPrepareAudioShareFile.mockImplementation(
() => new Promise<typeof PREPARED_FILE>((resolve) => {
resolvePreparation = resolve
}),
)
let renderer!: ReactTestRenderer
await act(async () => {
renderer = create(
<HistoryDetailScreen
route={{ key: 'HistoryDetail-4', name: 'HistoryDetail', params: { historyId: HISTORY_ID } }}
navigation={{ goBack: mockGoBack } as never}
/>,
)
})
await act(async () => {
renderer.root.findByProps({ testID: `history-audio-share-${AUDIO_ID}` }).props.onPress()
await Promise.resolve()
})
act(() => renderer.unmount())
await act(async () => {
resolvePreparation(PREPARED_FILE)
await Promise.resolve()
})
expect(mockSharePreparedPortableFile).not.toHaveBeenCalled()
expect(mockDisposePreparedFile).toHaveBeenCalledTimes(1)
})
})