Skip to content

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

TypeScript
3.5 KB
Raw Blame
import { beforeEach, describe, expect, it, vi } from 'vitest'
import * as k8s from '@kubernetes/client-node'
import { NetworkPolicyReconciler } from '../src/networkPolicyReconciler'
import { applyNetworkPolicy } from '../src/utils'

// Mutable nodeLocalDnsCidr so a single file can cover both the default
// (empty -> no ipBlock) and the configured kube-dns Service IP paths.
const mockConfig = {
  namespace: 'mcp-server',
  hostNamespace: 'mcp-host',
  rpcProxyNamespace: 'rpc-proxy',
  runtimeNamespaces: ['sandbox-recipes'],
  minimalInfraNamespaces: [],
  k8sApiCidrs: [],
  nodeLocalDnsCidr: '',
  port: 8081,
}

vi.mock('../src/config', () => ({
  get config() {
    return mockConfig
  },
}))

vi.mock('../src/utils', async importOriginal => {
  const actual = await importOriginal<typeof import('../src/utils')>()
  return {
    ...actual,
    applyNetworkPolicy: vi.fn().mockResolvedValue(undefined),
  }
})

const mockApply = vi.mocked(applyNetworkPolicy)

function createMockNetworkingApi() {
  return {
    createNamespacedNetworkPolicy: vi.fn().mockResolvedValue({}),
    readNamespacedNetworkPolicy: vi
      .fn()
      .mockRejectedValue(Object.assign(new Error('not found'), { code: 404 })),
    replaceNamespacedNetworkPolicy: vi.fn().mockResolvedValue({}),
    deleteNamespacedNetworkPolicy: vi.fn().mockResolvedValue({}),
    listNamespacedNetworkPolicy: vi.fn().mockResolvedValue({ items: [] }),
  }
}

function dnsPolicyFor(namespace: string): k8s.V1NetworkPolicy | undefined {
  const call = mockApply.mock.calls.find(
    c => c[1] === `allow-dns-egress-${namespace}` && c[2] === namespace
  )
  return call?.[3] as k8s.V1NetworkPolicy | undefined
}

describe('NetworkPolicyReconciler — NodeLocal DNSCache ipBlock egress', () => {
  let reconciler: NetworkPolicyReconciler

  beforeEach(() => {
    vi.clearAllMocks()
    mockConfig.nodeLocalDnsCidr = ''
    const mockKc = {
      makeApiClient: () => createMockNetworkingApi() as unknown as k8s.NetworkingV1Api,
    } as unknown as k8s.KubeConfig
    reconciler = new NetworkPolicyReconciler(mockKc, new Map())
  })

  it('default (nodeLocalDnsCidr empty) -> only the kube-system selector, no ipBlock', async () => {
    mockConfig.nodeLocalDnsCidr = ''

    await reconciler.ensureDefaultPolicies()

    const policy = dnsPolicyFor('sandbox-recipes')
    expect(policy).toBeDefined()
    const egress = policy!.spec!.egress!
    expect(egress).toHaveLength(1)
    expect(egress[0].to).toEqual([
      { namespaceSelector: { matchLabels: { 'kubernetes.io/metadata.name': 'kube-system' } } },
    ])
    // No ipBlock anywhere in the egress.
    const hasIpBlock = egress.some(rule => rule.to?.some(peer => 'ipBlock' in peer))
    expect(hasIpBlock).toBe(false)
  })

  it('with nodeLocalDnsCidr set -> appends a second ipBlock egress rule with that cidr + port 53', async () => {
    mockConfig.nodeLocalDnsCidr = '203.0.113.10/32'

    await reconciler.ensureDefaultPolicies()

    const policy = dnsPolicyFor('sandbox-recipes')
    expect(policy).toBeDefined()
    const egress = policy!.spec!.egress!
    expect(egress).toHaveLength(2)

    // First rule unchanged: kube-system selector.
    expect(egress[0].to).toEqual([
      { namespaceSelector: { matchLabels: { 'kubernetes.io/metadata.name': 'kube-system' } } },
    ])

    // Second rule: ipBlock to the cluster-specific kube-dns Service IP on port 53.
    expect(egress[1].to).toEqual([{ ipBlock: { cidr: '203.0.113.10/32' } }])
    expect(egress[1].ports).toEqual([
      { port: 53, protocol: 'UDP' },
      { port: 53, protocol: 'TCP' },
    ])
  })
})