Skip to content

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

TypeScript
43.0 KB
Raw Blame
import type { ReactNode } from 'react'
import { afterEach, describe, expect, it, vi } from 'vitest'
import { cleanup, fireEvent, render as rtlRender, screen, waitFor } from '@testing-library/react'
import * as api from '../../lib/api'
import {
  MCP_SERVER_PENDING_BODY,
  SECRETS_PENDING_BODY,
  uninstallIncompleteResponse,
} from '../../test/fixtures/mcpServerUninstall'
import { CreateMcpServerForm } from '../CreateMcpServerForm'
import { ToastProvider } from '../Toast'

// vi.mock is hoisted before imports; factory runs lazily so references to `api` are safe.
vi.mock('next/navigation', () => ({
  useRouter: () => ({ push: vi.fn() }),
}))
vi.mock('../../lib/api', async importOriginal => {
  const actual = await importOriginal<typeof import('../../lib/api')>()
  const { buildContextResource } = await import('../../test/fixtures/contextResource')
  const context1 = buildContextResource({
    metadata: { name: 'context1', resourceVersion: 'rv-context1' },
  })
  return {
    // Spread the real module so helpers the form imports directly (e.g.
    // getMcpSecretRollbackRepairIdentity) keep their real behaviour; every
    // network-touching export below is then overridden explicitly.
    ...actual,
    apiSend: vi.fn().mockResolvedValue({}),
    createMcpServer: vi.fn().mockResolvedValue({ metadata: { name: 'test-server' } }),
    listMcpSecrets: vi.fn().mockResolvedValue({
      items: [{ name: 'shared-credentials', uid: 'shared-uid', keys: ['api-key'] }],
    }),
    createMcpSecret: vi.fn().mockResolvedValue({
      name: 'test-credentials',
      namespace: 'mcp-server',
      uid: 'uid-test-credentials',
      resourceVersion: '1',
    }),
    deleteMcpSecret: vi.fn().mockResolvedValue({ name: 'test-credentials' }),
    deleteMcpServer: vi.fn().mockResolvedValue({ name: 'test-server' }),
    getAgentTeams: vi.fn().mockResolvedValue({ items: [] }),
    getAgentUsers: vi.fn().mockResolvedValue({ items: [] }),
    // The form no longer reads the context list; kept as a spy to lock that contract.
    getContexts: vi.fn(),
    getContext: vi.fn().mockResolvedValue(context1),
    getContextTeams: vi.fn().mockResolvedValue({ items: [] }),
    getContextUsers: vi.fn().mockResolvedValue({ items: [] }),
    listOrgImages: vi.fn().mockResolvedValue({ org: 'evenfire-dev', images: [] }),
    getHosts: vi.fn().mockResolvedValue({ items: [] }),
    updateContext: vi.fn().mockResolvedValue({}),
  }
})

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

function render(children: ReactNode) {
  return rtlRender(<ToastProvider>{children}</ToastProvider>)
}

async function fillIdentity(name = 'brave-search') {
  await waitFor(() => expect(api.getHosts).toHaveBeenCalledTimes(1))
  fireEvent.change(screen.getByPlaceholderText('my-mcp-server'), {
    target: { value: name },
  })
  fireEvent.change(
    screen.getByPlaceholderText('us-central1-docker.pkg.dev/my-project/repo/mcp-server:latest'),
    { target: { value: 'ghcr.io/example/mcp:1.0' } }
  )
}

function goToAccessStep() {
  fireEvent.click(screen.getByRole('button', { name: 'Continue' }))
}

function continueToSecretsStep() {
  // Already on the Access step: a single Continue lands on Secrets.
  fireEvent.click(screen.getByRole('button', { name: 'Continue' }))
}

async function selectAgents(...labels: string[]) {
  fireEvent.click(await screen.findByRole('button', { name: 'Select agents...' }))
  for (const label of labels) {
    fireEvent.click(screen.getByRole('option', { name: label }))
  }
}

function openAdvanced() {
  fireEvent.click(screen.getByText('Advanced options'))
}

function continueToSecrets() {
  fireEvent.click(screen.getByRole('button', { name: 'Continue' }))
  fireEvent.click(screen.getByRole('button', { name: 'Continue' }))
}

function chooseNoCredentials() {
  fireEvent.click(screen.getByRole('radio', { name: /No credentials required/ }))
}

function chooseNewSecret() {
  fireEvent.click(screen.getByRole('radio', { name: /Create Kubernetes Secret/ }))
}

function mcpSecretRollbackRepairError(created: Record<string, unknown>) {
  return Object.assign(
    new Error('503 Service Unavailable - mcp_secret_rollback_permit_unavailable'),
    {
      status: 503,
      code: 'mcp_secret_rollback_permit_unavailable',
      body: {
        error: 'mcp_secret_rollback_permit_unavailable',
        outcome: 'repair_required',
        created,
      },
    }
  )
}

