@bongos/core 1.24.7 → 1.24.8

package/tests/market_watch_rules_db.mjs

@@ -0,0 +1,133 @@
+// tests/market_watch_rules_db.mjs — the rules page's round trip against a REAL Postgres
+// (task 1004941, goal 1000137).
+//
+// What only a real engine can say: a member's proposal is filed under the table's CHECKs
+// (a rule change must name its version), approving it supersedes the version in use and
+// writes the next one in one transaction without tripping the one-active index, the new
+// row records who proposed it, who approved it, when and why, and the weekly run's own
+// rules loader (store.createStore(pool).activeRules, what run.js calls) then reads it.
+// Also: an approved add-item proposal creates the tracked item, and the page's read
+// (rules-view.readView, with its last-run-cost and builder-name SQL) runs.
+//
+// The module is default:false, so CI's migrate.sh never applies its SQL: this file
+// applies market_watch_001 and 002 itself. Rows live under a project origin no instance
+// has and are deleted before and after. Self-skips without a reachable Postgres; in the
+// INTEGRATION set (scripts/bongos/run-unit-tests.js). DB-free half: tests/market_watch_rules.mjs.
+//
+// Run:  DATABASE_URL=... node tests/market_watch_rules_db.mjs
+
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { strict as assert } from 'node:assert';
+import { insertTestBuilders } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const { Pool } = require('pg');
+const seed = require('../modules/market-watch/seed.js');
+const store = require('../modules/market-watch/store.js');
+const proposals = require('../modules/market-watch/proposals.js');
+const view = require('../modules/market-watch/rules-view.js');
+const research = require('../modules/market-watch/research.js');
+const pricing = require('../src/bongos/llm-pricing.js');
+
+const MIGRATION = readFileSync(new URL('../modules/market-watch/migrations/market_watch_001_tables.sql', import.meta.url), 'utf8');
+const MIGRATION_002 = readFileSync(new URL('../modules/market-watch/migrations/market_watch_002_run.sql', import.meta.url), 'utf8');
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
+try {
+  await pool.query('SELECT 1');
+} catch (e) {
+  console.log(`market_watch_rules_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+
+const P = 'https://t1004941-rules.example';
+const OWNER = 91049411, ADA = 91049412;
+const q = (sql, params) => pool.query(sql, params);
+const withTx = async (fn) => {
+  const client = await pool.connect();
+  try {
+    await client.query('BEGIN');
+    const out = await fn(client);
+    await client.query('COMMIT');
+    return out;
+  } catch (e) {
+    await client.query('ROLLBACK').catch(() => {});
+    throw e;
+  } finally { client.release(); }
+};
+
+async function cleanup() {
+  await q(`DELETE FROM market_watch_proposals WHERE project = $1`, [P]).catch(() => {});
+  await q(`DELETE FROM market_watch_items WHERE project = $1`, [P]).catch(() => {});
+  await q(`DELETE FROM market_watch_rule_versions WHERE project = $1`, [P]).catch(() => {});
+  await q(`DELETE FROM builders WHERE id = ANY($1::bigint[])`, [[OWNER, ADA]]).catch(() => {});
+}
+
+let failed = 0;
+async function check(name, fn) {
+  try { await fn(); console.log(`ok - ${name}`); } catch (e) { failed += 1; console.log(`not ok - ${name}\n  ${e && e.stack}`); }
+}
+
+try {
+  await q(MIGRATION);
+  await q(MIGRATION_002);
+  await cleanup();
+  await insertTestBuilders(pool, [{ id: OWNER, login: 't1004941-owner' }, { id: ADA, login: 't1004941-ada' }]);
+  const r = seed.RULES_V1;
+  await q(`INSERT INTO market_watch_rule_versions (project, version, status, search_queries, sources, rubric, instructions, summary, reason, approved_at)
+           VALUES ($1, 1, 'active', $2::jsonb, $3::jsonb, $4::jsonb, $5, $6, $7, now())`,
+  [P, JSON.stringify(r.searchQueries), JSON.stringify(r.sources), JSON.stringify(seed.RUBRIC), r.instructions, r.summary, r.reason]);
+
+  await check('a proposal round-trips to a new version, and the weekly run\'s rules loader reads it', async () => {
+    const filed = await proposals.createProposal(pool, {
+      project: P, step: 'searches', change: { op: 'add', text: 'open-source bounty boards' }, reason: 'finds Algora and Opire', proposedBy: ADA,
+    });
+    assert.equal(filed.ok, true, JSON.stringify(filed));
+    const out = await proposals.decideProposal({ project: P, id: filed.proposal.id, decision: 'approve', decidedBy: OWNER, withTx });
+    assert.equal(out.ok, true, JSON.stringify(out));
+    const { rows } = await q(`SELECT version, status, author_id, approved_by, approved_at, reason, search_queries
+                                FROM market_watch_rule_versions WHERE project = $1 ORDER BY version`, [P]);
+    assert.deepEqual(rows.map((v) => [v.version, v.status]), [[1, 'superseded'], [2, 'active']]);
+    assert.equal(String(rows[1].author_id), String(ADA));
+    assert.equal(String(rows[1].approved_by), String(OWNER));
+    assert.ok(rows[1].approved_at instanceof Date);
+    assert.equal(rows[1].reason, 'finds Algora and Opire');
+    const loaded = await store.createStore(pool).activeRules(P);
+    assert.equal(loaded.version, 2);
+    assert.ok(loaded.search_queries.includes('open-source bounty boards'));
+    const { rows: [p] } = await q(`SELECT status, decided_by, rule_version_id FROM market_watch_proposals WHERE id = $1`, [filed.proposal.id]);
+    assert.equal(p.status, 'applied');
+    assert.equal(String(p.rule_version_id), String(out.version.id));
+  });
+
+  await check('an approved add-item proposal creates the tracked item', async () => {
+    const filed = await proposals.createProposal(pool, {
+      project: P, step: 'names', change: { op: 'add', name: 'Algora', url: 'https://algora.io', kind: 'competitor', why: 'bounties' }, reason: 'they pay per task', proposedBy: ADA,
+    });
+    const out = await proposals.decideProposal({ project: P, id: filed.proposal.id, decision: 'approve', decidedBy: OWNER, withTx });
+    assert.equal(out.status, 'applied');
+    const { rows: [it] } = await q(`SELECT kind, url, added_via, added_by, status FROM market_watch_items WHERE project = $1 AND name = 'Algora'`, [P]);
+    assert.deepEqual([it.kind, it.url, it.added_via, String(it.added_by), it.status], ['competitor', 'https://algora.io', 'proposal', String(ADA), 'active']);
+  });
+
+  await check('the page read runs on the real schema', async () => {
+    await proposals.createProposal(pool, { project: P, step: 'brief', change: { op: 'set', text: 'Write five lines.' }, reason: 'shorter', proposedBy: ADA });
+    const page = await view.readView(pool, { project: P, decide: { mode: 'owner' }, pricing, model: research.MODEL });
+    assert.deepEqual(page.history.map((h) => h.version), [1, 2]);
+    assert.equal(page.history[1].by, 't1004941-ada');
+    assert.equal(page.next.version, 3);
+    assert.equal(page.cost.basis, 'estimate', 'no run has cost anything here');
+    assert.equal(page.steps.find((s) => s.key === 'names').value, 1);
+  });
+} finally {
+  await cleanup();
+  await pool.end();
+}
+
+if (failed) {
+  console.log(`market_watch_rules_db.mjs: ${failed} failed`);
+  process.exit(1);
+}
+console.log('market_watch_rules_db.mjs: all passed');