chore: add tests for the race conditions

Author: isekovanic

package/src/state-store/__tests__/audio-recorder-manager.test.ts

@@ -0,0 +1,219 @@
+import { AudioReturnType, NativeHandlers } from '../../native';
+import { AudioRecorderManager } from '../audio-recorder-manager';
+
+const createDeferred = <T>() => {
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, reject, resolve };
+};
+
+const getMockRecording = () =>
+  ({
+    getStatusAsync: jest.fn(),
+    getURI: jest.fn(),
+    pauseAsync: jest.fn(),
+    recording: 'recording-id',
+    setProgressUpdateInterval: jest.fn(),
+    stopAndUnloadAsync: jest.fn(),
+  }) as const;
+
+describe('AudioRecorderManager race conditions', () => {
+  const originalAudioHandler = NativeHandlers.Audio;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    NativeHandlers.Audio = originalAudioHandler;
+  });
+
+  it('keeps initial recorder state', () => {
+    const manager = new AudioRecorderManager();
+    expect(manager.state.getLatestValue()).toEqual({
+      duration: 0,
+      isStarting: false,
+      micLocked: false,
+      recording: undefined,
+      status: 'idle',
+      waveformData: [],
+    });
+  });
+
+  it('starts successfully and transitions to recording only after native start resolves', async () => {
+    const recording = getMockRecording();
+    const startRecording = jest.fn().mockResolvedValue({
+      accessGranted: true,
+      recording,
+    } satisfies AudioReturnType);
+    const stopRecording = jest.fn().mockResolvedValue(undefined);
+
+    NativeHandlers.Audio = {
+      audioRecordingConfiguration: {},
+      startRecording,
+      stopRecording,
+    };
+
+    const manager = new AudioRecorderManager();
+    const startPromise = manager.startRecording();
+
+    expect(manager.state.getLatestValue().isStarting).toBe(true);
+    await startPromise;
+
+    const latest = manager.state.getLatestValue();
+    expect(latest.isStarting).toBe(false);
+    expect(latest.status).toBe('recording');
+    expect(latest.recording).toBe(recording);
+    expect(recording.setProgressUpdateInterval).toHaveBeenCalledWith(expect.any(Number));
+  });
+
+  it('stops during in-flight start and does not enter recording when start resolves', async () => {
+    const recording = getMockRecording();
+    const deferred = createDeferred<AudioReturnType>();
+    const startRecording = jest.fn().mockImplementation(() => deferred.promise);
+    const stopRecording = jest.fn().mockResolvedValue(undefined);
+
+    NativeHandlers.Audio = {
+      audioRecordingConfiguration: {},
+      startRecording,
+      stopRecording,
+    };
+
+    const manager = new AudioRecorderManager();
+    const startPromise = manager.startRecording();
+
+    expect(manager.state.getLatestValue().isStarting).toBe(true);
+
+    await manager.stopRecording();
+    expect(manager.state.getLatestValue()).toEqual({
+      duration: 0,
+      isStarting: false,
+      micLocked: false,
+      recording: undefined,
+      status: 'idle',
+      waveformData: [],
+    });
+
+    deferred.resolve({ accessGranted: true, recording });
+    await startPromise;
+
+    expect(stopRecording).toHaveBeenCalledTimes(1);
+    expect(manager.state.getLatestValue().status).toBe('idle');
+    expect(manager.state.getLatestValue().recording).toBeUndefined();
+  });
+
+  it('does not call native stop after pending stop if start resolves without access', async () => {
+    const deferred = createDeferred<AudioReturnType>();
+    const startRecording = jest.fn().mockImplementation(() => deferred.promise);
+    const stopRecording = jest.fn().mockResolvedValue(undefined);
+
+    NativeHandlers.Audio = {
+      audioRecordingConfiguration: {},
+      startRecording,
+      stopRecording,
+    };
+
+    const manager = new AudioRecorderManager();
+    const startPromise = manager.startRecording();
+    await manager.stopRecording();
+
+    deferred.resolve({ accessGranted: false, recording: undefined });
+    await startPromise;
+
+    expect(stopRecording).not.toHaveBeenCalled();
+    expect(manager.state.getLatestValue().status).toBe('idle');
+  });
+
+  it('resets state when native start throws', async () => {
+    const startRecording = jest.fn().mockRejectedValue(new Error('start failed'));
+    const stopRecording = jest.fn().mockResolvedValue(undefined);
+
+    NativeHandlers.Audio = {
+      audioRecordingConfiguration: {},
+      startRecording,
+      stopRecording,
+    };
+
+    const manager = new AudioRecorderManager();
+    const result = await manager.startRecording();
+
+    expect(result).toBe(false);
+    expect(manager.state.getLatestValue()).toEqual({
+      duration: 0,
+      isStarting: false,
+      micLocked: false,
+      recording: undefined,
+      status: 'idle',
+      waveformData: [],
+    });
+  });
+
+  it('does not let stale start completion overwrite newer recording session', async () => {
+    const recording1 = getMockRecording();
+    const recording2 = getMockRecording();
+    const deferred1 = createDeferred<AudioReturnType>();
+    const deferred2 = createDeferred<AudioReturnType>();
+
+    const startRecording = jest
+      .fn()
+      .mockImplementationOnce(() => deferred1.promise)
+      .mockImplementationOnce(() => deferred2.promise);
+    const stopRecording = jest.fn().mockResolvedValue(undefined);
+
+    NativeHandlers.Audio = {
+      audioRecordingConfiguration: {},
+      startRecording,
+      stopRecording,
+    };
+
+    const manager = new AudioRecorderManager();
+    const firstStart = manager.startRecording();
+    await manager.stopRecording();
+    const secondStart = manager.startRecording();
+
+    deferred1.resolve({ accessGranted: true, recording: recording1 });
+    await firstStart;
+
+    // First (stale) completion should not put stale recording into state.
+    expect(manager.state.getLatestValue().recording).toBeUndefined();
+    expect(manager.state.getLatestValue().status).toBe('idle');
+
+    deferred2.resolve({ accessGranted: true, recording: recording2 });
+    await secondStart;
+
+    expect(manager.state.getLatestValue().recording).toBe(recording2);
+    expect(manager.state.getLatestValue().status).toBe('recording');
+  });
+
+  it('stopRecording with delete clears state instead of setting stopped', async () => {
+    const recording = getMockRecording();
+    const startRecording = jest.fn().mockResolvedValue({
+      accessGranted: true,
+      recording,
+    } satisfies AudioReturnType);
+    const stopRecording = jest.fn().mockResolvedValue(undefined);
+
+    NativeHandlers.Audio = {
+      audioRecordingConfiguration: {},
+      startRecording,
+      stopRecording,
+    };
+
+    const manager = new AudioRecorderManager();
+    await manager.startRecording();
+    await manager.stopRecording(true);
+
+    expect(manager.state.getLatestValue()).toEqual({
+      duration: 0,
+      isStarting: false,
+      micLocked: false,
+      recording: undefined,
+      status: 'idle',
+      waveformData: [],
+    });
+  });
+});