350 lines
12 KiB
TypeScript
350 lines
12 KiB
TypeScript
import React from 'react'
|
|
import { act, create, type ReactTestRenderer } from 'react-test-renderer'
|
|
import AsyncStorage from '@react-native-async-storage/async-storage'
|
|
import { FileSystem } from 'react-native-file-access'
|
|
import {
|
|
AudioPipelineError,
|
|
type AudioPipelineResult,
|
|
type LocalAudioInput,
|
|
} from '../src/features/import/audio-import-types'
|
|
import type { HistoryListEntry, HistoryPageResult } from '../src/features/history/history-service'
|
|
|
|
const START_MS = 1_700_000_000_000
|
|
const USER_A = '11111111-1111-4111-8111-111111111111'
|
|
const USER_B = '22222222-2222-4222-8222-222222222222'
|
|
|
|
const mockProcessAudioInput = jest.fn<Promise<AudioPipelineResult>, [LocalAudioInput, unknown]>()
|
|
const mockListHistoryPage = jest.fn<Promise<HistoryPageResult>, [unknown]>()
|
|
const mockLoadHistoryCache = jest.fn()
|
|
const mockUpdateHistoryRevisionSafe = jest.fn()
|
|
let mockAuthUser: { id: string } | null = null
|
|
|
|
jest.mock('../src/lib/supabase', () => ({
|
|
supabase: {
|
|
channel: jest.fn(),
|
|
removeChannel: jest.fn(async () => 'ok'),
|
|
},
|
|
}))
|
|
jest.mock('../src/lib/auth-context', () => ({
|
|
useAuth: () => ({ user: mockAuthUser }),
|
|
}))
|
|
jest.mock('../src/features/import/audio-transcription-service', () => ({
|
|
processAudioInput: (input: LocalAudioInput, options: unknown) => mockProcessAudioInput(input, options),
|
|
}))
|
|
jest.mock('../src/features/meetings/meetings-service', () => ({
|
|
failMeetingRecording: jest.fn(async () => undefined),
|
|
markMeetingProcessingFailure: jest.fn(async () => undefined),
|
|
queueMeetingRecording: jest.fn(async () => undefined),
|
|
}))
|
|
jest.mock('../src/features/history/history-service', () => ({
|
|
...jest.requireActual('../src/features/history/history-service'),
|
|
listHistoryPage: (options: unknown) => mockListHistoryPage(options),
|
|
subscribeToHistory: () => ({ unsubscribe: async () => undefined }),
|
|
updateHistoryRevisionSafe: (...args: unknown[]) => mockUpdateHistoryRevisionSafe(...args),
|
|
}))
|
|
jest.mock('../src/features/history/history-cache', () => ({
|
|
...jest.requireActual('../src/features/history/history-cache'),
|
|
loadHistoryCache: (...args: unknown[]) => mockLoadHistoryCache(...args),
|
|
saveHistoryCache: jest.fn(async () => undefined),
|
|
clearHistoryCache: jest.fn(async () => undefined),
|
|
}))
|
|
|
|
import {
|
|
clearQueuedAudioForUser,
|
|
durableQueueTestContract,
|
|
processQueuedAudioNow,
|
|
QueuedAudioPendingError,
|
|
resumeQueuedAudioForUser,
|
|
retainQueuedAudioOnlyForUser,
|
|
retryQueuedAudio,
|
|
type DurableQueueItem,
|
|
} from '../src/features/recording/durable-processing-queue'
|
|
import { useHistorySync } from '../src/features/history/use-history-sync'
|
|
|
|
const mockFileSystem = FileSystem as typeof FileSystem & {
|
|
filesystem: Map<string, string>
|
|
unlink: jest.Mock
|
|
}
|
|
|
|
function makeQueueItem(
|
|
userId: string,
|
|
suffix: string,
|
|
overrides: Partial<DurableQueueItem> = {},
|
|
): DurableQueueItem {
|
|
const path = `${durableQueueTestContract.queueDirectory}/queued-${suffix}.wav`
|
|
return {
|
|
schemaVersion: 1,
|
|
id: suffix,
|
|
userId,
|
|
meetingId: null,
|
|
path,
|
|
uri: `file://${path}`,
|
|
fileName: `${suffix}.wav`,
|
|
mimeType: 'audio/wav',
|
|
sizeBytes: 128,
|
|
durationMs: 1_000,
|
|
source: 'recording',
|
|
languageCode: 'ko',
|
|
status: 'pending',
|
|
phase: null,
|
|
attempts: 0,
|
|
uploadedBytes: 0,
|
|
nextAttemptAtMs: START_MS,
|
|
lastErrorCode: null,
|
|
lastErrorMessage: null,
|
|
createdAtMs: START_MS,
|
|
updatedAtMs: START_MS,
|
|
...overrides,
|
|
}
|
|
}
|
|
|
|
function makeHistoryEntry(id: string, userId = USER_A): HistoryListEntry {
|
|
return {
|
|
id,
|
|
user_id: userId,
|
|
title: `entry ${id}`,
|
|
original_text: `text ${id}`,
|
|
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: null,
|
|
duration: 2,
|
|
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.0.0',
|
|
summary_text: null,
|
|
is_favorite: false,
|
|
revision: 1,
|
|
created_at: '2026-08-21T00:00:00.000Z',
|
|
updated_at: '2026-08-21T00:00:00.000Z',
|
|
activeJob: null,
|
|
}
|
|
}
|
|
|
|
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 flushMicrotasks(): Promise<void> {
|
|
for (let index = 0; index < 8; index += 1) await Promise.resolve()
|
|
}
|
|
|
|
describe('durable queue and history sync race guards', () => {
|
|
let activeRenderer: ReactTestRenderer | null = null
|
|
|
|
beforeEach(async () => {
|
|
jest.useFakeTimers({ now: START_MS })
|
|
await AsyncStorage.clear()
|
|
mockFileSystem.filesystem.clear()
|
|
mockFileSystem.unlink.mockClear()
|
|
mockProcessAudioInput.mockReset()
|
|
mockListHistoryPage.mockReset()
|
|
mockLoadHistoryCache.mockReset()
|
|
mockUpdateHistoryRevisionSafe.mockReset()
|
|
mockAuthUser = null
|
|
})
|
|
|
|
afterEach(async () => {
|
|
if (activeRenderer !== null) {
|
|
const target = activeRenderer
|
|
activeRenderer = null
|
|
act(() => target.unmount())
|
|
}
|
|
await clearQueuedAudioForUser(USER_A).catch(() => undefined)
|
|
await clearQueuedAudioForUser(USER_B).catch(() => undefined)
|
|
await resumeQueuedAudioForUser(USER_A).catch(() => undefined)
|
|
await resumeQueuedAudioForUser(USER_B).catch(() => undefined)
|
|
jest.clearAllTimers()
|
|
jest.useRealTimers()
|
|
})
|
|
|
|
test('durableQueue_정지된사용자의재시도실패시_스케줄러를재예약하지않음', async () => {
|
|
const item = makeQueueItem(USER_A, 'aaaa0001')
|
|
mockFileSystem.filesystem.set(item.path, 'audio-bytes')
|
|
await AsyncStorage.setItem(durableQueueTestContract.storageKey, JSON.stringify([item]))
|
|
|
|
const runGate = deferred<AudioPipelineResult>()
|
|
mockProcessAudioInput.mockImplementationOnce(() => runGate.promise)
|
|
|
|
const processing = processQueuedAudioNow(USER_A, item.id).catch((err: unknown) => err)
|
|
await flushMicrotasks()
|
|
|
|
await retainQueuedAudioOnlyForUser(USER_A)
|
|
|
|
runGate.reject(new AudioPipelineError('upload', 'network temporarily offline'))
|
|
const caught = await processing
|
|
expect(caught).toBeInstanceOf(QueuedAudioPendingError)
|
|
expect(jest.getTimerCount()).toBe(0)
|
|
|
|
await jest.advanceTimersByTimeAsync(120_000)
|
|
await flushMicrotasks()
|
|
|
|
// While USER_A remains suspended after retainQueuedAudioOnlyForUser, no retry run fires.
|
|
expect(mockProcessAudioInput).toHaveBeenCalledTimes(1)
|
|
})
|
|
|
|
test('durableQueue_정지또는정리단계항목재시도시_running이나cleanup상태를덮어쓰지않음', async () => {
|
|
const cleaningItem = makeQueueItem(USER_A, 'aaaa0002', {
|
|
status: 'cleanup',
|
|
phase: 'saving',
|
|
})
|
|
const runningItem = makeQueueItem(USER_A, 'aaaa0003', {
|
|
status: 'running',
|
|
phase: 'transcribing',
|
|
})
|
|
mockFileSystem.filesystem.set(cleaningItem.path, 'audio-bytes')
|
|
mockFileSystem.filesystem.set(runningItem.path, 'audio-bytes')
|
|
await AsyncStorage.setItem(
|
|
durableQueueTestContract.storageKey,
|
|
JSON.stringify([cleaningItem, runningItem]),
|
|
)
|
|
mockProcessAudioInput.mockResolvedValue({
|
|
historyId: null,
|
|
audioFileId: 'audio-file',
|
|
meetingId: null,
|
|
processingJobId: null,
|
|
transcript: 'done',
|
|
provider: 'test',
|
|
language: 'ko',
|
|
durationSeconds: 1,
|
|
deduplicated: false,
|
|
})
|
|
|
|
// Hold resume at readQueue or reject nothing — instead inspect status change before resume consumes running.
|
|
await retryQueuedAudio(USER_A, cleaningItem.id)
|
|
const afterCleanupRetry = durableQueueTestContract.parseQueue(
|
|
await AsyncStorage.getItem(durableQueueTestContract.storageKey),
|
|
)
|
|
const cleanupState = afterCleanupRetry.find((candidate) => candidate.id === cleaningItem.id)
|
|
// cleanup item must not be downgraded to retry and re-transcribed, and its local file must be removed.
|
|
expect(mockProcessAudioInput).not.toHaveBeenCalled()
|
|
expect(cleanupState).toBeUndefined()
|
|
expect(mockFileSystem.filesystem.has(cleaningItem.path)).toBe(false)
|
|
|
|
await retryQueuedAudio(USER_A, runningItem.id)
|
|
const afterRunningRetry = durableQueueTestContract.parseQueue(
|
|
await AsyncStorage.getItem(durableQueueTestContract.storageKey),
|
|
)
|
|
expect(afterRunningRetry.find((candidate) => candidate.id === runningItem.id)?.status).toBe('running')
|
|
})
|
|
|
|
test('durableQueue_정리단계재시도중파일삭제실패시_큐항목을유지하고정리재시도를예약함', async () => {
|
|
const cleaningItem = makeQueueItem(USER_A, 'aaaa0004', {
|
|
status: 'cleanup',
|
|
phase: 'saving',
|
|
})
|
|
mockFileSystem.filesystem.set(cleaningItem.path, 'audio-bytes')
|
|
await AsyncStorage.setItem(durableQueueTestContract.storageKey, JSON.stringify([cleaningItem]))
|
|
mockFileSystem.unlink.mockRejectedValueOnce(new Error('filesystem busy'))
|
|
|
|
await retryQueuedAudio(USER_A, cleaningItem.id)
|
|
|
|
const retained = durableQueueTestContract.parseQueue(
|
|
await AsyncStorage.getItem(durableQueueTestContract.storageKey),
|
|
)
|
|
expect(retained.find((candidate) => candidate.id === cleaningItem.id)?.status).toBe('cleanup')
|
|
expect(mockFileSystem.filesystem.has(cleaningItem.path)).toBe(true)
|
|
expect(jest.getTimerCount()).toBe(1)
|
|
|
|
await jest.advanceTimersByTimeAsync(60_000)
|
|
await flushMicrotasks()
|
|
|
|
const afterScheduledCleanup = durableQueueTestContract.parseQueue(
|
|
await AsyncStorage.getItem(durableQueueTestContract.storageKey),
|
|
)
|
|
expect(afterScheduledCleanup.find((candidate) => candidate.id === cleaningItem.id)).toBeUndefined()
|
|
expect(mockFileSystem.filesystem.has(cleaningItem.path)).toBe(false)
|
|
expect(mockProcessAudioInput).not.toHaveBeenCalled()
|
|
})
|
|
|
|
test('useHistorySync_오프라인캐시조회중새요청이나언마운트시_오래된캐시로덮어쓰지않음', async () => {
|
|
jest.useRealTimers()
|
|
let latestState: ReturnType<typeof useHistorySync> | null = null
|
|
function Probe(): null {
|
|
latestState = useHistorySync()
|
|
return null
|
|
}
|
|
|
|
const firstOfflineCache = deferred<{ savedAt: string; entries: HistoryListEntry[] } | null>()
|
|
mockAuthUser = { id: USER_A }
|
|
mockListHistoryPage
|
|
.mockRejectedValueOnce(new TypeError('Network request failed'))
|
|
.mockResolvedValueOnce({
|
|
entries: [makeHistoryEntry('fresh-entry', USER_B)],
|
|
nextCursor: null,
|
|
})
|
|
mockLoadHistoryCache.mockReturnValueOnce(firstOfflineCache.promise)
|
|
|
|
let renderer!: ReactTestRenderer
|
|
await act(async () => {
|
|
renderer = create(React.createElement(Probe))
|
|
activeRenderer = renderer
|
|
await flushMicrotasks()
|
|
})
|
|
|
|
// Switch user while USER_A's offline cache load is still pending.
|
|
mockAuthUser = { id: USER_B }
|
|
await act(async () => {
|
|
renderer.update(React.createElement(Probe))
|
|
await flushMicrotasks()
|
|
})
|
|
expect(latestState?.entries.map((item) => item.id)).toEqual(['fresh-entry'])
|
|
|
|
// Now USER_A's stalled offline cache finishes.
|
|
await act(async () => {
|
|
firstOfflineCache.resolve({
|
|
savedAt: '2026-08-21T00:00:00.000Z',
|
|
entries: [makeHistoryEntry('stale-user-a-cache', USER_A)],
|
|
})
|
|
await flushMicrotasks()
|
|
})
|
|
|
|
expect(latestState?.entries.map((item) => item.id)).toEqual(['fresh-entry'])
|
|
expect(latestState?.offline).toBe(false)
|
|
|
|
// Now test toggleFavorite resolving after user switch does not pollute USER_B's entries.
|
|
const favGate = deferred<HistoryListEntry>()
|
|
mockUpdateHistoryRevisionSafe.mockReturnValueOnce(favGate.promise)
|
|
const staleEntry = makeHistoryEntry('shared-like-entry', USER_A)
|
|
let pendingToggle: Promise<unknown> = Promise.resolve()
|
|
act(() => {
|
|
pendingToggle = latestState!.toggleFavorite(staleEntry).catch(() => undefined)
|
|
})
|
|
|
|
mockAuthUser = { id: USER_A }
|
|
mockListHistoryPage.mockResolvedValueOnce({
|
|
entries: [makeHistoryEntry('shared-like-entry', USER_A)],
|
|
nextCursor: null,
|
|
})
|
|
await act(async () => {
|
|
renderer.update(React.createElement(Probe))
|
|
await flushMicrotasks()
|
|
})
|
|
expect(latestState?.entries[0]?.is_favorite).toBe(false)
|
|
|
|
await act(async () => {
|
|
favGate.resolve({ ...staleEntry, is_favorite: true, revision: 2 })
|
|
await pendingToggle
|
|
await flushMicrotasks()
|
|
})
|
|
|
|
expect(latestState?.entries[0]?.is_favorite).toBe(false)
|
|
activeRenderer = null
|
|
act(() => renderer.unmount())
|
|
})
|
|
})
|