orca/src/main/codex-usage/store-persistence.test.ts

import { readFileSync, writeFileSync } from 'node:fs'
import { join } from 'node:path'
import { describe, expect, it, vi } from 'vitest'
import type { CodexUsagePersistedState } from './types'
import { createStoreWithState, setupCodexUsageStoreEnv } from './store-test-harness'

const { getPathMock } = vi.hoisted(() => ({
  getPathMock: vi.fn(() => '/tmp/orca-test-userdata')
}))

vi.mock('electron', () => ({
  app: {
    getPath: getPathMock
  }
}))

vi.mock('../usage/usage-scan-worker-spawn', () => ({
  scanCodexUsageFilesViaWorker: vi.fn(),
  splitUsageCacheFileViaWorker: vi.fn()
}))

import { CodexUsageStore, normalizePersistedState } from './store'
import { CODEX_USAGE_SCHEMA_VERSION } from './codex-usage-provider'
import { scanCodexUsageFilesViaWorker } from '../usage/usage-scan-worker-spawn'

describe('CodexUsageStore', () => {
  const storeEnv = setupCodexUsageStoreEnv(getPathMock)

  it('adapts Codex scans to compact cache persistence', async () => {
    const store = createStoreWithState({
      schemaVersion: 5,
      scanState: {
        enabled: true,
        lastScanStartedAt: null,
        lastScanCompletedAt: null,
        lastScanError: null
      }
    })

    await store.refresh(true)

    const persistedJson = readFileSync(
      join(storeEnv.tempUserData, 'orca-codex-usage.json'),
      'utf-8'
    )
    expect(scanCodexUsageFilesViaWorker).toHaveBeenCalledWith([], {
      path: join(storeEnv.tempUserData, 'orca-codex-usage-sources.json'),
      schemaVersion: CODEX_USAGE_SCHEMA_VERSION,
      worktreeFingerprint: '[]',
      reuse: false
    })
    expect(persistedJson).toBe(JSON.stringify(JSON.parse(persistedJson)))
  })

  it('drops persisted caches from older schemas that lack scoped model breakdown data', () => {
    const normalized = normalizePersistedState({
      schemaVersion: 1,
      processedFiles: [],
      sessions: [
        {
          sessionId: 'legacy',
          firstTimestamp: '2026-04-09T10:00:00.000Z',
          lastTimestamp: '2026-04-09T10:10:00.000Z',
          primaryModel: 'gpt-5',
          hasMixedModels: false,
          primaryProjectLabel: 'Repo',
          hasMixedLocations: false,
          primaryWorktreeId: 'repo-1::/workspace/repo',
          primaryRepoId: 'repo-1',
          eventCount: 1,
          totalInputTokens: 1,
          totalCachedInputTokens: 0,
          totalOutputTokens: 1,
          totalReasoningOutputTokens: 0,
          totalTokens: 2,
          hasInferredPricing: false,
          locationBreakdown: [],
          modelBreakdown: []
        }
      ],
      dailyAggregates: [],
      scanState: {
        enabled: true,
        lastScanStartedAt: 1,
        lastScanCompletedAt: 2,
        lastScanError: null
      }
    } as unknown as CodexUsagePersistedState)

    expect(normalized).toEqual({
      schemaVersion: 6,
      worktreeFingerprint: null,
      processedFiles: [],
      sessions: [],
      dailyAggregates: [],
      scanState: {
        enabled: true,
        lastScanStartedAt: null,
        lastScanCompletedAt: null,
        lastScanError: null
      }
    })
  })

  it('rescans from scratch when the cache predates per-request long-context counts', async () => {
    const scanMock = vi.mocked(scanCodexUsageFilesViaWorker)
    const sourceCachePath = join(storeEnv.tempUserData, 'orca-codex-usage-sources.json')
    const cacheFile = join(storeEnv.tempUserData, 'orca-codex-usage.json')
    const seeded = new CodexUsageStore({ getRepos: () => [], getAllWorktreeMeta: () => ({}) })
    await seeded.setEnabled(true)
    await seeded.refresh(true)
    await seeded.flush()
    const current = readFileSync(cacheFile, 'utf-8')

    scanMock.mockClear()
    await new CodexUsageStore({ getRepos: () => [], getAllWorktreeMeta: () => ({}) }).refresh(true)
    // Control: a current-schema cache lets the worker reuse its processed files.
    expect(scanMock).toHaveBeenLastCalledWith([], {
      path: sourceCachePath,
      schemaVersion: CODEX_USAGE_SCHEMA_VERSION,
      worktreeFingerprint: '[]',
      reuse: true
    })

    writeFileSync(cacheFile, JSON.stringify({ ...JSON.parse(current), schemaVersion: 5 }))
    scanMock.mockClear()
    await new CodexUsageStore({ getRepos: () => [], getAllWorktreeMeta: () => ({}) }).refresh(false)
    expect(scanMock).toHaveBeenLastCalledWith([], {
      path: sourceCachePath,
      schemaVersion: CODEX_USAGE_SCHEMA_VERSION,
      worktreeFingerprint: '[]',
      reuse: false
    })
  })
})