Files
MikrotikManager/backend/src/modules/mcp/manual-api-ping-actions.test.ts
T

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)
})