// ─────────────────────────────────────────────────────────────────────────────
// Rendering
// ─────────────────────────────────────────────────────────────────────────────
describe('CreateMcpServerForm — render', () => {
  it('renders the section title', () => {
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    expect(screen.getByRole('heading', { name: 'Create connector' })).toBeInTheDocument()
  })

  it('renders the Continue button disabled until required fields are filled', async () => {
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    const continueButton = screen.getByRole('button', { name: 'Continue' })
    expect(continueButton).toBeDisabled()

    await fillIdentity()

    expect(continueButton).not.toBeDisabled()
  })

  it('loads available agents into the dedicated Access step', async () => {
    vi.mocked(api.getHosts).mockResolvedValueOnce({
      items: [
        { metadata: { name: 'agents/product' }, spec: { contextRef: 'context1' } },
        { metadata: { name: 'research-agent' }, spec: { contextRef: 'research' } },
        // Hosts without a contextRef are not selectable agent targets.
        { metadata: { name: 'orphan-agent' } },
      ],
    })
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)

    await fillIdentity()
    goToAccessStep()

    await waitFor(() =>
      expect(screen.getByRole('heading', { name: 'Agent access' })).toBeInTheDocument()
    )
    expect(
      screen.getByText(
        /^Optionally choose the agents that can use this connector right away\. You can also grant access later/
      )
    ).toBeInTheDocument()

    fireEvent.click(await screen.findByRole('button', { name: 'Select agents...' }))

    // Agent options are labeled with the derived display name.
    expect(screen.getByRole('option', { name: 'product' })).toBeInTheDocument()
    expect(screen.getByRole('option', { name: 'research-agent' })).toBeInTheDocument()
    expect(screen.queryByRole('option', { name: 'orphan-agent' })).not.toBeInTheDocument()
    // The context concept is gone from this flow.
    expect(api.getContexts).not.toHaveBeenCalled()
  })

  it('selects an organization image and fills its full registry coordinate', async () => {
    vi.mocked(api.listOrgImages).mockResolvedValueOnce({
      org: 'evenfire-dev',
      images: [
        {
          name: 'todoist-mcp-server',
          visibility: 'private',
          createdAt: '2026-08-05',
          tags: ['1.0.0'],
        },
      ],
    })
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)

    const imageField = await screen.findByPlaceholderText(
      'us-central1-docker.pkg.dev/my-project/repo/mcp-server:latest'
    )
    fireEvent.focus(imageField)
    fireEvent.click(screen.getByRole('option', { name: 'todoist-mcp-server:1.0.0' }))

    expect(
      screen.getByDisplayValue('registry.evenfire.ai/evenfire-dev/todoist-mcp-server:1.0.0')
    ).toBeInTheDocument()
  })

  it('uses connector, access, and secrets steps', () => {
    const { container } = render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    expect(container.querySelectorAll('.cu-agent-step-rail__item')).toHaveLength(3)
    const stepTitles = Array.from(container.querySelectorAll('.cu-agent-step-rail__title')).map(
      element => element.textContent
    )
    expect(stepTitles).toEqual(['Connector', 'Access', 'Secrets'])
    expect(screen.queryByText('Step 1 of 3')).not.toBeInTheDocument()
    expect(screen.queryByText('Step 1 of 4')).not.toBeInTheDocument()
  })

  it('previews who can use the connector for selected agents', async () => {
    vi.mocked(api.getAgentUsers).mockResolvedValueOnce({
      items: [{ id: 'user-1', displayName: 'Josue', email: '[email protected]', name: 'josue' }],
    })
    vi.mocked(api.getAgentTeams).mockResolvedValueOnce({
      items: [{ id: 'team-1', name: 'Development Team' }],
    })
    vi.mocked(api.getHosts).mockResolvedValueOnce({
      items: [{ metadata: { name: 'agents/product' }, spec: { contextRef: 'context1' } }],
    })
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)

    await fillIdentity()
    goToAccessStep()
    await selectAgents('product')

    const preview = await screen.findByLabelText('Agent access preview')
    expect(screen.getByText('Access preview')).toBeInTheDocument()
    expect(preview).toHaveTextContent('product')
    expect(preview).toHaveTextContent('Josue')
    expect(preview).toHaveTextContent('Development Team')
    // The preview follows direct Agent grants, not legacy Context mappings.
    expect(api.getAgentUsers).toHaveBeenCalledWith('agents/product')
    expect(api.getAgentTeams).toHaveBeenCalledWith('agents/product')
    expect(api.getContextUsers).not.toHaveBeenCalled()
    expect(api.getContextTeams).not.toHaveBeenCalled()
  })

  it('hides the advanced options by default and reveals them on toggle', async () => {
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillIdentity()
    const summary = screen.getByText('Advanced options')
    const details = summary.closest('details')
    expect(details).not.toBeNull()
    expect(details).not.toHaveAttribute('open')

    fireEvent.click(summary)

    expect(details).toHaveAttribute('open')
  })

  it('shows the Port field when transport is streamableHttp (default)', async () => {
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillIdentity()
    openAdvanced()
    expect(screen.getByDisplayValue('3000')).toBeInTheDocument()
  })
})

