apify-test-tools 0.10.2-beta.2 → 0.10.2-beta.21

package/bin/main.ts

@@ -6,25 +6,14 @@ import yargs, { type Options } from 'yargs';
 // eslint-disable-next-line import/extensions --- With .js, it cannot find types
 import { hideBin } from 'yargs/helpers';
 
-import { deleteOldBuilds, runBuilds } from './build.js';
+import { getAffectedActors } from './affected-actors.js';
+import { buildActors, DEFAULT_VERSION_KEYWORD, deleteOldBuilds } from './build.js';
 import { runBuildsFromLocal } from './build-from-local.js';
-import { getChangedActors } from './diff-changes.js';
-import {
-    getBranchOnlyChangedFiles,
-    getChangedFiles,
-    getCommits,
-    getCurrentBranch,
-    getReleaseChanges,
-    getRepoName,
-    hasMergeFromTarget,
-    resolveReleaseBaseCommit,
-    resolveRepoUrl,
-} from './git.js';
 import { logger, logLevels } from './logger.js';
+import { notify, notifyOnChoices } from './notify.js';
 import { writeJson } from './output.js';
-import { notifyToSlack } from './slack.js';
-import { reportTestResults } from './test-report.js';
-import type { Config } from './types.js';
+import { runTests } from './run-tests.js';
+import { parseBuildInput, parseNotifyInput, parseTestTargets, readStdin } from './stdin-input.js';
 import { readConfigFile } from './utils/config/load-config.js';
 
 /**
@@ -34,18 +23,11 @@ const middlewares = [(args: { logLevel: (typeof logLevels)[number] }) => logger.
 
 /*
  * Option groups shared across commands. Each is a plain object passed to `.options()`, so a command's
- * builder composes them by chaining (`y.options(gitRangeOptions).options(actorSelectionOptions)`)
+ * builder composes them by chaining (`y.options(affectedRangeOptions).options(actorSelectionOptions)`)
  * instead of nesting wrapper functions. `as const` keeps literals like `demandOption: true` so yargs
  * can infer non-optional types; `satisfies` validates the shape without widening it.
  */
 
-/** Commit range to inspect: everything on `source-branch` since it diverged from `target-branch`. */
-const gitRangeOptions = {
-    'target-branch': { type: 'string', demandOption: true },
-    'source-branch': { type: 'string', demandOption: true },
-    'base-commit': { type: 'string', demandOption: false },
-} as const satisfies Record<string, Options>;
-
 /**
  * Where to build the Actors from. Defaults to the `origin` remote, which is then checked against each
  * Actor's default version. Passing it explicitly skips that check (see assertRepoUrlMatchesDefaultVersion).
@@ -57,13 +39,25 @@ const repoUrlOptions = {
 /**
  * Actor-selection flags, applied to every command that reads the actor config so a caller can
  * narrow the set it operates on (e.g. two-stage releases: `--ignore X`, then `--actors X`).
- * Kept separate from `gitRangeOptions` so the read-only git commands don't advertise flags they ignore.
- */
+ *  */
 const actorSelectionOptions = {
     actors: { type: 'string', array: true, default: [] as string[] },
     ignore: { type: 'string', array: true, default: [] as string[] },
 } as const satisfies Record<string, Options>;
 
