From cc41577409e08ec6060946e30ebb73d933540a08 Mon Sep 17 00:00:00 2001 From: Jason Woltje Date: Thu, 22 Oct 2026 06:37:09 -0500 Subject: [PATCH] row 264a r8 (#1769): the six migration tests that compare a whole store with sqlite_sequence after the 3k-3l step leave out the sessions and session_defaults sequence rows and assert them exactly, so any other new row still fails; usage-migration reads sqlite_sequence by name (sage-2621, duckworth-0129); unrun --- packages/bus/tests/account-migration.test.mjs | 13 +++++++++++-- packages/bus/tests/gitea-migration.test.mjs | 11 ++++++++++- packages/bus/tests/grant-migration.test.mjs | 11 ++++++++++- packages/bus/tests/name-migration.test.mjs | 12 +++++++++++- packages/bus/tests/spec-migration.test.mjs | 12 +++++++++++- packages/bus/tests/usage-migration.test.mjs | 16 ++++++++++++++-- 6 files changed, 67 insertions(+), 8 deletions(-) diff --git a/packages/bus/tests/account-migration.test.mjs b/packages/bus/tests/account-migration.test.mjs index 4bdb10648..91b01c9ac 100644 --- a/packages/bus/tests/account-migration.test.mjs +++ b/packages/bus/tests/account-migration.test.mjs @@ -51,6 +51,15 @@ function snapshot(path, columns) { return { columns, rows }; } finally { db.close(); } } +// Row 264a: the 3k→3l step fills sessions and session_defaults with INSERT ... SELECT, which gives +// each a sqlite_sequence row even when it copies none (3k-3l.sql:50-52). An after-migration compare +// leaves out the rows SESSIONS_3L names and checks they are exactly those two at seq 0, so any other +// new row still fails. +function migrated3l(rows) { + const left = rows.sqlite_sequence.filter(r => SESSIONS_3L.includes(r.name)); + assert.deepEqual(left.map(r => ({ ...r })), [{ name: 'session_defaults', seq: 0 }, { name: 'sessions', seq: 0 }]); + return { ...rows, sqlite_sequence: rows.sqlite_sequence.filter(r => !SESSIONS_3L.includes(r.name)) }; +} function master(path) { const db = new DatabaseSync(path, { readOnly: true }); try { @@ -84,7 +93,7 @@ test('REQ-LIMIT-4 3h copy migrates to 3i: every row keeps its seq, the sequence new Store(root, { migrateSchema: true }).close(); assert.equal(version(path), '3l'); // Every table's rows as they were, usage_records with its seq values and sqlite_sequence with 50. - assert.deepEqual(snapshot(path, before.columns).rows, before.rows); + assert.deepEqual(migrated3l(snapshot(path, before.columns).rows), before.rows); assert.deepEqual(before.rows.usage_records.map(r => r.seq), [1, 2, 3]); assert.deepEqual({ ...before.rows.sqlite_sequence.find(r => r.name === 'usage_records') }, { name: 'usage_records', seq: SEQUENCE }); // sqlite_master as at 3h, the account line aside: same tables, indexes and triggers, same text. @@ -133,7 +142,7 @@ test('REQ-LIMIT-4 a 3h→3i step that fails partway leaves the store at 3h with // Still a whole 3h store: the real step migrates it. new Store(root, { migrateSchema: true }).close(); assert.equal(version(path), '3l'); - assert.deepEqual(snapshot(path, before.columns).rows, before.rows); + assert.deepEqual(migrated3l(snapshot(path, before.columns).rows), before.rows); }); test('REQ-LIMIT-4 the 3h engine refuses a migrated store, migrating or not, and leaves it as it was', async t => { diff --git a/packages/bus/tests/gitea-migration.test.mjs b/packages/bus/tests/gitea-migration.test.mjs index 830c9c509..e19d9382c 100644 --- a/packages/bus/tests/gitea-migration.test.mjs +++ b/packages/bus/tests/gitea-migration.test.mjs @@ -43,6 +43,15 @@ function rows(path) { .filter(r => name !== 'meta' || !['schema_version', 'schema_digest'].includes(r.key)).map(r => ({ ...r }))])); } finally { db.close(); } } +// Row 264a: the 3k→3l step fills sessions and session_defaults with INSERT ... SELECT, which gives +// each a sqlite_sequence row even when it copies none (3k-3l.sql:50-52). The compare after the step +// leaves out the rows SESSIONS_3L names and checks they are exactly those two at seq 0, so any other +// new row still fails. +function migrated3l(now) { + const left = now.sqlite_sequence.filter(r => SESSIONS_3L.includes(r.name)); + assert.deepEqual(left, [{ name: 'sessions', seq: 0 }, { name: 'session_defaults', seq: 0 }]); + return { ...now, sqlite_sequence: now.sqlite_sequence.filter(r => !SESSIONS_3L.includes(r.name)) }; +} function master(path) { const db = new DatabaseSync(path, { readOnly: true }); try { @@ -87,7 +96,7 @@ test('3j copy migrates to 3k: every row kept, and sqlite_master gains only the t assert.throws(() => new Store(root), /schema-mismatch/); new Store(root, { migrateSchema: true }).close(); assert.equal(version(path), '3l'); - assert.deepEqual(rows(path), before); + assert.deepEqual(migrated3l(rows(path)), before); const now = master(path); assert.deepEqual(now.filter(r => !NEW.includes(r.name) && !later3l(r)), was.filter(r => !later3l(r))); assert.deepEqual(now.filter(r => NEW.includes(r.name)).map(r => r.name).sort(), [...NEW].sort()); diff --git a/packages/bus/tests/grant-migration.test.mjs b/packages/bus/tests/grant-migration.test.mjs index 18a012601..8c40a36df 100644 --- a/packages/bus/tests/grant-migration.test.mjs +++ b/packages/bus/tests/grant-migration.test.mjs @@ -45,6 +45,15 @@ function rows(path) { .filter(r => name !== 'meta' || !['schema_version', 'schema_digest'].includes(r.key)).map(r => ({ ...r }))])); } finally { db.close(); } } +// Row 264a: the 3k→3l step fills sessions and session_defaults with INSERT ... SELECT, which gives +// each a sqlite_sequence row even when it copies none (3k-3l.sql:50-52). The compare after the step +// leaves out the rows SESSIONS_3L names and checks they are exactly those two at seq 0, so any other +// new row still fails. +function migrated3l(now) { + const left = now.sqlite_sequence.filter(r => SESSIONS_3L.includes(r.name)); + assert.deepEqual(left, [{ name: 'sessions', seq: 0 }, { name: 'session_defaults', seq: 0 }]); + return { ...now, sqlite_sequence: now.sqlite_sequence.filter(r => !SESSIONS_3L.includes(r.name)) }; +} function master(path) { const db = new DatabaseSync(path, { readOnly: true }); try { @@ -92,7 +101,7 @@ test('3i copy migrates to 3j: every row kept, and sqlite_master gains only the t assert.throws(() => new Store(root), /schema-mismatch/); new Store(root, { migrateSchema: true }).close(); assert.equal(version(path), '3l'); - assert.deepEqual(rows(path), before); + assert.deepEqual(migrated3l(rows(path)), before); const now = master(path).filter(r => !LATER.includes(r.name)); assert.deepEqual(now.filter(r => !NEW.includes(r.name) && !later3l(r)), was.filter(r => !later3l(r))); assert.deepEqual(now.filter(r => NEW.includes(r.name)).map(r => r.name).sort(), [...NEW].sort()); diff --git a/packages/bus/tests/name-migration.test.mjs b/packages/bus/tests/name-migration.test.mjs index bca9e1eeb..460eb3301 100644 --- a/packages/bus/tests/name-migration.test.mjs +++ b/packages/bus/tests/name-migration.test.mjs @@ -50,6 +50,16 @@ function snapshot(path, columns) { return { columns, rows }; } finally { db.close(); } } +// Row 264a: the 3k→3l step fills sessions and session_defaults with INSERT ... SELECT, which gives +// each a sqlite_sequence row (3k-3l.sql:50-52), at seq 1 for the one thread here. The compare after +// the step leaves those two rows out and checks them exactly, so any other new row still fails. +// thread_claims and thread_opens stay in the compare: the step carries their seq. +const SEQ_3L = ['sessions', 'session_defaults']; +function migrated3l(rows) { + const left = rows.sqlite_sequence.filter(r => SEQ_3L.includes(r.name)); + assert.deepEqual(left.map(r => ({ ...r })), [{ name: 'sessions', seq: 1 }, { name: 'session_defaults', seq: 1 }]); + return { ...rows, sqlite_sequence: rows.sqlite_sequence.filter(r => !SEQ_3L.includes(r.name)) }; +} test('3f copy migrates to 3g preserving every old column/row, with an empty instance_names and null to_name', t => { const { root, path, copy } = source3f(t), before = snapshot(path), untouched = readFileSync(copy); assert.throws(() => new Store(root), /schema-mismatch/); @@ -62,7 +72,7 @@ test('3f copy migrates to 3g preserving every old column/row, with an empty inst assert.equal(store.get('PRAGMA quick_check').quick_check, 'ok'); assert.deepEqual(store.all('PRAGMA foreign_key_check'), []); } finally { store.close(); } - assert.deepEqual(snapshot(path, before.columns).rows, before.rows); + assert.deepEqual(migrated3l(snapshot(path, before.columns).rows), before.rows); assert.deepEqual(readFileSync(copy), untouched); assert.deepEqual(snapshot(copy).rows, before.rows); new Store(root).close(); diff --git a/packages/bus/tests/spec-migration.test.mjs b/packages/bus/tests/spec-migration.test.mjs index 7706bb791..68b246319 100644 --- a/packages/bus/tests/spec-migration.test.mjs +++ b/packages/bus/tests/spec-migration.test.mjs @@ -48,6 +48,16 @@ function snapshot(path, columns) { return { columns, rows }; } finally { db.close(); } } +// Row 264a: the 3k→3l step fills sessions and session_defaults with INSERT ... SELECT, which gives +// each a sqlite_sequence row (3k-3l.sql:50-52), at seq 1 for the one thread here. The compare after +// the step leaves those two rows out and checks them exactly, so any other new row still fails. +// thread_claims and thread_opens stay in the compare: the step carries their seq. +const SEQ_3L = ['sessions', 'session_defaults']; +function migrated3l(rows) { + const left = rows.sqlite_sequence.filter(r => SEQ_3L.includes(r.name)); + assert.deepEqual(left.map(r => ({ ...r })), [{ name: 'sessions', seq: 1 }, { name: 'session_defaults', seq: 1 }]); + return { ...rows, sqlite_sequence: rows.sqlite_sequence.filter(r => !SEQ_3L.includes(r.name)) }; +} test('3e copy migrates through 3f to 3g preserving every old column/row and adding null spec citations', t => { const { root, path, copy } = source3e(t), before = snapshot(path), untouched = readFileSync(copy); assert.throws(() => new Store(root), /schema-mismatch/); @@ -58,7 +68,7 @@ test('3e copy migrates through 3f to 3g preserving every old column/row and addi assert.equal(store.get('PRAGMA quick_check').quick_check, 'ok'); assert.deepEqual(store.all('PRAGMA foreign_key_check'), []); } finally { store.close(); } - assert.deepEqual(snapshot(path, before.columns).rows, before.rows); + assert.deepEqual(migrated3l(snapshot(path, before.columns).rows), before.rows); assert.deepEqual(readFileSync(copy), untouched); assert.deepEqual(snapshot(copy).rows, before.rows); new Store(root).close(); diff --git a/packages/bus/tests/usage-migration.test.mjs b/packages/bus/tests/usage-migration.test.mjs index b839ec52d..135a5ede8 100644 --- a/packages/bus/tests/usage-migration.test.mjs +++ b/packages/bus/tests/usage-migration.test.mjs @@ -46,11 +46,23 @@ function snapshot(path, columns) { columns ??= Object.fromEntries(db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all() .map(({ name }) => [name, db.prepare(`PRAGMA table_info(${name})`).all().map(c => c.name)])); const rows = Object.fromEntries(Object.entries(columns).map(([table, keys]) => [table, - db.prepare(`SELECT ${keys.join(',')} FROM ${table} ORDER BY rowid`).all() + db.prepare(`SELECT ${keys.join(',')} FROM ${table} ORDER BY ${table === 'sqlite_sequence' ? 'name' : 'rowid'}`).all() .filter(r => table !== 'meta' || !['schema_version', 'schema_digest'].includes(r.key))])); return { columns, rows }; } finally { db.close(); } } +// Row 264a: the 3k→3l step fills sessions and session_defaults with INSERT ... SELECT, which gives +// each a sqlite_sequence row (3k-3l.sql:50-52), at seq 1 for the one thread here. The compare after +// the step leaves those two rows out and checks them exactly, so any other new row still fails. +// thread_claims and thread_opens stay in the compare: the step carries their seq. +// The step writes the thread_claims and thread_opens rows again, after instance_names', so the +// snapshot reads sqlite_sequence by name, as account-migration.test.mjs does (row 126). +const SEQ_3L = ['sessions', 'session_defaults']; +function migrated3l(rows) { + const left = rows.sqlite_sequence.filter(r => SEQ_3L.includes(r.name)); + assert.deepEqual(left.map(r => ({ ...r })), [{ name: 'session_defaults', seq: 1 }, { name: 'sessions', seq: 1 }]); + return { ...rows, sqlite_sequence: rows.sqlite_sequence.filter(r => !SEQ_3L.includes(r.name)) }; +} test('REQ-LIMIT-4 3g copy migrates through 3h, 3i, 3j and 3k to 3l preserving every old column, row and sequence; new usage table is empty', t => { const { root, path, copy } = source3g(t), before = snapshot(path), untouched = readFileSync(copy); assert.throws(() => new Store(root), /schema-mismatch/); @@ -64,7 +76,7 @@ test('REQ-LIMIT-4 3g copy migrates through 3h, 3i, 3j and 3k to 3l preserving ev assert.equal(store.get('PRAGMA quick_check').quick_check, 'ok'); assert.deepEqual(store.all('PRAGMA foreign_key_check'), []); } finally { store.close(); } - assert.deepEqual(snapshot(path, before.columns).rows, before.rows); + assert.deepEqual(migrated3l(snapshot(path, before.columns).rows), before.rows); assert.deepEqual(readFileSync(copy), untouched); assert.deepEqual(snapshot(copy).rows, before.rows); new Store(root).close();