// ─────────────────────────────────────────────────────────────────────────────
// Name validation (DNS-label pattern)
// ─────────────────────────────────────────────────────────────────────────────
describe('CreateMcpServerForm — name validation', () => {
  it('lowercases and strips invalid characters from name input', () => {
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    const nameField = screen.getByPlaceholderText('my-mcp-server') as HTMLInputElement
    fireEvent.change(nameField, { target: { value: 'My_MCP.Server!' } })
    // Uppercase → lowercase, invalid chars (_, ., !) stripped
    expect(nameField.value).toBe('mymcpserver')
  })

  it('accepts a valid DNS-label name', () => {
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    const nameField = screen.getByPlaceholderText('my-mcp-server') as HTMLInputElement
    fireEvent.change(nameField, { target: { value: 'brave-search' } })
    expect(nameField.value).toBe('brave-search')
    // No error banner for a valid name
    expect(screen.queryByText(/Name must match/)).not.toBeInTheDocument()
  })
})

// ─────────────────────────────────────────────────────────────────────────────
// Transport behavior
// ─────────────────────────────────────────────────────────────────────────────
describe('CreateMcpServerForm — transport', () => {
  it('hides the Port field when transport is set to stdio', async () => {
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillIdentity()
    openAdvanced()
    // Port defaults to 3000 and is visible initially
    expect(screen.getByDisplayValue('3000')).toBeInTheDocument()

    // SelectInput is a custom control; grab the transport dropdown by its
    // default selected option text (label: "StreamableHTTP") rather than an
    // accessible-name lookup, since the component does not wire htmlFor/
    // aria-labelledby. The `Managed` select has two different option labels
    // starting with "Yes" / "No" so there is no collision.
    const transportSelect = screen.getByDisplayValue('StreamableHTTP')
    fireEvent.change(transportSelect, { target: { value: 'stdio' } })

    expect(screen.queryByDisplayValue('3000')).not.toBeInTheDocument()
  })
})

// ─────────────────────────────────────────────────────────────────────────────
// Credentials
// ─────────────────────────────────────────────────────────────────────────────
describe('CreateMcpServerForm — secret reference', () => {
  it('requires an explicit credential decision before creation is enabled', async () => {
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillIdentity()
    continueToSecrets()

    const submit = screen.getByRole('button', { name: 'Create connector' })
    expect(submit).toBeDisabled()

    chooseNoCredentials()

    expect(submit).not.toBeDisabled()
  })

  it('reveals the Kubernetes Secret Name input when Create Kubernetes Secret is selected', async () => {
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillIdentity()
    continueToSecrets()

    // Not visible by default
    expect(screen.queryByPlaceholderText('brave-search-credentials')).not.toBeInTheDocument()

    chooseNewSecret()

    expect(screen.getByPlaceholderText('brave-search-credentials')).toBeInTheDocument()
    expect(screen.getByRole('button', { name: 'Add Key Mapping' })).toBeInTheDocument()
  })
})

// ─────────────────────────────────────────────────────────────────────────────
// Cancel
// ─────────────────────────────────────────────────────────────────────────────
describe('CreateMcpServerForm — cancel', () => {
  it('invokes onCancel when the Cancel button is clicked', () => {
    const onCancel = vi.fn()
    render(<CreateMcpServerForm onCancel={onCancel} onCreated={vi.fn()} />)

    fireEvent.click(screen.getByRole('button', { name: 'Cancel' }))
    expect(onCancel).toHaveBeenCalledTimes(1)
  })
})

