Files
0pt/scripts/bi-p061-release-race.mjs

134 lines
5.6 KiB
JavaScript

#!/usr/bin/env node
/**
* BI-P061: is "only one published release per dashboard" actually enforced?
*
* The application checks for a live release before publishing, and that check
* is a read-then-write race. This script measures BOTH directions against a
* real Postgres and writes evidence/bi-p061/dashboard-release-race.json:
*
* guard_absent the partial unique index dropped -> both concurrent
* publishes commit, and the dashboard has TWO live versions.
* guard_present the index in place -> the loser fails with 23505.
*
* Without the first run, the second proves nothing: a race that never
* interleaved would also show one published release.
*
* ANALYTICS_TEST_DATABASE_URL=postgres://postgres:test@127.0.0.1:25441/opt \
* node scripts/bi-p061-release-race.mjs
*
* It CREATEs and DROPs its own throwaway schemas and touches nothing else.
*/
import fs from 'node:fs';
import path from 'node:path';
import postgres from 'postgres';
const URL_ = process.env.ANALYTICS_TEST_DATABASE_URL;
if (!URL_) {
console.error('ANALYTICS_TEST_DATABASE_URL is required. Refusing to invent numbers.');
process.exit(2);
}
const STAMP = Date.now().toString(36);
const SCHEMAS = { guard_present: `bi_p061_ev_on_${STAMP}`, guard_absent: `bi_p061_ev_off_${STAMP}` };
const MIGRATIONS = ['sql/008_analytics_domain_model.sql', 'sql/010_analytics_dashboard_releases.sql'];
const HASH = (c) => c.repeat(64);
const connect = (schema, max = 1) =>
postgres(URL_, { max, onnotice: () => undefined, connection: { search_path: schema } });
async function setup(schema, { dropIndex }) {
const admin = postgres(URL_, { max: 1, onnotice: () => undefined });
await admin.unsafe(`CREATE SCHEMA IF NOT EXISTS ${schema}`);
await admin.end({ timeout: 5 });
const c = connect(schema, 2);
for (const f of MIGRATIONS) await c.unsafe(fs.readFileSync(path.join(process.cwd(), f), 'utf8'));
if (dropIndex) await c.unsafe('DROP INDEX opt_analytics_dashboard_release_one_published');
await c.unsafe(`
INSERT INTO opt_analytics_dashboard_definition
(dashboard_id, tenant_id, project_id, name, current_version, owner_id)
VALUES ('dash_race', 't_alpha', 'p_main', 'Race', 1, 'u_1');
INSERT INTO opt_analytics_dashboard_version
(dashboard_version_id, dashboard_id, tenant_id, project_id, version, layout_json, layout_hash)
VALUES ('dv_1', 'dash_race', 't_alpha', 'p_main', 1, '{}', '${HASH('a')}'),
('dv_2', 'dash_race', 't_alpha', 'p_main', 2, '{}', '${HASH('b')}');`);
return c;
}
/** Both sessions read "nothing is live", then both write. */
async function race(schema) {
const conns = [connect(schema), connect(schema)];
const publish = (conn, n) =>
conn.begin(async (tx) => {
await tx.unsafe(
`SELECT release_id FROM opt_analytics_dashboard_release
WHERE dashboard_id='dash_race' AND state='published'`,
);
await new Promise((r) => setTimeout(r, 60));
await tx.unsafe(`
INSERT INTO opt_analytics_dashboard_release
(release_id, dashboard_id, dashboard_version_id, tenant_id, project_id, version, state,
document_hash, published_at)
VALUES ('rel_${n}', 'dash_race', 'dv_${n}', 't_alpha', 'p_main', ${n},
'published', '${HASH(n === 1 ? 'a' : 'b')}', now())`);
});
const results = await Promise.allSettled([publish(conns[0], 1), publish(conns[1], 2)]);
for (const c of conns) await c.end({ timeout: 5 });
return {
committed: results.filter((r) => r.status === 'fulfilled').length,
rejected: results
.filter((r) => r.status === 'rejected')
.map((r) => ({ code: r.reason?.code ?? null, constraint: r.reason?.constraint_name ?? null })),
};
}
async function publishedRows(conn) {
const rows = await conn.unsafe(
`SELECT release_id, version FROM opt_analytics_dashboard_release
WHERE dashboard_id='dash_race' AND state='published' ORDER BY version`,
);
return rows.map((r) => ({ release_id: r.release_id, version: r.version }));
}
const out = { recorded_at: new Date().toISOString() };
const cleanup = [];
try {
for (const [label, schema] of Object.entries(SCHEMAS)) {
const conn = await setup(schema, { dropIndex: label === 'guard_absent' });
cleanup.push([schema, conn]);
if (!out.postgres_version) {
const v = await conn.unsafe('SHOW server_version');
out.postgres_version = v[0].server_version;
}
const result = await race(schema);
out[label] = {
partial_unique_index_present: label === 'guard_present',
transactions_committed: result.committed,
rejections: result.rejected,
published_releases_after: await publishedRows(conn),
};
}
out.verdict = {
counterfactual_produced_two_live_dashboards: out.guard_absent.published_releases_after.length === 2,
guard_left_exactly_one: out.guard_present.published_releases_after.length === 1,
loser_error_code: out.guard_present.rejections[0]?.code ?? null,
application_check_alone_is_sufficient: false,
note:
'DashboardReleaseService.publish() reads for a live release before writing. Both sessions in ' +
'guard_absent passed that check and both committed. The partial unique index is what holds.',
};
const dir = path.join(process.cwd(), 'evidence/bi-p061');
fs.mkdirSync(dir, { recursive: true });
const file = path.join(dir, 'dashboard-release-race.json');
fs.writeFileSync(file, `${JSON.stringify(out, null, 2)}\n`);
console.log(`wrote ${file}`);
console.log(JSON.stringify(out.verdict, null, 2));
} finally {
for (const [schema, conn] of cleanup) {
await conn.unsafe(`DROP SCHEMA IF EXISTS ${schema} CASCADE`);
await conn.end({ timeout: 5 });
}
}