108 lines
8.4 KiB
TypeScript
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()
|
|
}
|