// ─────────────────────────────────────────────────────────────────────────────
// Happy-path submission
// ─────────────────────────────────────────────────────────────────────────────
describe('CreateMcpServerForm — submit', () => {
  async function fillRequired(name = 'brave-search') {
    await fillIdentity(name)
    continueToSecrets()
    chooseNoCredentials()
  }

  it('creates the connector in the selected agents’ scope with one write per context', async () => {
    // Two agents sharing one contextRef must produce exactly one allowlist write.
    vi.mocked(api.getHosts).mockResolvedValueOnce({
      items: [
        { metadata: { name: 'agents/product' }, spec: { contextRef: 'context1' } },
        { metadata: { name: 'research-agent' }, spec: { contextRef: 'context1' } },
      ],
    })
    const onCreated = vi.fn()
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={onCreated} />)
    await fillIdentity()
    goToAccessStep()
    await selectAgents('product', 'research-agent')
    continueToSecretsStep()
    chooseNoCredentials()

    const submit = screen.getByRole('button', { name: 'Create connector' })
    await waitFor(() => expect(submit).not.toBeDisabled())
    fireEvent.click(submit)

    await waitFor(() => {
      expect(api.createMcpServer).toHaveBeenCalledTimes(1)
    })
    // Spec shape: streamableHttp default, managed: true default, in-cluster URL from the name.
    // The connector is attached to the selected agents' contextRef.
    const createCall = (api.createMcpServer as ReturnType<typeof vi.fn>).mock.calls[0][0]
    expect(createCall).toMatchObject({
      metadata: { name: 'brave-search' },
      spec: {
        image: 'ghcr.io/example/mcp:1.0',
        contextRef: 'context1',
        enabled: true,
        managed: true,
        transport: {
          type: 'streamableHttp',
          port: 3000,
          url: 'http://brave-search.mcp-server.svc.cluster.local:3000/mcp',
        },
      },
    })
    // With agents selected no private scope is created.
    expect(api.apiSend).not.toHaveBeenCalled()

    // Allowlist update: one read + one additive write for the shared contextRef.
    await waitFor(() => {
      expect(api.getContext).toHaveBeenCalledWith('context1')
      expect(api.updateContext).toHaveBeenCalledTimes(1)
    })
    const updateCall = (api.updateContext as ReturnType<typeof vi.fn>).mock.calls[0]
    expect(updateCall[0]).toBe('context1')
    expect(updateCall[1]).toMatchObject({
      metadata: { resourceVersion: 'rv-context1' },
      spec: { contextId: 'context1', mcpServers: ['brave-search'] },
    })

    // Success toast + delayed onCreated callback
    expect(screen.getByText('Connector created successfully.')).toBeInTheDocument()
    await waitFor(() => expect(onCreated).toHaveBeenCalledTimes(1), { timeout: 1500 })
  })

  it('rolls back a returned context-scoped OAuth connector and Secret across Agent scopes', async () => {
    vi.mocked(api.getHosts).mockResolvedValueOnce({
      items: [
        { metadata: { name: 'agent-alpha' }, spec: { contextRef: 'ctx-alpha' } },
        { metadata: { name: 'agent-beta' }, spec: { contextRef: 'ctx-beta' } },
      ],
    })
    vi.mocked(api.createMcpServer).mockResolvedValueOnce({
      metadata: { name: 'shared-drive' },
      spec: {
        contextRef: 'ctx-alpha',
        oauth: { grantScope: 'context' },
      },
    })
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillIdentity('shared-drive')
    goToAccessStep()
    await selectAgents('agent-alpha', 'agent-beta')
    continueToSecretsStep()
    chooseNewSecret()
    fireEvent.change(screen.getByPlaceholderText('brave-search-credentials'), {
      target: { value: 'shared-drive-oauth' },
    })
    fireEvent.click(screen.getByRole('button', { name: 'Add Key Mapping' }))
    fireEvent.change(screen.getByPlaceholderText('api-key'), {
      target: { value: 'api-key' },
    })
    fireEvent.change(screen.getByPlaceholderText('BRAVE_API_KEY'), {
      target: { value: 'DRIVE_API_KEY' },
    })
    fireEvent.change(screen.getByPlaceholderText('sk-...'), {
      target: { value: 'test-secret' },
    })

    fireEvent.click(screen.getByRole('button', { name: 'Create connector' }))

    expect(
      await screen.findByText(/shared OAuth identity.*original access scope/i)
    ).toBeInTheDocument()
    expect(api.deleteMcpServer).toHaveBeenCalledWith('shared-drive')
    // The rollback delete is compare-and-swap fenced: it must carry the
    // identity createMcpSecret returned, so it can never delete a Secret some
    // other writer replaced in between.
    expect(api.deleteMcpSecret).toHaveBeenCalledWith('shared-drive-oauth', {
      uid: 'uid-test-credentials',
      resourceVersion: '1',
    })
    expect(api.getContext).not.toHaveBeenCalled()
    expect(api.updateContext).not.toHaveBeenCalled()
  })

  it.each([
    {
      body: SECRETS_PENDING_BODY,
      expected:
        'Automatic cleanup of connector "shared-drive" is incomplete (pending cleanup: connector Secrets); it is still installed. Delete it from the Installed Connectors list to finish.',
    },
    {
      body: MCP_SERVER_PENDING_BODY,
      expected:
        'Automatic cleanup of connector "shared-drive" is incomplete (pending cleanup: connector resource); it may still be installed. Delete it from the Installed Connectors list to finish.',
    },
  ])(
    'tells the operator an incomplete rollback and what is pending ($body.pending)',
    async ({ body, expected }) => {
      vi.mocked(api.getHosts).mockResolvedValueOnce({
        items: [
          { metadata: { name: 'agent-alpha' }, spec: { contextRef: 'ctx-alpha' } },
          { metadata: { name: 'agent-beta' }, spec: { contextRef: 'ctx-beta' } },
        ],
      })
      vi.mocked(api.createMcpServer).mockResolvedValueOnce({
        metadata: { name: 'shared-drive' },
        spec: { contextRef: 'ctx-alpha', oauth: { grantScope: 'context' } },
      })
      // The real client parses the producer's 503 body; only the network is stubbed.
      vi.mocked(api.deleteMcpServer).mockImplementationOnce(async name => {
        const actual = await vi.importActual<typeof import('../../lib/api')>('../../lib/api')
        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(uninstallIncompleteResponse(body)))
        try {
          return await actual.deleteMcpServer(name)
        } finally {
          vi.unstubAllGlobals()
        }
      })
      render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
      await fillIdentity('shared-drive')
      goToAccessStep()
      await selectAgents('agent-alpha', 'agent-beta')
      continueToSecretsStep()
      chooseNoCredentials()

      fireEvent.click(screen.getByRole('button', { name: 'Create connector' }))

      expect(await screen.findByText(expected, { exact: false })).toBeInTheDocument()
      expect(
        screen.queryByText(/Automatic cleanup failed for the connector/)
      ).not.toBeInTheDocument()
    }
  )

  it('creates a private access scope when no agents are selected', async () => {
    const onCreated = vi.fn()
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={onCreated} />)
    await fillIdentity()
    // Skip the optional Access step without selecting any agent.
    continueToSecrets()
    chooseNoCredentials()

    const submit = screen.getByRole('button', { name: 'Create connector' })
    await waitFor(() => expect(submit).not.toBeDisabled())
    fireEvent.click(submit)

    await waitFor(() => {
      expect(api.apiSend).toHaveBeenCalledWith('POST', '/api/v1/admin/contexts', expect.any(Object))
    })
    const scopeCall = vi
      .mocked(api.apiSend)
      .mock.calls.find(call => call[0] === 'POST' && call[1] === '/api/v1/admin/contexts')
    expect(scopeCall).toBeDefined()
    const scopeBody = scopeCall![2] as {
      metadata: { name: string }
      spec: { contextId: string; description: string; mcpServers: string[] }
    }
    expect(scopeBody.metadata.name).toMatch(/^brave-search-[0-9]{5}$/)
    expect(scopeBody.spec.contextId).toBe(scopeBody.metadata.name)
    expect(scopeBody.spec.description).toBe('Connector access scope for brave-search')
    expect(scopeBody.spec.mcpServers).toEqual(['brave-search'])

    // The generated scope name becomes the created McpServer's contextRef.
    await waitFor(() => {
      expect(api.createMcpServer).toHaveBeenCalledTimes(1)
    })
    const createCall = (api.createMcpServer as ReturnType<typeof vi.fn>).mock.calls[0][0]
    expect(createCall.spec.contextRef).toBe(scopeBody.metadata.name)

    // No allowlist writes on this path.
    expect(api.getContext).not.toHaveBeenCalled()
    expect(api.updateContext).not.toHaveBeenCalled()
    expect(screen.getByText('Connector created successfully.')).toBeInTheDocument()
    await waitFor(() => expect(onCreated).toHaveBeenCalledTimes(1), { timeout: 1500 })
  })

  it('reports a partial failure when the access write rejects after creation', async () => {
    vi.mocked(api.getHosts).mockResolvedValueOnce({
      items: [{ metadata: { name: 'agents/product' }, spec: { contextRef: 'context1' } }],
    })
    ;(api.updateContext as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
      new Error('context write failed')
    )
    const onCreated = vi.fn()
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={onCreated} />)
    await fillIdentity()
    goToAccessStep()
    await selectAgents('product')
    continueToSecretsStep()
    chooseNoCredentials()

    const submit = screen.getByRole('button', { name: 'Create connector' })
    await waitFor(() => expect(submit).not.toBeDisabled())
    fireEvent.click(submit)

    await waitFor(() => {
      expect(api.createMcpServer).toHaveBeenCalledTimes(1)
      expect(
        screen.getByText(
          `Connector created, but we couldn't give access to product. ` +
            `Grant "brave-search" to those agents from the Installed Connectors list.`
        )
      ).toBeInTheDocument()
    })
    expect(onCreated).not.toHaveBeenCalled()
    expect(screen.queryByText('Connector created successfully.')).not.toBeInTheDocument()
  })

  it('submits exact-host egress bindings when configured', async () => {
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillIdentity()
    openAdvanced()

    fireEvent.change(screen.getByDisplayValue('No external egress (closed by default)'), {
      target: { value: 'exact-host' },
    })
    fireEvent.change(screen.getByPlaceholderText('api.example.com, auth.example.com'), {
      target: { value: 'api.example.com' },
    })
    fireEvent.change(screen.getByPlaceholderText('443'), {
      target: { value: '443' },
    })
    continueToSecrets()

    chooseNoCredentials()

    const submit = screen.getByRole('button', { name: 'Create connector' })
    await waitFor(() => expect(submit).not.toBeDisabled())
    fireEvent.click(submit)

    await waitFor(() => {
      expect(api.createMcpServer).toHaveBeenCalledTimes(1)
    })
    const createCall = (api.createMcpServer as ReturnType<typeof vi.fn>).mock.calls[0][0]
    expect(createCall.spec.egressBindings).toEqual([
      { dns: 'api.example.com', port: 443, protocol: 'TCP' },
    ])
  })

  it('submits public-web as one explicit egress class binding', async () => {
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillIdentity()
    openAdvanced()

    fireEvent.change(screen.getByDisplayValue('No external egress (closed by default)'), {
      target: { value: 'public-web' },
    })
    continueToSecrets()

    chooseNoCredentials()

    const submit = screen.getByRole('button', { name: 'Create connector' })
    await waitFor(() => expect(submit).not.toBeDisabled())
    fireEvent.click(submit)

    await waitFor(() => {
      expect(api.createMcpServer).toHaveBeenCalledTimes(1)
    })
    const createCall = (api.createMcpServer as ReturnType<typeof vi.fn>).mock.calls[0][0]
    expect(createCall.spec.egressBindings).toEqual([{ egressClass: 'public-web' }])
  })

  it('submits exact-cidr egress bindings when configured', async () => {
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillIdentity()
    openAdvanced()

    fireEvent.change(screen.getByDisplayValue('No external egress (closed by default)'), {
      target: { value: 'exact-cidr' },
    })
    fireEvent.change(screen.getByPlaceholderText('203.0.114.10/32, 8.8.8.8'), {
      target: { value: '8.8.8.8' },
    })
    fireEvent.change(screen.getByPlaceholderText('443'), {
      target: { value: '443' },
    })
    continueToSecrets()

    chooseNoCredentials()

    const submit = screen.getByRole('button', { name: 'Create connector' })
    await waitFor(() => expect(submit).not.toBeDisabled())
    fireEvent.click(submit)

    await waitFor(() => {
      expect(api.createMcpServer).toHaveBeenCalledTimes(1)
    })
    const createCall = (api.createMcpServer as ReturnType<typeof vi.fn>).mock.calls[0][0]
    expect(createCall.spec.egressBindings).toEqual([
      { cidr: '8.8.8.8/32', port: 443, protocol: 'TCP' },
    ])
  })

  it('shows an error banner when createMcpServer rejects', async () => {
    ;(api.createMcpServer as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
      new Error('image pull failed')
    )
    const onCreated = vi.fn()
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={onCreated} />)
    await fillRequired()

    const submit = screen.getByRole('button', { name: 'Create connector' })
    await waitFor(() => expect(submit).not.toBeDisabled())
    fireEvent.click(submit)

    await waitFor(() => {
      expect(screen.getByText('image pull failed')).toBeInTheDocument()
    })
    expect(onCreated).not.toHaveBeenCalled()
  })
})

