gha-workflow-testing 1.0.0

package/src/reporter.ts

@@ -0,0 +1,344 @@
+import * as fs from 'fs';
+
+export interface StepResult {
+  tested: boolean;
+  result: string;
+  conclusion?: string;
+  expected?: string;
+  actual?: string;
+}
+
+export interface JobResult {
+  tested: boolean;
+  result: string;
+  conclusion?: string;
+  expected?: string;
+  actual?: string;
+  steps: { [stepName: string]: StepResult };
+}
+
+export interface ArtifactResult {
+  tested: boolean;
+  result: string;
+  checks: string[];
+}
+
+export class WorkflowTestReporter {
+  private workflowName: string;
+  private jobs: { [jobName: string]: JobResult } = {};
+  private artifacts: { [artifactName: string]: ArtifactResult } = {};
+  private runId?: string;
+  private allJobsLoaded = false;
+
+  constructor(workflowName: string) {
+    this.workflowName = workflowName;
+  }
+
+  setRunId(runId: string | number): void {
+    this.runId = String(runId);
+  }
+
+  async loadAllJobsAndSteps(api: any): Promise<void> {
+    if (this.allJobsLoaded || !this.runId) {
+      return;
+    }
+
+    try {
+      // Get all jobs from the run
+      const jobsData = await api.getJobs(Number(this.runId));
+
+      for (const [jobName, jobInfo] of Object.entries(jobsData)) {
+        // Add job if not already tracked
+        if (!this.jobs[jobName]) {
+          this.jobs[jobName] = {
+            tested: false,
+            result: 'Not Tested',
+            conclusion: (jobInfo as any).conclusion || undefined,
+            steps: {},
+          };
+        }
+
+        // Get all steps for this job
+        try {
+          const stepsData = await api.getSteps(Number(this.runId), jobName);
+
+          for (const [stepName, stepInfo] of Object.entries(stepsData)) {
+            if (!this.jobs[jobName].steps[stepName]) {
+              this.jobs[jobName].steps[stepName] = {
+                tested: false,
+                result: 'Not Tested',
+                conclusion: (stepInfo as any).conclusion || undefined,
+              };
+            }
+          }
+        } catch (error) {
+          console.log(`⚠️  Could not load steps for ${jobName}: ${error}`);
+        }
+      }
+
+      this.allJobsLoaded = true;
+    } catch (error) {
+      console.log(`⚠️  Could not load all jobs and steps: ${error}`);
+    }
+  }
+
+  addJob(jobName: string): void {
+    if (!this.jobs[jobName]) {
+      this.jobs[jobName] = {
+        tested: false,
+        result: 'Not Tested',
+        steps: {},
+      };
+    }
+  }
+
+  recordJobTest(
+    jobName: string,
+    passed: boolean,
+    expected?: string,
+    actual?: string
+  ): void {
+    this.addJob(jobName);
+    this.jobs[jobName].tested = true;
+    this.jobs[jobName].expected = expected;
+    this.jobs[jobName].actual = actual;
+
+    if (passed) {
+      this.jobs[jobName].result = `✅ Passed (expected: ${expected})`;
+    } else {
+      this.jobs[jobName].result = `❌ Failed (expected: ${expected}, got: ${actual})`;
+    }
+  }
+
+  recordStepTest(
+    jobName: string,
+    stepName: string,
+    passed: boolean,
+    expected?: string,
+    actual?: string
+  ): void {
+    this.addJob(jobName);
+
+    if (!this.jobs[jobName].steps[stepName]) {
+      this.jobs[jobName].steps[stepName] = {
+        tested: false,
+        result: 'Not Tested',
+      };
+    }
+
+    this.jobs[jobName].steps[stepName].tested = true;
+    this.jobs[jobName].steps[stepName].expected = expected;
+    this.jobs[jobName].steps[stepName].actual = actual;
+
+    if (passed) {
+      this.jobs[jobName].steps[stepName].result = `✅ Passed (expected: ${expected})`;
+    } else {
+      this.jobs[jobName].steps[stepName].result = `❌ Failed (expected: ${expected}, got: ${actual})`;
+    }
+  }
+
+  addArtifact(artifactName: string): void {
+    if (!this.artifacts[artifactName]) {
+      this.artifacts[artifactName] = {
+        tested: false,
+        result: 'Not Tested',
+        checks: [],
+      };
+    }
+  }
+
+  recordArtifactTest(
+    artifactName: string,
+    checkType: string,
+    passed: boolean,
+    expected?: string,
+    actual?: string
+  ): void {
+    this.addArtifact(artifactName);
+    this.artifacts[artifactName].tested = true;
+
+    let result: string;
+    if (passed) {
+      result = `✅ ${checkType}`;
+      if (expected) {
+        result += ` (expected: ${expected})`;
+      }
+    } else {
+      result = `❌ ${checkType} failed`;
+      if (expected && actual) {
+        result += ` (expected: ${expected}, got: ${actual})`;
+      }
+    }
+
+    this.artifacts[artifactName].checks.push(result);
+
+    // Update overall artifact result
+    if (!passed) {
+      this.artifacts[artifactName].result = '❌ Failed';
+    } else if (this.artifacts[artifactName].result !== '❌ Failed') {
+      this.artifacts[artifactName].result = '✅ Passed';
+    }
+  }
+
+  generateMarkdown(): string {
+    const lines: string[] = [];
+
+    // Header
+    lines.push('# 🧪 Workflow Test Report');
+    lines.push('');
+    lines.push(`**Workflow:** \`${this.workflowName}\``);
+    if (this.runId) {
+      lines.push(`**Run ID:** \`${this.runId}\``);
+    }
+    lines.push('');
+
+    // Summary stats
+    const totalJobs = Object.keys(this.jobs).length;
+    const testedJobs = Object.values(this.jobs).filter((j) => j.tested).length;
+    const passedJobs = Object.values(this.jobs).filter((j) =>
+      j.result.startsWith('✅')
+    ).length;
+
+    const totalSteps = Object.values(this.jobs).reduce(
+      (sum, job) => sum + Object.keys(job.steps).length,
+      0
+    );
+    const testedSteps = Object.values(this.jobs).reduce(
+      (sum, job) =>
+        sum + Object.values(job.steps).filter((step) => step.tested).length,
+      0
+    );
+    const passedSteps = Object.values(this.jobs).reduce(
+      (sum, job) =>
+        sum +
+        Object.values(job.steps).filter((step) => step.result.startsWith('✅'))
+          .length,
+      0
+    );
+
+    const totalArtifacts = Object.keys(this.artifacts).length;
+    const testedArtifacts = Object.values(this.artifacts).filter(
+      (a) => a.tested
+    ).length;
+    const passedArtifacts = Object.values(this.artifacts).filter((a) =>
+      a.result.startsWith('✅')
+    ).length;
+
+    lines.push('## 📊 Summary');
+    lines.push('');
+    lines.push('| Metric | Count |');
+    lines.push('|--------|-------|');
+    lines.push(`| Total Jobs | ${totalJobs} |`);
+    lines.push(`| Jobs Tested | ${testedJobs} |`);
+    lines.push(`| Jobs Passed | ${passedJobs} |`);
+    lines.push(`| Total Steps | ${totalSteps} |`);
+    lines.push(`| Steps Tested | ${testedSteps} |`);
+    lines.push(`| Steps Passed | ${passedSteps} |`);
+    lines.push(`| Total Artifacts | ${totalArtifacts} |`);
+    lines.push(`| Artifacts Tested | ${testedArtifacts} |`);
+    lines.push(`| Artifacts Passed | ${passedArtifacts} |`);
+    lines.push('');
+
+    // Job details
+    lines.push('## 📋 Detailed Test Results');
+    lines.push('');
+
+    for (const [jobName, jobInfo] of Object.entries(this.jobs)) {
+      const testedIcon = jobInfo.tested ? '✅' : '⬜';
+
+      lines.push(`### ${testedIcon} ${jobName}`);
+      lines.push('');
+
+      // Job-level table
+      lines.push('| Type | Name | Tested | Result |');
+      lines.push('|------|------|--------|--------|');
+      lines.push(
+        `| **Job** | ${jobName} | ${jobInfo.tested ? '✅ Yes' : '❌ No'} | ${jobInfo.result} |`
+      );
+
+      // Steps table
+      if (Object.keys(jobInfo.steps).length > 0) {
+        for (const [stepName, stepInfo] of Object.entries(jobInfo.steps)) {
+          const tested = stepInfo.tested ? '✅ Yes' : '❌ No';
+          lines.push(`| Step | ${stepName} | ${tested} | ${stepInfo.result} |`);
+        }
+      }
+
+      lines.push('');
+    }
+
+    // Artifacts section
+    if (Object.keys(this.artifacts).length > 0) {
+      lines.push('## 📦 Artifacts');
+      lines.push('');
+      lines.push('| Artifact | Tested | Overall Result | Checks |');
+      lines.push('|----------|--------|----------------|--------|');
+
+      for (const [artifactName, artifactInfo] of Object.entries(this.artifacts)) {
+        const tested = artifactInfo.tested ? '✅ Yes' : '❌ No';
+        const result = artifactInfo.result;
+
+        // Combine all checks into one cell
+        const checks =
+          artifactInfo.checks.length > 0
+            ? artifactInfo.checks.join('<br>')
+            : 'No checks performed';
+
+        lines.push(`| ${artifactName} | ${tested} | ${result} | ${checks} |`);
+      }
+
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+
+  writeToGithubSummary(): void {
+    console.log('\n🔍 Attempting to write test report...');
+
+    const summaryFile = process.env.GITHUB_STEP_SUMMARY;
+
+    if (!summaryFile) {
+      console.log('⚠️  GITHUB_STEP_SUMMARY environment variable not set');
+      console.log('   Report will only be printed to console');
+      return;
+    }
+
+    console.log(`📝 Writing report to: ${summaryFile}`);
+
+    const markdown = this.generateMarkdown();
+
+    try {
+      fs.appendFileSync(summaryFile, markdown);
+      console.log('✅ Test report successfully written to GitHub Actions summary');
+    } catch (error) {
+      console.log(`❌ Failed to write report: ${error}`);
+    }
+  }
+
+  printReport(): void {
+    console.log('\n' + '='.repeat(80));
+    console.log(this.generateMarkdown());
+    console.log('='.repeat(80) + '\n');
+  }
+}
+
+// Global reporter instance
+let globalReporter: WorkflowTestReporter | null = null;
+
+export function getReporter(workflowName?: string): WorkflowTestReporter {
+  if (!globalReporter) {
+    if (!workflowName) {
+      throw new Error(
+        'Reporter not initialized. Call getReporter(workflowName) first.'
+      );
+    }
+    globalReporter = new WorkflowTestReporter(workflowName);
+  }
+
+  return globalReporter;
+}
+
+export function resetReporter(): void {
+  globalReporter = null;
+}