Files
faunosteo/packages/supabase/tests/sandbox/sheets-concurrency.sandbox.ts
T
bchanot f5456f330d test(supabase): concurrency seeding accepts Storage's duplicate answer
After e2e:shell seeds the same content-addressed drawing, Storage answers HTTP 400 with statusCode 409 (KeyAlreadyExists); any other 400 still fails. Docs: M7 adds no new write path; a TOTP code replays more than once within its span.
2026-11-02 23:31:49 +01:00

307 lines
17 KiB
TypeScript

/**
* V1-2.1 two-session scenarios on the real stack (contract §15: two saves,
* save against submit, publish against withdraw, two publishers, deprecate
* against publish, completion against withdrawal), plus archive against
* approve (§6.7, audit M1), two deprecations of one sheet (§6.1), two working
* copies (§14.3) and revoke against grant (§5.7). Each case holds the lock the
* two calls compete for in a blocking session, makes both calls queue behind
* it in a known order (checked in pg_stat_activity), lets go, and asserts the
* outcome of that serial order; both orders are run where they differ. The
* worker of M6 does not exist yet: the verdict and the completion are written
* by a postgres session standing in for it (§12.2). Run through
* `pnpm db:sandbox test tests/sandbox/sheets-concurrency.sandbox.ts`.
*/
import { randomUUID } from 'node:crypto'
import { readFile } from 'node:fs/promises'
import { join } from 'node:path'
import { rpc, sql, stack } from './stack'
import type { SteppedAccount } from './mfa'
import {
approvedRound,
holder,
inOrder,
message,
ok,
openRound,
openRoundAcknowledged,
officialSheet,
session,
sessionHolds,
sessionWaits,
callsWait,
sheetDoc,
type Sheet,
} from './sheet-fixtures'
import { repoRoot } from '../db/harness'
const HISTORICAL = '503dc301-a8b1-50d4-9e44-0919b2fc2916'
let E: SteppedAccount
let E2: SteppedAccount
let V: SteppedAccount
beforeAll(async () => {
E = await holder('cc-editor', 'admin', ['sheet_editor', 'sheet_publisher'])
E2 = await holder('cc-editor2', 'admin', ['sheet_editor', 'sheet_publisher'])
V = await holder('cc-reviewer', null, ['sheet_reviewer'])
}, 120_000)
const lockVersion = (s: Sheet) => `select 1 from public.anatomical_sheet_versions where id = '${s.draft}' for update`
const lockSheet = (id: string) => `select 1 from public.anatomical_sheets where id = '${id}' for update`
const save = (who: SteppedAccount, s: Sheet, revision: number, text: string) => () =>
rpc('save_sheet_draft', { version_id: s.draft, expected_revision: revision, document: sheetDoc(s.asset, text), change_note: text }, who.aal2)
const submit = (who: SteppedAccount, s: Sheet, revision: number) => () =>
rpc('submit_sheet_review', { version_id: s.draft, expected_revision: revision, note: 'r' }, who.aal2)
const publish = (who: SteppedAccount, review: string) => () => rpc('publish_sheet_version', { review_id: review }, who.aal2)
const withdraw = (who: SteppedAccount, review: string) => () => rpc('withdraw_sheet_review', { review_id: review, note: 'w' }, who.aal2)
const deprecate = (who: SteppedAccount, version: string) => () =>
rpc('deprecate_sheet_version', { version_id: version, reason: 'c' }, who.aal2)
const roundStatus = (review: string) => sql(`select status from public.anatomical_sheet_reviews where id = '${review}'`)
const versionStatus = (version: string) => sql(`select status from public.anatomical_sheet_versions where id = '${version}'`)
const currentOf = (sheet: string) => sql(`select coalesce(current_version_id::text, 'none') from public.anatomical_sheets where id = '${sheet}'`)
/** A sheet with v1 published through a round and v2 drafted from it, approved (same digests: covered by the base). */
async function publishedThenApprovedDraft(): Promise<{ s: Sheet; v1: string; v2: Sheet; r2: string }> {
const s = await officialSheet(E)
ok(await publish(E, await approvedRound(E, V, s))())
const v2draft = ok(await rpc('create_sheet_draft', { sheet_id: s.id, from_version_id: null, change_note: 'v2' }, E.aal2)) as string
const v2 = { ...s, draft: v2draft }
ok(await save(E, v2, 0, 'v2')())
const r2 = ok(await submit(E, v2, 1)()) as string
await openRound(r2, v2)
ok(await rpc('decide_sheet_review', { review_id: r2, approve: true, note: 'ok' }, V.aal2))
return { s, v1: s.draft, v2, r2 }
}
describe('two saves (§6.2)', () => {
it('the first save in line wins, the second answers draft_conflict and overwrites nothing', async () => {
const s = await officialSheet(E)
const [a, b] = await inOrder(lockVersion(s), ['save_sheet_draft', save(E, s, 1, 'first')], ['save_sheet_draft', save(E2, s, 1, 'second')])
expect([a.status, message(b)]).toEqual([200, 'draft_conflict'])
expect(await sql(`select revision || ' ' || (content -> 'description' ->> 'fr') from public.anatomical_sheet_versions where id = '${s.draft}'`))
.toBe('2 first')
}, 60_000)
})
describe('save against submit (§6.1, §6.2)', () => {
it('save first: the submission of the old revision answers draft_conflict', async () => {
const s = await officialSheet(E)
const [a, b] = await inOrder(lockVersion(s), ['save_sheet_draft', save(E, s, 1, 'edit')], ['submit_sheet_review', submit(E2, s, 1)])
expect([a.status, message(b)]).toEqual([200, 'draft_conflict'])
expect(await sql(`select count(*) from public.anatomical_sheet_reviews where version_id = '${s.draft}'`)).toBe('0')
}, 60_000)
it('submit first: the save answers draft.frozen and the round keeps its revision', async () => {
const s = await officialSheet(E)
const [a, b] = await inOrder(lockVersion(s), ['submit_sheet_review', submit(E, s, 1)], ['save_sheet_draft', save(E2, s, 1, 'late')])
expect([a.status, message(b)]).toEqual([200, 'draft.frozen'])
expect(await sql(`select r.revision || ' ' || v.revision from public.anatomical_sheet_reviews r
join public.anatomical_sheet_versions v on v.id = r.version_id where r.id = '${a.body}'`)).toBe('1 1')
}, 60_000)
})
describe('publish against withdraw (§6.1, §6.8)', () => {
it('publish first: the round of the published version is never withdrawn', async () => {
const s = await officialSheet(E)
const r = await approvedRound(E, V, s)
const [a, b] = await inOrder(lockVersion(s), ['publish_sheet_version', publish(E, r)], ['withdraw_sheet_review', withdraw(E2, r)])
expect([a.status, message(b)]).toEqual([200, 'draft.not_a_draft'])
expect([await versionStatus(s.draft), await roundStatus(r)]).toEqual(['published', 'approved'])
}, 60_000)
it('withdraw first: the publication finds no approved round', async () => {
const s = await officialSheet(E)
const r = await approvedRound(E, V, s)
const [a, b] = await inOrder(lockVersion(s), ['withdraw_sheet_review', withdraw(E2, r)], ['publish_sheet_version', publish(E, r)])
expect([a.status, message(b)]).toEqual([200, 'publish.review.missing'])
expect([await versionStatus(s.draft), await roundStatus(r)]).toEqual(['draft', 'withdrawn'])
}, 60_000)
})
describe('two publishers (§6.8)', () => {
it('one publication only: the second publisher answers draft.not_a_draft', async () => {
const s = await officialSheet(E)
const r = await approvedRound(E, V, s)
const [a, b] = await inOrder(lockSheet(s.id), ['publish_sheet_version', publish(E, r)], ['publish_sheet_version', publish(E2, r)])
expect([a.status, message(b)]).toEqual([200, 'draft.not_a_draft'])
expect(await sql(`select published_by || ' ' || (select count(*) from audit.audit_logs
where action = 'anatomical_sheet_version.published' and resource_id = '${s.draft}')
from public.anatomical_sheet_versions where id = '${s.draft}'`)).toBe(`${E.id} 1`)
}, 60_000)
})
describe('deprecate against publish (§6.9)', () => {
it('deprecate first: the new version becomes current', async () => {
const { s, v1, v2, r2 } = await publishedThenApprovedDraft()
const [a, b] = await inOrder(lockSheet(s.id), ['deprecate_sheet_version', deprecate(E, v1)], ['publish_sheet_version', publish(E2, r2)])
expect([a.status, b.status]).toEqual([200, 200])
expect([await currentOf(s.id), await versionStatus(v1), await versionStatus(v2.draft)]).toEqual([v2.draft, 'deprecated', 'published'])
}, 120_000)
it('publish first: the deprecation of the old version keeps the new one current', async () => {
const { s, v1, v2, r2 } = await publishedThenApprovedDraft()
const [a, b] = await inOrder(lockSheet(s.id), ['publish_sheet_version', publish(E2, r2)], ['deprecate_sheet_version', deprecate(E, v1)])
expect([a.status, b.status]).toEqual([200, 200])
expect([await currentOf(s.id), await versionStatus(v1), await versionStatus(v2.draft)]).toEqual([v2.draft, 'deprecated', 'published'])
}, 120_000)
})
describe('two deprecations of one sheet (§6.1, §6.9)', () => {
it('serialised on the sheet: the current version never names a deprecated one', async () => {
const { s, v1, r2 } = await publishedThenApprovedDraft()
const v2 = (await sql(`select version_id from public.anatomical_sheet_reviews where id = '${r2}'`))
ok(await publish(E, r2)())
const [a, b] = await inOrder(lockSheet(s.id), ['deprecate_sheet_version', deprecate(E, v2)], ['deprecate_sheet_version', deprecate(E2, v1)])
expect([a.status, b.status]).toEqual([200, 200])
expect([await currentOf(s.id), await versionStatus(v1), await versionStatus(v2)]).toEqual(['none', 'deprecated', 'deprecated'])
}, 120_000)
})
describe('completion against withdrawal (§6.4, §6.5)', () => {
// The completion the worker will run (M6): lock the round while it is
// verifying, write the verdict and open it; a round no longer verifying is
// left alone. Returns 'updated' when it wrote.
const completion = (review: string, s: Sheet, pause: string) => `
select id from public.anatomical_sheet_reviews where id = '${review}' and status = 'verifying' for update;
${pause};
update public.anatomical_sheet_reviews set status = 'open', verified_at = now(), verified_with = 'stand-in',
verdict = '${JSON.stringify({ fingerprint: 'a'.repeat(64), drawings: [{ asset_id: s.asset, sha256: s.sha }], groups: [] })}'::jsonb
where id = '${review}' and status = 'verifying' returning 'updated'`
it('completion first: the withdrawal waits, then withdraws the opened round; the draft unfreezes', async () => {
const s = await officialSheet(E)
const r = ok(await submit(E, s, 1)()) as string
const tag = `sandbox-worker-${randomUUID().slice(0, 8)}`
const worker = session(tag, completion(r, s, 'select pg_sleep(2)'))
await sessionHolds(tag)
const w = withdraw(E2, r)()
await callsWait('withdraw_sheet_review')
expect(await worker).toContain('updated')
expect((await w).status).toBe(200)
expect([await roundStatus(r), await sql(`select verdict is not null from public.anatomical_sheet_reviews where id = '${r}'`)])
.toEqual(['withdrawn', 't'])
expect((await save(E, s, 1, 'after')()).status).toBe(200)
}, 60_000)
it('withdrawal first: the completion finds no verifying round and writes nothing', async () => {
const s = await officialSheet(E)
const r = ok(await submit(E, s, 1)()) as string
const blockerTag = `sandbox-blocker-${randomUUID().slice(0, 8)}`
const blocker = session(blockerTag, `select 1 from public.anatomical_sheet_reviews where id = '${r}' for update; select pg_sleep(3)`)
await sessionHolds(blockerTag)
const w = withdraw(E2, r)()
await callsWait('withdraw_sheet_review')
const tag = `sandbox-worker-${randomUUID().slice(0, 8)}`
const worker = session(tag, completion(r, s, 'select 1'))
await sessionWaits(tag)
await blocker
expect((await w).status).toBe(200)
expect(await worker).not.toContain('updated')
expect([await roundStatus(r), await sql(`select verdict is null from public.anatomical_sheet_reviews where id = '${r}'`)])
.toEqual(['withdrawn', 't'])
expect((await save(E, s, 1, 'after')()).status).toBe(200)
}, 60_000)
})
describe('archive against approve (§6.7, audit M1)', () => {
it('archive first: the approval answers sheet.inactive and the round stays open', async () => {
const s = await officialSheet(E)
const r = await openRoundAcknowledged(E, V, s)
const [a, b] = await inOrder(lockSheet(s.id),
['archive_anatomical_sheet', () => rpc('archive_anatomical_sheet', { sheet_id: s.id }, E.aal2)],
['decide_sheet_review', () => rpc('decide_sheet_review', { review_id: r, approve: true, note: 'ok' }, V.aal2)])
expect([a.status, message(b)]).toEqual([200, 'sheet.inactive'])
expect(await roundStatus(r)).toBe('open')
}, 60_000)
it('approve first: the approval happened on an active sheet, the archive follows', async () => {
const s = await officialSheet(E)
const r = await openRoundAcknowledged(E, V, s)
const [a, b] = await inOrder(lockSheet(s.id),
['decide_sheet_review', () => rpc('decide_sheet_review', { review_id: r, approve: true, note: 'ok' }, V.aal2)],
['archive_anatomical_sheet', () => rpc('archive_anatomical_sheet', { sheet_id: s.id }, E.aal2)])
expect([a.status, b.status]).toEqual([200, 200])
expect(await roundStatus(r)).toBe('approved')
}, 60_000)
})
describe('two working copies of the historical sheet (§14.3)', () => {
let setAside: string[] = []
const created: string[] = []
beforeAll(async () => {
// The historical drawing confirmed by the operator path, as on DEV (§9.5):
// the object written with the service key, the row confirmed by the
// service role. Done once per stack; a confirmed row is left as it is.
const row = (await sql(`select id || ' ' || sha256 || ' ' || (uploaded_at is null)::text from public.anatomical_sheet_assets
where sheet_id = '${HISTORICAL}'`)).split(' ')
if (row[2] === 'true') {
const bytes = await readFile(join(repoRoot, 'supabase/seed/anatomical-sheets/equine/draft/assets/horse.svg'))
const res = await fetch(`${stack.storageUrl}/object/anatomical-sheet-assets/${row[1]}.svg`, {
method: 'POST', headers: { Authorization: `Bearer ${stack.serviceKey}`, 'Content-Type': 'image/svg+xml' }, body: new Uint8Array(bytes),
})
// Storage reports an existing object as HTTP 400 with statusCode "409" in the body.
const body = await res.text()
const duplicate = res.status === 400 && (JSON.parse(body) as { statusCode?: string }).statusCode === '409'
expect(res.status === 200 || res.status === 409 || duplicate, `${res.status} ${body}`).toBe(true)
ok(await rpc('confirm_sheet_asset_upload', { asset_id: row[0] }, stack.serviceKey))
}
// A copy left active by an earlier run is set aside and put back after.
setAside = (await sql(`update public.anatomical_sheets set status = 'archived', archived_at = now()
where status = 'active' and private.is_historical_working_copy(id) returning id`))
.split('\n').filter(Boolean)
}, 60_000)
afterAll(async () => {
for (const id of created) await rpc('archive_anatomical_sheet', { sheet_id: id }, E.aal2)
if (setAside.length > 0)
await sql(`update public.anatomical_sheets set status = 'active', archived_at = null
where id in (${setAside.map((id) => `'${id}'`).join(', ')})`)
})
it('serialised on the historical sheet row: one copy, the other answers working_copy.exists', async () => {
const source = await sql(`select id from public.anatomical_sheet_versions where sheet_id = '${HISTORICAL}'`)
const copy = (who: SteppedAccount) => () =>
rpc('create_sheet_working_copy', { source_version_id: source, slug: `wc-${randomUUID().slice(0, 12)}` }, who.aal2)
const [a, b] = await inOrder(`select 1 from public.anatomical_sheets where id = '${HISTORICAL}' for no key update`,
['create_sheet_working_copy', copy(E)], ['create_sheet_working_copy', copy(E2)])
if (a.status === 200) created.push(a.body as string)
if (b.status === 200) created.push(b.body as string)
expect([a.status, message(b)]).toEqual([200, 'working_copy.exists'])
}, 60_000)
})
describe('revoke against grant of platform roles (§5.7, F18)', () => {
const lock = `select pg_advisory_xact_lock(hashtextextended('faunosteo.platform_roles', 0))`
let accounts: SteppedAccount[] = []
afterAll(async () => {
if (accounts.length > 0) await sql(`delete from auth.users where id in (${accounts.map((a) => `'${a.id}'`).join(', ')})`)
})
it('revoke first: the revoked owner can no longer grant', async () => {
const a = await holder('rg-a', 'owner', [])
const b = await holder('rg-b', 'owner', [])
const c = await holder('rg-c', null, [])
accounts = accounts.concat([a, b, c])
const [revoke, grant] = await inOrder(lock,
['revoke_platform_role', () => rpc('revoke_platform_role', { target_user_id: b.id, role: 'owner', reason: 'race' }, a.aal2)],
['grant_platform_role', () => rpc('grant_platform_role', { target_user_id: c.id, role: 'support' }, b.aal2)])
expect([revoke.status, grant.status, message(grant)]).toEqual([200, 403, 'forbidden'])
expect(await sql(`select count(*) from public.profile_roles where user_id = '${c.id}' and revoked_at is null`)).toBe('0')
}, 60_000)
it('grant first: the grant was made by an owner, then the revocation applies', async () => {
const a = await holder('rg-a', 'owner', [])
const b = await holder('rg-b', 'owner', [])
const c = await holder('rg-c', null, [])
accounts = accounts.concat([a, b, c])
const [grant, revoke] = await inOrder(lock,
['grant_platform_role', () => rpc('grant_platform_role', { target_user_id: c.id, role: 'support' }, b.aal2)],
['revoke_platform_role', () => rpc('revoke_platform_role', { target_user_id: b.id, role: 'owner', reason: 'race' }, a.aal2)])
expect([grant.status, revoke.status]).toEqual([200, 200])
expect(await sql(`select string_agg(role::text, ',') from public.profile_roles where user_id = '${c.id}' and revoked_at is null`))
.toBe('support')
}, 60_000)
})