code-coordinator 0.5.46__py3-none-any.whl

coord/dashboard/webapp/src/components/__tests__/Gallery.test.tsx

@@ -0,0 +1,83 @@
+/**
+ * Smoke test for the dev-only component gallery (#1546) — the acceptance
+ * bar is "every primitive renders correctly in both themes; the gallery
+ * proves it," so this renders the gallery, checks every primitive's marker
+ * text is on screen, and exercises the live theme toggle end-to-end
+ * (button click → data-theme attribute → localStorage persistence).
+ *
+ * Deliberately does not open the Radix-portalled overlays (Dialog/
+ * DropdownMenu/Sheet/Tooltip) here -- doing so needs jsdom polyfills for
+ * pointer capture / scrollIntoView that Radix's own test suite already
+ * covers; this test's job is "does our styling wrapper mount," not
+ * "does Radix work."
+ */
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { render, screen, fireEvent } from '@testing-library/react'
+import Gallery from '../Gallery'
+import { THEME_STORAGE_KEY } from '@/components/ui/theme-provider'
+
+describe('Gallery', () => {
+  beforeEach(() => {
+    window.localStorage.clear()
+    document.documentElement.removeAttribute('data-theme')
+  })
+
+  afterEach(() => {
+    window.localStorage.clear()
+    document.documentElement.removeAttribute('data-theme')
+  })
+
+  it('renders every primitive section', () => {
+    render(<Gallery />)
+
+    // Button ("Primary"/"Outline"/"Destructive" also label buttons in the
+    // side-by-side preview and the toast triggers further down, hence
+    // getAllByRole rather than getByRole for those.
+    expect(screen.getAllByRole('button', { name: 'Primary' }).length).toBeGreaterThanOrEqual(1)
+    expect(screen.getAllByRole('button', { name: 'Destructive' }).length).toBeGreaterThanOrEqual(1)
+    expect(screen.getByRole('button', { name: 'Disabled' })).toBeDisabled()
+
+    // Badge ("Passed"/"Failed" also appear in the side-by-side preview).
+    expect(screen.getAllByText('Passed').length).toBeGreaterThanOrEqual(1)
+    expect(screen.getAllByText('Failed').length).toBeGreaterThanOrEqual(1)
+
+    // Card
+    expect(screen.getByText('W1-1: design tokens')).toBeInTheDocument()
+
+    // Tabs
+    expect(screen.getByRole('tab', { name: /Overview/ })).toHaveAttribute(
+      'aria-selected',
+      'true',
+    )
+
+    // Dialog / dropdown-menu / sheet / tooltip triggers
+    expect(screen.getByRole('button', { name: 'Open dialog' })).toBeInTheDocument()
+    expect(screen.getByRole('button', { name: 'More actions' })).toBeInTheDocument()
+    expect(screen.getByRole('button', { name: 'Open action sheet' })).toBeInTheDocument()
+    expect(screen.getByRole('button', { name: 'Help' })).toBeInTheDocument()
+
+    // Empty state
+    expect(screen.getByText('No issues match this filter')).toBeInTheDocument()
+
+    // Toast triggers
+    expect(screen.getByRole('button', { name: 'Success' })).toBeInTheDocument()
+
+    // Side-by-side dark/light preview (plus the header's current-theme label,
+    // which also reads "dark" -- hence getAllByText, not getByText).
+    expect(screen.getAllByText('dark').length).toBeGreaterThanOrEqual(1)
+    expect(screen.getByText('light')).toBeInTheDocument()
+  })
+
+  it('the live theme toggle flips data-theme and persists the choice', () => {
+    window.localStorage.setItem(THEME_STORAGE_KEY, 'dark')
+    render(<Gallery />)
+
+    expect(document.documentElement.getAttribute('data-theme')).toBe('dark')
+
+    fireEvent.click(screen.getByRole('button', { name: 'Switch to light theme' }))
+
+    expect(document.documentElement.getAttribute('data-theme')).toBe('light')
+    expect(window.localStorage.getItem(THEME_STORAGE_KEY)).toBe('light')
+    expect(screen.getByRole('button', { name: 'Switch to dark theme' })).toBeInTheDocument()
+  })
+})

coord/dashboard/webapp/src/components/__tests__/Home.test.tsx

