Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
16.3 KB
Raw Blame
import React, { useState } from 'react'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { act, cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react'
import {
  allowWorkflowApprovalTeam,
  getAdminTeams,
  getAdminUsers,
  listWorkflowApprovalAllowedTeams,
  listWorkflowGrants,
  listWorkflowTeamGrants,
  revokeWorkflowApprovalTeam,
  setWorkflowGrants,
  setWorkflowTeamGrants,
} from '@lib/api'
import { ToastProvider } from '../Toast'
import { WorkflowAccessPanel } from '../WorkflowAccessPanel'

vi.mock('@lib/api', () => ({
  getAdminUsers: vi.fn(),
  getAdminTeams: vi.fn(),
  listWorkflowGrants: vi.fn(),
  listWorkflowTeamGrants: vi.fn(),
  listWorkflowApprovalAllowedTeams: vi.fn(),
  isSilentApiError: (error: unknown) =>
    Boolean(error && typeof error === 'object' && (error as { silent?: unknown }).silent),
  setWorkflowGrants: vi.fn(),
  setWorkflowTeamGrants: vi.fn(),
  allowWorkflowApprovalTeam: vi.fn(),
  revokeWorkflowApprovalTeam: vi.fn(),
}))

function createDeferred<T>() {
  let resolve!: (value: T) => void
  let reject!: (reason?: unknown) => void
  const promise = new Promise<T>((res, rej) => {
    resolve = res
    reject = rej
  })
  return { promise, resolve, reject }
}

function EditHarness() {
  const [selectedUserIds, setSelectedUserIds] = useState<string[]>([])
  const [selectedTeamIds, setSelectedTeamIds] = useState<string[]>([])
  const [selectedApprovalTeamIds, setSelectedApprovalTeamIds] = useState<string[]>([])

  return (
    <ToastProvider>
      <WorkflowAccessPanel
        mode="edit"
        namespace="sandbox-recipes"
        recipeName="installed-recipe"
        selectedUserIds={selectedUserIds}
        selectedTeamIds={selectedTeamIds}
        selectedApprovalTeamIds={selectedApprovalTeamIds}
        onSelectedUserIdsChange={setSelectedUserIds}
        onSelectedTeamIdsChange={setSelectedTeamIds}
        onSelectedApprovalTeamIdsChange={setSelectedApprovalTeamIds}
      />
    </ToastProvider>
  )
}

const aliceGrant = {
  id: 'u-1',
  email: '[email protected]',
  name: 'Alice',
  displayName: null,
}

const bobGrant = {
  id: 'u-2',
  email: '[email protected]',
  name: 'Bob',
  displayName: null,
}

const triggerTeamGrant = {
  id: 'team-trigger',
  name: 'Trigger Team',
  createdAt: '2026-01-01T00:00:00Z',
}
const nextTeamGrant = { id: 'team-next', name: 'Next Team', createdAt: '2026-01-01T00:00:00Z' }
const finalTeamGrant = { id: 'team-final', name: 'Final Team', createdAt: '2026-01-01T00:00:00Z' }
const lastTeamGrant = { id: 'team-last', name: 'Last Team', createdAt: '2026-01-01T00:00:00Z' }

beforeEach(() => {
  vi.mocked(getAdminUsers).mockResolvedValue({
    items: [
      { ...aliceGrant, picture: null, activeTeamCount: 1 },
      { ...bobGrant, picture: null, activeTeamCount: 1 },
    ],
  })
  vi.mocked(getAdminTeams).mockResolvedValue({
    items: [
      { ...triggerTeamGrant, memberCount: 2 },
      { ...nextTeamGrant, memberCount: 2 },
      { ...finalTeamGrant, memberCount: 2 },
      { ...lastTeamGrant, memberCount: 2 },
    ],
  })
  vi.mocked(listWorkflowGrants).mockResolvedValue({ items: [] })
  vi.mocked(listWorkflowTeamGrants).mockResolvedValue({ items: [] })
  vi.mocked(listWorkflowApprovalAllowedTeams).mockResolvedValue({ items: [] })
  vi.mocked(setWorkflowGrants).mockResolvedValue({ userIds: [] })
  vi.mocked(setWorkflowTeamGrants).mockResolvedValue({ teamIds: [], added: [], removed: [] })
})

afterEach(() => {
  cleanup()
  vi.clearAllMocks()
})

describe('WorkflowAccessPanel', () => {
  it('does not render workflow access save-mode badges in the editor flow', async () => {
    render(<EditHarness />)

    await waitFor(() => expect(screen.getByText('Workflow access')).toBeInTheDocument())
    expect(screen.queryByText('Live save')).not.toBeInTheDocument()
    expect(screen.queryByText('Saved on deploy')).not.toBeInTheDocument()
  })

  it('does not render team ids as secondary text in team access sections', async () => {
    vi.mocked(listWorkflowTeamGrants).mockResolvedValue({ items: [triggerTeamGrant] })
    vi.mocked(listWorkflowApprovalAllowedTeams).mockResolvedValue({ items: [nextTeamGrant] })

    render(<EditHarness />)

    fireEvent.click(screen.getByRole('tab', { name: /Teams/ }))
    const teamSection = screen.getByTestId('workflow-access-trigger-teams')
    await waitFor(() => expect(within(teamSection).getByText('Trigger Team')).toBeInTheDocument())
    fireEvent.click(within(teamSection).getByRole('button', { name: 'Add team' }))
    const teamDialog = screen.getByRole('dialog', { name: 'Add team' })
    expect(within(teamDialog).getByRole('option', { name: 'Next Team' })).toBeInTheDocument()
    expect(within(teamSection).queryByText('team-trigger')).not.toBeInTheDocument()
    expect(within(teamDialog).queryByText('team-next')).not.toBeInTheDocument()
    fireEvent.click(within(teamDialog).getByRole('button', { name: 'Cancel' }))

    fireEvent.click(screen.getByRole('tab', { name: /Approval target teams/ }))
    const approvalSection = screen.getByTestId('workflow-access-approval-target-teams')
    await waitFor(() => expect(within(approvalSection).getByText('Next Team')).toBeInTheDocument())
    fireEvent.click(within(approvalSection).getByRole('button', { name: 'Allow team' }))
    const approvalDialog = screen.getByRole('dialog', { name: 'Allow team' })
    expect(within(approvalDialog).getByRole('option', { name: 'Trigger Team' })).toBeInTheDocument()
    expect(within(approvalSection).queryByText('team-trigger')).not.toBeInTheDocument()
    expect(within(approvalSection).queryByText('team-next')).not.toBeInTheDocument()
  })

  it('confirms before revoking loaded member trigger access', async () => {
    vi.mocked(listWorkflowGrants).mockResolvedValue({ items: [aliceGrant, bobGrant] })

    render(<EditHarness />)

    const section = screen.getByTestId('workflow-access-trigger-users')
    await waitFor(() => expect(within(section).getByText(/alice@example\.com/)).toBeInTheDocument())

    fireEvent.click(
      within(section).getByRole('button', { name: 'Actions for member trigger access: Alice' })
    )
    fireEvent.click(await screen.findByRole('menuitem', { name: 'Remove member trigger access' }))
    expect(setWorkflowGrants).not.toHaveBeenCalled()
    expect(
      await screen.findByRole('alertdialog', { name: 'Remove Member Trigger Access' })
    ).toBeInTheDocument()

    fireEvent.click(screen.getByRole('button', { name: 'Remove access' }))

    await waitFor(() =>
      expect(setWorkflowGrants).toHaveBeenCalledWith('sandbox-recipes', 'installed-recipe', ['u-2'])
    )
  })

  it('sorts visible access records by human identity with a stable id tie-break', async () => {
    vi.mocked(listWorkflowGrants).mockResolvedValue({
      items: [
        bobGrant,
        { id: 'u-10', email: '[email protected]', name: 'Same', displayName: null },
        { id: 'u-3', email: '[email protected]', name: 'Same', displayName: null },
        aliceGrant,
      ],
    })

    render(<EditHarness />)

    const section = screen.getByTestId('workflow-access-trigger-users')
    await waitFor(() => expect(within(section).getByText('Alice')).toBeInTheDocument())
    const rows = section.querySelectorAll('.cu-workflow-access__row-title')
    expect([...rows].map(row => row.textContent)).toEqual(['Alice', 'Bob', 'Same', 'Same'])
    expect(
      within(section)
        .getAllByRole('listitem')
        .map(row => row.getAttribute('data-access-id'))
    ).toEqual(['u-1', 'u-2', 'u-3', 'u-10'])
    expect(section.querySelector('.cu-workflow-access__rows')).toHaveAttribute('role', 'list')
  })

  it('sorts trigger-team and approval-team records by name with stable id tie-breaks', async () => {
    vi.mocked(listWorkflowTeamGrants).mockResolvedValue({
      items: [
        { id: 'team-z', name: 'Zulu' },
        { id: 'team-10', name: 'Same Team' },
        { id: 'team-2', name: 'Same Team' },
        { id: 'team-a', name: 'Alpha Team' },
      ],
    })
    vi.mocked(listWorkflowApprovalAllowedTeams).mockResolvedValue({
      items: [
        { id: 'approval-z', name: 'Zulu Approval', createdAt: '2026-01-01T00:00:00Z' },
        { id: 'approval-10', name: 'Same Approval', createdAt: '2026-01-01T00:00:00Z' },
        { id: 'approval-2', name: 'Same Approval', createdAt: '2026-01-01T00:00:00Z' },
        { id: 'approval-a', name: 'Alpha Approval', createdAt: '2026-01-01T00:00:00Z' },
      ],
    })

    render(<EditHarness />)

    fireEvent.click(screen.getByRole('tab', { name: /Teams/ }))
    const teamSection = screen.getByTestId('workflow-access-trigger-teams')
    await waitFor(() => expect(within(teamSection).getByText('Alpha Team')).toBeInTheDocument())
    expect(
      within(teamSection)
        .getAllByRole('listitem')
        .map(row => row.getAttribute('data-access-id'))
    ).toEqual(['team-a', 'team-2', 'team-10', 'team-z'])

    fireEvent.click(screen.getByRole('tab', { name: /Approval target teams/ }))
    const approvalSection = screen.getByTestId('workflow-access-approval-target-teams')
    await waitFor(() =>
      expect(within(approvalSection).getByText('Alpha Approval')).toBeInTheDocument()
    )
    expect(
      within(approvalSection)
        .getAllByRole('listitem')
        .map(row => row.getAttribute('data-access-id'))
    ).toEqual(['approval-a', 'approval-2', 'approval-10', 'approval-z'])
  })

  it('blocks live grant writes until the current edit-mode grants are loaded', async () => {
    const userGrants = createDeferred<{ items: (typeof aliceGrant)[] }>()
    const teamGrants = createDeferred<{ items: (typeof triggerTeamGrant)[] }>()
    vi.mocked(listWorkflowGrants)
      .mockReturnValueOnce(userGrants.promise)
      .mockResolvedValue({ items: [aliceGrant, bobGrant] })
    vi.mocked(listWorkflowTeamGrants)
      .mockReturnValueOnce(teamGrants.promise)
      .mockResolvedValue({ items: [triggerTeamGrant, nextTeamGrant] })

    render(<EditHarness />)

    await waitFor(() => expect(screen.getByText('Loading workflow access...')).toBeInTheDocument())

    fireEvent.click(screen.getByRole('tab', { name: /Teams/ }))
    const teamSection = screen.getByTestId('workflow-access-trigger-teams')

    fireEvent.click(screen.getByRole('tab', { name: /Members/ }))
    expect(
      within(screen.getByTestId('workflow-access-trigger-users')).getByRole('button', {
        name: /^Add member$/,
      })
    ).toBeDisabled()
    fireEvent.click(screen.getByRole('tab', { name: /Teams/ }))
    expect(
      within(screen.getByTestId('workflow-access-trigger-teams')).getByRole('button', {
        name: /^Add team$/,
      })
    ).toBeDisabled()

    expect(setWorkflowGrants).not.toHaveBeenCalled()
    expect(setWorkflowTeamGrants).not.toHaveBeenCalled()

    await act(async () => {
      userGrants.resolve({ items: [aliceGrant] })
      teamGrants.resolve({ items: [triggerTeamGrant] })
    })

    fireEvent.click(screen.getByRole('tab', { name: /Members/ }))
    await waitFor(() => expect(screen.getByText(/alice@example\.com/)).toBeInTheDocument())
    fireEvent.click(screen.getByRole('tab', { name: /Teams/ }))
    await waitFor(() =>
      expect(
        within(screen.getByTestId('workflow-access-trigger-teams')).getByText('Trigger Team')
      ).toBeInTheDocument()
    )
    fireEvent.click(screen.getByRole('tab', { name: /Members/ }))
    fireEvent.click(screen.getByRole('button', { name: /^Add member$/ }))
    const loadedUserPick = screen.getByRole('textbox', { name: 'Search members...' })
    expect(loadedUserPick).not.toBeDisabled()
    const userDialog = screen.getByRole('dialog', { name: 'Add member' })
    fireEvent.click(within(userDialog).getByRole('option', { name: 'Bob, [email protected]' }))
    expect(userDialog.querySelector('.cu-selection-dropdown__chips')).toHaveTextContent('Bob')
    fireEvent.click(within(userDialog).getByRole('button', { name: 'Add member' }))
    await waitFor(() =>
      expect(setWorkflowGrants).toHaveBeenCalledWith('sandbox-recipes', 'installed-recipe', [
        'u-1',
        'u-2',
      ])
    )

    fireEvent.click(screen.getByRole('tab', { name: /Teams/ }))
    const loadedTeamSection = screen.getByTestId('workflow-access-trigger-teams')
    fireEvent.click(within(loadedTeamSection).getByRole('button', { name: 'Add team' }))
    const addTeamDialog = screen.getByRole('dialog', { name: 'Add team' })
    expect(
      within(addTeamDialog).getByRole('textbox', { name: 'Search teams...' })
    ).not.toBeDisabled()
    fireEvent.click(within(addTeamDialog).getByRole('option', { name: 'Next Team' }))
    expect(addTeamDialog.querySelector('.cu-selection-dropdown__chips')).toHaveTextContent(
      'Next Team'
    )
    fireEvent.click(within(addTeamDialog).getByRole('button', { name: 'Add team' }))
    await waitFor(() =>
      expect(setWorkflowTeamGrants).toHaveBeenCalledWith('sandbox-recipes', 'installed-recipe', [
        'team-trigger',
        'team-next',
      ])
    )
  })

  it('serializes approval-team writes, reloads after a rate limit, and shows one retry message', async () => {
    const firstAllow = createDeferred<{ teamId: string }>()
    const rateLimitError = Object.assign(new Error('429 Too Many Requests'), {
      status: 429,
      body: { error: 'Too Many Requests', retryAfterSeconds: 12 },
    })
    vi.mocked(listWorkflowApprovalAllowedTeams).mockResolvedValue({ items: [triggerTeamGrant] })
    vi.mocked(allowWorkflowApprovalTeam)
      .mockReturnValueOnce(firstAllow.promise)
      .mockRejectedValueOnce(rateLimitError)

    render(<EditHarness />)

    fireEvent.click(screen.getByRole('tab', { name: /Approval target teams/ }))
    const section = screen.getByTestId('workflow-access-approval-target-teams')
    await waitFor(() => expect(within(section).getByText('Trigger Team')).toBeInTheDocument())

    fireEvent.click(within(section).getByRole('button', { name: 'Allow team' }))
    const dialog = screen.getByRole('dialog', { name: 'Allow team' })
    fireEvent.click(within(dialog).getByRole('option', { name: 'Next Team' }))
    fireEvent.click(within(dialog).getByRole('option', { name: 'Final Team' }))
    fireEvent.click(within(dialog).getByRole('option', { name: 'Last Team' }))
    fireEvent.click(within(dialog).getByRole('button', { name: 'Allow teams' }))

    await waitFor(() => expect(allowWorkflowApprovalTeam).toHaveBeenCalledTimes(1))
    expect(allowWorkflowApprovalTeam).toHaveBeenCalledWith(
      'sandbox-recipes',
      'installed-recipe',
      'team-next'
    )
    expect(allowWorkflowApprovalTeam).toHaveBeenCalledTimes(1)

    await act(async () => {
      firstAllow.resolve({ teamId: 'team-next' })
    })

    await waitFor(() => expect(allowWorkflowApprovalTeam).toHaveBeenCalledTimes(2))
    await waitFor(() => expect(listWorkflowApprovalAllowedTeams).toHaveBeenCalledTimes(2))
    expect(allowWorkflowApprovalTeam).toHaveBeenLastCalledWith(
      'sandbox-recipes',
      'installed-recipe',
      'team-final'
    )
    expect(allowWorkflowApprovalTeam).not.toHaveBeenCalledWith(
      'sandbox-recipes',
      'installed-recipe',
      'team-last'
    )
    expect(revokeWorkflowApprovalTeam).not.toHaveBeenCalled()
    expect(within(section).getByRole('alert')).toHaveTextContent(
      'Some changes were saved. Too many approval target team changes. Try again in about 12 seconds.'
    )
    expect(screen.queryByText('Approval target teams updated.')).not.toBeInTheDocument()
  })

  it('stops approval-team writes when the session expires', async () => {
    const authExpired = Object.assign(new Error('Session expired'), {
      status: 401,
      silent: true,
    })
    vi.mocked(allowWorkflowApprovalTeam).mockRejectedValueOnce(authExpired)

    render(<EditHarness />)

    fireEvent.click(screen.getByRole('tab', { name: /Approval target teams/ }))
    const section = screen.getByTestId('workflow-access-approval-target-teams')
    await waitFor(() =>
      expect(within(section).getByRole('button', { name: 'Allow team' })).toBeEnabled()
    )
    fireEvent.click(within(section).getByRole('button', { name: 'Allow team' }))
    const dialog = screen.getByRole('dialog', { name: 'Allow team' })
    fireEvent.click(within(dialog).getByRole('option', { name: 'Next Team' }))
    fireEvent.click(within(dialog).getByRole('button', { name: 'Allow team' }))

    await waitFor(() => expect(allowWorkflowApprovalTeam).toHaveBeenCalledOnce())
    expect(revokeWorkflowApprovalTeam).not.toHaveBeenCalled()
    expect(listWorkflowApprovalAllowedTeams).toHaveBeenCalledOnce()
    expect(within(section).queryByRole('alert')).not.toBeInTheDocument()
  })
})