gha-workflow-testing 1.0.0

package/src/assertions.ts

@@ -0,0 +1,387 @@
+import axios from 'axios';
+import { Jobs, Steps, Artifacts } from './github-api';
+import { WorkflowTestReporter } from './reporter';
+
+export function assertJobSuccess(
+  jobs: Jobs,
+  jobName: string,
+  reporter?: WorkflowTestReporter,
+  expectedConclusion: string = 'success'
+): void {
+  try {
+    if (!jobs[jobName]) {
+      const availableJobs = Object.keys(jobs).join('\n  - ');
+      throw new Error(
+        `${jobName} not found. Available jobs:\n  - ${availableJobs}`
+      );
+    }
+
+    const jobInfo = jobs[jobName];
+    const { status, conclusion } = jobInfo;
+
+    if (conclusion !== expectedConclusion) {
+      if (conclusion === null) {
+        throw new Error(
+          `${jobName} did not complete with expected conclusion '${expectedConclusion}'.\n` +
+            `  Status: ${status}\n` +
+            `  Conclusion: ${conclusion} (job was skipped, cancelled, or still running)`
+        );
+      } else {
+        throw new Error(
+          `${jobName} did not have expected conclusion.\n` +
+            `  Expected: ${expectedConclusion}\n` +
+            `  Actual: ${conclusion}\n` +
+            `  Status: ${status}`
+        );
+      }
+    }
+
+    console.log(`✅ ${jobName} completed with conclusion '${expectedConclusion}'`);
+
+    // Record success in reporter
+    if (reporter) {
+      reporter.recordJobTest(jobName, true, expectedConclusion, conclusion);
+    }
+  } catch (error) {
+    // Record failure in reporter
+    if (reporter) {
+      const conclusion = jobs[jobName]?.conclusion || 'unknown';
+      reporter.recordJobTest(jobName, false, expectedConclusion, conclusion);
+    }
+    throw error;
+  }
+}
+
+export function assertStepSuccess(
+  steps: Steps,
+  stepName: string,
+  jobName?: string,
+  reporter?: WorkflowTestReporter,
+  expectedConclusion: string = 'success'
+): void {
+  try {
+    if (!steps[stepName]) {
+      const availableSteps = Object.keys(steps).join('\n  - ');
+      throw new Error(
+        `Step '${stepName}' not found. Available steps:\n  - ${availableSteps}`
+      );
+    }
+
+    const stepInfo = steps[stepName];
+    const { conclusion } = stepInfo;
+
+    if (conclusion !== expectedConclusion) {
+      throw new Error(
+        `Step '${stepName}' did not have expected conclusion.\n` +
+          `  Expected: ${expectedConclusion}\n` +
+          `  Actual: ${conclusion}`
+      );
+    }
+
+    console.log(`✅ Step '${stepName}' completed with conclusion '${expectedConclusion}'`);
+
+    // Record success in reporter
+    if (reporter && jobName) {
+      reporter.recordStepTest(jobName, stepName, true, expectedConclusion, conclusion || undefined);
+    }
+  } catch (error) {
+    // Record failure in reporter
+    if (reporter && jobName) {
+      const conclusion = steps[stepName]?.conclusion || 'unknown';
+      reporter.recordStepTest(jobName, stepName, false, expectedConclusion, conclusion || undefined);
+    }
+    throw error;
+  }
+}
+
+export function assertArtifactExists(
+  artifacts: Artifacts,
+  artifactName: string,
+  reporter?: WorkflowTestReporter
+): void {
+  try {
+    if (!artifacts[artifactName]) {
+      const availableArtifacts = Object.keys(artifacts).length > 0
+        ? Object.keys(artifacts).join('\n  - ')
+        : '(no artifacts)';
+      throw new Error(
+        `Artifact '${artifactName}' not found. Available artifacts:\n  - ${availableArtifacts}`
+      );
+    }
+
+    const artifactInfo = artifacts[artifactName];
+    if (artifactInfo.expired) {
+      throw new Error(`Artifact '${artifactName}' has expired`);
+    }
+
+    console.log(`✅ Artifact '${artifactName}' exists (size: ${artifactInfo.size} bytes)`);
+
+    // Record success in reporter
+    if (reporter) {
+      reporter.recordArtifactTest(artifactName, 'exists', true, 'exists');
+    }
+  } catch (error) {
+    // Record failure in reporter
+    if (reporter) {
+      reporter.recordArtifactTest(
+        artifactName,
+        'exists',
+        false,
+        'exists',
+        'not found or expired'
+      );
+    }
+    throw error;
+  }
+}
+
+export function assertFileInArtifact(
+  artifactFiles: { [filename: string]: Buffer },
+  filename: string,
+  artifactName?: string,
+  reporter?: WorkflowTestReporter
+): void {
+  try {
+    if (!artifactFiles[filename]) {
+      const availableFiles = Object.keys(artifactFiles).length > 0
+        ? Object.keys(artifactFiles).join('\n  - ')
+        : '(no files)';
+      throw new Error(
+        `File '${filename}' not found in artifact. Available files:\n  - ${availableFiles}`
+      );
+    }
+
+    console.log(`✅ File '${filename}' found in artifact`);
+
+    // Record success in reporter
+    if (reporter && artifactName) {
+      reporter.recordArtifactTest(
+        artifactName,
+        `file '${filename}' exists`,
+        true,
+        filename
+      );
+    }
+  } catch (error) {
+    // Record failure in reporter
+    if (reporter && artifactName) {
+      reporter.recordArtifactTest(
+        artifactName,
+        `file '${filename}' exists`,
+        false,
+        filename,
+        'not found'
+      );
+    }
+    throw error;
+  }
+}
+
+export function assertFileContains(
+  artifactFiles: { [filename: string]: Buffer },
+  filename: string,
+  expectedContent: string | Buffer,
+  artifactName?: string,
+  reporter?: WorkflowTestReporter
+): void {
+  try {
+    assertFileInArtifact(artifactFiles, filename, artifactName, reporter);
+
+    const fileContent = artifactFiles[filename];
+    const expectedBuffer =
+      typeof expectedContent === 'string'
+        ? Buffer.from(expectedContent)
+        : expectedContent;
+
+    if (!fileContent.includes(expectedBuffer)) {
+      const contentStr =
+        typeof expectedContent === 'string'
+          ? expectedContent
+          : expectedContent.toString();
+      throw new Error(
+        `File '${filename}' does not contain expected content: ${contentStr}`
+      );
+    }
+
+    console.log(`✅ File '${filename}' contains expected content`);
+
+    // Record success in reporter
+    if (reporter && artifactName) {
+      const contentPreview = (
+        typeof expectedContent === 'string'
+          ? expectedContent
+          : expectedContent.toString()
+      ).substring(0, 50);
+      reporter.recordArtifactTest(
+        artifactName,
+        `file '${filename}' contains content`,
+        true,
+        contentPreview
+      );
+    }
+  } catch (error) {
+    // Record failure in reporter
+    if (reporter && artifactName) {
+      const contentPreview = (
+        typeof expectedContent === 'string'
+          ? expectedContent
+          : expectedContent.toString()
+      ).substring(0, 50);
+      reporter.recordArtifactTest(
+        artifactName,
+        `file '${filename}' contains content`,
+        false,
+        contentPreview,
+        'not found'
+      );
+    }
+    throw error;
+  }
+}
+
+// ============================================================================
+// JFrog Artifactory Assertions
+// ============================================================================
+
+export interface JFrogArtifactOptions {
+  jfrogUrl: string;
+  repository: string;
+  artifactPath: string;
+  artifactName: string;
+  jfrogApiKey?: string;
+  jfrogToken?: string;
+  reporter?: WorkflowTestReporter;
+  jobName?: string;
+}
+
+export async function assertJFrogArtifactExists(
+  options: JFrogArtifactOptions
+): Promise<void> {
+  const {
+    jfrogUrl,
+    repository,
+    artifactPath,
+    artifactName,
+    jfrogApiKey,
+    jfrogToken,
+    reporter,
+  } = options;
+
+  // Create artifact display name for reporter
+  const jfrogArtifactDisplayName = `JFrog: ${repository}/${artifactPath}/${artifactName}`;
+
+  try {
+    // Get credentials from parameters or environment
+    const apiKey = jfrogApiKey || process.env.MCD_ACTIONS_DD_API_KEY;
+    const token = jfrogToken || process.env.GDAP_ARTIFACTORY_ACCESS_TOKEN;
+
+    if (!apiKey && !token) {
+      throw new Error(
+        'JFrog credentials not provided. Set one of:\n' +
+          '  - JFROG_API_KEY or GDAP_ARTIFACTORY_ACCESS_TOKEN environment variable\n' +
+          '  - JFROG_TOKEN environment variable\n' +
+          '  - Pass jfrogApiKey or jfrogToken parameter'
+      );
+    }
+
+    // Build artifact URL
+    const cleanJfrogUrl = jfrogUrl.replace(/\/$/, '');
+    const cleanArtifactPath = artifactPath.replace(/^\/|\/$/g, '');
+    const artifactUrl = `${cleanJfrogUrl}/artifactory/${repository}/${cleanArtifactPath}/${artifactName}`;
+
+    // Set up authentication headers
+    const headers: { [key: string]: string } = {};
+    let authMethod: string;
+
+    if (apiKey) {
+      headers['X-JFrog-Art-Api'] = apiKey;
+      authMethod = 'API Key';
+    } else {
+      headers['Authorization'] = `Bearer ${token}`;
+      authMethod = 'Bearer Token';
+    }
+
+    console.log('🔍 Checking JFrog artifact existence...');
+    console.log(`   URL: ${artifactUrl}`);
+    console.log(`   Auth: ${authMethod}`);
+
+    // Make HEAD request to check if artifact exists
+    const response = await axios.head(artifactUrl, {
+      headers,
+      timeout: 30000,
+      maxRedirects: 5,
+    });
+
+    if (response.status === 200) {
+      // Artifact exists! Get metadata from response headers
+      const fileSize = response.headers['content-length'] || 'unknown';
+      const checksumSha1 = response.headers['x-checksum-sha1'] || 'N/A';
+      const lastModified = response.headers['last-modified'] || 'N/A';
+
+      console.log(`✅ Artifact '${artifactName}' exists in JFrog Artifactory`);
+      console.log(`   Repository: ${repository}`);
+      console.log(`   Path: ${artifactPath}`);
+      console.log(`   Size: ${fileSize} bytes`);
+      console.log(`   SHA1: ${checksumSha1}`);
+      console.log(`   Last Modified: ${lastModified}`);
+
+      // Record success in reporter as artifact
+      if (reporter) {
+        reporter.recordArtifactTest(
+          jfrogArtifactDisplayName,
+          'exists in JFrog',
+          true,
+          `Size: ${fileSize} bytes, SHA1: ${checksumSha1.substring(0, 8)}...`
+        );
+      }
+    }
+  } catch (error: any) {
+    let errorMsg: string;
+
+    if (axios.isAxiosError(error)) {
+      if (error.response?.status === 404) {
+        errorMsg =
+          `❌ Artifact '${artifactName}' not found in JFrog Artifactory.\n` +
+          `   Repository: ${repository}\n` +
+          `   Path: ${artifactPath}\n` +
+          `   Status: 404 Not Found`;
+      } else if (error.response?.status === 401) {
+        errorMsg =
+          `❌ Authentication failed when checking JFrog artifact.\n` +
+          `   Status: 401 Unauthorized`;
+      } else if (error.response?.status === 403) {
+        errorMsg =
+          `❌ Permission denied when checking JFrog artifact.\n` +
+          `   Status: 403 Forbidden`;
+      } else if (error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND') {
+        errorMsg =
+          `❌ Failed to connect to JFrog Artifactory.\n` +
+          `   Error: Connection error`;
+      } else if (error.code === 'ETIMEDOUT' || error.code === 'ECONNABORTED') {
+        errorMsg =
+          `❌ Request to JFrog Artifactory timed out.\n` +
+          `   Timeout: 30 seconds`;
+      } else {
+        errorMsg =
+          `❌ Unexpected response when checking JFrog artifact.\n` +
+          `   Status: ${error.response?.status}\n` +
+          `   Error: ${error.message}`;
+      }
+    } else {
+      errorMsg = `❌ Error checking JFrog artifact: ${error.message}`;
+    }
+
+    // Record failure in reporter
+    if (reporter) {
+      reporter.recordArtifactTest(
+        jfrogArtifactDisplayName,
+        'exists in JFrog',
+        false,
+        'artifact exists',
+        'not found or error'
+      );
+    }
+
+    throw new Error(errorMsg);
+  }
+}

