gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/run-uat.test.ts

@@ -1,5 +1,14 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
+// Tests for extractUatType — the core UAT classification primitive — plus
+// prompt template loading and dispatch precondition assertions (via
+// resolveSliceFile / extractUatType on real fixture files).
+//
+// Sections:
+//   (a)–(j)  extractUatType classification (17 assertions from T01)
+//   (k)      run-uat prompt template loading and content integrity (8 assertions)
+//   (l)      dispatch precondition assertions via resolveSliceFile (4 assertions)
+//   (m)      non-artifact UAT skip: human-experience UATs are not dispatched (1 assertion)
+//   (n)      stale replay guard: existing UAT-RESULT never re-dispatches (1 assertion)
+
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { tmpdir } from 'node:os';
@@ -8,6 +17,11 @@ import { fileURLToPath } from 'node:url';
 import { extractUatType } from '../files.ts';
 import { resolveSliceFile } from '../paths.ts';
 import { checkNeedsRunUat } from '../auto-prompts.ts';
+import { createTestContext } from './test-helpers.ts';
+
+// ─── Worktree-aware prompt loader ──────────────────────────────────────────
+// Resolves prompts relative to this test file so the worktree copy is used
+// instead of the main checkout copy (matches complete-milestone.test.ts pattern).
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const worktreePromptsDir = join(__dirname, '..', 'prompts');
@@ -25,6 +39,10 @@ function loadPromptFromWorktree(name: string, vars: Record<string, string> = {})
   return content.trim();
 }
 
