Skip to content

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

TypeScript
6.6 KB
Raw Blame
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
import { randomBytes, randomUUID } from 'node:crypto'
import { Pool } from 'pg'
import { initDb } from '../src/db.js'
import { endPoolAndWaitForClients } from './helpers/realPostgresTeardown.js'

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()
}

function quoteIdent(value: string): string {
  return `"${value.replace(/"/g, '""')}"`
}

describeRealPostgres('GFS immutable blob migration on real PostgreSQL', () => {
  const database = `gfs_blob_migration_${randomBytes(6).toString('hex')}`
  const connectionString = databaseUrl(
    adminUrl ?? 'postgresql://[email protected]/postgres',
    database
  )
  let adminPool: Pool
  let pool: Pool

  beforeAll(async () => {
    adminPool = new Pool({ connectionString: adminUrl })
    await adminPool.query(`CREATE DATABASE ${quoteIdent(database)}`)
    pool = new Pool({ connectionString })
    const connector = { connect: () => pool.connect() }
    await initDb(connector)
    await initDb(connector)
  }, 60_000)

  afterAll(async () => {
    try {
      await endPoolAndWaitForClients(pool)
      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 ${quoteIdent(database)}`)
    } finally {
      await adminPool?.end()
    }
  })

  it('applies 0071_gfs_immutable_blob_generations exactly once with named constraints, indexes, and writer ACL', async () => {
    const versions = await pool.query<{ count: string }>(
      `SELECT count(*)::text AS count FROM schema_migrations
        WHERE version = '0071_gfs_immutable_blob_generations'`
    )
    expect(versions.rows).toEqual([{ count: '1' }])

    const columns = await pool.query<{ column_name: string; is_nullable: string }>(
      `SELECT column_name,is_nullable FROM information_schema.columns
        WHERE table_schema='public' AND table_name='gfs_blob_manifests'
        ORDER BY ordinal_position`
    )
    expect(columns.rows.map(row => row.column_name)).toEqual([
      'blob_key',
      'request_id',
      'resource_id',
      'candidate_kind',
      'content_sha256',
      'bytes',
      'state',
      'created_at',
      'updated_at',
    ])
    expect(columns.rows.find(row => row.column_name === 'content_sha256')?.is_nullable).toBe('YES')

    const constraints = await pool.query<{ conname: string; definition: string }>(
      `SELECT conname,pg_get_constraintdef(oid) AS definition FROM pg_constraint
        WHERE conrelid IN ('gfs_resources'::regclass,'gfs_blob_manifests'::regclass)
          AND conname IN ('gfs_resources_blob_metadata_pair','gfs_blob_manifests_blob_key_valid')
        ORDER BY conname`
    )
    expect(constraints.rows.map(row => row.conname)).toEqual([
      'gfs_blob_manifests_blob_key_valid',
      'gfs_resources_blob_metadata_pair',
    ])
    expect(constraints.rows.map(row => row.definition).join(' ')).toMatch(
      /generation.*legacy_flat.*content_sha256 IS NULL/s
    )

    const indexes = await pool.query<{ indexname: string; indexdef: string }>(
      `SELECT indexname,indexdef FROM pg_indexes WHERE schemaname='public'
        AND indexname IN ('gfs_resources_blob_key_uniq','gfs_blob_manifests_cleanup_idx')
        ORDER BY indexname`
    )
    expect(indexes.rows.map(row => row.indexname)).toEqual([
      'gfs_blob_manifests_cleanup_idx',
      'gfs_resources_blob_key_uniq',
    ])
    expect(indexes.rows[0]?.indexdef).toContain('(state, updated_at, blob_key)')
    expect(indexes.rows[1]?.indexdef).toContain('WHERE (blob_key IS NOT NULL)')

    const acl = await pool.query<Record<string, boolean>>(`
      SELECT has_table_privilege('gfs_controller','gfs_resources','SELECT') AS resource_read,
             has_table_privilege('gfs_controller','gfs_resources','INSERT') AS resource_insert,
             has_table_privilege('gfs_controller','gfs_resources','UPDATE') AS resource_update,
             has_table_privilege('gfs_controller','gfs_resources','DELETE') AS resource_delete,
             has_table_privilege('gfs_controller','gfs_blob_manifests','SELECT') AS manifest_read,
             has_table_privilege('gfs_controller','gfs_blob_manifests','INSERT') AS manifest_insert,
             has_table_privilege('gfs_controller','gfs_blob_manifests','UPDATE') AS manifest_update,
             has_table_privilege('gfs_controller','gfs_blob_manifests','DELETE') AS manifest_delete`)
    expect(acl.rows[0]).toEqual({
      resource_read: true,
      resource_insert: true,
      resource_update: true,
      resource_delete: false,
      manifest_read: true,
      manifest_insert: true,
      manifest_update: true,
      manifest_delete: true,
    })
  })

  it('enforces generation ownership and permits only typed legacy cleanup candidates', async () => {
    const rootId = randomUUID()
    const resourceId = randomUUID()
    const drive = `blob-shape-${randomBytes(4).toString('hex')}`
    await pool.query(
      `INSERT INTO gfs_resources(resource_id,drive,parent_resource_id,name,kind,path_cache)
       VALUES ($1,$3,NULL,'','directory','/'),($2,$3,$1,'file.txt','file','/file.txt')`,
      [rootId, resourceId, drive]
    )
    const compactId = resourceId.replaceAll('-', '')
    const generationKey = `${compactId}/${randomUUID()}`
    await pool.query(
      `UPDATE gfs_resources SET blob_key=$2,content_sha256=$3 WHERE resource_id=$1`,
      [resourceId, generationKey, 'a'.repeat(64)]
    )
    await expect(
      pool.query(`UPDATE gfs_resources SET blob_key=$2,content_sha256=$3 WHERE resource_id=$1`, [
        resourceId,
        `${rootId.replaceAll('-', '')}/${randomUUID()}`,
        'a'.repeat(64),
      ])
    ).rejects.toMatchObject({ code: '23514' })
    await pool.query(
      `INSERT INTO gfs_blob_manifests
         (blob_key,request_id,resource_id,candidate_kind,content_sha256,bytes,state)
       VALUES ($1,$2,$3,'generation',$4,1,'staged'),
              ($5,$6,$3,'legacy_flat',NULL,1,'deleting')`,
      [generationKey, randomUUID(), resourceId, 'a'.repeat(64), compactId, randomUUID()]
    )
    await expect(
      pool.query(
        `INSERT INTO gfs_blob_manifests
         (blob_key,request_id,resource_id,candidate_kind,content_sha256,bytes,state)
       VALUES ($1,$2,$3,'legacy_flat',$4,1,'deleting')`,
        [rootId.replaceAll('-', ''), randomUUID(), rootId, 'b'.repeat(64)]
      )
    ).rejects.toMatchObject({ code: '23514' })
  })
})