Skip to content

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

TypeScript
5.6 KB
Raw Blame
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
import { randomBytes, randomUUID } from 'node:crypto'
import { Pool } from 'pg'
import { GfsSubjectResolutionDeniedError, resolveAuthzContext } from './subjectResolver'

const adminUrl = process.env.CONTROL_API_REAL_PG_ADMIN_URL
const describeRealPostgres = adminUrl ? describe : describe.skip

function databaseUrl(baseUrl: string, database: string): string {
  const url = new URL(baseUrl)
  url.pathname = `/${database}`
  return url.toString()
}

describeRealPostgres('gfsc subject lifecycle resolution on real PostgreSQL', () => {
  const database = `gfsc_subject_lifecycle_${randomBytes(6).toString('hex')}`
  const userId = randomUUID()
  const adminId = randomUUID()
  const lineageId = randomUUID()
  let adminPool: Pool
  let db: Pool

  beforeAll(async () => {
    adminPool = new Pool({ connectionString: adminUrl })
    await adminPool.query(`CREATE DATABASE "${database}"`)
    db = new Pool({ connectionString: databaseUrl(adminUrl as string, database) })
    await db.query(`
      CREATE TABLE users (
        id UUID PRIMARY KEY,
        lifecycle_state TEXT NOT NULL,
        lifecycle_version BIGINT NOT NULL
      );
      CREATE TABLE control_admin_users (
        id UUID PRIMARY KEY,
        status TEXT NOT NULL,
        session_version INTEGER NOT NULL
      );
      CREATE TABLE gfs_desktop_operator_links (
        id UUID PRIMARY KEY,
        lineage_id UUID NOT NULL,
        generation INTEGER NOT NULL,
        user_id UUID NOT NULL,
        control_admin_id UUID NOT NULL,
        state TEXT NOT NULL,
        source TEXT NOT NULL
      );
      CREATE TABLE team_members (
        team_id UUID NOT NULL,
        user_id UUID NOT NULL,
        status TEXT NOT NULL
      );
      INSERT INTO users (id, lifecycle_state, lifecycle_version)
      VALUES ('${userId}', 'active', 1);
      INSERT INTO control_admin_users (id, status, session_version)
      VALUES ('${adminId}', 'active', 1);
      INSERT INTO gfs_desktop_operator_links
        (id, lineage_id, generation, user_id, control_admin_id, state, source)
      VALUES ('${randomUUID()}', '${lineageId}', 1, '${userId}', '${adminId}', 'active', 'initial_setup');
    `)
  }, 60_000)

  afterAll(async () => {
    await db?.end()
    if (!adminPool) return
    await adminPool.query(
      `SELECT pg_terminate_backend(pid) FROM pg_stat_activity
        WHERE datname = $1 AND pid <> pg_backend_pid()`,
      [database]
    )
    await adminPool.query(`DROP DATABASE IF EXISTS "${database}"`)
    await adminPool.end()
  })

  const userClaims = () => ({
    sub: userId,
    drive: 'main',
    principalType: 'user' as const,
    authGeneration: 1,
  })

  const linkedClaims = () => ({
    sub: adminId,
    drive: 'main',
    principalType: 'control-admin' as const,
    authGeneration: 1,
    brokeredAuthority: {
      desktopUserId: userId,
      controlAdminId: adminId,
      authoritySource: 'linked-admin' as const,
      linkLineageId: lineageId,
      linkGeneration: 1,
      desktopUserGeneration: 1,
    },
  })

  it('allows the current user generation, then denies the same bearer after retirement', async () => {
    await expect(
      resolveAuthzContext(db, { ...userClaims(), scopes: [], pathBindings: [] })
    ).resolves.toMatchObject({
      primarySubject: userId,
      isOperator: false,
    })
    await db.query(
      `UPDATE users SET lifecycle_state = 'retired', lifecycle_version = 2 WHERE id = $1`,
      [userId]
    )
    await expect(
      resolveAuthzContext(db, { ...userClaims(), scopes: [], pathBindings: [] })
    ).rejects.toBeInstanceOf(GfsSubjectResolutionDeniedError)
  })

  it('denies a linked-admin bearer after the active link generation is revoked', async () => {
    await db.query(
      `UPDATE users SET lifecycle_state = 'active', lifecycle_version = 1 WHERE id = $1`,
      [userId]
    )
    await db.query(`UPDATE gfs_desktop_operator_links SET state = 'revoked' WHERE user_id = $1`, [
      userId,
    ])
    await expect(resolveAuthzContext(db, linkedClaims())).rejects.toBeInstanceOf(
      GfsSubjectResolutionDeniedError
    )
  })

  it('denies a linked-admin bearer when the link generation is stale', async () => {
    await db.query(
      `UPDATE users SET lifecycle_state = 'active', lifecycle_version = 1 WHERE id = $1`,
      [userId]
    )
    await db.query(
      `UPDATE control_admin_users SET status = 'active', session_version = 1 WHERE id = $1`,
      [adminId]
    )
    await db.query(
      `UPDATE gfs_desktop_operator_links
       SET state = 'active', generation = 2
       WHERE user_id = $1 AND control_admin_id = $2`,
      [userId, adminId]
    )
    await expect(resolveAuthzContext(db, linkedClaims())).rejects.toBeInstanceOf(
      GfsSubjectResolutionDeniedError
    )
  })

  it('denies a linked-admin bearer when the control-admin session generation is stale', async () => {
    await db.query(
      `UPDATE users SET lifecycle_state = 'active', lifecycle_version = 1 WHERE id = $1`,
      [userId]
    )
    await db.query(
      `UPDATE control_admin_users SET status = 'active', session_version = 1 WHERE id = $1`,
      [adminId]
    )
    await db.query(
      `UPDATE gfs_desktop_operator_links
       SET state = 'active', generation = 1
       WHERE user_id = $1 AND control_admin_id = $2`,
      [userId, adminId]
    )
    await expect(resolveAuthzContext(db, linkedClaims())).resolves.toMatchObject({
      primarySubject: adminId,
      isOperator: true,
    })

    await db.query(`UPDATE control_admin_users SET session_version = 2 WHERE id = $1`, [adminId])
    await expect(resolveAuthzContext(db, linkedClaims())).rejects.toBeInstanceOf(
      GfsSubjectResolutionDeniedError
    )
  })
})