freshyo/apps/backend/tests/api/superadmin-auth.test.ts
2026-10-20 00:31:05 +05:30

164 lines
6.3 KiB
TypeScript

/**
* SAUTH-01..09 — `superadmin.auth` (catalogue §8.1).
*
* `login` is `publicProcedure`; `me` is `superadminProcedure`, which rejects
* anonymous, staff and user tokens. A superadmin token is not trusted on its
* claims alone: `createContext` re-reads the `superadmins` row by id, so a token
* for a removed id no longer resolves (SAUTH-09).
*/
import fs from 'node:fs'
import path from 'node:path'
import crypto from 'node:crypto'
import { apiClient, expectTrpcError, uniqueSuffix } from '../helpers/api'
import {
anonClient,
staffSession,
superadminClient,
superadminSession,
userSession,
} from '../helpers/sessions'
import { superadminCredentials } from '../helpers/env'
jest.setTimeout(180_000)
/* -------------------------------------------------------------------------- */
/* JWT helpers — the dev secret lives in wrangler.dev.toml */
/* -------------------------------------------------------------------------- */
function jwtSecret(): string {
const toml = fs.readFileSync(path.resolve(__dirname, '../../wrangler.dev.toml'), 'utf8')
const match = toml.match(/JWT_SECRET\s*=\s*"([^"]+)"/)
if (!match) throw new Error('[api-tests] JWT_SECRET not found in wrangler.dev.toml')
return match[1]
}
/** Sign an HS256 JWT with node:crypto (avoids loading jose's ESM build). */
function signToken(payload: Record<string, unknown>, secret: string, expiresAtEpoch: number): string {
const b64url = (value: Buffer | string) => Buffer.from(value).toString('base64url')
const header = b64url(JSON.stringify({ alg: 'HS256', typ: 'JWT' }))
const body = b64url(JSON.stringify({ ...payload, exp: expiresAtEpoch }))
const data = `${header}.${body}`
const signature = crypto.createHmac('sha256', secret).update(data).digest('base64url')
return `${data}.${signature}`
}
/** Decode (without verifying) a JWT payload. */
function decodeJwt(token: string): Record<string, unknown> {
const [, payload] = token.split('.')
return JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'))
}
describe('superadmin.auth.login (SAUTH-01..04)', () => {
it('SAUTH-01: valid username/password returns a token + superadmin id/username', async () => {
const { username, password } = superadminCredentials()
const res: any = await apiClient().superadmin.auth.login.mutate({ username, password })
expect(res.message).toEqual('Login successful')
expect(res.token).toEqual(expect.any(String))
expect(res.token.length).toBeGreaterThan(20)
expect(res.superadmin).toEqual(
expect.objectContaining({ id: expect.any(Number), username })
)
expect(res.superadmin.id).toBeGreaterThan(0)
})
it('SAUTH-02: an unknown username is 401 invalid credentials', async () => {
await expectTrpcError(
() =>
apiClient().superadmin.auth.login.mutate({
username: `nobody-${uniqueSuffix()}`,
password: 'whatever-password',
}),
'UNAUTHORIZED',
'invalid credentials'
)
})
it('SAUTH-03: a wrong password is 401 invalid credentials', async () => {
const { username } = superadminCredentials()
await expectTrpcError(
() => apiClient().superadmin.auth.login.mutate({ username, password: 'definitely-wrong' }),
'UNAUTHORIZED',
'invalid credentials'
)
})
it('SAUTH-04: empty username/password is 400 BAD_REQUEST', async () => {
await expectTrpcError(
() => apiClient().superadmin.auth.login.mutate({ username: '', password: '' }),
'BAD_REQUEST'
)
// Missing keys are rejected by the zod schema as well.
await expectTrpcError(
() => apiClient().superadmin.auth.login.mutate({ username: '' } as any),
'BAD_REQUEST'
)
await expectTrpcError(
() => apiClient().superadmin.auth.login.mutate({} as any),
'BAD_REQUEST'
)
})
})
describe('superadmin.auth.me (SAUTH-05..09)', () => {
it('SAUTH-05: me returns the superadmin identity', async () => {
const session = await superadminSession()
const me: any = await (await superadminClient()).superadmin.auth.me.query()
expect(me.superadmin).toEqual(
expect.objectContaining({ id: session.superadminId, username: session.username })
)
})
it('SAUTH-06: me without a token is 401', async () => {
await expectTrpcError(() => anonClient().superadmin.auth.me.query(), 'UNAUTHORIZED')
})
it('SAUTH-07: a staff or user token is 401 on me', async () => {
const staff = await staffSession()
const user = await userSession()
await expectTrpcError(() => apiClient(staff.token).superadmin.auth.me.query(), 'UNAUTHORIZED')
await expectTrpcError(() => apiClient(user.token).superadmin.auth.me.query(), 'UNAUTHORIZED')
})
it('SAUTH-08: the login token carries superadminId/identityType claims and resolves to that id', async () => {
const session = await superadminSession()
const claims = decodeJwt(session.token)
expect(claims.identityType).toBe('superadmin')
expect(Number(claims.superadminId)).toBe(session.superadminId)
expect(claims.username).toBe(session.username)
expect(Number(claims.exp)).toBeGreaterThan(Math.floor(Date.now() / 1000))
const me: any = await (await superadminClient()).superadmin.auth.me.query()
expect(me.superadmin.id).toBe(session.superadminId)
})
it('(current) SAUTH-09: a token for a removed superadmin id no longer resolves (401)', async () => {
// There is no superadmin suspension/removal API; the reachable contract is
// that identity is re-read from D1. A correctly-signed token whose
// superadminId does not exist resolves to no superadmin -> 401.
const missingId = 987_654_321
const future = Math.floor(Date.now() / 1000) + 3_600
const token = signToken(
{ identityType: 'superadmin', superadminId: missingId, username: 'ghost' },
jwtSecret(),
future
)
await expectTrpcError(() => apiClient(token).superadmin.auth.me.query(), 'UNAUTHORIZED')
// Positive control: the same signing routine with the seeded id resolves.
const session = await superadminSession()
const live = signToken(
{ identityType: 'superadmin', superadminId: session.superadminId, username: session.username },
jwtSecret(),
future
)
const me: any = await apiClient(live).superadmin.auth.me.query()
expect(me.superadmin.id).toBe(session.superadminId)
})
})