mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-11-20 02:56:10 +00:00
526437926a
npm run test:pg --workspace=server (vitest.pg.config.ts) runs every suite that boots the app through buildApp() on the real database module against Postgres, each test file on its own copy of one template database the engine's bootstrap migrates once per run. TREK_TEST_DB_URL names the server; without it the lane fails instead of passing on nothing. The CI job 'Server: Postgres Tests' runs it on a postgres:17 service and is part of ci-ok. tests/postgres/ holds what only Postgres needs proving: - PARITY-PG: MikroORM's comparator finds nothing between the bootstrapped database and the entities. What it reports that changes nothing (key columns it would make nullable, defaults and checks Postgres spells its own way, the hand-ported triggers) is proven so: the spelling statements run in a rolled-back transaction and every default and check must read the same after, and every ported trigger must exist. - the write lock: concurrent read-then-insert units of work never see the same count, and counts are numbers; a search ignores case. tours-hike and tours-plan-types stay on SQLite only: they move a faked setTimeout on until a tool call ends, which a database over the network does not finish within.
133 lines
6.6 KiB
TypeScript
133 lines
6.6 KiB
TypeScript
/**
|
|
* PARITY-PG — the schema a Postgres database ends with after its bootstrap
|
|
* (the baseline, then every migration after its cut) is the schema the
|
|
* entities describe, as scripts/generate-pg-baseline.ts writes it for
|
|
* Postgres (src/db/engine/postgres/schema-adjust.ts). MikroORM's comparator
|
|
* reads the live database and must find nothing to change: a migration after
|
|
* the cut that left Postgres behind SQLite, or a baseline that drifted from
|
|
* the entities, fails here. It runs on the lane's database, never skipped.
|
|
*
|
|
* The comparator also reports statements that change nothing, and each kind
|
|
* is proven so rather than recognised by its text:
|
|
* - `drop not null` on a primary key column: SQLite lets a key column be null
|
|
* and the entities say so; Postgres keeps every primary key NOT NULL (and
|
|
* refuses the statement), checked against the live keys.
|
|
* - a column default or a check constraint Postgres stores in its own spelling
|
|
* (casts added, EXTRACT rewritten, BETWEEN as two comparisons): such
|
|
* statements are applied in a transaction that is rolled back, and the
|
|
* catalogue's own rendering of every default and check must read the same
|
|
* after as before. A default or a bound that really differs changes it.
|
|
* - dropping a trigger the entities cannot carry: only the triggers ported by
|
|
* hand (POSTGRES_TRIGGERS), by exact name, and each of them must exist.
|
|
*/
|
|
import { adjustColumns, POSTGRES_TRIGGERS, type ColumnMeta } from '../../src/db/engine/postgres/schema-adjust';
|
|
import { ALL_ENTITIES } from '../../src/db/entities';
|
|
import type { EntityProperty, Transaction } from '@mikro-orm/core';
|
|
import { MikroORM } from '@mikro-orm/postgresql';
|
|
|
|
import { describe, expect, it } from 'vitest';
|
|
|
|
const PORTED = Object.keys(POSTGRES_TRIGGERS);
|
|
const DROP_NOT_NULL = /^alter table "(\w+)" alter column "(\w+)" drop not null$/;
|
|
const SPELLING =
|
|
/^alter table "\w+" (?:alter column "\w+" set default .+|drop constraint "\w+"|add constraint "\w+" check \(.+\))$/s;
|
|
/** MikroORM drops a trigger by its name, and the function it would have made for it as `<table>_<trigger>_fn`. */
|
|
const DROP_TRIGGER = /^drop trigger if exists "(\w+)" on "(\w+)"$/;
|
|
const DROP_FUNCTION = /^drop function if exists "(\w+)"\(\)$/;
|
|
|
|
/** Every column default and check constraint of the schema, as the catalogue renders them. */
|
|
const FINGERPRINT_SQL = `select string_agg(item, E'\\n' order by item) as fingerprint from (
|
|
select 'default ' || c.relname || '.' || a.attname || ' = ' || pg_get_expr(d.adbin, d.adrelid) as item
|
|
from pg_attrdef d join pg_class c on c.oid = d.adrelid join pg_attribute a on a.attrelid = d.adrelid and a.attnum = d.adnum
|
|
where c.relnamespace = current_schema()::regnamespace
|
|
union all
|
|
select 'check ' || conrelid::regclass || '.' || conname || ' = ' || pg_get_constraintdef(oid)
|
|
from pg_constraint where contype = 'c' and connamespace = current_schema()::regnamespace
|
|
) items`;
|
|
|
|
const ROLLBACK = new Error('roll back the spelling check');
|
|
|
|
async function liveSets(orm: MikroORM): Promise<{ primaryKeys: Set<string>; triggers: Set<string> }> {
|
|
const connection = orm.em.getConnection();
|
|
const names = (sql: string) =>
|
|
connection.execute<Array<{ name: string }>>(sql).then((rows) => new Set(rows.map((row) => row.name)));
|
|
const [primaryKeys, triggers] = await Promise.all([
|
|
names(
|
|
`select c.relname || '.' || a.attname as name from pg_index i
|
|
join pg_class c on c.oid = i.indrelid join pg_attribute a on a.attrelid = i.indrelid and a.attnum = any(i.indkey)
|
|
where i.indisprimary and c.relnamespace = current_schema()::regnamespace`,
|
|
),
|
|
names(
|
|
`select c.relname || '.' || t.tgname as name from pg_trigger t join pg_class c on c.oid = t.tgrelid
|
|
where not t.tgisinternal and c.relnamespace = current_schema()::regnamespace`,
|
|
),
|
|
]);
|
|
return { primaryKeys, triggers };
|
|
}
|
|
|
|
/** Whether applying `statements` leaves every default and check constraint reading as it did; nothing is kept. */
|
|
async function changesNothing(
|
|
orm: MikroORM,
|
|
statements: readonly string[],
|
|
): Promise<{ before: string; after: string }> {
|
|
const connection = orm.em.getConnection();
|
|
const fingerprint = async (trx?: Transaction) =>
|
|
(await connection.execute<Array<{ fingerprint: string }>>(FINGERPRINT_SQL, [], 'all', trx))[0].fingerprint;
|
|
const before = await fingerprint();
|
|
let after = '';
|
|
await connection
|
|
.transactional(async (trx) => {
|
|
// One after the other: a drop and the add that follows name the same constraint.
|
|
await statements.reduce<Promise<unknown>>(
|
|
(previous, statement) => previous.then(() => connection.execute(statement, [], 'run', trx)),
|
|
Promise.resolve(),
|
|
);
|
|
after = await fingerprint(trx);
|
|
throw ROLLBACK;
|
|
})
|
|
.catch((err: unknown) => {
|
|
if (err !== ROLLBACK) throw err;
|
|
});
|
|
return { before, after };
|
|
}
|
|
|
|
describe('PARITY-PG', () => {
|
|
it('PARITY-PG-001: the bootstrapped database holds exactly the schema the entities generate for Postgres', async () => {
|
|
const orm = await MikroORM.init({
|
|
clientUrl: process.env.TREK_DB_URL,
|
|
entities: [...ALL_ENTITIES],
|
|
discovery: { warnWhenNoEntities: false },
|
|
});
|
|
try {
|
|
for (const meta of orm.getMetadata().getAll().values()) {
|
|
adjustColumns(meta.props as EntityProperty[] as ColumnMeta[]);
|
|
}
|
|
const live = await liveSets(orm);
|
|
const statements = (await orm.schema.getUpdateSchemaSQL({ wrap: false }))
|
|
.split(';\n')
|
|
.map((statement) => statement.trim().replace(/;$/, ''))
|
|
.filter((statement) => statement !== '');
|
|
|
|
const isKeyNotNull = (s: string) => {
|
|
const m = DROP_NOT_NULL.exec(s);
|
|
return m !== null && live.primaryKeys.has(`${m[1]}.${m[2]}`);
|
|
};
|
|
const isPortedTrigger = (s: string) => {
|
|
const trigger = DROP_TRIGGER.exec(s);
|
|
if (trigger) return PORTED.includes(trigger[1]) && live.triggers.has(`${trigger[2]}.${trigger[1]}`);
|
|
const fn = DROP_FUNCTION.exec(s);
|
|
return fn !== null && PORTED.some((name) => fn[1].endsWith(`_${name}_fn`));
|
|
};
|
|
const spelling = statements.filter((s) => !isKeyNotNull(s) && !isPortedTrigger(s) && SPELLING.test(s));
|
|
|
|
expect(statements.filter((s) => !isKeyNotNull(s) && !isPortedTrigger(s) && !SPELLING.test(s))).toEqual([]);
|
|
const { before, after } = await changesNothing(orm, spelling);
|
|
expect(after).toBe(before);
|
|
// Every hand-ported trigger is in the database, on its table.
|
|
expect(PORTED.filter((name) => ![...live.triggers].some((t) => t.endsWith(`.${name}`)))).toEqual([]);
|
|
} finally {
|
|
await orm.close(true);
|
|
}
|
|
}, 60_000);
|
|
});
|