@bugzy-ai/bugzy 1.2.0

package/templates/playwright/dateUtils.helper.template.ts

@@ -0,0 +1,96 @@
+/**
+ * Date Utility Functions
+ * Generated by Bugzy - https://github.com/bugzy-ai/bugzy
+ *
+ * Helper functions for working with dates in tests
+ */
+
+/**
+ * Get today's date in YYYY-MM-DD format
+ */
+export function getTodayDate(): string {
+  const today = new Date();
+  return formatDate(today);
+}
+
+/**
+ * Get tomorrow's date in YYYY-MM-DD format
+ */
+export function getTomorrowDate(): string {
+  const tomorrow = new Date();
+  tomorrow.setDate(tomorrow.getDate() + 1);
+  return formatDate(tomorrow);
+}
+
+/**
+ * Get yesterday's date in YYYY-MM-DD format
+ */
+export function getYesterdayDate(): string {
+  const yesterday = new Date();
+  yesterday.setDate(yesterday.getDate() - 1);
+  return formatDate(yesterday);
+}
+
+/**
+ * Get date N days from now
+ * @param days - Number of days (positive for future, negative for past)
+ */
+export function getDateDaysFromNow(days: number): string {
+  const date = new Date();
+  date.setDate(date.getDate() + days);
+  return formatDate(date);
+}
+
+/**
+ * Format date as YYYY-MM-DD
+ * @param date - Date object to format
+ */
+export function formatDate(date: Date): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+/**
+ * Format date as MM/DD/YYYY
+ * @param date - Date object to format
+ */
+export function formatDateUS(date: Date): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${month}/${day}/${year}`;
+}
+
+/**
+ * Parse date string (YYYY-MM-DD) to Date object
+ * @param dateString - Date string in YYYY-MM-DD format
+ */
+export function parseDate(dateString: string): Date {
+  const [year, month, day] = dateString.split('-').map(Number);
+  return new Date(year, month - 1, day);
+}
+
+/**
+ * Get current timestamp in milliseconds
+ */
+export function getCurrentTimestamp(): number {
+  return Date.now();
+}
+
+/**
+ * Get current ISO timestamp string
+ */
+export function getCurrentISOTimestamp(): string {
+  return new Date().toISOString();
+}
+
+/**
+ * Wait for a specific amount of time (use sparingly!)
+ * Note: Prefer Playwright's built-in waiting mechanisms over this
+ * @param ms - Milliseconds to wait
+ */
+export async function wait(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/templates/playwright/pages.fixture.template.ts

@@ -0,0 +1,50 @@
+import { test as base } from '@playwright/test';
+
+/**
+ * Custom Fixtures for Page Objects
+ * Generated by Bugzy - https://github.com/bugzy-ai/bugzy
+ *
+ * Fixtures provide a way to set up and tear down test dependencies
+ * This example shows how to create fixtures for page objects
+ *
+ * Usage in tests:
+ * test('my test', async ({ homePage }) => {
+ *   await homePage.navigate();
+ *   // ...
+ * });
+ */
+
+// Define fixture types
+type PageFixtures = {
+  // Add your page object fixtures here
+  // Example:
+  // homePage: HomePage;
+  // loginPage: LoginPage;
+};
+
+/**
+ * Extend the base test with custom fixtures
+ *
+ * Example implementation:
+ *
+ * import { HomePage } from '@pages/HomePage';
+ * import { LoginPage } from '@pages/LoginPage';
+ *
+ * export const test = base.extend<PageFixtures>({
+ *   homePage: async ({ page }, use) => {
+ *     const homePage = new HomePage(page);
+ *     await use(homePage);
+ *   },
+ *
+ *   loginPage: async ({ page }, use) => {
+ *     const loginPage = new LoginPage(page);
+ *     await use(loginPage);
+ *   },
+ * });
+ */
+
+export const test = base.extend<PageFixtures>({
+  // Add your fixtures here
+});
+
+export { expect } from '@playwright/test';

package/templates/playwright/playwright.config.template.ts

@@ -0,0 +1,97 @@
+import { defineConfig, devices } from '@playwright/test';
+import * as dotenv from 'dotenv';
+import * as path from 'path';
+
+// Load non-secret environment variables from .env.testdata
+dotenv.config({ path: path.resolve(__dirname, '.env.testdata') });
+
+// Load secret environment variables from .env (for local development)
+dotenv.config({ path: path.resolve(__dirname, '.env') });
+
+/**
+ * Playwright Configuration
+ * Generated by Bugzy - https://github.com/bugzy-ai/bugzy
+ *
+ * This configuration follows Playwright best practices:
+ * - Parallel execution for speed
+ * - Retries in CI for stability
+ * - Trace capture for debugging
+ * - Optimized artifact collection
+ */
+
+export default defineConfig({
+  // Test directory
+  testDir: './tests/specs',
+
+  // Fully parallel test execution
+  fullyParallel: true,
+
+  // Fail the build on CI if you accidentally left test.only in the source code
+  forbidOnly: !!process.env.CI,
+
+  // Retry on CI only (2 retries), no retries locally
+  retries: process.env.CI ? 2 : 0,
+
+  // Opt out of parallel tests on CI for stability (can be adjusted)
+  workers: process.env.CI ? 2 : undefined,
+
+  // Reporters
+  reporter: [
+    ['./reporters/bugzy-reporter.ts']
+  ],
+
+  // Global timeout
+  timeout: 30000,
+
+  // Expect timeout
+  expect: {
+    timeout: 5000
+  },
+
+  // Shared settings for all projects
+  use: {
+    // Base URL from environment variable
+    baseURL: process.env.TEST_BASE_URL || 'http://localhost:3000',
+
+    // Collect trace on failure
+    trace: 'retain-on-failure',
+
+    // Screenshot only on failure
+    screenshot: 'only-on-failure',
+
+    // Video for all tests (always record)
+    video: 'on',
+
+    // Maximum time for actions (click, fill, etc.)
+    actionTimeout: 10000,
+  },
+
+  // Configure projects for different browsers
+  projects: [
+    // Setup project - runs once before other tests
+    {
+      name: 'setup',
+      testDir: './tests/setup',
+      testMatch: /.*\.setup\.ts/,
+    },
+
+    // Chromium
+    {
+      name: 'chromium',
+      use: {
+        ...devices['Desktop Chrome'],
+        // Use authenticated state if available
+        storageState: 'tests/.auth/user.json',
+      },
+      dependencies: ['setup'],
+    },
+  ],
+
+  // Run your local dev server before starting the tests
+  // Uncomment and configure if needed:
+  // webServer: {
+  //   command: 'npm run dev',
+  //   url: 'http://127.0.0.1:3000',
+  //   reuseExistingServer: !process.env.CI,
+  // },
+});

package/templates/playwright/reporters/bugzy-reporter.ts

@@ -0,0 +1,454 @@
+import type {
+  Reporter,
+  FullConfig,
+  Suite,
+  TestCase,
+  TestResult,
+  FullResult,
+  TestStep,
+} from '@playwright/test/reporter';
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Step data for steps.json
+ */
+interface StepData {
+  index: number;
+  timestamp: string;
+  videoTimeSeconds: number;
+  action: string;
+  status: 'success' | 'failed' | 'skipped';
+  description: string;
+  technicalDetails: string;
+  duration?: number;
+}
+
+/**
+ * Bugzy Custom Playwright Reporter
+ *
+ * Records test executions in hierarchical structure:
+ * test-runs/YYYYMMDD-HHMMSS/TC-{id}/exec-{num}/
+ *
+ * Features:
+ * - Groups multiple test runs under same directory when BUGZY_EXECUTION_ID matches
+ * - Checks latest directory's manifest to reuse existing session directory
+ * - Tracks multiple execution attempts per test
+ * - Records videos for all tests
+ * - Captures traces/screenshots for failures only
+ * - Links to BUGZY_EXECUTION_ID for session tracking
+ * - Generates manifest.json with execution summary
+ * - Generates steps.json with video timestamps for test.step() calls
+ */
+class BugzyReporter implements Reporter {
+  private testRunDir!: string;
+  private timestamp!: string;
+  private bugzyExecutionId!: string;
+  private startTime!: Date;
+  private testResults: Map<string, Array<any>> = new Map();
+  private testSteps: Map<string, Array<StepData>> = new Map();
+  private testStartTimes: Map<string, number> = new Map();
+
+  constructor() {
+    // No longer need to read execution number from environment
+    // It will be auto-detected per test case
+  }
+
+  /**
+   * Called once before running tests
+   */
+  onBegin(config: FullConfig, suite: Suite): void {
+    this.startTime = new Date();
+
+    // Generate timestamp in YYYYMMDD-HHMMSS format
+    this.timestamp = this.startTime
+      .toISOString()
+      .replace(/[-:]/g, '')
+      .replace(/T/, '-')
+      .slice(0, 15);
+
+    const testRunsRoot = path.join(process.cwd(), 'test-runs');
+
+    // Check if we should reuse an existing session
+    let reuseDir: string | null = null;
+
+    // If BUGZY_EXECUTION_ID is provided, use it directly
+    if (process.env.BUGZY_EXECUTION_ID) {
+      this.bugzyExecutionId = process.env.BUGZY_EXECUTION_ID;
+    } else {
+      // For local runs, check if we can reuse the latest session
+      // Reuse if the latest manifest is within 60 minutes
+      if (fs.existsSync(testRunsRoot)) {
+        const dirs = fs.readdirSync(testRunsRoot)
+          .filter(d => fs.statSync(path.join(testRunsRoot, d)).isDirectory())
+          .sort()
+          .reverse(); // Sort descending (latest first)
+
+        if (dirs.length > 0) {
+          const latestDir = dirs[0];
+          const manifestPath = path.join(testRunsRoot, latestDir, 'manifest.json');
+
+          if (fs.existsSync(manifestPath)) {
+            try {
+              const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+              const manifestTime = new Date(manifest.startTime).getTime();
+              const currentTime = this.startTime.getTime();
+              const minutesDiff = (currentTime - manifestTime) / (1000 * 60);
+
+              // Reuse if within 60 minutes and has a local execution ID
+              if (minutesDiff <= 60 && manifest.bugzyExecutionId?.startsWith('local-')) {
+                this.bugzyExecutionId = manifest.bugzyExecutionId;
+                reuseDir = latestDir;
+              }
+            } catch (err) {
+              // Ignore parsing errors
+            }
+          }
+        }
+      }
+
+      // If no session to reuse, generate new local ID
+      if (!this.bugzyExecutionId) {
+        this.bugzyExecutionId = 'local-' + this.timestamp;
+      }
+    }
+
+    // If we have a specific execution ID but haven't found a reuse dir yet, check for matching session
+    if (!reuseDir && fs.existsSync(testRunsRoot)) {
+      const dirs = fs.readdirSync(testRunsRoot)
+        .filter(d => fs.statSync(path.join(testRunsRoot, d)).isDirectory())
+        .sort()
+        .reverse();
+
+      for (const dir of dirs) {
+        const manifestPath = path.join(testRunsRoot, dir, 'manifest.json');
+        if (fs.existsSync(manifestPath)) {
+          try {
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+            if (manifest.bugzyExecutionId === this.bugzyExecutionId) {
+              reuseDir = dir;
+              break;
+            }
+          } catch (err) {
+            // Ignore parsing errors
+          }
+        }
+      }
+    }
+
+    if (reuseDir) {
+      this.testRunDir = path.join(testRunsRoot, reuseDir);
+      console.log(`\n🔄 Continuing test run: ${reuseDir}`);
+      console.log(`📋 Execution ID: ${this.bugzyExecutionId}`);
+      console.log(`📁 Output directory: ${this.testRunDir}\n`);
+    } else {
+      this.testRunDir = path.join(testRunsRoot, this.timestamp);
+      fs.mkdirSync(this.testRunDir, { recursive: true });
+      console.log(`\n🆕 New test run: ${this.timestamp}`);
+      console.log(`📋 Execution ID: ${this.bugzyExecutionId}`);
+      console.log(`📁 Output directory: ${this.testRunDir}\n`);
+    }
+  }
+
+  /**
+   * Called after each test completes
+   */
+  onTestEnd(test: TestCase, result: TestResult): void {
+    // Extract test ID from test title or file path
+    const testId = this.extractTestId(test);
+
+    // Create test case directory
+    const testCaseDir = path.join(this.testRunDir, testId);
+    fs.mkdirSync(testCaseDir, { recursive: true });
+
+    // Auto-detect execution number from existing folders
+    let executionNum = 1;
+    if (fs.existsSync(testCaseDir)) {
+      const existingExecs = fs.readdirSync(testCaseDir)
+        .filter(d => d.startsWith('exec-') && fs.statSync(path.join(testCaseDir, d)).isDirectory())
+        .map(d => parseInt(d.replace('exec-', ''), 10))
+        .filter(n => !isNaN(n));
+
+      if (existingExecs.length > 0) {
+        executionNum = Math.max(...existingExecs) + 1;
+      }
+    }
+
+    // Create execution directory
+    const execDir = path.join(testCaseDir, `exec-${executionNum}`);
+    fs.mkdirSync(execDir, { recursive: true });
+
+    // Prepare result data in Playwright format
+    const resultData = {
+      status: result.status,
+      duration: result.duration,
+      errors: result.errors,
+      retry: result.retry,
+      startTime: result.startTime.toISOString(),
+      attachments: [] as Array<{ name: string; path: string; contentType: string }>,
+    };
+
+    // Handle attachments (videos, traces, screenshots)
+    let hasVideo = false;
+    let hasTrace = false;
+    let hasScreenshots = false;
+
+    for (const attachment of result.attachments) {
+      if (attachment.name === 'video' && attachment.path) {
+        // Copy video file to execution directory
+        const videoFileName = 'video.webm';
+        const videoDestPath = path.join(execDir, videoFileName);
+
+        try {
+          fs.copyFileSync(attachment.path, videoDestPath);
+          resultData.attachments.push({
+            name: 'video',
+            path: videoFileName,
+            contentType: attachment.contentType || 'video/webm',
+          });
+          hasVideo = true;
+        } catch (err) {
+          console.error(`Failed to copy video: ${err}`);
+        }
+      } else if (attachment.name === 'trace' && attachment.path) {
+        // Copy trace file to execution directory (only for failures)
+        if (result.status === 'failed' || result.status === 'timedOut') {
+          const traceFileName = 'trace.zip';
+          const traceDestPath = path.join(execDir, traceFileName);
+
+          try {
+            fs.copyFileSync(attachment.path, traceDestPath);
+            resultData.attachments.push({
+              name: 'trace',
+              path: traceFileName,
+              contentType: attachment.contentType || 'application/zip',
+            });
+            hasTrace = true;
+          } catch (err) {
+            console.error(`Failed to copy trace: ${err}`);
+          }
+        }
+      } else if (attachment.name === 'screenshot' && attachment.path) {
+        // Copy screenshots to execution directory (only for failures)
+        if (result.status === 'failed' || result.status === 'timedOut') {
+          const screenshotsDir = path.join(execDir, 'screenshots');
+          fs.mkdirSync(screenshotsDir, { recursive: true });
+
+          const screenshotFileName = path.basename(attachment.path);
+          const screenshotDestPath = path.join(screenshotsDir, screenshotFileName);
+
+          try {
+            fs.copyFileSync(attachment.path, screenshotDestPath);
+            resultData.attachments.push({
+              name: 'screenshot',
+              path: path.join('screenshots', screenshotFileName),
+              contentType: attachment.contentType || 'image/png',
+            });
+            hasScreenshots = true;
+          } catch (err) {
+            console.error(`Failed to copy screenshot: ${err}`);
+          }
+        }
+      }
+    }
+
+    // Write result.json
+    const resultPath = path.join(execDir, 'result.json');
+    fs.writeFileSync(resultPath, JSON.stringify(resultData, null, 2));
+
+    // Store execution info for manifest
+    if (!this.testResults.has(testId)) {
+      this.testResults.set(testId, []);
+    }
+
+    this.testResults.get(testId)!.push({
+      number: executionNum,
+      status: result.status,
+      duration: result.duration,
+      videoFile: hasVideo ? 'video.webm' : null,
+      hasTrace,
+      hasScreenshots,
+      error: result.errors.length > 0 ? result.errors[0].message : null,
+    });
+
+    // Generate steps.json if test has steps
+    const testKey = this.getTestKey(test);
+    const steps = this.testSteps.get(testKey);
+    if (steps && steps.length > 0) {
+      const stepsData = {
+        steps,
+        summary: {
+          totalSteps: steps.length,
+          successfulSteps: steps.filter(s => s.status === 'success').length,
+          failedSteps: steps.filter(s => s.status === 'failed').length,
+          skippedSteps: steps.filter(s => s.status === 'skipped').length,
+        },
+      };
+
+      const stepsPath = path.join(execDir, 'steps.json');
+      fs.writeFileSync(stepsPath, JSON.stringify(stepsData, null, 2));
+    }
+
+    // Log execution result
+    const statusIcon = result.status === 'passed' ? '✅' : result.status === 'failed' ? '❌' : '⚠️';
+    console.log(`${statusIcon} ${testId} [exec-${executionNum}] - ${result.status} (${result.duration}ms)`);
+  }
+
+  /**
+   * Called when a test step begins
+   */
+  onStepBegin(test: TestCase, _result: TestResult, step: TestStep): void {
+    // Only track test.step() calls (not hooks, fixtures, or expects)
+    if (step.category !== 'test.step') {
+      return;
+    }
+
+    const testKey = this.getTestKey(test);
+
+    // Record test start time on first step
+    if (!this.testStartTimes.has(testKey)) {
+      this.testStartTimes.set(testKey, step.startTime.getTime());
+    }
+
+    // Initialize steps array for this test
+    if (!this.testSteps.has(testKey)) {
+      this.testSteps.set(testKey, []);
+    }
+
+    const steps = this.testSteps.get(testKey)!;
+    const testStartTime = this.testStartTimes.get(testKey)!;
+    const videoTimeSeconds = Math.floor((step.startTime.getTime() - testStartTime) / 1000);
+
+    steps.push({
+      index: steps.length + 1,
+      timestamp: step.startTime.toISOString(),
+      videoTimeSeconds,
+      action: step.title,
+      status: 'success', // Will be updated in onStepEnd if it fails
+      description: `${step.title} - in progress`,
+      technicalDetails: 'test.step',
+    });
+  }
+
+  /**
+   * Called when a test step ends
+   */
+  onStepEnd(test: TestCase, _result: TestResult, step: TestStep): void {
+    // Only track test.step() calls
+    if (step.category !== 'test.step') {
+      return;
+    }
+
+    const testKey = this.getTestKey(test);
+    const steps = this.testSteps.get(testKey);
+
+    if (!steps || steps.length === 0) {
+      return;
+    }
+
+    // Update the last step with final status and duration
+    const lastStep = steps[steps.length - 1];
+    lastStep.duration = step.duration;
+
+    if (step.error) {
+      lastStep.status = 'failed';
+      lastStep.description = `${step.title} - failed: ${step.error.message}`;
+    } else {
+      lastStep.status = 'success';
+      lastStep.description = `${step.title} - completed successfully`;
+    }
+  }
+
+  /**
+   * Called after all tests complete
+   */
+  onEnd(result: FullResult): void {
+    const endTime = new Date();
+
+    // Calculate statistics
+    let totalTests = 0;
+    let totalExecutions = 0;
+    let passedTests = 0;
+    let failedTests = 0;
+
+    const testCases: Array<any> = [];
+
+    for (const [testId, executions] of this.testResults.entries()) {
+      totalTests++;
+      totalExecutions += executions.length;
+
+      const finalStatus = executions[executions.length - 1].status;
+      if (finalStatus === 'passed') {
+        passedTests++;
+      } else {
+        failedTests++;
+      }
+
+      testCases.push({
+        id: testId,
+        name: testId.replace(/^TC-\d+-/, '').replace(/-/g, ' '),
+        totalExecutions: executions.length,
+        finalStatus,
+        executions,
+      });
+    }
+
+    // Generate manifest.json
+    const manifest = {
+      bugzyExecutionId: this.bugzyExecutionId,
+      timestamp: this.timestamp,
+      startTime: this.startTime.toISOString(),
+      endTime: endTime.toISOString(),
+      status: result.status,
+      stats: {
+        totalTests,
+        passed: passedTests,
+        failed: failedTests,
+        totalExecutions,
+      },
+      testCases,
+    };
+
+    const manifestPath = path.join(this.testRunDir, 'manifest.json');
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+    console.log(`\n📊 Test Run Summary:`);
+    console.log(`   Total tests: ${totalTests}`);
+    console.log(`   Passed: ${passedTests}`);
+    console.log(`   Failed: ${failedTests}`);
+    console.log(`   Total executions: ${totalExecutions}`);
+    console.log(`   Manifest: ${manifestPath}\n`);
+  }
+
+  /**
+   * Extract test ID from test case
+   * Generates TC-XXX-{test-name} format
+   */
+  private extractTestId(test: TestCase): string {
+    // Try to extract from test title
+    const title = test.title.toLowerCase().replace(/\s+/g, '-');
+
+    // Get test file name without extension
+    const fileName = path.basename(test.location.file, path.extname(test.location.file));
+
+    // Extract number from filename if it follows TC-XXX pattern
+    const tcMatch = fileName.match(/TC-(\d+)/i);
+    if (tcMatch) {
+      return `TC-${tcMatch[1]}-${title}`;
+    }
+
+    // Otherwise generate from index
+    // This is a simple fallback - you may want to improve this
+    const testIndex = String(test.parent.tests.indexOf(test) + 1).padStart(3, '0');
+    return `TC-${testIndex}-${title}`;
+  }
+
+  /**
+   * Generate unique key for test to track steps across retries
+   */
+  private getTestKey(test: TestCase): string {
+    return `${test.location.file}::${test.title}`;
+  }
+}
+
+export default BugzyReporter;