feat: Introduce modern E2E test suite for Task Master AI

tests/e2e/runners/parallel-runner.js

@@ -0,0 +1,211 @@
+import { Worker } from 'worker_threads';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { EventEmitter } from 'events';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export class ParallelTestRunner extends EventEmitter {
+  constructor(logger) {
+    super();
+    this.logger = logger;
+    this.workers = [];
+    this.results = {};
+  }
+
+  /**
+   * Run test groups in parallel
+   * @param {Object} testGroups - Groups of tests to run
+   * @param {Object} sharedContext - Shared context for all tests
+   * @returns {Promise<Object>} Combined results from all test groups
+   */
+  async runTestGroups(testGroups, sharedContext) {
+    const groupNames = Object.keys(testGroups);
+    const workerPromises = [];
+
+    this.logger.info(`Starting parallel execution of ${groupNames.length} test groups`);
+
+    for (const groupName of groupNames) {
+      const workerPromise = this.runTestGroup(groupName, testGroups[groupName], sharedContext);
+      workerPromises.push(workerPromise);
+    }
+
+    // Wait for all workers to complete
+    const results = await Promise.allSettled(workerPromises);
+
+    // Process results
+    const combinedResults = {
+      overall: 'passed',
+      groups: {},
+      summary: {
+        totalGroups: groupNames.length,
+        passedGroups: 0,
+        failedGroups: 0,
+        errors: []
+      }
+    };
+
+    results.forEach((result, index) => {
+      const groupName = groupNames[index];
+      
+      if (result.status === 'fulfilled') {
+        combinedResults.groups[groupName] = result.value;
+        if (result.value.status === 'passed') {
+          combinedResults.summary.passedGroups++;
+        } else {
+          combinedResults.summary.failedGroups++;
+          combinedResults.overall = 'failed';
+        }
+      } else {
+        combinedResults.groups[groupName] = {
+          status: 'failed',
+          error: result.reason.message || 'Unknown error'
+        };
+        combinedResults.summary.failedGroups++;
+        combinedResults.summary.errors.push({
+          group: groupName,
+          error: result.reason.message
+        });
+        combinedResults.overall = 'failed';
+      }
+    });
+
+    return combinedResults;
+  }
+
+  /**
+   * Run a single test group in a worker thread
+   */
+  async runTestGroup(groupName, testModules, sharedContext) {
+    return new Promise((resolve, reject) => {
+      const workerPath = join(__dirname, 'test-worker.js');
+      
+      const worker = new Worker(workerPath, {
+        workerData: {
+          groupName,
+          testModules,
+          sharedContext,
+          logDir: this.logger.logDir,
+          testRunId: this.logger.testRunId
+        }
+      });
+
+      this.workers.push(worker);
+
+      // Handle messages from worker
+      worker.on('message', (message) => {
+        if (message.type === 'log') {
+          const level = message.level.toLowerCase();
+          if (typeof this.logger[level] === 'function') {
+            this.logger[level](message.message);
+          } else {
+            // Fallback to info if the level doesn't exist
+            this.logger.info(message.message);
+          }
+        } else if (message.type === 'step') {
+          this.logger.step(message.message);
+        } else if (message.type === 'cost') {
+          this.logger.addCost(message.cost);
+        } else if (message.type === 'results') {
+          this.results[groupName] = message.results;
+        }
+      });
+
+      // Handle worker completion
+      worker.on('exit', (code) => {
+        this.workers = this.workers.filter(w => w !== worker);
+        
+        if (code === 0) {
+          resolve(this.results[groupName] || { status: 'passed', group: groupName });
+        } else {
+          reject(new Error(`Worker for group ${groupName} exited with code ${code}`));
+        }
+      });
+
+      // Handle worker errors
+      worker.on('error', (error) => {
+        this.workers = this.workers.filter(w => w !== worker);
+        reject(error);
+      });
+
+    });
+  }
+
+  /**
+   * Terminate all running workers
+   */
+  async terminate() {
+    const terminationPromises = this.workers.map(worker => 
+      worker.terminate().catch(err => 
+        this.logger.warning(`Failed to terminate worker: ${err.message}`)
+      )
+    );
+
+    await Promise.all(terminationPromises);
+    this.workers = [];
+  }
+}
+
+/**
+ * Sequential test runner for comparison or fallback
+ */
+export class SequentialTestRunner {
+  constructor(logger, helpers) {
+    this.logger = logger;
+    this.helpers = helpers;
+  }
+
+  /**
+   * Run tests sequentially
+   */
+  async runTests(testModules, context) {
+    const results = {
+      overall: 'passed',
+      tests: {},
+      summary: {
+        totalTests: testModules.length,
+        passedTests: 0,
+        failedTests: 0,
+        errors: []
+      }
+    };
+
+    for (const testModule of testModules) {
+      try {
+        this.logger.step(`Running ${testModule} tests`);
+        
+        // Dynamic import of test module
+        const testPath = join(dirname(__dirname), 'tests', `${testModule}.test.js`);
+        const { default: testFn } = await import(testPath);
+        
+        // Run the test
+        const testResults = await testFn(this.logger, this.helpers, context);
+        
+        results.tests[testModule] = testResults;
+        
+        if (testResults.status === 'passed') {
+          results.summary.passedTests++;
+        } else {
+          results.summary.failedTests++;
+          results.overall = 'failed';
+        }
+        
+      } catch (error) {
+        this.logger.error(`Failed to run ${testModule}: ${error.message}`);
+        results.tests[testModule] = {
+          status: 'failed',
+          error: error.message
+        };
+        results.summary.failedTests++;
+        results.summary.errors.push({
+          test: testModule,
+          error: error.message
+        });
+        results.overall = 'failed';
+      }
+    }
+
+    return results;
+  }
+}