mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-10-19 05:26:47 +00:00
Maurice
b8144bb92a
Nothing in CI ran a statement against anything but SQLite, so the claim that the dialect layer keeps the repositories portable was never measured and new SQLite-only SQL could land unseen. The new postgres-probe job (server/scripts/pg-probe.ts, npm run probe:pg) does that against a postgres:17 service container: - it derives a Postgres schema from the entities with MikroORM's schema generator, keeping TEXT timestamps, mapping the SQLite-only defaults and the NOCASE collation, and leaving foreign keys out; - it runs every dialect helper on an in-memory SQLite and on Postgres against the same expectation, and every case has to pass; - it calls every public repository method once with arguments the TypeScript checker builds from the parameter types, through a Postgres driver that runs each statement alone in a rolled-back transaction with a statement timeout and records whether Postgres accepted it. The statements Postgres refuses are held per method to scripts/pg-probe-baseline.json, which may only shrink. The baseline starts unmeasured (failing: null): the job reports, passes and uploads the first measurement as the pg-probe-baseline artifact, together with a JSON report, so the commit that seeds it and every later commit that lowers it needs no local Postgres. The probe refuses a database holding tables it did not create. @mikro-orm/postgresql joins the server's devDependencies at the 7.2.1 the other MikroORM packages resolve to; the image's production install leaves it out. The job needs the preflight gates like every test job, runs only for the code area, stops after ten minutes and is part of ci-ok.
68 lines
3.6 KiB
TypeScript
68 lines
3.6 KiB
TypeScript
/**
|
|
* The Postgres probe's ratchet (scripts/pg-probe/baseline.ts). The probe
|
|
* itself only runs in CI against a Postgres service, so the rules that decide
|
|
* whether that job passes are pinned here: a method may not fail more
|
|
* statements than its entry, a stale entry fails until it is lowered, an
|
|
* unmeasured baseline only reports, and --update never raises or adds.
|
|
*/
|
|
import { readFileSync } from 'node:fs';
|
|
import path from 'node:path';
|
|
import { describe, expect, it } from 'vitest';
|
|
import { compareWithBaseline, formatBaseline, lowerBaseline, parseBaseline } from '../../../../scripts/pg-probe/baseline';
|
|
|
|
const now = (entries: Record<string, number>): Map<string, number> => new Map(Object.entries(entries));
|
|
|
|
describe('pg-probe baseline', () => {
|
|
it('PGPROBE-001: parses a measured and an unmeasured baseline', () => {
|
|
expect(parseBaseline('{"failing": null}', 'b.json')).toEqual({ failing: null });
|
|
expect(parseBaseline('{"failing": {"TagsRepository.listByUser": 2}}', 'b.json')).toEqual({ failing: { 'TagsRepository.listByUser': 2 } });
|
|
});
|
|
|
|
it('PGPROBE-002: refuses a malformed baseline instead of reading it as empty', () => {
|
|
expect(() => parseBaseline('nope', 'b.json')).toThrow(/b.json is not valid JSON/);
|
|
expect(() => parseBaseline('{}', 'b.json')).toThrow(/"failing" key/);
|
|
expect(() => parseBaseline('[]', 'b.json')).toThrow(/"failing" key/);
|
|
expect(() => parseBaseline('{"failing": []}', 'b.json')).toThrow(/null or an object/);
|
|
expect(() => parseBaseline('{"failing": {"listByUser": 1}}', 'b.json')).toThrow(/not a Class.method key/);
|
|
expect(() => parseBaseline('{"failing": {"A.b": 0}}', 'b.json')).toThrow(/expected a positive integer/);
|
|
expect(() => parseBaseline('{"failing": {"A.b": 1.5}}', 'b.json')).toThrow(/expected a positive integer/);
|
|
});
|
|
|
|
it('PGPROBE-003: an unmeasured baseline only reports', () => {
|
|
expect(compareWithBaseline({ failing: null }, now({ 'A.b': 3 }))).toEqual({ unseeded: true, grown: [], stale: [] });
|
|
});
|
|
|
|
it('PGPROBE-004: a method failing more statements than its entry (or any without one) fails', () => {
|
|
const verdict = compareWithBaseline({ failing: { 'A.b': 1 } }, now({ 'A.b': 2, 'C.d': 1, 'E.f': 0 }));
|
|
expect(verdict.grown).toEqual([
|
|
{ method: 'A.b', allowed: 1, now: 2 },
|
|
{ method: 'C.d', allowed: 0, now: 1 },
|
|
]);
|
|
expect(verdict.stale).toEqual([]);
|
|
});
|
|
|
|
it('PGPROBE-005: an entry above what its method fails now is stale, also when the method is gone', () => {
|
|
const verdict = compareWithBaseline({ failing: { 'A.b': 2, 'Gone.away': 1 } }, now({ 'A.b': 1 }));
|
|
expect(verdict.grown).toEqual([]);
|
|
expect(verdict.stale).toEqual([
|
|
{ method: 'A.b', allowed: 2, now: 1 },
|
|
{ method: 'Gone.away', allowed: 1, now: 0 },
|
|
]);
|
|
});
|
|
|
|
it('PGPROBE-006: --update lowers and drops entries but never raises or adds one', () => {
|
|
const lowered = lowerBaseline({ failing: { 'A.b': 2, 'C.d': 1, 'Gone.away': 1 } }, now({ 'A.b': 1, 'C.d': 5, 'New.one': 3 }));
|
|
expect(lowered).toEqual({ failing: { 'A.b': 1, 'C.d': 1 } });
|
|
});
|
|
|
|
it('PGPROBE-007: the first --update seeds an unmeasured baseline with what fails, sorted', () => {
|
|
expect(lowerBaseline({ failing: null }, now({ 'Z.z': 1, 'A.a': 2, 'M.m': 0 }))).toEqual({ failing: { 'A.a': 2, 'Z.z': 1 } });
|
|
});
|
|
|
|
it('PGPROBE-008: the checked-in baseline parses and formats back to itself', () => {
|
|
const file = path.join(__dirname, '../../../../scripts/pg-probe-baseline.json');
|
|
const text = readFileSync(file, 'utf8');
|
|
expect(formatBaseline(parseBaseline(text, file))).toBe(text.replace(/\r\n/g, '\n'));
|
|
});
|
|
});
|