@bongos/core 1.19.536 → 1.19.538

package/tests/provisioning_module_selection.mjs

@@ -169,15 +169,20 @@ provisioning.createInstance = async (_db, args) => {
 provisioning.enqueueIntent = async (_db, id, action) => ({ intent: { id: 9, action, state: 'pending' }, created: true });
 provisioning.getOpenIntent = async () => null;
 provisioning.recordEvent = async () => {};
-// Mirrors the real statement: `detail = detail || $n::jsonb` MERGES the
-// normalized answers onto what is already stored. The row the route then hands
-// `effectiveModules` is that merged one, so a stub that returned the pre-patch
-// row would hide exactly the staleness this test exists to catch.
+// Mirrors the real statement: `detail = (detail || $n::jsonb) - $m::text[]` MERGES
+// the patch's answers onto what is already stored and DROPS the keys it explicitly
+// un-answered (task 1003577). The row the route then hands `effectiveModules` is
+// that merged one, so a stub that returned the pre-patch row would hide exactly the
+// staleness this test exists to catch — and one that only merged would hide the
+// clear, which is the whole way back to "never answered".
 provisioning.updateInstanceDetail = async (_db, _id, patch) => {
   lastUpdatedRow = { ...detailRow };
   if (patch.description !== undefined) lastUpdatedRow.description = patch.description;
   if (patch.detail !== undefined) {
-    lastUpdatedRow.detail = { ...(detailRow.detail || {}), ...provisioning.normalizeProjectDetail(patch.detail) };
+    const { set, clear } = provisioning.projectDetailPatch(patch.detail);
+    const next = { ...(detailRow.detail || {}), ...set };
+    for (const key of clear) delete next[key];
+    lastUpdatedRow.detail = next;
   }
   // `modules` REPLACES and is normalized on the way in — the real statement's
   // `modules = $n::jsonb` over normalizeModuleSelection (BV1.R23, task 1002342).
@@ -502,6 +507,110 @@ await ta('PATCH /detail: another builder’s project is a 404, not a module chan
   detailRow = null; lastUpdatedRow = null;
 });
 
+// ── Un-answering the interview ─────────────────────────────────────────────
+// Task 1003577. `effectiveModules` reads three states off a row and "nobody said"
+// is one of them, but a MERGING write could only ever add an answer: `{}` merged to
+// nothing and `null` was dropped by the vocabulary, so the first `team_shape` an
+// owner ever sent was permanent and the bundle it moved could never move back. An
+// explicit per-key `null` is now the un-answer (RFC 7396, and `description`'s own
+// rule on this same route), and the read-back has to resolve as a never-answered row
+// — not merely "close to one".
+
+await ta('PATCH /detail: answer then CLEAR — the row reads back exactly as one that was never asked', async () => {
+  // Arrange — a game project that skipped the picker, so its modules resolve from
+  // the bundle and the interview answer is the only thing that can move them.
+  const virgin = { id: 41, owner_builder_id: 7, slug: 'mercury', status: 'active', type: 'game', modules: null, detail: {} };
+  const neverAnswered = effectiveModules(virgin);
+  assert.equal(neverAnswered.source, 'bundle', 'the fixture really is an unanswered project');
+
+  detailRow = { ...virgin };
+  lastUpdatedRow = null;
+  const answered = await patch('/provisioning/instances/41/detail', { detail: { team_shape: 'solo' } });
+  assert.equal(answered.status, 200, answered.raw);
+  assert.deepEqual(answered.body.detail, { team_shape: 'solo' });
+  assert.notDeepEqual(answered.body.modules.selected, neverAnswered.selected,
+    'the fixture is only meaningful if the answer really moved the bundle');
+
+  // Act — the owner takes it back
+  detailRow = lastUpdatedRow;
+  lastUpdatedRow = null;
+  const cleared = await patch('/provisioning/instances/41/detail', { detail: { team_shape: null } });
+
+  // Assert — the stored answer is GONE, not stored as null, and every derived read
+  // is the unanswered one again
+  assert.equal(cleared.status, 200, cleared.raw);
+  assert.ok(!('team_shape' in lastUpdatedRow.detail), 'the key left the jsonb entirely');
+  assert.deepEqual(cleared.body.detail, {}, 'and the read surface says the interview is unanswered');
+  assert.deepEqual(cleared.body.modules, neverAnswered, 'source, preset and adjustments are the never-answered ones');
+  assert.equal(cleared.body.modules.source, 'bundle');
+  assert.deepEqual(cleared.body.modules.selected, bundleForProjectType('game').bundle, 'the UNADJUSTED preset');
+  assert.deepEqual(cleared.body.modules.adjustments, [], 'no rule fired, so nothing claims to have');
+  assert.deepEqual(cleared.body.publish, answered.body.publish, 'clearing an answer is not a publish change');
+  detailRow = null; lastUpdatedRow = null;
+});
+
+await ta('PATCH /detail: clearing one key leaves every other stored key alone', async () => {
+  // The statement drops the named key rather than replacing the column, so an answer
+  // the patch never mentioned survives — including one stored before it left the
+  // vocabulary, which `projectDetail` filters on READ and must not silently delete.
+  detailRow = {
+    id: 41, owner_builder_id: 7, slug: 'mercury', status: 'active', type: 'game', modules: null,
+    detail: { team_shape: 'community', legacy_answer: 'kept' },
+  };
+  lastUpdatedRow = null;
+
+  const res = await patch('/provisioning/instances/41/detail', { detail: { team_shape: null } });
+
+  assert.equal(res.status, 200, res.raw);
+  assert.deepEqual(lastUpdatedRow.detail, { legacy_answer: 'kept' }, 'only the nulled key was dropped');
+  assert.deepEqual(res.body.detail, {}, 'and the read still filters the survivor through the vocabulary');
+  detailRow = null; lastUpdatedRow = null;
+});
+
+await ta('PATCH /detail: an off-vocabulary value is still REFUSED, never mistaken for a clear', async () => {
+  // Only null un-answers. A typo, an empty string or any other sentinel is the
+  // loud-validation case badProjectDetail was written for — silently treating one as
+  // "clear" would erase an answer the caller was trying to set.
+  detailRow = { id: 41, owner_builder_id: 7, slug: 'mercury', status: 'active', type: 'game', modules: null, detail: { team_shape: 'solo' } };
+  for (const value of ['enormous', '', 0, false]) {
+    lastUpdatedRow = null;
+    const res = await patch('/provisioning/instances/41/detail', { detail: { team_shape: value } });
+    assert.equal(res.status, 400, `${JSON.stringify(value)} → ${res.raw}`);
+    assert.equal(res.body.error.code, 'bad_detail');
+    assert.match(res.body.error.message, /solo/, 'the message names the answers it does take');
+    assert.equal(lastUpdatedRow, null, 'a refused write touches nothing');
+  }
+  detailRow = null; lastUpdatedRow = null;
+});
+
+await ta('POST /instances: a null answer at CREATION is accepted and stores nothing — there is nothing to un-answer yet', async () => {
+  // badProjectDetail is shared with the create route, so the un-answer verb must not
+  // become a 400 there. Nothing to clear at creation, so it simply reads as no answer.
+  lastCreateArgs = null; existingRow = null;
+
+  const res = await post('/provisioning/instances', {
+    slug: 'mercury', hosting_shape: 'standalone', type: 'game', detail: { team_shape: null },
+  });
+
+  assert.equal(res.status, 201, `expected 201, got ${res.status} ${res.raw}`);
+  assert.deepEqual(res.body.instance.detail, {}, 'the row is born unanswered, as it would be with no detail at all');
+});
+
+await ta('PATCH /detail: an EMPTY detail patch still changes nothing — a skipped form is not an erase', async () => {
+  // RFC 7396's own rule, and the one ADR 0240 leans on: `{}` is the shape a form
+  // sends when it collected no answers, so making it erase would un-answer the
+  // interview every time an owner saved the step without touching it.
+  detailRow = { id: 41, owner_builder_id: 7, slug: 'mercury', status: 'active', type: 'game', modules: null, detail: { team_shape: 'solo' } };
+  lastUpdatedRow = null;
+
+  const res = await patch('/provisioning/instances/41/detail', { detail: {} });
+
+  assert.equal(res.status, 200, res.raw);
+  assert.deepEqual(lastUpdatedRow.detail, { team_shape: 'solo' }, 'the stored answer survives an empty patch');
+  assert.deepEqual(res.body.detail, { team_shape: 'solo' });
+  detailRow = null; lastUpdatedRow = null;
+});
+
 server.close();
 console.log(`\n${passed} passed, ${failed} failed`);
 process.exit(failed === 0 ? 0 : 1);