@xenon-device-management/xenon 2.15.0 → 2.17.0

package/lib/test/unit/run-migrations-database.spec.js

@@ -0,0 +1,440 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const client_1 = require("../../src/generated/client");
+const config_1 = require("../../src/config");
+const run_migrations_1 = require("../../src/scripts/run-migrations");
+// The startup schema step, run for real: the prisma CLI from node_modules
+// against scratch SQLite files, never the server's own database.
+//
+// Through 2.15.0 the step chose its command from `databaseProvider` alone:
+// `migrate deploy` for postgresql, `db push` for anything else. A database
+// Xenon made with the default setting (or `npm run db:migrate`) has tables and
+// no migration history, and `migrate deploy` refuses one of those (P3005), so a
+// Xenon Control profile set to postgresql stopped the server. The default
+// setting, in turn, ran `db push` on a database that keeps a migration history,
+// moving its tables past that history, after which `migrate deploy` failed on
+// the migration it had already applied (P3018) and recorded it as failed.
+// The database now decides.
+const ROOT = path_1.default.resolve(__dirname, '../..');
+const PRISMA = path_1.default.join(ROOT, 'node_modules', '.bin', 'prisma');
+const SCHEMA = path_1.default.join(ROOT, 'prisma', 'schema.prisma');
+const MIGRATIONS = path_1.default.join(ROOT, 'prisma', 'migrations');
+const LOCAL_MIGRATIONS = fs_1.default
+    .readdirSync(MIGRATIONS)
+    .filter((name) => fs_1.default.existsSync(path_1.default.join(MIGRATIONS, name, 'migration.sql')))
+    .sort();
+function prismaCli(args, file, input) {
+    return (0, child_process_1.execFileSync)(PRISMA, args, {
+        cwd: ROOT,
+        env: Object.assign(Object.assign({}, process.env), { DATABASE_URL: `file:${file}`, CHECKPOINT_DISABLE: '1' }),
+        input,
+        stdio: 'pipe',
+    }).toString();
+}
+function sql(file, statements) {
+    prismaCli(['db', 'execute', '--url', `file:${file}`, '--stdin'], file, statements);
+}
+/** Whether the database's tables are exactly what prisma/schema.prisma says. */
+function matchesSchema(file) {
+    try {
+        prismaCli([
+            'migrate',
+            'diff',
+            '--from-url',
+            `file:${file}`,
+            '--to-schema-datamodel',
+            SCHEMA,
+            '--exit-code',
+        ], file);
+        return true;
+    }
+    catch (err) {
+        if ((err === null || err === void 0 ? void 0 : err.status) === 2)
+            return false;
+        throw err;
+    }
+}
+function query(file, statement) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const client = new client_1.PrismaClient({ datasources: { db: { url: `file:${file}` } } });
+        try {
+            return (yield client.$queryRawUnsafe(statement));
+        }
+        finally {
+            yield client.$disconnect();
+        }
+    });
+}
+/** `_prisma_migrations`, or null when the database has none. */
+function historyOf(file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [{ n }] = yield query(file, "SELECT count(*) AS n FROM sqlite_master WHERE type = 'table' AND name = '_prisma_migrations'");
+        if (Number(n) === 0)
+            return null;
+        return query(file, 'SELECT migration_name, finished_at, rolled_back_at FROM "_prisma_migrations"');
+    });
+}
+/** `_prisma_migrations`, which the database must have. */
+function recordedHistory(file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const rows = yield historyOf(file);
+        if (!rows)
+            throw new Error(`${file} has no migration history`);
+        return rows;
+    });
+}
+const SEED = `
+INSERT INTO "Team" ("id", "name", "createdAt") VALUES ('team-1', 'Payments', 1759600000000);
+INSERT INTO "Build" ("id", "name", "createdAt", "updatedAt") VALUES ('build-1', 'nightly #42', 1759600000000, 1759600000000);
+`;
+function seededRows(file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const teams = yield query(file, 'SELECT id, name FROM "Team"');
+        const builds = yield query(file, 'SELECT id, name FROM "Build"');
+        return [...teams, ...builds].map((r) => `${r.id}=${r.name}`).sort();
+    });
+}
+const SEEDED = ['build-1=nightly #42', 'team-1=Payments'];
+describe('runMigrations against real databases', function () {
+    // Each start runs the prisma CLI two or three times.
+    this.timeout(120000);
+    let dir;
+    let saved;
+    /** The release before this one, with its migration history: what `migrate deploy` made. */
+    let withHistory;
+    /** The release before this one with no migration history: what `db push` made. */
+    let withoutHistory;
+    /** A history behind its tables: the default setting's `db push` ran on a `migrate deploy` database. */
+    let historyBehind;
+    /** A history that records a failed migration: `migrate deploy` ran on `historyBehind`. */
+    let historyFailed;
+    let copies = 0;
+    function copyOf(fixture) {
+        const file = path_1.default.join(dir, `start-${++copies}.db`);
+        if (fixture)
+            fs_1.default.copyFileSync(fixture, file);
+        return file;
+    }
+    function start(file, provider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            config_1.config.databaseUrl = `file:${file}`;
+            config_1.config.databaseProvider = provider;
+            yield (0, run_migrations_1.runMigrations)();
+        });
+    }
+    before(() => {
+        dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'xenon-run-migrations-'));
+        // The previous release: every migration but the newest, so a start has one to apply.
+        const previous = path_1.default.join(dir, 'previous');
+        fs_1.default.mkdirSync(path_1.default.join(previous, 'migrations'), { recursive: true });
+        fs_1.default.copyFileSync(SCHEMA, path_1.default.join(previous, 'schema.prisma'));
+        fs_1.default.copyFileSync(path_1.default.join(MIGRATIONS, 'migration_lock.toml'), path_1.default.join(previous, 'migrations', 'migration_lock.toml'));
+        for (const name of LOCAL_MIGRATIONS.slice(0, -1)) {
+            fs_1.default.mkdirSync(path_1.default.join(previous, 'migrations', name));
+            fs_1.default.copyFileSync(path_1.default.join(MIGRATIONS, name, 'migration.sql'), path_1.default.join(previous, 'migrations', name, 'migration.sql'));
+        }
+        withHistory = path_1.default.join(dir, 'with-history.db');
+        prismaCli(['migrate', 'deploy', '--schema', path_1.default.join(previous, 'schema.prisma')], withHistory);
+        withoutHistory = path_1.default.join(dir, 'without-history.db');
+        fs_1.default.copyFileSync(withHistory, withoutHistory);
+        sql(withoutHistory, 'DROP TABLE "_prisma_migrations";');
+        sql(withHistory, SEED);
+        sql(withoutHistory, SEED);
+        historyBehind = path_1.default.join(dir, 'history-behind.db');
+        fs_1.default.copyFileSync(withHistory, historyBehind);
+        prismaCli(['db', 'push', '--skip-generate', '--schema', SCHEMA], historyBehind);
+        historyFailed = path_1.default.join(dir, 'history-failed.db');
+        fs_1.default.copyFileSync(historyBehind, historyFailed);
+        try {
+            prismaCli(['migrate', 'deploy', '--schema', SCHEMA], historyFailed);
+        }
+        catch (_a) {
+            // P3018: the newest migration is already applied. That is the point.
+        }
+    });
+    after(() => {
+        fs_1.default.rmSync(dir, { recursive: true, force: true });
+    });
+    beforeEach(() => {
+        saved = {
+            autoMigrate: config_1.config.autoMigrate,
+            databaseProvider: config_1.config.databaseProvider,
+            databaseUrl: config_1.config.databaseUrl,
+        };
+        config_1.config.autoMigrate = true;
+    });
+    afterEach(() => {
+        Object.assign(config_1.config, saved);
+    });
+    it('builds the fixtures it means to', () => __awaiter(this, void 0, void 0, function* () {
+        (0, chai_1.expect)(LOCAL_MIGRATIONS.length).to.be.greaterThan(1);
+        (0, chai_1.expect)(yield historyOf(withHistory)).to.have.length(LOCAL_MIGRATIONS.length - 1);
+        (0, chai_1.expect)(yield historyOf(withoutHistory)).to.equal(null);
+        (0, chai_1.expect)(matchesSchema(withoutHistory), 'one migration left to apply').to.equal(false);
+        (0, chai_1.expect)(matchesSchema(historyBehind)).to.equal(true);
+        const failed = (yield recordedHistory(historyFailed)).filter((r) => !r.finished_at);
+        (0, chai_1.expect)(failed.map((r) => r.migration_name)).to.deep.equal([
+            LOCAL_MIGRATIONS[LOCAL_MIGRATIONS.length - 1],
+        ]);
+    }));
+    // Through 2.15.0 the setting chose the command, so these two run under both.
+    for (const provider of ['sqlite', 'postgresql']) {
+        describe(`with databaseProvider ${provider}`, () => {
+            it('brings a database kept with db push up to date, keeps its rows, and keeps it on db push', () => __awaiter(this, void 0, void 0, function* () {
+                const file = copyOf(withoutHistory);
+                yield start(file, provider);
+                (0, chai_1.expect)(matchesSchema(file)).to.equal(true);
+                (0, chai_1.expect)(yield seededRows(file)).to.deep.equal(SEEDED);
+                (0, chai_1.expect)(yield historyOf(file), 'no migration history was made up').to.equal(null);
+                yield start(file, provider);
+                (0, chai_1.expect)(matchesSchema(file)).to.equal(true);
+                (0, chai_1.expect)(yield seededRows(file)).to.deep.equal(SEEDED);
+            }));
+            it('applies the missing migration to a database with migration history, and records it', () => __awaiter(this, void 0, void 0, function* () {
+                const file = copyOf(withHistory);
+                yield start(file, provider);
+                (0, chai_1.expect)(matchesSchema(file)).to.equal(true);
+                (0, chai_1.expect)(yield seededRows(file)).to.deep.equal(SEEDED);
+                const history = yield recordedHistory(file);
+                (0, chai_1.expect)(history.map((r) => r.migration_name).sort()).to.deep.equal(LOCAL_MIGRATIONS);
+                (0, chai_1.expect)(history.every((r) => r.finished_at && !r.rolled_back_at)).to.equal(true);
+                yield start(file, provider);
+                (0, chai_1.expect)(yield recordedHistory(file)).to.have.length(LOCAL_MIGRATIONS.length);
+                (0, chai_1.expect)(yield seededRows(file)).to.deep.equal(SEEDED);
+            }));
+        });
+    }
+    // The rest ran into trouble under postgresql, the setting that chose migrate deploy.
+    it('creates a new database', () => __awaiter(this, void 0, void 0, function* () {
+        const file = copyOf(null);
+        yield start(file, 'postgresql');
+        (0, chai_1.expect)(matchesSchema(file)).to.equal(true);
+        yield start(file, 'postgresql');
+        (0, chai_1.expect)(matchesSchema(file)).to.equal(true);
+    }));
+    it('starts a database whose tables are ahead of its history, without recording a failed migration', () => __awaiter(this, void 0, void 0, function* () {
+        const file = copyOf(historyBehind);
+        yield start(file, 'postgresql');
+        (0, chai_1.expect)(matchesSchema(file)).to.equal(true);
+        (0, chai_1.expect)(yield seededRows(file)).to.deep.equal(SEEDED);
+        const history = yield recordedHistory(file);
+        (0, chai_1.expect)(history.filter((r) => !r.finished_at && !r.rolled_back_at)).to.deep.equal([]);
+    }));
+    it('starts a database whose history records a failed migration', () => __awaiter(this, void 0, void 0, function* () {
+        const file = copyOf(historyFailed);
+        yield start(file, 'postgresql');
+        (0, chai_1.expect)(matchesSchema(file)).to.equal(true);
+        (0, chai_1.expect)(yield seededRows(file)).to.deep.equal(SEEDED);
+    }));
+    // A history database whose tables differ from its migrations for another
+    // reason than db push: a table with a row and an index added by hand. `db
+    // push --accept-data-loss` would drop them, and the default setting did.
+    // Without the flag, db push refuses to drop the table, and the start stops
+    // with commands to paste. Each case below follows them as an operator would.
+    const HAND = 'CREATE TABLE "LabNotes" ("id" INTEGER PRIMARY KEY, "note" TEXT); ' +
+        'INSERT INTO "LabNotes" ("note") VALUES (\'keep me\'); ' +
+        'CREATE INDEX "lab_team_created" ON "Team"("createdAt");';
+    function startStops(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield start(file, 'sqlite');
+            }
+            catch (e) {
+                return e.message;
+            }
+            throw new Error('the start was meant to stop');
+        });
+    }
+    /** The commands a failure message gives, one to an indented line, in its order. */
+    function commandsIn(message) {
+        return message
+            .split('\n')
+            .filter((line) => /^ {2}(DATABASE_URL=|echo )/.test(line))
+            .map((line) => line.trim());
+    }
+    /** Runs a command from a message as an operator would paste it into a shell. */
+    function paste(command) {
+        return (0, child_process_1.execSync)(command, {
+            shell: '/bin/sh',
+            stdio: 'pipe',
+            env: Object.assign(Object.assign({}, process.env), { CHECKPOINT_DISABLE: '1' }),
+        }).toString();
+    }
+    /** The file a `VACUUM INTO '<file>'` command writes. */
+    function vacuumTarget(command) {
+        const match = /VACUUM INTO '([^']+)'/.exec(command);
+        if (!match)
+            throw new Error(`not a copy: ${command}`);
+        return match[1];
+    }
+    function handAdded(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [{ n }] = yield query(file, "SELECT count(*) AS n FROM sqlite_master WHERE name = 'LabNotes'");
+            const notes = Number(n) === 0
+                ? []
+                : (yield query(file, 'SELECT note FROM "LabNotes"')).map((r) => r.note);
+            const index = yield query(file, "SELECT name FROM sqlite_master WHERE name = 'lab_team_created'");
+            return { notes, index: index.length === 1 };
+        });
+    }
+    const KEPT = { notes: ['keep me'], index: true };
+    const GONE = { notes: [], index: false };
+    /** Whether the tables are this version's schema plus what was added by hand. */
+    function matchesSchemaWithHandAdded(file) {
+        const probe = `${file}.probe`;
+        fs_1.default.copyFileSync(file, probe);
+        try {
+            sql(probe, 'DROP TABLE "LabNotes"; DROP INDEX "lab_team_created";');
+            return matchesSchema(probe);
+        }
+        finally {
+            fs_1.default.rmSync(probe, { force: true });
+        }
+    }
+    function failedMigrations(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const history = yield recordedHistory(file);
+            return history.filter((r) => !r.finished_at && !r.rolled_back_at).map((r) => r.migration_name);
+        });
+    }
+    it('drops nothing added by hand to a history database, and its copy-first advice keeps it', () => __awaiter(this, void 0, void 0, function* () {
+        const file = copyOf(withHistory);
+        sql(file, HAND);
+        const message = yield startStops(file);
+        (0, chai_1.expect)(message).to.match(/stopped rather than delete/);
+        (0, chai_1.expect)(message).to.include('LabNotes');
+        (0, chai_1.expect)(yield handAdded(file)).to.deep.equal(KEPT);
+        (0, chai_1.expect)(yield recordedHistory(file)).to.have.length(LOCAL_MIGRATIONS.length - 1);
+        // Back up, copy, deploy on the copy, then on the file, as it says.
+        const commands = commandsIn(message);
+        const backup = commands.find((c) => c.includes('.backup-'));
+        const copy = commands.find((c) => c.includes('VACUUM INTO') && c !== backup);
+        const copyUrl = `file:${vacuumTarget(copy)}`;
+        const onCopy = commands.find((c) => c.startsWith(`DATABASE_URL=${copyUrl} `));
+        const onFile = commands.find((c) => c.startsWith(`DATABASE_URL=file:${file} `) && c.includes('migrate deploy'));
+        (0, chai_1.expect)([backup, copy, onCopy, onFile].every(Boolean), message).to.equal(true);
+        paste(backup);
+        paste(copy);
+        paste(onCopy);
+        paste(onFile);
+        fs_1.default.rmSync(vacuumTarget(copy));
+        yield start(file, 'sqlite');
+        (0, chai_1.expect)(yield handAdded(file)).to.deep.equal(KEPT);
+        (0, chai_1.expect)(yield handAdded(vacuumTarget(backup))).to.deep.equal(KEPT);
+        (0, chai_1.expect)(matchesSchemaWithHandAdded(file)).to.equal(true);
+        (0, chai_1.expect)(yield seededRows(file)).to.deep.equal(SEEDED);
+        (0, chai_1.expect)(yield recordedHistory(file)).to.have.length(LOCAL_MIGRATIONS.length);
+    }));
+    // Tables ahead of the history and a table added by hand: migrate deploy
+    // fails on the change already there (P3018) and records it as failed, so
+    // the advice tries it on a copy, which fails there and leaves the file be.
+    it('never sends migrate deploy to a database whose tables are ahead of its history', () => __awaiter(this, void 0, void 0, function* () {
+        const file = copyOf(historyBehind);
+        sql(file, HAND);
+        const message = yield startStops(file);
+        (0, chai_1.expect)(message).to.match(/stopped rather than delete/);
+        (0, chai_1.expect)(message).to.include('LabNotes');
+        const commands = commandsIn(message);
+        const backup = commands.find((c) => c.includes('.backup-'));
+        const copy = commands.find((c) => c.includes('VACUUM INTO') && c !== backup);
+        const copyUrl = `file:${vacuumTarget(copy)}`;
+        const onCopy = commands.find((c) => c.startsWith(`DATABASE_URL=${copyUrl} `));
+        const letGo = commands.find((c) => c.includes('--accept-data-loss'));
+        (0, chai_1.expect)([backup, copy, onCopy, letGo].every(Boolean), message).to.equal(true);
+        (0, chai_1.expect)(letGo).to.equal(`DATABASE_URL=file:${file} ${PRISMA} db push --skip-generate --accept-data-loss --schema ${SCHEMA}`);
+        paste(backup);
+        paste(copy);
+        (0, chai_1.expect)(() => paste(onCopy)).to.throw(/P3018/);
+        fs_1.default.rmSync(vacuumTarget(copy));
+        (0, chai_1.expect)(yield failedMigrations(file), 'the file records no failed migration').to.deep.equal([]);
+        // Let it go, as the message says when the copy fails.
+        paste(letGo);
+        yield start(file, 'sqlite');
+        (0, chai_1.expect)(yield handAdded(file)).to.deep.equal(GONE);
+        (0, chai_1.expect)(yield handAdded(vacuumTarget(backup))).to.deep.equal(KEPT);
+        (0, chai_1.expect)(matchesSchema(file)).to.equal(true);
+        (0, chai_1.expect)(yield seededRows(file)).to.deep.equal(SEEDED);
+    }));
+    // A failed migration recorded: migrate deploy stops at once (P3009).
+    it('never suggests migrate deploy for a history that records a failed migration', () => __awaiter(this, void 0, void 0, function* () {
+        const file = copyOf(historyFailed);
+        sql(file, HAND);
+        const newest = LOCAL_MIGRATIONS[LOCAL_MIGRATIONS.length - 1];
+        const message = yield startStops(file);
+        (0, chai_1.expect)(message).to.match(/stopped rather than delete/);
+        (0, chai_1.expect)(message).to.include(newest);
+        (0, chai_1.expect)(message).to.include('LabNotes');
+        const commands = commandsIn(message);
+        (0, chai_1.expect)(commands.filter((c) => c.includes('migrate deploy'))).to.deep.equal([]);
+        const backup = commands.find((c) => c.includes('.backup-'));
+        const letGo = commands.find((c) => c.includes('--accept-data-loss'));
+        (0, chai_1.expect)([backup, letGo].every(Boolean), message).to.equal(true);
+        paste(backup);
+        paste(letGo);
+        yield start(file, 'sqlite');
+        (0, chai_1.expect)(yield handAdded(file)).to.deep.equal(GONE);
+        (0, chai_1.expect)(yield handAdded(vacuumTarget(backup))).to.deep.equal(KEPT);
+        (0, chai_1.expect)(matchesSchema(file)).to.equal(true);
+        (0, chai_1.expect)(yield seededRows(file)).to.deep.equal(SEEDED);
+    }));
+    // Prisma resolves a relative SQLite URL against the schema's directory,
+    // prisma/. Through the first cut of this change the history was read through
+    // a client that couldn't open a file in a directory that wasn't there yet,
+    // where the CLI makes it.
+    it('creates a new database at a relative file: URL in a directory that is not there yet', () => __awaiter(this, void 0, void 0, function* () {
+        const target = path_1.default.join(dir, 'relative', 'nested', 'xenon.db');
+        const relative = path_1.default.relative(path_1.default.dirname(SCHEMA), target);
+        (0, chai_1.expect)(path_1.default.isAbsolute(relative)).to.equal(false);
+        config_1.config.databaseUrl = `file:${relative}`;
+        config_1.config.databaseProvider = 'sqlite';
+        yield (0, run_migrations_1.runMigrations)();
+        (0, chai_1.expect)(fs_1.default.existsSync(target), 'the database is where the URL points').to.equal(true);
+        (0, chai_1.expect)(matchesSchema(target)).to.equal(true);
+    }));
+    // A `_prisma_migrations` table that isn't Prisma's (other columns) is no
+    // migration history. The default setting started on such a database.
+    it("starts a database whose _prisma_migrations table isn't Prisma's", () => __awaiter(this, void 0, void 0, function* () {
+        const file = copyOf(withoutHistory);
+        sql(file, 'CREATE TABLE "_prisma_migrations" ("id" TEXT PRIMARY KEY, "migration_name" TEXT);');
+        yield start(file, 'postgresql');
+        (0, chai_1.expect)(matchesSchema(file)).to.equal(true);
+        (0, chai_1.expect)(yield seededRows(file)).to.deep.equal(SEEDED);
+    }));
+    // `npm run db:migrate` checks the URL as a start does, before reading anything.
+    it('stops npm run db:migrate on a PostgreSQL URL with the database check, not a read error', () => {
+        var _a, _b;
+        let output = '';
+        let status = 0;
+        try {
+            output = (0, child_process_1.execFileSync)(path_1.default.join(ROOT, 'node_modules', '.bin', 'ts-node'), ['-T', path_1.default.join(ROOT, 'src', 'scripts', 'initialize-database.ts')], {
+                cwd: ROOT,
+                env: Object.assign(Object.assign({}, process.env), { DATABASE_URL: 'postgresql://xenon:pw@127.0.0.1:1/xenon', XENON_DB_PROVIDER: '' }),
+                stdio: 'pipe',
+            }).toString();
+        }
+        catch (err) {
+            status = err.status;
+            output = `${(_a = err.stdout) !== null && _a !== void 0 ? _a : ''}${(_b = err.stderr) !== null && _b !== void 0 ? _b : ''}`;
+        }
+        (0, chai_1.expect)(status, output).to.not.equal(0);
+        (0, chai_1.expect)(output).to.match(/built for SQLite/);
+        (0, chai_1.expect)(output).to.not.match(/could not read/);
+    });
+});

