Skip to content

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

TypeScript

test(control-api): prove invitation admission error contract

Josué565813b4590d
diff --git a/control-api/package-lock.json b/control-api/package-lock.json
index c32255081..7598627b7 100644
--- a/control-api/package-lock.json
+++ b/control-api/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "clerum-control-api",
- "version": "0.1.744",
+ "version": "0.1.745",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "clerum-control-api",
- "version": "0.1.744",
+ "version": "0.1.745",
"dependencies": {
"@clerum/display-field": "file:../packages/display-field",
"@clerum/grok-provider-attempt-contract": "file:../packages/grok-provider-attempt-contract",
diff --git a/control-api/package.json b/control-api/package.json
index e855de6fa..d7791d50f 100644
--- a/control-api/package.json
+++ b/control-api/package.json
@@ -1,6 +1,6 @@
{
"name": "clerum-control-api",
- "version": "0.1.744",
+ "version": "0.1.745",
"description": "Internal Clerum control plane REST API + UI for managing CRDs and secrets",
"main": "dist/main.js",
"engines": {
diff --git a/control-api/test/r2m1.passwordAuthorityConsumer.realPostgres.integration.test.ts b/control-api/test/r2m1.passwordAuthorityConsumer.realPostgres.integration.test.ts
new file mode 100644
index 000000000..16eeadace
--- /dev/null
+++ b/control-api/test/r2m1.passwordAuthorityConsumer.realPostgres.integration.test.ts
@@ -0,0 +1,260 @@
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
+import express from 'express'
+import { generateKeyPairSync, randomBytes } from 'node:crypto'
+import type { Server } from 'node:http'
+import { Pool } from 'pg'
+import request from 'supertest'
+import { endPoolAndWaitForClients } from './helpers/realPostgresTeardown.js'
+
+const adminUrl = process.env.CONTROL_API_REAL_PG_ADMIN_URL
+const realPg = adminUrl ? describe : describe.skip
+
+realPg('R2-M1/R2-M2 public password authority contract on PostgreSQL 16', () => {
+ const database = `r2m1_authority_${randomBytes(6).toString('hex')}`
+ const serviceToken = `synthetic-external-rest-${randomBytes(20).toString('hex')}`
+ const invitationPassword = 'Synthetic-Invitation-Password-123'
+ const currentPassword = 'Synthetic-Current-Password-123'
+ const replacementPassword = 'Synthetic-Replacement-Password-123'
+ let admin: Pool
+ let db: typeof import('../src/db.js')
+ let controlApp: express.Express
+ let controlServer: Server
+ let publicApp: express.Express
+ let bcrypt: typeof import('bcryptjs').default
+ let externalConfig: (typeof import('../../external-rest-api/src/config.js'))['config']
+ let previousBaseUrl: string
+ let previousServiceToken: string
+ let sourceCounter = 1
+
+ beforeAll(async () => {
+ admin = new Pool({ connectionString: adminUrl })
+ await admin.query(`CREATE DATABASE "${database}"`)
+ const databaseUrl = new URL(adminUrl!)
+ databaseUrl.pathname = `/${database}`
+ vi.stubEnv('CONTROL_API_PG_CONNECTION_STRING', databaseUrl.toString())
+ vi.stubEnv('CONTROL_API_INTERNAL_SERVICE_TOKENS', `external-rest-api=${serviceToken}`)
+ vi.stubEnv('EXTERNAL_REST_API_CONTROL_API_SERVICE_TOKEN', serviceToken)
+ vi.stubEnv('EXTERNAL_REST_API_CONTROL_API_SERVICE_NAME', 'external-rest-api')
+ const { privateKey, publicKey } = generateKeyPairSync('rsa', { modulusLength: 2048 })
+ vi.stubEnv(
+ 'CONTROL_API_SESSION_JWT_PRIVATE_KEY',
+ privateKey.export({ type: 'pkcs8', format: 'pem' }).toString()
+ )
+ vi.stubEnv(
+ 'EXTERNAL_REST_API_JWT_PUBLIC_KEY',
+ publicKey.export({ type: 'spki', format: 'pem' }).toString()
+ )
+ vi.resetModules()
+
+ bcrypt = (await import('bcryptjs')).default
+ db = await import('../src/db.js')
+ await db.initDb()
+ const { requireInternalService, requireInternalToken } =
+ await import('../src/middleware/internalServiceAuth.js')
+ const { createExternalInvitationsRouter } =
+ await import('../src/routes/external/invitations.js')
+ const { createExternalUsersRouter } = await import('../src/routes/external/users.js')
+
+ controlApp = express()
+ controlApp.use(express.json())
+ controlApp.use(requireInternalToken)
+ const controlApi = express.Router()
+ controlApi.use('/external', requireInternalService('external-rest-api'))
+ controlApi.use(createExternalInvitationsRouter())
+ controlApi.use(createExternalUsersRouter({} as Parameters<typeof createExternalUsersRouter>[0]))
+ controlApp.use('/api/v1', controlApi)
+ controlServer = controlApp.listen(0, '127.0.0.1')
+ await new Promise<void>(resolve => controlServer.once('listening', resolve))
+
+ externalConfig = (await import('../../external-rest-api/src/config.js')).config
+ previousBaseUrl = externalConfig.controlApiBaseUrl
+ previousServiceToken = externalConfig.controlApiServiceToken
+ externalConfig.controlApiBaseUrl = `http://127.0.0.1:${(controlServer.address() as { port: number }).port}/api/v1`
+ externalConfig.controlApiServiceToken = serviceToken
+ const { createApp } = await import('../../external-rest-api/src/app.js')
+ publicApp = createApp()
+ }, 60_000)
+
+ afterAll(async () => {
+ try {
+ if (externalConfig) {
+ externalConfig.controlApiBaseUrl = previousBaseUrl
+ externalConfig.controlApiServiceToken = previousServiceToken
+ }
+ if (controlServer) {
+ await new Promise<void>((resolve, reject) =>
+ controlServer.close(error => (error ? reject(error) : resolve()))
+ )
+ }
+ if (db) {
+ await endPoolAndWaitForClients(db.pool)
+ await endPoolAndWaitForClients(db.rateLimitPool)
+ }
+ if (admin) await admin.query(`DROP DATABASE IF EXISTS "${database}"`)
+ } finally {
+ await admin?.end()
+ vi.unstubAllEnvs()
+ }
+ })
+
+ async function acceptedInvitationSession() {
+ const { acceptInvitationForEmail, createSilentInvitationForTeams } =
+ await import('../src/services/directory/membership.js')
+ const { signExternalSessionToken } =
+ await import('../src/utils/auth/externalSessionAuthToken.js')
+ const { verifyToken } = await import('../../external-rest-api/src/authToken.js')
+ const email = `r2m1-${randomBytes(8).toString('hex')}@example.invalid`
+ const invitation = await createSilentInvitationForTeams({
+ inviteeName: 'Synthetic invited member',
+ email,
+ purpose: 'member_invitation',
+ teamAssignments: [],
+ fallbackRole: 'member',
+ })
+ const accepted = await acceptInvitationForEmail(email, invitation.token, invitation.id)
+ expect(accepted).not.toHaveProperty('error')
+ if (!('data' in accepted) || !accepted.data) throw new Error('invitation acceptance failed')
+ const user = await db.pool.query('SELECT lifecycle_version FROM users WHERE id = $1', [
+ accepted.data.userId,
+ ])
+ const token = signExternalSessionToken({
+ userId: accepted.data.userId,
+ email,
+ teamId: null,
+ role: 'member',
+ authGeneration: Number(user.rows[0].lifecycle_version),
+ })
+ expect(verifyToken(token)).toMatchObject({ userId: accepted.data.userId, email })
+ return {
+ email,
+ userId: accepted.data.userId,
+ invitationId: invitation.id,
+ token,
+ }
+ }
+
+ function nextSourceIp() {
+ return `198.51.100.${sourceCounter++}`
+ }
+
+ async function passwordOwner() {
+ const { acquirePasswordWork } = await import('../src/services/auth/passwordWorkOwnership.js')
+ const owner = await acquirePasswordWork()
+ expect(owner).not.toBeNull()
+ if (!owner) throw new Error('password work owner was not acquired')
+ return owner
+ }
+
+ async function withPasswordAuthorityUnavailable<T>(work: () => Promise<T>): Promise<T> {
+ await db.pool.query(
+ 'ALTER TABLE password_verification_work RENAME TO password_verification_work_unavailable'
+ )
+ try {
+ return await work()
+ } finally {
+ await db.pool.query(
+ 'ALTER TABLE password_verification_work_unavailable RENAME TO password_verification_work'
+ )
+ }
+ }
+
+ async function invitationPasswordRequest(
+ session: Awaited<ReturnType<typeof acceptedInvitationSession>>,
+ sourceIp: string,
+ password = invitationPassword
+ ) {
+ return request(publicApp)
+ .post('/api/v1/invitations/password')
+ .set('authorization', `Bearer ${session.token}`)
+ .set('x-forwarded-for', sourceIp)
+ .send({ invitationId: session.invitationId, password })
+ }
+
+ async function memberPasswordRequest(
+ token: string,
+ sourceIp: string,
+ nextPassword = replacementPassword
+ ) {
+ return request(publicApp)
+ .put('/api/v1/me/password')
+ .set('authorization', `Bearer ${token}`)
+ .set('x-forwarded-for', sourceIp)
+ .send({ currentPassword, newPassword: nextPassword })
+ }
+
+ async function memberWithPassword() {
+ const session = await acceptedInvitationSession()
+ const setPassword = await invitationPasswordRequest(session, nextSourceIp(), currentPassword)
+ expect(setPassword.status).toBe(200)
+ const user = await db.pool.query('SELECT password_hash FROM users WHERE id = $1', [
+ session.userId,
+ ])
+ expect(user.rows[0].password_hash).toEqual(expect.any(String))
+ return { ...session, passwordHash: user.rows[0].password_hash as string }
+ }
+
+ it('returns a sanitized busy response, preserves invitation state, and succeeds on retry', async () => {
+ const session = await acceptedInvitationSession()
+ const owner = await passwordOwner()
+ const sourceIp = nextSourceIp()
+ let denied: Awaited<ReturnType<typeof invitationPasswordRequest>>
+ try {
+ denied = await invitationPasswordRequest(session, sourceIp)
+ } finally {
+ await owner.release()
+ }
+
+ expect(denied.status).toBe(429)
+ expect(denied.body).toEqual({ error: 'rate_limited', retryAfterSeconds: 8 })
+ expect(denied.headers['retry-after']).toBe('8')
+ expect(denied.headers['set-cookie']).toBeUndefined()
+ expect(JSON.stringify(denied.body)).not.toMatch(/verification_busy|password_verification_work/i)
+ expect(
+ (await db.pool.query('SELECT status FROM invitations WHERE id = $1', [session.invitationId]))
+ .rows[0].status
+ ).toBe('accepted')
+ expect(
+ (await db.pool.query('SELECT password_hash FROM users WHERE id = $1', [session.userId]))
+ .rows[0].password_hash
+ ).toBeNull()
+
+ const retried = await invitationPasswordRequest(session, sourceIp)
+ expect(retried.status).toBe(200)
+ expect(String(retried.headers['set-cookie'])).toContain('profile_session=')
+ expect(
+ await bcrypt.compare(
+ invitationPassword,
+ (await db.pool.query('SELECT password_hash FROM users WHERE id = $1', [session.userId]))
+ .rows[0].password_hash
+ )
+ ).toBe(true)
+ })
+
+ it('returns sanitized authority unavailability without consuming invitation state', async () => {
+ const session = await acceptedInvitationSession()
+ const sourceIp = nextSourceIp()
+ const denied = await withPasswordAuthorityUnavailable(() =>
+ invitationPasswordRequest(session, sourceIp)
+ )
+
+ expect(denied.status).toBe(503)
+ expect(denied.body).toEqual({ error: 'authority_unavailable', retryAfterSeconds: 2 })
+ expect(denied.headers['retry-after']).toBe('2')
+ expect(denied.headers['set-cookie']).toBeUndefined()
+ expect(JSON.stringify(denied.body)).not.toMatch(
+ /authority_failure|password_verification_work|relation/i
+ )
+ expect(
+ (await db.pool.query('SELECT status FROM invitations WHERE id = $1', [session.invitationId]))
+ .rows[0].status
+ ).toBe('accepted')
+ expect(
+ (await db.pool.query('SELECT password_hash FROM users WHERE id = $1', [session.userId]))
+ .rows[0].password_hash
+ ).toBeNull()
+
+ const retried = await invitationPasswordRequest(session, sourceIp)
+ expect(retried.status).toBe(200)
+ expect(String(retried.headers['set-cookie'])).toContain('profile_session=')
+ })
+})