Skip to content

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

TypeScript
6.1 KB
Raw Blame
import { describe, expect, it, vi } from 'vitest'
import {
  agentNamesForContextAccess,
  applyAgentAccessCompatibilityUpdate,
  effectiveAgentNamesForAccess,
  planAgentAccessUpdate,
} from '../agentAccessCompatibility'
import type { ContextResource, HostResource } from '../api'

const hosts: HostResource[] = [
  { metadata: { name: 'agent-alpha' }, spec: { contextRef: 'ctx-alpha' } },
  { metadata: { name: 'agent-beta' }, spec: { contextRef: 'ctx-beta' } },
]
const contexts: ContextResource[] = [
  { metadata: { name: 'ctx-alpha' }, spec: { contextId: 'ctx-alpha', mcpServers: [] } },
  { metadata: { name: 'ctx-beta' }, spec: { contextId: 'ctx-beta', mcpServers: [] } },
  {
    metadata: { name: 'member-private-scope' },
    spec: { contextId: 'member-private-scope', mcpServers: [] },
  },
]

describe('planAgentAccessUpdate', () => {
  it('derives the effective Agent grant set from direct and Context-only access', () => {
    expect(
      effectiveAgentNamesForAccess({
        assignedAgentNames: ['agent-beta'],
        assignedContextIds: ['ctx-alpha', 'member-private-scope'],
        contexts,
        hosts,
      })
    ).toEqual(['agent-alpha', 'agent-beta'])
  })

  it('keeps only the member’s already-assigned unowned scopes', () => {
    const result = planAgentAccessUpdate(['member-private-scope'], ['agent-alpha'], hosts)

    expect(result).toEqual({
      agentNames: ['agent-alpha'],
      contextIds: ['ctx-alpha', 'member-private-scope'],
    })
    expect(result.contextIds).not.toContain('unrelated-unowned-scope')
  })

  it('keeps only the team’s already-assigned unowned scopes', () => {
    const result = planAgentAccessUpdate([], ['agent-beta'], hosts)

    expect(result).toEqual({
      agentNames: ['agent-beta'],
      contextIds: ['ctx-beta'],
    })
    expect(result.contextIds).not.toContain('unrelated-unowned-scope')
  })

  it('drops a revoked Agent scope while retaining a shared selected scope once', () => {
    const sharedHosts: HostResource[] = [
      { metadata: { name: 'agent-alpha' }, spec: { contextRef: 'ctx-shared' } },
      { metadata: { name: 'agent-beta' }, spec: { contextRef: 'ctx-shared' } },
      { metadata: { name: 'agent-revoked' }, spec: { contextRef: 'ctx-revoked' } },
    ]

    expect(
      planAgentAccessUpdate(
        ['ctx-shared', 'ctx-revoked'],
        ['agent-beta', 'agent-alpha'],
        sharedHosts
      )
    ).toEqual({
      agentNames: ['agent-alpha', 'agent-beta'],
      contextIds: ['ctx-shared'],
    })
  })

  it.each(['member', 'team'])(
    'preserves existing %s access through mismatched Context aliases',
    () => {
      const aliasedContexts: ContextResource[] = [
        {
          metadata: { name: 'ctx-resource' },
          spec: { contextId: 'ctx-wire', mcpServers: [] },
        },
      ]
      const aliasedHosts: HostResource[] = [
        { metadata: { name: 'agent-alpha' }, spec: { contextRef: 'ctx-wire' } },
      ]

      expect(
        planAgentAccessUpdate(['ctx-resource'], ['agent-alpha'], aliasedHosts, aliasedContexts)
      ).toEqual({ agentNames: ['agent-alpha'], contextIds: ['ctx-resource'] })
      expect(agentNamesForContextAccess(['ctx-resource'], aliasedHosts, aliasedContexts)).toEqual([
        'agent-alpha',
      ])
    }
  )
})

describe('applyAgentAccessCompatibilityUpdate', () => {
  it.each(['member', 'team'])(
    'does not start the %s Context write when the Agent CAS is stale',
    async () => {
      const staleCas = Object.assign(new Error('Precondition failed'), { status: 412 })
      const updateAgents = vi.fn().mockRejectedValue(staleCas)
      const loadCurrentContextIds = vi.fn().mockResolvedValue(['member-private-scope'])
      const updateContexts = vi.fn().mockResolvedValue({})

      await expect(
        applyAgentAccessCompatibilityUpdate({
          contexts,
          hosts,
          loadCurrentContextIds,
          nextGrantedAgentNames: ['agent-alpha'],
          updateAgents,
          updateContexts,
        })
      ).rejects.toBe(staleCas)
      expect(updateAgents).toHaveBeenCalledOnce()
      expect(loadCurrentContextIds).not.toHaveBeenCalled()
      expect(updateContexts).not.toHaveBeenCalled()
    }
  )

  it.each(['member', 'team'])(
    'does not restore an unowned Context revoked after the %s page loaded',
    async () => {
      const calls: string[] = []
      const updateContexts = vi.fn(async (contextIds: string[]) => {
        calls.push('contexts')
        return { contextIds }
      })

      const result = await applyAgentAccessCompatibilityUpdate({
        contexts,
        hosts,
        loadCurrentContextIds: async () => {
          calls.push('refresh-contexts')
          // The page originally saw ctx-sensitive, but another admin revoked
          // it before this post-CAS refresh.
          return []
        },
        nextGrantedAgentNames: ['agent-alpha'],
        updateAgents: async agentNames => {
          calls.push('agents')
          return { agentNames }
        },
        updateContexts,
      })

      expect(calls).toEqual(['agents', 'refresh-contexts', 'contexts'])
      expect(updateContexts).toHaveBeenCalledWith(['ctx-alpha'])
      expect(updateContexts).not.toHaveBeenCalledWith(expect.arrayContaining(['ctx-sensitive']))
      expect(result[1]).toEqual({ contextIds: ['ctx-alpha'] })
    }
  )

  it('writes refreshed Context compatibility state only after the Agent CAS succeeds', async () => {
    const calls: string[] = []
    const result = await applyAgentAccessCompatibilityUpdate({
      contexts,
      hosts,
      loadCurrentContextIds: async () => {
        calls.push('refresh-contexts')
        return ['member-private-scope']
      },
      nextGrantedAgentNames: ['agent-alpha'],
      updateAgents: async () => {
        calls.push('agents')
        return { agentNames: ['agent-alpha'] }
      },
      updateContexts: async contextIds => {
        calls.push('contexts')
        return { contextIds }
      },
    })

    expect(calls).toEqual(['agents', 'refresh-contexts', 'contexts'])
    expect(result).toEqual([
      { agentNames: ['agent-alpha'] },
      { contextIds: ['ctx-alpha', 'member-private-scope'] },
    ])
  })
})