+/**
+ * Commit range for get-affected-actors, which always ends at the checked-out HEAD. `base` and `since` combine:
+ * `base` alone is a branch's own commits (a PR), `since` alone is everything after a commit (a release), both is
+ * a branch after its last validated commit.
+ */
+const affectedRangeOptions = {
+    base: { type: 'string', describe: 'Only count commits on HEAD that are not on this branch' },
+    since: {
+        type: 'string',
+        describe: 'Only count commits after this one. Ignored with --base if it is not on the branch',
+    },
+} as const satisfies Record<string, Options>;
+
 /**
  * For commands that change something (builds, deletes, Slack posts). A dry run still does every read and check
  * the real run does, credentials included, and only skips the writes. So it needs the same tokens, though
@@ -77,9 +71,84 @@ const dryRunOptions = {
     },
 } as const satisfies Record<string, Options>;
 
-/** Flags for commands that trigger Apify builds. */
+/** Flags of `build`, which builds exactly the Actors it is given. */
 const buildOptions = {
-    'use-docker-cache': { type: 'boolean', default: false },
+    'version-number': {
+        type: 'string',
+        demandOption: true,
+        describe: `Version to build, like 0.1, or "${DEFAULT_VERSION_KEYWORD}" for each Actor's default version`,
+        coerce: (value: string) => {
+            if (value !== DEFAULT_VERSION_KEYWORD && !/^\d+\.\d+$/.test(value)) {
+                throw new Error(
+                    `--version-number must look like 0.1 or be "${DEFAULT_VERSION_KEYWORD}", got "${value}"`,
+                );
+            }
+            return value;
+        },
+    },
+} as const satisfies Record<string, Options>;
+
+/** For the commands that build a version other than the default one, see assertEnvVarsMatchDefaultVersion. */
+const envVarsSyncOptions = {
+    'require-env-vars-in-sync': {
+        type: 'boolean',
+        default: false,
+        describe: "Fail unless the built version's env var names match the default version's",
+    },
+} as const satisfies Record<string, Options>;
+
+/** Flags of `test`, which runs the repository's vitest on the Actors piped in, e.g. the builds from `build`. */
+const testOptions = {
+    'test-files-glob': {
+        type: 'string',
+        default: 'test/platform/**',
+        describe: 'Glob (from the repo root) of the test files to run. Quote it, so the shell does not expand it',
+    },
+    'vitest-output-file': { type: 'string', describe: "Also keep vitest's own JSON report there, e.g. to upload it" },
+    reporter: {
+        type: 'string',
+        describe:
+            'Vitest reporter (https://vitest.dev/guide/reporters) to add to `default` and `json`, which are always on, ' +
+            'e.g. github-actions. Repeat it for more',
+        // A plain string, not `array: true`: yargs would fill an array option with the arguments after it too. A
+        // repeated flag still comes as an array, a single one as a string, so both are normalized to an array.
+        coerce: (value: string | string[] | undefined) => (value === undefined ? [] : [value].flat()),
+    },
+} as const satisfies Record<string, Options>;
+
+/**
+ * Flags of `notify`, one target per call: posting to more places is calling it again. Some flags only fit one kind
+ * of input; `notify` fails on the others rather than ignoring them.
+ */
+const notifyOptions = {
+    'slack-channel': {
+        type: 'string',
+        describe: 'Slack channel to post to',
+        // yargs collects a repeated flag into an array, which would reach Slack as one comma-joined channel
+        coerce: (value: string | string[]) => {
+            if (Array.isArray(value)) {
+                throw new Error('--slack-channel takes one channel, call notify once for each channel');
+            }
+            return value;
+        },
+    },
+    on: {
+        choices: notifyOnChoices,
+        default: 'failure' as const,
+        describe: 'Tests only: notify only when tests fail, or always',
+    },
+    title: {
+        type: 'string',
+        describe: 'Tests only: what the message calls the run, e.g. the CI workflow name',
+    },
+    'job-url': {
+        type: 'string',
+        describe: 'Tests only: link to the CI job, included in the message',
+    },
+    'repo-url': {
+        type: 'string',
+        describe: 'Releases only: the repository the release is named after. Defaults to the origin remote',
+    },
 } as const satisfies Record<string, Options>;
 
 /** Global flags, available to every command. */
@@ -92,82 +161,10 @@ const globalOptions = {
     },
 } as const satisfies Record<string, Options>;
 
