238 lines
8.3 KiB
TypeScript
238 lines
8.3 KiB
TypeScript
import { NativeModules } from 'react-native'
|
|
import { FileSystem } from 'react-native-file-access'
|
|
|
|
const mockStartRecorder = jest.fn<Promise<string>, [string, unknown, boolean]>()
|
|
const mockStopRecorder = jest.fn(async () => 'stopped')
|
|
const mockPauseRecorder = jest.fn(async () => 'paused')
|
|
const mockResumeRecorder = jest.fn(async () => 'resumed')
|
|
|
|
jest.mock('react-native-nitro-sound', () => ({
|
|
AudioEncoderAndroidType: { AAC: 3 },
|
|
AudioSourceAndroidType: { MIC: 1 },
|
|
AVEncoderAudioQualityIOSType: { high: 96 },
|
|
OutputFormatAndroidType: { MPEG_4: 2 },
|
|
createSound: () => ({
|
|
addRecordBackListener: () => undefined,
|
|
pauseRecorder: () => mockPauseRecorder(),
|
|
resumeRecorder: () => mockResumeRecorder(),
|
|
setSubscriptionDuration: () => undefined,
|
|
startRecorder: (path: string, settings: unknown, metering: boolean) => (
|
|
mockStartRecorder(path, settings, metering)
|
|
),
|
|
stopRecorder: () => mockStopRecorder(),
|
|
}),
|
|
}))
|
|
|
|
import {
|
|
AudioRecorder,
|
|
RecorderBusyError,
|
|
type RecorderBackend,
|
|
} from '../src/lib/audio-recorder'
|
|
import { AndroidForegroundRecorderBackend } from '../src/lib/recorder/android-foreground-backend'
|
|
import { NitroRecorderBackend } from '../src/lib/recorder/nitro-backend'
|
|
|
|
const MEETING_PATH = '/data/user/0/com.d3ro.voice/files/recordings/d3ro-recording-11111111-1111-4111-8111-111111111111.wav'
|
|
|
|
function nativeSnapshot(
|
|
state: 'idle' | 'starting' | 'recording' | 'paused' | 'stopped' | 'recoverable',
|
|
) {
|
|
const hasFile = state !== 'idle'
|
|
return {
|
|
state,
|
|
path: hasFile ? MEETING_PATH : null,
|
|
uri: hasFile ? `file://${MEETING_PATH}` : null,
|
|
fileName: hasFile ? 'd3ro-recording-11111111-1111-4111-8111-111111111111.wav' : null,
|
|
mimeType: 'audio/wav',
|
|
size: hasFile ? 64_044 : 0,
|
|
durationMs: hasFile ? 4_000 : 0,
|
|
meteringDb: null,
|
|
meetingId: null,
|
|
interruptionReason: null,
|
|
startedAtMs: hasFile ? 1_000 : 0,
|
|
recoverable: state === 'recoverable',
|
|
}
|
|
}
|
|
|
|
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 }
|
|
}
|
|
|
|
describe('audio recorder and backend lifecycle race guards', () => {
|
|
afterEach(() => {
|
|
jest.clearAllTimers()
|
|
jest.useRealTimers()
|
|
jest.restoreAllMocks()
|
|
mockStartRecorder.mockReset()
|
|
mockStopRecorder.mockClear()
|
|
delete (NativeModules as Record<string, unknown>).D3RORecording
|
|
})
|
|
|
|
test('AudioRecorder_동시start클레임경합시_한소유자만인정하고실패시임대해제', async () => {
|
|
const busyChecks: Array<ReturnType<typeof deferred<boolean>>> = []
|
|
let active = false
|
|
let failNextStart = true
|
|
const backend: RecorderBackend = {
|
|
requestPermission: jest.fn(async () => true),
|
|
start: jest.fn(async () => {
|
|
if (failNextStart) {
|
|
failNextStart = false
|
|
throw new Error('mic unavailable')
|
|
}
|
|
active = true
|
|
}),
|
|
pause: jest.fn(async () => undefined),
|
|
resume: jest.fn(async () => undefined),
|
|
stop: jest.fn(async () => ({
|
|
uri: 'file:///cache/cap.m4a',
|
|
path: '/cache/cap.m4a',
|
|
fileName: 'cap.m4a',
|
|
mimeType: 'audio/mp4',
|
|
size: 128,
|
|
durationMs: 1_000,
|
|
})),
|
|
cleanup: jest.fn(async () => { active = false }),
|
|
cancel: jest.fn(async () => { active = false }),
|
|
restore: jest.fn(async () => ({
|
|
state: 'idle' as const,
|
|
recording: null,
|
|
meetingId: null,
|
|
interruptionReason: null,
|
|
startedAtMs: 0,
|
|
})),
|
|
isBusy: jest.fn(() => {
|
|
const gate = deferred<boolean>()
|
|
busyChecks.push(gate)
|
|
return gate.promise
|
|
}),
|
|
hasInProcessCapture: jest.fn(() => active),
|
|
}
|
|
|
|
const recorder = new AudioRecorder(backend)
|
|
const recordAcquire = recorder.acquire('record')
|
|
await Promise.resolve()
|
|
busyChecks.pop()?.resolve(false)
|
|
const record = await recordAcquire
|
|
|
|
const talkAcquire = recorder.acquire('talk')
|
|
await Promise.resolve()
|
|
busyChecks.pop()?.resolve(false)
|
|
const talk = await talkAcquire
|
|
|
|
// Both record.start and talk.start race while isBusy() is pending.
|
|
const recordStart = record.start(() => undefined)
|
|
const talkStart = talk.start(() => undefined)
|
|
await Promise.resolve()
|
|
while (busyChecks.length > 0) busyChecks.shift()?.resolve(false)
|
|
|
|
await expect(recordStart).rejects.toThrow('mic unavailable')
|
|
await expect(talkStart).rejects.toBeInstanceOf(RecorderBusyError)
|
|
expect(backend.start).toHaveBeenCalledTimes(1)
|
|
|
|
// After record.start fails and stays idle, lease must be released for talk.
|
|
const secondTalkStart = talk.start(() => undefined)
|
|
await Promise.resolve()
|
|
while (busyChecks.length > 0) busyChecks.shift()?.resolve(false)
|
|
await expect(secondTalkStart).resolves.toBeUndefined()
|
|
expect(backend.start).toHaveBeenCalledTimes(2)
|
|
})
|
|
|
|
test('NitroRecorderBackend_임시파일정리중취소시_녹음시작하지않고idle복귀', async () => {
|
|
const lsGate = deferred<string[]>()
|
|
jest.spyOn(FileSystem, 'ls').mockReturnValueOnce(lsGate.promise)
|
|
mockStartRecorder.mockResolvedValue('file:///cache/fake-nitro-recording.m4a')
|
|
const backend = new NitroRecorderBackend()
|
|
|
|
const startPromise = backend.start(() => undefined)
|
|
await Promise.resolve()
|
|
|
|
await backend.cancel()
|
|
lsGate.resolve([])
|
|
|
|
await expect(startPromise).rejects.toThrow('cancelled')
|
|
expect(mockStartRecorder).not.toHaveBeenCalled()
|
|
expect(backend.hasInProcessCapture()).toBe(false)
|
|
})
|
|
|
|
test('AndroidForegroundRecorderBackend_정지및취소시_예약된폴타이머를모두해제함', async () => {
|
|
jest.useFakeTimers()
|
|
const native = {
|
|
current: nativeSnapshot('idle'),
|
|
getStatus: jest.fn(async () => native.current),
|
|
start: jest.fn(async () => {
|
|
native.current = nativeSnapshot('recording')
|
|
return native.current
|
|
}),
|
|
pause: jest.fn(async () => nativeSnapshot('paused')),
|
|
resume: jest.fn(async () => nativeSnapshot('recording')),
|
|
stop: jest.fn(async () => {
|
|
native.current = nativeSnapshot('stopped')
|
|
return native.current
|
|
}),
|
|
cancel: jest.fn(async () => {
|
|
native.current = nativeSnapshot('idle')
|
|
return native.current
|
|
}),
|
|
dispose: jest.fn(async () => {
|
|
native.current = nativeSnapshot('idle')
|
|
}),
|
|
}
|
|
;(NativeModules as Record<string, unknown>).D3RORecording = native
|
|
|
|
const backend = new AndroidForegroundRecorderBackend()
|
|
await backend.start(() => undefined)
|
|
await Promise.resolve()
|
|
|
|
expect(jest.getTimerCount()).toBeGreaterThan(0)
|
|
await backend.stop()
|
|
expect(jest.getTimerCount()).toBe(0)
|
|
|
|
await backend.cleanup()
|
|
native.getStatus.mockRejectedValueOnce(new Error('transient bridge error'))
|
|
await backend.start(() => undefined)
|
|
await Promise.resolve()
|
|
|
|
expect(jest.getTimerCount()).toBeGreaterThan(0)
|
|
await backend.cancel()
|
|
expect(jest.getTimerCount()).toBe(0)
|
|
})
|
|
|
|
test('AndroidForegroundRecorderBackend_시작중취소호출시_지연된시작응답이idle상태를덮어쓰지않음', async () => {
|
|
jest.useFakeTimers()
|
|
const startGate = deferred<ReturnType<typeof nativeSnapshot>>()
|
|
const native = {
|
|
current: nativeSnapshot('idle'),
|
|
getStatus: jest.fn(async () => native.current),
|
|
start: jest.fn(() => startGate.promise),
|
|
pause: jest.fn(async () => nativeSnapshot('paused')),
|
|
resume: jest.fn(async () => nativeSnapshot('recording')),
|
|
stop: jest.fn(async () => nativeSnapshot('stopped')),
|
|
cancel: jest.fn(async () => {
|
|
native.current = nativeSnapshot('idle')
|
|
return native.current
|
|
}),
|
|
dispose: jest.fn(async () => undefined),
|
|
}
|
|
;(NativeModules as Record<string, unknown>).D3RORecording = native
|
|
|
|
const backend = new AndroidForegroundRecorderBackend()
|
|
const startPromise = backend.start(() => undefined)
|
|
await Promise.resolve()
|
|
|
|
await backend.cancel()
|
|
expect(native.cancel).toHaveBeenCalledTimes(1)
|
|
|
|
native.current = nativeSnapshot('recording')
|
|
startGate.resolve(native.current)
|
|
|
|
await expect(startPromise).rejects.toThrow('cancelled')
|
|
expect(backend.hasInProcessCapture()).toBe(false)
|
|
expect(native.cancel).toHaveBeenCalledTimes(2)
|
|
expect(jest.getTimerCount()).toBe(0)
|
|
})
|
|
})
|