[DRAFT] ci: prep builds

.github/scripts/git-diff-default-branch.ts

@@ -0,0 +1,171 @@
+import { exec as execCallback } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { promisify } from 'util';
+import { context } from '@actions/github';
+import * as core from '@actions/core';
+
+const exec = promisify(execCallback);
+
+// Get PR number from GitHub Actions environment variables
+const PR_NUMBER = context.payload.pull_request?.number;
+
+const GITHUB_DEFAULT_BRANCH = 'main';
+const SOURCE_BRANCH = PR_NUMBER ? `refs/pull/${PR_NUMBER}/head` : '';
+
+const CHANGED_FILES_DIR = 'changed-files';
+
+type PRInfo = {
+  base: {
+    ref: string;
+  };
+  body: string;
+  labels: { name: string }[];
+};
+
+/**
+ * Get JSON info about the given pull request using Octokit
+ *
+ * @returns PR information from GitHub
+ */
+async function getPrInfo(): Promise<PRInfo | null> {
+  if (!PR_NUMBER) {
+    return null;
+  }
+
+  const { owner, repo } = context.repo;
+
+  const response = await fetch(
+    `https://api.github.com/repos/${owner}/${repo}/pulls/${PR_NUMBER}`,
+    {
+      headers: {
+        'Authorization': `token ${process.env.GITHUB_TOKEN}`,
+        'Accept': 'application/vnd.github.v3+json'
+      }
+    }
+  );
+
+  return await response.json();
+}
+
+/**
+ * Fetches the git repository with a specified depth.
+ *
+ * @param depth - The depth to use for the fetch command.
+ * @returns True if the fetch is successful, otherwise false.
+ */
+async function fetchWithDepth(depth: number): Promise<boolean> {
+  try {
+    await exec(`git fetch --depth ${depth} origin "${GITHUB_DEFAULT_BRANCH}"`);
+    if (SOURCE_BRANCH) {
+      await exec(
+        `git fetch --depth ${depth} origin "${SOURCE_BRANCH}:${SOURCE_BRANCH}"`,
+      );
+    }
+    return true;
+  } catch (error: unknown) {
+    core.warning(`Failed to fetch with depth ${depth}:`, error);
+    return false;
+  }
+}
+
+/**
+ * Attempts to fetch the necessary commits until the merge base is found.
+ * It tries different fetch depths and performs a full fetch if needed.
+ *
+ * @throws If an unexpected error occurs during the execution of git commands.
+ */
+async function fetchUntilMergeBaseFound() {
+  const depths = [1, 10, 100];
+  for (const depth of depths) {
+    core.info(`Attempting git diff with depth ${depth}...`);
+    await fetchWithDepth(depth);
+
+    try {
+      await exec(`git merge-base origin/${GITHUB_DEFAULT_BRANCH} HEAD`);
+      return;
+    } catch (error: unknown) {
+      if (error instanceof Error && 'code' in error) {
+        core.warning(
+          `Error 'no merge base' encountered with depth ${depth}. Incrementing depth...`,
+        );
+      } else {
+        throw error;
+      }
+    }
+  }
+  await exec(`git fetch --unshallow origin "${GITHUB_DEFAULT_BRANCH}"`);
+}
+
+/**
+ * Performs a git diff command to get the list of files changed between the current branch and the origin.
+ * It first ensures that the necessary commits are fetched until the merge base is found.
+ *
+ * @returns The output of the git diff command, listing the file paths with status (A, M, D).
+ * @throws If unable to get the diff after fetching the merge base or if an unexpected error occurs.
+ */
+async function gitDiff(): Promise<string> {
+  await fetchUntilMergeBaseFound();
+  const { stdout: diffResult } = await exec(
+    `git diff --name-status "origin/${GITHUB_DEFAULT_BRANCH}...${SOURCE_BRANCH || 'HEAD'}"`
+  );
+  if (!diffResult) {
+    throw new Error('Unable to get diff after full checkout.');
+  }
+  return diffResult;
+}
+
+function writePrBodyAndInfoToFile(prInfo: PRInfo) {
+  const prBodyPath = path.resolve(CHANGED_FILES_DIR, 'pr-body.txt');
+  const labels = prInfo.labels.map(label => label.name).join(', ');
+  const updatedPrBody = `PR labels: {${labels}}\nPR base: {${prInfo.base.ref}}\n${prInfo.body.trim()}`;
+  fs.writeFileSync(prBodyPath, updatedPrBody);
+  core.info(`PR body and info saved to ${prBodyPath}`);
+}
+
+/**
+ * Main run function, stores the output of git diff and the body of the matching PR to a file.
+ *
+ * @returns Returns a promise that resolves when the git diff output and PR body is successfully stored.
+ */
+async function storeGitDiffOutputAndPrBody() {
+  try {
+    // Create the directory
+    fs.mkdirSync(CHANGED_FILES_DIR, { recursive: true });
+
+    core.info(`Determining whether to run git diff...`);
+    if (!PR_NUMBER) {
+      core.info('Not a PR, skipping git diff');
+      return;
+    }
+
+    const prInfo = await getPrInfo();
+
+    const baseRef = prInfo?.base.ref;
+    if (!baseRef) {
+      core.info('Not a PR, skipping git diff');
+      return;
+    }
+    // We perform git diff even if the PR base is not main or skip-e2e-quality-gate label is applied
+    // because we rely on the git diff results for other jobs
+    core.info('Attempting to get git diff...');
+    const diffOutput = await gitDiff();
+    core.info(diffOutput);
+
+    // Store the output of git diff
+    const outputPath = path.resolve(CHANGED_FILES_DIR, 'changed-files.txt');
+    fs.writeFileSync(outputPath, diffOutput.trim());
+    core.info(`Git diff results saved to ${outputPath}`);
+
+    writePrBodyAndInfoToFile(prInfo);
+
+    core.info('success', 'true');
+  } catch (error: any) {
+    core.setFailed(`Failed to process git diff: ${error.message}`);
+  }
+}
+
+// If main module (i.e. this is the TS file that was run directly)
+if (require.main === module) {
+  storeGitDiffOutputAndPrBody();
+}