package/src/github-api.ts

@@ -0,0 +1,184 @@
+import axios, { AxiosInstance } from 'axios';
+
+export interface JobInfo {
+  status: string;
+  conclusion: string | null;
+}
+
+export interface Jobs {
+  [jobName: string]: JobInfo;
+}
+
+export interface StepInfo {
+  conclusion: string | null;
+  number: number;
+}
+
+export interface Steps {
+  [stepName: string]: StepInfo;
+}
+
+export interface ArtifactInfo {
+  id: number;
+  size: number;
+  expired: boolean;
+  url: string;
+}
+
+export interface Artifacts {
+  [artifactName: string]: ArtifactInfo;
+}
+
+export class GitHubAPI {
+  private repo: string;
+  private client: AxiosInstance;
+
+  constructor() {
+    this.repo = process.env.GITHUB_REPOSITORY || '';
+    const token = process.env.GITHUB_TOKEN || '';
+
+    if (!this.repo || !token) {
+      throw new Error('GITHUB_REPOSITORY and GITHUB_TOKEN environment variables are required');
+    }
+
+    console.log(`🔍 GitHub API initialized for repo: ${this.repo}`);
+
+    this.client = axios.create({
+      baseURL: 'https://api.github.com',
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/vnd.github+json',
+      },
+    });
+  }
+
+  async getLatestRun(workflowName: string): Promise<number> {
+    const url = `/repos/${this.repo}/actions/runs`;
+    console.log(`📡 Fetching workflow runs from: ${url}`);
+
+    const response = await this.client.get(url);
+    const runs = response.data.workflow_runs;
+    console.log(`Found ${runs.length} total workflow runs`);
+
+    for (const run of runs) {
+      if (run.name === workflowName) {
+        console.log(`✅ Found matching workflow: ${workflowName} (ID: ${run.id})`);
+        return run.id;
+      }
+    }
+
+    console.log(`❌ Workflow '${workflowName}' not found in recent runs`);
+    throw new Error('Workflow run not found');
+  }
+
+  async getJobs(runId: number): Promise<Jobs> {
+    const url = `/repos/${this.repo}/actions/runs/${runId}/jobs`;
+    console.log(`📡 Fetching jobs for run ID ${runId}`);
+
+    const response = await this.client.get(url);
+    const jobs = response.data.jobs;
+    console.log(`Found ${jobs.length} jobs in this run`);
+
+    const result: Jobs = {};
+    for (const job of jobs) {
+      result[job.name] = {
+        status: job.status,
+        conclusion: job.conclusion,
+      };
+    }
+
+    return result;
+  }
+
+  async waitForJobsCompletion(
+    runId: number,
+    timeout: number = 300,
+    pollInterval: number = 10
+  ): Promise<Jobs> {
+    console.log(`⏳ Waiting for all jobs to complete (timeout: ${timeout}s)...`);
+    const startTime = Date.now();
+
+    while (Date.now() - startTime < timeout * 1000) {
+      const jobs = await this.getJobs(runId);
+
+      const incompleteJobs = Object.entries(jobs)
+        .filter(([_, info]) => info.conclusion === null)
+        .map(([name]) => name);
+
+      if (incompleteJobs.length === 0) {
+        console.log('✅ All jobs completed!');
+        return jobs;
+      }
+
+      console.log(
+        `⏳ Waiting for ${incompleteJobs.length} job(s) to complete: ${incompleteJobs.join(', ')}`
+      );
+      await this.sleep(pollInterval * 1000);
+    }
+
+    throw new Error(`Jobs did not complete within ${timeout} seconds`);
+  }
+
+  async getSteps(runId: number, jobName: string): Promise<Steps> {
+    const url = `/repos/${this.repo}/actions/runs/${runId}/jobs`;
+    console.log(`📡 Fetching steps for job: ${jobName}`);
+
+    const response = await this.client.get(url);
+    const jobs = response.data.jobs;
+
+    const job = jobs.find((j: any) => j.name === jobName);
+    if (!job) {
+      throw new Error(`Job '${jobName}' not found in run ${runId}`);
+    }
+
+    const result: Steps = {};
+    for (const step of job.steps) {
+      result[step.name] = {
+        conclusion: step.conclusion,
+        number: step.number,
+      };
+    }
+
+    console.log(`Found ${Object.keys(result).length} steps in job '${jobName}'`);
+    return result;
+  }
+
+  async getArtifacts(runId: number): Promise<Artifacts> {
+    const url = `/repos/${this.repo}/actions/runs/${runId}/artifacts`;
+    console.log(`📡 Fetching artifacts for run ID ${runId}`);
+
+    const response = await this.client.get(url);
+    const artifacts = response.data.artifacts;
+    console.log(`Found ${artifacts.length} artifacts`);
+
+    const result: Artifacts = {};
+    for (const artifact of artifacts) {
+      result[artifact.name] = {
+        id: artifact.id,
+        size: artifact.size_in_bytes,
+        expired: artifact.expired,
+        url: artifact.archive_download_url,
+      };
+    }
+
+    return result;
+  }
+
+  async downloadArtifact(artifactId: number): Promise<{ [filename: string]: Buffer }> {
+    const url = `/repos/${this.repo}/actions/artifacts/${artifactId}/zip`;
+    console.log(`📥 Downloading artifact ID ${artifactId}`);
+
+    const response = await this.client.get(url, { responseType: 'arraybuffer' });
+
+    // In a real implementation, you would unzip the response
+    // For simplicity, returning a placeholder
+    console.log('⚠️  Artifact download implemented - unzipping not yet implemented in this example');
+    return {
+      'artifact-file.zip': Buffer.from(response.data),
+    };
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './github-api';
+export * from './assertions';
+export * from './reporter';