Files
MikrotikManager/backend/src/services/ospf-template-cost-write.test.ts
T

73 lines
5.9 KiB
TypeScript

import assert from "node:assert/strict"
import { writeOspfTemplateCost, OspfCostWriteError, ospfCostConnectionProof } from "./ospf-template-cost-write.js"
import { MikrotikClient, MikrotikError } from "./mikrotik.js"
import { mkdtemp, rm } from "node:fs/promises"
import { tmpdir } from "node:os"
import { join, resolve, sep, basename } from "node:path"
const baseline = [{ ".id": "*1", interfaces: "gre-one", cost: "10", disabled: "false", "auth-key": "NEVER_OSPF_AUTH", opaque: "preserve" }, { ".id": "*2", interfaces: "gre-two", cost: "30", disabled: "false" }]
let rows = structuredClone(baseline), writes = 0, reads = 0, mode = "normal"
const dependencies = { expectedCost: 10, read: async () => {
reads++
if (mode === "lost-read" && writes) throw new MikrotikError(401, "/routing/ospf/interface-template", "read refused")
if (mode === "malformed" && writes) return { error: "invalid" }
return structuredClone(rows)
}, write: async (id: string, cost: number) => {
writes++
if (mode === "lost-write") throw new Error("Lost PATCH acknowledgement")
if (mode === "rejected-write") throw new MikrotikError(403, "/routing/ospf/interface-template", "refused")
if (mode !== "ignored" && !(mode === "second-ignored" && id === "*2")) rows.find(row => row[".id"] === id)!.cost = String(cost)
if (mode === "foreign") rows[1].interfaces = "unexpected"
if (mode === "secret") rows[0]["auth-key"] = "changed"
if (mode === "added") rows.push({ ...baseline[1], ".id": "*3" })
if (mode === "reordered") rows.reverse()
} }
const reset = (next = "normal") => { rows = structuredClone(baseline); reads = 0; writes = 0; mode = next }
assert.deepEqual(await writeOspfTemplateCost("*1", 20, dependencies), { id: "*1", from: 10, to: 20, changed: true })
assert.equal(writes, 1); assert.equal(rows[0]["auth-key"], "NEVER_OSPF_AUTH")
reset(); assert.equal((await writeOspfTemplateCost("*1", 10, dependencies)).changed, false); assert.equal(writes, 0)
for (const next of ["ignored", "foreign", "secret", "added", "reordered", "lost-read", "malformed"]) {
reset(next)
await assert.rejects(writeOspfTemplateCost("*1", 20, dependencies), error => error instanceof OspfCostWriteError && error.writeAttempted && !error.message.includes("NEVER_OSPF"))
assert.equal(writes, 1, "Unconfirmed write must not be replayed")
}
reset(); rows.reverse()
assert.deepEqual(await writeOspfTemplateCost("*1", 20, dependencies), { id: "*1", from: 10, to: 20, changed: true })
assert.deepEqual(rows.map(row => row[".id"]), ["*2", "*1"], "The native order is preserved even when it differs from ID sorting")
reset()
await assert.rejects(writeOspfTemplateCost("*1", 10, {
expectedCost: 10,
read: async () => ++reads === 1 ? structuredClone(rows) : structuredClone(rows).reverse(),
write: async () => { writes++ },
}), error => error instanceof OspfCostWriteError && !error.writeAttempted)
assert.equal(writes, 0, "A no-op with changed listing order is refused without issuing a PATCH")
reset("lost-write"); await assert.rejects(writeOspfTemplateCost("*1", 20, dependencies), /Lost PATCH/); assert.equal(writes, 1); assert.equal(reads, 1)
reset("rejected-write"); await assert.rejects(writeOspfTemplateCost("*1", 20, dependencies), error => error instanceof MikrotikError && error.statusCode === 403); assert.equal(writes, 1)
for (const [id, cost] of [["../1", 20], ["*1", 0], ["*1", 65536], ["*1", NaN]] as const) { reset(); await assert.rejects(writeOspfTemplateCost(id, cost, dependencies)); assert.equal(reads, 0); assert.equal(writes, 0) }
reset(); await assert.rejects(writeOspfTemplateCost("*1", 20, { ...dependencies, expectedCost: 11 }), error => error instanceof OspfCostWriteError && !error.writeAttempted); assert.equal(writes, 0)
reset(); rows.push({ ...baseline[0] }); await assert.rejects(writeOspfTemplateCost("*1", 20, dependencies)); assert.equal(writes, 0)
reset("second-ignored")
await assert.rejects(async () => { for (const [id, cost] of [["*1", 20], ["*2", 40], ["*1", 50]] as const) await writeOspfTemplateCost(id, cost, { ...dependencies, expectedCost: undefined }) })
assert.equal(writes, 2); assert.equal(rows[0].cost, "20"); assert.equal(rows[1].cost, "30")
const unidentifiedClient = new MikrotikClient({ host: "127.0.0.1", port: 1, username: "fixture", password: "fixture", useSsl: false, verifySsl: false })
let forbiddenReads = 0
unidentifiedClient.get = async () => { forbiddenReads++; throw new Error("Native read forbidden") }
await assert.rejects(unidentifiedClient.setOspfInterfaceTemplateCost("*1", 20, 10, "foreign-proof"), error => error instanceof OspfCostWriteError && !error.writeAttempted)
assert.equal(forbiddenReads, 0, "A source proof requires a bound server before any native read")
const privateState = await mkdtemp(join(tmpdir(), "mm-ospf-proof-")), previousState = process.env.MCP_STATE_DIR
try {
process.env.MCP_STATE_DIR = privateState
const source = { host: "192.0.2.1", port: 80, username: "fixture", password: "NEVER_OSPF_PROOF", useSsl: false, verifySsl: false }
const proof = await ospfCostConnectionProof(1, source)
assert.equal(proof, await ospfCostConnectionProof(1, { ...source }))
assert.match(proof, /^[a-f0-9]{64}$/); assert.ok(!proof.includes(source.password))
assert.notEqual(proof, await ospfCostConnectionProof(2, source))
for (const patch of [{ host: "192.0.2.2" }, { port: 443 }, { username: "other" }, { password: "changed" }, { useSsl: true }, { verifySsl: true }]) assert.notEqual(proof, await ospfCostConnectionProof(1, { ...source, ...patch }))
} finally {
if (previousState === undefined) delete process.env.MCP_STATE_DIR; else process.env.MCP_STATE_DIR = previousState
if (!resolve(privateState).startsWith(resolve(tmpdir()) + sep) || !basename(privateState).startsWith("mm-ospf-proof-")) throw new Error("Unsafe temporary proof path")
await rm(privateState, { recursive: true, force: true })
}
console.log('OSPF cost pure model: expected value, preserved fields, ignored/lost/rejected stop and no replay')