package/lib/test/unit/run-migrations-fail-fast.test.js

@@ -8,8 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const chai_1 = require("chai");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
 const run_migrations_1 = require("../../src/scripts/run-migrations");
 const config_1 = require("../../src/config");
 /**
@@ -22,51 +27,60 @@ const config_1 = require("../../src/config");
  * runMigrations must fail fast, and say what actually happened.
  */
 describe('runMigrations failure handling', () => {
+    // runMigrations reads the database before it chooses a command. A file that
+    // isn't there has no history and is never opened, so nothing here reaches
+    // the server's own database.
+    const scratchFile = path_1.default.join(os_1.default.tmpdir(), `xenon-fail-fast-${process.pid}-absent.db`);
     let originalAutoMigrate;
-    let originalProvider;
+    let originalUrl;
     beforeEach(() => {
         originalAutoMigrate = config_1.config.autoMigrate;
-        originalProvider = config_1.config.databaseProvider;
+        originalUrl = config_1.config.databaseUrl;
         config_1.config.autoMigrate = true;
-        config_1.config.databaseProvider = 'sqlite';
+        config_1.config.databaseUrl = `file:${scratchFile}`;
     });
     afterEach(() => {
         config_1.config.autoMigrate = originalAutoMigrate;
-        config_1.config.databaseProvider = originalProvider;
+        config_1.config.databaseUrl = originalUrl;
     });
+    function failureOf(stderr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const failingRunner = () => {
+                throw Object.assign(new Error('Command failed'), { stderr: Buffer.from(stderr) });
+            };
+            try {
+                yield (0, run_migrations_1.runMigrations)(failingRunner);
+            }
+            catch (e) {
+                return e;
+            }
+            throw new Error('runMigrations must not swallow the failure');
+        });
+    }
     it('throws instead of swallowing when the schema sync fails', () => __awaiter(void 0, void 0, void 0, function* () {
-        const prismaErr = new Error('Command failed');
-        prismaErr.stderr = Buffer.from('We found changes that cannot be executed:\n' +
+        const thrown = yield failureOf('We found changes that cannot be executed:\n' +
             '  - Added the required column `userId` to the `ApiKey` table without a default value.');
-        const failingRunner = () => {
-            throw prismaErr;
-        };
-        let thrown;
-        try {
-            yield (0, run_migrations_1.runMigrations)(failingRunner);
-        }
-        catch (e) {
-            thrown = e;
-        }
-        (0, chai_1.expect)(thrown, 'runMigrations must not swallow the failure').to.be.an('Error');
+        (0, chai_1.expect)(thrown).to.be.an('Error');
         // The message has to carry the real cause, not just "sync failed".
         (0, chai_1.expect)(thrown.message).to.match(/userId/);
         (0, chai_1.expect)(thrown.message).to.match(/ApiKey/);
+        (0, chai_1.expect)(thrown.message).to.match(/adds a required column to a table that already has rows/);
     }));
     it('names the database so the operator knows what to back up', () => __awaiter(void 0, void 0, void 0, function* () {
-        const failingRunner = () => {
-            throw Object.assign(new Error('Command failed'), { stderr: Buffer.from('boom') });
-        };
-        let thrown;
-        try {
-            yield (0, run_migrations_1.runMigrations)(failingRunner);
-        }
-        catch (e) {
-            thrown = e;
-        }
+        const thrown = yield failureOf('boom');
         (0, chai_1.expect)(thrown).to.be.an('Error');
+        (0, chai_1.expect)(thrown.message).to.include(scratchFile);
         (0, chai_1.expect)(thrown.message).to.match(/XENON_AUTO_MIGRATE/);
     }));
+    // Through 2.15.0 every failure was put down to a required column, P3005
+    // ("The database schema is not empty") included.
+    it("doesn't blame a required column when that isn't the cause", () => __awaiter(void 0, void 0, void 0, function* () {
+        const thrown = yield failureOf('Error: P3005\n\nThe database schema is not empty. Read more about how to baseline an ' +
+            'existing production database: https://pris.ly/d/migrate-baseline');
+        (0, chai_1.expect)(thrown.message).to.not.match(/required column/i);
+        (0, chai_1.expect)(thrown.message).to.match(/P3005/);
+        (0, chai_1.expect)(thrown.message).to.match(/could not bring the database at .* up to date/);
+    }));
     it('resolves normally when the schema sync succeeds', () => __awaiter(void 0, void 0, void 0, function* () {
         let called = false;
         yield (0, run_migrations_1.runMigrations)(() => {