// ─────────────────────────────────────────────────────────────────────────────
// PR-A / A2 — envSecret client validation + rollback
// ─────────────────────────────────────────────────────────────────────────────
describe('CreateMcpServerForm — envSecret guardrails', () => {
  async function fillRequiredBasics(name = 'brave-search') {
    await fillIdentity(name)
    continueToSecrets()
  }

  function enableEnvSecret(secretName = 'brave-credentials') {
    chooseNewSecret()
    fireEvent.change(screen.getByPlaceholderText('brave-search-credentials'), {
      target: { value: secretName },
    })
  }

  it('keeps Create disabled when a Secret has no key mappings', async () => {
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillRequiredBasics()
    enableEnvSecret()
    // No "Add Key Mapping" click — zero rows total.

    const submit = screen.getByRole('button', { name: 'Create connector' })
    expect(submit).toBeDisabled()
    expect(api.createMcpSecret).not.toHaveBeenCalled()
    expect(api.createMcpServer).not.toHaveBeenCalled()
  })

  it('keeps Create disabled when a Secret mapping is incomplete', async () => {
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillRequiredBasics()
    enableEnvSecret()
    fireEvent.click(screen.getByRole('button', { name: 'Add Key Mapping' }))

    // Fill secretKey + envVar but leave value blank (the broken shape).
    const secretKeyInput = screen.getByPlaceholderText('api-key') as HTMLInputElement
    const envVarInput = screen.getByPlaceholderText('BRAVE_API_KEY') as HTMLInputElement
    fireEvent.change(secretKeyInput, { target: { value: 'api-key' } })
    fireEvent.change(envVarInput, { target: { value: 'BRAVE_API_KEY' } })

    const submit = screen.getByRole('button', { name: 'Create connector' })
    expect(submit).toBeDisabled()
    expect(api.createMcpSecret).not.toHaveBeenCalled()
    expect(api.createMcpServer).not.toHaveBeenCalled()
  })

  it('keeps Create disabled when every Secret mapping row is blank', async () => {
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillRequiredBasics()
    enableEnvSecret()
    fireEvent.click(screen.getByRole('button', { name: 'Add Key Mapping' }))

    // Leave both secretKey and value blank. Row exists but no meaningful data.
    // This triggers the "Add at least one key-value pair or disable envSecret"
    // path (meaningfulRows.length === 0).
    const submit = screen.getByRole('button', { name: 'Create connector' })
    expect(submit).toBeDisabled()
    expect(api.createMcpSecret).not.toHaveBeenCalled()
    expect(api.createMcpServer).not.toHaveBeenCalled()
  })

  it('rolls back the created Secret when createMcpServer rejects', async () => {
    ;(api.createMcpServer as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
      new Error('422 Unprocessable - {"message":"Connector create failed"}')
    )

    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillRequiredBasics()
    enableEnvSecret('brave-credentials')
    fireEvent.click(screen.getByRole('button', { name: 'Add Key Mapping' }))
    fireEvent.change(screen.getByPlaceholderText('api-key'), {
      target: { value: 'api-key' },
    })
    fireEvent.change(screen.getByPlaceholderText('BRAVE_API_KEY'), {
      target: { value: 'BRAVE_API_KEY' },
    })
    fireEvent.change(screen.getByPlaceholderText('sk-...'), {
      target: { value: 'sk-test-abc' },
    })

    const submit = screen.getByRole('button', { name: 'Create connector' })
    await waitFor(() => expect(submit).not.toBeDisabled())
    fireEvent.click(submit)

    // Secret created first
    await waitFor(() => {
      expect(api.createMcpSecret).toHaveBeenCalledTimes(1)
    })
    expect(api.createMcpSecret).toHaveBeenCalledWith('brave-credentials', {
      'api-key': 'sk-test-abc',
    })

    // CRD failed → rollback deletes the Secret once with same name
    await waitFor(() => {
      expect(api.deleteMcpSecret).toHaveBeenCalledTimes(1)
    })
    expect(api.deleteMcpSecret).toHaveBeenCalledWith('brave-credentials', {
      uid: 'uid-test-credentials',
      resourceVersion: '1',
    })

    // JSON API errors surface their server message after rollback.
    await waitFor(() => {
      expect(screen.getByText('Connector create failed')).toBeInTheDocument()
    })
  })

  it('rolls back a repaired Secret with CAS when createMcpSecret rejects', async () => {
    ;(api.createMcpSecret as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
      mcpSecretRollbackRepairError({
        name: 'requested-credentials',
        namespace: 'mcp-server',
        uid: 'uid-requested-credentials',
        resourceVersion: '17',
      })
    )

    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillRequiredBasics()
    enableEnvSecret('requested-credentials')
    fireEvent.click(screen.getByRole('button', { name: 'Add Key Mapping' }))
    fireEvent.change(screen.getByPlaceholderText('api-key'), {
      target: { value: 'api-key' },
    })
    fireEvent.change(screen.getByPlaceholderText('BRAVE_API_KEY'), {
      target: { value: 'BRAVE_API_KEY' },
    })
    fireEvent.change(screen.getByPlaceholderText('sk-...'), {
      target: { value: 'sk-test-abc' },
    })

    fireEvent.click(screen.getByRole('button', { name: 'Create connector' }))

    await waitFor(() => {
      expect(api.deleteMcpSecret).toHaveBeenCalledWith('requested-credentials', {
        uid: 'uid-requested-credentials',
        resourceVersion: '17',
      })
    })
    expect(api.createMcpServer).not.toHaveBeenCalled()
  })

  it('does not use a bodyless rollback when a repair response has incomplete identity', async () => {
    ;(api.createMcpSecret as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
      mcpSecretRollbackRepairError({
        name: 'repaired-credentials',
        namespace: 'mcp-server',
        uid: 'uid-repaired-credentials',
      })
    )

    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillRequiredBasics()
    enableEnvSecret('requested-credentials')
    fireEvent.click(screen.getByRole('button', { name: 'Add Key Mapping' }))
    fireEvent.change(screen.getByPlaceholderText('api-key'), {
      target: { value: 'api-key' },
    })
    fireEvent.change(screen.getByPlaceholderText('BRAVE_API_KEY'), {
      target: { value: 'BRAVE_API_KEY' },
    })
    fireEvent.change(screen.getByPlaceholderText('sk-...'), {
      target: { value: 'sk-test-abc' },
    })

    fireEvent.click(screen.getByRole('button', { name: 'Create connector' }))

    await waitFor(() => {
      expect(screen.getByText(/mcp_secret_rollback_permit_unavailable/)).toBeInTheDocument()
    })
    expect(api.deleteMcpSecret).not.toHaveBeenCalled()
    expect(api.createMcpServer).not.toHaveBeenCalled()
  })

  it('uses the legacy bodyless rollback when the create API omits identity fields', async () => {
    ;(api.createMcpSecret as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
      name: 'legacy-credentials',
      namespace: 'mcp-server',
    })
    ;(api.createMcpServer as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
      new Error('Connector create failed')
    )

    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillRequiredBasics()
    enableEnvSecret('legacy-credentials')
    fireEvent.click(screen.getByRole('button', { name: 'Add Key Mapping' }))
    fireEvent.change(screen.getByPlaceholderText('api-key'), {
      target: { value: 'api-key' },
    })
    fireEvent.change(screen.getByPlaceholderText('BRAVE_API_KEY'), {
      target: { value: 'BRAVE_API_KEY' },
    })
    fireEvent.change(screen.getByPlaceholderText('sk-...'), {
      target: { value: 'test-value' },
    })

    fireEvent.click(screen.getByRole('button', { name: 'Create connector' }))

    await waitFor(() => {
      expect(api.deleteMcpSecret).toHaveBeenCalledWith('legacy-credentials', undefined)
    })
    expect(screen.getByText('Connector create failed')).toBeInTheDocument()
  })

  it('preserves the primary error when legacy rollback fails against a newer delete API', async () => {
    ;(api.createMcpSecret as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
      name: 'mixed-version-credentials',
      namespace: 'mcp-server',
    })
    ;(api.createMcpServer as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
      new Error('Connector create failed')
    )
    ;(api.deleteMcpSecret as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
      new Error('428 Precondition Required - current identity required')
    )

    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillRequiredBasics()
    enableEnvSecret('mixed-version-credentials')
    fireEvent.click(screen.getByRole('button', { name: 'Add Key Mapping' }))
    fireEvent.change(screen.getByPlaceholderText('api-key'), {
      target: { value: 'api-key' },
    })
    fireEvent.change(screen.getByPlaceholderText('BRAVE_API_KEY'), {
      target: { value: 'BRAVE_API_KEY' },
    })
    fireEvent.change(screen.getByPlaceholderText('sk-...'), {
      target: { value: 'test-value' },
    })

    fireEvent.click(screen.getByRole('button', { name: 'Create connector' }))

    await waitFor(() => {
      expect(api.deleteMcpSecret).toHaveBeenCalledWith('mixed-version-credentials', undefined)
    })
    expect(screen.getByText(/Connector create failed/)).toBeInTheDocument()
    expect(
      screen.getByText(
        /Cleanup of the created Secret "mixed-version-credentials" also failed: 428 Precondition Required - current identity required\. Refresh the page and review the Secret before taking further action\./
      )
    ).toBeInTheDocument()
  })

  it('happy path: creates Secret then CRD, no rollback', async () => {
    const onCreated = vi.fn()
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={onCreated} />)
    await fillRequiredBasics()
    enableEnvSecret('brave-credentials')
    fireEvent.click(screen.getByRole('button', { name: 'Add Key Mapping' }))
    fireEvent.change(screen.getByPlaceholderText('api-key'), {
      target: { value: 'api-key' },
    })
    fireEvent.change(screen.getByPlaceholderText('BRAVE_API_KEY'), {
      target: { value: 'BRAVE_API_KEY' },
    })
    fireEvent.change(screen.getByPlaceholderText('sk-...'), {
      target: { value: 'sk-live-xyz' },
    })

    const submit = screen.getByRole('button', { name: 'Create connector' })
    await waitFor(() => expect(submit).not.toBeDisabled())
    fireEvent.click(submit)

    await waitFor(() => {
      expect(api.createMcpSecret).toHaveBeenCalledTimes(1)
      expect(api.createMcpServer).toHaveBeenCalledTimes(1)
    })
    // Rollback must NOT fire on success
    expect(api.deleteMcpSecret).not.toHaveBeenCalled()
    expect(screen.getByText('Connector created successfully.')).toBeInTheDocument()
  })
})