.github/scripts/test-run-e2e-timeout-minutes.ts

@@ -0,0 +1,29 @@
+import { filterE2eChangedFiles, readChangedAndNewFilesWithStatus, getChangedAndNewFiles } from '../../test/e2e/changedFilesUtil';
+
+function computeTimeout(): number {
+  let timeout: number;
+
+  // Use the GitHub Action provided timeout if it exists
+  if (process.env.TIMEOUT) {
+    timeout = parseInt(process.env.TIMEOUT, 10);
+  } else {
+    // Calculate timeout based on changed files:
+    // Read the changed/new files and filter for e2e tests
+    const changedAndNewFilesWithStatus = readChangedAndNewFilesWithStatus();
+    const changedAndNewFiles = getChangedAndNewFiles(changedAndNewFilesWithStatus);
+    const changedOrNewTests = filterE2eChangedFiles(changedAndNewFiles);
+
+    // Base timeout of 20 minutes plus 3 minutes per changed file, capped at 30 minutes
+    timeout = Math.min(20 + changedOrNewTests.length * 3, 30);
+  }
+
+  // Optionally, adjust timeout for merge queue scenarios.
+  // For example, if the branch reference starts with 'refs/heads/gh-readonly-queue', add 10 minutes.
+  if (process.env.GITHUB_REF?.startsWith('refs/heads/gh-readonly-queue')) {
+    timeout += 10;
+  }
+
+  return timeout;
+}
+
+console.log(computeTimeout());

.github/scripts/test-run-e2e.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+
+set -e
+set -u
+set -o pipefail
+
+# Skip running e2e tests if the HEAD commit is tagged correctly
+if git show --format='%B' --no-patch "$GITHUB_SHA" | grep --fixed-strings --quiet '[skip e2e]'
+then
+    printf '%s\n' "$GITHUB_SHA contains the tag '[skip e2e]' so e2e tests will not run"
+    exit 1
+fi
+
+TIMEOUT_MINUTES=$(yarn tsx .github/scripts/test-run-e2e-timeout-minutes.ts)
+echo "TIMEOUT_MINUTES: $TIMEOUT_MINUTES"
+
+# Run the actual test command from the parameters
+timeout "${TIMEOUT_MINUTES}"m "$@" --retries 1
+
+# Error code 124 means the command timed out
+if [ $? -eq 124 ]
+then
+  echo 'Timeout error, deleting the test results'
+  rm -rf test/test-results/e2e
+  exit 124
+fi
+
+exit 0

.github/scripts/validate-e2e-page-object-usage.ts

@@ -11,7 +11,7 @@ import {
 async function verifyE2ePageObjectsUsage(fileStatus: 'M' | 'A' | 'both') {
     let e2eFiles: string[];
 
-    if (process.env.GITHUB_ACTIONS) {
+    if (process.env.GITHUB_ACTION) {
         // Running in Github Actions
         const branch = process.env.BRANCH || '';
         const headCommitHash = process.env.HEAD_COMMIT_HASH || '';