75 lines
4.9 KiB
TypeScript
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)
|
|
}
|
|
})
|