describe('CreateMcpServerForm — reusable Secrets', () => {
  async function prepareExisting() {
    render(<CreateMcpServerForm onCancel={vi.fn()} onCreated={vi.fn()} />)
    await fillIdentity()
    continueToSecrets()
    fireEvent.click(screen.getByRole('radio', { name: /Use an existing Secret/ }))
    await waitFor(() => expect(screen.getByLabelText(/^Existing Secret/)).toBeEnabled())
    fireEvent.click(screen.getByLabelText(/^Existing Secret/))
    fireEvent.click(await screen.findByRole('option', { name: 'shared-credentials' }))
  }
  it('creates a connector referencing stored keys without requesting or writing values', async () => {
    await prepareExisting()
    expect(screen.queryByPlaceholderText('sk-...')).not.toBeInTheDocument()
    expect(screen.getByLabelText(/^Environment variable 1/)).toHaveValue('API_KEY')
    fireEvent.click(screen.getByRole('button', { name: 'Create connector' }))
    await waitFor(() => expect(api.createMcpServer).toHaveBeenCalledOnce())
    expect(api.createMcpServer).toHaveBeenCalledWith(
      expect.objectContaining({
        spec: expect.objectContaining({
          envSecret: {
            name: 'shared-credentials',
            keys: [{ secretKey: 'api-key', envVar: 'API_KEY' }],
          },
        }),
      })
    )
    expect(api.listMcpSecrets).toHaveBeenCalledTimes(2)
    expect(api.createMcpSecret).not.toHaveBeenCalled()
    expect(api.deleteMcpSecret).not.toHaveBeenCalled()
  })
  it('keeps a shared Secret when connector creation fails', async () => {
    vi.mocked(api.createMcpServer).mockRejectedValueOnce(new Error('connector rejected'))
    await prepareExisting()
    fireEvent.click(screen.getByRole('button', { name: 'Create connector' }))
    expect(await screen.findByRole('alert')).toHaveTextContent('connector rejected')
    expect(api.createMcpSecret).not.toHaveBeenCalled()
    expect(api.deleteMcpSecret).not.toHaveBeenCalled()
  })
  it('checks the selected Secret identity before creating an access scope or connector', async () => {
    await prepareExisting()
    vi.mocked(api.listMcpSecrets).mockResolvedValueOnce({
      items: [{ name: 'shared-credentials', uid: 'replaced-uid', keys: ['api-key'] }],
    })
    fireEvent.click(screen.getByRole('button', { name: 'Create connector' }))
    expect(await screen.findByRole('alert')).toHaveTextContent('could not be verified')
    expect(api.apiSend).not.toHaveBeenCalled()
    expect(api.createMcpServer).not.toHaveBeenCalled()
    expect(api.createMcpSecret).not.toHaveBeenCalled()
    expect(api.deleteMcpSecret).not.toHaveBeenCalled()
    expect(screen.getByRole('button', { name: 'Create connector' })).toBeDisabled()
  })
  it('blocks invalid and colliding environment destinations', async () => {
    await prepareExisting()
    fireEvent.change(screen.getByLabelText(/^Environment variable 1/), {
      target: { value: 'NODE_OPTIONS' },
    })
    expect(screen.getByRole('button', { name: 'Create connector' })).toBeDisabled()
    expect(screen.getByRole('alert')).toHaveTextContent('runtime')
  })
})