-const resolveChangedActors = async (config: Config, { isLatest }: { isLatest: boolean }) => {
-    const actorConfigs = await readConfigFile(config);
-
-    // This is an optimization for the common case where a branch only has cosmetic changes but had to smerge in
-    // functional changes from master (being up-to-date is a CI requirement). Master is already validated, and
-    // since the branch has no functional changes of its own, there is nothing new to validate.
-    // Exception: if the branch has any functional changes alongside the merge, we must re-test — even
-    // individually validated changes can have novel interactions when combined.
-    if (await hasMergeFromTarget(config.sourceBranch, config.targetBranch)) {
-        logger.info(
-            '[MERGE-FROM-TARGET-OPTIMIZATION]: There is merge from target branch, checking if there are no functional changes in our own branch. If so, we can skip tests',
-        );
-        const branchOnlyFiles = await getBranchOnlyChangedFiles(config.sourceBranch, config.targetBranch);
-        // Omit baseCommit to get full branch history. Validated functional commits can still interact with merged ones
-        const allBranchCommits = await getCommits({ ...config, baseCommit: undefined });
-        const branchOnlyActorsChanged = await getChangedActors({
-            filepathsChanged: branchOnlyFiles,
-            actorConfigs,
-            commits: allBranchCommits,
-            testFilesGlob: config.testFilesGlob,
-        });
-        if (branchOnlyActorsChanged.length === 0) {
-            logger.info('[MERGE-FROM-TARGET-OPTIMIZATION]: Branch itself has no functional changes, skipping tests');
-            return [];
-        }
-        logger.info(
-            `[MERGE-FROM-TARGET-OPTIMIZATION]: Branch has ${branchOnlyActorsChanged.length} functional changes, cannot optimize, we continue with full check`,
-        );
-    }
-
-    // If the optimization doesn't apply, we check all branch commits including merges for full coverage. We don't reuse the merge optimization results because here we can apply baseCommit and check merge commits (they might be functional or just cosmetic)
-    const commits = await getCommits(config);
-    const changedFiles = await getChangedFiles(commits);
-    return getChangedActors({
-        filepathsChanged: changedFiles,
-        actorConfigs,
-        isLatest,
-        commits,
-        testFilesGlob: config.testFilesGlob,
-    });
-};
-
 await yargs()
     .scriptName('public-actors-utils')
     .options(globalOptions)
     .middleware(middlewares)
