apify-test-tools 0.10.2-beta.13 → 0.10.2-beta.15

package/bin/main.ts

@@ -9,12 +9,11 @@ import { hideBin } from 'yargs/helpers';
 import { getAffectedActors } from './affected-actors.js';
 import { buildActors, DEFAULT_VERSION_KEYWORD, deleteOldBuilds } from './build.js';
 import { runBuildsFromLocal } from './build-from-local.js';
-import { getChangedFiles, getCommits } 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 { parseBuildInput, parseReleaseChanges, readStdin } from './stdin-input.js';
-import { reportTestResults } from './test-report.js';
+import { runTests } from './run-tests.js';
+import { parseBuildInput, parseNotifyInput, parseTestTargets, readStdin } from './stdin-input.js';
 import { readConfigFile } from './utils/config/load-config.js';
 
 /**
@@ -24,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).
@@ -47,8 +39,7 @@ 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[] },
@@ -110,10 +101,54 @@ const envVarsSyncOptions = {
     },
 } as const satisfies Record<string, Options>;
 
-/** Where `notify-release` posts the release. */
-const releaseSlackOptions = {
-    'report-slack-channel': { type: 'string', describe: 'Channel for the full report: commits and changed files' },
-    'release-slack-channel': { type: 'string', describe: 'Channel for the changelog additions only' },
+/** Flags of `test`, which runs the repository's vitest on the Actors piped in, e.g. the builds from `build`. */
+const testOptions = {
+    '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, so
+        // `test --reporter github-actions test/platform` would take the test path as a reporter. 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. */
@@ -130,36 +165,6 @@ 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',
         '',
@@ -178,17 +183,43 @@ await yargs()
         },
     )
     .command(
-        'report-tests',
-        '',
+        'test [filters..]',
+        '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(dryRunOptions)
-                .option('report-file', { type: 'string', demandOption: true })
-                .option('report-slack-channel', { type: 'string' })
-                .option('job-url', { type: 'string' })
-                .option('workflow-name', { type: 'string' }),
+                .positional('filters', {
+                    type: 'string',
+                    array: true,
+                    default: ['test/platform'],
+                    describe: 'Test files to run, as vitest filters',
+                })
+                .options(testOptions),
+        async (args) => {
+            const report = await runTests({
+                filters: args.filters,
+                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(
+        '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 reportTestResults(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,
+            });
         },
     )
     .command(
@@ -210,23 +241,6 @@ await yargs()
             writeJson(builds);
         },
     )
