-- Files foundation: buckets, assets, avatar policies through assets, the -- browser and worker RPCs, the purge queue. Every allowed path has its denial -- twin; the eight scenarios of the Step 8 brief are named in the descriptions. begin; select plan(140); insert into auth.users (id, email) values ('40000000-0000-0000-0000-00000000000a', 'alice-files@test.local'), ('40000000-0000-0000-0000-00000000000b', 'bob-files@test.local'), ('40000000-0000-0000-0000-00000000000c', 'carol-files@test.local'); create table pg_temp.ids (key text primary key, id uuid not null); create function pg_temp.id(p_key text) returns uuid language sql stable as $$ select id from pg_temp.ids where key = p_key $$; create function pg_temp.row(p_key text) returns public.assets language sql stable security definer as $$ select a from public.assets a where a.id = pg_temp.id(p_key) $$; grant all on pg_temp.ids to anon, authenticated, service_role; grant execute on function pg_temp.id(text) to anon, authenticated, service_role; grant execute on function pg_temp.row(text) to anon, authenticated, service_role; -- --------------------------------------------------------------------------- -- 1. Buckets and the policy census -- --------------------------------------------------------------------------- select is( (select count(*) from storage.buckets where id in ('avatars', 'logos', 'professional-documents', 'client-files', 'animal-files', 'report-files', 'anatomical-sheet-assets', 'imports')), 8::bigint, 'the eight buckets exist' ); select is( (select count(*) from storage.buckets where public and id in ('avatars', 'logos', 'professional-documents', 'client-files', 'animal-files', 'report-files', 'anatomical-sheet-assets', 'imports')), 0::bigint, 'every bucket is private' ); select is((select file_size_limit from storage.buckets where id = 'avatars'), 5242880::bigint, 'avatars capped at 5 MiB'); select is( (select allowed_mime_types from storage.buckets where id = 'avatars'), array['image/jpeg', 'image/png', 'image/webp'], 'avatars accepts jpeg, png, webp only (never SVG)' ); select is( (select count(*) from pg_policies where schemaname = 'storage' and tablename = 'objects' and (select count(*) from regexp_matches(coalesce(qual, '') || coalesce(with_check, ''), 'bucket_id = ''[a-z-]+''', 'g')) <> 1), 0::bigint, 'census: every storage.objects policy pins exactly one bucket literal' ); select is( (select count(*) from pg_policies where schemaname = 'storage' and tablename = 'objects' and (coalesce(qual, '') || coalesce(with_check, '')) like '%bucket_id = ''avatars''%'), 2::bigint, 'census: two policies name avatars' ); select is( (select count(*) from pg_policies where schemaname = 'storage' and tablename = 'objects' and (coalesce(qual, '') || coalesce(with_check, '')) like '%bucket_id = ''anatomical-sheet-assets''%'), 1::bigint, 'census: one policy names anatomical-sheet-assets' ); select is( (select count(*) from pg_policies where schemaname = 'storage' and tablename = 'objects'), 3::bigint, 'census: three policies in total, so the six closed buckets have none' ); select is( (select count(*) from pg_policies where schemaname = 'storage' and tablename = 'objects' and cmd in ('UPDATE', 'DELETE')), 0::bigint, 'no UPDATE / DELETE policy exists on storage.objects for any API role' ); -- --------------------------------------------------------------------------- -- 2. Schema and privileges of assets -- --------------------------------------------------------------------------- select has_table('public', 'assets', 'table public.assets exists'); select ok((select relrowsecurity from pg_class where oid = 'public.assets'::regclass), 'RLS enabled on assets'); select enum_has_labels('public', 'asset_status', array['pending_upload', 'uploaded', 'clean', 'rejected', 'deleted'], 'asset_status labels'); select ok(not has_table_privilege('anon', 'public.assets', 'select'), 'anon cannot select assets'); select ok(not has_table_privilege('authenticated', 'public.assets', 'insert'), 'authenticated cannot insert assets'); select ok(not has_table_privilege('authenticated', 'public.assets', 'update'), 'authenticated cannot update assets'); select ok(not has_table_privilege('authenticated', 'public.assets', 'delete'), 'authenticated cannot delete assets'); select ok(has_column_privilege('authenticated', 'public.assets', 'status', 'select'), 'authenticated reads status'); select ok(not has_column_privilege('authenticated', 'public.assets', 'lock_token', 'select'), 'lock_token stays server-side'); select ok(not has_column_privilege('authenticated', 'public.assets', 'quarantine_key', 'select'), 'quarantine_key stays server-side'); select ok(not has_function_privilege('authenticated', 'public.claim_avatar_jobs(integer)', 'execute'), 'authenticated cannot claim jobs'); select ok(not has_function_privilege('authenticated', 'public.complete_avatar_job(uuid, uuid, integer, text)', 'execute'), 'authenticated cannot complete a job'); select ok(not has_function_privilege('authenticated', 'public.claim_purges(integer)', 'execute'), 'authenticated cannot claim purges'); select ok(not has_function_privilege('anon', 'public.begin_avatar_upload(text, integer)', 'execute'), 'anon cannot begin an upload'); select is(private.storage_ceiling(), 10737418240::bigint, 'storage ceiling is 10 GiB'); -- --------------------------------------------------------------------------- -- 3. Alice begins an upload -- --------------------------------------------------------------------------- set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000a","role":"authenticated"}', true); select throws_ok($$ select public.begin_avatar_upload('image/gif', 1000) $$, 'P0001', 'unsupported_type', 'a GIF is refused at begin'); select throws_ok($$ select public.begin_avatar_upload('image/svg+xml', 1000) $$, 'P0001', 'unsupported_type', 'an SVG is refused at begin'); select throws_ok($$ select public.begin_avatar_upload('image/jpeg', 5242881) $$, 'P0001', 'too_large', 'over 5 MiB is refused at begin'); select throws_ok($$ select public.begin_avatar_upload('image/jpeg', 0) $$, 'P0001', 'too_large', 'an empty file is refused at begin'); insert into pg_temp.ids select 'a1', (public.begin_avatar_upload('image/jpeg', 1000) ->> 'asset_id')::uuid; select is((pg_temp.row('a1')).status, 'pending_upload', 'a1 is pending_upload'); select is((pg_temp.row('a1')).object_key, 'profiles/40000000-0000-0000-0000-00000000000a/' || pg_temp.id('a1') || '/avatar.webp', 'final key built from uuids'); select is((pg_temp.row('a1')).quarantine_key, 'quarantine/40000000-0000-0000-0000-00000000000a/' || pg_temp.id('a1') || '/upload', 'quarantine key built from uuids'); select results_eq( $$ select id, status::text, object_key from public.assets order by created_at $$, $$ select pg_temp.id('a1'), 'pending_upload'::text, (pg_temp.row('a1')).object_key $$, 'alice reads her own row through RLS' ); select throws_ok($$ select lock_token from public.assets $$, '42501', null, 'alice cannot read the lease column'); -- --------------------------------------------------------------------------- -- 4. Upload policy: only the own quarantine key of a pending row -- --------------------------------------------------------------------------- select throws_ok( $$ insert into storage.objects (bucket_id, name, metadata) values ('avatars', (pg_temp.row('a1')).object_key, '{"size":1000}') $$, '42501', null, 'scenario: the final key cannot be written by the browser' ); select throws_ok( $$ insert into storage.objects (bucket_id, name, metadata) values ('avatars', 'quarantine/40000000-0000-0000-0000-00000000000a/00000000-0000-0000-0000-000000000000/upload', '{"size":1000}') $$, '42501', null, 'an unknown quarantine key is refused' ); select throws_ok( $$ insert into storage.objects (bucket_id, name, metadata) values ('logos', 'anything', '{"size":1000}') $$, '42501', null, 'a closed bucket refuses every upload' ); select throws_ok($$ select public.confirm_asset_upload(pg_temp.id('a1')) $$, 'P0001', 'upload_missing', 'confirm before the bytes landed is refused'); -- Bob at Alice's key select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000b","role":"authenticated"}', true); select throws_ok( $$ insert into storage.objects (bucket_id, name, metadata) values ('avatars', (pg_temp.row('a1')).quarantine_key, '{"size":1000}') $$, '42501', null, 'scenario: Bob cannot upload at Alice''s quarantine key' ); select throws_ok($$ select public.confirm_asset_upload(pg_temp.id('a1')) $$, 'P0001', 'not_found', 'Bob cannot confirm Alice''s row'); select is((select count(*) from public.assets), 0::bigint, 'Bob sees none of Alice''s rows'); -- Alice uploads and confirms select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000a","role":"authenticated"}', true); select lives_ok( $$ insert into storage.objects (bucket_id, name, metadata) values ('avatars', (pg_temp.row('a1')).quarantine_key, '{"size":1000}') $$, 'Alice uploads at her quarantine key' ); select is((select count(*) from storage.objects where bucket_id = 'avatars'), 0::bigint, 'scenario: a quarantine object is never readable, not even by its uploader'); select lives_ok($$ select public.confirm_asset_upload(pg_temp.id('a1')) $$, 'Alice confirms'); select is((pg_temp.row('a1')).status, 'uploaded', 'a1 is uploaded'); select throws_ok($$ select public.confirm_asset_upload(pg_temp.id('a1')) $$, 'P0001', 'invalid_state', 'confirming twice is refused'); select throws_ok( $$ insert into storage.objects (bucket_id, name, metadata) values ('avatars', (pg_temp.row('a1')).quarantine_key, '{"size":1000}') $$, '42501', null, 'once uploaded, the quarantine key accepts no second upload' ); select is((select count(*) from storage.objects where bucket_id = 'avatars'), 0::bigint, 'nothing readable while uploaded'); select throws_ok($$ select * from public.claim_avatar_jobs(1) $$, '42501', null, 'the browser cannot claim jobs'); -- --------------------------------------------------------------------------- -- 5. The worker claims, the parent writes the clean object, completes -- --------------------------------------------------------------------------- set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); insert into pg_temp.ids select 'tok1', lock_token from public.claim_avatar_jobs(1); select is((select count(*) from public.claim_avatar_jobs(1)), 0::bigint, 'a live lease is skipped by the next claim'); select is((pg_temp.row('a1')).attempts, 1::smallint, 'claim counts one attempt'); select throws_ok( $$ select public.complete_avatar_job(pg_temp.id('a1'), gen_random_uuid(), 30000, repeat('a', 64)) $$, 'P0001', 'invalid_state', 'scenario: a complete with a foreign lease token is refused' ); select throws_ok( $$ select public.complete_avatar_job(pg_temp.id('a1'), pg_temp.id('tok1'), 30000, 'nope') $$, 'P0001', 'invalid_output', 'a malformed sha256 is refused' ); select throws_ok( $$ select public.complete_avatar_job(pg_temp.id('a1'), pg_temp.id('tok1'), 600000, repeat('a', 64)) $$, 'P0001', 'invalid_output', 'an output over 512 KiB is refused' ); reset role; insert into storage.objects (bucket_id, name, metadata) values ('avatars', (pg_temp.row('a1')).object_key, '{"size":30000}'); set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); select lives_ok($$ select public.complete_avatar_job(pg_temp.id('a1'), pg_temp.id('tok1'), 30000, repeat('a', 64)) $$, 'worker completes a1'); select is((pg_temp.row('a1')).status, 'clean', 'a1 is clean'); select is((pg_temp.row('a1')).byte_size, 30000, 'byte_size recorded'); select is((pg_temp.row('a1')).lock_token, null, 'lease cleared on complete'); select throws_ok( $$ select public.complete_avatar_job(pg_temp.id('a1'), pg_temp.id('tok1'), 30000, repeat('a', 64)) $$, 'P0001', 'invalid_state', 'a clean row cannot be completed again' ); select lives_ok($$ select public.mark_quarantine_purged(pg_temp.id('a1')) $$, 'worker marks the quarantine purged'); select is((pg_temp.row('a1')).quarantine_key, null, 'quarantine_key cleared'); reset role; select is((select count(*) from private.object_purge_queue where object_name = (pg_temp.row('a1')).object_key), 0::bigint, 'a clean row''s object_key never enters the purge queue'); -- --------------------------------------------------------------------------- -- 6. Read policy: the owner reads exactly the clean object -- --------------------------------------------------------------------------- set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000a","role":"authenticated"}', true); select results_eq( $$ select name from storage.objects where bucket_id = 'avatars' $$, $$ select (pg_temp.row('a1')).object_key $$, 'Alice reads her clean avatar object and nothing else (the quarantine object still exists)' ); select ok( not private.can_read_avatar_object('40000000-0000-0000-0000-00000000000a', (pg_temp.row('a1')).object_key || '/') and not private.can_read_avatar_object('40000000-0000-0000-0000-00000000000a', upper((pg_temp.row('a1')).object_key)) and not private.can_read_avatar_object('40000000-0000-0000-0000-00000000000a', 'quarantine/40000000-0000-0000-0000-00000000000a/' || pg_temp.id('a1') || '/upload'), 'name variants and the quarantine key never match the read predicate' ); select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000b","role":"authenticated"}', true); select is((select count(*) from storage.objects where bucket_id = 'avatars'), 0::bigint, 'scenario: Bob reads none of Alice''s objects'); select is((select count(*) from public.assets), 0::bigint, 'Bob reads none of Alice''s rows'); select is(public.remove_avatar(), 0, 'scenario: Bob''s remove_avatar touches nothing of Alice'); select is((pg_temp.row('a1')).status, 'clean', 'Alice''s avatar survives Bob''s removal call'); set local role anon; select set_config('request.jwt.claims', '', true); select is((select count(*) from storage.objects where bucket_id = 'avatars'), 0::bigint, 'scenario: anon reads no private object'); select throws_ok($$ select public.begin_avatar_upload('image/jpeg', 1000) $$, '42501', null, 'anon cannot begin an upload'); select throws_ok($$ select public.remove_avatar() $$, '42501', null, 'anon cannot remove an avatar'); reset role; -- --------------------------------------------------------------------------- -- 7. Replacement: a2 clean → a1 deleted and enqueued with the 48 h grace -- --------------------------------------------------------------------------- set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000a","role":"authenticated"}', true); insert into pg_temp.ids select 'a2', (public.begin_avatar_upload('image/png', 2000) ->> 'asset_id')::uuid; insert into storage.objects (bucket_id, name, metadata) values ('avatars', (pg_temp.row('a2')).quarantine_key, '{"size":2000}'); select public.confirm_asset_upload(pg_temp.id('a2')); set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); insert into pg_temp.ids select 'tok2', lock_token from public.claim_avatar_jobs(1); reset role; insert into storage.objects (bucket_id, name, metadata) values ('avatars', (pg_temp.row('a2')).object_key, '{"size":31000}'); set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); select lives_ok($$ select public.complete_avatar_job(pg_temp.id('a2'), pg_temp.id('tok2'), 31000, repeat('b', 64)) $$, 'worker completes a2'); select is((pg_temp.row('a2')).status, 'clean', 'a2 is clean'); select is((pg_temp.row('a1')).status, 'deleted', 'the previous clean avatar is deleted in the same transaction'); select is((select count(*) from public.claim_purges(100)), 0::bigint, 'nothing is due before its grace elapsed'); reset role; select is( (select count(*) from private.object_purge_queue where object_name = (pg_temp.row('a1')).object_key and not_before > now() + interval '47 hours'), 1::bigint, 'the replaced object is enqueued with the 48 h grace (backup invariant)' ); set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000a","role":"authenticated"}', true); select results_eq( $$ select name from storage.objects where bucket_id = 'avatars' $$, $$ select (pg_temp.row('a2')).object_key $$, 'scenario: a replaced object is no longer readable although it still exists' ); reset role; -- --------------------------------------------------------------------------- -- 8. Supersede race: a claimed job whose row was superseded cannot complete -- --------------------------------------------------------------------------- set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000a","role":"authenticated"}', true); insert into pg_temp.ids select 'a3', (public.begin_avatar_upload('image/jpeg', 3000) ->> 'asset_id')::uuid; insert into storage.objects (bucket_id, name, metadata) values ('avatars', (pg_temp.row('a3')).quarantine_key, '{"size":3000}'); select public.confirm_asset_upload(pg_temp.id('a3')); set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); insert into pg_temp.ids select 'tok3', lock_token from public.claim_avatar_jobs(1); reset role; set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000a","role":"authenticated"}', true); insert into pg_temp.ids select 'a4', (public.begin_avatar_upload('image/jpeg', 4000) ->> 'asset_id')::uuid; select is((pg_temp.row('a3')).status, 'deleted', 'a new pick supersedes the in-flight row'); reset role; set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); select throws_ok( $$ select public.complete_avatar_job(pg_temp.id('a3'), pg_temp.id('tok3'), 30000, repeat('c', 64)) $$, 'P0001', 'invalid_state', 'scenario: an old task cannot complete a superseded row' ); select throws_ok( $$ select public.reject_avatar_job(pg_temp.id('a3'), pg_temp.id('tok3'), 'decode_failed') $$, 'P0001', 'invalid_state', 'nor reject it' ); select is((pg_temp.row('a2')).status, 'clean', 'the current avatar is untouched by the stale task'); reset role; select is( (select count(*) from private.object_purge_queue where object_name = (pg_temp.row('a3')).quarantine_key and not_before < now() + interval '2 hours'), 1::bigint, 'the superseded quarantine key is enqueued with the 1 h grace' ); -- --------------------------------------------------------------------------- -- 9. Stale lease: an expired lease is re-claimed, the old token is refused -- --------------------------------------------------------------------------- set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000a","role":"authenticated"}', true); insert into storage.objects (bucket_id, name, metadata) values ('avatars', (pg_temp.row('a4')).quarantine_key, '{"size":4000}'); select public.confirm_asset_upload(pg_temp.id('a4')); reset role; set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); insert into pg_temp.ids select 'tok4a', lock_token from public.claim_avatar_jobs(1); reset role; update public.assets set locked_at = now() - interval '11 minutes' where id = pg_temp.id('a4'); set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); insert into pg_temp.ids select 'tok4b', lock_token from public.claim_avatar_jobs(1); select is((pg_temp.row('a4')).attempts, 2::smallint, 'an expired lease is re-claimed (second attempt)'); select throws_ok( $$ select public.complete_avatar_job(pg_temp.id('a4'), pg_temp.id('tok4a'), 30000, repeat('d', 64)) $$, 'P0001', 'invalid_state', 'scenario: the worker whose lease expired cannot overwrite with its stale token' ); reset role; insert into storage.objects (bucket_id, name, metadata) values ('avatars', (pg_temp.row('a4')).object_key, '{"size":32000}'); set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); select lives_ok($$ select public.complete_avatar_job(pg_temp.id('a4'), pg_temp.id('tok4b'), 32000, repeat('d', 64)) $$, 'the current lease holder completes'); select is((pg_temp.row('a4')).status, 'clean', 'a4 is clean'); select is((pg_temp.row('a2')).status, 'deleted', 'a2 replaced'); reset role; -- --------------------------------------------------------------------------- -- 10. Removal: clean and in-flight rows go, a later complete is refused -- --------------------------------------------------------------------------- set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000a","role":"authenticated"}', true); insert into pg_temp.ids select 'a5', (public.begin_avatar_upload('image/webp', 5000) ->> 'asset_id')::uuid; insert into storage.objects (bucket_id, name, metadata) values ('avatars', (pg_temp.row('a5')).quarantine_key, '{"size":5000}'); select public.confirm_asset_upload(pg_temp.id('a5')); reset role; set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); insert into pg_temp.ids select 'tok5', lock_token from public.claim_avatar_jobs(1); reset role; set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000a","role":"authenticated"}', true); select is(public.remove_avatar(), 2, 'remove_avatar deletes the clean row and the in-flight one'); select is((pg_temp.row('a4')).status, 'deleted', 'a4 deleted'); select is((pg_temp.row('a5')).status, 'deleted', 'a5 deleted'); select is((select count(*) from storage.objects where bucket_id = 'avatars'), 0::bigint, 'nothing readable after removal'); reset role; set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); select throws_ok( $$ select public.complete_avatar_job(pg_temp.id('a5'), pg_temp.id('tok5'), 30000, repeat('e', 64)) $$, 'P0001', 'invalid_state', 'scenario: a removed avatar does not reappear through a late complete' ); reset role; -- --------------------------------------------------------------------------- -- 11. Rejections: closed codes, and the third expired lease -- --------------------------------------------------------------------------- set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000a","role":"authenticated"}', true); insert into pg_temp.ids select 'a6', (public.begin_avatar_upload('image/jpeg', 6000) ->> 'asset_id')::uuid; insert into storage.objects (bucket_id, name, metadata) values ('avatars', (pg_temp.row('a6')).quarantine_key, '{"size":6000}'); select public.confirm_asset_upload(pg_temp.id('a6')); reset role; set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); insert into pg_temp.ids select 'tok6', lock_token from public.claim_avatar_jobs(1); select throws_ok( $$ select public.reject_avatar_job(pg_temp.id('a6'), pg_temp.id('tok6'), 'virus') $$, 'P0001', 'invalid_reason', 'a reason outside the closed set is refused' ); select lives_ok($$ select public.reject_avatar_job(pg_temp.id('a6'), pg_temp.id('tok6'), 'decode_failed') $$, 'worker rejects a6'); select is((pg_temp.row('a6')).status, 'rejected', 'a6 rejected'); select is((pg_temp.row('a6')).rejection_reason, 'decode_failed', 'reason stored'); reset role; select is( (select count(*) from private.object_purge_queue where object_name in ((pg_temp.row('a6')).object_key, (pg_temp.row('a6')).quarantine_key)), 2::bigint, 'both keys of a rejected row are enqueued' ); set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000a","role":"authenticated"}', true); select is((select rejection_reason from public.assets where id = pg_temp.id('a6')), 'decode_failed', 'the owner reads the rejection code'); insert into pg_temp.ids select 'a7', (public.begin_avatar_upload('image/jpeg', 7000) ->> 'asset_id')::uuid; insert into storage.objects (bucket_id, name, metadata) values ('avatars', (pg_temp.row('a7')).quarantine_key, '{"size":7000}'); select public.confirm_asset_upload(pg_temp.id('a7')); reset role; set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); select is((select count(*) from public.claim_avatar_jobs(1)), 1::bigint, 'lease 1 of a7'); reset role; update public.assets set locked_at = now() - interval '11 minutes' where id = pg_temp.id('a7'); set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); select is((select count(*) from public.claim_avatar_jobs(1)), 1::bigint, 'lease 2 of a7'); reset role; update public.assets set locked_at = now() - interval '11 minutes' where id = pg_temp.id('a7'); set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); select is((select count(*) from public.claim_avatar_jobs(1)), 1::bigint, 'lease 3 of a7'); reset role; update public.assets set locked_at = now() - interval '11 minutes' where id = pg_temp.id('a7'); set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); select is((select count(*) from public.claim_avatar_jobs(1)), 0::bigint, 'no fourth lease'); select is((pg_temp.row('a7')).status, 'rejected', 'the third expired lease rejects the row'); select is((pg_temp.row('a7')).rejection_reason, 'processing_error', 'with processing_error'); reset role; -- --------------------------------------------------------------------------- -- 12. Purge queue: due entries are leased, acked entries disappear -- --------------------------------------------------------------------------- update private.object_purge_queue set not_before = now() - interval '1 second' where object_name in ((pg_temp.row('a6')).object_key, (pg_temp.row('a6')).quarantine_key); set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); create table pg_temp.purges as select * from public.claim_purges(100); select is((select count(*) from pg_temp.purges), 2::bigint, 'the two due entries are claimed'); select is((select count(*) from public.claim_purges(100)), 0::bigint, 'a leased purge entry is not claimed again'); select lives_ok($$ select public.ack_purge(purge_id) from pg_temp.purges $$, 'worker acks both'); reset role; select is( (select count(*) from private.object_purge_queue where object_name in ((pg_temp.row('a6')).object_key, (pg_temp.row('a6')).quarantine_key)), 0::bigint, 'acked entries are gone' ); -- --------------------------------------------------------------------------- -- 13. Quarantine leftovers and expiry of never-confirmed uploads -- --------------------------------------------------------------------------- -- Objects still present under quarantine/: a1 (its row no longer references -- it), a2, a3, a4, a5, a6, a7 (terminal rows). None pending or uploaded. set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); select is((select count(*) from public.claim_quarantine_leftovers(0, 100)), 7::bigint, 'every quarantine object without a waiting row is a leftover'); select is((select count(*) from public.claim_quarantine_leftovers(0, 100) l where l.asset_id is null), 1::bigint, 'a leftover whose row forgot the key (purged earlier) has no asset_id'); select is((select count(*) from public.claim_quarantine_leftovers(3600, 100)), 0::bigint, 'nothing younger than the grace is a leftover'); reset role; set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000a","role":"authenticated"}', true); insert into pg_temp.ids select 'a8', (public.begin_avatar_upload('image/jpeg', 8000) ->> 'asset_id')::uuid; insert into storage.objects (bucket_id, name, metadata) values ('avatars', (pg_temp.row('a8')).quarantine_key, '{"size":8000}'); reset role; set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); select is((select count(*) from public.claim_quarantine_leftovers(0, 100) l where l.object_name = (pg_temp.row('a8')).quarantine_key), 0::bigint, 'scenario: bytes of a pending row are not a leftover'); select is(public.expire_pending_uploads(86400), 0, 'a fresh pending row is not expired'); reset role; update public.assets set created_at = now() - interval '25 hours' where id = pg_temp.id('a8'); set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); select is(public.expire_pending_uploads(86400), 1, 'a pending row older than 24 h is expired'); select is((pg_temp.row('a8')).status, 'deleted', 'expired row deleted'); select is((select count(*) from public.claim_quarantine_leftovers(0, 100) l where l.object_name = (pg_temp.row('a8')).quarantine_key), 1::bigint, 'scenario: bytes landed for a row that moved on are swept as a leftover'); reset role; -- --------------------------------------------------------------------------- -- 14. Rate limit, audit, account cascade, ceiling -- --------------------------------------------------------------------------- set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000a","role":"authenticated"}', true); -- a1..a7 = 7 rows this hour (a8 was aged in §13); three more pass, the 11th is refused. select lives_ok($$ select public.begin_avatar_upload('image/jpeg', 100) $$, 'begin 8 of the hour'); select lives_ok($$ select public.begin_avatar_upload('image/jpeg', 100) $$, 'begin 9 of the hour'); select lives_ok($$ select public.begin_avatar_upload('image/jpeg', 100) $$, 'begin 10 of the hour'); select throws_ok($$ select public.begin_avatar_upload('image/jpeg', 100) $$, 'P0001', 'rate_limited', 'the 11th begin within the hour is refused'); reset role; select is( (select count(*) from audit.audit_logs where target_user_id = '40000000-0000-0000-0000-00000000000a' and action = 'asset.avatar_set'), 3::bigint, 'three avatar_set audit rows (a1, a2, a4)' ); select is( (select count(*) from audit.audit_logs where target_user_id = '40000000-0000-0000-0000-00000000000a' and action = 'asset.avatar_removed'), 1::bigint, 'one avatar_removed audit row' ); select is( (select count(*) from audit.audit_logs where target_user_id = '40000000-0000-0000-0000-00000000000a' and action = 'asset.rejected'), 2::bigint, 'two rejected audit rows (worker refusal, third expired lease)' ); -- Bob's account disappears: his keys are enqueued by the delete trigger. set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000b","role":"authenticated"}', true); insert into pg_temp.ids select 'b1', (public.begin_avatar_upload('image/jpeg', 1000) ->> 'asset_id')::uuid; reset role; delete from auth.users where id = '40000000-0000-0000-0000-00000000000b'; select is((select count(*) from public.assets where owner_id = '40000000-0000-0000-0000-00000000000b'), 0::bigint, 'assets cascade with the profile'); select is( (select count(*) from private.object_purge_queue where object_name like 'profiles/40000000-0000-0000-0000-00000000000b/%' or object_name like 'quarantine/40000000-0000-0000-0000-00000000000b/%'), 2::bigint, 'the cascade enqueues both keys of the deleted row' ); -- Ceiling = bytes present in the bucket + declared sizes of pending rows without bytes. -- 2048 rejected rows of 5 MiB (no object) weigh nothing. insert into public.assets (owner_id, kind, bucket_id, object_key, quarantine_key, status, declared_mime, declared_size, rejection_reason, created_at) select '40000000-0000-0000-0000-00000000000a', 'profile_avatar', 'avatars', 'profiles/40000000-0000-0000-0000-00000000000a/' || g || '/avatar.webp', 'quarantine/40000000-0000-0000-0000-00000000000a/' || g || '/upload', 'rejected', 'image/jpeg', 5242880, 'decode_failed', now() - interval '2 hours' from (select gen_random_uuid() as g from generate_series(1, 2048)) s; set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000c","role":"authenticated"}', true); select lives_ok($$ select public.begin_avatar_upload('image/jpeg', 1000) $$, 'rejected rows without bytes do not count toward the ceiling'); reset role; -- 2048 pending rows of 5 MiB whose bytes have not landed are expected bytes. insert into public.assets (owner_id, kind, bucket_id, object_key, quarantine_key, status, declared_mime, declared_size, created_at) select '40000000-0000-0000-0000-00000000000c', 'profile_avatar', 'avatars', 'profiles/40000000-0000-0000-0000-00000000000c/' || g || '/avatar.webp', 'quarantine/40000000-0000-0000-0000-00000000000c/' || g || '/upload', 'pending_upload', 'image/jpeg', 5242880, now() - interval '2 hours' from (select gen_random_uuid() as g from generate_series(1, 2048)) s; set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000c","role":"authenticated"}', true); select throws_ok($$ select public.begin_avatar_upload('image/jpeg', 1000) $$, 'P0001', 'storage_full', 'declared sizes of pending uploads fill the ceiling'); reset role; -- Superseded or expired without bytes: the claim dies with the row (no pinning by begin spam). update public.assets set status = 'deleted' where owner_id = '40000000-0000-0000-0000-00000000000c' and status = 'pending_upload' and created_at < now() - interval '1 hour'; set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000c","role":"authenticated"}', true); select lives_ok($$ select public.begin_avatar_upload('image/jpeg', 1000) $$, 'scenario: rows that moved on without bytes weigh nothing, even while queued for purge'); reset role; -- Bytes present count whatever the row says: one 10 GiB object (under a foreign -- prefix, so the per-account budget stays out of the way) fills the ceiling. insert into storage.objects (bucket_id, name, metadata) values ('avatars', 'quarantine/40000000-0000-0000-0000-00000000000d/00000000-0000-0000-0000-00000000ffff/upload', '{"size":10737418240}'); set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000c","role":"authenticated"}', true); select throws_ok($$ select public.begin_avatar_upload('image/jpeg', 1000) $$, 'P0001', 'storage_full', 'bytes present in the bucket fill the ceiling whatever their row'); reset role; update storage.objects set metadata = '{"size":1}' where name = 'quarantine/40000000-0000-0000-0000-00000000000d/00000000-0000-0000-0000-00000000ffff/upload'; -- A pending row whose bytes landed is charged once, by its object (no double count). update public.assets set declared_size = 5242880 where owner_id = '40000000-0000-0000-0000-00000000000c' and status = 'pending_upload'; insert into storage.objects (bucket_id, name, metadata) select 'avatars', a.quarantine_key, '{"size":1024}' from public.assets a where a.owner_id = '40000000-0000-0000-0000-00000000000c' and a.status = 'pending_upload'; set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000c","role":"authenticated"}', true); select lives_ok($$ select public.begin_avatar_upload('image/jpeg', 1000) $$, 'a landed upload is counted by its bytes, not by its claim'); reset role; -- Per-account budget: 64 MiB of the caller's own bytes present → rate_limited. insert into storage.objects (bucket_id, name, metadata) values ('avatars', 'quarantine/40000000-0000-0000-0000-00000000000c/00000000-0000-0000-0000-00000000fffe/upload', '{"size":67108864}'); set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000c","role":"authenticated"}', true); select throws_ok($$ select public.begin_avatar_upload('image/jpeg', 1000) $$, 'P0001', 'rate_limited', 'scenario: one account cannot hold more than its byte budget in the bucket'); reset role; update storage.objects set metadata = '{"size":1}' where name = 'quarantine/40000000-0000-0000-0000-00000000000c/00000000-0000-0000-0000-00000000fffe/upload'; -- Carol's pending row (begun above): the object may not exceed the declared size. set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000c","role":"authenticated"}', true); insert into pg_temp.ids select 'c1', id from public.assets where owner_id = '40000000-0000-0000-0000-00000000000c' and status = 'pending_upload'; insert into storage.objects (bucket_id, name, metadata) values ('avatars', (pg_temp.row('c1')).quarantine_key, '{}'); select throws_ok($$ select public.confirm_asset_upload(pg_temp.id('c1')) $$, 'P0001', 'upload_missing', 'an object without a size is not confirmable (fail closed)'); reset role; update storage.objects set metadata = '{"size":4000}' where name = (pg_temp.row('c1')).quarantine_key; set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000c","role":"authenticated"}', true); select throws_ok($$ select public.confirm_asset_upload(pg_temp.id('c1')) $$, 'P0001', 'too_large', 'an object larger than the declared size is refused at confirm'); reset role; update storage.objects set metadata = '{"size":1000}' where name = (pg_temp.row('c1')).quarantine_key; set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000c","role":"authenticated"}', true); select lives_ok($$ select public.confirm_asset_upload(pg_temp.id('c1')) $$, 'carol confirms within the declared size'); reset role; set local role service_role; select set_config('request.jwt.claims', '{"role":"service_role"}', true); insert into pg_temp.ids select 'tokc1', lock_token from public.claim_avatar_jobs(1); select throws_ok( $$ select public.complete_avatar_job(pg_temp.id('c1'), pg_temp.id('tokc1'), 30000, null) $$, 'P0001', 'invalid_output', 'a null sha256 is refused by the output guard' ); reset role; -- Deactivated account: begin, confirm and the upload policy refuse it. update public.profiles set active = false where id = '40000000-0000-0000-0000-00000000000c'; set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000c","role":"authenticated"}', true); select throws_ok($$ select public.confirm_asset_upload(gen_random_uuid()) $$, '42501', null, 'a deactivated account cannot confirm an upload'); select throws_ok($$ select public.begin_avatar_upload('image/jpeg', 1000) $$, '42501', null, 'a deactivated account cannot begin an upload'); reset role; -- Back to pending under a fresh quarantine key (the real stack forbids deleting storage rows directly). update public.assets set status = 'pending_upload', locked_at = null, lock_token = null, attempts = 0, quarantine_key = 'quarantine/40000000-0000-0000-0000-00000000000c/' || gen_random_uuid() || '/upload' where id = pg_temp.id('c1'); set local role authenticated; select set_config('request.jwt.claims', '{"sub":"40000000-0000-0000-0000-00000000000c","role":"authenticated"}', true); select throws_ok( $$ insert into storage.objects (bucket_id, name, metadata) values ('avatars', (pg_temp.row('c1')).quarantine_key, '{"size":1000}') $$, '42501', null, 'a deactivated account cannot upload at its pending quarantine key' ); reset role; select ok(not has_function_privilege('service_role', 'public.begin_avatar_upload(text, integer)', 'execute'), 'begin_avatar_upload is not granted to service_role'); select ok(not has_function_privilege('service_role', 'public.confirm_asset_upload(uuid)', 'execute'), 'confirm_asset_upload is not granted to service_role'); select ok(not has_function_privilege('service_role', 'public.remove_avatar()', 'execute'), 'remove_avatar is not granted to service_role'); select * from finish(); rollback;