156 lines
10 KiB
TypeScript
156 lines
10 KiB
TypeScript
/** Component orchestration tests with import doubles, not full RT-2 acceptance. */
|
|
import assert from "node:assert/strict"
|
|
import { readFile } from "node:fs/promises"
|
|
import { test } from "node:test"
|
|
import { runInNewContext } from "node:vm"
|
|
import ts from "typescript"
|
|
import type { executeReservedRoutingStep } from "./routing-reserved-step.js"
|
|
import type { RoutingReservedNetworkSession } from "./service-registry.js"
|
|
|
|
const source = await readFile(new URL("./routing-reserved-step.ts", import.meta.url), "utf8")
|
|
const compiled = ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 } }).outputText
|
|
|
|
function fixture(mode: "passed" | "passed-publish-revoked" | "failed" | "forward-error" | "forward-unknown" | "forward-quarantine-error" | "outcome-error" | "inverse-error" | "revoked" | "wrong-origin" | "bad-receipt" | "missing-network" = "failed") {
|
|
const events: string[] = [], allocation = Object.freeze({ kind: "routing-reserved-inverse-allocation" })
|
|
const principal = { connectionId: "owned-connection", credentialId: "owned-credential", credentialExpiresAt: "2026-10-29T01:00:00Z" }
|
|
const forwardResult = { configurationVerified: true, postProbeStatus: mode === "passed" ? "passed" : "failed", secret: "private-forward" }
|
|
const recoveryResult = { outcome: "recovered", nativeWrites: 1, configurationVerified: true, controlProbeVerified: true, receiptId: "inverse-receipt", recoveryCheckpointProof: "verified-proof" }
|
|
const counts = { forward: 0, outcome: 0, inverse: 0, access: 0 }
|
|
let active = true
|
|
let sessionCloses = 0
|
|
const session = { readBudget: () => ({ closed: sessionCloses > 0 }), close: () => { sessionCloses++ } } as RoutingReservedNetworkSession
|
|
const origin = Object.freeze({}), metadata = { operationId: "owned-source", operationName: "routing.community.switch", operationVersion: 7,
|
|
serviceName: "routing.community.scoped", stepIndex: 0, phase: "forward", principal, serviceInput: { receiptId: "source-receipt" } }
|
|
class McpError extends Error {
|
|
constructor(readonly code: string, message: string, readonly statusCode: number) { super(message) }
|
|
}
|
|
const original = mode === "forward-unknown" || mode === "forward-quarantine-error"
|
|
? new McpError("MUTATION_OUTCOME_UNKNOWN", "owned forward outcome unknown", 409) : Error("owned failure")
|
|
const modules: Record<string, unknown> = {
|
|
"../../services/config-mutation-policy.js": { captureVerifiedMcpServiceExecution: async () => origin, inspectVerifiedMcpServiceExecution: async (token: unknown) => {
|
|
assert.equal(token, origin)
|
|
events.push("access"); counts.access++
|
|
if (!active || mode === "revoked" && counts.access === 3) throw original
|
|
return mode === "wrong-origin" ? { ...metadata, stepIndex: 1 } : metadata
|
|
} },
|
|
"./routing-reservation-store.js": { createRoutingReservationStore: () => ({ recordForwardOutcome: async (id: string) => {
|
|
events.push("outcome"); counts.outcome++; assert.equal(active, true); assert.equal(id, "owned-reservation")
|
|
if (mode === "outcome-error") throw original
|
|
if (mode === "passed-publish-revoked") active = false
|
|
return { allocation: mode === "passed" || mode === "passed-publish-revoked" ? undefined : allocation }
|
|
}, markUnknown: async (id: string, lane: string) => {
|
|
assert.equal(id, "owned-reservation"); assert.equal(lane, "forward"); events.push("quarantine")
|
|
if (mode === "forward-quarantine-error") throw Error("owned quarantine acknowledgement lost")
|
|
}, read: async (id: string, actor: unknown) => {
|
|
assert.equal(id, "owned-reservation"); assert.equal(actor, principal); events.push("ledger")
|
|
return { sourceOperationId: "owned-source", state: { forward: "spent", inverse: "spent", outcome: { status: "failed", configurationProof: "config-proof", networkProof: "network-proof" } }, deadline: "deadline", sharedSlotQuarantined: false }
|
|
} }) },
|
|
"./routing-community-scoped-recovery.js": { executeReservedScopedRecovery: async (capability: unknown, expected: { sourceOperationId: string; principal: unknown; networkSession: unknown }) => {
|
|
events.push("inverse"); counts.inverse++; assert.equal(active, true)
|
|
assert.equal(capability, allocation, "Pass the exact process-private allocation object without cloning/JSON")
|
|
assert.equal(expected.sourceOperationId, "owned-source"); assert.equal(expected.principal, principal)
|
|
assert.equal(expected.networkSession, session); assert.equal(sessionCloses, 0)
|
|
if (mode === "inverse-error") throw original
|
|
return recoveryResult
|
|
}, validateReservedInverseVerified: async (_row: unknown, expected: unknown) => {
|
|
events.push("receipt")
|
|
assert.deepEqual(JSON.parse(JSON.stringify(expected)), { reservationId: "owned-reservation", sourceOperationId: "owned-source", sourceReceiptId: "source-receipt", inverseReceiptId: "inverse-receipt", deadline: "deadline", configurationProof: "config-proof", networkProof: "network-proof" })
|
|
return mode !== "bad-receipt"
|
|
} },
|
|
"../../db/index.js": { pool: { query: async (_sql: string, args: unknown[]) => {
|
|
assert.deepEqual(Array.from(args), ["owned-source", "owned-reservation"]); events.push("slot")
|
|
return { rows: [{ state: "verified", verified_proof: "verified-proof" }] }
|
|
} } },
|
|
"./security.js": { McpError, fingerprint: (value: unknown) => JSON.stringify(value) },
|
|
}
|
|
const exports: Record<string, unknown> = {}
|
|
runInNewContext(compiled, { exports, require: (id: string) => { assert(id in modules, id); return modules[id] } })
|
|
const execute = exports.executeReservedRoutingStep as typeof executeReservedRoutingStep
|
|
const branded = exports.hasConfirmedReservedRoutingForward as (error: unknown) => boolean
|
|
const run = () => execute({ reservationId: "owned-reservation", sourceOperationId: "owned-source", principal,
|
|
forward: async retain => { events.push("forward"); counts.forward++; assert.equal(active, true); if (mode === "forward-error" || mode === "forward-unknown" || mode === "forward-quarantine-error") throw original; if (mode !== "missing-network") retain(session); return forwardResult } })
|
|
return { run, branded, events, counts, forwardResult, recoveryResult, original, sessionCloses: () => sessionCloses, close: () => { active = false } }
|
|
}
|
|
|
|
test("component: successful forward publishes once inside original scope and never invokes inverse", async () => {
|
|
const f = fixture("passed"), result = await f.run()
|
|
assert.equal(result.kind, "forwardPassed"); assert.equal(result.forwardResult, f.forwardResult)
|
|
assert.deepEqual(f.events, ["access", "forward", "access", "outcome", "access"])
|
|
assert.deepEqual(f.counts, { forward: 1, outcome: 1, inverse: 0, access: 3 })
|
|
assert.equal(f.sessionCloses(), 1)
|
|
})
|
|
|
|
test("component: failed signed outcome hands exact private capability to inverse before caller receives result", async () => {
|
|
const f = fixture(), result = await f.run()
|
|
assert.equal(result.kind, "recovered"); assert.equal(result.forwardResult, f.forwardResult)
|
|
if (result.kind === "recovered") assert.equal(result.recoveryResult, f.recoveryResult)
|
|
assert.equal(result.forwardResult.postProbeStatus, "failed", "Recovery must not relabel forward as verified")
|
|
assert.deepEqual(f.events, ["access", "forward", "access", "outcome", "access", "inverse", "access", "ledger", "slot", "receipt", "access"])
|
|
assert.equal(f.sessionCloses(), 1)
|
|
})
|
|
|
|
test("component: inverse cannot start without the original session", async () => {
|
|
const f = fixture("missing-network")
|
|
await assert.rejects(f.run(), error => f.branded(error))
|
|
assert.equal(f.counts.inverse, 0)
|
|
})
|
|
|
|
test("component: completed original verified scope refuses before forward", async () => {
|
|
const f = fixture(); f.close()
|
|
await assert.rejects(f.run(), error => error === f.original)
|
|
assert.deepEqual(f.counts, { forward: 0, outcome: 0, inverse: 0, access: 1 })
|
|
})
|
|
|
|
test("component: unclassified forward error propagates without changing the reservation", async () => {
|
|
const f = fixture("forward-error")
|
|
await assert.rejects(f.run(), error => error === f.original)
|
|
assert.deepEqual(f.counts, { forward: 1, outcome: 0, inverse: 0, access: 1 })
|
|
})
|
|
|
|
test("component: unknown forward attempts quarantine once and preserves the original failure", async () => {
|
|
for (const mode of ["forward-unknown", "forward-quarantine-error"] as const) {
|
|
const f = fixture(mode)
|
|
await assert.rejects(f.run(), error => error === f.original)
|
|
assert.deepEqual(f.events, ["access", "forward", "quarantine"])
|
|
assert.deepEqual(f.counts, { forward: 1, outcome: 0, inverse: 0, access: 1 })
|
|
}
|
|
})
|
|
|
|
for (const mode of ["outcome-error", "inverse-error", "revoked"] as const) test(`component: ${mode} preserves private forward progress, fails unknown and never retries`, async () => {
|
|
const f = fixture(mode)
|
|
await assert.rejects(f.run(), (error: unknown) => {
|
|
const value = error as { code: string }
|
|
assert.equal(value.code, "MUTATION_OUTCOME_UNKNOWN")
|
|
assert.equal(f.branded(error), true)
|
|
assert.equal(f.branded(JSON.parse(JSON.stringify(error))), false)
|
|
assert.equal(JSON.stringify(error).includes("private-forward"), false)
|
|
return true
|
|
})
|
|
assert.equal(f.counts.forward, 1); assert.equal(f.counts.outcome, 1)
|
|
assert.equal(f.counts.inverse, mode === "inverse-error" ? 1 : 0)
|
|
assert.equal(f.sessionCloses(), 1)
|
|
})
|
|
|
|
test("component: another operation/service step cannot use an active verified scope", async () => {
|
|
const f = fixture("wrong-origin")
|
|
await assert.rejects(f.run(), /Исходный service step/)
|
|
assert.equal(f.counts.forward, 0); assert.equal(f.counts.outcome, 0)
|
|
})
|
|
|
|
test("component: returned recovery object cannot replace authenticated durable receipts", async () => {
|
|
const f = fixture("bad-receipt")
|
|
await assert.rejects(f.run(), error => f.branded(error))
|
|
assert.equal(f.counts.inverse, 1); assert.equal(f.counts.forward, 1)
|
|
})
|
|
|
|
test("component: passed outcome publication cannot outlive original scope or return forwardPassed", async () => {
|
|
const f = fixture("passed-publish-revoked")
|
|
await assert.rejects(f.run(), error => {
|
|
assert.equal(f.branded(error), true, "Actual forward progress survives late scope revocation privately")
|
|
assert.equal((error as { code: string }).code, "MUTATION_OUTCOME_UNKNOWN")
|
|
return true
|
|
})
|
|
assert.deepEqual(f.events, ["access", "forward", "access", "outcome", "access"])
|
|
assert.deepEqual(f.counts, { forward: 1, outcome: 1, inverse: 0, access: 3 })
|
|
})
|