@fragments-sdk/cli 0.2.2

package/src/test/reporters/json.ts

@@ -0,0 +1,190 @@
+/**
+ * JSON reporter - machine-readable output
+ *
+ * Outputs structured JSON for:
+ * - AI analysis and processing
+ * - Custom dashboards
+ * - Integration with other tools
+ */
+
+import { writeFile, mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import type { TestRunResult, TestReporter } from '../types.js';
+
+export interface JsonReporterOptions {
+  /** Output file path */
+  outputPath: string;
+  /** Pretty print the JSON */
+  pretty?: boolean;
+  /** Include full step details */
+  includeSteps?: boolean;
+  /** Include stack traces in errors */
+  includeStacks?: boolean;
+}
+
+/**
+ * JSON report structure
+ */
+export interface JsonReport {
+  /** Report metadata */
+  meta: {
+    /** Report version */
+    version: string;
+    /** Test run start time */
+    startTime: string;
+    /** Test run end time */
+    endTime: string;
+    /** Total duration in milliseconds */
+    duration: number;
+  };
+  /** Summary statistics */
+  summary: {
+    total: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    passRate: number;
+    a11yViolations?: number;
+  };
+  /** Test suites with results */
+  suites: Array<{
+    name: string;
+    tests: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    duration: number;
+    results: Array<{
+      id: string;
+      component: string;
+      variant: string;
+      status: 'passed' | 'failed' | 'skipped';
+      duration: number;
+      steps?: Array<{
+        name: string;
+        status: 'passed' | 'failed' | 'skipped';
+        duration: number;
+        error?: string;
+      }>;
+      error?: {
+        message: string;
+        stack?: string;
+      };
+      accessibility?: {
+        violations: number;
+        passes: number;
+        details?: Array<{
+          id: string;
+          impact: string;
+          description: string;
+          elements: number;
+        }>;
+      };
+      retryAttempt?: number;
+    }>;
+  }>;
+}
+
+/**
+ * Create a JSON reporter
+ */
+export function createJsonReporter(options: JsonReporterOptions): TestReporter {
+  const { outputPath, pretty = true, includeSteps = true, includeStacks = false } = options;
+
+  return {
+    async onRunComplete(result: TestRunResult) {
+      const report = generateJsonReport(result, includeSteps, includeStacks);
+
+      // Ensure output directory exists
+      await mkdir(dirname(outputPath), { recursive: true });
+
+      // Write the JSON file
+      const json = pretty ? JSON.stringify(report, null, 2) : JSON.stringify(report);
+      await writeFile(outputPath, json, 'utf-8');
+    },
+  };
+}
+
+/**
+ * Generate JSON report from test results
+ */
+function generateJsonReport(
+  result: TestRunResult,
+  includeSteps: boolean,
+  includeStacks: boolean
+): JsonReport {
+  const { suites, totalTests, totalPassed, totalFailed, totalSkipped, totalDuration, startTime, endTime } = result;
+
+  return {
+    meta: {
+      version: '1.0.0',
+      startTime: startTime.toISOString(),
+      endTime: endTime.toISOString(),
+      duration: totalDuration,
+    },
+    summary: {
+      total: totalTests,
+      passed: totalPassed,
+      failed: totalFailed,
+      skipped: totalSkipped,
+      passRate: totalTests > 0 ? Math.round((totalPassed / totalTests) * 100) : 0,
+      a11yViolations: result.totalA11yViolations,
+    },
+    suites: suites.map((suite) => ({
+      name: suite.name,
+      tests: suite.tests.length,
+      passed: suite.passed,
+      failed: suite.failed,
+      skipped: suite.skipped,
+      duration: suite.duration,
+      results: suite.tests.map((test) => {
+        const resultObj: JsonReport['suites'][0]['results'][0] = {
+          id: test.testCase.id,
+          component: test.testCase.component,
+          variant: test.testCase.variant,
+          status: test.status,
+          duration: test.duration,
+        };
+
+        // Include steps if requested
+        if (includeSteps && test.steps.length > 0) {
+          resultObj.steps = test.steps.map((step) => ({
+            name: step.name,
+            status: step.status,
+            duration: step.duration,
+            error: step.error?.message,
+          }));
+        }
+
+        // Include error if present
+        if (test.error) {
+          resultObj.error = {
+            message: test.error.message,
+            stack: includeStacks ? test.error.stack : undefined,
+          };
+        }
+
+        // Include accessibility results if present
+        if (test.accessibility) {
+          resultObj.accessibility = {
+            violations: test.accessibility.violations.length,
+            passes: test.accessibility.passes,
+            details: test.accessibility.violations.map((v) => ({
+              id: v.id,
+              impact: v.impact,
+              description: v.description,
+              elements: v.nodes.length,
+            })),
+          };
+        }
+
+        // Include retry info if applicable
+        if (test.retryAttempt) {
+          resultObj.retryAttempt = test.retryAttempt;
+        }
+
+        return resultObj;
+      }),
+    })),
+  };
+}

package/src/test/reporters/junit.ts

@@ -0,0 +1,186 @@
+/**
+ * JUnit XML reporter - CI/CD integration
+ *
+ * Generates JUnit XML format compatible with:
+ * - GitHub Actions (mikepenz/action-junit-report)
+ * - Jenkins
+ * - GitLab CI
+ * - CircleCI
+ * - Azure DevOps
+ */
+
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import type { TestRunResult, TestReporter, TestResult, TestSuite } from '../types.js';
+
+export interface JUnitReporterOptions {
+  /** Output file path */
+  outputPath: string;
+  /** Suite name for the root element */
+  suiteName?: string;
+  /** Include properties in the XML */
+  includeProperties?: boolean;
+}
+
+/**
+ * Create a JUnit XML reporter
+ */
+export function createJUnitReporter(options: JUnitReporterOptions): TestReporter {
+  const { outputPath, suiteName = 'Segments Tests', includeProperties = true } = options;
+
+  return {
+    async onRunComplete(result: TestRunResult) {
+      const xml = generateJUnitXml(result, suiteName, includeProperties);
+
+      // Ensure output directory exists
+      await mkdir(dirname(outputPath), { recursive: true });
+
+      // Write the XML file
+      await writeFile(outputPath, xml, 'utf-8');
+    },
+  };
+}
+
+/**
+ * Generate JUnit XML from test results
+ */
+function generateJUnitXml(
+  result: TestRunResult,
+  suiteName: string,
+  includeProperties: boolean
+): string {
+  const lines: string[] = [];
+
+  // XML declaration
+  lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+
+  // Root testsuites element
+  lines.push(
+    `<testsuites name="${escapeXml(suiteName)}" tests="${result.totalTests}" failures="${result.totalFailed}" skipped="${result.totalSkipped}" time="${(result.totalDuration / 1000).toFixed(3)}">`
+  );
+
+  // Generate each test suite
+  for (const suite of result.suites) {
+    lines.push(generateTestSuiteXml(suite, includeProperties));
+  }
+
+  lines.push('</testsuites>');
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate XML for a single test suite
+ */
+function generateTestSuiteXml(suite: TestSuite, includeProperties: boolean): string {
+  const lines: string[] = [];
+
+  // Testsuite element
+  lines.push(
+    `  <testsuite name="${escapeXml(suite.name)}" tests="${suite.tests.length}" failures="${suite.failed}" skipped="${suite.skipped}" time="${(suite.duration / 1000).toFixed(3)}">`
+  );
+
+  // Properties (optional)
+  if (includeProperties) {
+    lines.push('    <properties>');
+    lines.push(`      <property name="component" value="${escapeXml(suite.name)}"/>`);
+    lines.push('    </properties>');
+  }
+
+  // Test cases
+  for (const test of suite.tests) {
+    lines.push(generateTestCaseXml(test));
+  }
+
+  lines.push('  </testsuite>');
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate XML for a single test case
+ */
+function generateTestCaseXml(result: TestResult): string {
+  const { testCase, status, duration, error, steps, accessibility } = result;
+  const lines: string[] = [];
+
+  const testName = testCase.variant;
+  const className = testCase.component;
+  const time = (duration / 1000).toFixed(3);
+
+  // Opening tag
+  if (status === 'passed' && !accessibility?.violations.length) {
+    // Simple passed test - self-closing tag
+    lines.push(`    <testcase name="${escapeXml(testName)}" classname="${escapeXml(className)}" time="${time}"/>`);
+  } else {
+    // Test with failure, skip, or a11y info
+    lines.push(`    <testcase name="${escapeXml(testName)}" classname="${escapeXml(className)}" time="${time}">`);
+
+    if (status === 'failed') {
+      // Failure element
+      const message = error?.message || 'Test failed';
+      lines.push(`      <failure message="${escapeXml(message)}" type="AssertionError">`);
+
+      // Add detailed failure info
+      const details: string[] = [];
+
+      // Add step failures
+      const failedSteps = steps.filter((s) => s.status === 'failed');
+      if (failedSteps.length > 0) {
+        details.push('Failed steps:');
+        for (const step of failedSteps) {
+          details.push(`  - ${step.name}: ${step.error?.message || 'Failed'}`);
+        }
+      }
+
+      // Add stack trace if available
+      if (error?.stack) {
+        details.push('');
+        details.push('Stack trace:');
+        details.push(error.stack);
+      }
+
+      if (details.length > 0) {
+        lines.push(escapeXml(details.join('\n')));
+      }
+
+      lines.push('      </failure>');
+    } else if (status === 'skipped') {
+      lines.push('      <skipped/>');
+    }
+
+    // Add system-out for accessibility violations
+    if (accessibility?.violations.length) {
+      lines.push('      <system-out>');
+      lines.push(`Accessibility violations (${accessibility.violations.length}):`);
+      for (const violation of accessibility.violations) {
+        lines.push(`  [${violation.impact}] ${violation.id}: ${violation.description}`);
+        lines.push(`    Help: ${violation.help}`);
+        for (const node of violation.nodes.slice(0, 3)) {
+          lines.push(`    Element: ${node.html.substring(0, 100)}`);
+        }
+        if (violation.nodes.length > 3) {
+          lines.push(`    ... and ${violation.nodes.length - 3} more elements`);
+        }
+      }
+      lines.push('      </system-out>');
+    }
+
+    lines.push('    </testcase>');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Escape special XML characters
+ */
+function escapeXml(str: string): string {
+  return str
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;')
+    .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, ''); // Remove invalid XML characters
+}