Skip to content

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

TypeScript
23.1 KB
Raw Blame
import { beforeEach, describe, expect, it, vi } from 'vitest'
import * as api from '@lib/api'
import type { McpServerResource } from '@lib/api'
import {
  attachConnectorCredentials,
  buildAttachPayload,
  changeConnectorSecretReference,
  credentialAttachUnavailable,
  validateCredentialAttach,
} from '@lib/connectorCredentials'
import type { AttachCredentialRow, AttachCredentialsRequest } from '@lib/connectorCredentials.types'

vi.mock('@lib/api', async importOriginal => ({
  ...(await importOriginal<typeof import('@lib/api')>()),
  getMcpServer: vi.fn(),
  listMcpSecrets: vi.fn(),
  createMcpSecret: vi.fn(),
  updateMcpSecret: vi.fn(),
  deleteMcpSecret: vi.fn(),
  updateMcpServer: vi.fn(),
}))

const reference = { name: 'new-secret', keys: [{ secretKey: 'api-key', envVar: 'API_KEY' }] }
const row: AttachCredentialRow = {
  id: 'row',
  secretKey: 'api-key',
  envVar: 'API_KEY',
  value: '  private bytes  ',
}
function server(): McpServerResource {
  return {
    metadata: { name: 'connector', uid: 'server-uid', resourceVersion: '10', generation: 2 },
    spec: {
      image: 'example/image:v1',
      managed: true,
      egressBindings: [{ dns: 'api.example.com', port: 443 }],
    },
  }
}
function error(status: number, body?: object) {
  return Object.assign(new Error('request failed'), { status, body })
}
function request(overrides: Partial<AttachCredentialsRequest> = {}): AttachCredentialsRequest {
  return {
    serverName: 'connector',
    secretName: 'new-secret',
    mode: 'create-new',
    rows: [{ ...row }],
    onSecretWritten: vi.fn(),
    ...overrides,
  }
}
const existing = { name: 'new-secret', uid: 'secret-uid', keys: ['api-key'] }

beforeEach(() => {
  vi.resetAllMocks()
  vi.mocked(api.getMcpServer).mockResolvedValue(server())
  vi.mocked(api.listMcpSecrets).mockResolvedValue({ items: [existing] })
  vi.mocked(api.createMcpSecret).mockResolvedValue({
    name: 'new-secret',
    namespace: 'mcp-server',
    uid: 'created-uid',
    resourceVersion: 'secret-rv',
  })
  vi.mocked(api.updateMcpSecret).mockResolvedValue({
    name: 'new-secret',
    namespace: 'mcp-server',
    keys: ['api-key'],
    affectedConnectors: ['other'],
  })
  vi.mocked(api.updateMcpServer).mockImplementation(async (_name, payload) => ({
    ...server(),
    metadata: { ...server().metadata, generation: 3 },
    spec: payload.spec,
  }))
  vi.mocked(api.deleteMcpSecret).mockResolvedValue({ name: 'new-secret', namespace: 'mcp-server' })
})

