832 lines
27 KiB
TypeScript
832 lines
27 KiB
TypeScript
import React from 'react'
|
|
import { TextInput } from 'react-native'
|
|
import { act, create, type ReactTestRenderer } from 'react-test-renderer'
|
|
import type { Meeting } from '@d3ro/api-client'
|
|
import { AudioPipelineError, type LocalAudioInput } from '../src/features/import/audio-import-types'
|
|
import { CommandSyncError, type SyncedCommand } from '../src/features/commands/command-service'
|
|
import type { HistoryDetail } from '../src/features/history/history-service'
|
|
import type { MobileDashboardStats } from '../src/features/dashboard/dashboard-service'
|
|
|
|
const USER_A = '11111111-1111-4111-8111-111111111111'
|
|
const USER_B = '22222222-2222-4222-8222-222222222222'
|
|
const MEETING_ID_1 = '33333333-3333-4333-8333-333333333333'
|
|
const MEETING_ID_2 = '44444444-4444-4444-8444-444444444444'
|
|
const HISTORY_ID = '55555555-5555-4555-8555-555555555555'
|
|
const AUDIO_ID = '66666666-6666-4666-8666-666666666666'
|
|
const AUDIO_ID_2 = '66666666-6666-4666-8666-666666666667'
|
|
const COMMAND_ID = '77777777-7777-4777-8777-777777777777'
|
|
const TEAM_ID = '88888888-8888-4888-8888-888888888888'
|
|
|
|
let mockCurrentUser: { id: string; email?: string } | null = { id: USER_A, email: 'a@example.com' }
|
|
const mockSession = { access_token: 'access-token' }
|
|
const mockNavigate = jest.fn()
|
|
const mockGoBack = jest.fn()
|
|
const mockNavigation = {
|
|
navigate: mockNavigate,
|
|
goBack: mockGoBack,
|
|
getParent: () => undefined,
|
|
}
|
|
const mockSafeInsets = { top: 0, bottom: 0, left: 0, right: 0 }
|
|
const mockI18nValue = {
|
|
t: (key: string) => key,
|
|
locale: 'ko',
|
|
formatDate: () => '2026-08-21',
|
|
formatRelativeDate: () => 'today',
|
|
formatTime: () => '10:00',
|
|
}
|
|
const mockRefreshEntitlement = jest.fn(async () => null)
|
|
const mockEntitlementValue = {
|
|
refresh: mockRefreshEntitlement,
|
|
snapshot: { tier: 'free', adFree: false, overageCredits: 0 },
|
|
}
|
|
const { d3roNativeDarkPalette } = jest.requireActual('@d3ro/ui-native') as typeof import('@d3ro/ui-native')
|
|
const mockPreferencesValue = {
|
|
palette: d3roNativeDarkPalette,
|
|
preferences: { preferredLlmModel: 'claude-haiku-4-5-20251001' },
|
|
}
|
|
|
|
const mockLoadDashboardStats = jest.fn<Promise<MobileDashboardStats>, [string]>()
|
|
const mockListMeetingsPage = jest.fn()
|
|
const mockListKnowledgeDocuments = jest.fn()
|
|
const mockConsumeIncomingMediaAudio = jest.fn<Promise<LocalAudioInput | null>, []>()
|
|
const mockEnqueueAudioProcessing = jest.fn()
|
|
const mockProcessQueuedAudioNow = jest.fn()
|
|
const mockGetHistoryDetail = jest.fn<Promise<HistoryDetail>, [string, string]>()
|
|
const mockCreateAudioPlaybackUrl = jest.fn<Promise<string>, [string, unknown]>()
|
|
const mockStartPlayer = jest.fn(async () => 'started')
|
|
const mockStopPlayer = jest.fn(async () => 'stopped')
|
|
const mockLoadSyncedCommandCatalog = jest.fn()
|
|
const mockCreateSyncedCommand = jest.fn()
|
|
const mockListTeams = jest.fn()
|
|
const mockCreateTeam = jest.fn()
|
|
|
|
jest.mock('@react-navigation/native', () => {
|
|
const ReactValue = require('react') as typeof React
|
|
return {
|
|
useNavigation: () => mockNavigation,
|
|
useFocusEffect: (callback: () => void | (() => void)) => {
|
|
ReactValue.useEffect(callback, [callback])
|
|
},
|
|
}
|
|
})
|
|
jest.mock('react-native-safe-area-context', () => ({
|
|
useSafeAreaInsets: () => mockSafeInsets,
|
|
}))
|
|
jest.mock('../src/navigation/tab-layout', () => ({
|
|
useTabScreenBottomPadding: () => 88,
|
|
}))
|
|
jest.mock('@d3ro/i18n', () => ({
|
|
useI18n: () => mockI18nValue,
|
|
}))
|
|
jest.mock('../src/lib/auth-context', () => ({
|
|
useAuth: () => ({
|
|
user: mockCurrentUser,
|
|
session: mockSession,
|
|
loading: false,
|
|
}),
|
|
}))
|
|
jest.mock('../src/lib/entitlement-context', () => ({
|
|
useEntitlement: () => mockEntitlementValue,
|
|
}))
|
|
jest.mock('../src/lib/preferences-context', () => ({
|
|
useMobilePreferences: () => mockPreferencesValue,
|
|
}))
|
|
jest.mock('../src/lib/supabase', () => ({
|
|
supabase: {
|
|
channel: jest.fn(() => ({
|
|
on: jest.fn().mockReturnThis(),
|
|
subscribe: jest.fn().mockReturnThis(),
|
|
})),
|
|
removeChannel: jest.fn(async () => 'ok'),
|
|
},
|
|
}))
|
|
jest.mock('../src/components/ScreenHeader', () => ({
|
|
ScreenHeader: ({ rightContent }: { rightContent?: React.ReactNode }) => rightContent ?? null,
|
|
}))
|
|
jest.mock('../src/components/ContentReportSheet', () => () => null)
|
|
jest.mock('../src/features/dashboard/dashboard-service', () => ({
|
|
loadDashboardStats: (userId: string) => mockLoadDashboardStats(userId),
|
|
}))
|
|
jest.mock('../src/features/meetings/meetings-service', () => {
|
|
class MockMeetingServiceError extends Error {
|
|
code: string
|
|
constructor(code: string, message: string) {
|
|
super(message)
|
|
this.code = code
|
|
}
|
|
}
|
|
return {
|
|
MeetingServiceError: MockMeetingServiceError,
|
|
createMeetingCreationIdempotencyKey: () => 'cccccccc-cccc-4ccc-8ccc-cccccccccccc',
|
|
createMeetingWorkspaceWithMetadata: jest.fn(),
|
|
listMeetingsPage: (opts: unknown) => mockListMeetingsPage(opts),
|
|
updateMeetingTitleRevisionSafe: jest.fn(),
|
|
deleteMeetingRevisionSafe: jest.fn(),
|
|
beginMeetingRecording: jest.fn(async () => ({})),
|
|
cancelMeetingRecording: jest.fn(async () => ({})),
|
|
failMeetingRecording: jest.fn(async () => ({})),
|
|
getMeetingRecordingLanguage: jest.fn(async () => 'ko'),
|
|
}
|
|
})
|
|
jest.mock('../src/features/templates', () => ({
|
|
loadTemplateLibrary: jest.fn(async () => ({ templates: [], selections: {} })),
|
|
}))
|
|
jest.mock('../src/features/knowledge/knowledge-service', () => {
|
|
class MockKnowledgeServiceError extends Error {
|
|
code: string
|
|
constructor(code: string, message: string) {
|
|
super(message)
|
|
this.code = code
|
|
}
|
|
}
|
|
return {
|
|
KnowledgeServiceError: MockKnowledgeServiceError,
|
|
createKnowledgeDocument: jest.fn(),
|
|
deleteKnowledgeDocument: jest.fn(),
|
|
indexKnowledgeDocument: jest.fn(),
|
|
listKnowledgeDocuments: (opts: unknown) => mockListKnowledgeDocuments(opts),
|
|
mergeKnowledgeDocuments: (current: unknown[], next: unknown[]) => [...current, ...next],
|
|
searchKnowledge: jest.fn(),
|
|
subscribeToKnowledgeDocuments: () => ({ unsubscribe: async () => undefined }),
|
|
}
|
|
})
|
|
jest.mock('../src/features/knowledge/knowledge-file-picker', () => ({
|
|
pickKnowledgeFile: jest.fn(),
|
|
}))
|
|
jest.mock('../src/features/import/incoming-media-intent', () => ({
|
|
consumeIncomingMediaAudio: () => mockConsumeIncomingMediaAudio(),
|
|
}))
|
|
jest.mock('../src/features/import/audio-validation', () => ({
|
|
validateLocalAudio: jest.fn(),
|
|
}))
|
|
jest.mock('../src/features/import/audio-file-picker', () => ({
|
|
pickAudioFile: jest.fn(),
|
|
}))
|
|
jest.mock('../src/features/notifications/notification-native', () => ({
|
|
showLocalTranscriptionCompleted: jest.fn(async () => true),
|
|
}))
|
|
jest.mock('../src/lib/audio-recorder', () => ({
|
|
RecorderBusyError: class extends Error {},
|
|
audioRecorder: {
|
|
acquire: async () => ({
|
|
restore: async () => ({ state: 'idle', recording: null, meetingId: null, interruptionReason: null }),
|
|
start: jest.fn(async () => undefined),
|
|
stop: jest.fn(),
|
|
cleanup: jest.fn(async () => undefined),
|
|
cancel: jest.fn(async () => undefined),
|
|
pause: jest.fn(async () => undefined),
|
|
resume: jest.fn(async () => undefined),
|
|
}),
|
|
requestPermission: async () => true,
|
|
},
|
|
}))
|
|
jest.mock('../src/features/recording/durable-processing-queue', () => ({
|
|
discardQueuedAudio: jest.fn(async () => undefined),
|
|
enqueueAudioProcessing: (...args: unknown[]) => mockEnqueueAudioProcessing(...args),
|
|
processQueuedAudioNow: (...args: unknown[]) => mockProcessQueuedAudioNow(...args),
|
|
QueuedAudioPendingError: class extends Error { item = { id: 'q-1' } },
|
|
retryQueuedAudio: jest.fn(async () => undefined),
|
|
subscribeToDurableQueue: () => () => undefined,
|
|
}))
|
|
jest.mock('react-native-nitro-sound', () => ({
|
|
useSoundWithStates: () => ({
|
|
state: { isPlaying: false, playback: { position: 0, duration: 1_000 } },
|
|
startPlayer: () => mockStartPlayer(),
|
|
stopPlayer: () => mockStopPlayer(),
|
|
pausePlayer: jest.fn(async () => 'paused'),
|
|
resumePlayer: jest.fn(async () => 'resumed'),
|
|
}),
|
|
}))
|
|
jest.mock('../src/features/history/history-cache', () => ({
|
|
loadHistoryCache: jest.fn(async () => null),
|
|
}))
|
|
jest.mock('../src/features/history/history-service', () => ({
|
|
HistoryServiceError: class extends Error {
|
|
code: string
|
|
constructor(code: string, message: string) {
|
|
super(message)
|
|
this.code = code
|
|
}
|
|
},
|
|
getHistoryDetail: (userId: string, historyId: string) => mockGetHistoryDetail(userId, historyId),
|
|
createAudioPlaybackUrl: (userId: string, audioFile: unknown) => (
|
|
mockCreateAudioPlaybackUrl(userId, audioFile)
|
|
),
|
|
updateHistoryRevisionSafe: jest.fn(),
|
|
deleteHistoryRevisionSafe: jest.fn(),
|
|
}))
|
|
jest.mock('../src/features/commands/command-service', () => {
|
|
class MockCommandSyncError extends Error {
|
|
code: string
|
|
constructor(code: string, message: string) {
|
|
super(message)
|
|
this.code = code
|
|
}
|
|
}
|
|
return {
|
|
COMMAND_INPUT_MAX_CHARS: 4000,
|
|
CommandExecutionError: class extends Error {
|
|
code: string
|
|
retryable: boolean
|
|
constructor(code: string, retryable = false) {
|
|
super(code)
|
|
this.code = code
|
|
this.retryable = retryable
|
|
}
|
|
},
|
|
CommandSyncError: MockCommandSyncError,
|
|
createSyncedCommand: (...args: unknown[]) => mockCreateSyncedCommand(...args),
|
|
deleteSyncedCommand: jest.fn(),
|
|
executeSyncedCommand: jest.fn(),
|
|
loadSyncedCommandCatalog: (...args: unknown[]) => mockLoadSyncedCommandCatalog(...args),
|
|
reorderSyncedCommand: jest.fn(),
|
|
setActiveSyncedCommand: jest.fn(),
|
|
updateSyncedCommand: jest.fn(),
|
|
}
|
|
})
|
|
jest.mock('../src/features/teams/team-service', () => {
|
|
class MockTeamServiceError extends Error {
|
|
code: string
|
|
constructor(code: string, message: string) {
|
|
super(message)
|
|
this.code = code
|
|
}
|
|
}
|
|
return {
|
|
TeamServiceError: MockTeamServiceError,
|
|
listTeams: (...args: unknown[]) => mockListTeams(...args),
|
|
createTeam: (...args: unknown[]) => mockCreateTeam(...args),
|
|
}
|
|
})
|
|
|
|
import HomeScreen from '../src/screens/HomeScreen'
|
|
import MeetingsScreen from '../src/screens/MeetingsScreen'
|
|
import KnowledgeScreen from '../src/screens/KnowledgeScreen'
|
|
import RecordScreen from '../src/screens/RecordScreen'
|
|
import HistoryDetailScreen from '../src/screens/HistoryDetailScreen'
|
|
import CommandsScreen from '../src/screens/CommandsScreen'
|
|
import TeamsScreen from '../src/screens/TeamsScreen'
|
|
|
|
function deferred<T>() {
|
|
let resolve: (value: T) => void = () => undefined
|
|
let reject: (reason?: unknown) => void = () => undefined
|
|
const promise = new Promise<T>((res, rej) => {
|
|
resolve = res
|
|
reject = rej
|
|
})
|
|
return { promise, resolve, reject }
|
|
}
|
|
|
|
async function flush(): Promise<void> {
|
|
for (let index = 0; index < 8; index += 1) await Promise.resolve()
|
|
}
|
|
|
|
function findHostByTestId(renderer: ReactTestRenderer, testID: string) {
|
|
return renderer.root.findAll(
|
|
(node) => typeof node.type === 'string' && node.props.testID === testID,
|
|
)
|
|
}
|
|
|
|
function makeMeeting(id: string, title: string, userId = USER_A): Meeting {
|
|
return {
|
|
id,
|
|
user_id: userId,
|
|
team_id: null,
|
|
title,
|
|
status: 'completed',
|
|
started_at: '2026-08-21T00:00:00.000Z',
|
|
ended_at: '2026-08-21T00:05:00.000Z',
|
|
duration_ms: 300_000,
|
|
raw_transcript: 'transcript',
|
|
edited_transcript: null,
|
|
minutes_markdown: null,
|
|
minutes_json: null,
|
|
stt_model: null,
|
|
llm_model: null,
|
|
stt_latency_ms: null,
|
|
llm_latency_ms: null,
|
|
error_message: null,
|
|
audio_storage_key: null,
|
|
language: 'ko',
|
|
attendees: [],
|
|
template_id: null,
|
|
creation_idempotency_key: null,
|
|
creation_request_hash: null,
|
|
created_at: '2026-08-21T00:00:00.000Z',
|
|
updated_at: '2026-08-21T00:05:00.000Z',
|
|
}
|
|
}
|
|
|
|
describe('screen async lifecycle and race guards', () => {
|
|
let activeRenderer: ReactTestRenderer | null = null
|
|
|
|
beforeEach(() => {
|
|
mockCurrentUser = { id: USER_A, email: 'a@example.com' }
|
|
mockNavigate.mockReset()
|
|
mockGoBack.mockReset()
|
|
mockRefreshEntitlement.mockClear()
|
|
mockLoadDashboardStats.mockReset()
|
|
mockListMeetingsPage.mockReset()
|
|
mockListKnowledgeDocuments.mockReset()
|
|
mockConsumeIncomingMediaAudio.mockReset()
|
|
mockEnqueueAudioProcessing.mockReset()
|
|
mockProcessQueuedAudioNow.mockReset()
|
|
mockGetHistoryDetail.mockReset()
|
|
mockCreateAudioPlaybackUrl.mockReset()
|
|
mockStartPlayer.mockClear()
|
|
mockStopPlayer.mockClear()
|
|
mockLoadSyncedCommandCatalog.mockReset()
|
|
mockCreateSyncedCommand.mockReset()
|
|
mockListTeams.mockReset()
|
|
mockCreateTeam.mockReset()
|
|
})
|
|
|
|
afterEach(() => {
|
|
if (activeRenderer !== null) {
|
|
const target = activeRenderer
|
|
activeRenderer = null
|
|
act(() => target.unmount())
|
|
}
|
|
jest.restoreAllMocks()
|
|
jest.clearAllTimers()
|
|
jest.useRealTimers()
|
|
})
|
|
|
|
test('HomeScreen_새로고침중계정변경시_이전계정응답으로화면을덮어쓰지않음', async () => {
|
|
const statsA = deferred<MobileDashboardStats>()
|
|
const meetingsA = deferred<{ meetings: Meeting[]; total: number; page: number; pageSize: number; hasMore: boolean }>()
|
|
|
|
mockLoadDashboardStats
|
|
.mockReturnValueOnce(statsA.promise)
|
|
.mockResolvedValueOnce({
|
|
totalSessions: 1,
|
|
totalRecordingSeconds: 10,
|
|
totalWordCount: 5,
|
|
todaySessions: 1,
|
|
todayRecordingSeconds: 10,
|
|
todayWordCount: 5,
|
|
streakDays: 1,
|
|
recentHistory: [{
|
|
id: 'user-b-rec',
|
|
title: 'User B record',
|
|
text: 'User B note',
|
|
durationSeconds: 10,
|
|
mode: 'dictation',
|
|
createdAt: '2026-08-21T00:00:00.000Z',
|
|
}],
|
|
generatedAt: '2026-08-21T00:00:00.000Z',
|
|
})
|
|
mockListMeetingsPage
|
|
.mockReturnValueOnce(meetingsA.promise)
|
|
.mockResolvedValueOnce({
|
|
meetings: [makeMeeting(MEETING_ID_2, 'User B Meeting', USER_B)],
|
|
total: 1,
|
|
page: 0,
|
|
pageSize: 3,
|
|
hasMore: false,
|
|
})
|
|
|
|
let renderer!: ReactTestRenderer
|
|
await act(async () => {
|
|
renderer = create(<HomeScreen />)
|
|
activeRenderer = renderer
|
|
await flush()
|
|
})
|
|
|
|
// User switches from USER_A to USER_B while USER_A's dashboard request is still pending.
|
|
mockCurrentUser = { id: USER_B, email: 'b@example.com' }
|
|
await act(async () => {
|
|
renderer.update(<HomeScreen />)
|
|
await flush()
|
|
})
|
|
expect(findHostByTestId(renderer, `home-meeting-${MEETING_ID_2}`)).toHaveLength(1)
|
|
|
|
await act(async () => {
|
|
statsA.resolve({
|
|
totalSessions: 9,
|
|
totalRecordingSeconds: 90,
|
|
totalWordCount: 90,
|
|
todaySessions: 2,
|
|
todayRecordingSeconds: 20,
|
|
todayWordCount: 20,
|
|
streakDays: 3,
|
|
recentHistory: [{
|
|
id: 'user-a-stale-rec',
|
|
title: 'Stale A',
|
|
text: 'Stale A',
|
|
durationSeconds: 20,
|
|
mode: 'dictation',
|
|
createdAt: '2026-08-21T00:00:00.000Z',
|
|
}],
|
|
generatedAt: '2026-08-21T00:00:00.000Z',
|
|
})
|
|
meetingsA.resolve({
|
|
meetings: [makeMeeting(MEETING_ID_1, 'Stale A Meeting', USER_A)],
|
|
total: 1,
|
|
page: 0,
|
|
pageSize: 3,
|
|
hasMore: false,
|
|
})
|
|
await flush()
|
|
})
|
|
|
|
expect(findHostByTestId(renderer, `home-meeting-${MEETING_ID_1}`)).toHaveLength(0)
|
|
expect(findHostByTestId(renderer, `home-meeting-${MEETING_ID_2}`)).toHaveLength(1)
|
|
activeRenderer = null
|
|
act(() => renderer.unmount())
|
|
})
|
|
|
|
test('MeetingsScreen_더보기조회중새검색실행시_이전페이지결과를병합하지않음', async () => {
|
|
jest.useFakeTimers({ now: 1_700_000_000_000 })
|
|
const stalePage2 = deferred<{ meetings: Meeting[]; total: number; page: number; pageSize: number; hasMore: boolean }>()
|
|
mockListMeetingsPage.mockImplementation(async (opts: { page: number; search?: string }) => {
|
|
if (opts.search && opts.search.length > 0) {
|
|
return {
|
|
meetings: [makeMeeting(MEETING_ID_2, 'Filtered Search Result')],
|
|
total: 1,
|
|
page: 0,
|
|
pageSize: 30,
|
|
hasMore: false,
|
|
}
|
|
}
|
|
if (opts.page === 1) return stalePage2.promise
|
|
return {
|
|
meetings: [makeMeeting(MEETING_ID_1, 'Initial Meeting')],
|
|
total: 2,
|
|
page: 0,
|
|
pageSize: 30,
|
|
hasMore: true,
|
|
}
|
|
})
|
|
|
|
let renderer!: ReactTestRenderer
|
|
await act(async () => {
|
|
renderer = create(<MeetingsScreen navigation={mockNavigation as never} />)
|
|
activeRenderer = renderer
|
|
await flush()
|
|
})
|
|
|
|
const flatList = renderer.root.findAll((node) => typeof node.props.onEndReached === 'function')[0]
|
|
await act(async () => {
|
|
flatList.props.onEndReached()
|
|
await Promise.resolve()
|
|
})
|
|
|
|
// Trigger a new search (debounced 300ms) while page 1 (loadMore) is still in flight.
|
|
const searchInput = renderer.root.findByProps({ testID: 'meetings-search' })
|
|
await act(async () => {
|
|
searchInput.props.onChangeText('Filtered')
|
|
})
|
|
await act(async () => {
|
|
await jest.advanceTimersByTimeAsync(350)
|
|
await flush()
|
|
})
|
|
|
|
expect(findHostByTestId(renderer, `meeting-card-${MEETING_ID_2}`)).toHaveLength(1)
|
|
|
|
await act(async () => {
|
|
stalePage2.resolve({
|
|
meetings: [makeMeeting('99999999-9999-4999-8999-999999999999', 'Stale Page 2')],
|
|
total: 2,
|
|
page: 1,
|
|
pageSize: 30,
|
|
hasMore: false,
|
|
})
|
|
await flush()
|
|
})
|
|
|
|
expect(findHostByTestId(renderer, 'meeting-card-99999999-9999-4999-8999-999999999999')).toHaveLength(0)
|
|
expect(findHostByTestId(renderer, `meeting-card-${MEETING_ID_2}`)).toHaveLength(1)
|
|
activeRenderer = null
|
|
act(() => renderer.unmount())
|
|
})
|
|
|
|
test('KnowledgeScreen_더보기조회중새검색실행시_이전문서결과를병합하지않음', async () => {
|
|
const staleDocPage2 = deferred<{ documents: unknown[]; total: number; page: number; pageSize: number; hasMore: boolean }>()
|
|
const makeDoc = (id: string, title: string) => ({
|
|
id,
|
|
user_id: USER_A,
|
|
team_id: null,
|
|
title,
|
|
file_name: `${id}.md`,
|
|
file_type: 'md',
|
|
source_url: null,
|
|
storage_key: null,
|
|
chunk_count: 1,
|
|
indexed: true,
|
|
indexed_at: '2026-08-21T00:00:00.000Z',
|
|
created_at: '2026-08-21T00:00:00.000Z',
|
|
updated_at: '2026-08-21T00:00:00.000Z',
|
|
})
|
|
|
|
mockListKnowledgeDocuments.mockImplementation(async (opts: { page: number; search?: string }) => {
|
|
if (opts.search && opts.search.length > 0) {
|
|
return {
|
|
documents: [makeDoc('doc-search', 'Filtered Doc')],
|
|
total: 1,
|
|
page: 0,
|
|
pageSize: 30,
|
|
hasMore: false,
|
|
}
|
|
}
|
|
if (opts.page === 1) return staleDocPage2.promise
|
|
return {
|
|
documents: [makeDoc('doc-1', 'Doc 1')],
|
|
total: 2,
|
|
page: 0,
|
|
pageSize: 30,
|
|
hasMore: true,
|
|
}
|
|
})
|
|
|
|
let renderer!: ReactTestRenderer
|
|
await act(async () => {
|
|
renderer = create(<KnowledgeScreen />)
|
|
activeRenderer = renderer
|
|
await flush()
|
|
})
|
|
|
|
const flatList = renderer.root.findAll((node) => typeof node.props.onEndReached === 'function')[0]
|
|
await act(async () => {
|
|
flatList.props.onEndReached()
|
|
await Promise.resolve()
|
|
})
|
|
|
|
const searchInput = renderer.root.findByProps({ testID: 'knowledge-document-search' })
|
|
const searchSubmit = renderer.root.findByProps({ testID: 'knowledge-document-search-submit' })
|
|
await act(async () => {
|
|
searchInput.props.onChangeText('Filtered')
|
|
await Promise.resolve()
|
|
})
|
|
await act(async () => {
|
|
searchSubmit.props.onPress()
|
|
await flush()
|
|
})
|
|
|
|
expect(findHostByTestId(renderer, 'knowledge-document-doc-search')).toHaveLength(1)
|
|
|
|
await act(async () => {
|
|
staleDocPage2.resolve({
|
|
documents: [makeDoc('doc-stale', 'Stale Doc Page 2')],
|
|
total: 2,
|
|
page: 1,
|
|
pageSize: 30,
|
|
hasMore: false,
|
|
})
|
|
await flush()
|
|
})
|
|
|
|
expect(findHostByTestId(renderer, 'knowledge-document-doc-stale')).toHaveLength(0)
|
|
activeRenderer = null
|
|
act(() => renderer.unmount())
|
|
})
|
|
|
|
test('RecordScreen_공유미디어가져오기중단시_오류대신idle상태로복귀', async () => {
|
|
const input: LocalAudioInput = {
|
|
uri: 'file:///cache/shared.wav',
|
|
path: '/cache/shared.wav',
|
|
fileName: 'shared.wav',
|
|
mimeType: 'audio/wav',
|
|
sizeBytes: 1_024,
|
|
durationMs: 2_000,
|
|
source: 'share-intent',
|
|
dispose: jest.fn(async () => undefined),
|
|
}
|
|
mockConsumeIncomingMediaAudio.mockResolvedValueOnce(input)
|
|
mockEnqueueAudioProcessing.mockResolvedValueOnce({ id: 'queue-1' })
|
|
mockProcessQueuedAudioNow.mockRejectedValueOnce(new AudioPipelineError('cancelled', 'Import cancelled'))
|
|
|
|
let renderer!: ReactTestRenderer
|
|
await act(async () => {
|
|
renderer = create(
|
|
<RecordScreen
|
|
route={{ params: { incomingMediaId: 'media-cancel-1' } }}
|
|
navigation={{ getParent: () => undefined, setParams: jest.fn() }}
|
|
/>,
|
|
)
|
|
activeRenderer = renderer
|
|
await flush()
|
|
})
|
|
|
|
expect(findHostByTestId(renderer, 'record-error')).toHaveLength(0)
|
|
activeRenderer = null
|
|
act(() => renderer.unmount())
|
|
})
|
|
|
|
test('HistoryDetailScreen_오디오전환후이전URL응답시_오래된트랙재생을시작하지않음', async () => {
|
|
const detail: HistoryDetail = {
|
|
entry: {
|
|
id: HISTORY_ID,
|
|
user_id: USER_A,
|
|
title: 'Memo',
|
|
original_text: 'Body',
|
|
polished_text: null,
|
|
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: 1,
|
|
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-08-21T00:00:00.000Z',
|
|
updated_at: '2026-08-21T00:00:00.000Z',
|
|
},
|
|
audioFiles: [
|
|
{
|
|
id: AUDIO_ID,
|
|
user_id: USER_A,
|
|
history_id: HISTORY_ID,
|
|
meeting_id: null,
|
|
storage_bucket: 'audio-files',
|
|
storage_key: 'audio/sample-1.wav',
|
|
original_name: 'sample-1.wav',
|
|
mime_type: 'audio/wav',
|
|
size_bytes: 2_048,
|
|
duration_ms: 12_000,
|
|
checksum_sha256: 'abc',
|
|
upload_status: 'uploaded',
|
|
retention_until: null,
|
|
created_at: '2026-08-21T00:00:00.000Z',
|
|
updated_at: '2026-08-21T00:00:00.000Z',
|
|
},
|
|
{
|
|
id: AUDIO_ID_2,
|
|
user_id: USER_A,
|
|
history_id: HISTORY_ID,
|
|
meeting_id: null,
|
|
storage_bucket: 'audio-files',
|
|
storage_key: 'audio/sample-2.wav',
|
|
original_name: 'sample-2.wav',
|
|
mime_type: 'audio/wav',
|
|
size_bytes: 2_048,
|
|
duration_ms: 12_000,
|
|
checksum_sha256: 'def',
|
|
upload_status: 'uploaded',
|
|
retention_until: null,
|
|
created_at: '2026-08-21T00:00:00.000Z',
|
|
updated_at: '2026-08-21T00:00:00.000Z',
|
|
},
|
|
],
|
|
jobs: [],
|
|
}
|
|
mockGetHistoryDetail.mockResolvedValueOnce(detail)
|
|
const slowUrlGate = deferred<string>()
|
|
mockCreateAudioPlaybackUrl
|
|
.mockReturnValueOnce(slowUrlGate.promise)
|
|
.mockResolvedValueOnce('https://storage.example/track-2.wav')
|
|
|
|
let renderer!: ReactTestRenderer
|
|
await act(async () => {
|
|
renderer = create(
|
|
<HistoryDetailScreen
|
|
route={{ key: 'HistoryDetail-1', name: 'HistoryDetail', params: { historyId: HISTORY_ID } }}
|
|
navigation={{ goBack: mockGoBack } as never}
|
|
/>,
|
|
)
|
|
activeRenderer = renderer
|
|
await flush()
|
|
})
|
|
|
|
const row1 = renderer.root.findByProps({ testID: `history-audio-${AUDIO_ID}` })
|
|
const row2 = renderer.root.findByProps({ testID: `history-audio-${AUDIO_ID_2}` })
|
|
const play1 = row1.findAll(
|
|
(node) => typeof node.props.onPress === 'function' && node.props.accessibilityLabel === 'mobile.hist.audioPlay',
|
|
)[0]
|
|
const play2 = row2.findAll(
|
|
(node) => typeof node.props.onPress === 'function' && node.props.accessibilityLabel === 'mobile.hist.audioPlay',
|
|
)[0]
|
|
|
|
await act(async () => {
|
|
// Simulate rapid tap on track 1 then track 2 before React disables buttons.
|
|
play1.props.onPress()
|
|
play2.props.onPress()
|
|
await flush()
|
|
})
|
|
|
|
await act(async () => {
|
|
slowUrlGate.resolve('https://storage.example/track-1.wav')
|
|
await flush()
|
|
})
|
|
|
|
expect(mockStartPlayer).toHaveBeenCalledTimes(1)
|
|
activeRenderer = null
|
|
act(() => renderer.unmount())
|
|
})
|
|
|
|
test('CommandsScreen_저장충돌실패전언마운트시_카탈로그재조회를시작하지않음', async () => {
|
|
const command: SyncedCommand = {
|
|
id: COMMAND_ID,
|
|
userId: USER_A,
|
|
builtinKey: null,
|
|
name: 'Summarize',
|
|
description: '',
|
|
prompt: 'Summarize: {{text}}',
|
|
icon: 'bolt',
|
|
sortOrder: 0,
|
|
revision: 1,
|
|
createdAt: '2026-08-21T00:00:00.000Z',
|
|
updatedAt: '2026-08-21T00:00:00.000Z',
|
|
}
|
|
mockLoadSyncedCommandCatalog.mockResolvedValue({
|
|
commands: [command],
|
|
activeCommandId: null,
|
|
})
|
|
const saveGate = deferred<SyncedCommand>()
|
|
mockCreateSyncedCommand.mockReturnValueOnce(saveGate.promise)
|
|
|
|
let renderer!: ReactTestRenderer
|
|
await act(async () => {
|
|
renderer = create(<CommandsScreen />)
|
|
activeRenderer = renderer
|
|
await flush()
|
|
})
|
|
expect(mockLoadSyncedCommandCatalog).toHaveBeenCalledTimes(1)
|
|
|
|
act(() => {
|
|
renderer.root.findByProps({ testID: 'commands-add' }).props.onPress()
|
|
})
|
|
const editor = renderer.root.findByProps({ testID: 'commands-editor' })
|
|
const inputs = editor.findAllByType(TextInput)
|
|
act(() => {
|
|
inputs[0]?.props.onChangeText('New Command')
|
|
inputs[2]?.props.onChangeText('Prompt: {{text}}')
|
|
})
|
|
|
|
await act(async () => {
|
|
renderer.root.findByProps({ testID: 'commands-editor-save' }).props.onPress()
|
|
await Promise.resolve()
|
|
})
|
|
|
|
activeRenderer = null
|
|
act(() => renderer.unmount())
|
|
|
|
await act(async () => {
|
|
saveGate.reject(new CommandSyncError('conflict', 'stale revision'))
|
|
await flush()
|
|
})
|
|
|
|
expect(mockLoadSyncedCommandCatalog).toHaveBeenCalledTimes(1)
|
|
})
|
|
|
|
test('TeamsScreen_팀생성중언마운트시_상세화면으로이동하지않음', async () => {
|
|
mockListTeams.mockResolvedValueOnce([])
|
|
const createGate = deferred<{
|
|
id: string
|
|
name: string
|
|
ownerId: string
|
|
role: 'owner'
|
|
memberCount: number
|
|
createdAt: string
|
|
updatedAt: string
|
|
}>()
|
|
mockCreateTeam.mockReturnValueOnce(createGate.promise)
|
|
|
|
let renderer!: ReactTestRenderer
|
|
await act(async () => {
|
|
renderer = create(<TeamsScreen navigation={mockNavigation as never} />)
|
|
activeRenderer = renderer
|
|
await flush()
|
|
})
|
|
|
|
act(() => {
|
|
renderer.root.findByProps({ testID: 'teams-create' }).props.onPress()
|
|
})
|
|
act(() => {
|
|
renderer.root.findByProps({ testID: 'team-name-input' }).props.onChangeText('Product Team')
|
|
})
|
|
await act(async () => {
|
|
renderer.root.findByProps({ testID: 'team-create-submit' }).props.onPress()
|
|
await Promise.resolve()
|
|
})
|
|
|
|
activeRenderer = null
|
|
act(() => renderer.unmount())
|
|
|
|
await act(async () => {
|
|
createGate.resolve({
|
|
id: TEAM_ID,
|
|
name: 'Product Team',
|
|
ownerId: USER_A,
|
|
role: 'owner',
|
|
memberCount: 1,
|
|
createdAt: '2026-08-21T00:00:00.000Z',
|
|
updatedAt: '2026-08-21T00:00:00.000Z',
|
|
})
|
|
await flush()
|
|
})
|
|
|
|
expect(mockNavigate).not.toHaveBeenCalled()
|
|
})
|
|
})
|