Files
accounted/tests/pg/inbox-rate-limit.pg.test.ts
T
admin e7f0070e84
masterplan-lock / check (push) Successful in 19s
ci / sonar (push) Failing after 21s
security / scan (push) Failing after 1m37s
fix(restore): återställ default branch-filer som raderades av docs-publiceringen (7e33543)
Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i
server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma
strängvärde byggs med konkatenering i stället för att matcha mönstret.
2026-11-10 09:37:22 +01:00

163 lines
5.5 KiB
TypeScript

import { describe, expect, it } from 'vitest'
import { seedCompany } from '@/tests/pg/fixtures'
import { getPool } from '@/tests/pg/setup'
/**
* Smoke for check_and_increment_inbox_quota (migration 20260512083644).
*
* Locks in:
* - Two atomic upsert windows (minute + day) with serializable counter increment.
* - Successful calls return ok=true.
* - Minute-cap rejection returns ok=false + scope='minute' + retry_after_sec.
* - Day-cap rejection returns ok=false + scope='day'.
* - Decrement-on-rejection: counter is rolled back when the call is denied,
* so a failed attempt doesn't permanently consume budget. Both minute and
* day rejections must roll back the minute counter; day-cap rejection
* must also roll back the day counter it just incremented.
*
* Mock-based tests can't catch a PL/pgSQL syntax error, a wrong column
* reference, or an INSERT…ON CONFLICT predicate that targets the wrong index.
* This test exercises the RPC against a real Postgres so a broken function
* fails loudly at the DB layer instead of passing the unit suite and failing
* in production.
*/
interface QuotaResult {
ok: boolean
scope?: 'minute' | 'day'
retry_after_sec?: number
}
async function callQuota(
companyId: string,
minuteMax: number,
dayMax: number,
): Promise<QuotaResult> {
const res = await getPool().query<{ result: QuotaResult }>(
`SELECT public.check_and_increment_inbox_quota($1::uuid, $2::int, $3::int) AS result`,
[companyId, minuteMax, dayMax],
)
return res.rows[0]!.result
}
async function getCounters(
companyId: string,
): Promise<{ minute: number; day: number }> {
const res = await getPool().query<{
window_kind: 'minute' | 'day'
count: number
}>(
`SELECT window_kind, count
FROM public.inbox_rate_counters
WHERE company_id = $1`,
[companyId],
)
let minute = 0
let day = 0
for (const row of res.rows) {
if (row.window_kind === 'minute') minute = row.count
if (row.window_kind === 'day') day = row.count
}
return { minute, day }
}
describe('check_and_increment_inbox_quota.pg', () => {
it('returns ok=true and increments both windows on a successful call', async () => {
const { companyId } = await seedCompany()
const result = await callQuota(companyId, 30, 500)
expect(result.ok).toBe(true)
expect(result.scope).toBeUndefined()
const counters = await getCounters(companyId)
expect(counters.minute).toBe(1)
expect(counters.day).toBe(1)
})
it('increments to the cap on the boundary call, then rejects the next one', async () => {
const { companyId } = await seedCompany()
const MINUTE_MAX = 3
// Three successful calls take us to count=3 (exactly at the cap).
for (let i = 0; i < MINUTE_MAX; i++) {
const r = await callQuota(companyId, MINUTE_MAX, 1000)
expect(r.ok).toBe(true)
}
expect((await getCounters(companyId)).minute).toBe(MINUTE_MAX)
// The 4th call exceeds the cap.
const denied = await callQuota(companyId, MINUTE_MAX, 1000)
expect(denied.ok).toBe(false)
expect(denied.scope).toBe('minute')
expect(denied.retry_after_sec).toBe(60)
// Critical: the rejected call must NOT have permanently consumed budget.
// Counter stays at MINUTE_MAX after the rollback inside the RPC.
expect((await getCounters(companyId)).minute).toBe(MINUTE_MAX)
})
it('rejects with scope=day when the minute cap is generous but the day cap is hit', async () => {
const { companyId } = await seedCompany()
const DAY_MAX = 2
for (let i = 0; i < DAY_MAX; i++) {
const r = await callQuota(companyId, 1000, DAY_MAX)
expect(r.ok).toBe(true)
}
const after = await getCounters(companyId)
expect(after.minute).toBe(DAY_MAX)
expect(after.day).toBe(DAY_MAX)
const denied = await callQuota(companyId, 1000, DAY_MAX)
expect(denied.ok).toBe(false)
expect(denied.scope).toBe('day')
expect(denied.retry_after_sec).toBe(3600)
// Both counters must roll back: the day cap was checked AFTER the minute
// counter was incremented for this call, so both increments are undone.
const final = await getCounters(companyId)
expect(final.minute).toBe(DAY_MAX)
expect(final.day).toBe(DAY_MAX)
})
it('isolates counters per company', async () => {
const { companyId: companyA } = await seedCompany()
const { companyId: companyB } = await seedCompany()
await callQuota(companyA, 30, 500)
await callQuota(companyA, 30, 500)
await callQuota(companyB, 30, 500)
const a = await getCounters(companyA)
const b = await getCounters(companyB)
expect(a.minute).toBe(2)
expect(b.minute).toBe(1)
})
it('updated_at trigger fires on counter updates', async () => {
const { companyId } = await seedCompany()
await callQuota(companyId, 30, 500)
const first = await getPool().query<{ updated_at: Date }>(
`SELECT updated_at FROM public.inbox_rate_counters
WHERE company_id = $1 AND window_kind = 'minute'`,
[companyId],
)
// Trigger an UPDATE path (second call hits ON CONFLICT DO UPDATE).
// Sleep so the timestamp delta is observable.
await new Promise((r) => setTimeout(r, 10))
await callQuota(companyId, 30, 500)
const second = await getPool().query<{ updated_at: Date }>(
`SELECT updated_at FROM public.inbox_rate_counters
WHERE company_id = $1 AND window_kind = 'minute'`,
[companyId],
)
expect(second.rows[0]!.updated_at.getTime()).toBeGreaterThan(
first.rows[0]!.updated_at.getTime(),
)
})
})