describe('attach validation', () => {
  it.each(['-abc', 'UPPER', 'a'.repeat(254), ''])('rejects invalid Secret name %s', name => {
    expect(validateCredentialAttach('create-new', name, [row], server())?.field).toBe('secret')
  })
  it.each(['.', '..data', '', 'a/b', 'a'.repeat(254)])('rejects invalid key %s', secretKey => {
    expect(
      validateCredentialAttach('create-new', 'secret', [{ ...row, secretKey }], server())?.field
    ).toBe('row-key')
  })
  it.each(['', '1INVALID', 'KEY-VAR', 'NODE_OPTIONS', 'path'])(
    'rejects invalid or dangerous env %s',
    envVar => {
      expect(
        validateCredentialAttach('create-new', 'secret', [{ ...row, envVar }], server())?.field
      ).toBe('row-env')
    }
  )
  it('requires rows, every new value, and a selected existing Secret', () => {
    expect(validateCredentialAttach('create-new', 'secret', [], server())?.message).toContain(
      'at least one'
    )
    expect(
      validateCredentialAttach('create-new', 'secret', [{ ...row, value: '' }], server())?.field
    ).toBe('row-value')
    expect(validateCredentialAttach('use-existing', 'secret', [row], server())?.field).toBe(
      'secret'
    )
  })
  it('rejects duplicate destinations, env collisions, and conflicting duplicate-key values', () => {
    const target = server()
    target.spec.env = [{ name: 'API_KEY', value: 'plain' }]
    expect(validateCredentialAttach('create-new', 'secret', [row], target)?.message).toContain(
      'already mapped'
    )
    target.spec.env = []
    target.spec.envMapping = { token: 'API_KEY' }
    expect(validateCredentialAttach('create-new', 'secret', [row], target)?.message).toContain(
      'already mapped'
    )
    expect(
      validateCredentialAttach('create-new', 'secret', [row, { ...row, id: 'two' }], server())
        ?.message
    ).toContain('already mapped')
    expect(
      validateCredentialAttach(
        'create-new',
        'secret',
        [row, { ...row, id: 'two', envVar: 'OTHER_KEY', value: 'different' }],
        server()
      )?.message
    ).toContain('same value')
  })
  it('preserves credential bytes and safely serializes prototype-overlapping keys', () => {
    const rows = ['__proto__', 'constructor', 'toString'].map((secretKey, index) => ({
      ...row,
      id: String(index),
      secretKey,
      envVar: `KEY_${index}`,
    }))
    const payload = buildAttachPayload(' secret ', rows)
    expect(Object.getPrototypeOf(payload.data)).toBeNull()
    expect(JSON.parse(JSON.stringify(payload.data))['__proto__']).toBe(row.value)
    expect(payload.reference.name).toBe('secret')
    expect(({} as Record<string, unknown>).polluted).toBeUndefined()
  })
  it.each([
    { envSecret: null },
    { envSecret: { name: 'broken' } },
    { oauth: null },
    { oauth: {} },
    { managed: false },
    { enabled: false },
  ])('blocks structural ineligibility %j', spec => {
    expect(
      credentialAttachUnavailable({ ...server(), spec: { ...server().spec, ...spec } })
    ).toBeTruthy()
  })
})

// Reference-only reuse (creation + reassignment) must answer a missing or
// stale key with a KEY selection error and must never request a credential
// value — unlike the keyless-attach flow, which may still write new keys.
describe('reference-only validation with storedKeysOnly', () => {
  const selected = { name: 'new-secret', uid: 'secret-uid', keys: ['api-key', 'other-key'] }
  const options = { storedKeysOnly: true } as const

  it('reports an empty key as a key choice, not a format or value error', () => {
    const invalid = validateCredentialAttach(
      'use-existing',
      'new-secret',
      [{ ...row, secretKey: '' }],
      server(),
      selected,
      options
    )
    expect(invalid?.field).toBe('row-key')
    expect(invalid?.message).toContain('Choose a stored key')
  })

  it('reports a stale key as a key selection error and never asks for a value', () => {
    const invalid = validateCredentialAttach(
      'use-existing',
      'new-secret',
      [{ ...row, secretKey: 'removed-key' }],
      server(),
      selected,
      options
    )
    expect(invalid?.field).toBe('row-key')
    expect(invalid?.message).toContain('not stored')
    expect(invalid?.message.toLowerCase()).not.toContain('enter a credential value')
  })

  it('rejects a supplied value even for a stored key', () => {
    const invalid = validateCredentialAttach(
      'use-existing',
      'new-secret',
      [row],
      server(),
      selected,
      options
    )
    expect(invalid?.field).toBe('row-value')
    expect(invalid?.message).toContain('never take a value')
  })

  it('accepts a stored key mapped without a value and keeps destination checks', () => {
    const stored: AttachCredentialRow = { ...row, value: '' }
    expect(
      validateCredentialAttach('use-existing', 'new-secret', [stored], server(), selected, options)
    ).toBeUndefined()
    const colliding = server()
    colliding.spec.env = [{ name: 'API_KEY', value: 'plain' }]
    expect(
      validateCredentialAttach('use-existing', 'new-secret', [stored], colliding, selected, options)
        ?.field
    ).toBe('row-env')
  })

  it('keeps the keyless-attach behavior when the option is absent: a missing stored key requires a value', () => {
    const invalid = validateCredentialAttach(
      'use-existing',
      'new-secret',
      [{ ...row, secretKey: 'new-key', value: '' }],
      server(),
      selected
    )
    expect(invalid?.field).toBe('row-value')
  })
})

