Skip to content

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

TypeScript
12.3 KB
Raw Blame
import { beforeEach, describe, expect, it, vi } from 'vitest'
import express from 'express'
import request from 'supertest'
import { createAdminControlAdminsRouter } from '../src/routes/admin/controlAdmins.js'
import { GfsDesktopOperatorLinkError } from '../src/services/gfsDesktopOperatorLinkService.js'

const adminSvc = vi.hoisted(() => ({
  createControlAdminEmailChangeRequest: vi.fn(),
  createControlAdminInvitation: vi.fn(),
  deleteControlAdmin: vi.fn(),
  findAdminById: vi.fn(),
  getPendingControlAdminEmailChangeForAdmin: vi.fn(),
  isValidAdminEmail: vi.fn(() => true),
  isValidAdminUsername: vi.fn(() => true),
  listControlAdmins: vi.fn(),
  revokeControlAdminEmailChangeRequest: vi.fn(),
  revokeControlAdminInvitation: vi.fn(),
  updateAdminPassword: vi.fn(),
  updateAdminUsername: vi.fn(),
}))

const controlAdminInvitationRegistrationSvc = vi.hoisted(() => ({
  registerAndSendControlAdminEmailConfirmation: vi.fn(),
  registerAndSendControlAdminInvitation: vi.fn(),
}))

const operatorLinkSvc = vi.hoisted(() => ({
  getLinkForControlAdmin: vi.fn(),
  getActiveRowVersionForControlAdmin: vi.fn(),
  unlink: vi.fn(),
  reactivate: vi.fn(),
}))

const uiAuth = vi.hoisted(() => ({
  requireAuthForControlUI: vi.fn((req: any, _res: any, next: any) => {
    req.adminAuth = {
      sub: 'current-admin-id',
      role: 'admin',
      jti: 'j1',
      exp: 9999999999,
      typ: 'user',
    }
    next()
  }),
}))

vi.mock('../src/services/adminAuthService.js', () => adminSvc)
vi.mock('../src/services/gfsDesktopOperatorLinkService.js', () => ({
  GfsDesktopOperatorLinkError: class GfsDesktopOperatorLinkError extends Error {
    code: string
    constructor(code: string) {
      super(code)
      this.code = code
    }
  },
  gfsDesktopOperatorLinkService: operatorLinkSvc,
}))
vi.mock(
  '../src/services/controlAdminInvitationRegistrationService.js',
  () => controlAdminInvitationRegistrationSvc
)
vi.mock('../src/middleware/controlUIAuth.js', () => uiAuth)

const directorySvc = vi.hoisted(() => ({
  revokePendingInvitation: vi.fn(),
}))
vi.mock('../src/services/directory/index.js', async importOriginal => ({
  ...(await importOriginal<typeof import('../src/services/directory/index.js')>()),
  ...directorySvc,
}))

function storedInvitation(replaceInviter: boolean) {
  return {
    id: '11111111-1111-4111-8111-111111111111',
    email: '[email protected]',
    status: 'pending' as const,
    expiresAt: new Date('2026-09-28T10:00:00.000Z'),
    createdAt: new Date('2026-09-26T10:00:00.000Z'),
    acceptedAt: null,
    replaceInviter,
    invitedByAdminId: 'current-admin-id',
  }
}

function createTestApp() {
  const app = express()
  app.use(express.json())
  app.use((req: any, _res: any, next: any) => {
    req.adminAuth = {
      sub: 'current-admin-id',
      role: 'admin',
      jti: 'j1',
      exp: 9999999999,
      typ: 'user',
    }
    next()
  })
  app.use(createAdminControlAdminsRouter())
  return app
}

