@bongos/core 1.21.107 → 1.21.109

package/tests/seed_verify_criteria.mjs

@@ -15,11 +15,13 @@
 
 import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
 
 const require = createRequire(import.meta.url);
 const {
   diffCriterionLinks,
   expectedCriterionCounts,
+  baselineSeedCriteria,
   verifySeedCriteriaLinks,
 } = require('../scripts/gds/seed-verify-criteria.js');
 
@@ -145,5 +147,133 @@ await testAsync('a failed/malformed GET is treated as a verification failure, no
   assert.ok(logs.some((l) => l.includes('VERIFY FAILED')));
 });
 
+// --- task 1004668: seeding into a goal that already carries linked work -----
+//
+// Goal 1000095 held six criteria with live links (1, 9, 4, 3, 6, 10) before a
+// seed touched it. The old diff unioned those into the check with an expected
+// count of zero, so a CORRECT seed exited 1 six times over.
+
+const POPULATED = [
+  { criterion_id: 'old-1', linked_tasks: 1 }, { criterion_id: 'old-2', linked_tasks: 9 },
+  { criterion_id: 'old-3', linked_tasks: 4 }, { criterion_id: 'old-4', linked_tasks: 3 },
+  { criterion_id: 'old-5', linked_tasks: 6 }, { criterion_id: 'old-6', linked_tasks: 10 },
+];
+
+test('THE INCIDENT: without a baseline, criteria the seed does not cite are not assumed to be zero', () => {
+  const rows = [...POPULATED, { criterion_id: 'ours', linked_tasks: 2 }];
+  assert.deepEqual(diffCriterionLinks({ ours: 2 }, rows), []);
+});
+
+test('without a baseline the plan\'s own criteria are still checked', () => {
+  const rows = [...POPULATED, { criterion_id: 'ours', linked_tasks: 0 }];
+  assert.deepEqual(diffCriterionLinks({ ours: 2 }, rows), [{ criterion_id: 'ours', expected: 2, actual: 0 }]);
+});
+
+test('with a baseline, an untouched criterion at its pre-seed count passes', () => {
+  const baseline = { 'old-1': 1, 'old-2': 9, 'old-3': 4, 'old-4': 3, 'old-5': 6, 'old-6': 10, ours: 0 };
+  const rows = [...POPULATED, { criterion_id: 'ours', linked_tasks: 2 }];
+  assert.deepEqual(diffCriterionLinks({ ours: 2 }, rows, { baseline }), []);
+});
+
+test('with a baseline, a stray link onto a criterion the seed never cites is caught', () => {
+  // The RETRO2 mislink lands tasks on the WRONG criterion. With a baseline that
+  // excess is visible even though the wrong criterion is not in the plan.
+  const baseline = { 'old-1': 1, ours: 0 };
+  const rows = [{ criterion_id: 'old-1', linked_tasks: 3 }, { criterion_id: 'ours', linked_tasks: 0 }];
+  assert.deepEqual(diffCriterionLinks({ ours: 2 }, rows, { baseline }), [
+    { criterion_id: 'old-1', expected: 1, actual: 3 },
+    { criterion_id: 'ours', expected: 2, actual: 0 },
+  ]);
+});
+
+test('with a baseline, a planned criterion that already had links expects baseline + plan', () => {
+  const rows = [{ criterion_id: 'shared', linked_tasks: 7 }];
+  assert.deepEqual(diffCriterionLinks({ shared: 2 }, rows, { baseline: { shared: 5 } }), []);
+  assert.deepEqual(diffCriterionLinks({ shared: 2 }, rows, { baseline: { shared: 4 } }),
+    [{ criterion_id: 'shared', expected: 6, actual: 7 }]);
+});
+
+test('a criterion created after the baseline starts at zero, so a link on it is caught', () => {
+  const rows = [{ criterion_id: 'brand-new', linked_tasks: 1 }];
+  assert.deepEqual(diffCriterionLinks({}, rows, { baseline: {} }),
+    [{ criterion_id: 'brand-new', expected: 0, actual: 1 }]);
+});
+
+const goalWith = (criteria) => async () => ({ ok: true, status: 200, json: { criteria } });
+
+// A RESUMED seed (grade finding on task 1004668). The first run created task A
+// (linked to `ours`) and died; the re-run baselines AFTER that, replays A
+// (`idempotent: true`) and creates B. The plan must count only B — tallying the
+// replay too expects A's link twice and fails a correct resume.
+function tallyCreated(responses) {
+  // The reference seed's tally rule, exactly: skip a replayed create.
+  return expectedCriterionCounts(responses.filter((r) => !r.idempotent).map((r) => r.crit));
+}
+
+test('a resumed seed tallies only what THIS run created, and verifies OK', () => {
+  const baseline = { ours: 1 }; // A's link, from the first run
+  const responses = [{ crit: ['ours'], idempotent: true }, { crit: ['ours'] }];
+  const rows = [{ criterion_id: 'ours', linked_tasks: 2 }];
+  assert.deepEqual(diffCriterionLinks(tallyCreated(responses), rows, { baseline }), []);
+  // The bug the finding names: counting the replay expects 3.
+  const naive = expectedCriterionCounts(responses.map((r) => r.crit));
+  assert.deepEqual(diffCriterionLinks(naive, rows, { baseline }), [{ criterion_id: 'ours', expected: 3, actual: 2 }]);
+});
+
+test('a fully re-run seed (every create a replay) plans nothing and verifies OK', () => {
+  const responses = [{ crit: ['ours'], idempotent: true }, { crit: ['ours'], idempotent: true }];
+  assert.deepEqual(diffCriterionLinks(tallyCreated(responses), [{ criterion_id: 'ours', linked_tasks: 2 }], { baseline: { ours: 2 } }), []);
+});
+
+test('the baselined reference seed skips replays when it tallies', () => {
+  const src = readFileSync(new URL('../scripts/gds/seed-bv2-ideator-surface-tasks.js', import.meta.url), 'utf8');
+  assert.match(src, /baselineSeedCriteria\(/, 'it takes a baseline');
+  assert.match(src, /if \(!r\.json\.idempotent\) criterionIdListsPerTask\.push\(t\.crit\);/, 'and tallies only created tasks');
+});
+
+await testAsync('baselineSeedCriteria snapshots the goal before any write', async () => {
+  const logs = [];
+  const baseline = await baselineSeedCriteria({
+    goalId: 1000095, fetchGoal: goalWith(POPULATED), log: (l) => logs.push(l), exit: () => { throw new Error('should not exit'); },
+  });
+  assert.deepEqual(baseline, { 'old-1': 1, 'old-2': 9, 'old-3': 4, 'old-4': 3, 'old-5': 6, 'old-6': 10 });
+  assert.ok(logs.some((l) => l.includes('6 already carrying linked tasks')));
+});
+
+await testAsync('baselineSeedCriteria refuses to seed blind when the goal cannot be read', async () => {
+  let exitCode = null; const logs = [];
+  await baselineSeedCriteria({
+    goalId: 1000095, fetchGoal: async () => ({ ok: false, status: 401, json: null }),
+    log: (l) => logs.push(l), exit: (c) => { exitCode = c; },
+  });
+  assert.equal(exitCode, 1);
+  assert.ok(logs.some((l) => l.includes('Refusing to seed blind')));
+});
+
+await testAsync('a correct seed into a populated goal verifies OK end to end, baseline passed through', async () => {
+  const logs = []; let exitCalled = false;
+  const baseline = await baselineSeedCriteria({ goalId: 1000095, fetchGoal: goalWith(POPULATED), log: () => {} });
+  await verifySeedCriteriaLinks({
+    goalId: 1000095,
+    expectedCounts: expectedCriterionCounts([['ours'], ['ours']]),
+    baseline,
+    fetchGoal: goalWith([...POPULATED, { criterion_id: 'ours', linked_tasks: 2 }]),
+    log: (l) => logs.push(l),
+    exit: () => { exitCalled = true; },
+  });
+  assert.equal(exitCalled, false, logs.join('\n'));
+  assert.ok(logs.some((l) => l.includes('VERIFY OK') && l.includes('pre-seed count')));
+});
+
+await testAsync('without a baseline the OK line says what it did not check', async () => {
+  const logs = [];
+  await verifySeedCriteriaLinks({
+    goalId: 1000095, expectedCounts: { ours: 2 },
+    fetchGoal: goalWith([...POPULATED, { criterion_id: 'ours', linked_tasks: 2 }]),
+    log: (l) => logs.push(l), exit: () => { throw new Error('should not exit'); },
+  });
+  assert.ok(logs.some((l) => /were not checked/.test(l) && l.includes('baselineSeedCriteria')));
+});
+
 console.log(`\nseed_verify_criteria: ${passed} passed, ${failed} failed`);
 if (failed > 0) process.exit(1);