describe('ordered attach writes and recovery', () => {
  it('refuses a same-name replacement since the page loaded before touching any Secret', async () => {
    await expect(
      attachConnectorCredentials(request({ expectedUid: 'old-page-uid' }))
    ).rejects.toThrow('replaced')
    expect(api.createMcpSecret).not.toHaveBeenCalled()
    expect(api.updateMcpSecret).not.toHaveBeenCalled()
  })

  it('preserves fresh spec, fences by UID/RV, and keeps values out of spec', async () => {
    const fresh = server()
    fresh.metadata.resourceVersion = '12'
    vi.mocked(api.getMcpServer).mockResolvedValueOnce(server()).mockResolvedValueOnce(fresh)
    const input = request()
    const result = await attachConnectorCredentials(input)
    expect(api.createMcpSecret).toHaveBeenCalledWith('new-secret', { 'api-key': row.value })
    expect(api.updateMcpServer).toHaveBeenCalledWith('connector', {
      metadata: { uid: 'server-uid', resourceVersion: '12' },
      spec: { ...fresh.spec, envSecret: reference },
    })
    expect(api.getMcpServer.mock.invocationCallOrder[0]).toBeLessThan(
      api.createMcpSecret.mock.invocationCallOrder[0]
    )
    expect(api.createMcpSecret.mock.invocationCallOrder[0]).toBeLessThan(
      api.getMcpServer.mock.invocationCallOrder[1]
    )
    expect(api.getMcpServer.mock.invocationCallOrder[1]).toBeLessThan(
      api.updateMcpServer.mock.invocationCallOrder[0]
    )
    expect(JSON.stringify(api.updateMcpServer.mock.calls)).not.toContain(row.value)
    expect(result.server.metadata.generation).toBe(3)
    expect(input.onSecretWritten).toHaveBeenCalledOnce()
    expect(api.deleteMcpSecret).not.toHaveBeenCalled()
  })
  it.each([409, 500, 503])('never overwrites after rejected create %s', async status => {
    vi.mocked(api.createMcpSecret).mockRejectedValue(error(status))
    await expect(attachConnectorCredentials(request())).rejects.toMatchObject({
      collision: status === 409,
      refreshRequired: status !== 409,
    })
    expect(api.updateMcpSecret).not.toHaveBeenCalled()
    expect(api.updateMcpServer).not.toHaveBeenCalled()
    expect(api.deleteMcpSecret).not.toHaveBeenCalled()
  })
  it('does not blindly overwrite or delete after lost create response', async () => {
    vi.mocked(api.createMcpSecret).mockRejectedValue(new TypeError('network'))
    await expect(attachConnectorCredentials(request())).rejects.toMatchObject({
      refreshRequired: true,
    })
    expect(api.deleteMcpSecret).not.toHaveBeenCalled()
    expect(api.updateMcpSecret).not.toHaveBeenCalled()
  })
  it.each([true, false])(
    'handles a partial create with complete repair identity=%s',
    async complete => {
      vi.mocked(api.createMcpSecret).mockRejectedValue(
        error(503, {
          error: 'mcp_secret_rollback_permit_unavailable',
          outcome: 'repair_required',
          created: {
            name: 'new-secret',
            namespace: 'mcp-server',
            uid: 'repair-uid',
            ...(complete ? { resourceVersion: 'repair-rv' } : {}),
          },
        })
      )
      await expect(attachConnectorCredentials(request())).rejects.toThrow()
      if (complete)
        expect(api.deleteMcpSecret).toHaveBeenCalledWith('new-secret', {
          uid: 'repair-uid',
          resourceVersion: 'repair-rv',
        })
      else expect(api.deleteMcpSecret).not.toHaveBeenCalled()
      expect(api.updateMcpServer).not.toHaveBeenCalled()
    }
  )
  it('refuses a successful create without identity', async () => {
    vi.mocked(api.createMcpSecret).mockResolvedValue({
      name: 'new-secret',
      namespace: 'mcp-server',
    })
    await expect(attachConnectorCredentials(request())).rejects.toMatchObject({
      refreshRequired: true,
    })
    expect(api.deleteMcpSecret).not.toHaveBeenCalled()
    expect(api.updateMcpServer).not.toHaveBeenCalled()
  })
  it.each([409, 422])(
    'cleans only the exact created Secret after definite spec rejection %s',
    async status => {
      vi.mocked(api.updateMcpServer).mockRejectedValue(error(status))
      await expect(attachConnectorCredentials(request())).rejects.toThrow('could not be attached')
      expect(api.deleteMcpSecret).toHaveBeenCalledWith('new-secret', {
        uid: 'created-uid',
        resourceVersion: 'secret-rv',
      })
    }
  )
  it.each([409, 503])('reports both failures when cleanup is refused %s', async status => {
    vi.mocked(api.updateMcpServer).mockRejectedValue(error(422))
    vi.mocked(api.deleteMcpSecret).mockRejectedValue(error(status))
    await expect(attachConnectorCredentials(request())).rejects.toThrow(
      /could not be attached.*Cleanup.*new-secret/
    )
    expect(api.deleteMcpSecret).toHaveBeenCalledOnce()
  })
  it('treats an already absent cleanup target as cleaned', async () => {
    vi.mocked(api.updateMcpServer).mockRejectedValue(error(422))
    vi.mocked(api.deleteMcpSecret).mockRejectedValue(error(404))
    await expect(attachConnectorCredentials(request())).rejects.not.toThrow('Cleanup')
  })
  it('continues verification after a lost PUT response and matching readback', async () => {
    vi.mocked(api.updateMcpServer).mockRejectedValue(new TypeError('network'))
    const saved = {
      ...server(),
      metadata: { ...server().metadata, generation: 3 },
      spec: { ...server().spec, envSecret: reference },
    }
    vi.mocked(api.getMcpServer)
      .mockResolvedValueOnce(server())
      .mockResolvedValueOnce(server())
      .mockResolvedValueOnce(saved)
    expect((await attachConnectorCredentials(request())).server).toEqual(saved)
    expect(api.deleteMcpSecret).not.toHaveBeenCalled()
  })
  it.each(['old', 'replaced', 'unreadable'])(
    'retains Secret when PUT outcome is uncertain (%s)',
    async outcome => {
      vi.mocked(api.updateMcpServer).mockRejectedValue(error(500))
      const read = vi
        .mocked(api.getMcpServer)
        .mockResolvedValueOnce(server())
        .mockResolvedValueOnce(server())
      if (outcome === 'unreadable') read.mockRejectedValueOnce(error(503))
      else
        read.mockResolvedValueOnce({
          ...server(),
          metadata: {
            ...server().metadata,
            uid: outcome === 'replaced' ? 'replacement' : 'server-uid',
          },
        })
      await expect(attachConnectorCredentials(request())).rejects.toThrow('Secret was retained')
      expect(api.deleteMcpSecret).not.toHaveBeenCalled()
    }
  )
  it.each(['uid', 'spec', 'ownership', 'rv'])(
    'rechecks identity and eligibility after Secret creation (%s)',
    async change => {
      const latest = server()
      if (change === 'uid') latest.metadata.uid = 'replacement'
      if (change === 'spec') latest.spec.egressBindings = []
      if (change === 'ownership') latest.spec.managed = false
      if (change === 'rv') delete latest.metadata.resourceVersion
      vi.mocked(api.getMcpServer).mockResolvedValueOnce(server()).mockResolvedValueOnce(latest)
      await expect(attachConnectorCredentials(request())).rejects.toThrow(
        'current settings could not be verified'
      )
      expect(api.updateMcpServer).not.toHaveBeenCalled()
      expect(api.deleteMcpSecret).toHaveBeenCalledOnce()
    }
  )
  it('rejects ineligible or unidentified initial reads before any writes', async () => {
    vi.mocked(api.getMcpServer).mockResolvedValue({ ...server(), metadata: {} })
    await expect(attachConnectorCredentials(request())).rejects.toThrow('identity')
    expect(api.createMcpSecret).not.toHaveBeenCalled()
  })
  it('skips all Secret writes when existing values are blank', async () => {
    await attachConnectorCredentials(
      request({ mode: 'use-existing', selectedSecret: existing, rows: [{ ...row, value: '' }] })
    )
    expect(api.listMcpSecrets).toHaveBeenCalledOnce()
    expect(api.createMcpSecret).not.toHaveBeenCalled()
    expect(api.updateMcpSecret).not.toHaveBeenCalled()
    expect(api.updateMcpServer).toHaveBeenCalledOnce()
  })
  it('merges only filled keys before saving spec and returns other affected consumers', async () => {
    const result = await attachConnectorCredentials(
      request({ mode: 'use-existing', selectedSecret: existing })
    )
    expect(api.updateMcpSecret).toHaveBeenCalledWith('new-secret', { 'api-key': row.value })
    expect(api.updateMcpSecret.mock.invocationCallOrder[0]).toBeLessThan(
      api.updateMcpServer.mock.invocationCallOrder[0]
    )
    expect(result.affectedConnectors).toEqual(['other'])
  })
  it.each(['gone', 'key-gone', 'replaced'])(
    'stops before writes if selected Secret changed: %s',
    async change => {
      vi.mocked(api.listMcpSecrets).mockResolvedValue({
        items:
          change === 'gone'
            ? []
            : [
                {
                  ...existing,
                  keys: change === 'key-gone' ? [] : existing.keys,
                  uid: change === 'replaced' ? 'replacement' : existing.uid,
                },
              ],
      })
      await expect(
        attachConnectorCredentials(
          request({ mode: 'use-existing', selectedSecret: existing, rows: [{ ...row, value: '' }] })
        )
      ).rejects.toThrow()
      expect(api.updateMcpSecret).not.toHaveBeenCalled()
      expect(api.updateMcpServer).not.toHaveBeenCalled()
    }
  )
  it('never creates on an existing Secret update 404', async () => {
    vi.mocked(api.updateMcpSecret).mockRejectedValue(error(404))
    await expect(
      attachConnectorCredentials(request({ mode: 'use-existing', selectedSecret: existing }))
    ).rejects.toThrow('no longer exists')
    expect(api.createMcpSecret).not.toHaveBeenCalled()
    expect(api.updateMcpServer).not.toHaveBeenCalled()
  })
  it('does not undo existing values when spec save fails', async () => {
    vi.mocked(api.updateMcpServer).mockRejectedValue(error(409))
    await expect(
      attachConnectorCredentials(request({ mode: 'use-existing', selectedSecret: existing }))
    ).rejects.toThrow('Secret values were updated')
    expect(api.deleteMcpSecret).not.toHaveBeenCalled()
    expect(api.updateMcpSecret).toHaveBeenCalledOnce()
  })
})

