Files
MikrotikManager/backend/src/db/controlled-migrations.sql.test.ts
T

108 lines
8.4 KiB
TypeScript

import assert from "node:assert/strict"
import { createHash, randomUUID } from "node:crypto"
import { basename, dirname, resolve } from "node:path"
assert.equal(process.env.MMAPP_OWN_CONTROLLED_MIGRATIONS, "true")
const url = new URL(process.env.DATABASE_URL ?? "")
assert.equal(url.hostname, "127.0.0.1"); assert.equal(url.pathname, "/postgres")
assert(process.env.MCP_STATE_DIR && basename(dirname(resolve(process.env.MCP_STATE_DIR))).startsWith("mm-mcp-test-"))
const { Pool } = await import("pg")
const { pool, closePool } = await import("./index.js")
const { applySqlMigrations } = await import("./migrate.js")
const { executeControlledSqlMigrations } = await import("./controlled-migrations.js")
const { initialDatabaseSchemaControlState } = await import("./database-schema-control-model.js")
const { MIGRATION_MANIFEST } = await import("./migration-manifest.js")
const { SYSTEM_DATABASE_OPERATION_LOCK, withOperationLock } = await import("./operation-lock.js")
const originalConnect = pool.connect.bind(pool), databases: InstanceType<typeof Pool>[] = [], names: string[] = [], cases: string[] = []
const hashes = new Set(MIGRATION_MANIFEST.map(pin => pin.sha256))
async function database(seed = true) {
const name = "mm_dispatch_" + randomUUID().replaceAll("-", "")
assert(/^mm_dispatch_[a-f0-9]{32}$/.test(name))
await pool.query('CREATE DATABASE "' + name + '" TEMPLATE template0')
const target = new URL(url); target.pathname = "/" + name
const connection = new Pool({ connectionString: target.toString(), max: 6 }); databases.push(connection); names.push(name)
if (seed) {
await connection.query("CREATE SCHEMA mmapp_control; CREATE TABLE mmapp_control.database_schema_state(id smallint PRIMARY KEY CHECK(id=1),revision bigint NOT NULL CHECK(revision>=0),state jsonb NOT NULL); CREATE TABLE mmapp_control.database_schema_intents(id uuid PRIMARY KEY,intent jsonb NOT NULL,terminal jsonb)")
await connection.query("INSERT INTO mmapp_control.database_schema_state VALUES(1,0,$1::jsonb)", [JSON.stringify(initialDatabaseSchemaControlState())])
}
return connection
}
type Fault = "none" | "application-commit" | "terminal-commit"
const requestAdmissionSql = "SELECT pg_catalog.pg_try_advisory_xact_lock_shared($1::bigint) AS acquired"
async function run(connection: InstanceType<typeof Pool>, fault: Fault = "none") {
const files: string[] = []; let ordinal = 0, controlCommits = 0
// Owned fixture instrumentation at the fixed module's actual Pool boundary.
// Every SQL statement still executes on a real checked-out private backend.
pool.connect = (async () => {
const client = await connection.connect(), index = ++ordinal, originalQuery = client.query, release = client.release.bind(client), query = originalQuery.bind(client)
client.release = (destroy?: boolean) => { client.query = originalQuery; release(destroy) }
client.query = (async (text: string, values?: unknown[]) => {
const digest = createHash("sha256").update(text).digest("hex")
if (hashes.has(digest)) {
files.push(digest)
if (files.length === 1 || files.length === MIGRATION_MANIFEST.length) {
const { rows } = await connection.query(requestAdmissionSql, [SYSTEM_DATABASE_OPERATION_LOCK])
assert.equal(rows[0]?.acquired, false, "Migration SQL must exclude MCP request writes")
}
}
const result = await query(text, values)
if (index === 2 && text === "COMMIT" && fault === "application-commit") throw Error("Owned application COMMIT ACK lost")
if (index === 1 && text === "COMMIT" && ++controlCommits === 4 && fault === "terminal-commit") throw Error("Owned terminal publication COMMIT ACK lost")
return result
}) as typeof client.query
return client
}) as typeof pool.connect
try { return { result: await executeControlledSqlMigrations(), files, failed: false } }
catch { return { files, failed: true } }
finally { pool.connect = originalConnect as typeof pool.connect }
}
try {
await applySqlMigrations(pool)
const missing = await database(false), noControl = await run(missing)
assert(noControl.failed); assert.equal(noControl.files.length, 0)
cases.push("missing external control refuses before application migration SQL")
const clean = await database()
await withOperationLock(() => clean.connect(), SYSTEM_DATABASE_OPERATION_LOCK, async () => {
const blocked = await run(clean)
assert(blocked.failed)
assert.deepEqual(blocked.files, [])
assert.equal((await clean.query("SELECT count(*)::int AS n FROM mmapp_control.database_schema_intents")).rows[0].n, 0)
})
cases.push("live backup/restore lease refuses controlled migration before DDL or intent")
const initial = await run(clean)
assert(!initial.failed); assert.equal(initial.result?.completedFiles, MIGRATION_MANIFEST.length); assert.equal(initial.result?.ready, false)
assert.deepEqual(initial.files, MIGRATION_MANIFEST.map(pin => pin.sha256))
assert.equal((await clean.query(requestAdmissionSql, [SYSTEM_DATABASE_OPERATION_LOCK])).rows[0].acquired, true)
assert.equal((await clean.query("SELECT count(*)::int AS n FROM mmapp_control.database_schema_intents WHERE terminal->>'outcome'='observed-success'")).rows[0].n, MIGRATION_MANIFEST.length)
cases.push("all current exact pinned files execute once with genuine keyed ACK receipts; READY remains closed")
const repeated = await run(clean); assert(!repeated.failed); assert.equal(repeated.files.length, 0)
cases.push("fresh owner verifies complete known prefix and executes no file twice")
const legacy = await database(); await legacy.query("CREATE TABLE public.unmarked(id integer)")
const refused = await run(legacy); assert(refused.failed); assert.equal(refused.files.length, 0)
cases.push("unmarked legacy application objects are not treated as a fresh database")
const unknown = await database(), lostFile = await run(unknown, "application-commit")
assert(lostFile.failed); assert.equal(lostFile.files.length, 1)
assert.equal((await unknown.query("SELECT terminal->>'outcome' AS outcome FROM mmapp_control.database_schema_intents")).rows[0].outcome, "interrupted-unknown")
const unknownRepeat = await run(unknown); assert(unknownRepeat.failed); assert.equal(unknownRepeat.files.length, 0)
cases.push("actual application COMMIT with lost ACK becomes unknown and is never replayed by fresh owner")
const prefix = await database(), lostTerminal = await run(prefix, "terminal-commit")
assert(lostTerminal.failed); assert.equal(lostTerminal.files.length, 1)
assert.equal((await prefix.query("SELECT terminal->>'outcome' AS outcome FROM mmapp_control.database_schema_intents")).rows[0].outcome, "observed-success")
const resumed = await run(prefix); assert(!resumed.failed); assert.equal(resumed.files.length, MIGRATION_MANIFEST.length - 1)
assert.deepEqual(resumed.files, MIGRATION_MANIFEST.slice(1).map(pin => pin.sha256))
cases.push("lost terminal publication ACK preserves genuine known file ACK; fresh invocation resumes only remaining manifest files without replay")
const badMarker = await database(), markerPrefix = await run(badMarker, "terminal-commit"); assert(markerPrefix.failed)
await badMarker.query("DELETE FROM public.schema_migrations")
const markerDrift = await run(badMarker); assert(markerDrift.failed); assert.equal(markerDrift.files.length, 0)
cases.push("marker and protected history mismatch refuses before any next file")
const tampered = await database(), tamperPrefix = await run(tampered, "terminal-commit"); assert(tamperPrefix.failed)
await tampered.query("UPDATE mmapp_control.database_schema_intents SET terminal=jsonb_set(terminal,'{observationSha256}',to_jsonb($1::text))", ["f".repeat(64)])
await tampered.query("UPDATE mmapp_control.database_schema_state SET state=jsonb_set(state,'{terminal,observationSha256}',to_jsonb($1::text))", ["f".repeat(64)])
const forged = await run(tampered); assert(forged.failed); assert.equal(forged.files.length, 0)
cases.push("matching singleton/history plain-hash forgery cannot replace fixed server-keyed file receipt")
console.log("Owned controlled migration SQL:", JSON.stringify({ cases: cases.length, names: cases, databases: names.length, actualSql: true, fixedSourceFiles: MIGRATION_MANIFEST.length, fullRuns: 2, actualApplicationAckLosses: 1, actualTerminalPublicationAckLosses: 3, readyAuthorized: false, startupWired: false, productionDatabaseTouched: false }))
} finally {
pool.connect = originalConnect as typeof pool.connect
for (const connection of databases) await connection.end()
await closePool()
}