M4 20261028100000_sheet_access_hardening + M5 20261028110000_sheet_review_workflow (applied together; no unprotected window). Implements contract §5-§14. - Catalogue rights table + owner RPCs; has_mfa / has_aal2_session (live auth.sessions check); grant_active vs caller_has split; catalogue reader predicate; can_edit_sheet on the sheet_editor capability (F14). - AR-1 B: aal2 required on every platform role change, target verified factor, race-free last-owner guard (F18/F19); service_role loses table privileges on the catalogue + profiles/profile_roles and EXECUTE on the role RPCs (F12/F17). - Reviewed lifecycle: version provenance + review columns, content/freeze/ author triggers, rounds/comments/acknowledgments, save/submit/withdraw/ comment/acknowledge/decide, atomic publish_sheet_version(review_id) on the stored verdict, deprecate/archive/restore, species RPCs, equine working copy, uploads with the storage check (F7) + editor INSERT policy + 2 MiB bucket. F1-F3,F5,F6,F8,F9,F13,F15,F16 closed. Verdict is a fixture until M6 (V1-2.3). - O22: SQL business mirror removed, declared status check kept; pgTAP 011 and the Rust generator's SQL parts deleted, ledger retargeted. - Access layer sheets.ts (closed SheetFailure kinds); old client publish gate deleted; types regenerated; upload tool reads via get_sheet_asset_state. Tested on the throwaway sandbox only; DEV untouched. pgTAP 850 (real stack) / 122 (PGlite) green; real-GoTrue AR-1 B + F18 race green; fresh install and M3->M5 upgrade green; V1-1 regression green; rust:check, typecheck, lint, build, types drift clean. BDR-084, LRN-095.
613 lines
41 KiB
PL/PgSQL
613 lines
41 KiB
PL/PgSQL
-- 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(141);
|
|
|
|
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;
|
|
|
|
-- ---------------------------------------------------------------------------
|
|
-- 0. Work the base already holds
|
|
-- ---------------------------------------------------------------------------
|
|
-- A used stack (DEV) can hold due purge entries, uploaded avatars waiting for
|
|
-- the worker and uploads begun more than 24 h ago. The worker RPCs serve the
|
|
-- whole queue, oldest first: that work is leased (or expired) here, inside
|
|
-- this transaction and rolled back with it, so the queue assertions below
|
|
-- count this file's rows only. A clean base has nothing to lease.
|
|
set local role service_role;
|
|
select set_config('request.jwt.claims', '{"role":"service_role"}', true);
|
|
do $$
|
|
begin
|
|
for i in 1..1000 loop
|
|
exit when not exists (select 1 from public.claim_purges(100))
|
|
and not exists (select 1 from public.claim_avatar_jobs(10));
|
|
end loop;
|
|
perform public.expire_pending_uploads(86400);
|
|
end $$;
|
|
select ok(
|
|
not exists (select 1 from public.claim_purges(100))
|
|
and not exists (select 1 from public.claim_avatar_jobs(10))
|
|
and public.expire_pending_uploads(86400) = 0,
|
|
'setup: the base holds no claimable purge entry, avatar job or stale upload of its own'
|
|
);
|
|
reset 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''%'),
|
|
2::bigint, 'census: two policies name anatomical-sheet-assets (read + editor upload, V1-2.1)'
|
|
);
|
|
select is(
|
|
(select count(*) from pg_policies where schemaname = 'storage' and tablename = 'objects'),
|
|
4::bigint, 'census: four policies in total (avatars read+insert, sheet-assets read+insert)'
|
|
);
|
|
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.
|
|
-- The sweep reads the whole bucket and holds no lease: leftovers of the base
|
|
-- (a used stack) are left out of the counts by this file's key prefix.
|
|
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 like 'quarantine/40000000-0000-0000-0000-00000000000_/%'),
|
|
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.object_name like 'quarantine/40000000-0000-0000-0000-00000000000_/%' and 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) l
|
|
where l.object_name like 'quarantine/40000000-0000-0000-0000-00000000000_/%'),
|
|
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;
|