@xenon-device-management/xenon 2.16.0 → 2.17.0

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

@@ -68,7 +68,7 @@ describe('planSchemaSync', () => {
         (0, chai_1.expect)(plan.command).to.equal('migrate deploy');
         (0, chai_1.expect)(compared).to.deep.equal([LOCAL.slice(0, 2)]);
     });
-    it('pushes when the tables match no run of the migrations, so deploy would redo a change', () => {
+    it('pushes when the tables are ahead of the history, so deploy would redo a change', () => {
         const history = { applied: LOCAL.slice(0, 1), failed: [] };
         const plan = (0, run_migrations_1.planSchemaSync)(history, LOCAL, () => false);
         (0, chai_1.expect)(plan.command).to.equal('db push');
@@ -76,7 +76,6 @@ describe('planSchemaSync', () => {
         (0, chai_1.expect)(plan.reason).to.match(/differ from what its recorded migrations make/);
         // The failure message depends on why: see schemaSyncFailure.
         (0, chai_1.expect)(plan.basis).to.equal('tables-differ');
-        (0, chai_1.expect)(plan.resolve).to.equal(undefined);
     });
     it('deploys, as the history says, when the tables could not be compared', () => {
         const history = { applied: LOCAL.slice(0, 1), failed: [] };
@@ -84,234 +83,15 @@ describe('planSchemaSync', () => {
         (0, chai_1.expect)(plan.command).to.equal('migrate deploy');
         (0, chai_1.expect)(plan.reason).to.match(/could not be compared/);
     });
-    it('pushes a database whose history records a failed migration and whose tables match no run of the migrations', () => {
+    it('pushes a database whose history records a failed migration', () => {
         const history = { applied: LOCAL.slice(0, 2), failed: [LOCAL[2]] };
-        const plan = (0, run_migrations_1.planSchemaSync)(history, LOCAL, () => false);
+        const plan = (0, run_migrations_1.planSchemaSync)(history, LOCAL, unasked);
         (0, chai_1.expect)(plan.command).to.equal('db push');
         (0, chai_1.expect)(plan.acceptDataLoss).to.equal(false);
         (0, chai_1.expect)(plan.reason).to.include(LOCAL[2]);
         (0, chai_1.expect)(plan.basis).to.equal('failed-migration');
         (0, chai_1.expect)(plan.failed).to.deep.equal([LOCAL[2]]);
     });
-    // Re-baselining. db push writes no history, so a history behind its tables,
-    // or one with a failed migration, stayed on db push for good: at the first
-    // release whose migration drops a column or adds a unique index, db push
-    // without --accept-data-loss refused it. When the tables are exactly what
-    // the first k migrations make, the history can say so.
-    describe('re-baselining', () => {
-        const FOUR = [...LOCAL, '20250104_d'];
-        it('records the migrations the tables already have, then deploys the rest', () => {
-            const history = { applied: FOUR.slice(0, 1), failed: [] };
-            const compared = [];
-            const plan = (0, run_migrations_1.planSchemaSync)(history, FOUR, (migrations) => {
-                compared.push(migrations.length);
-                return migrations.length === 3;
-            });
-            (0, chai_1.expect)(plan.command).to.equal('migrate deploy');
-            (0, chai_1.expect)(plan.basis).to.equal('rebaselined');
-            (0, chai_1.expect)(plan.resolve).to.deep.equal({ rolledBack: [], applied: FOUR.slice(1, 3) });
-            (0, chai_1.expect)(plan.reason).to.match(/first 3 migrations/);
-            // The history first; then every migration (what db push leaves); then
-            // down; then one below the match, which must not match too.
-            (0, chai_1.expect)(compared).to.deep.equal([1, 4, 3, 2]);
-        });
-        // Prisma's comparison sees tables, never rows: a backfill makes the same
-        // tables as the migrations before it. Through #493 the largest k that
-        // matched won, so the backfill was recorded as applied and never ran.
-        it('runs a migration the comparison cannot see rather than record it', () => {
-            const history = { applied: FOUR.slice(0, 2), failed: [] };
-            const compared = [];
-            const plan = (0, run_migrations_1.planSchemaSync)(history, FOUR, (migrations) => {
-                compared.push(migrations.length);
-                return migrations.length >= 3;
-            });
-            (0, chai_1.expect)(plan.basis).to.equal('rebaselined');
-            (0, chai_1.expect)(plan.resolve).to.deep.equal({ rolledBack: [], applied: [FOUR[2]] });
-            (0, chai_1.expect)(plan.reason).to.match(/first 3 migrations/);
-            (0, chai_1.expect)(compared).to.deep.equal([2, 4, 3]);
-        });
-        const dup = 'Database error code: 1\n\nDatabase error:\nduplicate column name: path';
-        const notNull = 'Database error code: 1299\n\nDatabase error:\nNOT NULL constraint failed: Team.name';
-        it('rolls a failed migration back first, and records it as applied when the tables have it', () => {
-            const history = {
-                applied: FOUR.slice(0, 2),
-                failed: [FOUR[2]],
-                failureLogs: { [FOUR[2]]: dup },
-            };
-            const plan = (0, run_migrations_1.planSchemaSync)(history, FOUR, (migrations) => migrations.length === 4);
-            (0, chai_1.expect)(plan.command).to.equal('migrate deploy');
-            (0, chai_1.expect)(plan.basis).to.equal('rebaselined');
-            (0, chai_1.expect)(plan.resolve).to.deep.equal({ rolledBack: [FOUR[2]], applied: FOUR.slice(2, 4) });
-        });
-        // The rows a migration failed on stay as they were until someone changes
-        // them, and a migration can fail after its first statements ran. Through
-        // #493 the start after such a failure recorded it as applied.
-        it('leaves a failed migration alone when the tables have what it makes but it failed on the rows', () => {
-            var _a;
-            const history = {
-                applied: FOUR.slice(0, 3),
-                failed: [FOUR[3]],
-                failureLogs: { [FOUR[3]]: notNull },
-            };
-            const plan = (0, run_migrations_1.planSchemaSync)(history, FOUR, (migrations) => migrations.length === 4);
-            (0, chai_1.expect)(plan.command).to.equal('none');
-            (0, chai_1.expect)(plan.basis).to.equal('failed-unresolved');
-            (0, chai_1.expect)(plan.resolve).to.equal(undefined);
-            (0, chai_1.expect)(plan.unresolved).to.deep.include({ migration: FOUR[3], why: 'part-way' });
-            (0, chai_1.expect)((_a = plan.unresolved) === null || _a === void 0 ? void 0 : _a.logs).to.include('NOT NULL');
-        });
-        it('leaves a failed migration alone when its record says nothing of why it failed', () => {
-            const history = { applied: FOUR.slice(0, 3), failed: [FOUR[3]] };
-            const plan = (0, run_migrations_1.planSchemaSync)(history, FOUR, (migrations) => migrations.length === 4);
-            (0, chai_1.expect)(plan.basis).to.equal('failed-unresolved');
-        });
-        const backfill = { statements: 1, unseen: ['UPDATE "Team" SET "name" = ...'] };
-        const twoBackfills = {
-            statements: 2,
-            unseen: ['UPDATE "Team" SET "a" = 1', 'UPDATE "Team" SET "b" = 2'],
-        };
-        const shapes = (special) => (name) => { var _a; return (_a = special[name]) !== null && _a !== void 0 ? _a : { statements: 1, unseen: [] }; };
-        it('rolls back a one-statement backfill that failed, so deploy runs it again', () => {
-            const history = {
-                applied: FOUR.slice(0, 3),
-                failed: [FOUR[3]],
-                failureLogs: { [FOUR[3]]: notNull },
-            };
-            const plan = (0, run_migrations_1.planSchemaSync)(history, FOUR, (migrations) => migrations.length >= 3, shapes({ [FOUR[3]]: backfill }));
-            (0, chai_1.expect)(plan.basis).to.equal('rebaselined');
-            (0, chai_1.expect)(plan.resolve).to.deep.equal({ rolledBack: [FOUR[3]], applied: [] });
-        });
-        it("leaves a failed backfill of several statements alone: the tables can't show how far it got", () => {
-            const history = {
-                applied: FOUR.slice(0, 3),
-                failed: [FOUR[3]],
-                failureLogs: { [FOUR[3]]: notNull },
-            };
-            const plan = (0, run_migrations_1.planSchemaSync)(history, FOUR, (migrations) => migrations.length >= 3, shapes({ [FOUR[3]]: twoBackfills }));
-            (0, chai_1.expect)(plan.command).to.equal('none');
-            (0, chai_1.expect)(plan.unresolved).to.deep.include({ migration: FOUR[3], why: 'part-way' });
-        });
-        it("never records a failed migration as applied when part of it is what the tables can't show", () => {
-            const history = {
-                applied: FOUR.slice(0, 3),
-                failed: [FOUR[3]],
-                failureLogs: { [FOUR[3]]: dup },
-            };
-            const plan = (0, run_migrations_1.planSchemaSync)(history, FOUR, (migrations) => migrations.length === 4, shapes({ [FOUR[3]]: { statements: 2, unseen: ['UPDATE "LocatorEtalon" ...'] } }));
-            (0, chai_1.expect)(plan.command).to.equal('none');
-            (0, chai_1.expect)(plan.unresolved).to.deep.include({ migration: FOUR[3], why: 'unseen-part' });
-        });
-        it("keeps a database on db push when a migration it would record changes what the tables can't show", () => {
-            const history = { applied: FOUR.slice(0, 1), failed: [] };
-            const plan = (0, run_migrations_1.planSchemaSync)(history, FOUR, (migrations) => migrations.length === 3, shapes({ [FOUR[1]]: backfill }));
-            (0, chai_1.expect)(plan.command).to.equal('db push');
-            (0, chai_1.expect)(plan.acceptDataLoss).to.equal(false);
-            (0, chai_1.expect)(plan.basis).to.equal('unrecordable');
-            (0, chai_1.expect)(plan.unseen).to.deep.equal([FOUR[1]]);
-            (0, chai_1.expect)(plan.resolve).to.equal(undefined);
-        });
-        it('leaves a failed migration of several statements alone when the tables match no run', () => {
-            const history = { applied: FOUR.slice(0, 3), failed: [FOUR[3]] };
-            const plan = (0, run_migrations_1.planSchemaSync)(history, FOUR, () => false, shapes({ [FOUR[3]]: twoBackfills }));
-            (0, chai_1.expect)(plan.command).to.equal('none');
-            (0, chai_1.expect)(plan.basis).to.equal('failed-unresolved');
-        });
-        it('rolls back a failed migration that left the tables as they were, so deploy runs it again', () => {
-            const history = { applied: FOUR.slice(0, 2), failed: [FOUR[2]] };
-            const compared = [];
-            const plan = (0, run_migrations_1.planSchemaSync)(history, FOUR, (migrations) => {
-                compared.push(migrations.length);
-                return migrations.length === 2;
-            });
-            (0, chai_1.expect)(plan.command).to.equal('migrate deploy');
-            (0, chai_1.expect)(plan.resolve).to.deep.equal({ rolledBack: [FOUR[2]], applied: [] });
-            // Every migration first, then the history's own, before the rest.
-            (0, chai_1.expect)(compared).to.deep.equal([4, 2]);
-        });
-        it('never records fewer migrations than the history has', () => {
-            const history = { applied: FOUR.slice(0, 3), failed: [] };
-            const compared = [];
-            (0, run_migrations_1.planSchemaSync)(history, FOUR, (migrations) => {
-                compared.push(migrations.length);
-                return false;
-            });
-            (0, chai_1.expect)(Math.min(...compared)).to.equal(3);
-        });
-        it('stops looking when the tables cannot be compared', () => {
-            const history = { applied: FOUR.slice(0, 1), failed: [] };
-            const compared = [];
-            const plan = (0, run_migrations_1.planSchemaSync)(history, FOUR, (migrations) => {
-                compared.push(migrations.length);
-                return migrations.length === 1 ? false : null;
-            });
-            (0, chai_1.expect)(plan.command).to.equal('db push');
-            (0, chai_1.expect)(plan.basis).to.equal('tables-differ');
-            (0, chai_1.expect)(compared).to.deep.equal([1, 4]);
-        });
-        it('records a migration missing from the middle of the history when the tables have it', () => {
-            const history = { applied: [FOUR[0], FOUR[2]], failed: [] };
-            const plan = (0, run_migrations_1.planSchemaSync)(history, FOUR, (migrations) => migrations.length === 3);
-            (0, chai_1.expect)(plan.command).to.equal('migrate deploy');
-            (0, chai_1.expect)(plan.resolve).to.deep.equal({ rolledBack: [], applied: [FOUR[1]] });
-        });
-        // A history that names a migration this release doesn't have (another
-        // branch's, or a later release's) is not this release's to rewrite.
-        it('leaves a history that names a migration this release lacks as it is', () => {
-            const history = { applied: [...LOCAL, '20990101_elsewhere'], failed: [] };
-            const compared = [];
-            const plan = (0, run_migrations_1.planSchemaSync)(history, FOUR, (migrations) => {
-                compared.push(migrations.length);
-                return false;
-            });
-            (0, chai_1.expect)(plan.command).to.equal('db push');
-            (0, chai_1.expect)(plan.basis).to.equal('other-release');
-            (0, chai_1.expect)(plan.unknown).to.deep.equal(['20990101_elsewhere']);
-            (0, chai_1.expect)(plan.resolve).to.equal(undefined);
-            (0, chai_1.expect)(compared, 'only the history itself').to.deep.equal([3]);
-        });
-    });
-});
-describe('migrationShape', () => {
-    it('counts what the tables show: tables, columns, indexes and the copy of a redefined table', () => {
-        const shape = (0, run_migrations_1.migrationShape)('-- RedefineTables\nPRAGMA defer_foreign_keys=ON;\nPRAGMA foreign_keys=OFF;\n' +
-            'CREATE TABLE "new_Team" ("id" TEXT NOT NULL PRIMARY KEY, "name" TEXT NOT NULL);\n' +
-            'INSERT INTO "new_Team" ("id", "name") SELECT "id", "name" FROM "Team";\n' +
-            'DROP TABLE "Team";\nALTER TABLE "new_Team" RENAME TO "Team";\n' +
-            'CREATE UNIQUE INDEX "Team_name_key" ON "Team"("name");\n' +
-            'CREATE INDEX "x" ON "Team"("name") WHERE "name" IS NOT NULL;\n' +
-            'DROP INDEX "y";\nPRAGMA foreign_keys=ON;\n');
-        (0, chai_1.expect)(shape).to.deep.equal({ statements: 7, unseen: [] });
-    });
-    it("finds what the tables can't show: rows, triggers, views, collations", () => {
-        const shape = (0, run_migrations_1.migrationShape)('UPDATE "Team" SET "name" = \'a; b\' || "name"; -- a comment; with a semicolon\n' +
-            'INSERT INTO "TeamMember" ("teamId") SELECT "id" FROM "Team";\n' +
-            'DELETE FROM "Log";\n' +
-            'CREATE VIEW "v" AS SELECT 1;\n' +
-            'CREATE TRIGGER "t" AFTER UPDATE ON "Team" BEGIN SELECT 1; END;\n' +
-            'CREATE INDEX "c" ON "Team"("name" COLLATE NOCASE);\n' +
-            '/* a block; comment */ INSERT INTO "new_Team" ("id") SELECT "id" FROM "Other";\n');
-        (0, chai_1.expect)(shape.unseen).to.have.length(8);
-        (0, chai_1.expect)(shape.unseen[0]).to.match(/^UPDATE "Team" SET "name" = 'a; b'/);
-        (0, chai_1.expect)(shape.statements).to.equal(8);
-    });
-});
-describe('schemaMissingIn', () => {
-    it('finds nothing missing where the database only has more', () => {
-        (0, chai_1.expect)((0, run_migrations_1.schemaMissingIn)('No difference detected.\n')).to.equal(null);
-        (0, chai_1.expect)((0, run_migrations_1.schemaMissingIn)('\n[+] Added tables\n  - LabNotes\n\n[*] Changed the `Team` table\n' +
-            '  [+] Added column `labCol`\n  [+] Added index on columns (createdAt)\n')).to.equal(null);
-    });
-    it('lists what the database lacks, with its table', () => {
-        const missing = (0, run_migrations_1.schemaMissingIn)('\n[+] Added tables\n  - LabNotes\n\n[*] Redefined table `LocatorEtalon`\n\n' +
-            '[*] Changed the `SessionLog` table\n  [-] Removed index on columns (session_id, createdAt)\n' +
-            '\n[*] Changed the `Team` table\n  [+] Added column `labCol`\n');
-        (0, chai_1.expect)(missing).to.equal('[*] Redefined table `LocatorEtalon`\n[*] Changed the `SessionLog` table\n' +
-            '  [-] Removed index on columns (session_id, createdAt)');
-    });
-    it("counts a line it doesn't know as missing", () => {
-        (0, chai_1.expect)((0, run_migrations_1.schemaMissingIn)('Something new from Prisma')).to.equal('Something new from Prisma');
-        (0, chai_1.expect)((0, run_migrations_1.schemaMissingIn)('[-] Removed tables\n  - Session')).to.equal('[-] Removed tables\n  - Session');
-    });
 });
 describe('runMigrations chooses by the database, not by databaseProvider', () => {
     const scratchUrl = `file:${path_1.default.join(os_1.default.tmpdir(), `xenon-choose-${process.pid}-absent.db`)}`;
@@ -374,38 +154,20 @@ describe('runMigrations: what each plan runs', () => {
         Object.assign(config_1.config, saved);
         sinon_1.default.restore();
     });
-    /**
-     * Every prisma call's arguments and database URL, answered by the given
-     * steps: `diff` compares the tables with a run of migrations (`--exit-code`),
-     * `lack` lists what the tables lack of the recorded migrations before a
-     * copy, `check` what the copy lacks of the schema after the migrations,
-     * `resolve` writes the history, and `update` is the rest. A summary step
-     * left out finds nothing missing.
-     */
+    /** Every prisma call's arguments, with `diff` and the update answered by the given steps. */
     function run(history_1) {
-        return __awaiter(this, arguments, void 0, function* (history, steps = {}, options = {}) {
+        return __awaiter(this, arguments, void 0, function* (history, steps = {}) {
             const calls = [];
-            const urls = [];
             try {
-                yield (0, run_migrations_1.runMigrations)((_cmd, args, opts) => {
-                    const url = String(opts.env.DATABASE_URL);
+                yield (0, run_migrations_1.runMigrations)((_cmd, args) => {
                     calls.push(args);
-                    urls.push(url);
-                    if (args.includes('diff') && !args.includes('--exit-code')) {
-                        const summary = args.includes('--to-url') ? steps.check : steps.lack;
-                        return summary ? summary(args, url) : Buffer.from('No difference detected.\n');
-                    }
-                    const step = args.includes('diff')
-                        ? steps.diff
-                        : args.includes('resolve')
-                            ? steps.resolve
-                            : steps.update;
-                    return step ? step(args, url) : Buffer.from('ok');
-                }, () => __awaiter(this, void 0, void 0, function* () { return history; }), options);
-                return { calls, urls };
+                    const step = args.includes('diff') ? steps.diff : steps.update;
+                    return step ? step(args) : Buffer.from('ok');
+                }, () => __awaiter(this, void 0, void 0, function* () { return history; }));
+                return { calls };
             }
             catch (error) {
-                return { calls, urls, error };
+                return { calls, error };
             }
         });
     }
@@ -417,47 +179,19 @@ describe('runMigrations: what each plan runs', () => {
         });
     };
     const update = (calls) => calls[calls.length - 1];
-    /** The number of migrations a `migrate diff --from-migrations <dir>` call builds. */
-    const migrationsIn = (args) => fs_1.default.readdirSync(args[args.indexOf('--from-migrations') + 1]).filter((n) => !n.endsWith('.toml'))
-        .length;
-    /** A diff that finds the tables equal to the first `k` migrations, and only those. */
-    const tablesAreFirst = (k) => (args) => migrationsIn(args) === k ? Buffer.from('') : fail(2, '')();
-    /** The prisma subcommands called, as words: `migrate resolve --applied x`. */
-    const words = (calls) => calls.map((args) => args
-        .filter((a) => !a.includes(path_1.default.sep) && a !== '--schema' && a !== '--exit-code')
-        .join(' '));
-    // What `db push` without --accept-data-loss prints when it would drop a table
-    // that holds rows: the list on stdout, the refusal on stderr.
-    const refusesDataLoss = fail(1, 'Error: Use the --accept-data-loss flag to ignore the data loss warnings like prisma db push --accept-data-loss', '⚠️  There might be data loss when applying the changes:\n\n' +
-        '  • You are about to drop the `LabNotes` table, which is not empty (1 rows).');
-    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 scratchFile = scratchUrl.slice('file:'.length);
-    /** The commands a failure message gives, one to an indented line, in its order. */
-    const commandsIn = (message) => message
-        .split('\n')
-        .filter((line) => /^ {2}(DATABASE_URL=|echo |touch )/.test(line))
-        .map((line) => line.trim());
-    const letGo = `DATABASE_URL=file:${scratchFile} ${prisma} db push --skip-generate --accept-data-loss ` +
-        `--schema ${schema}`;
-    const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    /** One command: a backup, and once it is made, `letGo`. */
-    const letGoAfterBackup = new RegExp(`^(touch \\S+ && chmod [0-7]{3} \\S+ && )?echo "VACUUM INTO '${escape(scratchFile)}\\.backup-` +
-        `\\d{8}T\\d{9}Z'" \\| \\S+ db execute --url \\S+ --stdin && ${escape(letGo)}$`);
     it('accepts data loss only for a database with no history, as the default always did', () => __awaiter(void 0, void 0, void 0, function* () {
         const { calls } = yield run(null);
         (0, chai_1.expect)(update(calls)).to.include.members(['db', 'push', '--accept-data-loss']);
     }));
-    it('pushes without accepting data loss when the tables match no run of the migrations', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('pushes without accepting data loss when the tables differ from the history', () => __awaiter(void 0, void 0, void 0, function* () {
         const history = { applied: everyMigration.slice(0, -1), failed: [] };
         const { calls } = yield run(history, { diff: fail(2, '') });
         (0, chai_1.expect)(update(calls)).to.include.members(['db', 'push']);
         (0, chai_1.expect)(update(calls)).to.not.include('--accept-data-loss');
     }));
-    it('pushes without accepting data loss when the history records a failed migration and the tables match no run', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('pushes without accepting data loss when the history records a failed migration', () => __awaiter(void 0, void 0, void 0, function* () {
         const history = { applied: everyMigration.slice(0, -1), failed: everyMigration.slice(-1) };
-        const { calls } = yield run(history, { diff: fail(2, '') });
+        const { calls } = yield run(history);
         (0, chai_1.expect)(update(calls)).to.include.members(['db', 'push']);
         (0, chai_1.expect)(update(calls)).to.not.include('--accept-data-loss');
     }));
@@ -466,381 +200,91 @@ describe('runMigrations: what each plan runs', () => {
         const { calls } = yield run(history);
         (0, chai_1.expect)(update(calls)).to.include.members(['migrate', 'deploy']);
     }));
-    // The default setting's db push moved a migrate-deploy database's tables
-    // past its history. Recording what they have puts it back on migrate deploy.
-    it('records the migrations the tables already have, then deploys, without db push', () => __awaiter(void 0, void 0, void 0, function* () {
-        const newest = everyMigration[everyMigration.length - 1];
-        const history = { applied: everyMigration.slice(0, -1), failed: [] };
-        const { calls, error } = yield run(history, { diff: tablesAreFirst(everyMigration.length) });
-        (0, chai_1.expect)(error).to.equal(undefined);
-        (0, chai_1.expect)(words(calls).filter((w) => !w.startsWith('migrate diff'))).to.deep.equal([
-            `migrate resolve --applied ${newest}`,
-            'migrate deploy',
-        ]);
-    }));
-    it('rolls a failed migration back before recording it as applied', () => __awaiter(void 0, void 0, void 0, function* () {
-        const newest = everyMigration[everyMigration.length - 1];
-        const history = {
-            applied: everyMigration.slice(0, -1),
-            failed: [newest],
-            failureLogs: { [newest]: 'Database error:\nduplicate column name: path' },
-        };
-        const { calls, error } = yield run(history, { diff: tablesAreFirst(everyMigration.length) });
-        (0, chai_1.expect)(error).to.equal(undefined);
-        (0, chai_1.expect)(words(calls).filter((w) => !w.startsWith('migrate diff'))).to.deep.equal([
-            `migrate resolve --rolled-back ${newest}`,
-            `migrate resolve --applied ${newest}`,
-            'migrate deploy',
-        ]);
-    }));
-    // The start after a migration failed on the rows: the history stays as it
-    // is, nothing runs, and the message says how to finish or undo it.
-    it('changes nothing, and says how to finish or undo it, for a failed migration it cannot resolve', () => __awaiter(void 0, void 0, void 0, function* () {
+    // What `db push` without --accept-data-loss prints when it would drop a table
+    // that holds rows: the list on stdout, the refusal on stderr.
+    const refusesDataLoss = fail(1, 'Error: Use the --accept-data-loss flag to ignore the data loss warnings like prisma db push --accept-data-loss', '⚠️  There might be data loss when applying the changes:\n\n' +
+        '  • You are about to drop the `LabNotes` table, which is not empty (1 rows).');
+    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 scratchFile = scratchUrl.slice('file:'.length);
+    /** The commands a failure message gives, one to an indented line, in its order. */
+    const commandsIn = (message) => message
+        .split('\n')
+        .filter((line) => /^ {2}(DATABASE_URL=|echo )/.test(line))
+        .map((line) => line.trim());
+    const letGo = `DATABASE_URL=file:${scratchFile} ${prisma} db push --skip-generate --accept-data-loss ` +
+        `--schema ${schema}`;
+    // A history database whose tables differ from its migrations: `migrate
+    // deploy` works on it when something was added by hand, and fails (P3018)
+    // when db push moved the tables past the history. The message can't tell
+    // which, so it never sends migrate deploy to the file before a copy.
+    it('says how to let go of what db push would delete, or keep it by trying migrate deploy on a copy first', () => __awaiter(void 0, void 0, void 0, function* () {
         var _a;
-        const newest = everyMigration[everyMigration.length - 1];
-        const history = {
-            applied: everyMigration.slice(0, -1),
-            failed: [newest],
-            failureLogs: {
-                [newest]: 'Database error:\nNOT NULL constraint failed: Team.name\n\n   0: sql_schema_connector::apply',
-            },
-        };
-        const { calls, error } = yield run(history, { diff: tablesAreFirst(everyMigration.length) });
+        const history = { applied: everyMigration.slice(0, -1), failed: [] };
+        const { error } = yield run(history, { diff: fail(2, ''), update: refusesDataLoss });
         (0, chai_1.expect)(error, 'the start stops').to.be.an('Error');
-        (0, chai_1.expect)(words(calls).filter((w) => !w.startsWith('migrate diff'))).to.deep.equal([]);
         const message = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : '';
-        (0, chai_1.expect)(message).to.include(newest);
-        (0, chai_1.expect)(message).to.match(/part of it may be in the tables/);
-        (0, chai_1.expect)(message).to.include('NOT NULL constraint failed: Team.name');
-        (0, chai_1.expect)(message, 'without the engine stack').to.not.include('sql_schema_connector');
-        (0, chai_1.expect)(message).to.include(path_1.default.join(root, 'prisma', 'migrations', newest, 'migration.sql'));
+        (0, chai_1.expect)(message).to.match(/stopped rather than delete/);
+        (0, chai_1.expect)(message).to.match(/differ from what its recorded migrations make/);
+        // Prisma's own list of what it would drop, which is only on stdout.
+        (0, chai_1.expect)(message).to.include('LabNotes');
+        (0, chai_1.expect)(message).to.not.match(/required column/);
+        (0, chai_1.expect)(message, 'no plain advice to migrate deploy the file').to.not.match(/by hand with prisma migrate deploy/);
         const commands = commandsIn(message);
-        (0, chai_1.expect)(commands).to.include(`DATABASE_URL=file:${scratchFile} ${prisma} migrate resolve --applied ${newest} --schema ${schema}`);
-        (0, chai_1.expect)(commands).to.include(`DATABASE_URL=file:${scratchFile} ${prisma} migrate resolve --rolled-back ${newest} --schema ${schema}`);
+        const backup = commands.findIndex((c) => c.includes(`VACUUM INTO '${scratchFile}.backup-`) &&
+            c.endsWith(`| ${prisma} db execute --url file:${scratchFile} --stdin`));
+        (0, chai_1.expect)(backup, `a backup first:\n${message}`).to.equal(0);
+        (0, chai_1.expect)(commands).to.include(letGo);
+        const onCopy = commands.findIndex((c) => c.startsWith(`DATABASE_URL=file:${scratchFile}.copy ${prisma} migrate deploy --schema ${schema}`));
+        const copied = commands.findIndex((c) => c.includes(`VACUUM INTO '${scratchFile}.copy'`));
+        const onFile = commands.indexOf(`DATABASE_URL=file:${scratchFile} ${prisma} migrate deploy --schema ${schema}`);
+        (0, chai_1.expect)(copied, 'the copy is made').to.be.greaterThan(backup);
+        (0, chai_1.expect)(onCopy, 'migrate deploy runs on the copy').to.be.greaterThan(copied);
+        (0, chai_1.expect)(onFile, 'and on the file only after the copy').to.be.greaterThan(onCopy);
     }));
-    describe('the copy', () => {
-        const trialPrefix = `${path_1.default.basename(scratchFile)}.xenon-trial-`;
-        const trialFiles = () => fs_1.default.readdirSync(path_1.default.dirname(scratchFile)).filter((n) => n.startsWith(trialPrefix));
-        beforeEach(() => {
-            fs_1.default.writeFileSync(scratchFile, '');
-        });
-        afterEach(() => {
-            fs_1.default.rmSync(scratchFile, { force: true });
-            for (const name of trialFiles())
-                fs_1.default.rmSync(path_1.default.join(path_1.default.dirname(scratchFile), name));
-        });
-        /** A copier that makes the file it is asked for, and notes where. */
-        function copier(made) {
-            return (_from, to) => __awaiter(this, void 0, void 0, function* () {
-                made.push(to);
-                fs_1.default.writeFileSync(to, 'copy');
-            });
-        }
-        const roomy = () => 1e12;
-        it('runs migrate deploy on a copy next to the database first, then on the database', () => __awaiter(void 0, void 0, void 0, function* () {
-            const made = [];
-            const history = { applied: everyMigration.slice(0, -1), failed: [] };
-            const { calls, urls, error } = yield run(history, { diff: fail(2, '') }, { copyDatabase: copier(made), freeBytes: roomy });
-            (0, chai_1.expect)(error).to.equal(undefined);
-            (0, chai_1.expect)(made).to.have.length(1);
-            (0, chai_1.expect)(path_1.default.dirname(made[0])).to.equal(path_1.default.dirname(scratchFile));
-            (0, chai_1.expect)(path_1.default.basename(made[0])).to.equal(`${trialPrefix}${process.pid}`);
-            const deploys = urls.filter((_, i) => calls[i].includes('deploy'));
-            (0, chai_1.expect)(deploys).to.deep.equal([`file:${made[0]}`, scratchUrl]);
-            (0, chai_1.expect)(calls.some((args) => args.includes('push')), 'no db push').to.equal(false);
-            (0, chai_1.expect)(trialFiles(), 'the copy is deleted').to.deep.equal([]);
-        }));
-        it('rolls a failed migration back on the copy first, and on the database only when the copy took the rest', () => __awaiter(void 0, void 0, void 0, function* () {
-            const made = [];
-            const newest = everyMigration[everyMigration.length - 1];
-            const history = { applied: everyMigration.slice(0, -1), failed: [newest] };
-            const { calls, urls, error } = yield run(history, { diff: fail(2, '') }, { copyDatabase: copier(made), freeBytes: roomy });
-            (0, chai_1.expect)(error).to.equal(undefined);
-            const steps = calls
-                .map((args, i) => ({ word: words([args])[0], url: urls[i] }))
-                .filter((c) => !c.word.startsWith('migrate diff'));
-            (0, chai_1.expect)(steps).to.deep.equal([
-                { word: `migrate resolve --rolled-back ${newest}`, url: `file:${made[0]}` },
-                { word: 'migrate deploy', url: `file:${made[0]}` },
-                { word: `migrate resolve --rolled-back ${newest}`, url: scratchUrl },
-                { word: 'migrate deploy', url: scratchUrl },
-            ]);
-        }));
-        it('falls back to db push without the flag when the copy fails, and never deploys to the database', () => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            const made = [];
-            const history = { applied: everyMigration.slice(0, -1), failed: [] };
-            const { calls, urls, error } = yield run(history, {
-                diff: fail(2, ''),
-                update: (args, url) => {
-                    if (args.includes('deploy')) {
-                        return fail(1, 'Error: P3018\n\nA migration failed to apply.\n\nMigration name: ' +
-                            `${everyMigration[everyMigration.length - 1]}\n\nDatabase error:\nduplicate column name: path`)();
-                    }
-                    (0, chai_1.expect)(url).to.equal(scratchUrl);
-                    return refusesDataLoss();
-                },
-            }, { copyDatabase: copier(made), freeBytes: roomy });
-            const deploys = urls.filter((_, i) => calls[i].includes('deploy'));
-            (0, chai_1.expect)(deploys).to.deep.equal([`file:${made[0]}`]);
-            (0, chai_1.expect)(update(calls)).to.include.members(['db', 'push']);
-            (0, chai_1.expect)(update(calls)).to.not.include('--accept-data-loss');
-            (0, chai_1.expect)(trialFiles()).to.deep.equal([]);
-            const message = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : '';
-            (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, "the copy's own reason").to.include('duplicate column name: path');
-            (0, chai_1.expect)(message).to.include('LabNotes');
-            const commands = commandsIn(message);
-            (0, chai_1.expect)(commands[0]).to.include(`VACUUM INTO '${scratchFile}.backup-`);
-            (0, chai_1.expect)(commands[0], 'let go only once backed up').to.match(letGoAfterBackup);
-            (0, chai_1.expect)(commands.filter((c) => c.includes('migrate deploy'))).to.deep.equal([]);
-        }));
-        it("skips the copy when there isn't room for it next to the database", () => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            const made = [];
-            const history = { applied: everyMigration.slice(0, -1), failed: [] };
-            fs_1.default.writeFileSync(scratchFile, Buffer.alloc(1024 * 1024));
-            const { calls, error } = yield run(history, { diff: fail(2, ''), update: refusesDataLoss }, { copyDatabase: copier(made), freeBytes: () => 1024 * 1024 });
-            (0, chai_1.expect)(made, 'no copy').to.deep.equal([]);
-            (0, chai_1.expect)(calls.some((args) => args.includes('deploy'))).to.equal(false);
-            (0, chai_1.expect)(update(calls)).to.include.members(['db', 'push']);
-            (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.match(/room/);
-            (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.match(/MB/);
-            (0, chai_1.expect)(commandsIn((_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : '')[0]).to.match(letGoAfterBackup);
-            (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.include(`free ${Math.ceil((2 * 1024 * 1024 + 64 * 1024 * 1024) / (1024 * 1024))} MB`);
-        }));
-        it('skips the copy when the database is locked', () => __awaiter(void 0, void 0, void 0, function* () {
-            const history = { applied: everyMigration.slice(0, -1), failed: [] };
-            const { calls, error } = yield run(history, { diff: fail(2, ''), update: refusesDataLoss }, {
-                copyDatabase: () => __awaiter(void 0, void 0, void 0, function* () {
-                    throw new Error('Raw query failed. Code: `5`. Message: `database is locked`');
-                }),
-                freeBytes: roomy,
-            });
-            (0, chai_1.expect)(calls.some((args) => args.includes('deploy'))).to.equal(false);
-            (0, chai_1.expect)(update(calls)).to.include.members(['db', 'push']);
-            (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.match(/locked/);
-            (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.match(/another server/);
-            (0, chai_1.expect)(trialFiles()).to.deep.equal([]);
-        }));
-        // migrate deploy builds on what the recorded migrations made. Through #493
-        // a copy it worked on stood for the file, even where the tables lacked
-        // part of that (an index dropped by hand, a column an older release's db
-        // push took away), and the file then got a full history over the gap.
-        it("doesn't try the copy when the tables lack part of what their recorded migrations make", () => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            const made = [];
-            const history = { applied: everyMigration.slice(0, -1), failed: [] };
-            const lacking = '[*] Changed the `SessionLog` table\n  [-] Removed index on columns (session_id, createdAt)';
-            const { calls, error } = yield run(history, {
-                diff: fail(2, ''),
-                lack: () => Buffer.from(`\n[+] Added tables\n  - LabNotes\n\n${lacking}\n`),
-                update: refusesDataLoss,
-            }, { copyDatabase: copier(made), freeBytes: roomy });
-            (0, chai_1.expect)(made, 'no copy').to.deep.equal([]);
-            (0, chai_1.expect)(calls.some((args) => args.includes('deploy'))).to.equal(false);
-            (0, chai_1.expect)(update(calls)).to.include.members(['db', 'push']);
-            (0, chai_1.expect)(update(calls)).to.not.include('--accept-data-loss');
-            const message = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : '';
-            (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(lacking);
-            (0, chai_1.expect)(message).to.not.include('LabNotes\n  - ');
-        }));
-        it('says both reasons when a database with a failed migration also lacks part of its migrations', () => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            const made = [];
-            const newest = everyMigration[everyMigration.length - 1];
-            const history = { applied: everyMigration.slice(0, -1), failed: [newest] };
-            const { error } = yield run(history, {
-                diff: fail(2, ''),
-                lack: () => Buffer.from('[*] Redefined table `LocatorEtalon`\n'),
-                update: refusesDataLoss,
-            }, { copyDatabase: copier(made), freeBytes: roomy });
-            (0, chai_1.expect)(made, 'no copy').to.deep.equal([]);
-            const message = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : '';
-            (0, chai_1.expect)(message).to.match(new RegExp(`records a failed migration \\(${newest}\\), which prisma migrate deploy won't run ` +
-                'past, and its tables lack part of what its recorded migrations make'));
-        }));
-        it("doesn't run the migrations on the database when the copy still lacks part of the schema", () => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            const made = [];
-            const history = { applied: everyMigration.slice(0, -1), failed: [] };
-            const { calls, urls, error } = yield run(history, {
-                diff: fail(2, ''),
-                check: (args) => {
-                    (0, chai_1.expect)(args).to.include('--from-schema-datamodel');
-                    return Buffer.from('\n[*] Redefined table `LocatorEtalon`\n');
-                },
-                update: (args) => (args.includes('deploy') ? Buffer.from('ok') : refusesDataLoss()),
-            }, { copyDatabase: copier(made), freeBytes: roomy });
-            const deploys = urls.filter((_, i) => calls[i].includes('deploy'));
-            (0, chai_1.expect)(deploys, 'the copy only').to.deep.equal([`file:${made[0]}`]);
-            (0, chai_1.expect)(update(calls)).to.include.members(['db', 'push']);
-            (0, chai_1.expect)(update(calls)).to.not.include('--accept-data-loss');
-            const message = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : '';
-            (0, chai_1.expect)(message).to.match(/a copy of it still lacked part of this version's schema/);
-            (0, chai_1.expect)(message).to.include('[*] Redefined table `LocatorEtalon`');
-            (0, chai_1.expect)(trialFiles()).to.deep.equal([]);
-        }));
-        it("tries the copy when it can't tell how much space is free", () => __awaiter(void 0, void 0, void 0, function* () {
-            const made = [];
-            const info = sinon_1.default.spy(logger_1.default, 'info');
-            const history = { applied: everyMigration.slice(0, -1), failed: [] };
-            const { error } = yield run(history, { diff: fail(2, '') }, { copyDatabase: copier(made), freeBytes: () => null });
-            (0, chai_1.expect)(error).to.equal(undefined);
-            (0, chai_1.expect)(made).to.have.length(1);
-            const lines = info.getCalls().map((c) => c.args.join(' '));
-            (0, chai_1.expect)(lines.some((l) => /could not tell how much space is free/.test(l))).to.equal(true);
-        }));
-        it('says what is copied before it copies', () => __awaiter(void 0, void 0, void 0, function* () {
-            const info = sinon_1.default.spy(logger_1.default, 'info');
-            const history = { applied: everyMigration.slice(0, -1), failed: [] };
-            fs_1.default.writeFileSync(scratchFile, Buffer.alloc(3 * 1024 * 1024));
-            let before = -1;
-            yield run(history, { diff: fail(2, '') }, {
-                copyDatabase: (_from, to) => __awaiter(void 0, void 0, void 0, function* () {
-                    before = info.callCount;
-                    fs_1.default.writeFileSync(to, 'copy');
-                }),
-                freeBytes: roomy,
-            });
-            const lines = info
-                .getCalls()
-                .slice(0, before)
-                .map((c) => c.args.join(' '));
-            (0, chai_1.expect)(lines.some((l) => /3 MB to copy, which can take a while/.test(l))).to.equal(true);
-        }));
-        it("gives the copy the database's own mode before any data is in it", () => __awaiter(void 0, void 0, void 0, function* () {
-            fs_1.default.chmodSync(scratchFile, 0o640);
-            let mode = -1;
-            const history = { applied: everyMigration.slice(0, -1), failed: [] };
-            yield run(history, { diff: fail(2, '') }, {
-                copyDatabase: (_from, to) => __awaiter(void 0, void 0, void 0, function* () {
-                    mode = fs_1.default.statSync(to).mode & 0o777;
-                    fs_1.default.writeFileSync(to, 'copy');
-                }),
-                freeBytes: roomy,
-            });
-            (0, chai_1.expect)(mode.toString(8)).to.equal('640');
-        }));
-        it('says there was no room when the copy runs out of space', () => __awaiter(void 0, void 0, void 0, function* () {
-            const history = { applied: everyMigration.slice(0, -1), failed: [] };
-            const { error } = yield run(history, { diff: fail(2, ''), update: refusesDataLoss }, {
-                copyDatabase: () => __awaiter(void 0, void 0, void 0, function* () {
-                    throw new Error('Raw query failed. Code: `13`. Message: `database or disk is full`');
-                }),
-                freeBytes: () => null,
-            });
-            (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.match(/no room next to it for a copy/);
-            (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.match(/free \d+ MB next to the file/);
-            (0, chai_1.expect)(trialFiles()).to.deep.equal([]);
-        }));
-        // A history that names a migration this release lacks is another
-        // release's. Through #493 the copy ran this release's migrations on it,
-        // and then the file did.
-        it("doesn't try this release's migrations on a database from another release", () => __awaiter(void 0, void 0, void 0, function* () {
-            const made = [];
-            const history = {
-                applied: [...everyMigration.slice(0, -1), '29980101000000_elsewhere'],
-                failed: [],
-            };
-            const { calls, error } = yield run(history, { diff: fail(2, ''), update: refusesDataLoss }, { copyDatabase: copier(made), freeBytes: roomy });
-            (0, chai_1.expect)(made, 'no copy').to.deep.equal([]);
-            (0, chai_1.expect)(calls.some((args) => args.includes('deploy') || args.includes('resolve'))).to.equal(false);
-            (0, chai_1.expect)(update(calls)).to.include.members(['db', 'push']);
-            (0, chai_1.expect)(update(calls)).to.not.include('--accept-data-loss');
-            (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.match(/another release brought it up to date/);
-            (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.include('29980101000000_elsewhere');
-        }));
-        // A start that died mid-trial leaves its copy. The next start removes it,
-        // unless the process that made it is still running.
-        it('removes a copy a previous start left, but not one a running start is using', () => __awaiter(void 0, void 0, void 0, function* () {
-            const dir = path_1.default.dirname(scratchFile);
-            const dead = path_1.default.join(dir, `${trialPrefix}999991`);
-            const alive = path_1.default.join(dir, `${trialPrefix}999992`);
-            const other = `${scratchFile}.backup-20261005T000000Z`;
-            for (const f of [dead, `${dead}-journal`, alive, other])
-                fs_1.default.writeFileSync(f, 'x');
-            // Signal 0 only asks whether a process is there; stubbed all the same.
-            sinon_1.default.stub(process, 'kill').callsFake(((pid) => {
-                if (pid === 999992)
-                    return true;
-                throw Object.assign(new Error('kill ESRCH'), { code: 'ESRCH' });
-            }));
-            try {
-                yield run({ applied: [...everyMigration], failed: [] });
-                (0, chai_1.expect)(trialFiles().sort()).to.deep.equal([path_1.default.basename(alive)]);
-                (0, chai_1.expect)(fs_1.default.existsSync(other)).to.equal(true);
-            }
-            finally {
-                fs_1.default.rmSync(other, { force: true });
-            }
-        }));
-    });
     // With a failed migration recorded, `migrate deploy` stops at once (P3009),
     // whatever the tables hold, so the message never suggests it.
     it('names the failed migration and never suggests migrate deploy when the history records one', () => __awaiter(void 0, void 0, void 0, function* () {
         var _a;
         const failed = everyMigration[everyMigration.length - 1];
         const history = { applied: everyMigration.slice(0, -1), failed: [failed] };
-        const { error } = yield run(history, { diff: fail(2, ''), update: refusesDataLoss });
+        const { error } = yield run(history, { update: refusesDataLoss });
         (0, chai_1.expect)(error, 'the start stops').to.be.an('Error');
         const message = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : '';
         (0, chai_1.expect)(message).to.match(/stopped rather than delete/);
         (0, chai_1.expect)(message).to.include(failed);
         (0, chai_1.expect)(message).to.match(/records a failed migration/);
+        (0, chai_1.expect)(message).to.not.match(/differ from what its recorded migrations make/);
         (0, chai_1.expect)(message).to.include('LabNotes');
         const commands = commandsIn(message);
         (0, chai_1.expect)(commands[0]).to.include(`VACUUM INTO '${scratchFile}.backup-`);
-        (0, chai_1.expect)(commands[0]).to.match(letGoAfterBackup);
+        (0, chai_1.expect)(commands).to.include(letGo);
         (0, chai_1.expect)(commands.filter((c) => c.includes('migrate deploy'))).to.deep.equal([]);
         (0, chai_1.expect)(message).to.not.match(/by hand with prisma migrate deploy/);
     }));
     // A migration can fail on what is already in the tables, which a later
     // start deals with, or on the rows (a unique index over duplicate values),
-    // which no start gets past until someone changes them. The message says
-    // what the next start does for this migration, and nothing it doesn't.
-    describe('when migrate deploy fails on a migration (P3018)', () => {
-        const newest = everyMigration[everyMigration.length - 1];
-        const failure = (name, error) => fail(1, `Error: P3018\n\nA migration failed to apply.\n\nMigration name: ${name}\n\n` +
-            `Database error:\n${error}`);
+    // which no start gets past until someone changes them.
+    it('says what to check when migrate deploy fails on a migration (P3018), without promising the next start recovers', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
         const history = { applied: everyMigration.slice(0, -1), failed: [] };
-        it('promises the next start runs a one-statement migration that failed on the rows again', () => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            const { error } = yield run(history, {
-                diff: fail(1, 'simulated diff failure'),
-                update: failure(newest, 'UNIQUE constraint failed: LocatorEtalon.strategy'),
-            });
-            const message = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : '';
-            (0, chai_1.expect)(message).to.include(newest);
-            (0, chai_1.expect)(message).to.include('UNIQUE constraint failed');
-            (0, chai_1.expect)(message).to.match(/duplicate values/);
-            (0, chai_1.expect)(message).to.match(/change those rows, and start again: the next start runs it again/);
-            (0, chai_1.expect)(message).to.not.match(/next start brings the database up to date/);
-        }));
-        it('says the next start records it when what it makes was already there', () => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            const { error } = yield run(history, {
-                diff: fail(1, 'simulated diff failure'),
-                update: failure(newest, 'duplicate column name: path'),
-            });
-            const message = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : '';
-            (0, chai_1.expect)(message).to.match(/because what it makes was already there/);
-            (0, chai_1.expect)(message).to.match(/records it as applied if the tables are what/);
-            (0, chai_1.expect)(message).to.not.match(/change those rows/);
-        }));
-        it("promises nothing for a migration this release doesn't have", () => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            const { error } = yield run(history, {
-                diff: fail(1, 'simulated diff failure'),
-                update: failure('20261101000000_uniq', 'UNIQUE constraint failed'),
-            });
-            const message = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : '';
-            (0, chai_1.expect)(message).to.include('20261101000000_uniq');
-            (0, chai_1.expect)(message).to.not.match(/next start/);
-        }));
-    });
+        const { error } = yield run(history, {
+            diff: fail(1, 'simulated diff failure'),
+            update: fail(1, 'Error: P3018\n\nA migration failed to apply.\n\nMigration name: 20261101000000_uniq\n\n' +
+                'Database error:\nUNIQUE constraint failed: LocatorEtalon.strategy, LocatorEtalon.nodeName'),
+        });
+        (0, chai_1.expect)(error, 'the start stops').to.be.an('Error');
+        const message = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : '';
+        (0, chai_1.expect)(message).to.include('20261101000000_uniq');
+        (0, chai_1.expect)(message).to.include('UNIQUE constraint failed');
+        (0, chai_1.expect)(message).to.not.match(/next start brings the database up to date/);
+        (0, chai_1.expect)(message).to.not.match(/start again, or first/);
+        // Both things to check: a change already there, and rows the migration can't take.
+        (0, chai_1.expect)(message).to.match(/already there/);
+        (0, chai_1.expect)(message).to.match(/duplicate values/);
+        (0, chai_1.expect)(message).to.match(/change those rows/);
+    }));
     it("says it couldn't read the history without blaming the file outright", () => __awaiter(void 0, void 0, void 0, function* () {
         let error;
         try {
@@ -856,47 +300,3 @@ describe('runMigrations: what each plan runs', () => {
         (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.include('database is locked');
     }));
 });
-// `npm run db:generate` runs `prisma migrate dev` on the developer's database,
-// which gives it a migration history. From then on `npm run db:migrate` updates
-// it with `migrate deploy`, so a schema.prisma edit with no migration never
-// reaches it (or any server the release reaches), while the log said "in sync".
-describe('npm run db:migrate: schema changes without a migration', () => {
-    afterEach(() => sinon_1.default.restore());
-    const failing = (status) => () => {
-        throw Object.assign(new Error('Command failed'), {
-            status,
-            stderr: Buffer.from('boom'),
-            stdout: Buffer.from(''),
-        });
-    };
-    it('warns to run npm run db:generate when prisma/schema.prisma has changes no migration makes', () => {
-        const warn = sinon_1.default.stub(logger_1.default, 'warn');
-        const calls = [];
-        const found = (0, run_migrations_1.warnOfUnmigratedSchemaChanges)((_cmd, args) => {
-            calls.push(args);
-            return failing(2)();
-        });
-        (0, chai_1.expect)(found).to.equal(true);
-        (0, chai_1.expect)(calls).to.have.length(1);
-        (0, chai_1.expect)(calls[0]).to.include.members([
-            'migrate',
-            'diff',
-            '--from-migrations',
-            '--to-schema-datamodel',
-            '--exit-code',
-        ]);
-        const lines = warn.getCalls().map((c) => c.args.join(' '));
-        (0, chai_1.expect)(lines).to.have.length(1);
-        (0, chai_1.expect)(lines[0]).to.match(/npm run db:generate/);
-        (0, chai_1.expect)(lines[0]).to.match(/migrate deploy/);
-    });
-    it('says nothing when the migrations make the schema', () => {
-        const warn = sinon_1.default.stub(logger_1.default, 'warn');
-        (0, chai_1.expect)((0, run_migrations_1.warnOfUnmigratedSchemaChanges)(() => Buffer.from(''))).to.equal(false);
-        (0, chai_1.expect)(warn.called).to.equal(false);
-    });
-    it("doesn't stop when it can't tell", () => {
-        sinon_1.default.stub(logger_1.default, 'warn');
-        (0, chai_1.expect)((0, run_migrations_1.warnOfUnmigratedSchemaChanges)(failing(1))).to.equal(null);
-    });
-});