Files
MikrotikManager/backend/src/services/bandwidth-external-node-registry-catalog.test.ts
T

82 lines
9.2 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_EXTERNAL_NODE_REGISTRY_DDL } from "./bandwidth-external-node-registry-schema.js"
import { observeBandwidthExternalNodeRegistryCatalog, BandwidthExternalNodeRegistryCatalogRefused } from "./bandwidth-external-node-registry-catalog.js"
type Row=Record<string,unknown>
type Item={section:string;raw_json:string|null}
const refused=(error:unknown)=>error instanceof BandwidthExternalNodeRegistryCatalogRefused
/** 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_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 run=(rows:Item[],live=()=>{})=>observeBandwidthExternalNodeRegistryCatalog({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("external fixed catalog includes two tables, original-node incoming FK guards and deterministic pin",async()=>{
const rows=fixture(),first=await run(rows);assert.match(first,/^[a-f0-9]{64}$/);assert.equal(await run(rows.reverse()),first)
assert.equal(rows.filter(item=>item.section==="tables").length,2)
assert.equal(rows.filter(item=>item.section==="triggers"&&JSON.parse(item.raw_json!).table_name==="bandwidth_nodes").length,4)
})
test("external catalog refuses altered UUID/reference, guard body, ALWAYS trigger and occupancy tables",async()=>{
for(const [section,predicate,change]of [
["columns",(r:Row)=>r.name==="enrollment_id",(r:Row)=>{r.type_name="int8"}],
["functions",(r:Row)=>r.name==="bandwidth_external_node_alias_guard",(r:Row)=>{r.body="BEGIN RETURN NEW; END;"}],
["triggers",(r:Row)=>r.name==="bandwidth_external_node_alias_guard",(r:Row)=>{r.enabled="O"}],
["constraints",(r:Row)=>r.type==="f",(r:Row)=>{r.delete_action="c"}],
["tables",(_r:Row)=>true,(r:Row)=>{r.name="bandwidth_node_occupancy"}],
] as Array<[string,(r:Row)=>boolean,(r:Row)=>void]>){const rows=fixture();mutate(rows,section,predicate,change);await assert.rejects(run(rows),refused)}
})
test("external catalog requires all inherited RI trigger identities and no extra policies",async()=>{
const rows=fixture();rows.splice(rows.findIndex(item=>item.section==="triggers"&&JSON.parse(item.raw_json!).table_name==="bandwidth_nodes"),1);await assert.rejects(run(rows),refused)
const policy=fixture();policy.push({section:"policies",raw_json:JSON.stringify({name:"unsafe"})});await assert.rejects(run(policy),refused)
})