@xenon-device-management/xenon 2.15.0 → 2.16.0

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

@@ -0,0 +1,807 @@
+"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 sinon_1 = __importDefault(require("sinon"));
+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 a schema (prisma/schema.prisma) says. */
+function matchesSchema(file, schema = SCHEMA) {
+    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;
+    });
+}
+// A selector fingerprint too, so a migration that changes LocatorEtalon meets a row.
+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);
+INSERT INTO "LocatorEtalon" ("id", "selector", "strategy", "attributes", "nodeName", "lastSeen", "createdAt", "updatedAt") VALUES ('et-1', '//b', 'xpath', '{}', 'Button', 1759600000000, 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"');
+        const etalons = yield query(file, 'SELECT id, selector AS name FROM "LocatorEtalon"');
+        return [...teams, ...builds, ...etalons].map((r) => `${r.id}=${r.name}`).sort();
+    });
+}
+const SEEDED = ['build-1=nightly #42', 'et-1=//b', '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);
+    }));
+    /** Every local migration recorded as applied, none failed: what migrate deploy leaves. */
+    function expectFullHistory(file_1) {
+        return __awaiter(this, arguments, void 0, function* (file, migrations = LOCAL_MIGRATIONS) {
+            const history = yield recordedHistory(file);
+            const applied = history.filter((r) => r.finished_at && !r.rolled_back_at);
+            (0, chai_1.expect)(applied.map((r) => r.migration_name).sort()).to.deep.equal(migrations);
+            (0, chai_1.expect)(history.filter((r) => !r.finished_at && !r.rolled_back_at)).to.deep.equal([]);
+        });
+    }
+    /** The copies a start tries the migrations on, which it must not leave behind. */
+    function trialCopiesOf(file) {
+        const prefix = `${path_1.default.basename(file)}.xenon-trial-`;
+        return fs_1.default.readdirSync(path_1.default.dirname(file)).filter((n) => n.startsWith(prefix));
+    }
+    // Re-baselining: db push writes no history, so these two stayed on db push
+    // for good, and refused at the first release whose migration drops a column
+    // or adds a unique index (see the next releases below). Now their history
+    // records what the tables have, and migrate deploy takes over.
+    it('records what the tables of a database ahead of its history have, and puts it back on migrate deploy', () => __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);
+        yield expectFullHistory(file);
+        (0, chai_1.expect)(trialCopiesOf(file)).to.deep.equal([]);
+    }));
+    it('starts a database whose history records a failed migration, and clears it', () => __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);
+        yield expectFullHistory(file);
+    }));
+    it('records a migration that was rolled back when the tables have it', () => __awaiter(this, void 0, void 0, function* () {
+        const file = copyOf(historyFailed);
+        prismaCli(['migrate', 'resolve', '--rolled-back', LOCAL_MIGRATIONS[LOCAL_MIGRATIONS.length - 1]], file);
+        yield start(file, 'sqlite');
+        (0, chai_1.expect)(matchesSchema(file)).to.equal(true);
+        yield expectFullHistory(file);
+    }));
+    // 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.
+    // `migrate deploy`, the old `postgresql` path, kept them; a start now tries
+    // it on a copy and uses it when it works there. When it doesn't, db push
+    // without the flag refuses to drop the table, and the start stops with
+    // commands to paste. The cases that stop follow 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 |touch )/.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 a schema's plus what was added by hand. */
+    function matchesSchemaWithHandAdded(file, schema = SCHEMA) {
+        const probe = `${file}.probe`;
+        fs_1.default.copyFileSync(file, probe);
+        try {
+            sql(probe, 'DROP TABLE IF EXISTS "LabNotes"; DROP INDEX IF EXISTS "lab_team_created";');
+            return matchesSchema(probe, schema);
+        }
+        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('keeps what was added by hand to a history database: migrate deploy worked on a copy', () => __awaiter(this, void 0, void 0, function* () {
+        const file = copyOf(withHistory);
+        sql(file, HAND);
+        yield start(file, 'sqlite');
+        (0, chai_1.expect)(yield handAdded(file)).to.deep.equal(KEPT);
+        (0, chai_1.expect)(matchesSchemaWithHandAdded(file)).to.equal(true);
+        (0, chai_1.expect)(yield seededRows(file)).to.deep.equal(SEEDED);
+        yield expectFullHistory(file);
+        (0, chai_1.expect)(trialCopiesOf(file), 'the copy is gone').to.deep.equal([]);
+        yield start(file, 'sqlite');
+        (0, chai_1.expect)(yield handAdded(file)).to.deep.equal(KEPT);
+    }));
+    // db push drops an index without asking, with or without the flag.
+    it('keeps an index added by hand to a history database', () => __awaiter(this, void 0, void 0, function* () {
+        const file = copyOf(withHistory);
+        sql(file, 'CREATE INDEX "lab_team_created" ON "Team"("createdAt");');
+        yield start(file, 'sqlite');
+        (0, chai_1.expect)((yield handAdded(file)).index).to.equal(true);
+        yield expectFullHistory(file);
+    }));
+    // Tables ahead of the history and a table added by hand: no run of the
+    // migrations matches the tables, and migrate deploy fails on the copy on
+    // the change already there (P3018). The file never gets migrate deploy.
+    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);
+        // Not what the umask gives: the backup gets the file's own.
+        fs_1.default.chmodSync(file, 0o640);
+        const message = yield startStops(file);
+        (0, chai_1.expect)(message).to.match(/stopped rather than delete/);
+        (0, chai_1.expect)(message).to.match(/failed on a copy/);
+        (0, chai_1.expect)(message).to.include('LabNotes');
+        (0, chai_1.expect)(yield failedMigrations(file), 'the file records no failed migration').to.deep.equal([]);
+        (0, chai_1.expect)(yield handAdded(file)).to.deep.equal(KEPT);
+        (0, chai_1.expect)(trialCopiesOf(file)).to.deep.equal([]);
+        const commands = commandsIn(message);
+        (0, chai_1.expect)(commands.filter((c) => c.includes('migrate deploy'))).to.deep.equal([]);
+        // One command: the backup, and only once it is made, the data let go.
+        const letGo = commands.find((c) => c.includes('--accept-data-loss'));
+        (0, chai_1.expect)(letGo, message).to.be.a('string');
+        (0, chai_1.expect)(letGo).to.match(/^touch \S+\.backup-\S+ && chmod 640 \S+ && echo .* \| .* db execute /);
+        (0, chai_1.expect)(letGo.endsWith(` && DATABASE_URL=file:${file} ${PRISMA} db push --skip-generate --accept-data-loss ` +
+            `--schema ${SCHEMA}`), letGo).to.equal(true);
+        // A backup that can't be made (its name is taken) lets nothing go.
+        const backup = vacuumTarget(letGo);
+        fs_1.default.writeFileSync(backup, 'taken');
+        (0, chai_1.expect)(() => paste(letGo)).to.throw();
+        (0, chai_1.expect)(yield handAdded(file)).to.deep.equal(KEPT);
+        fs_1.default.rmSync(backup);
+        // Let it go, as it says, and start: the history then catches up.
+        paste(letGo);
+        (0, chai_1.expect)(fs_1.default.statSync(backup).mode & 0o777).to.equal(0o640);
+        yield start(file, 'sqlite');
+        (0, chai_1.expect)(yield handAdded(file)).to.deep.equal(GONE);
+        (0, chai_1.expect)(yield handAdded(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);
+        yield expectFullHistory(file);
+    }));
+    // 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');
+        (0, chai_1.expect)(yield failedMigrations(file)).to.deep.equal([newest]);
+        const commands = commandsIn(message);
+        (0, chai_1.expect)(commands.filter((c) => c.includes('migrate deploy'))).to.deep.equal([]);
+        const letGo = commands.find((c) => c.includes('--accept-data-loss'));
+        (0, chai_1.expect)(letGo, message).to.include('.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(letGo))).to.deep.equal(KEPT);
+        (0, chai_1.expect)(matchesSchema(file)).to.equal(true);
+        (0, chai_1.expect)(yield seededRows(file)).to.deep.equal(SEEDED);
+        yield expectFullHistory(file);
+    }));
+    // A start that died while it tried the migrations on a copy left the copy.
+    it('removes a copy a start that died left behind', () => __awaiter(this, void 0, void 0, function* () {
+        const file = copyOf(withHistory);
+        const leftover = `${file}.xenon-trial-999993`;
+        fs_1.default.copyFileSync(file, leftover);
+        fs_1.default.writeFileSync(`${leftover}-journal`, '');
+        // Signal 0 only asks whether a process is there; stubbed all the same.
+        const kill = sinon_1.default.stub(process, 'kill').callsFake((() => {
+            throw Object.assign(new Error('kill ESRCH'), { code: 'ESRCH' });
+        }));
+        try {
+            yield start(file, 'sqlite');
+        }
+        finally {
+            kill.restore();
+        }
+        (0, chai_1.expect)(trialCopiesOf(file)).to.deep.equal([]);
+    }));
+    // The two kinds of migration `db push` without --accept-data-loss refuses
+    // on a table with rows: one that drops a column, one that adds a unique
+    // index. Each is made as a release after this one would make it, with
+    // Prisma's own migration for the change.
+    describe('the next release', () => {
+        /**
+         * A plugin root for a release after this one: this schema, edited, and its
+         * migration. The migration is Prisma's own for the edit, unless `script`
+         * gives one written by hand (a backfill changes rows, and no table).
+         */
+        function nextRelease(name, edit, script, migrationName = `29990101000000_${name}`) {
+            const root = path_1.default.join(dir, `next-${name}`);
+            fs_1.default.mkdirSync(path_1.default.join(root, 'prisma'), { recursive: true });
+            fs_1.default.cpSync(MIGRATIONS, path_1.default.join(root, 'prisma', 'migrations'), { recursive: true });
+            const before = fs_1.default.readFileSync(SCHEMA, 'utf8');
+            const after = edit(before);
+            if (script === undefined)
+                (0, chai_1.expect)(after, 'the edit changes the schema').to.not.equal(before);
+            const schema = path_1.default.join(root, 'prisma', 'schema.prisma');
+            fs_1.default.writeFileSync(schema, after);
+            script !== null && script !== void 0 ? script : (script = (0, child_process_1.execFileSync)(PRISMA, [
+                'migrate',
+                'diff',
+                '--from-schema-datamodel',
+                SCHEMA,
+                '--to-schema-datamodel',
+                schema,
+                '--script',
+            ], { cwd: ROOT, env: Object.assign(Object.assign({}, process.env), { CHECKPOINT_DISABLE: '1' }), stdio: 'pipe' }).toString());
+            const migration = path_1.default.join(root, 'prisma', 'migrations', migrationName);
+            fs_1.default.mkdirSync(migration);
+            fs_1.default.writeFileSync(path_1.default.join(migration, 'migration.sql'), script);
+            fs_1.default.symlinkSync(path_1.default.join(ROOT, 'node_modules'), path_1.default.join(root, 'node_modules'));
+            return root;
+        }
+        let dropColumn;
+        let addUnique;
+        /** This release's database with its full history. */
+        let current;
+        /** This release's database with its full history, and a table and index added by hand. */
+        let currentWithHand;
+        before(() => __awaiter(this, void 0, void 0, function* () {
+            dropColumn = nextRelease('drop_attributes', (schema) => schema.replace(/(model LocatorEtalon \{[^}]*?)\n {2}attributes +String\n/, '$1\n'));
+            addUnique = nextRelease('unique_strategy_node', (schema) => schema.replace(/(model LocatorEtalon \{[^}]*?)\n\}/, '$1\n\n  @@unique([strategy, nodeName])\n}'));
+            current = path_1.default.join(dir, 'current.db');
+            fs_1.default.copyFileSync(withHistory, current);
+            prismaCli(['migrate', 'deploy', '--schema', SCHEMA], current);
+            currentWithHand = path_1.default.join(dir, 'current-with-hand.db');
+            fs_1.default.copyFileSync(current, currentWithHand);
+            sql(currentWithHand, HAND);
+        }));
+        function startNext(file, root) {
+            return __awaiter(this, void 0, void 0, function* () {
+                config_1.config.databaseUrl = `file:${file}`;
+                config_1.config.databaseProvider = 'sqlite';
+                yield (0, run_migrations_1.runMigrations)(undefined, undefined, { root });
+            });
+        }
+        const migrationsOf = (root) => fs_1.default
+            .readdirSync(path_1.default.join(root, 'prisma', 'migrations'))
+            .filter((n) => !n.endsWith('.toml'))
+            .sort();
+        for (const [label, rootOf] of [
+            ['drops a column', () => dropColumn],
+            ['adds a unique index', () => addUnique],
+        ]) {
+            describe(`that ${label}`, () => {
+                it('updates a database ahead of its history with migrate deploy', () => __awaiter(this, void 0, void 0, function* () {
+                    const root = rootOf();
+                    const file = copyOf(historyBehind);
+                    yield startNext(file, root);
+                    (0, chai_1.expect)(matchesSchema(file, path_1.default.join(root, 'prisma', 'schema.prisma'))).to.equal(true);
+                    (0, chai_1.expect)(yield seededRows(file)).to.deep.equal(SEEDED);
+                    yield expectFullHistory(file, migrationsOf(root));
+                }));
+                it('updates a database with a failed migration recorded with migrate deploy', () => __awaiter(this, void 0, void 0, function* () {
+                    const root = rootOf();
+                    const file = copyOf(historyFailed);
+                    yield startNext(file, root);
+                    (0, chai_1.expect)(matchesSchema(file, path_1.default.join(root, 'prisma', 'schema.prisma'))).to.equal(true);
+                    (0, chai_1.expect)(yield seededRows(file)).to.deep.equal(SEEDED);
+                    yield expectFullHistory(file, migrationsOf(root));
+                }));
+                it('keeps what was added by hand to a database with its full history', () => __awaiter(this, void 0, void 0, function* () {
+                    const root = rootOf();
+                    const file = copyOf(currentWithHand);
+                    yield startNext(file, root);
+                    (0, chai_1.expect)(yield handAdded(file)).to.deep.equal(KEPT);
+                    (0, chai_1.expect)(matchesSchemaWithHandAdded(file, path_1.default.join(root, 'prisma', 'schema.prisma'))).to.equal(true);
+                    (0, chai_1.expect)(yield seededRows(file)).to.deep.equal(SEEDED);
+                    yield expectFullHistory(file, migrationsOf(root));
+                }));
+            });
+        }
+        function stopsNext(file, root) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield startNext(file, root);
+                }
+                catch (e) {
+                    return e.message;
+                }
+                throw new Error('the start was meant to stop');
+            });
+        }
+        function teamNames(file) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return (yield query(file, 'SELECT name FROM "Team"')).map((r) => r.name);
+            });
+        }
+        /** What the history records as applied (sorted) and as failed. */
+        function recorded(file) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const history = yield recordedHistory(file);
+                return {
+                    applied: history
+                        .filter((r) => r.finished_at && !r.rolled_back_at)
+                        .map((r) => r.migration_name)
+                        .sort(),
+                    failed: yield failedMigrations(file),
+                };
+            });
+        }
+        const newestOf = (root) => migrationsOf(root)[migrationsOf(root).length - 1];
+        // Prisma's diff compares tables, so it can't see what a migration does to
+        // the rows (a backfill), nor a trigger, a view or an index's collation.
+        // Through #493, re-baselining recorded such a migration as applied when the
+        // tables matched it, so it never ran, and recorded a migration that had
+        // failed on the rows as applied at the start after.
+        describe('whose migration changes rows', () => {
+            let backfill;
+            let backfillFails;
+            let addThenFill;
+            before(() => {
+                backfill = nextRelease('backfill', (schema) => schema, 'UPDATE "Team" SET "name" = "name" || \' [backfilled]\';\n');
+                // One statement, failing on the team named Payments: SQLite undoes it whole.
+                backfillFails = nextRelease('backfill_fails', (schema) => schema, 'UPDATE "Team" SET "name" = CASE WHEN "name" = \'Payments\' THEN NULL ' +
+                    'ELSE "name" || \' [backfilled]\' END;\n');
+                // A column, then a backfill whose second statement fails on that team.
+                // Prisma doesn't run a SQLite migration in a transaction, so the column
+                // and the first statement stay.
+                addThenFill = nextRelease('team_slug', (schema) => schema.replace(/(model Team \{\n)/, '$1  slug           String?\n'), 'ALTER TABLE "Team" ADD COLUMN "slug" TEXT;\n' +
+                    'UPDATE "Team" SET "slug" = lower("name");\n' +
+                    'UPDATE "Team" SET "name" = NULL WHERE "slug" = \'payments\';\n');
+            });
+            it('runs a backfill on a database ahead of its history, rather than record it', () => __awaiter(this, void 0, void 0, function* () {
+                const file = copyOf(historyBehind);
+                yield startNext(file, backfill);
+                (0, chai_1.expect)(yield teamNames(file)).to.deep.equal(['Payments [backfilled]']);
+                yield expectFullHistory(file, migrationsOf(backfill));
+            }));
+            it('runs a backfill on a database whose history records a failed migration', () => __awaiter(this, void 0, void 0, function* () {
+                const file = copyOf(historyFailed);
+                yield startNext(file, backfill);
+                (0, chai_1.expect)(yield teamNames(file)).to.deep.equal(['Payments [backfilled]']);
+                yield expectFullHistory(file, migrationsOf(backfill));
+            }));
+            // db push made the tables of both migrations after the history, the
+            // backfill's and a column's: the tables match the column's run, and say
+            // nothing of whether the backfill ran (db push never runs one).
+            it('leaves the history alone when a backfill is among what db push already made', () => __awaiter(this, void 0, void 0, function* () {
+                const root = nextRelease('backfill_then_column', (schema) => schema.replace(/(model Team \{\n)/, '$1  slug           String?\n'), 'ALTER TABLE "Team" ADD COLUMN "slug" TEXT;\n', '29990102000000_team_slug');
+                const backfillDir = path_1.default.join(root, 'prisma', 'migrations', newestOf(backfill));
+                fs_1.default.mkdirSync(backfillDir);
+                fs_1.default.copyFileSync(path_1.default.join(backfill, 'prisma', 'migrations', newestOf(backfill), 'migration.sql'), path_1.default.join(backfillDir, 'migration.sql'));
+                const file = copyOf(current);
+                prismaCli(['db', 'push', '--skip-generate', '--schema', path_1.default.join(root, 'prisma', 'schema.prisma')], file);
+                yield startNext(file, root);
+                (0, chai_1.expect)(yield recorded(file)).to.deep.equal({ applied: LOCAL_MIGRATIONS, failed: [] });
+                (0, chai_1.expect)(yield teamNames(file)).to.deep.equal(['Payments']);
+                (0, chai_1.expect)(matchesSchema(file, path_1.default.join(root, 'prisma', 'schema.prisma'))).to.equal(true);
+            }));
+            it('keeps a backfill that failed on the rows failed until they change, then runs it', () => __awaiter(this, void 0, void 0, function* () {
+                const newest = newestOf(backfillFails);
+                const file = copyOf(current);
+                for (const attempt of [1, 2]) {
+                    const message = yield stopsNext(file, backfillFails);
+                    (0, chai_1.expect)(message, `start ${attempt}`).to.include(newest);
+                    (0, chai_1.expect)(message).to.include('NOT NULL constraint failed');
+                    (0, chai_1.expect)(message).to.match(/change those rows, and start again: the next start runs it/);
+                    (0, chai_1.expect)(yield recorded(file), `start ${attempt}`).to.deep.equal({
+                        applied: LOCAL_MIGRATIONS,
+                        failed: [newest],
+                    });
+                    (0, chai_1.expect)(yield teamNames(file)).to.deep.equal(['Payments']);
+                }
+                sql(file, 'UPDATE "Team" SET "name" = \'Payments team\';');
+                yield startNext(file, backfillFails);
+                (0, chai_1.expect)(yield teamNames(file)).to.deep.equal(['Payments team [backfilled]']);
+                yield expectFullHistory(file, migrationsOf(backfillFails));
+            }));
+            it('never records a migration that failed part-way as applied', () => __awaiter(this, void 0, void 0, function* () {
+                const newest = newestOf(addThenFill);
+                const file = copyOf(current);
+                let message = '';
+                for (const attempt of [1, 2]) {
+                    message = yield stopsNext(file, addThenFill);
+                    (0, chai_1.expect)(message, `start ${attempt}`).to.include(newest);
+                    (0, chai_1.expect)(message).to.include('NOT NULL constraint failed');
+                    (0, chai_1.expect)(message).to.match(/part of it/);
+                    (0, chai_1.expect)(message).to.not.match(/change those rows, and start again/);
+                    (0, chai_1.expect)(yield recorded(file), `start ${attempt}`).to.deep.equal({
+                        applied: LOCAL_MIGRATIONS,
+                        failed: [newest],
+                    });
+                }
+                // As the message says: change the rows, finish what the migration
+                // didn't do, record it, and start.
+                const commands = commandsIn(message);
+                const applied = commands.find((c) => c.includes(`migrate resolve --applied ${newest}`));
+                const rolledBack = commands.find((c) => c.includes(`migrate resolve --rolled-back ${newest}`));
+                (0, chai_1.expect)([applied, rolledBack].every(Boolean), message).to.equal(true);
+                sql(file, 'UPDATE "Team" SET "name" = \'Payments team\', "slug" = \'payments team\';');
+                paste(applied);
+                yield startNext(file, addThenFill);
+                yield expectFullHistory(file, migrationsOf(addThenFill));
+                (0, chai_1.expect)(matchesSchema(file, path_1.default.join(addThenFill, 'prisma', 'schema.prisma'))).to.equal(true);
+            }));
+        });
+        /** The columns a table has. */
+        function columnsOf(file, table) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const rows = yield query(file, `SELECT name FROM pragma_table_info('${table}')`);
+                return rows.map((r) => r.name);
+            });
+        }
+        // `migrate deploy` applies migrations and nothing else, so that they work
+        // on a copy says nothing of what the tables lacked before them. Through
+        // #493 a copy that worked wrote the full history over tables that lacked
+        // part of the schema, and every later start took the history's word. A
+        // migration that redefines a table lacking a column filled the column
+        // with its own name: SQLite reads an unknown "path" as the string 'path'.
+        for (const [label, rootOf] of [
+            ['drops a column', () => dropColumn],
+            ['adds a unique index', () => addUnique],
+        ]) {
+            describe(`that ${label}, on tables that lack part of this release`, () => {
+                it('does not record it over an index dropped by hand', () => __awaiter(this, void 0, void 0, function* () {
+                    const root = rootOf();
+                    const file = copyOf(current);
+                    sql(file, 'DROP INDEX "SessionLog_session_id_createdAt_idx";');
+                    const message = yield stopsNext(file, root);
+                    (0, chai_1.expect)(message).to.match(/differ from what its recorded migrations make: they lack part of what those make/);
+                    (0, chai_1.expect)(message).to.include('session_id, createdAt');
+                    (0, chai_1.expect)(yield recorded(file)).to.deep.equal({ applied: LOCAL_MIGRATIONS, failed: [] });
+                    (0, chai_1.expect)(yield seededRows(file)).to.deep.equal(SEEDED);
+                    (0, chai_1.expect)(trialCopiesOf(file)).to.deep.equal([]);
+                }));
+                // An older release's db push --accept-data-loss (the default through
+                // 2.15.0) takes away the newest migration's column and leaves the history.
+                it('does not record it over a database an older release pushed back', () => __awaiter(this, void 0, void 0, function* () {
+                    const root = rootOf();
+                    const file = copyOf(current);
+                    const older = path_1.default.join(dir, `older-${path_1.default.basename(root)}.prisma`);
+                    fs_1.default.writeFileSync(older, fs_1.default
+                        .readFileSync(SCHEMA, 'utf8')
+                        .replace(/\n(\s*\/\/\/[^\n]*\n)*\s*path\s+String\?\n/, '\n'));
+                    prismaCli(['db', 'push', '--skip-generate', '--accept-data-loss', '--schema', older], file);
+                    (0, chai_1.expect)(matchesSchema(file, older), 'the older release pushed it').to.equal(true);
+                    const message = yield stopsNext(file, root);
+                    (0, chai_1.expect)(message).to.match(/differ from what its recorded migrations make: they lack part of what those make/);
+                    (0, chai_1.expect)(message).to.include('LocatorEtalon');
+                    (0, chai_1.expect)(yield recorded(file)).to.deep.equal({ applied: LOCAL_MIGRATIONS, failed: [] });
+                    (0, chai_1.expect)(yield seededRows(file)).to.deep.equal(SEEDED);
+                    (0, chai_1.expect)(yield columnsOf(file, 'LocatorEtalon')).to.not.include('path');
+                    (0, chai_1.expect)(yield columnsOf(file, 'LocatorEtalon')).to.include('attributes');
+                }));
+            });
+        }
+        // A schema with a change no migration makes (a build from a checkout
+        // someone edited, say): the migrations work on the copy, which still
+        // lacks the change, so the file gets neither them nor a full history.
+        it('does not record a release over tables that lack what its schema has beyond its migrations', () => __awaiter(this, void 0, void 0, function* () {
+            const dropScript = fs_1.default.readFileSync(path_1.default.join(dropColumn, 'prisma', 'migrations', newestOf(dropColumn), 'migration.sql'), 'utf8');
+            const unmigrated = nextRelease('drop_and_unmigrated_index', () => fs_1.default
+                .readFileSync(path_1.default.join(dropColumn, 'prisma', 'schema.prisma'), 'utf8')
+                .replace(/(model Team \{[^}]*?)\n\}/, '$1\n\n  @@index([name, createdAt])\n}'), dropScript, newestOf(dropColumn));
+            const file = copyOf(currentWithHand);
+            const message = yield stopsNext(file, unmigrated);
+            (0, chai_1.expect)(message).to.match(/after this version's migrations a copy of it still lacked part/);
+            (0, chai_1.expect)(message).to.include('name, createdAt');
+            (0, chai_1.expect)(yield recorded(file)).to.deep.equal({ applied: LOCAL_MIGRATIONS, failed: [] });
+            (0, chai_1.expect)(yield handAdded(file)).to.deep.equal(KEPT);
+            (0, chai_1.expect)(yield columnsOf(file, 'LocatorEtalon')).to.include('attributes');
+            (0, chai_1.expect)(trialCopiesOf(file)).to.deep.equal([]);
+        }));
+        // A history that names a migration this release doesn't have (a later
+        // release's, or another branch's) belongs to another release. Through
+        // #493 only re-baselining left it alone: the copy ran this release's
+        // migrations on it and the file got them, dropping a column the other
+        // release still has.
+        it('leaves a database from another release alone', () => __awaiter(this, void 0, void 0, function* () {
+            const elsewhere = nextRelease('elsewhere', (schema) => schema.replace(/(model Team \{\n)/, '$1  elsewhere      String?\n'), 'ALTER TABLE "Team" ADD COLUMN "elsewhere" TEXT;\n', '29980101000000_elsewhere');
+            const file = copyOf(current);
+            prismaCli(['migrate', 'deploy', '--schema', path_1.default.join(elsewhere, 'prisma', 'schema.prisma')], file);
+            sql(file, 'UPDATE "Team" SET "elsewhere" = \'other release\';');
+            const message = yield stopsNext(file, dropColumn);
+            (0, chai_1.expect)(message).to.match(/another release/);
+            (0, chai_1.expect)(message).to.include('29980101000000_elsewhere');
+            const { applied } = yield recorded(file);
+            (0, chai_1.expect)(applied).to.not.include(newestOf(dropColumn));
+            (0, chai_1.expect)(yield query(file, 'SELECT attributes FROM "LocatorEtalon"')).to.have.length(1);
+            (0, chai_1.expect)(trialCopiesOf(file)).to.deep.equal([]);
+        }));
+        // Minor: `npm run db:migrate` warns of a schema edit with no migration.
+        it('tells schema changes with no migration from a schema its migrations make', () => {
+            const unmigrated = path_1.default.join(dir, 'unmigrated');
+            fs_1.default.mkdirSync(path_1.default.join(unmigrated, 'prisma'), { recursive: true });
+            fs_1.default.cpSync(MIGRATIONS, path_1.default.join(unmigrated, 'prisma', 'migrations'), { recursive: true });
+            fs_1.default.copyFileSync(path_1.default.join(dropColumn, 'prisma', 'schema.prisma'), path_1.default.join(unmigrated, 'prisma', 'schema.prisma'));
+            fs_1.default.symlinkSync(path_1.default.join(ROOT, 'node_modules'), path_1.default.join(unmigrated, 'node_modules'));
+            (0, chai_1.expect)((0, run_migrations_1.warnOfUnmigratedSchemaChanges)(undefined, { root: ROOT })).to.equal(false);
+            (0, chai_1.expect)((0, run_migrations_1.warnOfUnmigratedSchemaChanges)(undefined, { root: dropColumn })).to.equal(false);
+            (0, chai_1.expect)((0, run_migrations_1.warnOfUnmigratedSchemaChanges)(undefined, { root: unmigrated })).to.equal(true);
+        });
+    });
+    // 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/);
+    });
+});