test pipeline v2 for js automation

.github/workflows/_reusable-verify-run-status.yaml

@@ -0,0 +1,42 @@
+# Prefix with "~" to sort last in Actions list
+name: ~Templates - Verify Run Status
+
+on:
+  workflow_call:
+    inputs:
+      check_run_name:
+        description: Name of the check run to verify
+        required: true
+        type: string
+      workflow_name:
+        description: Name of the workflow to verify
+        required: true
+        type: string
+
+permissions:
+  checks: read
+  contents: read
+
+jobs:
+  check-run-status:
+    if: |
+      (github.event_name == 'workflow_run') || 
+      (github.event_name == 'check_suite' && github.event.check_suite.app.name == 'openapi-pipeline-app') || 
+      (github.event_name == 'check_run' && github.event.check_run.name == inputs.check_run_name)
+    runs-on: ubuntu-24.04
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          sparse-checkout: |
+            .github
+
+      - name: Verify matching status
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { verifyRunStatus } = await import('${{ github.workspace }}/.github/workflows/src/verify-run-status.js');
+            return await verifyRunStatus({ github, context, core });
+        env:
+          CHECK_RUN_NAME: ${{ inputs.check_run_name }}
+          WORKFLOW_NAME: ${{ inputs.workflow_name }}

.github/workflows/src/checks.js

@@ -0,0 +1,25 @@
+import { PER_PAGE_MAX } from "./github.js";
+
+/**
+ * @param {import('github-script').AsyncFunctionArguments['github']} github
+ * @param {{ 
+ *   owner: string; 
+ *   repo: string; 
+ *   ref: string; 
+ *   name?: string; 
+ *   status?: "queued" | "in_progress" | "completed";
+ * }} params
+ * @returns {Promise<import("@octokit/plugin-rest-endpoint-methods").RestEndpointMethodTypes["checks"]["listForRef"]["response"]["data"]["check_runs"]>}
+ */
+export async function listChecksForRef(github, { owner, repo, ref, name, status}) { 
+  const options = { 
+    owner, 
+    repo, 
+    ref, 
+    ...(name && { check_name: name }), 
+    ...(status && { status }),
+    per_page: PER_PAGE_MAX,
+  };
+
+  return await github.paginate(github.rest.checks.listForRef, options);
+}

.github/workflows/src/verify-run-status.js