describe('reference-only Secret reassignment', () => {
  const oldReference = { name: 'old-secret', keys: [{ secretKey: 'old-token', envVar: 'API_KEY' }] }
  function assignedServer() {
    const current = server()
    current.spec.envSecret = oldReference
    current.spec.contextRef = 'private-context'
    current.spec.remote = {
      authType: 'bearer',
      authHeaders: [{ name: 'Authorization', valueTemplate: 'Bearer ${API_KEY}' }],
    }
    return current
  }
  function changeRequest() {
    return {
      serverName: 'connector',
      server: assignedServer(),
      selection: { ready: true, secret: existing, rows: [{ ...row, value: '' }] },
    }
  }
  beforeEach(() => {
    vi.mocked(api.getMcpServer).mockResolvedValue(assignedServer())
  })
  it('changes only envSecret and preserves the remote auth, access, egress, and identity preconditions', async () => {
    const result = await changeConnectorSecretReference(changeRequest())
    expect(api.updateMcpServer).toHaveBeenCalledWith('connector', {
      metadata: { uid: 'server-uid', resourceVersion: '10' },
      spec: { ...assignedServer().spec, envSecret: reference },
    })
    expect(result.server.spec.envSecret).toEqual(reference)
    expect(api.createMcpSecret).not.toHaveBeenCalled()
    expect(api.updateMcpSecret).not.toHaveBeenCalled()
    expect(api.deleteMcpSecret).not.toHaveBeenCalled()
  })
  it.each([
    { managed: false },
    { enabled: false },
    { oauth: null },
    { envSecret: null },
    { envSecret: { name: 'invalid' } },
  ])('rejects ineligible reference changes without writes: %j', async changed => {
    const request = changeRequest()
    request.server.spec = { ...request.server.spec, ...changed }
    vi.mocked(api.getMcpServer).mockResolvedValue(request.server)
    await expect(changeConnectorSecretReference(request)).rejects.toThrow(/connector changed/)
    expect(api.updateMcpServer).not.toHaveBeenCalled()
    expect(api.deleteMcpSecret).not.toHaveBeenCalled()
  })
  it('rejects an edit since the displayed snapshot before checking or writing Secrets', async () => {
    const changed = assignedServer()
    changed.spec.image = 'example/new-image:v2'
    vi.mocked(api.getMcpServer).mockResolvedValue(changed)
    await expect(changeConnectorSecretReference(changeRequest())).rejects.toThrow(
      /connector changed/
    )
    expect(api.listMcpSecrets).not.toHaveBeenCalled()
    expect(api.updateMcpServer).not.toHaveBeenCalled()
  })
  it('rejects changes between verification and the final write', async () => {
    const changed = assignedServer()
    changed.spec.enabled = false
    vi.mocked(api.getMcpServer)
      .mockResolvedValueOnce(assignedServer())
      .mockResolvedValueOnce(changed)
    await expect(changeConnectorSecretReference(changeRequest())).rejects.toThrow(
      /connector changed/
    )
    expect(api.updateMcpServer).not.toHaveBeenCalled()
  })
  // Each case is the full `items` array, wrapped one extra level so `it.each`
  // passes it as a single argument instead of spreading it.
  it.each([
    [[]],
    [[{ ...existing, uid: 'replacement' }]],
    [[{ ...existing, keys: ['different-key'] }]],
  ])('rejects missing/replaced Secrets and missing stored keys: %j', async items => {
    vi.mocked(api.listMcpSecrets).mockResolvedValue({ items })
    await expect(changeConnectorSecretReference(changeRequest())).rejects.toThrow(/Secret|key/)
    expect(api.updateMcpServer).not.toHaveBeenCalled()
    expect(api.createMcpSecret).not.toHaveBeenCalled()
    expect(api.updateMcpSecret).not.toHaveBeenCalled()
    expect(api.deleteMcpSecret).not.toHaveBeenCalled()
  })
  it('rejects an unchanged assignment', async () => {
    const current = assignedServer()
    current.spec.envSecret = reference
    vi.mocked(api.getMcpServer).mockResolvedValue(current)
    await expect(
      changeConnectorSecretReference({ ...changeRequest(), server: current })
    ).rejects.toThrow(/different Secret/)
    expect(api.updateMcpServer).not.toHaveBeenCalled()
  })
  it('never cleans up shared Secrets when the API rejects the reference save', async () => {
    vi.mocked(api.updateMcpServer).mockRejectedValue(error(409))
    await expect(changeConnectorSecretReference(changeRequest())).rejects.toThrow(/rejected/)
    expect(api.deleteMcpSecret).not.toHaveBeenCalled()
  })
  it('recovers an uncertain successful save through a matching read', async () => {
    vi.mocked(api.updateMcpServer).mockRejectedValue(error(503))
    const saved = assignedServer()
    saved.spec.envSecret = reference
    vi.mocked(api.getMcpServer)
      .mockResolvedValueOnce(assignedServer())
      .mockResolvedValueOnce(assignedServer())
      .mockResolvedValueOnce(saved)
    expect((await changeConnectorSecretReference(changeRequest())).server).toEqual(saved)
    expect(api.deleteMcpSecret).not.toHaveBeenCalled()
  })
  it('reports an uncertain outcome when the read cannot prove the reference was saved', async () => {
    vi.mocked(api.updateMcpServer).mockRejectedValue(error(503))
    await expect(changeConnectorSecretReference(changeRequest())).rejects.toThrow(
      /could not be confirmed/
    )
    expect(api.deleteMcpSecret).not.toHaveBeenCalled()
  })
  it('rejects any attempt to supply credential bytes in a reference-only operation', async () => {
    const request = changeRequest()
    request.selection.rows[0].value = 'unexpected'
    await expect(changeConnectorSecretReference(request)).rejects.toThrow(/key/)
    expect(api.updateMcpServer).not.toHaveBeenCalled()
    expect(api.updateMcpSecret).not.toHaveBeenCalled()
  })
})