Å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.
177 lines
6.3 KiB
TypeScript
177 lines
6.3 KiB
TypeScript
import { describe, expect, it } from 'vitest'
|
|
import { getClient, getPool } from '@/tests/pg/setup'
|
|
import { insertAuthUser } from '@/tests/pg/fixtures'
|
|
|
|
// claim_email_change_request / release_email_change_request
|
|
// (20260903083000_email_change_request_claims.sql): the cross-instance gate
|
|
// in front of GoTrue's updateUser in POST /api/account/email. Exactly one
|
|
// caller per user, address and window may proceed; the rest must answer
|
|
// "already pending" without re-issuing confirmation tokens.
|
|
//
|
|
// withUserContext rolls its transaction back, which would hide the claim
|
|
// from the next call. These helpers commit instead, because the claim's
|
|
// whole point is what a SECOND transaction sees; the test users are fresh
|
|
// per test and their rows cascade away with them.
|
|
|
|
const WINDOW = 30 * 60
|
|
|
|
async function asUser<T>(
|
|
userId: string,
|
|
fn: (client: import('pg').PoolClient) => Promise<T>,
|
|
): Promise<T> {
|
|
const client = await getClient()
|
|
try {
|
|
await client.query('BEGIN')
|
|
await client.query(`SELECT set_config('request.jwt.claims', $1, true)`, [
|
|
JSON.stringify({ sub: userId, role: 'authenticated' }),
|
|
])
|
|
await client.query(`SELECT set_config('request.jwt.claim.sub', $1, true)`, [userId])
|
|
await client.query(`SET LOCAL ROLE authenticated`)
|
|
const result = await fn(client)
|
|
await client.query('COMMIT')
|
|
return result
|
|
} catch (err) {
|
|
await client.query('ROLLBACK').catch(() => {})
|
|
throw err
|
|
} finally {
|
|
client.release()
|
|
}
|
|
}
|
|
|
|
async function claim(userId: string, email: string, window = WINDOW): Promise<boolean> {
|
|
return asUser(userId, async (client) => {
|
|
const { rows } = await client.query<{ claim_email_change_request: boolean }>(
|
|
`SELECT public.claim_email_change_request($1, $2)`,
|
|
[email, window],
|
|
)
|
|
return rows[0]!.claim_email_change_request
|
|
})
|
|
}
|
|
|
|
async function release(userId: string): Promise<void> {
|
|
await asUser(userId, async (client) => {
|
|
await client.query(`SELECT public.release_email_change_request()`)
|
|
})
|
|
}
|
|
|
|
async function backdateClaim(userId: string, seconds: number): Promise<void> {
|
|
await getPool().query(
|
|
`UPDATE public.email_change_requests
|
|
SET claimed_at = now() - make_interval(secs => $2)
|
|
WHERE user_id = $1`,
|
|
[userId, seconds],
|
|
)
|
|
}
|
|
|
|
describe('claim_email_change_request', () => {
|
|
it('grants the first claim and refuses a repeat for the same address inside the window', async () => {
|
|
const userId = await insertAuthUser()
|
|
|
|
expect(await claim(userId, 'new@testbrand.example')).toBe(true)
|
|
expect(await claim(userId, 'new@testbrand.example')).toBe(false)
|
|
// Case and whitespace are not a different address.
|
|
expect(await claim(userId, ' New@Testbrand.example ')).toBe(false)
|
|
})
|
|
|
|
it('grants a claim for a different address while one is held', async () => {
|
|
const userId = await insertAuthUser()
|
|
|
|
expect(await claim(userId, 'first@testbrand.example')).toBe(true)
|
|
expect(await claim(userId, 'second@testbrand.example')).toBe(true)
|
|
// ... and the first address is now the "different" one again.
|
|
expect(await claim(userId, 'first@testbrand.example')).toBe(true)
|
|
})
|
|
|
|
it('grants a repeat once the held claim is older than the window', async () => {
|
|
const userId = await insertAuthUser()
|
|
|
|
expect(await claim(userId, 'new@testbrand.example')).toBe(true)
|
|
await backdateClaim(userId, WINDOW + 5)
|
|
expect(await claim(userId, 'new@testbrand.example')).toBe(true)
|
|
expect(await claim(userId, 'new@testbrand.example')).toBe(false)
|
|
})
|
|
|
|
it('lets exactly one of three concurrent claimers through', async () => {
|
|
const userId = await insertAuthUser()
|
|
|
|
const results = await Promise.all([
|
|
claim(userId, 'new@testbrand.example'),
|
|
claim(userId, 'new@testbrand.example'),
|
|
claim(userId, 'new@testbrand.example'),
|
|
])
|
|
|
|
expect(results.filter(Boolean)).toHaveLength(1)
|
|
})
|
|
|
|
it('keeps claims per user', async () => {
|
|
const a = await insertAuthUser()
|
|
const b = await insertAuthUser()
|
|
|
|
expect(await claim(a, 'shared@testbrand.example')).toBe(true)
|
|
expect(await claim(b, 'shared@testbrand.example')).toBe(true)
|
|
})
|
|
|
|
it('release drops the claim so the same address can be requested again', async () => {
|
|
const userId = await insertAuthUser()
|
|
|
|
expect(await claim(userId, 'new@testbrand.example')).toBe(true)
|
|
await release(userId)
|
|
expect(await claim(userId, 'new@testbrand.example')).toBe(true)
|
|
})
|
|
|
|
it('release only touches the caller', async () => {
|
|
const a = await insertAuthUser()
|
|
const b = await insertAuthUser()
|
|
|
|
expect(await claim(a, 'a@testbrand.example')).toBe(true)
|
|
expect(await claim(b, 'b@testbrand.example')).toBe(true)
|
|
await release(a)
|
|
expect(await claim(b, 'b@testbrand.example')).toBe(false)
|
|
})
|
|
|
|
it('rejects an empty address and a non-positive window', async () => {
|
|
const userId = await insertAuthUser()
|
|
|
|
await expect(claim(userId, ' ')).rejects.toThrow(/requires an address/)
|
|
await expect(claim(userId, 'new@testbrand.example', 0)).rejects.toThrow(
|
|
/positive window/,
|
|
)
|
|
})
|
|
|
|
it('refuses unauthenticated callers', async () => {
|
|
await expect(
|
|
getPool().query(`SELECT public.claim_email_change_request('x@testbrand.example', 60)`),
|
|
).rejects.toThrow(/authenticated user/)
|
|
await expect(
|
|
getPool().query(`SELECT public.release_email_change_request()`),
|
|
).rejects.toThrow(/authenticated user/)
|
|
})
|
|
|
|
it('is not readable or writable directly by an authenticated user', async () => {
|
|
const userId = await insertAuthUser()
|
|
expect(await claim(userId, 'new@testbrand.example')).toBe(true)
|
|
|
|
const visible = await asUser(userId, async (client) => {
|
|
const { rows } = await client.query(`SELECT * FROM public.email_change_requests`)
|
|
return rows.length
|
|
})
|
|
expect(visible).toBe(0)
|
|
|
|
await expect(
|
|
asUser(userId, async (client) => {
|
|
await client.query(`DELETE FROM public.email_change_requests`)
|
|
const { rows } = await client.query(
|
|
`SELECT count(*)::int AS n FROM public.email_change_requests`,
|
|
)
|
|
return rows[0]
|
|
}),
|
|
).resolves.toBeDefined()
|
|
// RLS with no policies: the DELETE above matched nothing.
|
|
const { rows } = await getPool().query<{ n: number }>(
|
|
`SELECT count(*)::int AS n FROM public.email_change_requests WHERE user_id = $1`,
|
|
[userId],
|
|
)
|
|
expect(rows[0]!.n).toBe(1)
|
|
})
|
|
})
|