fix(mobile-history): drop history cache writes that outlive the auth scope

apps/mobile-rn/__tests__/history-cache-scope-redteam-r1-26.test.tsx

@@ -0,0 +1,241 @@
+import React from 'react'
+import { act, create, type ReactTestRenderer } from 'react-test-renderer'
+import * as Keychain from 'react-native-keychain'
+import type { HistoryListEntry, HistoryPageResult } from '../src/features/history/history-service'
+
+const USER_A = '11111111-1111-4111-8111-111111111111'
+const HISTORY_CACHE_PREFIX = 'com.d3ro.voice.history-cache.v1.'
+
+let mockAuthUser: { id: string } | null = null
+const mockListHistoryPage = jest.fn<Promise<HistoryPageResult>, [unknown]>()
+
+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/history/history-service', () => ({
+  ...jest.requireActual('../src/features/history/history-service'),
+  listHistoryPage: (options: unknown) => mockListHistoryPage(options),
+  subscribeToHistory: () => ({ unsubscribe: async () => undefined }),
+}))
+
+import { clearAllHistoryCaches } from '../src/features/history/history-cache'
+import {
+  createHistoryCacheScope,
+  saveHistoryCacheInScope,
+  type HistoryCacheStore,
+} from '../src/features/history/history-cache-writer'
+import { useHistorySync } from '../src/features/history/use-history-sync'
+import { synchronizeAfterMissedNotifications } from '../src/features/notifications/missed-notification-sync'
+
+const keychainMock = Keychain as unknown as typeof Keychain & { __reset: () => void }
+
+function entry(id: string): HistoryListEntry {
+  return {
+    id,
+    user_id: USER_A,
+    title: null,
+    original_text: `original ${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: 2,
+    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,
+  }
+}
+
+interface Deferred<T> {
+  promise: Promise<T>
+  resolve: (value: T) => void
+}
+
+function deferred<T>(): Deferred<T> {
+  let resolve: (value: T) => void = () => undefined
+  const promise = new Promise<T>((settle) => { resolve = settle })
+  return { promise, resolve }
+}
+
+async function storedHistoryServices(): Promise<string[]> {
+  const services = await Keychain.getAllGenericPasswordServices()
+  return services.filter((service) => service.startsWith(HISTORY_CACHE_PREFIX))
+}
+
+async function flush(): Promise<void> {
+  for (let index = 0; index < 10; index += 1) await Promise.resolve()
+}
+
+function Harness(): null {
+  useHistorySync()
+  return null
+}
+
+function fakeStore(): HistoryCacheStore & { save: jest.Mock; clear: jest.Mock } {
+  return {
+    save: jest.fn(async () => undefined),
+    clear: jest.fn(async () => undefined),
+  }
+}
+
+describe('history cache auth-scope guard', () => {
+  beforeEach(() => {
+    keychainMock.__reset()
+    mockAuthUser = null
+    mockListHistoryPage.mockReset()
+  })
+
+  test('drops a write whose scope went stale before it started', async () => {
+    const store = fakeStore()
+    const outcome = await saveHistoryCacheInScope(USER_A, [entry('a')], () => false, store)
+    expect(outcome).toBe('dropped')
+    expect(store.save).not.toHaveBeenCalled()
+    expect(store.clear).not.toHaveBeenCalled()
+  })
+
+  test('deletes the entry it just stored when the scope went stale during the write', async () => {
+    const store = fakeStore()
+    let current = true
+    store.save.mockImplementation(async () => { current = false })
+    const outcome = await saveHistoryCacheInScope(USER_A, [entry('a')], () => current, store)
+    expect(outcome).toBe('dropped')
+    expect(store.clear).toHaveBeenCalledWith(USER_A)
+  })
+
+  test('writes normally while the scope stays current', async () => {
+    const store = fakeStore()
+    const outcome = await saveHistoryCacheInScope(USER_A, [entry('a')], () => true, store)
+    expect(outcome).toBe('written')
+    expect(store.save).toHaveBeenCalledWith(USER_A, [entry('a')])
+    expect(store.clear).not.toHaveBeenCalled()
+  })
+
+  test('scope checks captured before invalidate report stale, later captures are current', () => {
+    const scope = createHistoryCacheScope()
+    const before = scope.capture()
+    expect(before()).toBe(true)
+    scope.invalidate()
+    expect(before()).toBe(false)
+    expect(scope.capture()()).toBe(true)
+  })
+
+  test('missed-notification sync does not persist history after the auth scope changed', async () => {
+    const store = fakeStore()
+    const scope = createHistoryCacheScope()
+    const history = deferred<{ entries: HistoryListEntry[] }>()
+    const refreshEntitlement = jest.fn(async () => null)
+
+    const pending = synchronizeAfterMissedNotifications(USER_A, scope.capture(), {
+      listRecentHistory: () => history.promise,
+      listTeams: async () => [],
+      fetchEntitlement: async () => null,
+      refreshEntitlement,
+      historyCacheStore: store,
+    })
+    scope.invalidate()
+    history.resolve({ entries: [entry('a')] })
+
+    await expect(pending).resolves.toBe(false)
+    expect(store.save).not.toHaveBeenCalled()
+    expect(refreshEntitlement).not.toHaveBeenCalled()
+  })
+
+  test('missed-notification sync still caches and refreshes for the current user', async () => {
+    const store = fakeStore()
+    const refreshEntitlement = jest.fn(async () => null)
+    const ok = await synchronizeAfterMissedNotifications(USER_A, () => true, {
+      listRecentHistory: async () => ({ entries: [entry('a')] }),
+      listTeams: async () => [],
+      fetchEntitlement: async () => null,
+      refreshEntitlement,
+      historyCacheStore: store,
+    })
+    expect(ok).toBe(true)
+    expect(store.save).toHaveBeenCalledWith(USER_A, [entry('a')])
+    expect(refreshEntitlement).toHaveBeenCalledTimes(1)
+  })
+
+  test('an in-flight refresh cannot write the history cache back after the logout purge', async () => {
+    const page = deferred<HistoryPageResult>()
+    mockListHistoryPage.mockReturnValueOnce(page.promise)
+    mockAuthUser = { id: USER_A }
+
+    let renderer: ReactTestRenderer | null = null
+    await act(async () => {
+      renderer = create(<Harness />)
+      await flush()
+    })
+    expect(mockListHistoryPage).toHaveBeenCalledTimes(1)
+
+    // Logout: the purge clears every cache and the history screen unmounts
+    // while user A's request is still in flight with a valid JWT.
+    mockAuthUser = null
+    await clearAllHistoryCaches()
+    await act(async () => {
+      renderer?.unmount()
+      await flush()
+    })
+
+    await act(async () => {
+      page.resolve({ entries: [entry('a')], nextCursor: null })
+      await flush()
+    })
+
+    expect(await storedHistoryServices()).toEqual([])
+  })
+
+  test('a write that lands after the purge enumerated the caches is compensated', async () => {
+    mockListHistoryPage.mockResolvedValueOnce({ entries: [entry('a')], nextCursor: null })
+    const write = deferred<false | { service: string; storage: string }>()
+    const setGenericPassword = Keychain.setGenericPassword as jest.Mock
+    const realSet = setGenericPassword.getMockImplementation()
+    setGenericPassword.mockImplementationOnce(async (...args: unknown[]) => {
+      await write.promise
+      return realSet?.(...args)
+    })
+    mockAuthUser = { id: USER_A }
+
+    let renderer: ReactTestRenderer | null = null
+    await act(async () => {
+      renderer = create(<Harness />)
+      await flush()
+    })
+    // The cache write was issued while A was still current but has not landed
+    // yet. The purge enumerates now (nothing to clear), then the screen
+    // unmounts, and only afterwards does the native write complete.
+    mockAuthUser = null
+    await clearAllHistoryCaches()
+    await act(async () => {
+      renderer?.unmount()
+      await flush()
+    })
+
+    await act(async () => {
+      write.resolve(false)
+      await flush()
+    })
+
+    expect(await storedHistoryServices()).toEqual([])
+  })
+})