56 lines
5.5 KiB
TypeScript
56 lines
5.5 KiB
TypeScript
import assert from "node:assert/strict"
|
|
import { randomUUID } from "node:crypto"
|
|
import { pool } from "../../db/index.js"
|
|
import { MikrotikClient } from "../../services/mikrotik.js"
|
|
import type { ActionContext } from "./action-types.js"
|
|
|
|
const priorQuery = pool.query, priorConnect = pool.connect, priorNative = MikrotikClient.fromServer, priorFetch = globalThis.fetch
|
|
let sql = 0, native = 0, network = 0
|
|
pool.query = (() => { sql++; throw Error("Registration must not query SQL") }) as never
|
|
pool.connect = (() => { sql++; throw Error("Registration must not acquire a backend") }) as never
|
|
MikrotikClient.fromServer = (() => { native++; throw Error("Registration must not open a router") }) as never
|
|
globalThis.fetch = (async () => { network++; throw Error("Registration must not perform network I/O") }) as typeof fetch
|
|
try {
|
|
const { findAction, findActionByOperation, listActions } = await import("./actions.js")
|
|
const { findMcpService } = await import("./service-registry.js")
|
|
const { listMcpOperations } = await import("./registry.js")
|
|
const { SERVER_PROBE_MCP_OPERATION_VERSION } = await import("./server-probe-actions.js")
|
|
const { SERVER_PROBE_CANCEL_OPERATION } = await import("./server-probe-registration.js")
|
|
const run = findAction("mm_server_probe_plan"), read = findAction("mm_server_probe_receipt_get"), cancel = findAction("mm_server_probe_cancel")
|
|
assert.equal(run.operation.id, "servers.probes.run"); assert.equal(run.operation.version, SERVER_PROBE_MCP_OPERATION_VERSION)
|
|
assert.equal(run.operation.effect, "diagnostic"); assert.equal(run.operation.scope, "servers"); assert.equal(run.operation.implementation, "available")
|
|
assert.deepEqual(run.operation.requiredPermissions, ["mm:servers:write"]); assert.equal(run.operation.annotations.readOnlyHint, false)
|
|
assert(run.prepare); assert(!run.read); assert.equal(findActionByOperation(run.operation.id), run)
|
|
assert.equal(read.operation.id, "servers.probes.receipt.read"); assert.equal(read.operation.effect, "read"); assert.equal(read.operation.scope, "servers")
|
|
assert.deepEqual(read.operation.requiredPermissions, ["mm:servers:read"]); assert(read.read); assert(!read.prepare)
|
|
assert.equal(cancel.operation.id, SERVER_PROBE_CANCEL_OPERATION); assert.equal(cancel.operation.effect, "write")
|
|
assert.equal(cancel.operation.scope, "connection"); assert.deepEqual(cancel.operation.requiredPermissions, ["mm:servers:write"])
|
|
assert.equal(cancel.operation.annotations.readOnlyHint, false); assert(cancel.read); assert(!cancel.prepare, "Stop requests must execute immediately without another approval plan")
|
|
const service = findMcpService(run.operation.id)
|
|
assert(service); assert.equal(service.cancellableDiagnostic, true)
|
|
for (const method of ["current", "execute", "verify", "reconcile", "diagnosticIdentity"] as const) assert.equal(typeof service[method], "function")
|
|
assert.equal(findMcpService(read.operation.id), undefined); assert.equal(findMcpService(cancel.operation.id), undefined)
|
|
const ids = [run.operation.id, read.operation.id, cancel.operation.id]
|
|
assert.equal(listActions().filter(action => ids.includes(action.operation.id)).length, 3)
|
|
assert.equal(listMcpOperations().filter(operation => ids.includes(operation.id)).length, 3)
|
|
for (const action of [run, read, cancel]) assert.equal(listMcpOperations().find(value => value.id === action.operation.id)?.implementation, "available")
|
|
|
|
assert(run.schema.safeParse({ serverId: 1, request: { tool: "ping", target: "127.0.0.1", pingCount: 1 } }).success)
|
|
assert(!run.schema.safeParse({ serverId: 1, request: { tool: "ping", target: "127.0.0.1" }, journal: {}, sql: "SELECT 1" }).success)
|
|
assert(!run.schema.safeParse({ serverId: 1, request: { tool: "command", command: "/system/reboot" } }).success)
|
|
assert(read.schema.safeParse({ operationId: randomUUID(), receiptId: randomUUID(), page: 0 }).success)
|
|
assert(!read.schema.safeParse({ operationId: randomUUID(), receiptId: randomUUID(), page: 16 }).success)
|
|
assert(!read.schema.safeParse({ operationId: randomUUID(), receiptId: randomUUID(), page: 0, credentialId: randomUUID() }).success)
|
|
assert(cancel.schema.safeParse({ operationId: randomUUID() }).success)
|
|
assert(!cancel.schema.safeParse({ operationId: randomUUID(), ownerId: "forged", source: {}, principal: {} }).success)
|
|
assert(!cancel.schema.safeParse({ operationId: "not-an-operation" }).success)
|
|
const context = { principal: { connectionId: randomUUID(), credentialId: randomUUID(), credentialExpiresAt: new Date(Date.now() + 60000).toISOString() }, connection: {} } as ActionContext
|
|
await assert.rejects(run.prepare({}, context)); await assert.rejects(read.read({}, context)); await assert.rejects(cancel.read({}, context))
|
|
await assert.rejects(service.current({})); await assert.rejects(service.execute({}, { operationId: randomUUID(), phase: "recovery" }))
|
|
assert.equal(await service.verify!({}, {}), false)
|
|
const controller = new AbortController(); controller.abort()
|
|
await assert.rejects(async () => run.target({ serverId: 1, request: { tool: "ping", target: "127.0.0.1" } }, { ...context, signal: controller.signal }), { code: "READ_CANCELLED" })
|
|
assert.deepEqual({ sql, native, network }, { sql: 0, native: 0, network: 0 })
|
|
console.log("Public server-probe registration: three real descriptors and fixed storage service; immediate durable stop has write metadata; strict source/native escape rejection; inert construction and invalid/pre-aborted input perform no I/O")
|
|
} finally { pool.query = priorQuery; pool.connect = priorConnect; MikrotikClient.fromServer = priorNative; globalThis.fetch = priorFetch }
|