@bongos/core 1.19.909 → 1.19.911

package/tests/idea_spark_hall.mjs

@@ -60,6 +60,11 @@ const GOALS = [
 function boot({
   search = '', sparks = QUEUE, count = null, idea = SPARK, ideaOk = true, store = {},
   versions = VERSIONS, goals = GOALS, suggestions = [],
+  // GRAVITY (task 1004083 / spec R02). The landing verdict the composer draws
+  // its one line from. `null` means the read FAILED — distinct from a verdict of
+  // `{ outcome: null }`, which is the server saying "nothing to state yet"; the
+  // line must go quiet for both, and there is a case below for each.
+  landing = undefined,
 } = {}) {
   const els = new Map();
   const makeEl = () => ({
@@ -108,6 +113,21 @@ function boot({
         return { status: 201, ok: true, data: { idea: { id: '900', grade: 'full', completeness_score: 80 } } };
       },
       postInboxIdDevelop: async (a) => { calls.push(['develop', a]); return { status: 200, ok: true, data: { idea: { ...idea, grade: 'full', completeness_score: 80, ideator_credit: 5 } } }; },
+      // task 1004083 (spec R02) — the landing preview. The DEFAULT mirrors the
+      // real matrix for the fixtures this file already files with: a goal named
+      // ⇒ it lands there, no goal ⇒ it floats. A test that cares about a
+      // particular verdict passes `landing` and overrides the lot.
+      postInboxPreviewLanding: async (a) => {
+        calls.push(['preview', a]);
+        if (landing === null) return { status: 500, ok: false, data: null };
+        if (landing !== undefined) return { status: 200, ok: true, data: landing };
+        const gid = a.body && a.body.goal_id;
+        if (gid != null) {
+          const g = goals.find((x) => String(x.id) === String(gid));
+          return { status: 200, ok: true, data: { outcome: 'routed', reason: 'bug_trusted_filer', status: 'ready', goal: { id: String(gid), title: g ? g.title : `goal ${gid}` }, version_id: 'BV1', refusal: null } };
+        }
+        return { status: 200, ok: true, data: { outcome: 'floats', reason: 'no_goal', status: null, goal: null, version_id: null, refusal: null } };
+      },
     },
     // task 1003069 (R08) — the quick-filing goal picker's reads: the building
     // versions (to scope the suggester) and the open goal list (the picker's
@@ -515,5 +535,168 @@ await test('storage that refuses never takes the composer down, and says it is n
 // the element. Without the markup pin this file would have certified a page
 // that renders nothing.
 
+// ---------------------------------------------------------------------------
+// GRAVITY — which goal will catch this thought, said before it is released
+// (task 1004083 / spec R02)
+//
+// THE DEFECT THESE PIN is not a missing control: #fq-goal is a visible select.
+// It is that the select's own labels are UNTRUE in two directions — "No goal
+// (homeless)" for a bug (ADR 0262 routes it to the maintenance goal) and a named
+// goal for a judgment kind (routing.js NEVER_ROUTE_KINDS). So the cases that
+// matter most here are the two where the LINE AND THE PICKER DISAGREE.
+//
+// The same stub caveat the receipts block above records applies in full: the DOM
+// fake manufactures an element for any id, so the markup pin is load-bearing and
+// every other case below would stay green without it.
+// ---------------------------------------------------------------------------
+
+await test('ideas.html actually declares the gravity line (the stub would fake it otherwise)', async () => {
+  const html = fs.readFileSync(path.join(HALL, 'ideas.html'), 'utf8');
+  assert.match(html, /id="fq-gravity"/, 'the gravity line is in the real markup');
+  assert.match(html, /id="fq-gravity"[^>]*hidden/, 'and it starts hidden — nothing true to say yet');
+  assert.match(html, /id="fq-gravity"[^>]*aria-live="polite"/, 'and it is announced, not just painted');
+});
+
+await test('picking a goal says which goal will catch it, and that it is claimable', async () => {
+  const r = boot();
+  await settle(); await settle();
+  r.el('fq-title').value = 'the widget is broken';
+  r.el('fq-goal').value = '77';
+  r.el('fq-goal')._handlers.change();
+  await settle(); await settle();
+  assert.equal(r.el('fq-gravity').hidden, false, 'the line is shown');
+  assert.match(r.el('fq-gravity').textContent, /Goal Seventy Seven/, 'and it names the goal');
+  assert.match(r.el('fq-gravity').textContent, /anyone can claim/, 'and says the task is claimable');
+  assert.equal(r.el('fq-gravity').dataset.tone, 'lands');
+});
+
+await test('a goal that only lands at backlog says a nod is still needed', async () => {
+  const r = boot({ landing: { outcome: 'routed', reason: 'bug_awaiting_nod', status: 'backlog', goal: { id: '77', title: 'Goal Seventy Seven' }, version_id: 'BV1', refusal: null } });
+  await settle(); await settle();
+  r.el('fq-title').value = 'the widget is broken';
+  r.el('fq-title')._handlers.input();
+  await new Promise((res) => setTimeout(res, 320));
+  await settle();
+  assert.match(r.el('fq-gravity').textContent, /waiting for a nod/, 'the two routed outcomes are not conflated');
+  assert.equal(r.el('fq-gravity').dataset.tone, 'lands', 'it still lands — the tone is about having a home, not about being claimable');
+});
+
+await test('a homeless BUG is told it lands anyway — the picker says "homeless" and that is false', async () => {
+  // ADR 0262: decideLanding routes a goal-less kind='bug' from the api vector
+  // into the version's maintenance goal. The select still reads "No goal
+  // (homeless)". This line is the correction, and it is the whole reason the
+  // verdict is read from the server instead of inferred from the select's value.
+  const r = boot({ landing: { outcome: 'routed_home', reason: 'bug_homeless_trusted_filer', status: 'ready', goal: null, version_id: 'BV1', refusal: null } });
+  await settle(); await settle();
+  r.el('fq-title').value = 'the widget is broken';
+  r.el('fq-title')._handlers.input();
+  await new Promise((res) => setTimeout(res, 320));
+  await settle();
+  const said = r.el('fq-gravity').textContent;
+  assert.match(said, /A bug always lands/, 'it contradicts the picker rather than echoing it');
+  assert.match(said, /BV1/, 'and names whose maintenance goal catches it');
+  assert.equal(r.el('fq-gravity').dataset.tone, 'lands');
+});
+
+await test('a named goal that the matrix DECLINES says so instead of implying the goal caught it', async () => {
+  // The second lie: a criterion-proposal or a decision never routes, however
+  // confidently the select shows a goal beside it.
+  const r = boot({ landing: { outcome: 'floats', reason: 'judgment_kind', status: null, goal: { id: '77', title: 'Goal Seventy Seven' }, version_id: 'BV1', refusal: null } });
+  await settle(); await settle();
+  r.el('fq-title').value = 'should we split the hall';
+  r.el('fq-title')._handlers.input();
+  await new Promise((res) => setTimeout(res, 320));
+  await settle();
+  const said = r.el('fq-gravity').textContent;
+  assert.match(said, /will not catch this/, 'the goal is named as NOT catching it');
+  assert.match(said, /inbox/, 'and the real destination is stated');
+  assert.equal(r.el('fq-gravity').dataset.tone, 'floats');
+});
+
+await test('letting it float is stated as an outcome, not left as an empty default', async () => {
+  const r = boot();
+  await settle(); await settle();
+  r.el('fq-title').value = 'a loose thought';
+  r.el('fq-title')._handlers.input();
+  await new Promise((res) => setTimeout(res, 320));
+  await settle();
+  assert.equal(r.el('fq-gravity').hidden, false);
+  assert.match(r.el('fq-gravity').textContent, /floats in the inbox/);
+  assert.equal(r.el('fq-gravity').dataset.tone, 'floats', 'floating is neutral — it is a legal choice, not a warning');
+});
+
+await test('a refusal is shown in the filer\'s own words before they spend the filing', async () => {
+  const r = boot({ landing: { outcome: 'refused', reason: 'soft_landing', status: null, goal: { id: '77', title: 'Goal Seventy Seven' }, version_id: 'BV1', refusal: { code: 'protected_scope', reason: 'This goal reaches protected territory, so a filer below Metic cannot route work into it.' } } });
+  await settle(); await settle();
+  r.el('fq-title').value = 'touch the deploy core';
+  r.el('fq-title')._handlers.input();
+  await new Promise((res) => setTimeout(res, 320));
+  await settle();
+  assert.match(r.el('fq-gravity').textContent, /protected territory/, 'the server\'s reason is passed through');
+  assert.equal(r.el('fq-gravity').dataset.tone, 'refused');
+});
+
+await test('an empty title states nothing, and a failed read states nothing — never a guess', async () => {
+  const quiet = boot();
+  await settle(); await settle();
+  quiet.el('fq-title').value = '   ';
+  quiet.el('fq-title')._handlers.input();
+  await new Promise((res) => setTimeout(res, 320));
+  await settle();
+  assert.equal(quiet.el('fq-gravity').hidden, true, 'nothing to file, nothing to say');
+
+  const down = boot({ landing: null });
+  await settle(); await settle();
+  down.el('fq-title').value = 'the widget is broken';
+  down.el('fq-title')._handlers.input();
+  await new Promise((res) => setTimeout(res, 320));
+  await settle();
+  assert.equal(down.el('fq-gravity').hidden, true, 'a preview outage degrades to silence, not to a wrong sentence');
+  assert.equal(down.el('fq-err').textContent, '', 'and never to an error under a half-typed thought');
+});
+
+await test('filing clears the line — gravity describes a draft, and the draft is gone', async () => {
+  const r = boot();
+  await settle(); await settle();
+  r.el('fq-title').value = 'the widget is broken';
+  r.el('fq-goal').value = '77';
+  r.el('fq-goal')._handlers.change();
+  await settle(); await settle();
+  // The TEXT is what proves it was shown, not `hidden`. The DOM stub starts an
+  // element at hidden:false, so asserting only on that passes when the line was
+  // never rendered at all — the same class of vacuous pass the markup pin above
+  // exists for, caught by reverting the goal-change redraw and watching this
+  // case stay green.
+  assert.match(r.el('fq-gravity').textContent, /Goal Seventy Seven/, 'shown while composing');
+  assert.equal(r.el('fq-gravity').hidden, false);
+  await r.submitQuick();
+  await settle();
+  assert.equal(r.el('fq-gravity').hidden, true, 'and gone once it is filed');
+  assert.equal(r.el('fq-gravity').textContent, '', 'and the sentence with it');
+  assert.equal(r.el('fq-receipts').hidden, false, 'the RECEIPT is what survives instead (task 1004082)');
+});
+
+// Every guard above was reverted and each redded its named case (RUN, and these
+// are the measured counts, not the predicted ones):
+//   drop renderGravity from the goal-change handler   -> 2 red (named-goal + filing-clears)
+//   infer from the select instead of the verdict      -> 4 red (both lies, + backlog + refusal)
+//   drop the seq guard and paint every answer         -> 0 red  <-- see below
+//   rename the id in ideas.html                       -> 1 red (the markup pin ONLY)
+//
+// THE FIRST LINE COST A TEST FIX, and it is the reason to run these rather than
+// reason about them. That probe first redded only ONE case: "filing clears the
+// line" opened by asserting `hidden === false`, and the DOM stub starts every
+// element at `hidden: false` — so the assertion passed while the line was never
+// rendered at all. It asserts on the TEXT now. A stub's defaults can agree with
+// a broken page, which is the same lesson the markup pin below teaches twice.
+//
+// THE THIRD LINE IS AN HONEST GAP, recorded rather than papered over. The
+// out-of-order guard in refreshGravity is not covered: the fake resolves
+// synchronously, so two previews cannot interleave here and a test that removed
+// the guard would still pass. Pinning it needs a fake that delays per call,
+// which is a different harness from this one. Filed as task 1004108 rather than
+// claimed as tested — a green test over an unreachable branch would be a false
+// claim of coverage, which is the failure this file's own note above warns about.
+
 console.log(`\nidea_spark_hall: ${passed} passed, ${failed} failed`);
 if (failed > 0) process.exit(1);