121 lines
13 KiB
TypeScript
121 lines
13 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 { observeBandwidthNodeRegistryCatalog, BandwidthNodeRegistryCatalogRefused } from "./bandwidth-node-registry-catalog.js"
|
|
|
|
type Row=Record<string,unknown>
|
|
type Item={section:string;raw_json:string|null}
|
|
const refused=(error:unknown)=>error instanceof BandwidthNodeRegistryCatalogRefused
|
|
/** Inert catalog fixture derived from the checked-in component, not an external
|
|
* supplied digest. Actual PostgreSQL deparser/types are covered separately. */
|
|
function fixture():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)})))
|
|
}
|
|
const run=(rows:Item[],live=()=>{})=>observeBandwidthNodeRegistryCatalog({query:async()=>({rows})},live)
|
|
function mutate(rows:Item[],section:string,predicate:(row:Row)=>boolean,change:(row:Row)=>void){
|
|
const item=rows.find(item=>item.section===section&&predicate(JSON.parse(item.raw_json!)as Row))!;assert.ok(item,section)
|
|
const row=JSON.parse(item.raw_json!)as Row;change(row);item.raw_json=JSON.stringify(row)
|
|
}
|
|
|
|
test("fixed component validates and produces deterministic SHA independent of row/object order and CRLF",async()=>{
|
|
const rows=fixture(),events:string[]=[]
|
|
const first=await observeBandwidthNodeRegistryCatalog({query:async(text,values)=>{events.push("SQL");assert.deepEqual(values,[]);assert.ok(text.includes("pg_catalog.pg_proc"));assert.ok(text.includes("n.nspname='mmapp_control'"));assert.ok(text.includes("LIMIT 81"));return{rows}}},()=>events.push("live"))
|
|
assert.match(first,/^[a-f0-9]{64}$/);assert.deepEqual(events,["live","SQL","live"])
|
|
const shuffled=rows.reverse().map(item=>{const row=JSON.parse(item.raw_json!);if(item.section==="functions")row.body=row.body.replace(/\n/g,"\r\n");return{...item,raw_json:JSON.stringify(Object.fromEntries(Object.entries(row).reverse()))}})
|
|
assert.equal(await run(shuffled),first)
|
|
})
|
|
|
|
test("function replacement, SECURITY DEFINER, overload, changed arguments or search path cannot be blessed by a new digest",async()=>{
|
|
for(const name of["bandwidth_node_alias_guard","bandwidth_admission_reject_truncate"])for(const change of[(row:Row)=>{row.body="BEGIN RETURN NEW; END;"},(row:Row)=>{row.security_definer=true},(row:Row)=>{row.language="sql"},(row:Row)=>{row.config=["search_path=pg_catalog, public"]},(row:Row)=>{row.argument_types=["text"]},(row:Row)=>{row.return_type="text"},(row:Row)=>{row.owner="app_restorer"},(row:Row)=>{row.returns_set=true},(row:Row)=>{row.has_support=true}]){
|
|
const rows=fixture();mutate(rows,"functions",row=>row.name===name,change);await assert.rejects(run(rows),refused)
|
|
}
|
|
const overload=fixture();overload.push({...overload.find(item=>item.section==="functions")!});await assert.rejects(run(overload),refused)
|
|
})
|
|
|
|
test("all ten guards must be ALWAYS and retain exact function, trigger type and deferred ownership",async()=>{
|
|
for(const change of[(row:Row)=>{row.enabled="O"},(row:Row)=>{row.type=29},(row:Row)=>{row.function_name="bandwidth_admission_event_guard"},(row:Row)=>{row.deferrable=true},(row:Row)=>{row.condition="false"}]){
|
|
const rows=fixture();mutate(rows,"triggers",row=>row.name==="bandwidth_node_alias_guard",change);await assert.rejects(run(rows),refused)
|
|
}
|
|
const rows=fixture();mutate(rows,"triggers",row=>row.name==="bandwidth_node_alias_consistency",row=>{row.initially_deferred=false});await assert.rejects(run(rows),refused)
|
|
const internal=fixture();mutate(internal,"triggers",row=>row.internal===true,row=>{row.enabled="D"});await assert.rejects(run(internal),refused)
|
|
})
|
|
|
|
test("column type/nullability/default/collation and complete four-table footprint are fixed",async()=>{
|
|
for(const change of[(row:Row)=>{row.type_name="int8"},(row:Row)=>{row.not_null=false},(row:Row)=>{row.generated="s"},(row:Row)=>{row.default_expr="1"},(row:Row)=>{row.collation_name="default"}]){
|
|
const rows=fixture();mutate(rows,"columns",row=>row.table_name==="bandwidth_node_authority"&&row.name==="status",change);await assert.rejects(run(rows),refused)
|
|
}
|
|
for(const section of["namespace","tables","columns","functions","triggers"]){const rows=fixture(),index=rows.findIndex(item=>item.section===section);rows.splice(index,1);await assert.rejects(run(rows),refused)}
|
|
const rows=fixture();mutate(rows,"tables",row=>row.name==="bandwidth_nodes",row=>{row.row_security=true});await assert.rejects(run(rows),refused)
|
|
})
|
|
|
|
test("structural constraints, exact uniqueness/index shape and unrewritten tables are required",async()=>{
|
|
for(const section of["constraints","indexes"]){const rows=fixture();rows.splice(rows.findIndex(item=>item.section===section),1);await assert.rejects(run(rows),refused)}
|
|
const fk=fixture();mutate(fk,"constraints",row=>row.type==="f",row=>{row.delete_action="c"});await assert.rejects(run(fk),refused)
|
|
const index=fixture();mutate(index,"indexes",row=>row.table_name==="bandwidth_node_aliases"&&row.primary===true,row=>{row.predicate="false"});await assert.rejects(run(index),refused)
|
|
for(const section of["rules","policies"]){const rows=fixture();rows.push({section,raw_json:JSON.stringify({name:"bypass"})});await assert.rejects(run(rows),refused)}
|
|
})
|
|
|
|
test("observed constraint expressions are pinned by the digest without claiming arbitrary SQL equivalence",async()=>{
|
|
const rows=fixture(),before=await run(rows)
|
|
mutate(rows,"constraints",row=>row.type==="c",row=>{row.definition="CHECK (changed_expression)"})
|
|
assert.notEqual(await run(rows),before,"the fixed issuer must reject drift against its signed observation")
|
|
})
|
|
|
|
test("NULL budget sentinels, unknown tags, row/byte overflow and malformed JSON fail closed",async()=>{
|
|
for(const extra of[{section:"functions",raw_json:null},{section:"foreign",raw_json:"{}"},{section:"functions",raw_json:"{"},{section:"functions",raw_json:JSON.stringify({body:"x".repeat(65536)})}])await assert.rejects(run([...fixture(),extra]),refused)
|
|
await assert.rejects(run(Array.from({length:231},()=>({section:"namespace",raw_json:"{}"}))),refused)
|
|
})
|
|
|
|
test("late catalog results and query failures honor the live boundary without exposing provider errors",async()=>{
|
|
let active=true,resolve!:(value:{rows:Item[]})=>void
|
|
const pending=new Promise<{rows:Item[]}>(done=>{resolve=done})
|
|
const result=observeBandwidthNodeRegistryCatalog({query:async()=>pending},()=>{if(!active)throw new Error("closed owner")})
|
|
active=false;const rejected=assert.rejects(result,/closed owner/);resolve({rows:fixture()});await rejected
|
|
let checks=0
|
|
await assert.rejects(observeBandwidthNodeRegistryCatalog({query:async()=>{throw new Error("SECRET")}},()=>{checks++}),error=>refused(error)&&!String(error).includes("SECRET"));assert.equal(checks,2)
|
|
})
|