@rakeyshgidwani/roger-ui-bank-theme-stan-design 0.1.6 → 0.1.7

package/src/testing/test-automation.ts

@@ -0,0 +1,627 @@
+/**
+ * Test Automation Scripts
+ * Automated testing utilities and scripts for running comprehensive test suites
+ */
+
+import { spawn, exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs';
+import path from 'path';
+
+const execAsync = promisify(exec);
+
+export interface TestConfig {
+  testTypes: string[];
+  browsers?: string[];
+  themes?: string[];
+  viewports?: string[];
+  coverage?: boolean;
+  parallel?: boolean;
+  timeout?: number;
+}
+
+export interface TestResult {
+  testType: string;
+  passed: number;
+  failed: number;
+  skipped: number;
+  duration: number;
+  coverage?: number;
+}
+
+export interface TestReport {
+  timestamp: string;
+  totalTests: number;
+  totalPassed: number;
+  totalFailed: number;
+  totalSkipped: number;
+  totalDuration: number;
+  results: TestResult[];
+  coverageReport?: any;
+}
+
+/**
+ * Main test automation class
+ */
+export class TestAutomation {
+  private config: TestConfig;
+  private results: TestResult[] = [];
+
+  constructor(config: TestConfig) {
+    this.config = {
+      timeout: 30000,
+      parallel: true,
+      coverage: true,
+      ...config,
+    };
+  }
+
+  /**
+   * Run all configured tests
+   */
+  async runAllTests(): Promise<TestReport> {
+    console.log('🚀 Starting comprehensive test suite...');
+    const startTime = Date.now();
+
+    try {
+      // Run tests based on configuration
+      if (this.config.testTypes.includes('unit')) {
+        await this.runUnitTests();
+      }
+
+      if (this.config.testTypes.includes('visual-regression')) {
+        await this.runVisualRegressionTests();
+      }
+
+      if (this.config.testTypes.includes('theme-switching')) {
+        await this.runThemeSwitchingTests();
+      }
+
+      if (this.config.testTypes.includes('state-testing')) {
+        await this.runStateTests();
+      }
+
+      if (this.config.testTypes.includes('responsive')) {
+        await this.runResponsiveTests();
+      }
+
+      if (this.config.testTypes.includes('cross-browser')) {
+        await this.runCrossBrowserTests();
+      }
+
+      if (this.config.testTypes.includes('accessibility')) {
+        await this.runAccessibilityTests();
+      }
+
+      if (this.config.testTypes.includes('performance')) {
+        await this.runPerformanceTests();
+      }
+
+      if (this.config.testTypes.includes('e2e')) {
+        await this.runE2ETests();
+      }
+
+      const endTime = Date.now();
+      const totalDuration = endTime - startTime;
+
+      const report = this.generateReport(totalDuration);
+      await this.saveReport(report);
+
+      console.log('✅ Test suite completed successfully!');
+      this.printSummary(report);
+
+      return report;
+    } catch (error) {
+      console.error('❌ Test suite failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Run unit tests
+   */
+  private async runUnitTests(): Promise<void> {
+    console.log('🧪 Running unit tests...');
+    const startTime = Date.now();
+
+    try {
+      const command = this.config.coverage
+        ? 'npm run test:coverage'
+        : 'npm test';
+
+      const { stdout } = await execAsync(command, {
+        timeout: this.config.timeout,
+      });
+
+      const result = this.parseJestOutput(stdout);
+      result.testType = 'unit';
+      result.duration = Date.now() - startTime;
+
+      this.results.push(result);
+      console.log(`✅ Unit tests completed: ${result.passed} passed, ${result.failed} failed`);
+    } catch (error) {
+      console.error('❌ Unit tests failed:', error);
+      this.results.push({
+        testType: 'unit',
+        passed: 0,
+        failed: 1,
+        skipped: 0,
+        duration: Date.now() - startTime,
+      });
+    }
+  }
+
+  /**
+   * Run visual regression tests
+   */
+  private async runVisualRegressionTests(): Promise<void> {
+    console.log('📸 Running visual regression tests...');
+    const startTime = Date.now();
+
+    try {
+      const command = 'npm test -- --testPathPatterns=visual-regression';
+      const { stdout } = await execAsync(command, {
+        timeout: this.config.timeout,
+      });
+
+      const result = this.parseJestOutput(stdout);
+      result.testType = 'visual-regression';
+      result.duration = Date.now() - startTime;
+
+      this.results.push(result);
+      console.log(`✅ Visual regression tests completed: ${result.passed} passed, ${result.failed} failed`);
+    } catch (error) {
+      console.error('❌ Visual regression tests failed:', error);
+      this.results.push({
+        testType: 'visual-regression',
+        passed: 0,
+        failed: 1,
+        skipped: 0,
+        duration: Date.now() - startTime,
+      });
+    }
+  }
+
+  /**
+   * Run theme switching tests
+   */
+  private async runThemeSwitchingTests(): Promise<void> {
+    console.log('🎨 Running theme switching tests...');
+    const startTime = Date.now();
+
+    try {
+      const command = 'npm test -- --testPathPatterns=theme-switching';
+      const { stdout } = await execAsync(command, {
+        timeout: this.config.timeout,
+      });
+
+      const result = this.parseJestOutput(stdout);
+      result.testType = 'theme-switching';
+      result.duration = Date.now() - startTime;
+
+      this.results.push(result);
+      console.log(`✅ Theme switching tests completed: ${result.passed} passed, ${result.failed} failed`);
+    } catch (error) {
+      console.error('❌ Theme switching tests failed:', error);
+      this.results.push({
+        testType: 'theme-switching',
+        passed: 0,
+        failed: 1,
+        skipped: 0,
+        duration: Date.now() - startTime,
+      });
+    }
+  }
+
+  /**
+   * Run state tests
+   */
+  private async runStateTests(): Promise<void> {
+    console.log('🔄 Running state tests...');
+    const startTime = Date.now();
+
+    try {
+      const command = 'npm test -- --testPathPatterns=state-testing';
+      const { stdout } = await execAsync(command, {
+        timeout: this.config.timeout,
+      });
+
+      const result = this.parseJestOutput(stdout);
+      result.testType = 'state-testing';
+      result.duration = Date.now() - startTime;
+
+      this.results.push(result);
+      console.log(`✅ State tests completed: ${result.passed} passed, ${result.failed} failed`);
+    } catch (error) {
+      console.error('❌ State tests failed:', error);
+      this.results.push({
+        testType: 'state-testing',
+        passed: 0,
+        failed: 1,
+        skipped: 0,
+        duration: Date.now() - startTime,
+      });
+    }
+  }
+
+  /**
+   * Run responsive tests
+   */
+  private async runResponsiveTests(): Promise<void> {
+    console.log('📱 Running responsive tests...');
+    const startTime = Date.now();
+
+    try {
+      const command = 'npm test -- --testPathPatterns=responsive-testing';
+      const { stdout } = await execAsync(command, {
+        timeout: this.config.timeout,
+      });
+
+      const result = this.parseJestOutput(stdout);
+      result.testType = 'responsive';
+      result.duration = Date.now() - startTime;
+
+      this.results.push(result);
+      console.log(`✅ Responsive tests completed: ${result.passed} passed, ${result.failed} failed`);
+    } catch (error) {
+      console.error('❌ Responsive tests failed:', error);
+      this.results.push({
+        testType: 'responsive',
+        passed: 0,
+        failed: 1,
+        skipped: 0,
+        duration: Date.now() - startTime,
+      });
+    }
+  }
+
+  /**
+   * Run cross-browser tests
+   */
+  private async runCrossBrowserTests(): Promise<void> {
+    console.log('🌐 Running cross-browser tests...');
+    const startTime = Date.now();
+
+    try {
+      const command = 'npm test -- --testPathPatterns=cross-browser';
+      const { stdout } = await execAsync(command, {
+        timeout: this.config.timeout,
+      });
+
+      const result = this.parseJestOutput(stdout);
+      result.testType = 'cross-browser';
+      result.duration = Date.now() - startTime;
+
+      this.results.push(result);
+      console.log(`✅ Cross-browser tests completed: ${result.passed} passed, ${result.failed} failed`);
+    } catch (error) {
+      console.error('❌ Cross-browser tests failed:', error);
+      this.results.push({
+        testType: 'cross-browser',
+        passed: 0,
+        failed: 1,
+        skipped: 0,
+        duration: Date.now() - startTime,
+      });
+    }
+  }
+
+  /**
+   * Run accessibility tests
+   */
+  private async runAccessibilityTests(): Promise<void> {
+    console.log('♿ Running accessibility tests...');
+    const startTime = Date.now();
+
+    try {
+      const command = 'npm test -- --testPathPatterns=accessibility';
+      const { stdout } = await execAsync(command, {
+        timeout: this.config.timeout,
+      });
+
+      const result = this.parseJestOutput(stdout);
+      result.testType = 'accessibility';
+      result.duration = Date.now() - startTime;
+
+      this.results.push(result);
+      console.log(`✅ Accessibility tests completed: ${result.passed} passed, ${result.failed} failed`);
+    } catch (error) {
+      console.error('❌ Accessibility tests failed:', error);
+      this.results.push({
+        testType: 'accessibility',
+        passed: 0,
+        failed: 1,
+        skipped: 0,
+        duration: Date.now() - startTime,
+      });
+    }
+  }
+
+  /**
+   * Run performance tests
+   */
+  private async runPerformanceTests(): Promise<void> {
+    console.log('⚡ Running performance tests...');
+    const startTime = Date.now();
+
+    try {
+      const command = 'npm test -- --testPathPatterns=performance';
+      const { stdout } = await execAsync(command, {
+        timeout: this.config.timeout,
+      });
+
+      const result = this.parseJestOutput(stdout);
+      result.testType = 'performance';
+      result.duration = Date.now() - startTime;
+
+      this.results.push(result);
+      console.log(`✅ Performance tests completed: ${result.passed} passed, ${result.failed} failed`);
+    } catch (error) {
+      console.error('❌ Performance tests failed:', error);
+      this.results.push({
+        testType: 'performance',
+        passed: 0,
+        failed: 1,
+        skipped: 0,
+        duration: Date.now() - startTime,
+      });
+    }
+  }
+
+  /**
+   * Run E2E tests (placeholder for future implementation)
+   */
+  private async runE2ETests(): Promise<void> {
+    console.log('🎭 Running E2E tests...');
+    const startTime = Date.now();
+
+    try {
+      // Placeholder for E2E tests (Playwright, Cypress, etc.)
+      console.log('ℹ️  E2E tests not yet configured - skipping');
+
+      this.results.push({
+        testType: 'e2e',
+        passed: 0,
+        failed: 0,
+        skipped: 1,
+        duration: Date.now() - startTime,
+      });
+    } catch (error) {
+      console.error('❌ E2E tests failed:', error);
+      this.results.push({
+        testType: 'e2e',
+        passed: 0,
+        failed: 1,
+        skipped: 0,
+        duration: Date.now() - startTime,
+      });
+    }
+  }
+
+  /**
+   * Parse Jest output to extract test results
+   */
+  private parseJestOutput(output: string): TestResult {
+    const result: TestResult = {
+      testType: '',
+      passed: 0,
+      failed: 0,
+      skipped: 0,
+      duration: 0,
+    };
+
+    // Parse Jest output for test counts
+    const passedMatch = output.match(/(\d+) passed/);
+    const failedMatch = output.match(/(\d+) failed/);
+    const skippedMatch = output.match(/(\d+) skipped/);
+
+    if (passedMatch) result.passed = parseInt(passedMatch[1], 10);
+    if (failedMatch) result.failed = parseInt(failedMatch[1], 10);
+    if (skippedMatch) result.skipped = parseInt(skippedMatch[1], 10);
+
+    return result;
+  }
+
+  /**
+   * Generate comprehensive test report
+   */
+  private generateReport(totalDuration: number): TestReport {
+    const totalPassed = this.results.reduce((sum, r) => sum + r.passed, 0);
+    const totalFailed = this.results.reduce((sum, r) => sum + r.failed, 0);
+    const totalSkipped = this.results.reduce((sum, r) => sum + r.skipped, 0);
+    const totalTests = totalPassed + totalFailed + totalSkipped;
+
+    return {
+      timestamp: new Date().toISOString(),
+      totalTests,
+      totalPassed,
+      totalFailed,
+      totalSkipped,
+      totalDuration,
+      results: this.results,
+    };
+  }
+
+  /**
+   * Save test report to file
+   */
+  private async saveReport(report: TestReport): Promise<void> {
+    const reportsDir = path.join(process.cwd(), 'test-reports');
+
+    if (!fs.existsSync(reportsDir)) {
+      fs.mkdirSync(reportsDir, { recursive: true });
+    }
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const reportPath = path.join(reportsDir, `test-report-${timestamp}.json`);
+
+    fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+    console.log(`📄 Test report saved to: ${reportPath}`);
+  }
+
+  /**
+   * Print test summary to console
+   */
+  private printSummary(report: TestReport): void {
+    console.log('\n📊 Test Summary:');
+    console.log('================');
+    console.log(`Total Tests: ${report.totalTests}`);
+    console.log(`✅ Passed: ${report.totalPassed}`);
+    console.log(`❌ Failed: ${report.totalFailed}`);
+    console.log(`⏭️  Skipped: ${report.totalSkipped}`);
+    console.log(`⏱️  Duration: ${(report.totalDuration / 1000).toFixed(2)}s`);
+    console.log(`📈 Success Rate: ${((report.totalPassed / (report.totalPassed + report.totalFailed)) * 100).toFixed(1)}%`);
+
+    console.log('\n📝 Test Type Results:');
+    console.log('=====================');
+    report.results.forEach((result) => {
+      const icon = result.failed > 0 ? '❌' : result.passed > 0 ? '✅' : '⏭️';
+      console.log(`${icon} ${result.testType}: ${result.passed} passed, ${result.failed} failed, ${result.skipped} skipped (${(result.duration / 1000).toFixed(2)}s)`);
+    });
+  }
+}
+
+/**
+ * Predefined test configurations
+ */
+export const testConfigurations = {
+  quick: {
+    testTypes: ['unit', 'visual-regression'],
+    parallel: true,
+    timeout: 30000,
+  },
+  comprehensive: {
+    testTypes: [
+      'unit',
+      'visual-regression',
+      'theme-switching',
+      'state-testing',
+      'responsive',
+      'cross-browser',
+      'accessibility',
+      'performance',
+    ],
+    parallel: true,
+    coverage: true,
+    timeout: 60000,
+  },
+  ci: {
+    testTypes: [
+      'unit',
+      'visual-regression',
+      'theme-switching',
+      'state-testing',
+      'responsive',
+      'accessibility',
+    ],
+    parallel: true,
+    coverage: true,
+    timeout: 45000,
+  },
+  accessibility: {
+    testTypes: ['accessibility'],
+    timeout: 30000,
+  },
+  performance: {
+    testTypes: ['performance'],
+    timeout: 45000,
+  },
+};
+
+/**
+ * CLI utility functions
+ */
+export class TestCLI {
+  static async runConfiguration(configName: keyof typeof testConfigurations): Promise<void> {
+    const config = testConfigurations[configName];
+    if (!config) {
+      throw new Error(`Unknown configuration: ${configName}`);
+    }
+
+    const automation = new TestAutomation(config);
+    await automation.runAllTests();
+  }
+
+  static async runCustom(customConfig: TestConfig): Promise<void> {
+    const automation = new TestAutomation(customConfig);
+    await automation.runAllTests();
+  }
+
+  static listConfigurations(): void {
+    console.log('Available test configurations:');
+    console.log('==============================');
+    Object.keys(testConfigurations).forEach((name) => {
+      const config = testConfigurations[name as keyof typeof testConfigurations];
+      console.log(`• ${name}: ${config.testTypes.join(', ')}`);
+    });
+  }
+}
+
+/**
+ * Utility functions for individual test operations
+ */
+export const testUtils = {
+  /**
+   * Run tests with coverage
+   */
+  async runWithCoverage(): Promise<void> {
+    console.log('📊 Running tests with coverage...');
+    try {
+      await execAsync('npm run test:coverage');
+      console.log('✅ Coverage report generated');
+    } catch (error) {
+      console.error('❌ Coverage test failed:', error);
+      throw error;
+    }
+  },
+
+  /**
+   * Update visual regression snapshots
+   */
+  async updateSnapshots(): Promise<void> {
+    console.log('📸 Updating visual regression snapshots...');
+    try {
+      await execAsync('npm test -- --updateSnapshot');
+      console.log('✅ Snapshots updated');
+    } catch (error) {
+      console.error('❌ Snapshot update failed:', error);
+      throw error;
+    }
+  },
+
+  /**
+   * Run tests in watch mode
+   */
+  async runInWatchMode(): Promise<void> {
+    console.log('👀 Starting tests in watch mode...');
+    try {
+      const child = spawn('npm', ['test', '--', '--watch'], {
+        stdio: 'inherit',
+      });
+
+      child.on('close', (code) => {
+        console.log(`Watch mode exited with code ${code}`);
+      });
+    } catch (error) {
+      console.error('❌ Watch mode failed:', error);
+      throw error;
+    }
+  },
+
+  /**
+   * Clean test artifacts
+   */
+  async cleanTestArtifacts(): Promise<void> {
+    console.log('🧹 Cleaning test artifacts...');
+    try {
+      await execAsync('rm -rf coverage test-reports __snapshots__');
+      console.log('✅ Test artifacts cleaned');
+    } catch (error) {
+      console.error('❌ Cleanup failed:', error);
+      throw error;
+    }
+  },
+};
+
+// Export main automation class as default
+export default TestAutomation;