@xenon-device-management/xenon 2.16.0 → 2.17.0

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

@@ -19,7 +19,6 @@ 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.
@@ -52,8 +51,8 @@ function prismaCli(args, file, input) {
 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) {
+/** Whether the database's tables are exactly what prisma/schema.prisma says. */
+function matchesSchema(file) {
     try {
         prismaCli([
             'migrate',
@@ -61,7 +60,7 @@ function matchesSchema(file, schema = SCHEMA) {
             '--from-url',
             `file:${file}`,
             '--to-schema-datamodel',
-            schema,
+            SCHEMA,
             '--exit-code',
         ], file);
         return true;
@@ -101,21 +100,18 @@ function recordedHistory(file) {
         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();
+        return [...teams, ...builds].map((r) => `${r.id}=${r.name}`).sort();
     });
 }
-const SEEDED = ['build-1=nightly #42', 'et-1=//b', 'team-1=Payments'];
+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);
@@ -233,53 +229,25 @@ describe('runMigrations against real databases', function () {
         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* () {
+    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);
-        yield expectFullHistory(file);
-        (0, chai_1.expect)(trialCopiesOf(file)).to.deep.equal([]);
+        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, and clears it', () => __awaiter(this, void 0, void 0, function* () {
+    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);
-        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.
+    // 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");';
@@ -298,7 +266,7 @@ describe('runMigrations against real databases', function () {
     function commandsIn(message) {
         return message
             .split('\n')
-            .filter((line) => /^ {2}(DATABASE_URL=|echo |touch )/.test(line))
+            .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. */
@@ -328,13 +296,13 @@ describe('runMigrations against real databases', function () {
     }
     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) {
+    /** 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 IF EXISTS "LabNotes"; DROP INDEX IF EXISTS "lab_team_created";');
-            return matchesSchema(probe, schema);
+            sql(probe, 'DROP TABLE "LabNotes"; DROP INDEX "lab_team_created";');
+            return matchesSchema(probe);
         }
         finally {
             fs_1.default.rmSync(probe, { force: true });
@@ -346,64 +314,63 @@ describe('runMigrations against real databases', function () {
             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* () {
+    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);
-        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);
+        (0, chai_1.expect)(yield recordedHistory(file)).to.have.length(LOCAL_MIGRATIONS.length);
     }));
-    // 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.
+    // 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);
-        // 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 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)(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.
+        (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);
-        (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)(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);
-        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* () {
@@ -414,353 +381,19 @@ describe('runMigrations against real databases', function () {
         (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 backup = commands.find((c) => c.includes('.backup-'));
         const letGo = commands.find((c) => c.includes('--accept-data-loss'));
-        (0, chai_1.expect)(letGo, message).to.include('.backup-');
+        (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(letGo))).to.deep.equal(KEPT);
+        (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);
-        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,