-    .command(
-        'notify-release',
-        'Announce a release on Slack, from the get-affected-actors output on stdin',
-        (y) => y.options(releaseSlackOptions).options(repoUrlOptions).options(dryRunOptions),
-        async (args) => {
-            const { commits, changedFiles, changelog } = parseReleaseChanges(await readStdin());
-            await notifyToSlack({
-                commits,
-                changedFiles,
-                changelog,
-                repoUrl: args.repoUrl,
-                dryRun: args.dryRun,
-                reportSlackChannel: args.reportSlackChannel,
-                releaseSlackChannel: args.releaseSlackChannel,
-            });
-        },
-    )
     .command(
         'build-from-local',
         '',

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}`) };
+};

package/bin/run-tests.ts

@@ -0,0 +1,141 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { createInterface } from 'node:readline';
+
+import { withActorIds } from './actor-ids.js';
+import { logger } from './logger.js';
+import type { TestTarget } from './stdin-input.js';
+import { failedRunReport, logTestReport, type TestReport, toTestReport, type VitestJsonReport } from './test-report.js';
+
+/**
+ * Finds the vitest the repository installed, the way Node would resolve it from `cwd`. The CLI ships as a bundle
+ * that runs outside the repository's `node_modules`, so the tests keep the vitest (and the lib) version the
+ * repository locked. Read from `package.json` because vitest's exports don't expose its bin.
+ */
+const resolveVitestBin = async (cwd: string): Promise<string> => {
+    for (let dir = path.resolve(cwd); ; dir = path.dirname(dir)) {
+        const packageDir = path.join(dir, 'node_modules', 'vitest');
+        if (existsSync(path.join(packageDir, 'package.json'))) {
+            const { bin } = JSON.parse(await fs.readFile(path.join(packageDir, 'package.json'), 'utf8'));
+            return path.join(packageDir, typeof bin === 'string' ? bin : bin.vitest);
+        }
+        if (path.dirname(dir) === dir) {
+            throw new Error(`vitest is not installed in ${cwd}, install the repository's dependencies first`);
+        }
+    }
+};
+
+interface RunTestsOptions {
+    /** Vitest file filters, e.g. `test/platform/core` */
+    filters: string[];
+    /** The Actors to test, each with its build or, without one, its default build */
+    targets: TestTarget[];
+    /** Keeps vitest's own JSON report there, e.g. to upload it */
+    vitestOutputFile?: string;
+    /** Vitest reporters to add to the default one and the JSON one the report is read from, e.g. `github-actions` */
+    reporters?: string[];
+    cwd?: string;
+}
+
+/**
+ * Runs the repository's vitest on the given builds and returns what happened as a `TestReport`. Vitest's own output
+ * goes to stderr, so stdout stays free for the report. A failing test or a crashing vitest is a failed report, not
+ * an error: the report is how the failure gets to `notify`.
+ */
+export const runTests = async ({
+    filters,
+    targets,
+    vitestOutputFile,
+    reporters = [],
+    cwd = process.cwd(),
+}: RunTestsOptions): Promise<TestReport> => {
+    // Without it the lib skips every platform test, and a run that tested nothing would pass
+    if (!process.env.TESTER_APIFY_TOKEN) {
+        throw new Error('TESTER_APIFY_TOKEN is not set. The platform tests need it to run the Actors.');
+    }
+    const vitestBin = await resolveVitestBin(cwd);
+    // A test only runs when the ID it names its Actor by is listed, so each Actor gets both its full name and raw ID
+    const actorBuilds = await withActorIds(targets);
+
+    const tempDir = vitestOutputFile ? null : await fs.mkdtemp(path.join(os.tmpdir(), 'apify-test-tools-'));
+    const outputFile = path.resolve(cwd, vitestOutputFile ?? path.join(tempDir!, 'vitest-report.json'));
+    // A report left over from an earlier run must not pass for this one's
+    await fs.rm(outputFile, { force: true });
+
+    // Stdin is the only source of what to test, so whatever the caller's environment holds doesn't leak into the tests
+    const env = { ...process.env };
+    // Vitest writes to a pipe, so it would drop colors that the terminal it ends up in shows
+    if (process.stderr.isTTY && env.FORCE_COLOR === undefined && env.NO_COLOR === undefined) env.FORCE_COLOR = '1';
+    // The lib runs the tests of the Actors listed here, each on the build given, or on its default build without one
+    env.ACTOR_BUILDS = JSON.stringify(actorBuilds);
+    const described = actorBuilds.map(
+        ({ actorFullName, buildNumber }) => `${actorFullName} (${buildNumber ?? 'default build'})`,
+    );
+    logger.info(`Testing ${targets.length} Actor(s): ${described.join(', ') || 'none'}`);
+
+    const args = [
+        vitestBin,
+        'run',
+        ...filters,
+        '--reporter=default',
+        '--reporter=json',
+        ...reporters.map((reporter) => `--reporter=${reporter}`),
+        `--outputFile.json=${outputFile}`,
+        // Platform tests mostly wait on Actor runs, not on the CPU, so they run far more at once than vitest's defaults
+        '--maxConcurrency=20',
+        '--fileParallelism',
+        '--maxWorkers=100',
+    ];
+    logger.debug(`Running vitest: ${args.join(' ')}`);
+
+    try {
+        const exitCode = await spawnVitest(args, { cwd, env });
+        let vitestReport: VitestJsonReport;
+        try {
+            vitestReport = JSON.parse(await fs.readFile(outputFile, 'utf8'));
+        } catch (error) {
+            logger.debug(`Could not read the vitest report: ${(error as Error).message}`);
+            const report = failedRunReport(
+                `Vitest exited with code ${exitCode} without a report, see its output above`,
+            );
+            logTestReport(report);
+            return report;
+        }
+        const report = toTestReport(vitestReport, { cwd, exitCode });
+        logTestReport(report);
+        return report;
+    } finally {
+        if (tempDir) await fs.rm(tempDir, { recursive: true, force: true });
+    }
+};
+
+/** Resolves with vitest's exit code. Signals we get (a cancelled CI job) are passed on, so vitest can clean up. */
+const spawnVitest = async (args: string[], { cwd, env }: { cwd: string; env: NodeJS.ProcessEnv }) =>
+    new Promise<number>((resolve, reject) => {
+        // Vitest's stdout goes to our stderr: stdout is reserved for the report. It is piped through us rather than
+        // handed over, to leave out the JSON reporter's note about the temporary file it wrote.
+        const child = spawn(process.execPath, args, { cwd, env, stdio: ['ignore', 'pipe', 2] });
+        createInterface({ input: child.stdout!, crlfDelay: Infinity }).on('line', (line) => {
+            if (!line.startsWith('JSON report written to ')) process.stderr.write(`${line}\n`);
+        });
+        const forward = (signal: NodeJS.Signals) => child.kill(signal);
+        process.on('SIGINT', forward);
+        process.on('SIGTERM', forward);
+        const cleanup = () => {
+            process.off('SIGINT', forward);
+            process.off('SIGTERM', forward);
+        };
+        child.on('error', (error) => {
+            cleanup();
+            reject(new Error(`Failed to start vitest: ${error.message}`));
+        });
+        child.on('close', (code, signal) => {
+            cleanup();
+            if (signal) logger.warn(`Vitest was stopped by ${signal}`);
+            resolve(code ?? 1);
+        });
+    });

package/bin/slack.ts

@@ -1,21 +1,8 @@
 import { WebClient } from '@slack/web-api';
 
-import { getRepoName, resolveRepoUrl } from './git.js';
 import { logger } from './logger.js';
