Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
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()
})
})