gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/park-milestone.test.ts

@@ -1,5 +1,3 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
@@ -8,7 +6,26 @@ import { deriveState, invalidateStateCache, getActiveMilestoneId } from '../stat
 import { clearPathCache } from '../paths.ts';
 import { parkMilestone, unparkMilestone, discardMilestone, isParked, getParkedReason } from '../milestone-actions.ts';
 
+let passed = 0;
+let failed = 0;
 
+function assert(condition: boolean, message: string): void {
+  if (condition) {
+    passed++;
+  } else {
+    failed++;
+    console.error(`  FAIL: ${message}`);
+  }
+}
+
+function assertEq<T>(actual: T, expected: T, message: string): void {
+  if (JSON.stringify(actual) === JSON.stringify(expected)) {
+    passed++;
+  } else {
+    failed++;
+    console.error(`  FAIL: ${message} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
 
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
@@ -72,28 +89,30 @@ function clearCaches(): void {
 // Tests
 // ═══════════════════════════════════════════════════════════════════════════
 
-  // ─── Test 1: parkMilestone creates PARKED.md ──────────────────────────
+async function main(): Promise<void> {
 
-describe('park-milestone', () => {
-test('parkMilestone creates PARKED.md', () => {
+  // ─── Test 1: parkMilestone creates PARKED.md ──────────────────────────
+  console.log('\n=== parkMilestone creates PARKED.md ===');
+  {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
       clearCaches();
 
       const success = parkMilestone(base, 'M001', 'Priority shift');
-      assert.ok(success, 'parkMilestone returns true');
-      assert.ok(isParked(base, 'M001'), 'isParked returns true after parking');
+      assert(success, 'parkMilestone returns true');
+      assert(isParked(base, 'M001'), 'isParked returns true after parking');
 
       const reason = getParkedReason(base, 'M001');
-      assert.deepStrictEqual(reason, 'Priority shift', 'reason matches');
+      assertEq(reason, 'Priority shift', 'reason matches');
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Test 2: parkMilestone is idempotent — fails if already parked ────
-test('parkMilestone fails if already parked', () => {
+  console.log('\n=== parkMilestone fails if already parked ===');
+  {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
@@ -101,47 +120,50 @@ test('parkMilestone fails if already parked', () => {
 
       parkMilestone(base, 'M001', 'First park');
       const secondPark = parkMilestone(base, 'M001', 'Second park');
-      assert.ok(!secondPark, 'second parkMilestone returns false');
-      assert.deepStrictEqual(getParkedReason(base, 'M001'), 'First park', 'reason unchanged from first park');
+      assert(!secondPark, 'second parkMilestone returns false');
+      assertEq(getParkedReason(base, 'M001'), 'First park', 'reason unchanged from first park');
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Test 3: unparkMilestone removes PARKED.md ────────────────────────
-test('unparkMilestone removes PARKED.md', () => {
+  console.log('\n=== unparkMilestone removes PARKED.md ===');
+  {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
       clearCaches();
 
       parkMilestone(base, 'M001', 'Test reason');
-      assert.ok(isParked(base, 'M001'), 'milestone is parked');
+      assert(isParked(base, 'M001'), 'milestone is parked');
 
       const success = unparkMilestone(base, 'M001');
-      assert.ok(success, 'unparkMilestone returns true');
-      assert.ok(!isParked(base, 'M001'), 'isParked returns false after unpark');
+      assert(success, 'unparkMilestone returns true');
+      assert(!isParked(base, 'M001'), 'isParked returns false after unpark');
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Test 4: unparkMilestone fails if not parked ──────────────────────
-test('unparkMilestone fails if not parked', () => {
+  console.log('\n=== unparkMilestone fails if not parked ===');
+  {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
       clearCaches();
 
       const result = unparkMilestone(base, 'M001');
-      assert.ok(!result, 'unparkMilestone returns false when not parked');
+      assert(!result, 'unparkMilestone returns false when not parked');
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Test 5: deriveState returns 'parked' status ──────────────────────
-test('deriveState returns parked status', async () => {
+  console.log('\n=== deriveState returns parked status ===');
+  {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
@@ -151,15 +173,16 @@ test('deriveState returns parked status', async () => {
 
       const state = await deriveState(base);
       const entry = state.registry.find(e => e.id === 'M001');
-      assert.ok(!!entry, 'M001 in registry');
-      assert.deepStrictEqual(entry?.status, 'parked', 'status is parked');
+      assert(!!entry, 'M001 in registry');
+      assertEq(entry?.status, 'parked', 'status is parked');
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Test 6: deriveState skips parked milestone for active ─────────────
-test('deriveState skips parked milestone', async () => {
+  console.log('\n=== deriveState skips parked milestone ===');
+  {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
@@ -168,28 +191,29 @@ test('deriveState skips parked milestone', async () => {
 
       // Before park: M001 is active
       const stateBefore = await deriveState(base);
-      assert.deepStrictEqual(stateBefore.activeMilestone?.id, 'M001', 'before park: M001 is active');
+      assertEq(stateBefore.activeMilestone?.id, 'M001', 'before park: M001 is active');
 
       parkMilestone(base, 'M001', 'Testing');
 
       // After park: M002 becomes active
       const stateAfter = await deriveState(base);
-      assert.deepStrictEqual(stateAfter.activeMilestone?.id, 'M002', 'after park: M002 is active');
+      assertEq(stateAfter.activeMilestone?.id, 'M002', 'after park: M002 is active');
 
       // M001 still in registry as parked
       const m001 = stateAfter.registry.find(e => e.id === 'M001');
-      assert.deepStrictEqual(m001?.status, 'parked', 'M001 has parked status');
+      assertEq(m001?.status, 'parked', 'M001 has parked status');
 
       // M002 is active
       const m002 = stateAfter.registry.find(e => e.id === 'M002');
-      assert.deepStrictEqual(m002?.status, 'active', 'M002 has active status');
+      assertEq(m002?.status, 'active', 'M002 has active status');
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Test 7: getActiveMilestoneId skips parked ────────────────────────
-test('getActiveMilestoneId skips parked', async () => {
+  console.log('\n=== getActiveMilestoneId skips parked ===');
+  {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
@@ -199,14 +223,15 @@ test('getActiveMilestoneId skips parked', async () => {
       parkMilestone(base, 'M001', 'Testing');
 
       const activeId = await getActiveMilestoneId(base);
-      assert.deepStrictEqual(activeId, 'M002', 'getActiveMilestoneId returns M002');
+      assertEq(activeId, 'M002', 'getActiveMilestoneId returns M002');
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Test 8: Parked milestone does NOT satisfy depends_on ─────────────
-test('Parked milestone does not satisfy depends_on', async () => {
+  console.log('\n=== Parked milestone does not satisfy depends_on ===');
+  {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
@@ -218,17 +243,18 @@ test('Parked milestone does not satisfy depends_on', async () => {
       const state = await deriveState(base);
       // M001 is parked, M002 depends on M001 → M002 should be pending, not active
       const m002 = state.registry.find(e => e.id === 'M002');
-      assert.deepStrictEqual(m002?.status, 'pending', 'M002 stays pending when M001 is parked');
+      assertEq(m002?.status, 'pending', 'M002 stays pending when M001 is parked');
 
       // No active milestone (both are blocked/parked)
-      assert.deepStrictEqual(state.activeMilestone, null, 'no active milestone');
+      assertEq(state.activeMilestone, null, 'no active milestone');
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Test 9: Park then unpark restores correct status ─────────────────
-test('Park then unpark restores status', async () => {
+  console.log('\n=== Park then unpark restores status ===');
+  {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
@@ -238,41 +264,43 @@ test('Park then unpark restores status', async () => {
       // Park M001
       parkMilestone(base, 'M001', 'Testing');
       const stateParked = await deriveState(base);
-      assert.deepStrictEqual(stateParked.activeMilestone?.id, 'M002', 'while parked: M002 is active');
+      assertEq(stateParked.activeMilestone?.id, 'M002', 'while parked: M002 is active');
 
       // Unpark M001 — M001 should become active again (it's first in queue)
       unparkMilestone(base, 'M001');
       const stateUnparked = await deriveState(base);
-      assert.deepStrictEqual(stateUnparked.activeMilestone?.id, 'M001', 'after unpark: M001 is active again');
-      assert.deepStrictEqual(stateUnparked.registry.find(e => e.id === 'M001')?.status, 'active', 'M001 is active status');
+      assertEq(stateUnparked.activeMilestone?.id, 'M001', 'after unpark: M001 is active again');
+      assertEq(stateUnparked.registry.find(e => e.id === 'M001')?.status, 'active', 'M001 is active status');
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Test 10: discardMilestone removes directory ──────────────────────
-test('discardMilestone removes directory', async () => {
+  console.log('\n=== discardMilestone removes directory ===');
+  {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
       clearCaches();
 
       const mDir = join(base, '.gsd', 'milestones', 'M001');
-      assert.ok(existsSync(mDir), 'milestone dir exists before discard');
+      assert(existsSync(mDir), 'milestone dir exists before discard');
 
       const success = discardMilestone(base, 'M001');
-      assert.ok(success, 'discardMilestone returns true');
-      assert.ok(!existsSync(mDir), 'milestone dir removed after discard');
+      assert(success, 'discardMilestone returns true');
+      assert(!existsSync(mDir), 'milestone dir removed after discard');
 
       const state = await deriveState(base);
-      assert.ok(!state.registry.some(e => e.id === 'M001'), 'M001 not in registry after discard');
+      assert(!state.registry.some(e => e.id === 'M001'), 'M001 not in registry after discard');
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Test 11: discardMilestone updates queue order ────────────────────
-test('discardMilestone updates queue order', () => {
+  console.log('\n=== discardMilestone updates queue order ===');
+  {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
@@ -287,15 +315,16 @@ test('discardMilestone updates queue order', () => {
 
       // Queue order should no longer include M001
       const queueContent = JSON.parse(readFileSync(queuePath, 'utf-8'));
-      assert.ok(!queueContent.order.includes('M001'), 'M001 removed from queue order');
-      assert.ok(queueContent.order.includes('M002'), 'M002 still in queue order');
+      assert(!queueContent.order.includes('M001'), 'M001 removed from queue order');
+      assert(queueContent.order.includes('M002'), 'M002 still in queue order');
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Test 12: All milestones parked → no active milestone ─────────────
-test('All milestones parked → no active', async () => {
+  console.log('\n=== All milestones parked → no active ===');
+  {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
@@ -304,17 +333,18 @@ test('All milestones parked → no active', async () => {
       parkMilestone(base, 'M001', 'Testing');
 
       const state = await deriveState(base);
-      assert.deepStrictEqual(state.activeMilestone, null, 'no active milestone when all parked');
-      assert.deepStrictEqual(state.phase, 'pre-planning', 'phase is pre-planning');
-      assert.ok(state.registry.length === 1, 'registry still has 1 entry');
-      assert.deepStrictEqual(state.registry[0]?.status, 'parked', 'entry is parked');
+      assertEq(state.activeMilestone, null, 'no active milestone when all parked');
+      assertEq(state.phase, 'pre-planning', 'phase is pre-planning');
+      assert(state.registry.length === 1, 'registry still has 1 entry');
+      assertEq(state.registry[0]?.status, 'parked', 'entry is parked');
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Test 13: Parked milestone without roadmap ────────────────────────
-test('Park milestone without roadmap', async () => {
+  console.log('\n=== Park milestone without roadmap ===');
+  {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001'); // No roadmap
@@ -324,15 +354,16 @@ test('Park milestone without roadmap', async () => {
       parkMilestone(base, 'M001', 'Not ready yet');
 
       const state = await deriveState(base);
-      assert.deepStrictEqual(state.activeMilestone?.id, 'M002', 'M002 is active when M001 (no roadmap) is parked');
-      assert.deepStrictEqual(state.registry.find(e => e.id === 'M001')?.status, 'parked', 'M001 is parked');
+      assertEq(state.activeMilestone?.id, 'M002', 'M002 is active when M001 (no roadmap) is parked');
+      assertEq(state.registry.find(e => e.id === 'M001')?.status, 'parked', 'M001 is parked');
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Test 14: Progress counts with parked milestone ───────────────────
-test('Progress counts with parked', async () => {
+  console.log('\n=== Progress counts with parked ===');
+  {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true, withSummary: true }); // complete
@@ -343,12 +374,28 @@ test('Progress counts with parked', async () => {
       parkMilestone(base, 'M002', 'Parked');
 
       const state = await deriveState(base);
-      assert.deepStrictEqual(state.progress?.milestones.done, 1, '1 complete milestone');
-      assert.deepStrictEqual(state.progress?.milestones.total, 3, '3 total milestones (including parked)');
-      assert.deepStrictEqual(state.activeMilestone?.id, 'M003', 'M003 is active');
+      assertEq(state.progress?.milestones.done, 1, '1 complete milestone');
+      assertEq(state.progress?.milestones.total, 3, '3 total milestones (including parked)');
+      assertEq(state.activeMilestone?.id, 'M003', 'M003 is active');
     } finally {
       cleanup(base);
     }
-});
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Results
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  console.log(`\n${'='.repeat(40)}`);
+  console.log(`Results: ${passed} passed, ${failed} failed`);
+  if (failed > 0) {
+    process.exit(1);
+  } else {
+    console.log('All tests passed ✓');
+  }
+}
 
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
 });