+
+const { assertEq, assertTrue, report } = createTestContext();
+// ─── Fixture helpers ───────────────────────────────────────────────────────
+
 function createFixtureBase(): string {
   const base = mkdtempSync(join(tmpdir(), 'gsd-run-uat-test-'));
   mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
@@ -51,129 +69,154 @@ function makeUatContent(mode: string): string {
   return `# UAT File\n\n## UAT Type\n\n- UAT mode: ${mode}\n- Some other bullet: value\n`;
 }
 
-describe('run-uat', () => {
-test('(a) artifact-driven', () => {
-  assert.deepStrictEqual(
+// ═══════════════════════════════════════════════════════════════════════════
+// Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+async function main(): Promise<void> {
+
+  // ─── (a) artifact-driven ──────────────────────────────────────────────────
+  console.log('\n── (a) artifact-driven');
+
+  assertEq(
     extractUatType(makeUatContent('artifact-driven')),
     'artifact-driven',
     'plain artifact-driven → artifact-driven',
   );
-  assert.deepStrictEqual(
+
+  assertEq(
     extractUatType('## UAT Type\n\n- UAT mode: artifact-driven\n'),
     'artifact-driven',
     'minimal content, artifact-driven',
   );
-});
 
-test('(b) live-runtime', () => {
-  assert.deepStrictEqual(
+  // ─── (b) live-runtime ─────────────────────────────────────────────────────
+  console.log('\n── (b) live-runtime');
+
+  assertEq(
     extractUatType(makeUatContent('live-runtime')),
     'live-runtime',
     'plain live-runtime → live-runtime',
   );
-});
 
-test('(c) human-experience', () => {
-  assert.deepStrictEqual(
+  // ─── (c) human-experience ─────────────────────────────────────────────────
+  console.log('\n── (c) human-experience');
+
+  assertEq(
     extractUatType(makeUatContent('human-experience')),
     'human-experience',
     'plain human-experience → human-experience',
   );
-});
 
-test('(d) mixed standalone', () => {
-  assert.deepStrictEqual(
+  // ─── (d) mixed standalone ─────────────────────────────────────────────────
+  console.log('\n── (d) mixed standalone');
+
+  assertEq(
     extractUatType(makeUatContent('mixed')),
     'mixed',
     'plain mixed → mixed',
   );
-});
 
-test('(e) mixed parenthetical', () => {
-  assert.deepStrictEqual(
+  // ─── (e) mixed with parenthetical ─────────────────────────────────────────
+  console.log('\n── (e) mixed parenthetical');
+
+  assertEq(
     extractUatType(makeUatContent('mixed (artifact-driven + live-runtime)')),
     'mixed',
     'mixed (artifact-driven + live-runtime) → mixed (leading keyword only)',
   );
-  assert.deepStrictEqual(
+
+  assertEq(
     extractUatType(makeUatContent('mixed (some other description)')),
     'mixed',
     'mixed with arbitrary parenthetical → mixed',
   );
-});
 
-test('(f) missing UAT Type section', () => {
-  assert.deepStrictEqual(
+  // ─── (f) missing ## UAT Type section ──────────────────────────────────────
+  console.log('\n── (f) missing UAT Type section');
+
+  assertEq(
     extractUatType('# UAT File\n\n## Overview\n\nSome content.\n'),
     undefined,
     'no ## UAT Type section → undefined',
   );
-  assert.deepStrictEqual(
+
+  assertEq(
     extractUatType(''),
     undefined,
     'empty content → undefined',
   );
-});
 
-test('(g) UAT Type section present, no UAT mode: bullet', () => {
-  assert.deepStrictEqual(
+  // ─── (g) ## UAT Type present but no UAT mode: bullet ─────────────────────
+  console.log('\n── (g) UAT Type section present, no UAT mode: bullet');
+
+  assertEq(
     extractUatType('## UAT Type\n\n- Some other bullet: value\n- Another bullet\n'),
     undefined,
     'section present but no UAT mode: bullet → undefined',
   );
-  assert.deepStrictEqual(
+
+  assertEq(
     extractUatType('## UAT Type\n\n'),
     undefined,
     'section present but empty → undefined',
   );
-});
 
-test('(h) unknown keyword', () => {
-  assert.deepStrictEqual(
+  // ─── (h) unknown keyword ──────────────────────────────────────────────────
+  console.log('\n── (h) unknown keyword');
+
+  assertEq(
     extractUatType(makeUatContent('automated')),
     undefined,
     'unknown keyword automated → undefined',
   );
-  assert.deepStrictEqual(
+
+  assertEq(
     extractUatType(makeUatContent('fully-automated')),
     undefined,
     'unknown keyword fully-automated → undefined',
   );
-});
 
-test('(i) extra whitespace', () => {
-  assert.deepStrictEqual(
+  // ─── (i) extra whitespace around value ────────────────────────────────────
+  console.log('\n── (i) extra whitespace');
+
+  assertEq(
     extractUatType('## UAT Type\n\n- UAT mode:   artifact-driven   \n'),
     'artifact-driven',
     'leading/trailing whitespace around value → still classified correctly',
   );
-  assert.deepStrictEqual(
+
+  assertEq(
     extractUatType('## UAT Type\n\n- UAT mode:  mixed (artifact-driven + live-runtime)  \n'),
     'mixed',
     'whitespace around mixed parenthetical → mixed',
   );
-});
 
-test('(j) case sensitivity', () => {
-  assert.deepStrictEqual(
+  // ─── (j) case sensitivity ─────────────────────────────────────────────────
+  console.log('\n── (j) case sensitivity');
+
+  assertEq(
     extractUatType(makeUatContent('Artifact-Driven')),
     'artifact-driven',
     'Artifact-Driven (title case) → artifact-driven (function lowercases before matching)',
   );
-  assert.deepStrictEqual(
+
+  assertEq(
     extractUatType(makeUatContent('MIXED')),
     'mixed',
     'MIXED (upper case) → mixed (function lowercases before matching)',
   );
-});
 
-test('(k) run-uat prompt template', () => {
+  // ─── (k) prompt template loading and content integrity ────────────────────
+  console.log('\n── (k) run-uat prompt template');
+
   const milestoneId = 'M001';
   const sliceId = 'S01';
   const uatPath = '.gsd/milestones/M001/slices/S01/S01-UAT.md';
   const uatResultPath = '.gsd/milestones/M001/slices/S01/S01-UAT-RESULT.md';
   const uatType = 'live-runtime';
   const inlinedContext = '<!-- no context -->';
+
   let promptResult: string | undefined;
   let promptThrew = false;
   try {
@@ -189,66 +232,71 @@ test('(k) run-uat prompt template', () => {
   } catch {
     promptThrew = true;
   }
-  assert.ok(!promptThrew, 'loadPromptFromWorktree("run-uat", vars) does not throw');
-  assert.ok(
+
+  assertTrue(!promptThrew, 'loadPromptFromWorktree("run-uat", vars) does not throw');
+  assertTrue(
     typeof promptResult === 'string' && promptResult.length > 0,
     'run-uat prompt result is a non-empty string',
   );
-  assert.ok(
+  assertTrue(
     promptResult?.includes(milestoneId) ?? false,
     `prompt contains milestoneId value "${milestoneId}" after substitution`,
   );
-  assert.ok(
+  assertTrue(
     promptResult?.includes(sliceId) ?? false,
     `prompt contains sliceId value "${sliceId}" after substitution`,
   );
-  assert.ok(
+  assertTrue(
     promptResult?.includes(uatResultPath) ?? false,
     `prompt contains uatResultPath value after substitution`,
   );
-  assert.ok(
+  assertTrue(
     promptResult?.includes(`Detected UAT mode:** \`${uatType}\``) ?? false,
     `prompt contains detected dynamic uatType value "${uatType}" after substitution`,
   );
-  assert.ok(
+  assertTrue(
     promptResult?.includes(`uatType: ${uatType}`) ?? false,
     `prompt contains dynamic uatType frontmatter value "${uatType}" after substitution`,
   );
-  assert.ok(
+  assertTrue(
     !/\{\{[^}]+\}\}/.test(promptResult ?? ''),
     'no unreplaced {{...}} tokens remain after variable substitution',
   );
-  assert.ok(
+  assertTrue(
     /browser|runtime|execute|run/i.test(promptResult ?? ''),
     'prompt contains runtime execution language (browser/runtime/execute/run)',
   );
-  assert.ok(
+  assertTrue(
     !/surfaced for human review/i.test(promptResult ?? ''),
     'prompt does not contain "surfaced for human review" (non-artifact UATs are skipped, not dispatched)',
   );
-});
 
-test('(l) dispatch preconditions via resolveSliceFile', () => {
+  // ─── (l) dispatch precondition assertions via resolveSliceFile ────────────
+  console.log('\n── (l) dispatch preconditions via resolveSliceFile');
+
+  // State A: UAT file exists, UAT-RESULT file does NOT — triggers dispatch
+  {
     const base = createFixtureBase();
     const uatContent = makeUatContent('artifact-driven');
     try {
       writeSliceFile(base, 'M001', 'S01', 'UAT', uatContent);
 
       const uatFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT');
-      assert.ok(
+      assertTrue(
         uatFilePath !== null,
         'resolveSliceFile(..., "UAT") returns non-null when UAT file exists (dispatch trigger state)',
       );
 
       const uatResultFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT-RESULT');
-      assert.deepStrictEqual(
+      assertEq(
         uatResultFilePath,
         null,
         'resolveSliceFile(..., "UAT-RESULT") returns null when result file missing (dispatch trigger state)',
       );
 
+      // End-to-end: file content → parse → classify
       const rawContent = readFileSync(uatFilePath!, 'utf-8');
-      assert.deepStrictEqual(
+      assertEq(
         extractUatType(rawContent),
         'artifact-driven',
         'extractUatType on fixture UAT file returns expected type (end-to-end data flow)',
@@ -256,25 +304,29 @@ test('(l) dispatch preconditions via resolveSliceFile', () => {
     } finally {
       cleanup(base);
     }
-});
+  }
 
-test('test block at line 307', () => {
+  // State B: UAT-RESULT file exists — dispatch is skipped (idempotent)
+  {
     const base = createFixtureBase();
     try {
       writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('artifact-driven'));
       writeSliceFile(base, 'M001', 'S01', 'UAT-RESULT', '# UAT Result\n\nverdict: PASS\n');
 
       const uatResultFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT-RESULT');
-      assert.ok(
+      assertTrue(
         uatResultFilePath !== null,
         'resolveSliceFile(..., "UAT-RESULT") returns non-null when result file exists (idempotent skip state)',
       );
     } finally {
       cleanup(base);
     }
-});
+  }
+
+  // ─── (m) non-artifact UATs are skipped (not dispatched) ─────────────────
+  console.log('\n── (m) non-artifact UAT skip');
 
-test('(m) non-artifact UAT skip', async () => {
+  {
     const base = createFixtureBase();
     try {
       const roadmapDir = join(base, '.gsd', 'milestones', 'M001');
@@ -294,6 +346,7 @@ test('(m) non-artifact UAT skip', async () => {
         ].join('\n'),
       );
 
+      // human-experience UAT still dispatches, but auto-mode later pauses for manual review
       writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('human-experience'));
 
       const state = {
@@ -308,7 +361,7 @@ test('(m) non-artifact UAT skip', async () => {
       } as const;
 
       const result = await checkNeedsRunUat(base, 'M001', state as any, { uat_dispatch: true } as any);
-      assert.deepStrictEqual(
+      assertEq(
         result,
         { sliceId: 'S01', uatType: 'human-experience' },
         'human-experience UAT dispatches so auto-mode can pause for manual review',
@@ -316,9 +369,12 @@ test('(m) non-artifact UAT skip', async () => {
     } finally {
       cleanup(base);
     }
-});
+  }
+
+  // ─── (n) existing UAT-RESULT never re-dispatches ──────────────────────
+  console.log('\n── (n) stale replay guard');
 
-test('(n) stale replay guard', async () => {
+  {
     const base = createFixtureBase();
     try {
       const roadmapDir = join(base, '.gsd', 'milestones', 'M001');
@@ -353,7 +409,7 @@ test('(n) stale replay guard', async () => {
       } as const;
 
       const result = await checkNeedsRunUat(base, 'M001', state as any, { uat_dispatch: true } as any);
-      assert.deepStrictEqual(
+      assertEq(
         result,
         null,
         'existing UAT-RESULT with FAIL verdict does not re-dispatch; verdict gate owns blocking',
@@ -361,6 +417,12 @@ test('(n) stale replay guard', async () => {
     } finally {
       cleanup(base);
     }
-});
+  }
+
+  report();
+}
 
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
 });

package/src/resources/extensions/gsd/tests/session-lock-multipath.test.ts

@@ -20,11 +20,11 @@ import {
   _getRegisteredLockDirs,
 } from '../session-lock.ts';
 import { gsdRoot } from '../paths.ts';
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
+import { createTestContext } from './test-helpers.ts';
 
+const { assertEq, assertTrue, report } = createTestContext();
 
-describe('session-lock-multipath', async () => {
+async function main(): Promise<void> {
 
   // ─── 1. Lock dir registry tracks gsdDir on acquisition ──────────────────
   console.log('\n=== 1. Lock dir registry tracks gsdDir on acquisition ===');
@@ -34,17 +34,17 @@ describe('session-lock-multipath', async () => {
 
     try {
       const result = acquireSessionLock(base);
-      assert.ok(result.acquired, 'lock acquired');
+      assertTrue(result.acquired, 'lock acquired');
 
       const registered = _getRegisteredLockDirs();
       const gsdDir = gsdRoot(base);
-      assert.ok(registered.includes(gsdDir), 'gsdDir is registered in lock dir registry');
+      assertTrue(registered.includes(gsdDir), 'gsdDir is registered in lock dir registry');
 
       releaseSessionLock(base);
 
       // After release, registry should be cleared
       const afterRelease = _getRegisteredLockDirs();
-      assert.deepStrictEqual(afterRelease.length, 0, 'lock dir registry cleared after release');
+      assertEq(afterRelease.length, 0, 'lock dir registry cleared after release');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -62,7 +62,7 @@ describe('session-lock-multipath', async () => {
 
     try {
       const result = acquireSessionLock(base);
-      assert.ok(result.acquired, 'lock acquired');
+      assertTrue(result.acquired, 'lock acquired');
 
       // Manually plant a stale lock file at the secondary path to simulate
       // multi-path lock accumulation
@@ -72,8 +72,8 @@ describe('session-lock-multipath', async () => {
       mkdirSync(secondaryLockDir, { recursive: true });
 
       // Verify they exist before release
-      assert.ok(existsSync(secondaryLockFile), 'secondary lock file exists before release');
-      assert.ok(existsSync(secondaryLockDir), 'secondary lock dir exists before release');
+      assertTrue(existsSync(secondaryLockFile), 'secondary lock file exists before release');
+      assertTrue(existsSync(secondaryLockDir), 'secondary lock dir exists before release');
 
       // Manually add the secondary dir to the registry (simulating ensureExitHandler call)
       // We do this by acquiring knowledge of internals — the registry is populated
@@ -83,10 +83,10 @@ describe('session-lock-multipath', async () => {
 
       // Primary lock artifacts should be cleaned
       const primaryLockFile = join(gsdRoot(base), 'auto.lock');
-      assert.ok(!existsSync(primaryLockFile), 'primary auto.lock removed after release');
+      assertTrue(!existsSync(primaryLockFile), 'primary auto.lock removed after release');
 
       const primaryLockDir = gsdRoot(base) + '.lock';
-      assert.ok(!existsSync(primaryLockDir), 'primary .gsd.lock/ removed after release');
+      assertTrue(!existsSync(primaryLockDir), 'primary .gsd.lock/ removed after release');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -106,7 +106,7 @@ describe('session-lock-multipath', async () => {
       const gsdDir = gsdRoot(base);
       // Should only appear once (Set deduplication)
       const count = registered.filter(d => d === gsdDir).length;
-      assert.deepStrictEqual(count, 1, 'gsdDir registered exactly once after re-entrant acquisition');
+      assertEq(count, 1, 'gsdDir registered exactly once after re-entrant acquisition');
 
       releaseSessionLock(base);
     } finally {
@@ -124,17 +124,17 @@ describe('session-lock-multipath', async () => {
 
     try {
       const r1 = acquireSessionLock(base1);
-      assert.ok(r1.acquired, 'first base lock acquired');
+      assertTrue(r1.acquired, 'first base lock acquired');
 
       // Release first to acquire second (module state is single-lock)
       releaseSessionLock(base1);
 
       const r2 = acquireSessionLock(base2);
-      assert.ok(r2.acquired, 'second base lock acquired');
+      assertTrue(r2.acquired, 'second base lock acquired');
 
       const registered = _getRegisteredLockDirs();
       const gsd2 = gsdRoot(base2);
-      assert.ok(registered.includes(gsd2), 'second gsdDir is registered');
+      assertTrue(registered.includes(gsd2), 'second gsdDir is registered');
 
       releaseSessionLock(base2);
     } finally {
@@ -156,11 +156,18 @@ describe('session-lock-multipath', async () => {
       // Verify everything is clean
       const lockFile = join(gsdRoot(base), 'auto.lock');
       const lockDir = gsdRoot(base) + '.lock';
-      assert.ok(!existsSync(lockFile), 'auto.lock cleaned');
-      assert.ok(!existsSync(lockDir), '.gsd.lock/ cleaned');
-      assert.deepStrictEqual(_getRegisteredLockDirs().length, 0, 'registry empty');
+      assertTrue(!existsSync(lockFile), 'auto.lock cleaned');
+      assertTrue(!existsSync(lockDir), '.gsd.lock/ cleaned');
+      assertEq(_getRegisteredLockDirs().length, 0, 'registry empty');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
   }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
 });