@bongos/core 1.19.508 → 1.19.510

package/tests/publish_gate.mjs

@@ -0,0 +1,167 @@
+// tests/publish_gate.mjs — the PUBLISH GATE (task 1002335, BV1.R16; ADR 0182 D3/D4).
+//
+// A project is on the public map if and only if it has a name AND a description.
+// That is the whole bar — identity only, deliberately not a completeness check —
+// and until it is met the project is DARK MATTER: off the map and un-joinable.
+//
+// R04 (task 1002323) landed the DEFINITION, dormant. This file pins what R16 does
+// with it, which is three things:
+//
+//   1. the gate BLOCKS the one publish action that could bypass it — an Archon
+//      featuring a row. ADR 0182 D3: `featured` may rank or promote among projects
+//      already on the map, it may never put one there;
+//   2. every refusal NAMES what is absent (D4), in one shared phrase, because a
+//      project that cannot be published and is not told why is indistinguishable
+//      from a broken one;
+//   3. the OTHER plane — `provisioning`, where an owner stands before their project
+//      is ever catalogued — asks the same gate through the kernel seam instead of
+//      keeping a second copy of the rule. The ADR 0083 one-way rule forbids the
+//      import; a duplicated two-field predicate is exactly the drift that the
+//      single SQL definition (publishableSql) exists to prevent.
+//
+// Pure + DB-free: the pool is a recording fake, and the seam is the real port object.
+//
+// Run:  node --test tests/publish_gate.mjs
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const pi = require('../modules/platform-identity/platform-identity.js');
+const api = require('../src/module-api.js');
+
+// The REAL port object, registered exactly as routes/projects.js registers it at
+// boot — so provisioning below is answered by platform-identity's own gate, not by
+// a stub that could agree with a rule nobody ships.
+if (!api.hasProvider('project.publishGate')) {
+  api.registerProvider('project.publishGate', pi.publishGatePort);
+}
+const provRoutes = require('../modules/provisioning/routes/provisioning.js');
+
+// A recording fake pool: returns queued responses in order, records every call.
+function mockPool(responses = []) {
+  const calls = [];
+  let i = 0;
+  return {
+    calls,
+    query: async (text, params) => {
+      calls.push({ text: String(text), params: params || [] });
+      return responses[i++] || { rows: [], rowCount: 0 };
+    },
+  };
+}
+
+// ── what is missing, said the same way everywhere ────────────────────────────
+
+test('missingPhrase names every absent field, so no surface invents its own wording', () => {
+  assert.equal(pi.missingPhrase(['description']), 'no description');
+  assert.equal(pi.missingPhrase(['name', 'description']), 'no name and no description');
+  // a met bar has nothing to name — the caller renders the "on the map" sentence
+  assert.equal(pi.missingPhrase([]), '');
+  assert.equal(pi.missingPhrase(undefined), '');
+});
+
+// ── the gate as a kernel seam port ───────────────────────────────────────────
+
+test('the gate is published as a PORT, so another module can ask without importing', () => {
+  const port = pi.publishGatePort;
+  assert.deepEqual([...port.fields].sort(), ['description', 'name']);
+  assert.deepEqual(port.evaluate({ name: 'Mercury', description: 'A weather sim.' }),
+    { publishable: true, missing: [] });
+  assert.deepEqual(port.evaluate({ name: 'Mercury' }), { publishable: false, missing: ['description'] });
+  assert.equal(typeof port.missingPhrase, 'function');
+  // The port answers with the SAME function the SQL predicate mirrors — a caller
+  // that reached a private copy could drift from the feed's own definition.
+  assert.deepEqual(port.evaluate({ name: 'x', description: ' ' }),
+    pi.projectPublishability({ name: 'x', description: ' ' }));
+});
+
+test('the module manifest DECLARES the port — an undeclared provider is invisible to the boot check', () => {
+  const manifest = require('../modules/platform-identity/module.json');
+  assert.ok(manifest.provides.includes('project.publishGate'));
+});
+
+// ── featuring cannot publish an unpublishable project (ADR 0182 D3) ──────────
+
+test('featuring is bounded IN THE UPDATE, not by a read-then-write', async () => {
+  const pool = mockPool([{ rows: [{ id: '7', origin: 'https://p', name: 'P', featured: true, status: 'active' }] }]);
+  const out = await pi.setProjectFeatured(7, true, { pool });
+  assert.equal(out.project.featured, true);
+  assert.equal(pool.calls.length, 1, 'the happy path is ONE statement — no separate check to race');
+  const sql = pool.calls[0].text;
+  assert.match(sql, /UPDATE platform_identity_projects SET featured = \$2/);
+  // the bound is the same predicate the public feed reads
+  assert.ok(sql.includes(pi.publishableSql()), 'the gate rides in the WHERE, from the one SQL definition');
+  assert.deepEqual(pool.calls[0].params, [7, true]);
+});
+
+test('featuring a DARK-MATTER project is refused, and the refusal names what is missing', async () => {
+  const pool = mockPool([
+    { rows: [] },                                                               // the guarded UPDATE matched nothing
+    { rows: [{ id: '7', origin: 'https://p', name: 'P', description: null }] }, // …because of the gate
+  ]);
+  const out = await pi.setProjectFeatured(7, true, { pool });
+  assert.equal(out.blocked, true);
+  assert.deepEqual(out.missing, ['description'], 'ADR 0182 D4 — never merely refuse');
+  assert.ok(!out.project, 'nothing was featured');
+});
+
+test('a missing row is NOT reported as a gate refusal — the two answers are different', async () => {
+  const pool = mockPool([{ rows: [] }, { rows: [] }]);
+  const out = await pi.setProjectFeatured(999, true, { pool });
+  assert.equal(out.notFound, true);
+  assert.ok(!out.blocked, 'a curator told to "add a description" for a row that does not exist is sent chasing nothing');
+});
+
+test('UN-featuring is never gate-bound — a husk that is already featured must stay removable', async () => {
+  const pool = mockPool([{ rows: [{ id: '7', featured: false }] }]);
+  const out = await pi.setProjectFeatured(7, false, { pool });
+  assert.equal(out.project.featured, false);
+  // the predicate short-circuits on the OFF direction, in SQL, for every row
+  assert.match(pool.calls[0].text, /\$2 = false OR /);
+  assert.deepEqual(pool.calls[0].params, [7, false]);
+});
+
+// ── the other plane asks the same gate through the seam ──────────────────────
+
+test('provisioning maps its own row onto the gate: an instance slug IS its name', () => {
+  const told = provRoutes.publishVerdict({ slug: 'mercury', description: 'A weather sim.' });
+  assert.equal(told.publishable, true);
+  assert.deepEqual(told.missing, []);
+
+  // The About step skipped: the only identity field this plane can lack.
+  const skipped = provRoutes.publishVerdict({ slug: 'mercury', description: null });
+  assert.equal(skipped.publishable, false);
+  assert.deepEqual(skipped.missing, ['description']);
+  assert.equal(skipped.missing_phrase, 'no description',
+    'the phrase travels WITH the verdict so the owner-facing card cannot word the rule differently');
+
+  // A slug is never empty, so `name` can never be the missing half here — and the
+  // gate is never told about a column this table does not have.
+  assert.ok(!skipped.missing.includes('name'));
+});
+
+test('an instance read carries the verdict, so no read can ship the row without the reason', () => {
+  const row = { id: 4, slug: 'mercury', status: 'active', description: null, detail: {} };
+  const out = provRoutes.ownerInstance(row);
+  assert.equal(out.slug, 'mercury', 'the allow-listed projection is still there');
+  assert.equal(out.publish.publishable, false);
+  assert.deepEqual(out.publish.missing, ['description']);
+});
+
+test('with NO hub on the platform there is no map — and the verdict is silence, not a guess', () => {
+  // resolveOptional's absent case. platform-identity is hub-only (`default: false`),
+  // and the public map is a hub concept: an instance without it has nothing to be
+  // on. A locally-invented rule here is exactly what the seam exists to prevent, so
+  // the surfaces hide the section instead.
+  const seams = require('../src/module-seams.js');
+  const saved = seams.resolve('project.publishGate');
+  seams._reset();
+  try {
+    assert.equal(provRoutes.publishVerdict({ slug: 'mercury', description: null }), null);
+    assert.equal(provRoutes.ownerInstance({ id: 1, slug: 'mercury' }).publish, null);
+  } finally {
+    seams.registerProvider('project.publishGate', saved);
+  }
+});