-import type { Commit } from './types.js';
 import { getEnvVar } from './utils.js';
 
-type NotifyToSlackOptions = {
-    changedFiles: string[];
-    changelog: string | null;
-    commits: Commit[];
-    // Defaults to the `origin` remote, see resolveRepoUrl
-    repoUrl?: string;
-    dryRun: boolean;
-    releaseSlackChannel?: string;
-    reportSlackChannel?: string;
-};
-
 /**
  * Creates the client the real run posts with. A dry run posts nothing but still requires the token and checks
  * Slack accepts it (`auth.test` is read-only), so it fails wherever the real run would.
@@ -35,85 +22,27 @@ export const getSlackClient = async (tokenEnvVar: string, dryRun: boolean): Prom
 
 export const sendingLabel = (dryRun: boolean) => (dryRun ? '[DRY RUN] Would send' : 'Sending');
 
-// Git authors come as "Name<email>", Slack only needs the name
-const displayName = (author: string) => author.replace(/\s*<[^>]*>$/, '');
-
-/**
- * Posts what a release changed: its commits, changed files and changelog, as get-affected-actors reports them.
- * Posts nothing when there are no commits, which means there is nothing new to release.
- */
-export const notifyToSlack = async ({
-    changedFiles,
-    commits,
-    changelog,
-    repoUrl,
-    dryRun,
-    releaseSlackChannel,
-    reportSlackChannel,
-}: NotifyToSlackOptions) => {
-    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?');
-    }
-
-    if (!releaseSlackChannel && !reportSlackChannel) {
-        logger.info('Skipping slack notification, no --release-slack-channel or --report-slack-channel passed');
-        return;
-    }
-    const slack = await getSlackClient('SLACK_TOKEN_RELEASES_BOT', dryRun);
-
-    const repository = getRepoName((await resolveRepoUrl(repoUrl)).repoUrl);
-    // The newest commit, same as the pushed head commit
-    const { author } = commits[commits.length - 1];
-    let shortMessage = `*${repository}* – New release (by ${displayName(author)}):\n\n`;
-
-    // This one is just for broader public that only cares about public facing changes
-    if (changelog && releaseSlackChannel) {
-        shortMessage += `*Additions to the changelog*:\n\n${changelog}\n`;
-        logger.info(`=========================================`);
-        logger.info(`**${sendingLabel(dryRun)} slack message to channel**: ${releaseSlackChannel}.\n\n${shortMessage}`);
-        logger.info(`=========================================`);
-        if (!dryRun) {
-            await slack.chat.postMessage({
-                channel: releaseSlackChannel,
-                text: shortMessage,
-            });
-        }
-    }
-
-    const commitsMessage = `${commits
-        .map(
-            ({ author: commitAuthor, message }, index) =>
-                `${index + 1}. Commit message: ${message}\n\tAuthor: ${displayName(commitAuthor)}.`,
-        )
-        .join('\n')}`;
-    const changedFilesMessage = `*Files changed*: ${changedFiles.map((file) => `\`${file}\``).join(', ')}`;
-    const longMessage = `${shortMessage}\n*Commit list*:\n${commitsMessage}\n\n${changedFilesMessage}`;
-
-    // This one is for devs and project managers that need to know more details
-    if (reportSlackChannel) {
-        logger.info(`=========================================`);
-        logger.info(`${sendingLabel(dryRun)} slack message to channel: ${reportSlackChannel}.\n\n${longMessage}`);
-        logger.info(`=========================================`);
-        if (!dryRun) {
-            await slack.chat.postMessage({
-                text: longMessage,
-                channel: reportSlackChannel,
-            });
-        }
-    }
-};
+// Slack's limits: 50 blocks per message, 3000 characters per section
+const MAX_BLOCKS_PER_MESSAGE = 50;
+const MAX_SECTION_LENGTH = 3000;
 
-export const sendSlackMessage = async (slack: WebClient, channel: string, text: string, blocks: string[]) => {
+/** Posts `text`, with `details` as sections in its thread, as many replies as Slack's block limit needs. */
+export const sendSlackMessage = async (slack: WebClient, channel: string, text: string, details: string[]) => {
     const { ts } = await slack.chat.postMessage({ text, channel });
-    if (blocks.length > 0 && ts) {
+    if (!ts) return;
+    for (let i = 0; i < details.length; i += MAX_BLOCKS_PER_MESSAGE) {
+        const sections = details.slice(i, i + MAX_BLOCKS_PER_MESSAGE);
         await slack.chat.postMessage({
             channel,
             thread_ts: ts,
-            blocks: blocks.map((t) => ({ text: { type: 'mrkdwn', text: t }, type: 'section' })),
+            text: sections.join('\n').slice(0, MAX_SECTION_LENGTH),
+            blocks: sections.map((t) => ({
+                text: {
+                    type: 'mrkdwn',
+                    text: t.length > MAX_SECTION_LENGTH ? `${t.slice(0, MAX_SECTION_LENGTH - 1)}…` : t,
+                },
+                type: 'section',
+            })),
         });
     }
 };