134 lines
5.6 KiB
JavaScript
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 });
|
|
}
|
|
}
|