@@ -0,0 +1,271 @@
+/**
+ * Component tests for the Home screen's "Live sessions" section (#1067) and
+ * the Active tab's in-progress/done grouping (#1218).
+ *
+ * Mocks @/api/client entirely; wraps renders in a QueryClientProvider +
+ * MemoryRouter so useQuery / useNavigate work correctly, matching
+ * Detail.test.tsx's pattern.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { render, screen, waitFor } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { MemoryRouter, Routes, Route } from 'react-router-dom'
+import Home from '@/components/Home'
+import { ThemeProvider } from '@/components/ui/theme-provider'
+import { type PipelineView, type SessionInfo } from '@/api/client'
+
+// ── Mock API client + navigate ────────────────────────────────────────────────
+
+vi.mock('@/api/client', () => ({
+  fetchPipeline: vi.fn(),
+  fetchSessions: vi.fn(),
+}))
+
+import { fetchPipeline, fetchSessions } from '@/api/client'
+
+const navigateSpy = vi.fn()
+vi.mock('react-router-dom', async () => {
+  const actual = await vi.importActual<typeof import('react-router-dom')>('react-router-dom')
+  return { ...actual, useNavigate: () => navigateSpy }
+})
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+// ── Test helpers ──────────────────────────────────────────────────────────────
+
+function makeView(overrides: Partial<PipelineView> = {}): PipelineView {
+  return {
+    assignment_id: 'work-1',
+    issue_number: 42,
+    issue_title: 'Fix the thing',
+    repo_name: 'myrepo',
+    machine_name: 'laptop',
+    current_stage: 'coding',
+    stages: [
+      { name: 'coding', status: 'active', is_current: true },
+      { name: 'review', status: 'waiting', is_current: false },
+      { name: 'smoke', status: 'waiting', is_current: false },
+      { name: 'merge', status: 'waiting', is_current: false },
+    ],
+    available_gates: [],
+    progress_pct: 10,
+    review_findings_pending: false,
+    review_verdict: null,
+    // #1456: null = the reviewer's own verdict stands (the normal case).
+    review_verdict_original: null,
+    review_verdict_override_reason: null,
+    review_findings_body: null,
+    test_verdict: null,
+    needs_attention: false,
+    needs_attention_reason: null,
+    needs_attention_detail: null,
+    finished_at: null,
+    ...overrides,
+  }
+}
+
+function makeSession(overrides: Partial<SessionInfo> = {}): SessionInfo {
+  return {
+    session_id: 'work-2',
+    session_name: 'coord-work-2',
+    machine: 'desktop',
+    host: 'desktop.tailnet.ts.net',
+    repo: 'otherrepo',
+    issue: 7,
+    issue_title: 'Live session issue',
+    stage: 'work',
+    status: 'running',
+    attached: false,
+    pane_dead: false,
+    ...overrides,
+  }
+}
+
+function createTestQueryClient() {
+  return new QueryClient({
+    defaultOptions: {
+      queries: { retry: false, refetchInterval: false, refetchOnWindowFocus: false },
+    },
+  })
+}
+
+function renderHome() {
+  return render(
+    <ThemeProvider>
+      <QueryClientProvider client={createTestQueryClient()}>
+        <MemoryRouter initialEntries={['/']}>
+          <Routes>
+            <Route path="/" element={<Home />} />
+          </Routes>
+        </MemoryRouter>
+      </QueryClientProvider>
+    </ThemeProvider>,
+  )
+}
+
+// ── Live sessions section ─────────────────────────────────────────────────────
+
+describe('Home — live sessions section', () => {
+  it('renders live session cards above the pipeline list', async () => {
+    vi.mocked(fetchPipeline).mockResolvedValue([makeView()])
+    vi.mocked(fetchSessions).mockResolvedValue([makeSession()])
+
+    renderHome()
+
+    await waitFor(() => {
+      expect(screen.getByText('Live sessions')).toBeInTheDocument()
+    })
+    expect(screen.getByText('Live session issue')).toBeInTheDocument()
+
+    // The "Live sessions" heading appears before the pipeline card in DOM order.
+    const heading = screen.getByText('Live sessions')
+    const pipelineCard = screen.getByText('Fix the thing')
+    expect(
+      heading.compareDocumentPosition(pipelineCard) & Node.DOCUMENT_POSITION_FOLLOWING,
+    ).toBeTruthy()
+  })
+
+  it('renders no "Live sessions" heading when there are no live sessions', async () => {
+    vi.mocked(fetchPipeline).mockResolvedValue([makeView()])
+    vi.mocked(fetchSessions).mockResolvedValue([])
+
+    renderHome()
+
+    await waitFor(() => {
+      expect(screen.getByText('Fix the thing')).toBeInTheDocument()
+    })
+    expect(screen.queryByText('Live sessions')).not.toBeInTheDocument()
+  })
+
+  it('navigates to /terminal/:sessionId when a session card is tapped', async () => {
+    vi.mocked(fetchPipeline).mockResolvedValue([])
+    vi.mocked(fetchSessions).mockResolvedValue([makeSession()])
+
+    renderHome()
+
+    const card = await screen.findByText('Live session issue')
+    await userEvent.click(card)
+
+    expect(navigateSpy).toHaveBeenCalledWith('/terminal/work-2')
+  })
+})
+
+// ── Active tab: in-progress/done grouping (#1218) ───────────────────────────────
+
+describe('Home — Active tab grouping', () => {
+  it('renders in-progress items expanded, needs-me first then running', async () => {
+    // Incoming (API) order deliberately scrambled: running item first, then
+    // a needs-me (failed, offers retry) item — expect needs-me to sort first.
+    const running = makeView({
+      assignment_id: 'a-running',
+      issue_title: 'Running item',
+      current_stage: 'coding',
+      available_gates: [],
+    })
+    const needsMe = makeView({
+      assignment_id: 'a-needs-me',
+      issue_title: 'Failed item needing retry',
+      current_stage: 'failed',
+      available_gates: [{ action: 'retry', label: 'Retry', endpoint: '/api/pipeline/action' }],
+    })
+    vi.mocked(fetchPipeline).mockResolvedValue([running, needsMe])
+    vi.mocked(fetchSessions).mockResolvedValue([])
+
+    renderHome()
+
+    const needsMeCard = await screen.findByText('Failed item needing retry')
+    const runningCard = screen.getByText('Running item')
+    expect(
+      needsMeCard.compareDocumentPosition(runningCard) & Node.DOCUMENT_POSITION_FOLLOWING,
+    ).toBeTruthy()
+  })
+
+  it('collapses done-ish items into a "Work done (N)" section by default', async () => {
+    const running = makeView({
+      assignment_id: 'a-running',
+      issue_title: 'Running item',
+      current_stage: 'coding',
+    })
+    const done1 = makeView({
+      assignment_id: 'a-done-1',
+      issue_title: 'Finished thing one',
+      current_stage: 'done',
+      available_gates: [{ action: 'enqueue', label: 'Queue', endpoint: '/api/pipeline/action' }],
+      finished_at: 100,
+    })
+    const done2 = makeView({
+      assignment_id: 'a-done-2',
+      issue_title: 'Finished thing two',
+      current_stage: 'review_done',
+      available_gates: [{ action: 'enqueue', label: 'Queue', endpoint: '/api/pipeline/action' }],
+      finished_at: 200,
+    })
+    vi.mocked(fetchPipeline).mockResolvedValue([running, done1, done2])
+    vi.mocked(fetchSessions).mockResolvedValue([])
+
+    renderHome()
+
+    await waitFor(() => {
+      expect(screen.getByText('Running item')).toBeInTheDocument()
+    })
+
+    // Collapsed by default: header with count shown, done cards not rendered.
+    expect(screen.getByText('Work done (2)')).toBeInTheDocument()
+    expect(screen.queryByText('Finished thing one')).not.toBeInTheDocument()
+    expect(screen.queryByText('Finished thing two')).not.toBeInTheDocument()
+  })
+
+  it('expands the Work done section on tap, sorted by recency descending', async () => {
+    const older = makeView({
+      assignment_id: 'a-done-older',
+      issue_title: 'Older done item',
+      current_stage: 'done',
+      available_gates: [{ action: 'enqueue', label: 'Queue', endpoint: '/api/pipeline/action' }],
+      finished_at: 100,
+    })
+    const newer = makeView({
+      assignment_id: 'a-done-newer',
+      issue_title: 'Newer done item',
+      current_stage: 'smoke_passed',
+      available_gates: [{ action: 'enqueue', label: 'Queue', endpoint: '/api/pipeline/action' }],
+      finished_at: 200,
+    })
+    vi.mocked(fetchPipeline).mockResolvedValue([older, newer])
+    vi.mocked(fetchSessions).mockResolvedValue([])
+
+    renderHome()
+
+    const toggle = await screen.findByText('Work done (2)')
+    await userEvent.click(toggle)
+
+    const newerCard = await screen.findByText('Newer done item')
+    const olderCard = await screen.findByText('Older done item')
+    expect(
+      newerCard.compareDocumentPosition(olderCard) & Node.DOCUMENT_POSITION_FOLLOWING,
+    ).toBeTruthy()
+  })
+
+  it('keeps the "Needs me" tab as a flat, ungrouped list', async () => {
+    const done = makeView({
+      assignment_id: 'a-done',
+      issue_title: 'Finished needing merge',
+      current_stage: 'done',
+      available_gates: [{ action: 'enqueue', label: 'Queue', endpoint: '/api/pipeline/action' }],
+      finished_at: 100,
+    })
+    vi.mocked(fetchPipeline).mockResolvedValue([done])
+    vi.mocked(fetchSessions).mockResolvedValue([])
+
+    renderHome()
+
+    const tab = await screen.findByRole('tab', { name: /Needs me/i })
+    await userEvent.click(tab)
+
+    // Rendered directly — no collapsed "Work done" wrapper on this tab.
+    expect(await screen.findByText('Finished needing merge')).toBeInTheDocument()
+    expect(screen.queryByText(/Work done \(/)).not.toBeInTheDocument()
+  })
+})

coord/dashboard/webapp/src/components/__tests__/MobileKeyBar.test.tsx

@@ -0,0 +1,197 @@
+/**
+ * Component tests for MobileKeyBar (#1070, #1299) -- the acceptance criterion
+ * is "each soft-key emits the correct escape / control bytes to the terminal
+ * write path (mocked)". `onSend` stands in for that write path here;
+ * `Terminal.test.tsx` covers the real (fake) WebSocket wiring end-to-end.
+ *
+ * Scroll-mode tests (#1299): assert the toggle, swapped key rows, and the
+ * line-submit-exits-scroll-first invariant.
+ */
+import { describe, it, expect, vi } from 'vitest'
+import { render, screen, waitFor } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import MobileKeyBar, { KEY_BYTES } from '@/components/MobileKeyBar'
+
+const noop = () => {}
+
+describe('MobileKeyBar', () => {
+  it.each([
+    ['Escape', KEY_BYTES.escape],
+    ['Tab', KEY_BYTES.tab],
+    ['Ctrl-C', KEY_BYTES.ctrlC],
+    ['Slash', KEY_BYTES.slash],
+    ['Left', KEY_BYTES.left],
+    ['Up', KEY_BYTES.up],
+    ['Down', KEY_BYTES.down],
+    ['Right', KEY_BYTES.right],
+    ['Enter', KEY_BYTES.enter],
+  ])('%s sends %j', async (ariaLabel, expectedBytes) => {
+    const onSend = vi.fn()
+    render(<MobileKeyBar onSend={onSend} onControl={noop} />)
+
+    await userEvent.click(screen.getByRole('button', { name: ariaLabel }))
+
+    expect(onSend).toHaveBeenCalledOnce()
+    expect(onSend).toHaveBeenCalledWith(expectedBytes)
+  })
+
+  it('sends the typed line followed by a carriage return on submit, then clears the field', async () => {
+    const onSend = vi.fn()
+    render(<MobileKeyBar onSend={onSend} onControl={noop} />)
+
+    const input = screen.getByRole('textbox', { name: 'Command line' })
+    await userEvent.type(input, '/status')
+    await userEvent.click(screen.getByRole('button', { name: 'Send line' }))
+
+    expect(onSend).toHaveBeenCalledOnce()
+    expect(onSend).toHaveBeenCalledWith('/status\r')
+    expect(input).toHaveValue('')
+  })
+
+  it('does not send an empty line', async () => {
+    const onSend = vi.fn()
+    render(<MobileKeyBar onSend={onSend} onControl={noop} />)
+
+    await userEvent.click(screen.getByRole('button', { name: 'Send line' }))
+
+    expect(onSend).not.toHaveBeenCalled()
+  })
+
+  it("submits the line on the field's own Enter key, same as tapping Send", async () => {
+    const onSend = vi.fn()
+    render(<MobileKeyBar onSend={onSend} onControl={noop} />)
+
+    const input = screen.getByRole('textbox', { name: 'Command line' })
+    await userEvent.type(input, 'ls{Enter}')
+
+    expect(onSend).toHaveBeenCalledOnce()
+    expect(onSend).toHaveBeenCalledWith('ls\r')
+  })
+
+  it('does not steal focus from the line-input when a soft key is tapped', async () => {
+    const onSend = vi.fn()
+    render(<MobileKeyBar onSend={onSend} onControl={noop} />)
+
+    const input = screen.getByRole('textbox', { name: 'Command line' })
+    input.focus()
+    expect(input).toHaveFocus()
+
+    await userEvent.click(screen.getByRole('button', { name: 'Ctrl-C' }))
+
+    expect(input).toHaveFocus()
+    expect(onSend).toHaveBeenCalledOnce()
+    expect(onSend).toHaveBeenCalledWith(KEY_BYTES.ctrlC)
+  })
+})
+
+describe('MobileKeyBar — scroll mode (#1299)', () => {
+  it('tapping Scroll emits onControl("enter") and shows the SCROLL badge', async () => {
+    const onControl = vi.fn()
+    render(<MobileKeyBar onSend={noop} onControl={onControl} />)
+
+    // Scroll button exists in normal mode
+    await userEvent.click(screen.getByRole('button', { name: 'Scroll' }))
+
+    expect(onControl).toHaveBeenCalledOnce()
+    expect(onControl).toHaveBeenCalledWith('enter')
+
+    // SCROLL badge is now visible
+    expect(screen.getByRole('status', { name: 'Scroll mode active' })).toBeInTheDocument()
+  })
+
+  it('tapping Exit Scroll emits onControl("exit") and hides the badge', async () => {
+    const onControl = vi.fn()
+    render(<MobileKeyBar onSend={noop} onControl={onControl} />)
+
+    // Enter scroll mode first
+    await userEvent.click(screen.getByRole('button', { name: 'Scroll' }))
+    onControl.mockClear()
+
+    // Exit scroll mode
+    await userEvent.click(screen.getByRole('button', { name: 'Exit Scroll' }))
+
+    expect(onControl).toHaveBeenCalledOnce()
+    expect(onControl).toHaveBeenCalledWith('exit')
+
+    // Badge is gone; normal keys are back
+    expect(screen.queryByRole('status', { name: 'Scroll mode active' })).not.toBeInTheDocument()
+    expect(screen.getByRole('button', { name: 'Scroll' })).toBeInTheDocument()
+  })
+
+  it('scroll controls emit the correct actions while in scroll mode', async () => {
+    const onControl = vi.fn()
+    render(<MobileKeyBar onSend={noop} onControl={onControl} />)
+
+    await userEvent.click(screen.getByRole('button', { name: 'Scroll' }))
+    onControl.mockClear()
+
+    const cases: Array<[string, string]> = [
+      ['Page Up', 'page-up'],
+      ['Page Down', 'page-down'],
+      ['Top', 'top'],
+      ['Bottom', 'bottom'],
+    ]
+    for (const [label, action] of cases) {
+      await userEvent.click(screen.getByRole('button', { name: label }))
+      expect(onControl).toHaveBeenLastCalledWith(action)
+    }
+  })
+
+  it('normal key rows are absent while in scroll mode', async () => {
+    render(<MobileKeyBar onSend={noop} onControl={noop} />)
+
+    await userEvent.click(screen.getByRole('button', { name: 'Scroll' }))
+
+    // Normal-mode-only keys must be gone while in scroll mode
+    expect(screen.queryByRole('button', { name: 'Escape' })).not.toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Up' })).not.toBeInTheDocument()
+  })
+
+  it('submitting the line-input in scroll mode sends exit before the text', async () => {
+    const onSend = vi.fn()
+    const onControl = vi.fn()
+    render(<MobileKeyBar onSend={onSend} onControl={onControl} />)
+
+    // Enter scroll mode
+    await userEvent.click(screen.getByRole('button', { name: 'Scroll' }))
+    onControl.mockClear()
+
+    // Type and submit text
+    const input = screen.getByRole('textbox', { name: 'Command line' })
+    await userEvent.type(input, 'hello')
+    await userEvent.click(screen.getByRole('button', { name: 'Send line' }))
+
+    // exit must have been called before onSend
+    expect(onControl).toHaveBeenCalledOnce()
+    expect(onControl).toHaveBeenCalledWith('exit')
+
+    expect(onSend).toHaveBeenCalledOnce()
+    expect(onSend).toHaveBeenCalledWith('hello\r')
+
+    // Scroll mode is now off
+    expect(screen.queryByRole('status', { name: 'Scroll mode active' })).not.toBeInTheDocument()
+  })
+
+  it('scroll mode resets to off when connectionKey changes (reconnect)', async () => {
+    const onControl = vi.fn()
+    const { rerender } = render(
+      <MobileKeyBar onSend={noop} onControl={onControl} connectionKey={1} />,
+    )
+
+    // Enter scroll mode
+    await userEvent.click(screen.getByRole('button', { name: 'Scroll' }))
+    expect(screen.getByRole('status', { name: 'Scroll mode active' })).toBeInTheDocument()
+
+    // Simulate reconnect: connectionKey increments
+    rerender(<MobileKeyBar onSend={noop} onControl={onControl} connectionKey={2} />)
+
+    // Badge must be gone
+    await waitFor(() =>
+      expect(
+        screen.queryByRole('status', { name: 'Scroll mode active' }),
+      ).not.toBeInTheDocument(),
+    )
+    // Normal Scroll button is back
+    expect(screen.getByRole('button', { name: 'Scroll' })).toBeInTheDocument()
+  })
+})