orca/mobile/src/session/MobileNativeChatTurnStatus.test.ts

import { createElement } from 'react'
import { act, create, type ReactTestInstance, type ReactTestRenderer } from 'react-test-renderer'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'

vi.mock('react-native', async () => {
  const React = await import('react')
  const Text = ({ children, ...props }: { children?: unknown }): unknown =>
    React.createElement('Text', props, children)
  return {
    ActivityIndicator: (props: Record<string, unknown>) =>
      React.createElement('ActivityIndicator', props),
    Pressable: ({ children, ...props }: { children?: unknown }) =>
      React.createElement('Pressable', props, children),
    Text,
    View: ({ children, ...props }: { children?: unknown }) =>
      React.createElement('View', props, children),
    StyleSheet: { create: (styles: unknown) => styles, hairlineWidth: 1 }
  }
})
vi.mock('lucide-react-native', () => ({ ChevronRight: 'ChevronRight' }))

import {
  MobileNativeChatTurnActivity,
  MobileNativeChatTurnStatus
} from './MobileNativeChatTurnStatus'

const labels = (node: ReactTestInstance): string[] =>
  node.findAllByType('Text' as never).map((text) => String(text.children.join('')))

const spinners = (node: ReactTestInstance): ReactTestInstance[] =>
  node.findAllByType('ActivityIndicator' as never)

let renderer: ReactTestRenderer | null = null

beforeEach(() => {
  vi.useFakeTimers()
  vi.setSystemTime(new Date('2026-09-04T00:00:00Z'))
})

afterEach(() => {
  act(() => renderer?.unmount())
  renderer = null
  vi.useRealTimers()
})

describe('MobileNativeChatTurnStatus', () => {
  function render(props: {
    startedAt: number | null
    workedSeconds?: number | null
    verdict?: 'interruption' | 'cancellation'
    expanded?: boolean
    onToggleExpanded?: () => void
  }): ReactTestRenderer {
    act(() => {
      renderer = create(createElement(MobileNativeChatTurnStatus, props))
    })
    return renderer!
  }

  it('counts up from the first second while the turn runs, with no spinner', () => {
    const tree = render({ startedAt: Date.now() })
    expect(labels(tree.root)).toEqual(['Working for 0s'])
    act(() => {
      vi.advanceTimersByTime(12_000)
    })
    expect(labels(tree.root)).toEqual(['Working for 12s'])
    expect(spinners(tree.root)).toHaveLength(0)
  })

  it('settles to a tappable "Worked for" row that toggles the turn', () => {
    const onToggleExpanded = vi.fn()
    const tree = render({ startedAt: Date.now(), workedSeconds: 184, onToggleExpanded })
    expect(labels(tree.root)).toEqual(['Worked for 3m 4s'])
    const button = tree.root.findByType('Pressable' as never)
    expect(button.props.accessibilityLabel).toBe('Toggle turn details')
    expect(button.props.accessibilityState).toEqual({ expanded: false })
    act(() => button.props.onPress())
    expect(onToggleExpanded).toHaveBeenCalledOnce()
  })

  // The crash's notice row explains the cut; the turn bar reads like any finished turn.
  it('heads a turn a crash cut off as worked, and a turn the user stopped as interrupted', () => {
    const crashed = render({
      startedAt: Date.now(),
      workedSeconds: 12,
      verdict: 'interruption',
      onToggleExpanded: vi.fn()
    })
    expect(labels(crashed.root)).toEqual(['Worked for 12s'])
    act(() => crashed.unmount())
    const stopped = render({
      startedAt: Date.now(),
      workedSeconds: 12,
      verdict: 'cancellation',
      onToggleExpanded: vi.fn()
    })
    expect(labels(stopped.root)).toEqual(['Interrupted after 12s'])
  })

  it('stays a plain row when the settled turn has nothing to disclose', () => {
    const tree = render({ startedAt: Date.now(), workedSeconds: 5 })
    expect(tree.root.findAllByType('Pressable' as never)).toHaveLength(0)
    expect(labels(tree.root)).toEqual(['Worked for 5s'])
  })

  it('holds no interval once the turn has settled', () => {
    render({ startedAt: Date.now(), workedSeconds: 5 })
    expect(vi.getTimerCount()).toBe(0)
  })
})

describe('MobileNativeChatTurnActivity', () => {
  function render(props: { thinking: boolean; activityText?: string | null }): ReactTestRenderer {
    act(() => {
      renderer = create(createElement(MobileNativeChatTurnActivity, props))
    })
    return renderer!
  }

  it('reads "Thinking" beside one spinner while the turn reasons', () => {
    const tree = render({ thinking: true })
    expect(labels(tree.root)).toEqual(['Thinking'])
    expect(spinners(tree.root)).toHaveLength(1)
  })

  // The bar owns the clock; the tail line never repeats it.
  it('reads plain "Working…" when the turn is not reasoning, and holds no timer', () => {
    const tree = render({ thinking: false })
    expect(labels(tree.root)).toEqual(['Working…'])
    expect(vi.getTimerCount()).toBe(0)
  })

  it('lets provider activity text beat both fallbacks', () => {
    const tree = render({ thinking: true, activityText: 'Running pnpm test' })
    expect(labels(tree.root)).toEqual(['Running pnpm test'])
    expect(spinners(tree.root)).toHaveLength(1)
  })

  it('announces the live line to assistive tech', () => {
    const tree = render({ thinking: true })
    const row = tree.root.findByType('View' as never)
    expect(row.props.accessibilityLiveRegion).toBe('polite')
    expect(row.props.accessibilityLabel).toBe('Agent is responding')
  })
})