bmad-fh 6.0.0-alpha.23 → 6.0.0-alpha.23.6fbcf839

package/test/test-scope-e2e.js

@@ -1,9 +1,9 @@
 /**
  * End-to-End Test: Multi-Scope Parallel Workflows
- * 
+ *
  * Tests the complete flow of running parallel workflows in different scopes,
  * including artifact isolation, sync operations, and event notifications.
- * 
+ *
  * Usage: node test/test-scope-e2e.js
  * Exit codes: 0 = all tests pass, 1 = test failures
  */
@@ -97,12 +97,12 @@ function assertFileContains(filePath, content, message = '') {
 // Create temporary test directory with BMAD structure
 function createTestProject() {
   const tmpDir = path.join(os.tmpdir(), `bmad-e2e-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  
+
   // Create BMAD directory structure
   fs.mkdirSync(path.join(tmpDir, '_bmad', '_config'), { recursive: true });
   fs.mkdirSync(path.join(tmpDir, '_bmad', '_events'), { recursive: true });
   fs.mkdirSync(path.join(tmpDir, '_bmad-output'), { recursive: true });
-  
+
   return tmpDir;
 }
 
@@ -116,33 +116,33 @@ function cleanupTestProject(tmpDir) {
 
 async function testParallelScopeWorkflow() {
   console.log(`\n${colors.blue}E2E: Parallel Scope Workflow Simulation${colors.reset}`);
-  
+
   const { ScopeManager } = require('../src/core/lib/scope/scope-manager');
   const { ScopeContext } = require('../src/core/lib/scope/scope-context');
   const { ArtifactResolver } = require('../src/core/lib/scope/artifact-resolver');
   const { ScopeSync } = require('../src/core/lib/scope/scope-sync');
   const { EventLogger } = require('../src/core/lib/scope/event-logger');
-  
+
   let tmpDir;
-  
+
   try {
     tmpDir = createTestProject();
-    
+
     // Initialize components
     const manager = new ScopeManager({ projectRoot: tmpDir });
     const context = new ScopeContext({ projectRoot: tmpDir });
-    
+
     // ========================================
     // Step 1: Initialize scope system
     // ========================================
     await asyncTest('Initialize scope system', async () => {
       await manager.initialize();
-      
+
       assertFileExists(path.join(tmpDir, '_bmad', '_config', 'scopes.yaml'));
       assertFileExists(path.join(tmpDir, '_bmad-output', '_shared'));
       assertFileExists(path.join(tmpDir, '_bmad', '_events'));
     });
-    
+
     // ========================================
     // Step 2: Create two scopes (auth and payments)
     // ========================================
@@ -151,25 +151,25 @@ async function testParallelScopeWorkflow() {
         name: 'Authentication Service',
         description: 'User auth, SSO, authorization',
       });
-      
+
       assertEqual(scope.id, 'auth');
       assertEqual(scope.status, 'active');
       assertFileExists(path.join(tmpDir, '_bmad-output', 'auth', 'planning-artifacts'));
       assertFileExists(path.join(tmpDir, '_bmad-output', 'auth', 'implementation-artifacts'));
       assertFileExists(path.join(tmpDir, '_bmad-output', 'auth', 'tests'));
     });
-    
+
     await asyncTest('Create payments scope with dependency on auth', async () => {
       const scope = await manager.createScope('payments', {
         name: 'Payment Processing',
         description: 'Payment gateway integration',
         dependencies: ['auth'],
       });
-      
+
       assertEqual(scope.id, 'payments');
       assertTrue(scope.dependencies.includes('auth'));
     });
-    
+
     // ========================================
     // Step 3: Simulate parallel artifact creation
     // ========================================
@@ -177,39 +177,33 @@ async function testParallelScopeWorkflow() {
       // Create PRD in auth scope
       const prdPath = path.join(tmpDir, '_bmad-output', 'auth', 'planning-artifacts', 'prd.md');
       fs.writeFileSync(prdPath, '# Auth PRD\n\nAuthentication requirements...');
-      
+
       assertFileExists(prdPath);
       assertFileContains(prdPath, 'Auth PRD');
     });
-    
+
     await asyncTest('Simulate parallel PRD creation in payments scope', async () => {
       // Create PRD in payments scope
       const prdPath = path.join(tmpDir, '_bmad-output', 'payments', 'planning-artifacts', 'prd.md');
       fs.writeFileSync(prdPath, '# Payments PRD\n\nPayment processing requirements...');
-      
+
       assertFileExists(prdPath);
       assertFileContains(prdPath, 'Payments PRD');
     });
-    
+
     // ========================================
     // Step 4: Verify artifact isolation
     // ========================================
     await asyncTest('Verify artifacts are isolated', async () => {
-      const authPrd = fs.readFileSync(
-        path.join(tmpDir, '_bmad-output', 'auth', 'planning-artifacts', 'prd.md'),
-        'utf8'
-      );
-      const paymentsPrd = fs.readFileSync(
-        path.join(tmpDir, '_bmad-output', 'payments', 'planning-artifacts', 'prd.md'),
-        'utf8'
-      );
-      
+      const authPrd = fs.readFileSync(path.join(tmpDir, '_bmad-output', 'auth', 'planning-artifacts', 'prd.md'), 'utf8');
+      const paymentsPrd = fs.readFileSync(path.join(tmpDir, '_bmad-output', 'payments', 'planning-artifacts', 'prd.md'), 'utf8');
+
       assertTrue(authPrd.includes('Auth PRD'), 'Auth PRD should contain auth content');
       assertTrue(paymentsPrd.includes('Payments PRD'), 'Payments PRD should contain payments content');
       assertFalse(authPrd.includes('Payments'), 'Auth PRD should not contain payments content');
       assertFalse(paymentsPrd.includes('Auth'), 'Payments PRD should not contain auth content');
     });
-    
+
     // ========================================
     // Step 5: Test ArtifactResolver access control
     // ========================================
@@ -219,14 +213,14 @@ async function testParallelScopeWorkflow() {
         basePath: '_bmad-output',
         projectRoot: tmpDir,
       });
-      
+
       // Payments scope can read auth scope
       assertTrue(
         resolver.canRead(path.join(tmpDir, '_bmad-output', 'auth', 'planning-artifacts', 'prd.md')),
-        'Should allow cross-scope read'
+        'Should allow cross-scope read',
       );
     });
-    
+
     await asyncTest('ArtifactResolver blocks cross-scope write', async () => {
       const resolver = new ArtifactResolver({
         currentScope: 'payments',
@@ -234,111 +228,110 @@ async function testParallelScopeWorkflow() {
         projectRoot: tmpDir,
         isolationMode: 'strict',
       });
-      
+
       // Payments scope cannot write to auth scope
       assertFalse(
         resolver.canWrite(path.join(tmpDir, '_bmad-output', 'auth', 'planning-artifacts', 'new.md')),
-        'Should block cross-scope write'
+        'Should block cross-scope write',
       );
     });
-    
+
     // ========================================
     // Step 6: Test scope context session
     // ========================================
     await asyncTest('Session-sticky scope works', async () => {
       await context.setScope('auth');
-      
+
       const currentScope = await context.getCurrentScope();
       assertEqual(currentScope, 'auth', 'Session scope should be auth');
-      
+
       // Check .bmad-scope file was created
       assertFileExists(path.join(tmpDir, '.bmad-scope'));
     });
-    
+
     await asyncTest('Session scope can be switched', async () => {
       await context.setScope('payments');
-      
+
       const currentScope = await context.getCurrentScope();
       assertEqual(currentScope, 'payments', 'Session scope should be payments');
     });
-    
+
     // ========================================
     // Step 7: Test sync-up (promote to shared)
     // ========================================
     await asyncTest('Sync-up promotes artifacts to shared layer', async () => {
       const sync = new ScopeSync({ projectRoot: tmpDir });
-      
+
       // Create a promotable artifact (architecture.md)
       const archPath = path.join(tmpDir, '_bmad-output', 'auth', 'planning-artifacts', 'architecture.md');
       fs.mkdirSync(path.dirname(archPath), { recursive: true });
       fs.writeFileSync(archPath, '# Auth Architecture\n\nShared auth patterns...');
-      
+
       // Create architecture directory in shared
       fs.mkdirSync(path.join(tmpDir, '_bmad-output', '_shared', 'auth'), { recursive: true });
-      
+
       await sync.syncUp('auth');
-      
+
       // Check artifact was promoted
       assertFileExists(
         path.join(tmpDir, '_bmad-output', '_shared', 'auth', 'architecture.md'),
-        'Architecture should be promoted to shared'
+        'Architecture should be promoted to shared',
       );
     });
-    
+
     // ========================================
     // Step 8: Test event logging
     // ========================================
     await asyncTest('Events are logged', async () => {
       const eventLogger = new EventLogger({ projectRoot: tmpDir });
-      
+
       await eventLogger.log({
         type: 'artifact_created',
         scope: 'auth',
         artifact: 'prd.md',
       });
-      
+
       const events = await eventLogger.getEvents({ scope: 'auth' });
       assertTrue(events.length > 0, 'Should have logged events');
       assertEqual(events[0].type, 'artifact_created');
     });
-    
+
     // ========================================
     // Step 9: Test dependency tracking
     // ========================================
     await asyncTest('Dependent scopes can be found', async () => {
       const dependents = await manager.findDependentScopes('auth');
-      
+
       assertTrue(dependents.includes('payments'), 'payments should depend on auth');
     });
-    
+
     // ========================================
     // Step 10: Test scope archival
     // ========================================
     await asyncTest('Scope can be archived', async () => {
       await manager.archiveScope('auth');
-      
+
       const scope = await manager.getScope('auth');
       assertEqual(scope.status, 'archived', 'Scope should be archived');
-      
+
       // Re-activate for cleanup
       await manager.activateScope('auth');
     });
-    
+
     // ========================================
     // Step 11: Verify final state
     // ========================================
     await asyncTest('Final state verification', async () => {
       const scopes = await manager.listScopes();
       assertEqual(scopes.length, 2, 'Should have 2 scopes');
-      
+
       // Both scopes should have their artifacts
       assertFileExists(path.join(tmpDir, '_bmad-output', 'auth', 'planning-artifacts', 'prd.md'));
       assertFileExists(path.join(tmpDir, '_bmad-output', 'payments', 'planning-artifacts', 'prd.md'));
-      
+
       // Shared layer should have promoted artifacts
       assertFileExists(path.join(tmpDir, '_bmad-output', '_shared'));
     });
-    
   } finally {
     if (tmpDir) {
       cleanupTestProject(tmpDir);
@@ -352,52 +345,48 @@ async function testParallelScopeWorkflow() {
 
 async function testConcurrentLockSimulation() {
   console.log(`\n${colors.blue}E2E: Concurrent Lock Simulation${colors.reset}`);
-  
+
   const { StateLock } = require('../src/core/lib/scope/state-lock');
-  
+
   let tmpDir;
-  
+
   try {
     tmpDir = createTestProject();
     const lock = new StateLock();
     const lockPath = path.join(tmpDir, 'state.lock');
-    
+
     // ========================================
     // Simulate concurrent access from two "terminals"
     // ========================================
     await asyncTest('Concurrent operations are serialized', async () => {
       const results = [];
       const startTime = Date.now();
-      
+
       // Simulate Terminal 1 (auth scope)
       const terminal1 = lock.withLock(lockPath, async () => {
         results.push({ terminal: 1, action: 'start', time: Date.now() - startTime });
-        await new Promise(r => setTimeout(r, 50)); // Simulate work
+        await new Promise((r) => setTimeout(r, 50)); // Simulate work
         results.push({ terminal: 1, action: 'end', time: Date.now() - startTime });
         return 'terminal1';
       });
-      
+
       // Simulate Terminal 2 (payments scope) - starts slightly after
-      await new Promise(r => setTimeout(r, 10));
+      await new Promise((r) => setTimeout(r, 10));
       const terminal2 = lock.withLock(lockPath, async () => {
         results.push({ terminal: 2, action: 'start', time: Date.now() - startTime });
-        await new Promise(r => setTimeout(r, 50)); // Simulate work
+        await new Promise((r) => setTimeout(r, 50)); // Simulate work
         results.push({ terminal: 2, action: 'end', time: Date.now() - startTime });
         return 'terminal2';
       });
-      
+
       await Promise.all([terminal1, terminal2]);
-      
+
       // Terminal 2 should start after Terminal 1 ends
-      const t1End = results.find(r => r.terminal === 1 && r.action === 'end');
-      const t2Start = results.find(r => r.terminal === 2 && r.action === 'start');
-      
-      assertTrue(
-        t2Start.time >= t1End.time,
-        `Terminal 2 should start (${t2Start.time}ms) after Terminal 1 ends (${t1End.time}ms)`
-      );
+      const t1End = results.find((r) => r.terminal === 1 && r.action === 'end');
+      const t2Start = results.find((r) => r.terminal === 2 && r.action === 'start');
+
+      assertTrue(t2Start.time >= t1End.time, `Terminal 2 should start (${t2Start.time}ms) after Terminal 1 ends (${t1End.time}ms)`);
     });
-    
   } finally {
     if (tmpDir) {
       cleanupTestProject(tmpDir);