describe('routes/adminControlAdmins', () => {
  beforeEach(() => {
    Object.values(adminSvc).forEach(fn => fn.mockReset())
    Object.values(controlAdminInvitationRegistrationSvc).forEach(fn => fn.mockReset())
    Object.values(operatorLinkSvc).forEach(fn => fn.mockReset())
    Object.values(uiAuth).forEach(fn => fn.mockClear())
    Object.values(directorySvc).forEach(fn => fn.mockReset())
  })

  it('deletes another admin', async () => {
    adminSvc.deleteControlAdmin.mockResolvedValue({ deleted: true })

    const res = await request(createTestApp())
      .delete('/admin/control-admins/other-admin-id')
      .expect(200)

    expect(res.body).toEqual({ deleted: true })
    expect(adminSvc.deleteControlAdmin).toHaveBeenCalledWith('current-admin-id', 'other-admin-id')
  })

  it('rejects deleting the current admin', async () => {
    const res = await request(createTestApp())
      .delete('/admin/control-admins/current-admin-id')
      .expect(400)

    expect(res.body).toEqual({ error: 'cannot_delete_current_admin' })
    expect(adminSvc.deleteControlAdmin).not.toHaveBeenCalled()
  })

  it('returns 404 when the target admin does not exist', async () => {
    adminSvc.deleteControlAdmin.mockResolvedValue({ error: 'not_found' })

    const res = await request(createTestApp())
      .delete('/admin/control-admins/missing-admin-id')
      .expect(404)

    expect(res.body).toEqual({ error: 'not_found' })
  })

  it('revokes only the exact server-resolved Desktop GFS operator link', async () => {
    const targetAdminId = 'target-admin-id'
    const desktopUserId = 'desktop-user-id'
    adminSvc.findAdminById.mockResolvedValue({ id: targetAdminId })
    operatorLinkSvc.getLinkForControlAdmin.mockResolvedValue({
      desktopUserId,
      controlAdminId: targetAdminId,
      source: 'initial_setup',
      createdAt: new Date('2026-08-10T12:00:00.000Z'),
      state: 'active',
      rowVersion: 1,
      generation: 1,
    })
    operatorLinkSvc.unlink.mockResolvedValue({
      unlinked: true,
      link: {
        desktopUserId,
        controlAdminId: targetAdminId,
        source: 'initial_setup',
        createdAt: new Date('2026-08-10T12:00:00.000Z'),
      },
    })

    const res = await request(createTestApp())
      .delete(`/admin/control-admins/${targetAdminId}/gfs-operator-link`)
      .send({ desktopUserId: 'client-supplied-id', rowVersion: 1, reason: 'test-revoke' })
      .expect(200)

    expect(res.body).toEqual({
      revoked: true,
      gfsOperatorLinkStatus: 'revoked',
      controlAdminId: targetAdminId,
      desktopUserId,
      generation: 1,
      rowVersion: null,
    })
    expect(operatorLinkSvc.getLinkForControlAdmin).toHaveBeenCalledWith(targetAdminId)
    expect(operatorLinkSvc.unlink).toHaveBeenCalledWith({
      desktopUserId,
      controlAdminId: targetAdminId,
      operatorSub: 'current-admin-id',
      rowVersion: 1,
      reason: 'test-revoke',
    })
  })

  it('exposes the latest generation and tombstone version to the Control UI', async () => {
    operatorLinkSvc.getLinkForControlAdmin.mockResolvedValue({
      desktopUserId: 'desktop-user-id',
      controlAdminId: 'target-admin-id',
      source: 'initial_setup',
      createdAt: new Date('2026-08-10T12:00:00.000Z'),
      state: 'revoked',
      generation: 1,
      rowVersion: 2,
      revocationReason: 'control-ui-revoke',
    })

    const res = await request(createTestApp())
      .get('/admin/control-admins/target-admin-id/gfs-operator-link')
      .expect(200)

    expect(res.body).toEqual({
      gfsOperatorLinkStatus: 'revoked',
      controlAdminId: 'target-admin-id',
      desktopUserId: 'desktop-user-id',
      generation: 1,
      rowVersion: 2,
      revocationReason: 'control-ui-revoke',
    })
  })

  it('is idempotent when the target admin has no current Desktop GFS link', async () => {
    const targetAdminId = 'target-admin-id'
    adminSvc.findAdminById.mockResolvedValue({ id: targetAdminId })
    operatorLinkSvc.getLinkForControlAdmin.mockResolvedValue(null)

    const res = await request(createTestApp())
      .delete(`/admin/control-admins/${targetAdminId}/gfs-operator-link`)
      .expect(200)

    expect(res.body).toEqual({
      revoked: false,
      gfsOperatorLinkStatus: 'revoked',
      controlAdminId: targetAdminId,
      desktopUserId: null,
      generation: null,
      rowVersion: null,
    })
    expect(operatorLinkSvc.unlink).not.toHaveBeenCalled()
  })

  it('reactivates the server-resolved revoked generation with its row version', async () => {
    operatorLinkSvc.reactivate.mockResolvedValue({
      reactivated: true,
      link: {
        desktopUserId: 'desktop-user-id',
        controlAdminId: 'target-admin-id',
        source: 'initial_setup',
        createdAt: new Date('2026-08-10T12:00:00.000Z'),
        state: 'active',
        generation: 2,
        rowVersion: 1,
      },
    })

    const res = await request(createTestApp())
      .post('/admin/control-admins/target-admin-id/gfs-operator-link/reactivate')
      .send({ rowVersion: 2, reason: 'control-ui-reactivate' })
      .expect(200)

    expect(res.body).toEqual({
      reactivated: true,
      gfsOperatorLinkStatus: 'active',
      controlAdminId: 'target-admin-id',
      desktopUserId: 'desktop-user-id',
      generation: 2,
      rowVersion: 1,
    })
    expect(operatorLinkSvc.reactivate).toHaveBeenCalledWith({
      controlAdminId: 'target-admin-id',
      operatorSub: 'current-admin-id',
      rowVersion: 2,
      reason: 'control-ui-reactivate',
    })
  })

  it('maps a retired Desktop user reactivation refusal to a business conflict', async () => {
    operatorLinkSvc.reactivate.mockRejectedValue(
      new GfsDesktopOperatorLinkError('desktop_user_retired')
    )

    const res = await request(createTestApp())
      .post('/admin/control-admins/target-admin-id/gfs-operator-link/reactivate')
      .send({ rowVersion: 2, reason: 'control-ui-reactivate' })
      .expect(409)

    expect(res.body).toEqual({ error: 'desktop_user_retired' })
  })

  it('stores replaceInviter and echoes the stored flag on the 201 body', async () => {
    adminSvc.createControlAdminInvitation.mockResolvedValue({
      invitation: storedInvitation(true),
      desktopInvitation: {
        id: 'desktop-invitation-id',
        team_id: null,
        teams: [],
      },
    })
    controlAdminInvitationRegistrationSvc.registerAndSendControlAdminInvitation.mockResolvedValue(
      undefined
    )

    const res = await request(createTestApp())
      .post('/admin/control-admin-invitations')
      .send({ email: '[email protected]', createDesktopAccess: true, replaceInviter: true })
      .expect(201)

    expect(adminSvc.createControlAdminInvitation).toHaveBeenCalledWith(
      '[email protected]',
      'current-admin-id',
      { replaceInviter: true, desktopAccess: { teamAssignments: [] } }
    )
    expect(res.body).toEqual({
      invitation: {
        id: '11111111-1111-4111-8111-111111111111',
        email: '[email protected]',
        status: 'pending',
        expiresAt: '2026-09-28T10:00:00.000Z',
        createdAt: '2026-09-26T10:00:00.000Z',
        replaceInviter: true,
      },
    })
  })

  it('returns 409 without sending when invitation creation reports an inactive inviter', async () => {
    adminSvc.createControlAdminInvitation.mockResolvedValue({ error: 'inviter_not_active' })

    const res = await request(createTestApp())
      .post('/admin/control-admin-invitations')
      .send({ email: '[email protected]', createDesktopAccess: true })
      .expect(409)

    expect(res.body).toEqual({ error: 'inviter_not_active' })
    expect(adminSvc.createControlAdminInvitation).toHaveBeenCalledWith(
      '[email protected]',
      'current-admin-id',
      { replaceInviter: false, desktopAccess: { teamAssignments: [] } }
    )
    expect(
      controlAdminInvitationRegistrationSvc.registerAndSendControlAdminInvitation
    ).not.toHaveBeenCalled()
  })

  it('defaults replaceInviter to false when the body omits it', async () => {
    adminSvc.createControlAdminInvitation.mockResolvedValue(storedInvitation(false))
    controlAdminInvitationRegistrationSvc.registerAndSendControlAdminInvitation.mockResolvedValue(
      undefined
    )

    const res = await request(createTestApp())
      .post('/admin/control-admin-invitations')
      .send({ email: '[email protected]' })
      .expect(201)

    expect(adminSvc.createControlAdminInvitation).toHaveBeenCalledWith(
      '[email protected]',
      'current-admin-id',
      { replaceInviter: false }
    )
    expect(res.body.invitation.replaceInviter).toBe(false)
  })

  it('echoes what was stored, not what was requested', async () => {
    adminSvc.createControlAdminInvitation.mockResolvedValue(storedInvitation(false))
    controlAdminInvitationRegistrationSvc.registerAndSendControlAdminInvitation.mockResolvedValue(
      undefined
    )

    const res = await request(createTestApp())
      .post('/admin/control-admin-invitations')
      .send({ email: '[email protected]', replaceInviter: true })
      .expect(201)

    expect(res.body.invitation.replaceInviter).toBe(false)
  })

  it('rejects a non-boolean replaceInviter before creating anything', async () => {
    const res = await request(createTestApp())
      .post('/admin/control-admin-invitations')
      .send({ email: '[email protected]', replaceInviter: 'true' })
      .expect(400)

    expect(res.body).toEqual({ error: 'replaceInviter must be a boolean' })
    expect(adminSvc.createControlAdminInvitation).not.toHaveBeenCalled()
  })
})