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 { deriveOAuthEncryptionKey, encryptOAuthSecret } from '../src/oauth/encryption.js'
import {
GrokSubscriptionConnectionKeyConflictError,
GrokSubscriptionFingerprintConflictError,
GrokSubscriptionInvalidConnectionKeyError,
GrokSubscriptionStaleRevisionError,
assertGrokConnectionKey,
generateGrokConnectionKey,
getGrokSubscriptionConnectionIncludingRevoked,
getSafeGrokSubscriptionConnection,
insertInitialGrokSubscriptionConnection,
persistGrokRefreshCiphertextFirst,
readHostGrokConnectionRef,
revokeGrokSubscriptionConnection,
} from '../src/services/grokSubscriptionConnection.js'
const KEY = deriveOAuthEncryptionKey('ab'.repeat(32))
function queryMock() {
return vi.fn()
}
describe('grok subscription connection repository', () => {
const query = queryMock()
beforeEach(() => {
query.mockReset()
})
it('generates grok-<16 hex> keys and rejects reserved names', () => {
expect(generateGrokConnectionKey()).toMatch(/^grok-[0-9a-f]{16}$/)
expect(assertGrokConnectionKey('team-grok')).toBe('team-grok')
expect(() => assertGrokConnectionKey('unassigned')).toThrow(
GrokSubscriptionInvalidConnectionKeyError
)
expect(() => assertGrokConnectionKey('deployment-default')).toThrow(
GrokSubscriptionInvalidConnectionKeyError
)
expect(() => assertGrokConnectionKey('')).toThrow(GrokSubscriptionInvalidConnectionKeyError)
})
it('maps empty Host connectionRef to unassigned, never deployment-default', () => {
expect(readHostGrokConnectionRef(undefined)).toBe('unassigned')
expect(readHostGrokConnectionRef('')).toBe('unassigned')
expect(readHostGrokConnectionRef(' ')).toBe('unassigned')
expect(readHostGrokConnectionRef('team-grok')).toBe('team-grok')
})
it('returns safe metadata without ciphertext or token fields', async () => {
const ciphertext = encryptOAuthSecret(KEY, 'refresh-secret')
query.mockResolvedValueOnce({
rows: [
{
id: '11111111-1111-1111-1111-111111111111',
connection_key: 'team-grok',
display_name: 'Team Grok',
created_by: null,
status: 'connected',
refresh_token_encrypted: ciphertext,
access_token_encrypted: encryptOAuthSecret(KEY, 'access-secret'),
access_token_expires_at: new Date('2026-09-16T12:00:00.000Z'),
credential_revision: '3',
catalog_revision: '1',
account_fingerprint: 'fp_abc',
catalog_status: 'ready',
catalog_synced_at: new Date('2026-09-16T11:00:00.000Z'),
last_refresh_at: new Date('2026-09-16T11:30:00.000Z'),
last_auth_at: new Date('2026-09-16T10:00:00.000Z'),
refresh_lock_token: 'lock',
refresh_lock_expires_at: new Date('2026-09-16T12:00:00.000Z'),
revoked_at: null,
created_at: new Date('2026-09-16T09:00:00.000Z'),
updated_at: new Date('2026-09-16T11:30:00.000Z'),
},
],
rowCount: 1,
})
const metadata = await getSafeGrokSubscriptionConnection({ query }, 'team-grok')
expect(metadata).toMatchObject({
connectionKey: 'team-grok',
status: 'connected',
credentialRevision: 3,
catalogRevision: 1,
accountFingerprint: 'fp_abc',
catalogStatus: 'ready',
})
const serialized = JSON.stringify(metadata)
expect(serialized).not.toContain(ciphertext)
expect(serialized).not.toContain('refresh-secret')
expect(serialized).not.toContain('access-secret')
expect(metadata).not.toHaveProperty('refreshToken')
expect(metadata).not.toHaveProperty('accessToken')
expect(String(query.mock.calls[0]?.[0])).not.toContain('chatgpt')
})
it('inserts encrypted credentials without ChatGPT columns', async () => {
query.mockResolvedValueOnce({
rows: [
{
id: '11111111-1111-1111-1111-111111111111',
connection_key: 'team-grok',
display_name: 'team-grok',
created_by: null,
status: 'connected',
credential_revision: '1',
catalog_revision: '0',
account_fingerprint: 'fp_new',
catalog_status: 'never_synced',
catalog_synced_at: null,
last_refresh_at: null,
last_auth_at: new Date(),
refresh_lock_token: null,
refresh_lock_expires_at: null,
revoked_at: null,
created_at: new Date(),
updated_at: new Date(),
},
],
rowCount: 1,
})
const metadata = await insertInitialGrokSubscriptionConnection(
{ query },
KEY,
{
refreshToken: 'plain-refresh',
accessToken: 'plain-access',
accountFingerprint: 'fp_new',
},
'team-grok'
)
expect(metadata.connectionKey).toBe('team-grok')
const sql = String(query.mock.calls[0]?.[0])
expect(sql).not.toContain('chatgpt')
const [, params] = query.mock.calls[0] as [string, unknown[]]
expect(params).not.toContain('plain-refresh')
expect(params).not.toContain('plain-access')
expect(String(params[3])).toMatch(/^v1\./)
})
it('maps a unique active fingerprint violation to fingerprint_in_use', async () => {
query.mockRejectedValueOnce(
Object.assign(new Error('duplicate'), {
code: '23505',
constraint: 'grok_subscription_connections_active_fingerprint',
})
)
await expect(
insertInitialGrokSubscriptionConnection(
{ query },
KEY,
{ refreshToken: 'plain-refresh', accountFingerprint: 'fp_dup' },
'team-grok'
)
).rejects.toBeInstanceOf(GrokSubscriptionFingerprintConflictError)
})
it.each(['grok_subscription_connections_active_key', 'grok_subscription_connections_key_unique'])(
'maps a %s unique violation to a connection key conflict',
async constraint => {
query.mockRejectedValueOnce(
Object.assign(new Error('duplicate'), { code: '23505', constraint })
)
await expect(
insertInitialGrokSubscriptionConnection(
{ query },
KEY,
{ refreshToken: 'plain-refresh', accountFingerprint: 'fp_race' },
'team-grok'
)
).rejects.toBeInstanceOf(GrokSubscriptionConnectionKeyConflictError)
}
)
it('reads revoked tombstones through the lifecycle lookup', async () => {
query.mockResolvedValueOnce({ rows: [], rowCount: 0 })
await expect(
getGrokSubscriptionConnectionIncludingRevoked({ query }, 'team-grok')
).resolves.toBe(null)
const sql = String(query.mock.calls[0]?.[0])
expect(sql).toContain('connection_key = $1')
expect(sql).not.toContain('revoked_at IS NULL')
})
it('revokes the grant and cancels pending OAuth states for the key atomically', async () => {
query.mockResolvedValueOnce({ rows: [], rowCount: 0 })
query.mockResolvedValueOnce({ rows: [], rowCount: 0 })
await revokeGrokSubscriptionConnection({ query }, 'team-grok')
const sql = String(query.mock.calls[0]?.[0])
expect(sql).toContain('UPDATE grok_subscription_oauth_states')
expect(sql).toContain("status = 'cancelled'")
expect(sql).toContain("status = 'pending'")
expect(sql).toContain('UPDATE grok_subscription_connections')
expect(sql).toContain('UPDATE grok_catalog_models')
expect(query.mock.calls[0]?.[1]).toEqual(['team-grok'])
})
it('fences persist-first refresh on lock token, revision, and live lease', async () => {
query.mockResolvedValueOnce({ rows: [], rowCount: 0 })
await expect(
persistGrokRefreshCiphertextFirst({ query }, KEY, {
connectionKey: 'team-grok',
expectedRevision: 4,
lockToken: 'lease-1',
refreshToken: 'rotated-refresh',
})
).rejects.toBeInstanceOf(GrokSubscriptionStaleRevisionError)
const sql = String(query.mock.calls[0]?.[0])
expect(sql).toContain('refresh_lock_token = $4')
expect(sql).toContain('credential_revision = $3')
expect(sql).toContain('refresh_lock_expires_at > now()')
expect(sql).not.toContain('credential_revision + 1')
const [, params] = query.mock.calls[0] as [string, unknown[]]
expect(params).not.toContain('rotated-refresh')
})
})