bmad-fh 6.0.0-alpha.052779ef

package/test/test-scope-e2e.js

@@ -0,0 +1,439 @@
+/**
+ * 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
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+// ANSI color codes
+const colors = {
+  reset: '\u001B[0m',
+  green: '\u001B[32m',
+  red: '\u001B[31m',
+  yellow: '\u001B[33m',
+  blue: '\u001B[34m',
+  cyan: '\u001B[36m',
+  dim: '\u001B[2m',
+};
+
+// Test utilities
+let testCount = 0;
+let passCount = 0;
+let failCount = 0;
+const failures = [];
+
+function test(name, fn) {
+  testCount++;
+  try {
+    fn();
+    passCount++;
+    console.log(`  ${colors.green}✓${colors.reset} ${name}`);
+  } catch (error) {
+    failCount++;
+    console.log(`  ${colors.red}✗${colors.reset} ${name}`);
+    console.log(`    ${colors.red}${error.message}${colors.reset}`);
+    failures.push({ name, error: error.message });
+  }
+}
+
+async function asyncTest(name, fn) {
+  testCount++;
+  try {
+    await fn();
+    passCount++;
+    console.log(`  ${colors.green}✓${colors.reset} ${name}`);
+  } catch (error) {
+    failCount++;
+    console.log(`  ${colors.red}✗${colors.reset} ${name}`);
+    console.log(`    ${colors.red}${error.message}${colors.reset}`);
+    failures.push({ name, error: error.message });
+  }
+}
+
+function assertEqual(actual, expected, message = '') {
+  if (actual !== expected) {
+    throw new Error(`${message}\n    Expected: ${expected}\n    Actual: ${actual}`);
+  }
+}
+
+function assertTrue(value, message = 'Expected true') {
+  if (!value) {
+    throw new Error(message);
+  }
+}
+
+function assertFalse(value, message = 'Expected false') {
+  if (value) {
+    throw new Error(message);
+  }
+}
+
+function assertFileExists(filePath, message = '') {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`${message || 'File should exist'}: ${filePath}`);
+  }
+}
+
+function assertFileNotExists(filePath, message = '') {
+  if (fs.existsSync(filePath)) {
+    throw new Error(`${message || 'File should not exist'}: ${filePath}`);
+  }
+}
+
+function assertFileContains(filePath, content, message = '') {
+  const fileContent = fs.readFileSync(filePath, 'utf8');
+  if (!fileContent.includes(content)) {
+    throw new Error(`${message || 'File should contain'}: "${content}" in ${filePath}`);
+  }
+}
+
+// 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;
+}
+
+function cleanupTestProject(tmpDir) {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+}
+
+// ============================================================================
+// E2E Test: Complete Parallel Workflow Simulation
+// ============================================================================
+
+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)
+    // ========================================
+    await asyncTest('Create auth scope', async () => {
+      const scope = await manager.createScope('auth', {
+        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
+    // ========================================
+    await asyncTest('Simulate parallel PRD creation in auth scope', async () => {
+      // 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');
+
+      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
+    // ========================================
+    await asyncTest('ArtifactResolver allows cross-scope read', async () => {
+      const resolver = new ArtifactResolver({
+        currentScope: 'payments',
+        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',
+      );
+    });
+
+    await asyncTest('ArtifactResolver blocks cross-scope write', async () => {
+      const resolver = new ArtifactResolver({
+        currentScope: 'payments',
+        basePath: '_bmad-output',
+        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',
+      );
+    });
+
+    // ========================================
+    // 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',
+      );
+    });
+
+    // ========================================
+    // 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);
+    }
+  }
+}
+
+// ============================================================================
+// E2E Test: Concurrent Lock Simulation
+// ============================================================================
+
+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
+        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));
+      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
+        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)`);
+    });
+  } finally {
+    if (tmpDir) {
+      cleanupTestProject(tmpDir);
+    }
+  }
+}
+
+// ============================================================================
+// Main Runner
+// ============================================================================
+
+async function main() {
+  console.log(`${colors.cyan}╔═══════════════════════════════════════════════════════════╗${colors.reset}`);
+  console.log(`${colors.cyan}║  Multi-Scope End-to-End Test Suite                         ║${colors.reset}`);
+  console.log(`${colors.cyan}╚═══════════════════════════════════════════════════════════╝${colors.reset}`);
+
+  try {
+    await testParallelScopeWorkflow();
+    await testConcurrentLockSimulation();
+  } catch (error) {
+    console.log(`\n${colors.red}Fatal error: ${error.message}${colors.reset}`);
+    console.log(error.stack);
+    process.exit(1);
+  }
+
+  // Summary
+  console.log(`\n${colors.cyan}═══════════════════════════════════════════════════════════${colors.reset}`);
+  console.log(`${colors.cyan}E2E Test Results:${colors.reset}`);
+  console.log(`  Total:  ${testCount}`);
+  console.log(`  Passed: ${colors.green}${passCount}${colors.reset}`);
+  console.log(`  Failed: ${failCount === 0 ? colors.green : colors.red}${failCount}${colors.reset}`);
+  console.log(`${colors.cyan}═══════════════════════════════════════════════════════════${colors.reset}\n`);
+
+  if (failures.length > 0) {
+    console.log(`${colors.red}Failed Tests:${colors.reset}\n`);
+    for (const failure of failures) {
+      console.log(`${colors.red}✗${colors.reset} ${failure.name}`);
+      console.log(`  ${failure.error}\n`);
+    }
+    process.exit(1);
+  }
+
+  console.log(`${colors.green}All E2E tests passed!${colors.reset}\n`);
+  process.exit(0);
+}
+
+main().catch((error) => {
+  console.error(`${colors.red}Fatal error:${colors.reset}`, error);
+  process.exit(1);
+});