Files
MikrotikManager/backend/scripts/writer-profile/registry-enrollment.test.mts
T

75 lines
4.9 KiB
TypeScript

import assert from 'node:assert/strict'
import {EventEmitter} from 'node:events'
import {mock,test} from 'node:test'
import {MIGRATION_MANIFEST,migrationManifestDigest} from '../../src/db/migration-manifest.js'
test('enrollment uses the independently pinned owner, validates readback, and never retries an unknown COMMIT',async()=>{
const digest='a'.repeat(64)
const roles=Object.fromEntries(['runtime','operator','capture','publisher','control'].map((role,index)=>[role,{name:`app_${role}`,signedOid:String(20000+index)}]))
const source={databaseOid:'30000',databaseName:'fixture',systemIdentifier:'121212',serverVersionNum:180004,inRecovery:false}
const deploymentRequest={format:'application-writer-bootstrap-request-v1',installationId:'7435bc0c-b7c8-40d8-be88-5f6ae478a221',sourceHeadSha256:digest,
source,roles,tls:{serverName:'localhost',caSha256:digest,spkiSha256:digest}}
const manifestSha256=migrationManifestDigest()
const approval={format:'application-writer-registry-enrollment-v1',manifestSha256,deploymentRequest}
const args=['registry-enroll','--approval','approval','--approval-sha256',digest,'--transport','transport','--transport-sha256',digest,'--ca','ca']
let mode='success'
const trace:string[]=[]
class Client extends EventEmitter{
async query(sql:string){
trace.push(sql)
if(sql.includes('pg_catalog.pg_control_system()'))return {rows:mode==='wrong-target'?[]:[{...source,roleOid:roles.control.signedOid}]}
if(sql.includes('AS name, oid::text'))return {rows:Object.values(roles).map(role=>({name:role.name,oid:role.signedOid}))}
if(sql.includes('FROM public.schema_migrations'))return {rows:mode==='wrong-markers'?[]:MIGRATION_MANIFEST.map(pin=>({id:pin.file.slice(0,-4)}))}
if(sql.includes('c.relname=ANY'))return {rows:mode==='absent'?[]:
['application_writer_profile_current',...(mode==='partial'?[]:['application_writer_profile_history'])].map(name=>({name}))}
if(sql==='COMMIT'&&mode==='ack-lost')throw Error('Synthetic ACK loss')
if(sql==='ROLLBACK'&&mode==='rollback-lost')throw Error('Synthetic ROLLBACK loss')
return {command:sql,rows:[]}
}
release(destroy:boolean){assert(destroy);trace.push('release')}
}
class Pool extends EventEmitter{
async connect(){trace.push('connect');return new Client()}
async end(){trace.push('end')}
}
mock.module('pg',{defaultExport:{Pool}})
mock.module('./operator-files.mjs',{namedExports:{readProtected:async(path:string,_limit:number,expected:string)=>{
assert.equal(expected,digest)
return Buffer.from(JSON.stringify(path==='approval'?approval:{}))
}}})
mock.module('./operator-contract.mjs',{namedExports:{assertJsDriverEnvironment:()=>{},poolOptions:(_transport:unknown,request:typeof deploymentRequest,_ca:Buffer,role:string)=>{
assert.deepEqual(request,deploymentRequest);assert.equal(role,'control');return {}
},retainPublisherTlsPeer:()=>()=>{}}})
mock.module('../../src/db/application-writer-profile-registry-structure.js',{namedExports:{readProtectedRegistryStructureData:async()=>{
trace.push('profile-verified');if(mode==='drift')throw Error('Synthetic catalogue drift')
return {sha256:digest}
}}})
const {registryEnrollmentMain}=await import('./registry-enrollment.mjs')
const before=await registryEnrollmentMain(args)
assert.equal(before.outcome,'committed');assert.equal(before.registryStructureSha256,digest);assert.equal(before.readyAuthorized,false)
const lock=trace.findIndex(sql=>sql.includes('pg_advisory_xact_lock')),ddl=trace.findIndex(sql=>sql.startsWith('CREATE TABLE'))
assert(lock>=0&&lock<ddl&&ddl<trace.indexOf('profile-verified'))
assert.match(trace[ddl+1],/GRANT SELECT, INSERT, UPDATE ON mmapp_control\.application_writer_profile_current TO "app_publisher"/)
assert.deepEqual(trace.slice(-4),['profile-verified','COMMIT','release','end'])
for(const scenario of ['wrong-target','wrong-markers','drift','ack-lost']){
mode=scenario;trace.length=0
await assert.rejects(registryEnrollmentMain(args),scenario==='ack-lost'?{code:'WRITER_REGISTRY_TERMINAL_UNKNOWN'}:Error)
assert.deepEqual(trace.slice(-2),['release','end'])
assert.equal(trace.filter(sql=>sql.startsWith('CREATE TABLE')).length,scenario.startsWith('wrong-')?0:1)
assert.equal(trace.filter(sql=>sql==='COMMIT').length,scenario==='ack-lost'?1:0)
}
const inspectArgs=['registry-inspect',...args.slice(1)]
for(const scenario of ['absent','installed','partial','drift','rollback-lost']){
mode=scenario;trace.length=0
if(scenario==='absent'||scenario==='installed'){
const result=await registryEnrollmentMain(inspectArgs)
assert.equal(result.outcome,scenario)
assert.equal(result.registryStructureSha256,scenario==='installed'?digest:undefined)
assert.equal(result.readyAuthorized,false)
assert.deepEqual(trace.slice(-3),['ROLLBACK','release','end'])
}else await assert.rejects(registryEnrollmentMain(inspectArgs),Error)
assert.equal(trace[1],'BEGIN READ ONLY')
assert.equal(trace.some(sql=>sql.startsWith('CREATE TABLE')||sql==='COMMIT'),false)
}
})