@@ -0,0 +1,180 @@
+import { extractInputs } from "./context.js";
+import { PER_PAGE_MAX } from "./github.js";
+
+const SUPPORTED_EVENTS = ["workflow_run", "check_run", "check_suite"];
+
+/**
+ * @typedef {import('@octokit/plugin-rest-endpoint-methods').RestEndpointMethodTypes} RestEndpointMethodTypes
+ * @typedef {RestEndpointMethodTypes["checks"]["listForRef"]["response"]["data"]["check_runs"]} CheckRuns
+ * @typedef {RestEndpointMethodTypes["actions"]["listWorkflowRunsForRepo"]["response"]["data"]["workflow_runs"]} WorkflowRuns
+ */
+
+/* v8 ignore start */
+/**
+ * Given the name of a completed check run name and a completed workflow, verify 
+ * that both have the same conclusion. If conclusions are different, fail the 
+ * action.
+ * @param {import('github-script').AsyncFunctionArguments} AsyncFunctionArguments
+ */
+export async function verifyRunStatus({ github, context, core }) {
+  const checkRunName = process.env.CHECK_RUN_NAME;
+  if (!checkRunName) {
+    throw new Error("CHECK_RUN_NAME is not set");
+  }
+
+  const workflowName = process.env.WORKFLOW_NAME;
+  if (!workflowName) {
+    throw new Error("WORKFLOW_NAME is not set");
+  }
+
+  if (!SUPPORTED_EVENTS.some((e) => e === context.eventName)) {
+    throw new Error(
+      `Unsupported event: ${context.eventName}. Supported events: ${SUPPORTED_EVENTS.join(", ")}`,
+    );
+  }
+
+  if (context.eventName === "check_suite" && context.payload.check_suite.status !== "completed") { 
+    core.setFailed(`Check suite ${context.payload.check_suite.app.name} is not completed. Cannot evaluate incomplete check suite.`);
+    return;
+  }
+
+  return await verifyRunStatusImpl({ github, context, core , checkRunName, workflowName});
+}
+/* v8 ignore stop */
+
+/**
+ * @param {Object} params
+ * @param {import('github-script').AsyncFunctionArguments["github"]} params.github
+ * @param {import('github-script').AsyncFunctionArguments["context"]} params.context
+ * @param {import('github-script').AsyncFunctionArguments["core"]} params.core
+ * @param {string} params.checkRunName
+ * @param {string} params.workflowName
+ */
+export async function verifyRunStatusImpl({github, context, core, checkRunName, workflowName}) {
+  if (context.eventName == "check_run") {
+    const contextRunName = context.payload.check_run.name;
+    if (contextRunName !== checkRunName) {
+      core.setFailed(`Check run name (${contextRunName}) does not match input: ${checkRunName}. Ensure job is filtering by github.event.check_run.name.`);
+      return;
+    }
+  }
+
+  const { head_sha } = await extractInputs(github, context, core);
+
+  let checkRun;
+  if (context.eventName == "check_run") {
+    checkRun = context.payload.check_run;
+  } else {
+    const checkRuns = await getCheckRuns(github, context, checkRunName, head_sha);
+    if (checkRuns.length === 0) {
+      if (context.eventName === "check_suite") { 
+        const message = `Could not locate check run ${checkRunName} in check suite ${context.payload.check_suite.app.name}. Ensure job is filtering by github.event.check_suite.app.name.`;
+        core.setFailed(message);
+        return;
+      }
+
+      core.notice(`No completed check run with name: ${checkRunName}. Not enough information to judge success or failure. Ending with success status.`);
+      return;
+    }
+
+    // Use the most recent check run
+    checkRun = checkRuns[0];
+  }
+
+  core.info(
+    `Check run name: ${checkRun.name}, conclusion: ${checkRun.conclusion}, URL: ${checkRun.html_url}`,
+  );
+  core.debug(`Check run: ${JSON.stringify(checkRun)}`);
+
+  let workflowRun;
+  if (context.eventName == "workflow_run") { 
+    workflowRun = context.payload.workflow_run;
+  } else {
+    const workflowRuns = await getWorkflowRuns(github, context, workflowName, head_sha);
+    if (workflowRuns.length === 0) {
+      core.notice(`No completed workflow run with name: ${workflowName}. Not enough information to judge success or failure. Ending with success status.`);
+      return;
+    }
+
+    // Use the most recent workflow run
+    workflowRun = workflowRuns[0];
+  }
+
+  core.info(
+    `Workflow run name: ${workflowRun.name}, conclusion: ${workflowRun.conclusion}, URL: ${workflowRun.html_url}`,
+  );
+  core.debug(`Workflow run: ${JSON.stringify(workflowRun)}`);
+
+  if (checkRun.conclusion !== workflowRun.conclusion) {
+    core.setFailed(
+      `Check run conclusion (${checkRun.conclusion}) does not match workflow run conclusion (${workflowRun.conclusion})`,
+    );
+    return;
+  }
+
+  core.notice(`Conclusions match for check run ${checkRunName} and workflow run ${workflowName}`);
+}
+
+/**
+ * Returns the check with the given checkRunName for the given ref.
+ * @param {import('github-script').AsyncFunctionArguments['github']} github
+ * @param {import('github-script').AsyncFunctionArguments['context']} context
+ * @param {string} checkRunName
+ * @param {string} ref
+ * @returns {Promise<CheckRuns>}
+ */
+export async function getCheckRuns(
+  github,
+  context,
+  checkRunName,
+  ref,
+) {
+  const result = await github.paginate(github.rest.checks.listForRef, {
+    ...context.repo,
+    ref: ref,
+    check_name: checkRunName,
+    status: "completed",
+    per_page: PER_PAGE_MAX,
+  });
+
+  // a and b will never be null because status is "completed"
+  /* v8 ignore next */
+  return result.sort((a, b) => compareDatesDescending(a.completed_at || '', b.completed_at || ''));
+}
+
+/**
+ * Returns the workflow run with the given workflowName for the given ref.
+ * @param {import('github-script').AsyncFunctionArguments['github']} github
+ * @param {import('github-script').AsyncFunctionArguments['context']} context
+ * @param {string} workflowName
+ * @param {string} ref
+ * @returns {Promise<WorkflowRuns>}
+ */
+export async function getWorkflowRuns(
+  github,
+  context,
+  workflowName,
+  ref,
+) {
+  const result = await github.paginate(
+    github.rest.actions.listWorkflowRunsForRepo,
+    {
+      ...context.repo,
+      head_sha: ref,
+      status: "completed",
+      per_page: PER_PAGE_MAX,
+    },
+  );
+
+  return result.filter((run) => run.name === workflowName).sort((a, b) => compareDatesDescending(a.updated_at, b.updated_at));
+}
+
+/**
+ * Compares two date strings in descending order.
+ * @param {string} a date string of the form "YYYY-MM-DDTHH:mm:ssZ"
+ * @param {string} b date string of the form "YYYY-MM-DDTHH:mm:ssZ"
+ * @returns 
+ */
+export function compareDatesDescending(a, b) {
+  return new Date(b).getTime() - new Date(a).getTime();
+}

.github/workflows/src/workflows.js

@@ -0,0 +1,23 @@
+import { PER_PAGE_MAX } from "./github.js";
+
+/**
+ * @param {import('github-script').AsyncFunctionArguments['github']} github
+ * @param {{ 
+ *   owner: string; 
+ *   repo: string; 
+ *   head_sha?: string; 
+ *   status?: "completed" | "in_progress" | "queued";
+ *   event?: string;
+ * }} params
+ * @returns {Promise<import("@octokit/plugin-rest-endpoint-methods").RestEndpointMethodTypes["actions"]["listWorkflowRunsForRepo"]["response"]["data"]["workflow_runs"]>}
+ */
+export async function listWorkflowRunsForRepo(github, { owner, repo, head_sha, status, event}) {
+  return await github.paginate(github.rest.actions.listWorkflowRunsForRepo, {
+    owner,
+    repo,
+    ...(head_sha && { head_sha }),
+    ...(status && { status }),
+    ...(event && { event }),
+    per_page: PER_PAGE_MAX,
+  });
+}

.github/workflows/test/mocks.js

@@ -48,12 +48,14 @@ export function createMockCore() {
   return {
     debug: vi.fn(console.debug),
     info: vi.fn(console.log),
+    notice: vi.fn(console.log),
     error: vi.fn(console.error),
     warning: vi.fn(console.warn),
     isDebug: vi.fn().mockReturnValue(true),
     setOutput: vi.fn((name, value) =>
       console.log(`setOutput('${name}', '${value}')`),
     ),
+    setFailed: vi.fn((msg) => console.log(`setFailed('${msg}')`)),
   };
 }