121 lines
11 KiB
TypeScript
121 lines
11 KiB
TypeScript
/** Ordinary MCP adapter + ACTUAL shared manual executor with inert collector
|
|
* and alert hook. No database, network, notifications or scheduler execution. */
|
|
import assert from "node:assert/strict"
|
|
import { randomUUID } from "node:crypto"
|
|
import { beforeEach, mock, test } from "node:test"
|
|
import { createManualDataCollection } from "../../services/manual-data-collection-execution.js"
|
|
import type { add } from "./actions.js"
|
|
|
|
const permission="mm:servers:write",principal={connectionId:randomUUID(),credentialId:randomUUID(),credentialExpiresAt:new Date(Date.now()+60000).toISOString()}
|
|
const context={principal,connection:{owner_id:"owned-manual-actor"}} as Parameters<NonNullable<Parameters<typeof add>[8]["prepare"]>>[1]
|
|
const forward={phase:"forward" as const,operationId:randomUUID(),stepIndex:0}
|
|
const epochs=[randomUUID(),randomUUID(),randomUUID()],queries:string[]=[],events:string[]=[]
|
|
let connection:{owner_id:string;owner_permissions:string[];policy:{version:number;permissions:string[];scope:{allowGlobal:boolean;serverIds:number[]}}}
|
|
let catalog:Array<{id:number;enabled:boolean;routingEndpointEpoch:string}>,settings:{enabled:boolean;intervalSec:number}|undefined,skipped=false,collectorFailure:Error|undefined,readFailure=false,failReceiptAfterCollector=false,lastError=""
|
|
let lastCollectedAt="2026-10-29T00:00:00.000Z",collectCalls=0,alertCalls=0
|
|
const shared=createManualDataCollection({
|
|
async collectServersRestPing(){collectCalls++;events.push("collector");if(collectorFailure)throw collectorFailure;return {skipped}},
|
|
async readServersRestPingSettings(){events.push("receipt-settings");if(readFailure||failReceiptAfterCollector&&events.includes("global-alert-hook"))throw Error("receipt read uncertain");if(!settings){settings={enabled:false,intervalSec:120};events.push("initialize-settings")}return {lastCollectedAt,lastDurationMs:23,lastError}},
|
|
async collectUptime(){assert.fail("wrong shared operation")},async readUptimeSettings(){return {}},async collectPingGroup(){assert.fail("wrong shared operation")},
|
|
scheduleGlobalAlerts(){alertCalls++;events.push("global-alert-hook")},
|
|
})
|
|
mock.module("../../db/index.js",{namedExports:{pool:{async query(sql:string){queries.push(sql)
|
|
if(sql.startsWith('SELECT id,enabled,routing_endpoint_epoch'))return {rows:structuredClone(catalog)}
|
|
assert.equal(sql,'SELECT enabled,interval_sec AS "intervalSec" FROM servers_api_ping_settings WHERE id=1')
|
|
return {rows:settings?[structuredClone(settings)]:[]}
|
|
}}}})
|
|
mock.module("./store.js",{namedExports:{async effectiveMcpConnection(){return structuredClone(connection)}}})
|
|
mock.module("../../services/config-mutation-policy.js",{namedExports:{async assertVerifiedConfigurationAccess(){events.push("authorize")}}})
|
|
mock.module("../../services/manual-data-collection.js",{namedExports:{manualDataCollection:shared}})
|
|
const {registerManualApiPingActions}=await import("./manual-api-ping-actions.js"),{findMcpService}=await import("./service-registry.js")
|
|
let registration:Parameters<typeof add>|undefined
|
|
registerManualApiPingActions((...args:Parameters<typeof add>)=>{registration=args});assert(registration)
|
|
const [operation,tool,_title,_section,requiredPermission,effect,scope,schema,handlers]=registration,service=findMcpService("servers.api-ping.collect")!
|
|
assert(service)
|
|
async function prepare(){const evidence=await handlers.prepare!({},context),step=evidence.steps[0];assert(step.kind==="service");return {evidence,sealed:step.input}}
|
|
beforeEach(()=>{
|
|
queries.length=0;events.length=0;collectCalls=0;alertCalls=0;skipped=false;collectorFailure=undefined;readFailure=false;failReceiptAfterCollector=false;lastError="";lastCollectedAt="2026-10-29T00:00:00.000Z"
|
|
connection={owner_id:context.connection.owner_id,owner_permissions:[permission],policy:{version:1,permissions:[permission],scope:{allowGlobal:true,serverIds:[1,2,3]}}}
|
|
catalog=epochs.map((routingEndpointEpoch,index)=>({id:index+1,enabled:index!==2,routingEndpointEpoch}));settings={enabled:true,intervalSec:120}
|
|
})
|
|
|
|
test("GLOBAL manual API Ping has REST-parity permission, human plan and honest full alert/outbox footprint",async()=>{
|
|
assert.equal(operation,"servers.api-ping.collect");assert.equal(tool,"mm_api_ping_collect_plan");assert.equal(requiredPermission,permission);assert.equal(effect,"write");assert.equal(scope,"global")
|
|
assert(schema.safeParse({}).success);assert.equal(schema.safeParse({serverId:1}).success,false);assert.equal(service.cancellableDiagnostic,undefined)
|
|
const {evidence,sealed}=await prepare()
|
|
assert.deepEqual(evidence.target,{scope:"global"});assert.equal(evidence.requiresHuman,true);assert.equal(evidence.steps.length,1);assert.equal(evidence.verificationScope,"acknowledgement")
|
|
assert.deepEqual(evidence.objects.filter(value=>value.kind==="server").map(value=>value.serverId),[1,2,3])
|
|
for(const kind of ["servers-api-ping-settings","partition-maintenance","alert-engine","alerts-outbox"])assert(evidence.objects.some(value=>value.kind===kind))
|
|
const warnings=evidence.warnings.join(" ");for(const word of ["GLOBAL ALERT ENGINE","outbox","Telegram","samples","partitions"])assert(warnings.includes(word))
|
|
assert.equal(typeof sealed.beforeFingerprint,"string");assert.equal(queries.length,2);assert.equal(collectCalls,0);assert.equal(alertCalls,0)
|
|
assert(queries.every(sql=>!sql.includes("password")&&!sql.includes("username")&&!sql.includes("last_collected_at")))
|
|
})
|
|
|
|
test("global denial, missing permission and incomplete ALL catalog including disabled refuse before effect",async()=>{
|
|
for(const mode of ["global","permission","owner","missing-disabled"]){
|
|
connection.policy.scope.allowGlobal=true;connection.policy.permissions=[permission];connection.owner_permissions=[permission];connection.policy.scope.serverIds=[1,2,3]
|
|
if(mode==="global")connection.policy.scope.allowGlobal=false
|
|
if(mode==="permission")connection.policy.permissions=[]
|
|
if(mode==="owner")connection.owner_permissions=[]
|
|
if(mode==="missing-disabled")connection.policy.scope.serverIds=[1,2]
|
|
await assert.rejects(prepare());assert.equal(collectCalls,0);assert.equal(alertCalls,0)
|
|
}
|
|
})
|
|
|
|
test("bounded public catalog and nullable settings snapshot never initialize during plan/current",async()=>{
|
|
settings=undefined;const {evidence,sealed}=await prepare();assert.deepEqual(await service.current(sealed),evidence.before);assert.equal(settings,undefined);assert.equal(collectCalls,0);assert(!events.includes("initialize-settings"))
|
|
settings={enabled:true,intervalSec:120};catalog=Array.from({length:1001},(_,index)=>({id:index+1,enabled:true,routingEndpointEpoch:epochs[0]}))
|
|
await assert.rejects(prepare());assert.equal(collectCalls,0);assert.equal(alertCalls,0)
|
|
assert(queries.every(sql=>sql.startsWith("SELECT ")));assert(queries.some(sql=>sql.endsWith("ORDER BY id LIMIT 1001")))
|
|
})
|
|
|
|
test("missing settings initialize ONLY inside approved shared execution; null-to-configured drift invalidates old plan",async()=>{
|
|
settings=undefined;const {sealed}=await prepare();assert.equal(settings,undefined)
|
|
const result=await service.execute(sealed,forward);assert.equal(await service.verify!(sealed,result),true);assert.deepEqual(settings,{enabled:false,intervalSec:120});assert.equal(collectCalls,1);assert.equal(alertCalls,1)
|
|
settings=undefined;const next=await prepare();settings={enabled:true,intervalSec:60}
|
|
await assert.rejects(service.execute(next.sealed,forward));assert.equal(collectCalls,1)
|
|
})
|
|
|
|
test("changing last receipt timestamps does not invalidate stable public configuration fingerprint",async()=>{
|
|
const {evidence,sealed}=await prepare();lastCollectedAt="2026-10-29T00:01:00.000Z"
|
|
assert.deepEqual(await service.current(sealed),evidence.before)
|
|
const result=await service.execute(sealed,forward) as {acknowledged:boolean;lastCollectedAt:string;skipped:boolean}
|
|
assert.equal(result.acknowledged,true);assert.equal(result.lastCollectedAt,lastCollectedAt);assert.equal(result.skipped,false)
|
|
assert.equal(collectCalls,1);assert.equal(alertCalls,1)
|
|
})
|
|
|
|
test("one shared executor call preserves settings receipt and global alert hook; summary strips errors and claims no delivery",async()=>{
|
|
const {sealed}=await prepare();lastError="PRIVATE_NATIVE_PASSWORD_OR_STACK"
|
|
const result=await service.execute(sealed,forward)
|
|
assert.deepEqual(result,{acknowledged:true,skipped:false,lastCollectedAt,lastDurationMs:23,lastError:true,globalAlertHookRequested:true,alertDeliveryConfirmed:false})
|
|
assert.equal(collectCalls,1);assert.equal(alertCalls,1);assert.equal(events.filter(value=>value==="collector").length,1)
|
|
assert.deepEqual(events.slice(-4),["receipt-settings","collector","global-alert-hook","receipt-settings"])
|
|
assert.equal(JSON.stringify(result).includes(lastError),false);assert.equal(await service.verify!(sealed,result),true)
|
|
assert.deepEqual(await service.reconcile!(sealed,async()=>{}),{matchesDesiredState:false,matchesOriginalState:false});assert.equal(collectCalls,1)
|
|
})
|
|
|
|
test("ACTUAL shared skipped snapshot still invokes global alert hook but MCP reports busy without collected success",async()=>{
|
|
const {sealed}=await prepare();skipped=true
|
|
await assert.rejects(service.execute(sealed,forward),(error:unknown)=>!!error&&typeof error==="object"&&"code"in error&&error.code==="COLLECTOR_BUSY")
|
|
assert.equal(collectCalls,1);assert.equal(alertCalls,1);assert.equal(await service.verify!(sealed,{acknowledged:true,skipped:true}),false)
|
|
})
|
|
|
|
test("scope revocation/catalog/settings/endpoint drift refuses before shared executor; recovery cannot dispatch",async()=>{
|
|
const {sealed}=await prepare()
|
|
await assert.rejects(service.execute(sealed,{phase:"recovery",operationId:forward.operationId}));assert.equal(collectCalls,0)
|
|
connection.policy.scope.serverIds=[1,2];await assert.rejects(service.execute(sealed,forward));assert.equal(collectCalls,0)
|
|
connection.policy.scope.serverIds=[1,2,3];catalog[0].routingEndpointEpoch=randomUUID();await assert.rejects(service.execute(sealed,forward));assert.equal(collectCalls,0)
|
|
catalog[0].routingEndpointEpoch=epochs[0];settings!.intervalSec=121;await assert.rejects(service.execute(sealed,forward));assert.equal(collectCalls,0)
|
|
})
|
|
|
|
test("collector or receipt failure is never automatically replayed, including after alert hook already ran",async()=>{
|
|
const {sealed}=await prepare();collectorFailure=Error("collector uncertain")
|
|
await assert.rejects(service.execute(sealed,forward),error=>error===collectorFailure);assert.equal(collectCalls,1);assert.equal(alertCalls,0)
|
|
collectorFailure=undefined;readFailure=true
|
|
// Shared pre-read fails before this attempt reaches the collector.
|
|
await assert.rejects(service.execute(sealed,forward));assert.equal(collectCalls,1);assert.equal(alertCalls,0)
|
|
readFailure=false;failReceiptAfterCollector=true
|
|
await assert.rejects(service.execute(sealed,forward));assert.equal(collectCalls,2);assert.equal(alertCalls,1)
|
|
await service.reconcile!(sealed,async()=>{});assert.equal(collectCalls,2);assert.equal(alertCalls,1)
|
|
})
|