Files
MikrotikManager/backend/src/services/bandwidth-peer-identity.test.ts
T

196 lines
26 KiB
TypeScript

import assert from "node:assert/strict"
import { test } from "node:test"
import { BANDWIDTH_ADMISSION_PROPOSAL_DDL } from "./bandwidth-admission-schema.js"
import { BANDWIDTH_NODE_REGISTRY_DDL } from "./bandwidth-node-registry-schema.js"
import { BANDWIDTH_EXTERNAL_NODE_REGISTRY_DDL } from "./bandwidth-external-node-registry-schema.js"
import { BANDWIDTH_PEER_IDENTITY_SQL, assertBandwidthPeerIdentity, validateBandwidthPeerIdentityRows, BandwidthPeerIdentityRefused, type BandwidthPeerIdentityExpected } from "./bandwidth-peer-identity.js"
import { validateBandwidthPeerRegistryCatalogRows, validateBandwidthNodeRegistryCatalogRows } from "./bandwidth-node-registry-catalog.js"
type Row=Record<string,unknown>
type Item={section:string;raw_json:string|null}
type Batch={kind:string;row_order:string;raw_json:string|null}
// Inert DDL-derived catalog facts, matching the independent component tests.
// No database callbacks or observer replays implement the batch validator.
function managedFixture():Item[]{
const found:Record<string,Row[]>={namespace:[{name:"mmapp_control",owner:"fixed_owner"}],tables:[],columns:[],functions:[],triggers:[],constraints:[],indexes:[],rules:[],policies:[]}
const tableBodies=new Map<string,string>()
const tables=["bandwidth_node_authority","bandwidth_nodes","bandwidth_node_aliases","bandwidth_node_events"]
const functions=["bandwidth_node_authority_guard","bandwidth_node_immutable_guard","bandwidth_node_alias_guard","bandwidth_node_event_guard","bandwidth_node_alias_consistency_guard","bandwidth_admission_reject_truncate"]
for(const ddl of [BANDWIDTH_ADMISSION_PROPOSAL_DDL,BANDWIDTH_NODE_REGISTRY_DDL]){
for(const match of ddl.matchAll(/CREATE TABLE mmapp_control\.([a-z_]+) \(([\s\S]*?)\n\);/g)){
const table=match[1];if(!tables.includes(table))continue;tableBodies.set(table,match[2])
found.tables.push({name:table,owner:"fixed_owner",kind:"r",persistence:"p",row_security:false,force_row_security:false,is_partition:false,replica_identity:"d",options:null,has_parent:false,has_children:false,typed_table:false,access_method:"heap"})
let position=0
for(const column of match[2].matchAll(/^\s+([a-z_][a-z_0-9]*) (uuid|text|integer|bigint|jsonb|timestamptz)\b([^\n]*)/gm)){
const type=column[2]==="integer"?"int4":column[2]==="bigint"?"int8":column[2],isText=type==="text"
found.columns.push({table_name:table,position:++position,name:column[1],type_namespace:"pg_catalog",type_name:type,not_null:/NOT NULL|PRIMARY KEY/.test(column[3]),identity:"",generated:"",collation_namespace:isText?"pg_catalog":null,collation_name:isText?(/COLLATE "C"/.test(column[3])?"C":"default"):null,default_expr:/DEFAULT clock_timestamp\(\)/.test(column[3])?"clock_timestamp()":/DEFAULT 'active'/.test(column[3])?"'active'::text":null})
}
}
for(const match of ddl.matchAll(/CREATE FUNCTION mmapp_control\.([a-z_]+)\([\s\S]*?\)\s+RETURNS\s+(?:boolean|trigger)[\s\S]*?\bAS\s+\$body\$([\s\S]*?)\$body\$;/g)){
if(!functions.includes(match[1]))continue
const validator=match[1]==="bandwidth_admission_binding_valid",args=validator?["jsonb","uuid","text","text","text","text","text","text"]:[]
found.functions.push({name:match[1],owner:"fixed_owner",language:"plpgsql",body:match[2],security_definer:false,strict:validator,volatility:validator?"i":"v",leakproof:false,kind:"f",parallel:"u",argument_defaults:0,variadic:false,returns_set:false,has_support:false,input_only:true,argument_names:validator?["b","attempt","caller","operation","source","destination","proof","generation"]:null,config:["search_path=pg_catalog, mmapp_control"],return_type:validator?"bool":"trigger",return_namespace:"pg_catalog",argument_types:args,argument_namespaces:args.map(()=>"pg_catalog")})
}
for(const match of ddl.matchAll(/CREATE (CONSTRAINT )?TRIGGER ([a-z_]+) (BEFORE|AFTER) ([\s\S]*?) ON mmapp_control\.([a-z_]+) ([\s\S]*?)EXECUTE FUNCTION mmapp_control\.([a-z_]+)\(\);/g)){
if(!tables.includes(match[5]))continue
const deferred=!!match[1],events=match[4],row=match[6].includes("FOR EACH ROW"),type=(row?1:0)+(match[3]==="BEFORE"?2:0)+(events.includes("INSERT")?4:0)+(events.includes("DELETE")?8:0)+(events.includes("UPDATE")?16:0)+(events.includes("TRUNCATE")?32:0)
found.triggers.push({table_name:match[5],name:match[2],internal:false,type,enabled:"A",deferrable:deferred,initially_deferred:deferred,is_constraint:deferred,constraint_name:deferred?match[2]:null,function_namespace:"mmapp_control",function_name:match[7],argument_count:0,arguments:"",columns:"",condition:null,old_table:null,new_table:null})
}
}
const addConstraint=(table:string,type:string,keys:string[],name:string,extra:Row={})=>found.constraints.push({table_name:table,name,type,validated:true,deferrable:type==="t",initially_deferred:type==="t",keys,foreign_namespace:null,foreign_table:null,foreign_keys:[],update_action:" ",delete_action:" ",match_type:" ",definition:type+":"+keys.join(","),...extra})
for(const [table,body]of tableBodies){
let index=0
for(const _ of body.matchAll(/\bCHECK\s*\(/g))addConstraint(table,"c",[],`${table}_check_${index++}`)
for(const column of found.columns.filter(row=>row.table_name===table&&row.not_null))addConstraint(table,"n",[String(column.name)],`${table}_${column.name}_not_null`)
}
for(const row of found.triggers.filter(row=>row.is_constraint))addConstraint(String(row.table_name),"t",[],String(row.name))
const specifications:Record<string,Array<[string,string[]]>>={bandwidth_node_authority:[["p",["id"]]],bandwidth_nodes:[["p",["node_id"]],["u",["claim_proof"]]],bandwidth_node_aliases:[["p",["server_id"]],["u",["incarnation"]],["i",["node_id"]]],bandwidth_node_events:[["p",["event_id"]],["u",["server_id","kind"]],["i",["node_id"]]]}
for(const[table,specs]of Object.entries(specifications))for(const[kind,keys]of specs){
if(kind!=="i")addConstraint(table,kind,keys,`${table}_${kind}`)
const fields=keys.map(name=>found.columns.find(row=>row.table_name===table&&row.name===name)!)
found.indexes.push({table_name:table,name:`${table}_${kind}`,unique:kind!=="i",primary:kind==="p",valid:true,ready:true,live:true,key_count:keys.length,attribute_count:keys.length,method:"btree",keys,collations:fields.map(row=>row.collation_name),collation_namespaces:fields.map(row=>row.collation_namespace),operator_classes:fields.map(row=>row.type_name==="uuid"?"uuid_ops":row.type_name==="int4"?"int4_ops":row.type_name==="int8"?"int8_ops":"text_ops"),operator_class_namespaces:fields.map(()=>"pg_catalog"),options:keys.map(()=>"0").join(" "),expressions:null,predicate:null,definition:`index ${table} (${keys.join(",")})`})
}
for(const[table,key,parent]of[["bandwidth_node_aliases","node_id","bandwidth_nodes"],["bandwidth_node_events","server_id","bandwidth_node_aliases"],["bandwidth_node_events","node_id","bandwidth_nodes"]]){
const name=`${table}_${key}_fkey`
addConstraint(table,"f",[key],name,{foreign_namespace:"mmapp_control",foreign_table:parent,foreign_keys:[key],update_action:"r",delete_action:"r",match_type:"s"})
for(const[relation,fn,type]of[[table,"RI_FKey_check_ins",5],[table,"RI_FKey_check_upd",17],[parent,"RI_FKey_restrict_del",9],[parent,"RI_FKey_restrict_upd",17]]as const)found.triggers.push({table_name:relation,name:null,internal:true,type,enabled:"O",deferrable:false,initially_deferred:false,is_constraint:true,constraint_name:name,function_namespace:"pg_catalog",function_name:fn,argument_count:0,arguments:"",columns:"",condition:null,old_table:null,new_table:null})
}
return Object.entries(found).flatMap(([section,rows])=>rows.map(row=>({section,raw_json:JSON.stringify(row)})))
}
function externalFixture():Item[]{
const found:Record<string,Row[]>={namespace:[{name:"mmapp_control",owner:"fixed_owner"}],tables:[],columns:[],functions:[],triggers:[],constraints:[],indexes:[],rules:[],policies:[]}
const tableBodies=new Map<string,string>()
const tables=["bandwidth_external_node_aliases","bandwidth_external_node_events"]
const functions=["bandwidth_external_node_alias_guard","bandwidth_external_node_event_guard","bandwidth_external_node_alias_consistency_guard","bandwidth_admission_reject_truncate"]
for(const ddl of [BANDWIDTH_ADMISSION_PROPOSAL_DDL,BANDWIDTH_EXTERNAL_NODE_REGISTRY_DDL]){
for(const match of ddl.matchAll(/CREATE TABLE mmapp_control\.([a-z_]+) \(([\s\S]*?)\n\);/g)){
const table=match[1];if(!tables.includes(table))continue;tableBodies.set(table,match[2])
found.tables.push({name:table,owner:"fixed_owner",kind:"r",persistence:"p",row_security:false,force_row_security:false,is_partition:false,replica_identity:"d",options:null,has_parent:false,has_children:false,typed_table:false,access_method:"heap"})
let position=0
for(const column of match[2].matchAll(/^\s+([a-z_][a-z_0-9]*) (uuid|text|integer|bigint|jsonb|timestamptz)\b([^\n]*)/gm)){
const type=column[2]==="integer"?"int4":column[2]==="bigint"?"int8":column[2],isText=type==="text"
found.columns.push({table_name:table,position:++position,name:column[1],type_namespace:"pg_catalog",type_name:type,not_null:/NOT NULL|PRIMARY KEY/.test(column[3]),identity:"",generated:"",collation_namespace:isText?"pg_catalog":null,collation_name:isText?(/COLLATE "C"/.test(column[3])?"C":"default"):null,default_expr:/DEFAULT clock_timestamp\(\)/.test(column[3])?"clock_timestamp()":/DEFAULT 'active'/.test(column[3])?"'active'::text":null})
}
}
for(const match of ddl.matchAll(/CREATE FUNCTION mmapp_control\.([a-z_]+)\([\s\S]*?\)\s+RETURNS\s+(?:boolean|trigger)[\s\S]*?\bAS\s+\$body\$([\s\S]*?)\$body\$;/g)){
if(!functions.includes(match[1]))continue
const validator=match[1]==="bandwidth_admission_binding_valid",args=validator?["jsonb","uuid","text","text","text","text","text","text"]:[]
found.functions.push({name:match[1],owner:"fixed_owner",language:"plpgsql",body:match[2],security_definer:false,strict:validator,volatility:validator?"i":"v",leakproof:false,kind:"f",parallel:"u",argument_defaults:0,variadic:false,returns_set:false,has_support:false,input_only:true,argument_names:validator?["b","attempt","caller","operation","source","destination","proof","generation"]:null,config:["search_path=pg_catalog, mmapp_control"],return_type:validator?"bool":"trigger",return_namespace:"pg_catalog",argument_types:args,argument_namespaces:args.map(()=>"pg_catalog")})
}
for(const match of ddl.matchAll(/CREATE (CONSTRAINT )?TRIGGER ([a-z_]+) (BEFORE|AFTER) ([\s\S]*?) ON mmapp_control\.([a-z_]+) ([\s\S]*?)EXECUTE FUNCTION mmapp_control\.([a-z_]+)\(\);/g)){
if(!tables.includes(match[5]))continue
const deferred=!!match[1],events=match[4],row=match[6].includes("FOR EACH ROW"),type=(row?1:0)+(match[3]==="BEFORE"?2:0)+(events.includes("INSERT")?4:0)+(events.includes("DELETE")?8:0)+(events.includes("UPDATE")?16:0)+(events.includes("TRUNCATE")?32:0)
found.triggers.push({table_name:match[5],name:match[2],internal:false,type,enabled:"A",deferrable:deferred,initially_deferred:deferred,is_constraint:deferred,constraint_name:deferred?match[2]:null,function_namespace:"mmapp_control",function_name:match[7],argument_count:0,arguments:"",columns:"",condition:null,old_table:null,new_table:null})
}
}
const addConstraint=(table:string,type:string,keys:string[],name:string,extra:Row={})=>found.constraints.push({table_name:table,name,type,validated:true,deferrable:type==="t",initially_deferred:type==="t",keys,foreign_namespace:null,foreign_table:null,foreign_keys:[],update_action:" ",delete_action:" ",match_type:" ",definition:type+":"+keys.join(","),...extra})
for(const [table,body]of tableBodies){
let index=0
for(const _ of body.matchAll(/\bCHECK\s*\(/g))addConstraint(table,"c",[],`${table}_check_${index++}`)
for(const column of found.columns.filter(row=>row.table_name===table&&row.not_null))addConstraint(table,"n",[String(column.name)],`${table}_${column.name}_not_null`)
}
for(const row of found.triggers.filter(row=>row.is_constraint))addConstraint(String(row.table_name),"t",[],String(row.name))
const specifications:Record<string,Array<[string,string[]]>>={bandwidth_external_node_aliases:[["p",["enrollment_id"]],["u",["incarnation"]],["i",["node_id"]]],bandwidth_external_node_events:[["p",["event_id"]],["u",["enrollment_id","kind"]],["i",["node_id"]]]}
for(const[table,specs]of Object.entries(specifications))for(const[kind,keys]of specs){
if(kind!=="i")addConstraint(table,kind,keys,`${table}_${kind}`)
const fields=keys.map(name=>found.columns.find(row=>row.table_name===table&&row.name===name)!)
found.indexes.push({table_name:table,name:`${table}_${kind}`,unique:kind!=="i",primary:kind==="p",valid:true,ready:true,live:true,key_count:keys.length,attribute_count:keys.length,method:"btree",keys,collations:fields.map(row=>row.collation_name),collation_namespaces:fields.map(row=>row.collation_namespace),operator_classes:fields.map(row=>row.type_name==="uuid"?"uuid_ops":row.type_name==="int4"?"int4_ops":row.type_name==="int8"?"int8_ops":"text_ops"),operator_class_namespaces:fields.map(()=>"pg_catalog"),options:keys.map(()=>"0").join(" "),expressions:null,predicate:null,definition:`index ${table} (${keys.join(",")})`})
}
for(const[table,key,parent]of[["bandwidth_external_node_aliases","node_id","bandwidth_nodes"],["bandwidth_external_node_events","enrollment_id","bandwidth_external_node_aliases"],["bandwidth_external_node_events","node_id","bandwidth_nodes"]]){
const name=`${table}_${key}_fkey`
addConstraint(table,"f",[key],name,{foreign_namespace:"mmapp_control",foreign_table:parent,foreign_keys:[key],update_action:"r",delete_action:"r",match_type:"s"})
for(const[relation,fn,type]of[[table,"RI_FKey_check_ins",5],[table,"RI_FKey_check_upd",17],[parent,"RI_FKey_restrict_del",9],[parent,"RI_FKey_restrict_upd",17]]as const)found.triggers.push({table_name:relation,name:null,internal:true,type,enabled:"O",deferrable:false,initially_deferred:false,is_constraint:true,constraint_name:name,function_namespace:"pg_catalog",function_name:fn,argument_count:0,arguments:"",columns:"",condition:null,old_table:null,new_table:null})
}
return Object.entries(found).flatMap(([section,rows])=>rows.map(row=>({section,raw_json:JSON.stringify(row)})))
}
const role=(external:boolean)=>({observation:{databaseName:"owned_database",sessionRole:"bandwidth_runtime",currentRole:"bandwidth_runtime",runtimeRoleExists:true,ownerRoleExists:true,runtimeFlagsSafe:true,ownerMembership:false,dangerousMembership:false,schemaExists:true,schemaOwner:"fixed_owner",schemaUsage:true,schemaCreate:false,publicSchemaUsage:false,publicSchemaCreate:false,tables:[external?"bandwidth_external_node_aliases":"bandwidth_node_aliases","bandwidth_nodes",external?"bandwidth_external_node_events":"bandwidth_node_events","bandwidth_node_authority"].map(name=>({name,exists:true,ownerRole:"fixed_owner",ownedByRuntime:false,privilegesExact:true}))}})
function fixture(){
const external=externalFixture(),managed=managedFixture()
managed.push(...external.filter(item=>item.section==="triggers"&&JSON.parse(item.raw_json!).table_name==="bandwidth_nodes"))
const incoming=external.filter(item=>item.section==="constraints").map(item=>JSON.parse(item.raw_json!) as Row).filter(row=>row.type==="f"&&row.foreign_table==="bandwidth_nodes").map(row=>({table_name:row.table_name,constraint_name:row.name}))
const expected:BandwidthPeerIdentityExpected={databaseName:"owned_database",runtimeRole:"bandwidth_runtime",ownerRole:"fixed_owner",installationId:"11111111-1111-4111-8111-111111111111",issuerKeySha256:"a".repeat(64),quiescenceProof:"b".repeat(64),registryCatalogSha256:validateBandwidthPeerRegistryCatalogRows(managed,external,incoming)}
const authority={installation_id:expected.installationId,issuer_key_sha256:expected.issuerKeySha256,quiescence_proof:expected.quiescenceProof,status:"active"}
const groups:Record<string,unknown[]>={"managed-role":[role(false)],"external-role":[role(true)],"managed-catalog":managed,"external-catalog":external,incoming,authority:[authority]}
const rows:Batch[]=Object.entries(groups).flatMap(([kind,items])=>items.map(value=>({kind,row_order:"",raw_json:JSON.stringify(value)})))
ordinal(rows);return{expected,rows,managed,external,incoming}
}
function ordinal(rows:Batch[]){rows.forEach((row,index)=>{row.row_order=String(index+1)});return rows}
const refused=(e:unknown)=>e instanceof BandwidthPeerIdentityRefused
const check=(f:ReturnType<typeof fixture>)=>validateBandwidthPeerIdentityRows(f.rows,f.expected)
function change(f:ReturnType<typeof fixture>,kind:string,mutate:(row:Row)=>void){const item=f.rows.find(row=>row.kind===kind)!;assert(item);const value=JSON.parse(item.raw_json!) as Row;mutate(value);item.raw_json=JSON.stringify(value)}
function catalogChange(f:ReturnType<typeof fixture>,kind:string,section:string,predicate:(row:Row)=>boolean,mutate:(row:Row)=>void){
const item=f.rows.find(row=>{if(row.kind!==kind)return false;const value=JSON.parse(row.raw_json!) as Item;return value.section===section&&predicate(JSON.parse(value.raw_json!) as Row)})!;assert(item)
const value=JSON.parse(item.raw_json!) as Item,row=JSON.parse(value.raw_json!) as Row;mutate(row);value.raw_json=JSON.stringify(row);item.raw_json=JSON.stringify(value)
}
test("one materialized SQL snapshot validates both exact roles, complete catalogs/FKs and authority, with three live fences",async()=>{
const f=fixture(),events:string[]=[],calls:string[]=[]
await assertBandwidthPeerIdentity({async query(text,values){events.push("SQL");calls.push(text);assert.deepEqual(values,[f.expected.databaseName,f.expected.runtimeRole,f.expected.ownerRole]);return{rows:f.rows}}},f.expected,()=>events.push("live"))
assert.deepEqual(events,["live","SQL","live","live"]);assert.equal(calls.length,1);assert.equal(calls[0],BANDWIDTH_PEER_IDENTITY_SQL)
for(const cte of ["managed_role","external_role","managed_catalog","external_catalog","incoming","authority"])assert(calls[0].includes(cte+" AS MATERIALIZED"))
assert(calls[0].includes("ORDER BY c.relname,t.tgname LIMIT 27"));assert(calls[0].includes("ORDER BY c.relname,t.tgname LIMIT 19"));assert(calls[0].includes("row_count<=469"));assert(calls[0].includes("LIMIT 470"))
assert(!/INSERT INTO|CREATE TABLE|CREATE FUNCTION/.test(calls[0]));assert(!calls[0].includes("owned_database"))
})
test("pure combined digest and batch preserve strict v1 footprint and semantic transport-order independence",()=>{
const f=fixture();assert.throws(()=>validateBandwidthNodeRegistryCatalogRows(f.managed));assert.equal(validateBandwidthPeerRegistryCatalogRows(f.managed,f.external,f.incoming),f.expected.registryCatalogSha256)
f.rows.reverse();for(const row of f.rows){const value=JSON.parse(row.raw_json!) as Row;row.raw_json=JSON.stringify(Object.fromEntries(Object.entries(value).reverse()))}check(f)
})
test("missing or duplicated every component refuses without accepting another section as authority",()=>{
for(const kind of ["managed-role","external-role","managed-catalog","external-catalog","incoming","authority"]){
const f=fixture();f.rows=ordinal(f.rows.filter(row=>row.kind!==kind));assert.throws(()=>check(f),refused)
const duplicate=fixture(),row=duplicate.rows.find(row=>row.kind===kind)!;duplicate.rows.push({...row});ordinal(duplicate.rows);assert.throws(()=>check(duplicate),refused)
}
})
test("outer result shape, unknown tags, NULL overflow, malformed JSON and duplicate/missing ordinals fail closed",()=>{
const changes=[(rows:Batch[])=>{rows[0].kind="untrusted"},(rows:Batch[])=>{rows[0].raw_json=null},(rows:Batch[])=>{rows[0].raw_json="{"},(rows:Batch[])=>{rows[0].raw_json="[]"},(rows:Batch[])=>{rows[0].row_order=rows[1].row_order},(rows:Batch[])=>{rows[0].row_order="0"},(rows:Batch[])=>{rows[0].row_order="01"},(rows:Batch[])=>{rows[0].row_order="999"}]
for(const mutate of changes){const f=fixture();mutate(f.rows);assert.throws(()=>check(f),refused)}
const extra=fixture();(extra.rows[0] as unknown as Row).trusted=true;assert.throws(()=>check(extra),refused)
for(const invalid of [undefined,null,{},"rows",[null]])assert.throws(()=>validateBandwidthPeerIdentityRows(invalid,fixture().expected),refused)
})
test("row/per-row/total-byte/component limits reject sentinels and oversized observations before semantic trust",()=>{
const f=fixture(),valid={kind:"managed-catalog",row_order:"1",raw_json:JSON.stringify({padding:"x".repeat(131180)})}
assert.throws(()=>validateBandwidthPeerIdentityRows(ordinal(Array.from({length:470},()=>({...valid}))),f.expected),refused)
assert.throws(()=>validateBandwidthPeerIdentityRows([{...valid,raw_json:JSON.stringify({padding:"x".repeat(131201)})}],f.expected),refused)
assert.throws(()=>validateBandwidthPeerIdentityRows(ordinal(Array.from({length:49},()=>({...valid}))),f.expected),refused)
for(const [kind,count]of [["managed-catalog",235],["external-catalog",231]] as const)assert.throws(()=>validateBandwidthPeerIdentityRows(ordinal(Array.from({length:count},()=>({kind,row_order:"",raw_json:"{}"}))),f.expected),refused)
})
test("both least-privilege role observations retain exact membership/ACL/owner/flag checks",()=>{
for(const kind of ["managed-role","external-role"])for(const mutate of [
(row:Row)=>{(row.observation as Row).runtimeFlagsSafe=false},(row:Row)=>{(row.observation as Row).dangerousMembership=true},(row:Row)=>{(row.observation as Row).ownerMembership=true},(row:Row)=>{(row.observation as Row).publicSchemaCreate=true},(row:Row)=>{(row.observation as Row).schemaOwner="application_owner"},
(row:Row)=>{((row.observation as Row).tables as Row[])[0].privilegesExact=false},(row:Row)=>{((row.observation as Row).tables as Row[])[0].ownedByRuntime=true},(row:Row)=>{const tables=(row.observation as Row).tables as Row[];tables[1]={...tables[0]}},
]){const f=fixture();change(f,kind,mutate);assert.throws(()=>check(f),refused)}
})
test("managed and external catalogs retain literal guards, ALWAYS triggers, UUID columns, indexes and signed expression pin",()=>{
for(const kind of ["managed-catalog","external-catalog"])for(const [section,predicate,mutate]of [
["functions",()=>true,(row:Row)=>{row.body="BEGIN RETURN NEW; END;"}],
["triggers",(row:Row)=>row.internal===false,(row:Row)=>{row.enabled="O"}],
["columns",(row:Row)=>row.type_name==="uuid",(row:Row)=>{row.type_name="int8"}],
["indexes",()=>true,(row:Row)=>{row.predicate="false"}],
["constraints",(row:Row)=>row.type==="f",(row:Row)=>{row.delete_action="c"}],
["constraints",(row:Row)=>row.type==="c",(row:Row)=>{row.definition="CHECK(true)"}],
] as Array<[string,(row:Row)=>boolean,(row:Row)=>void]>){const f=fixture();catalogChange(f,kind,section,predicate,mutate);assert.throws(()=>check(f),refused)}
})
test("two incoming FK identities must match both complete trigger footprints and signed original pin",()=>{
for(const mutate of [(row:Row)=>{row.constraint_name="different_fk"},(row:Row)=>{row.table_name="bandwidth_node_occupancy"},(row:Row)=>{row.constraint_name="x".repeat(64)},(row:Row)=>{row.extra=true}]){const f=fixture();change(f,"incoming",mutate);assert.throws(()=>check(f),refused)}
const f=fixture();catalogChange(f,"managed-catalog","triggers",row=>String(row.constraint_name).startsWith("bandwidth_external"),row=>{row.constraint_name="wrong_original_foreign_key"});assert.throws(()=>check(f),refused)
})
test("immutable authority exact installation/key/quiescence/status row is required, independently of valid catalog digests",()=>{
for(const mutate of [(row:Row)=>{row.installation_id="22222222-2222-4222-8222-222222222222"},(row:Row)=>{row.issuer_key_sha256="f".repeat(64)},(row:Row)=>{row.quiescence_proof="f".repeat(64)},(row:Row)=>{row.status="quarantined"},(row:Row)=>{row.ready=true},(row:Row)=>{delete row.status}]){const f=fixture();change(f,"authority",mutate);assert.throws(()=>check(f),refused)}
})
test("caller mutation during SQL cannot replace original expected role/root/catalog pin",async()=>{
const f=fixture(),original={...f.expected};let calls=0
await assertBandwidthPeerIdentity({async query(_text,values){calls++;assert.deepEqual(values,[original.databaseName,original.runtimeRole,original.ownerRole]);f.expected.databaseName="changed_database";f.expected.runtimeRole="changed_role";f.expected.registryCatalogSha256="f".repeat(64);f.expected.installationId="22222222-2222-4222-8222-222222222222";return{rows:f.rows}}},f.expected,()=>{})
assert.equal(calls,1)
})
test("expected getters/symbols/additional fields/malformed root are refused before SQL without invoking accessors",async()=>{
for(const field of ["installationId","issuerKeySha256","registryCatalogSha256"]){const f=fixture();(f.expected as Row)[field]="invalid";let calls=0;await assert.rejects(assertBandwidthPeerIdentity({async query(){calls++;return{rows:f.rows}}},f.expected,()=>{}),refused);assert.equal(calls,0)}
const f=fixture();let getters=0,calls=0;Object.defineProperty(f.expected,"issuerKeySha256",{enumerable:true,get(){getters++;return"a".repeat(64)}})
await assert.rejects(assertBandwidthPeerIdentity({async query(){calls++;return{rows:f.rows}}},f.expected,()=>{}),refused);assert.equal(getters,0);assert.equal(calls,0)
const symbol=fixture();Object.defineProperty(symbol.expected,Symbol("proof"),{value:true});assert.throws(()=>check(symbol),refused)
})
test("expiry/cancellation live boundary rejects late valid snapshots and SQL failure without exposing provider detail",async()=>{
const f=fixture(),closed=Error("original authority closed");let calls=0,checks=0
await assert.rejects(assertBandwidthPeerIdentity({async query(){calls++;return{rows:f.rows}}},f.expected,()=>{if(++checks===2)throw closed}),error=>error===closed);assert.equal(calls,1);assert.equal(checks,2)
const events:string[]=[];await assert.rejects(assertBandwidthPeerIdentity({async query(){events.push("SQL");throw Error("private provider endpoint/password")}},f.expected,()=>events.push("live")),e=>refused(e)&&!String(e).includes("password"));assert.deepEqual(events,["live","SQL","live"])
let before=0;await assert.rejects(assertBandwidthPeerIdentity({async query(){before++;return{rows:f.rows}}},f.expected,()=>{throw closed}),error=>error===closed);assert.equal(before,0)
})