-    .command(
-        'get-commits',
-        '',
-        (y) => y.options(gitRangeOptions),
-        async (args) => {
-            const commits = await getCommits(args);
-            writeJson(commits);
-        },
-    )
-    .command(
-        'get-latest-commit',
-        '',
-        (y) => y.options(gitRangeOptions),
-        async (args) => {
-            const commits = await getCommits(args);
-            if (commits.length > 0) {
-                writeJson(commits[commits.length - 1]);
-            }
-        },
-    )
-    .command(
-        'get-changed-files',
-        '',
-        (y) => y.options(gitRangeOptions),
-        async (args) => {
-            const commits = await getCommits(args);
-            const changedFiles = await getChangedFiles(commits);
-            writeJson(changedFiles);
-        },
-    )
     .command(
         'get-actor-configs',
         '',
@@ -179,115 +176,71 @@ await yargs()
     )
     .command(
         'get-affected-actors',
-        '',
-        (y) => y.options(gitRangeOptions).options(actorSelectionOptions),
-        async (config) => {
-            const actorsChanged = await resolveChangedActors(config, { isLatest: false });
-            writeJson(actorsChanged);
+        'Find the Actors whose context changed in a commit range ending at the checked-out HEAD',
+        (y) => y.options(affectedRangeOptions).options(actorSelectionOptions),
+        async (args) => {
+            writeJson(await getAffectedActors(args));
         },
     )
     .command(
-        'report-tests',
-        '',
-        (y) =>
-            y
-                .options(dryRunOptions)
-                .option('report-file', { type: 'string', demandOption: true })
-                .option('report-slack-channel', { type: 'string' })
-                .option('job-url', { type: 'string' })
-                .option('workflow-name', { type: 'string' }),
+        'test',
+        'Run the tests of the Actors listed on stdin (builds from build, or get-actor-configs for default builds), and print a report for notify',
+        (y) => y.options(testOptions),
         async (args) => {
-            await reportTestResults(args);
+            const report = await runTests({
+                testFilesGlob: args.testFilesGlob,
+                targets: parseTestTargets(await readStdin()),
+                vitestOutputFile: args.vitestOutputFile,
+                reporters: args.reporter,
+            });
+            writeJson(report);
+            // The report is printed either way, so `notify` later in the pipe still hears about the failure
+            if (!report.success) process.exitCode = 1;
         },
     )
     .command(
-        'build',
-        '',
-        (y) =>
-            y
-                .options(gitRangeOptions)
-                .options(actorSelectionOptions)
-                .options(buildOptions)
-                .options(repoUrlOptions)
-                .options(dryRunOptions)
-                .option('test-files-glob', { type: 'string' }),
-        async (config) => {
-            const actorsChanged = await resolveChangedActors(config, { isLatest: false });
-            const builds = await runBuilds({
-                ...(await resolveRepoUrl(config.repoUrl)),
-                actorConfigs: actorsChanged,
-                branch: config.sourceBranch.replace('origin/', ''),
-                dryRun: config.dryRun,
-                useDockerCache: config.useDockerCache,
+        'notify',
+        'Tell the target about a test run (the output of test) or a release (of get-affected-actors) on stdin',
+        (y) => y.options(notifyOptions).options(dryRunOptions),
+        async (args) => {
+            await notify({
+                input: parseNotifyInput(await readStdin()),
+                slackChannel: args.slackChannel,
+                on: args.on,
+                title: args.title,
+                jobUrl: args.jobUrl,
+                repoUrl: args.repoUrl,
+                dryRun: args.dryRun,
             });
-            writeJson(builds);
         },
     )
     .command(
-        'release',
-        '',
-        (y) =>
-            y
-                .options(actorSelectionOptions)
-                .options(buildOptions)
-                .options(repoUrlOptions)
-                .options(dryRunOptions)
-                // The last commit that is already released, everything after it up to HEAD gets released.
-                // Required, see the README section "Releasing Actors" for how to set it for each merge strategy.
-                .option('base-commit', { type: 'string', demandOption: true })
-                .option('report-slack-channel', { type: 'string' })
-                .option('release-slack-channel', { type: 'string' }),
+        'build',
+        'Build the Actors listed on stdin, as {"actors": [{"actorFullName": ...}]}, from the checked-out branch',
+        (y) => y.options(buildOptions).options(repoUrlOptions).options(envVarsSyncOptions).options(dryRunOptions),
         async (args) => {
-            const baseSha = await resolveReleaseBaseCommit(args.baseCommit);
-            const branch = await getCurrentBranch();
-            const changes = await getReleaseChanges(baseSha);
-            if (!changes) {
-                logger.info(`HEAD is the base commit ${baseSha}, there is nothing new to release`);
-                return;
-            }
-            const { commits, changedFiles, changelog } = changes;
-            const { repoUrl, shouldVerifyRepoUrl } = await resolveRepoUrl(args.repoUrl);
-
-            const isLatest = true;
-            const actorConfigs = await readConfigFile(args);
-            const actorsChanged = await getChangedActors({
-                filepathsChanged: changedFiles,
+            const input = parseBuildInput(await readStdin());
+            const names = input.actors.map(({ actorFullName }) => actorFullName);
+            // An empty --actors selects every Actor, but an empty list here means there is nothing to build. The configs
+            // are picked by name, so an Actor listed twice (e.g. in two lists of get-affected-actors) is built once
+            const actorConfigs = names.length > 0 ? await readConfigFile({ actors: names, ignore: [] }) : [];
+            const builds = await buildActors({
                 actorConfigs,
-                isLatest,
-                commits,
-            });
-            const { dryRun, reportSlackChannel, releaseSlackChannel } = args;
-            const builds = await runBuilds({
-                isLatest,
-                repoUrl,
-                shouldVerifyRepoUrl,
-                actorConfigs: actorsChanged,
-                branch,
-                dryRun,
-                useDockerCache: args.useDockerCache,
-            });
-            logger.info(JSON.stringify(builds));
-
-            await notifyToSlack({
-                changedFiles,
-                commits,
-                changelog,
-                repository: getRepoName(repoUrl),
-                dryRun,
-                // The newest commit, same as the pushed head commit
-                author: commits[commits.length - 1].author,
-                reportSlackChannel,
-                releaseSlackChannel,
+                versionNumber: args.versionNumber,
+                repoUrl: args.repoUrl,
+                dryRun: args.dryRun,
+                requireEnvVarsInSync: args.requireEnvVarsInSync,
             });
+            writeJson(builds);
         },
     )
     .command(
         'build-from-local',
         '',
-        (y) => y.options(actorSelectionOptions).options(dryRunOptions),
-        async ({ actors, ignore, dryRun }) => {
+        (y) => y.options(actorSelectionOptions).options(envVarsSyncOptions).options(dryRunOptions),
+        async ({ actors, ignore, dryRun, requireEnvVarsInSync }) => {
             const actorConfigs = await readConfigFile({ actors, ignore });
-            const builds = await runBuildsFromLocal({ actorConfigs, dryRun });
+            const builds = await runBuildsFromLocal({ actorConfigs, dryRun, requireEnvVarsInSync });
             writeJson(builds);
         },
     )

package/bin/notify.ts

@@ -0,0 +1,198 @@
+import { getCommitUrl, getRepoName, resolveRepoUrl } from './git.js';
+import { logger } from './logger.js';
+import { getSlackClient, sendingLabel, sendSlackMessage } from './slack.js';
+import type { NotifyInput, ReleaseChanges } from './stdin-input.js';
+import type { TestCaseReport, TestReport } from './test-report.js';
+
+export const notifyOnChoices = ['failure', 'always'] as const;
+type NotifyOn = (typeof notifyOnChoices)[number];
+
+interface Message {
+    text: string;
+    /** Posted in the message's thread, so a long list keeps the channel readable */
+    details: string[];
+}
+
+/**
+ * A place a notification goes, one per `notify` call: a caller with more places calls `notify` once for each. A
+ * target checks its credentials when it is created, before we know whether there is anything to send, so a broken
+ * token shows up on a green run (and in dry runs) rather than on the day tests fail. Slack is the only one for now;
+ * another (e.g. email) is one more factory next to `createSlackTarget`.
+ */
+interface NotificationTarget {
+    send(message: Message): Promise<void>;
+}
+
+const SLACK_TOKEN_ENV_VAR = 'SLACK_BOT_TOKEN';
+
+// Long enough for any sensible commit title, short enough that one runaway title doesn't swamp the message
+const MAX_COMMIT_TITLE_LENGTH = 200;
+
+interface NotifyOptions {
+    input: NotifyInput;
+    slackChannel?: string;
+    /** Tests only */
+    on: NotifyOn;
+    /** Tests only: what the message calls the run, e.g. the CI workflow name */
+    title?: string;
+    /** Tests only: link to the CI job, included in the message */
+    jobUrl?: string;
+    /** Releases only, names the release. Defaults to the `origin` remote, see resolveRepoUrl */
+    repoUrl?: string;
+    dryRun: boolean;
+}
+
+/** Tells the target about what is on stdin: a test run (the output of `test`) or a release (of `get-affected-actors`). */
+export const notify = async (options: NotifyOptions) => {
+    assertFlagsFitInput(options);
+    const { input, slackChannel, dryRun } = options;
+    // A target is created only once we know a message may go out, so a release with no commits needs no token
+    const createTarget = async () => {
+        if (!slackChannel) {
+            logger.info('Skipping notification, no --slack-channel passed');
+            return null;
+        }
+        return createSlackTarget(SLACK_TOKEN_ENV_VAR, slackChannel, dryRun);
+    };
+    if (input.kind === 'tests') {
+        await notifyTestReport({ ...options, report: input.report, createTarget });
+    } else {
+        await notifyRelease({ ...options, changes: input.changes, createTarget });
+    }
+};
+
+/** A flag the input has no use for would be dropped silently, so it fails instead: the caller meant something by it. */
+const assertFlagsFitInput = ({ input, on, title, jobUrl, repoUrl }: NotifyOptions) => {
+    const misfits =
+        input.kind === 'tests'
+            ? [repoUrl && '--repo-url']
+            : [on !== 'failure' && '--on', title && '--title', jobUrl && '--job-url'];
+    const passed = misfits.filter(Boolean);
+    if (passed.length > 0) {
+        const what =
+            input.kind === 'tests'
+                ? 'a test report (the output of test)'
+                : 'a release (the output of get-affected-actors)';
+        throw new Error(`${passed.join(', ')} can't be used with ${what} on stdin`);
+    }
+};
+
+type CreateTarget = () => Promise<NotificationTarget | null>;
+
+/** How a test run went: by default only when it failed, with `on: 'always'` always. */
+const notifyTestReport = async ({
+    report,
+    on,
+    title,
+    jobUrl,
+    createTarget,
+}: Pick<NotifyOptions, 'on' | 'title' | 'jobUrl'> & { report: TestReport; createTarget: CreateTarget }) => {
+    const target = await createTarget();
+    if (!target) return;
+    if (report.success && on === 'failure') {
+        logger.info('The tests passed, so there is nothing to notify about (pass --on always to notify anyway)');
+        return;
+    }
+
+    await target.send(formatTestMessage({ report, title: title ?? '-', jobUrl }));
+};
+
+/**
+ * What a release changed: its changelog additions, then its commits, each linked to its commit page. Posts nothing
+ * when there are no commits, which means there is nothing new to release.
+ */
+const notifyRelease = async ({
+    changes: { commits, changelog },
+    repoUrl,
+    createTarget,
+}: Pick<NotifyOptions, 'repoUrl'> & { changes: ReleaseChanges; createTarget: CreateTarget }) => {
+    if (commits.length === 0) {
+        logger.info('No new commits, so there is no release to announce');
+        return;
+    }
+    if (!changelog) {
+        logger.warn('No new changelog entries found, did you forget to update it?');
+    }
+    const target = await createTarget();
+    if (!target) return;
+
+    const resolvedRepoUrl = (await resolveRepoUrl(repoUrl)).repoUrl;
+    await target.send({ text: formatReleaseMessage({ commits, changelog }, resolvedRepoUrl), details: [] });
+};
+
+/** The release, named after the repository and the author of its newest commit, the pushed head. */
+export const formatReleaseMessage = ({ commits, changelog }: ReleaseChanges, repoUrl: string) => {
+    const { author } = commits[commits.length - 1];
+    let text = `*${getRepoName(repoUrl)}* – New release (by ${displayName(author)}):\n\n`;
+    if (changelog) text += `${changelog.trim()}\n\n`;
+    text += '*Commits*:\n';
+    text += commits
+        .map(({ sha, author: commitAuthor, message }, index) => {
+            const title =
+                message.length > MAX_COMMIT_TITLE_LENGTH
+                    ? `${message.slice(0, MAX_COMMIT_TITLE_LENGTH - 1)}…`
+                    : message;
+            const url = getCommitUrl(repoUrl, sha);
+            const linked = url ? `<${url}|${escapeSlack(title)}>` : escapeSlack(title);
+            return `${index + 1}. ${linked} – ${displayName(commitAuthor)}`;
+        })
+        .join('\n');
+    return text;
+};
+
+// Git authors come as "Name<email>", Slack only needs the name
+const displayName = (author: string) => author.replace(/\s*<[^>]*>$/, '');
+
+const createSlackTarget = async (
+    tokenEnvVar: string,
+    channel: string,
+    dryRun: boolean,
+): Promise<NotificationTarget> => {
+    const slack = await getSlackClient(tokenEnvVar, dryRun);
+    return {
+        async send({ text, details }) {
+            logger.info(`${sendingLabel(dryRun)} slack message to channel ${channel}:\n${text}`);
+            if (details.length > 0) logger.info(`\tin its thread:\n\t${details.join('\n\t')}`);
+            if (!dryRun) await sendSlackMessage(slack, channel, text, details);
+        },
+    };
+};
+
+// Slack reads these as markup, so they have to be escaped wherever text comes from the tests
+const escapeSlack = (text: string) => text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+
+/** One line per failure message, linked to the run that failed, if the test started one. */
+const formatFailures = ({ failureMessages, run }: TestCaseReport) => {
+    const link = run ? ` --- <${run.runLink}|${escapeSlack(run.actorId)}>` : '';
+    return failureMessages.map((message) => `${escapeSlack(message)}${link}`);
+};
+
+/**
+ * The message is the outcome and the first failure; the other failures go to its thread, so a channel with many
+ * failing runs stays readable.
+ */
+export const formatTestMessage = ({
+    report,
+    title,
+    jobUrl,
+}: {
+    report: TestReport;
+    title: string;
+    jobUrl?: string;
+}) => {
+    const { total, failed, passed } = report.summary;
+    const failedAssertions = report.tests.filter(({ status }) => status === 'failed').flatMap(formatFailures);
+    const failures = [...failedAssertions, ...report.errors.map((error) => `Error: ${escapeSlack(error)}`)];
+    const jobLink = jobUrl ? ` Check <${jobUrl}|the job>.` : '';
+
+    let text = `\`${escapeSlack(title)}\``;
+    if (report.success) {
+        text += `: all ${passed} tests passed.${jobLink}`;
+        return { text, details: [] };
+    }
+    text += `: has ${failedAssertions.length} failed assertions. Failing test suites: ${failed}/${total}.`;
+    if (report.errors.length > 0) text += ` Errors outside of tests: ${report.errors.length}.`;
+    text += jobLink;
+    if (failures.length > 0) text += `\n\n${failures[0]}`;
+    return { text, details: failures.slice(1).map((failure) => `• ${failure}`) };
+};