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

package/bin/run-tests.ts

@@ -0,0 +1,182 @@
+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 { resolveTestFilesGlob } from './test-files-glob.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`);
+        }
+    }
+};
+
+/**
+ * Turns the glob into vitest filters. Vitest filters are parts of a file path, not globs, so the glob is resolved here.
+ * The filters are the folders that hold only matched files and the other matched files one by one, so the command
+ * line stays short. They go to vitest as absolute paths. Vitest also matches their path relative to the root anywhere
+ * in a test file's path, so a copy at `dist/test/platform/a.test.ts` would run too: vitest's own `exclude` keeps such
+ * copies out.
+ */
+const resolveVitestFilters = async (testFilesGlob: string, cwd: string): Promise<string[]> => {
+    const { files, paths } = await resolveTestFilesGlob(testFilesGlob, cwd);
+    // Without filters vitest would run every test of the repo
+    if (files.length === 0) {
+        throw new Error(
+            `No files match --test-files-glob "${testFilesGlob}". The glob is relative to the repo root, e.g. "test/platform/**".`,
+        );
+    }
+    logger.info(`Running the ${files.length} file(s) that match --test-files-glob "${testFilesGlob}"`);
+    logger.debug(`Files: ${files.join(', ')}`);
+    // Vitest compares against real paths, and cwd can be a symlink (e.g. /tmp on macOS). join keeps a folder's
+    // trailing slash, which stops `test/platform/daily/` from also matching `test/platform/daily-without-pr/`.
+    const root = await fs.realpath(cwd);
+    return paths.map((filePath) => path.join(root, filePath));
+};
+
+interface RunTestsOptions {
+    /** Glob from the repo root (`cwd`) of the test files to run, e.g. `test/platform/**` */
+    testFilesGlob: 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 ({
+    testFilesGlob,
+    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);
+    const vitestFilters = await resolveVitestFilters(testFilesGlob, 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
+    // Lib versions before 0.9.0 read the IDs as actorName and actorId, so they are given under both names
+    env.ACTOR_BUILDS = JSON.stringify(
+        actorBuilds.map((build) => ({ ...build, actorName: build.actorFullName, actorId: build.actorRawId })),
+    );
+    // Lib versions before 0.10.0 skip every test in their `describe` unless this is set. Newer versions read
+    // TESTER_APIFY_TOKEN instead and ignore it. It only unlocks `describe`: which tests run still follows ACTOR_BUILDS.
+    env.RUN_PLATFORM_TESTS = '1';
+    // In those versions this runs the tests of every Actor, whatever ACTOR_BUILDS lists
+    delete env.RUN_ALL_PLATFORM_TESTS;
+    const described = actorBuilds.map(
+        ({ actorFullName, actorRawId, buildNumber }) =>
+            `${actorFullName ?? actorRawId} (${buildNumber ?? 'default build'})`,
+    );
+    logger.info(`Testing ${targets.length} Actor(s): ${described.join(', ') || 'none'}`);
+
+    const args = [
+        vitestBin,
+        'run',
+        ...vitestFilters,
+        '--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);
+        const { total, skipped } = report.summary;
+        if (targets.length !== 0 && total !== 0 && skipped === total) {
+            logger.warn(
+                `Every test was skipped, although ${targets.length} Actor(s) were given. Check that the tests name ` +
+                    'these Actors by their full name or raw ID.',
+            );
+        }
+        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,20 +1,8 @@
 import { WebClient } from '@slack/web-api';
 
 import { logger } from './logger.js';
-import type { Commit } from './types.js';
 import { getEnvVar } from './utils.js';
 
-type NotifyToSlackOptions = {
-    repository: string;
-    changedFiles: string[];
-    changelog: string | null;
-    commits: Commit[];
-    dryRun: boolean;
-    author: string;
-    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.
@@ -34,75 +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*<[^>]*>$/, '');
-
-export const notifyToSlack = async ({
-    changedFiles,
-    commits,
-    changelog,
-    repository,
-    dryRun,
-    author,
-    releaseSlackChannel,
-    reportSlackChannel,
-}: NotifyToSlackOptions) => {
-    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);
-
-    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',
+            })),
         });
     }
 };

package/bin/stdin-input.ts

@@ -0,0 +1,156 @@
+import process from 'node:process';
+
+import z, { prettifyError, type ZodType } from 'zod';
+
+export const readStdin = async (): Promise<string> => {
+    // Nothing piped in: fail right away instead of waiting for someone to type
+    if (process.stdin.isTTY) {
+        throw new Error('Expected JSON on stdin, but nothing was piped in.');
+    }
+    let raw = '';
+    for await (const chunk of process.stdin) {
+        raw += chunk;
+    }
+    return raw;
+};
+
+const parseStdinJson = <T>(
+    raw: string,
+    schema: ZodType<T>,
+    { expected, example }: { expected: string; example: string },
+) => {
+    // Empty input is an error, not "nothing to do": it is what a failed command earlier in the pipe leaves behind
+    if (!raw.trim()) {
+        throw new Error(`Expected ${expected} as JSON on stdin, got nothing (${example}).`);
+    }
+    let json: unknown;
+    try {
+        json = JSON.parse(raw);
+    } catch (error) {
+        throw new Error(`The input on stdin is not valid JSON: ${(error as Error).message}`);
+    }
+    return validateStdinJson(json, schema, { expected, example });
+};
+
+const validateStdinJson = <T>(
+    json: unknown,
+    schema: ZodType<T>,
+    { expected, example }: { expected: string; example: string },
+) => {
+    const result = schema.safeParse(json);
+    if (!result.success) {
+        throw new Error(`The input on stdin is not ${expected} (${example}):\n${prettifyError(result.error)}`);
+    }
+    return result.data;
+};
+
+/**
+ * What `build` reads: the Actors to build. Only their names are read, the config file stays the source of truth
+ * for everything else about them. Other fields are ignored, so a get-affected-actors document only needs its Actor
+ * list picked, e.g. `jq '{ actors: .functionallyChangedActors }'`.
+ */
+const buildInputSchema = z.object({
+    actors: z.array(z.object({ actorFullName: z.string() })),
+});
+
+export const parseBuildInput = (raw: string) =>
+    parseStdinJson(raw, buildInputSchema, {
+        expected: 'the Actors to build',
+        example: `e.g. echo '{"actors":[{"actorFullName":"owner/name"}]}' | apify-test-tools build --version-number 0.1`,
+    });
+
+/**
+ * What `test` reads: the Actors to test, each with the build to test or, without one, its default build. The builds
+ * `build` and `build-from-local` print fit, and so does `get-actor-configs`, whose other fields are ignored. An Actor
+ * needs its full name or its raw ID, `test` looks up the other. A dry-run plan is an object on purpose, so it is
+ * rejected here rather than tested as if it were built.
+ */
+const testTargetsSchema = z.array(
+    z
+        .object({
+            actorFullName: z.string().optional(),
+            buildId: z.string().optional(),
+            actorRawId: z.string().optional(),
+            buildNumber: z.string().optional(),
+        })
+        .refine(({ actorFullName, actorRawId }) => !!actorFullName || !!actorRawId, {
+            message: 'An Actor needs actorFullName or actorRawId',
+        }),
+);
+
+export type TestTarget = z.infer<typeof testTargetsSchema>[number];
+
+const isDryRunPlan = (raw: string) => {
+    try {
+        return (JSON.parse(raw) as { dryRun?: unknown } | null)?.dryRun === true;
+    } catch {
+        // Not JSON at all, parseStdinJson says so
+        return false;
+    }
+};
+
+export const parseTestTargets = (raw: string) => {
+    const example =
+        'e.g. ... | apify-test-tools build --version-number 0.99 | apify-test-tools test, ' +
+        "or apify-test-tools get-actor-configs | apify-test-tools test for every Actor's default build";
+    if (isDryRunPlan(raw)) {
+        throw new Error(`The input on stdin is a dry-run plan, not builds, so there is nothing to test (${example}).`);
+    }
+    return parseStdinJson(raw, testTargetsSchema, { expected: 'the Actors to test', example });
+};
+
+/** The report `test` prints, see TestReport. */
+const testRunSchema = z.object({ actorId: z.string(), runId: z.string(), runLink: z.string() });
+const testReportSchema = z.object({
+    kind: z.literal('test-report'),
+    version: z.literal(1),
+    success: z.boolean(),
+    summary: z.object({ total: z.number(), passed: z.number(), failed: z.number(), skipped: z.number() }),
+    tests: z.array(
+        z.object({
+            name: z.string(),
+            file: z.string(),
+            status: z.enum(['passed', 'failed', 'skipped']),
+            durationMs: z.number().nullable(),
+            failureMessages: z.array(z.string()),
+            run: testRunSchema.nullable(),
+        }),
+    ),
+    errors: z.array(z.string()),
+});
+
+/** The parts of a get-affected-actors document that describe what a release changed. Other fields are ignored. */
+const releaseChangesSchema = z.object({
+    commits: z.array(z.object({ sha: z.string(), author: z.string(), date: z.string(), message: z.string() })),
+    changelog: z.string().nullable(),
+});
+
+export type ReleaseChanges = z.infer<typeof releaseChangesSchema>;
+
+export type NotifyInput =
+    | { kind: 'tests'; report: z.infer<typeof testReportSchema> }
+    | { kind: 'release'; changes: ReleaseChanges };
+
+/**
+ * What `notify` reads: a test run, as `test` reports it, or a release, as `get-affected-actors` reports it. The test
+ * report says so in its `kind`, a release is told by its `commits`, so either can be piped in as it is.
+ */
+export const parseNotifyInput = (raw: string): NotifyInput => {
+    const example =
+        'e.g. ... | apify-test-tools test | apify-test-tools notify --slack-channel "#my-channel", ' +
+        'or apify-test-tools get-affected-actors --since <sha> | apify-test-tools notify --slack-channel "#my-channel"';
+    const expected = 'the output of test or get-affected-actors';
+    const json = parseStdinJson(raw, z.looseObject({}), { expected, example });
+    if (json.kind === 'test-report') {
+        const report = validateStdinJson(json, testReportSchema, { expected: 'the output of test', example });
+        return { kind: 'tests', report };
+    }
+    if ('commits' in json) {
+        const changes = validateStdinJson(json, releaseChangesSchema, {
+            expected: 'the output of get-affected-actors',
+            example,
+        });
+        return { kind: 'release', changes };
+    }
+    throw new Error(`The input on stdin is not ${expected} (${example}).`);
+};

package/bin/test-files-glob.ts

@@ -0,0 +1,126 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import picomatch from 'picomatch';
+
+/**
+ * Test globs are from the repo root, e.g. `test/platform/**`. `get-affected-actors` matches changed files against the
+ * config's `platformTestsGlob` and `test` runs the files `--test-files-glob` matches, so both read globs the same way.
+ */
+const PICOMATCH_OPTIONS = { nocase: true, dot: true } as const;
+
+/** Never walked: they hold no test files of the repo, and node_modules can be huge. */
+const SKIPPED_DIRS = new Set(['node_modules', '.git']);
+
+const assertRelativeGlob = (glob: string) => {
+    if (path.posix.isAbsolute(glob) || path.win32.isAbsolute(glob)) {
+        throw new Error(`Test file globs must be relative to the repo root, got "${glob}".`);
+    }
+};
+
+/** Tells whether a repo-root-relative path matches the glob. Without a glob, nothing matches. */
+export const createTestFilesMatcher = (glob?: string): ((filePath: string) => boolean) => {
+    if (!glob) return () => false;
+    assertRelativeGlob(glob);
+    const isMatch = picomatch(glob, PICOMATCH_OPTIONS);
+    // One argument only: picomatch's second one returns a truthy object, and Array#filter passes the index there
+    return (filePath) => isMatch(filePath);
+};
+
+interface Listing {
+    /** POSIX paths relative to `cwd` */
+    files: string[];
+    /** What wasn't walked (skipped directories, symlinks), so the folders holding them never count as fully matched */
+    skipped: string[];
+}
+
+/** Lists the files under `dir`. A missing `dir` has no files. */
+const listFiles = async (cwd: string, dir: string): Promise<Listing> => {
+    let entries;
+    try {
+        entries = await fs.readdir(path.join(cwd, dir), { withFileTypes: true });
+    } catch (error) {
+        const { code } = error as NodeJS.ErrnoException;
+        if (code === 'ENOENT') return { files: [], skipped: [] };
+        // A glob without wildcards has the file itself as its base
+        if (code === 'ENOTDIR') return { files: [dir], skipped: [] };
+        throw error;
+    }
+    const listing: Listing = { files: [], skipped: [] };
+    for (const entry of entries) {
+        const entryPath = path.posix.join(dir, entry.name);
+        if (entry.isDirectory() && !SKIPPED_DIRS.has(entry.name)) {
+            const inner = await listFiles(cwd, entryPath);
+            listing.files.push(...inner.files);
+            listing.skipped.push(...inner.skipped);
+        } else if (entry.isFile()) {
+            listing.files.push(entryPath);
+        } else {
+            listing.skipped.push(entryPath);
+        }
+    }
+    return listing;
+};
+
+const isWithin = (dir: string, base: string) => base === '.' || dir === base || dir.startsWith(`${base}/`);
+
+/**
+ * The directories from `base` down to the file's own directory, `base` first. None when `base` is the file itself,
+ * as for a glob without wildcards.
+ */
+const dirsFromBase = (file: string, base: string): string[] => {
+    const dirs: string[] = [];
+    for (let dir = path.posix.dirname(file); isWithin(dir, base); dir = path.posix.dirname(dir)) {
+        dirs.unshift(dir);
+        if (dir === base || dir === '.') break;
+    }
+    return dirs;
+};
+
+/**
+ * Turns the matched files into as few paths as possible: a directory, with a trailing `/`, where the glob matches
+ * every file in it, and a single file otherwise. `test/platform/{daily,hourly}/**` gives two paths however many
+ * tests the folders hold, so the vitest command line stays short.
+ */
+const toCoveringPaths = ({ files, skipped }: Listing, matched: Set<string>, base: string): string[] => {
+    const counts = new Map<string, { total: number; matched: number }>();
+    for (const file of [...files, ...skipped]) {
+        for (const dir of dirsFromBase(file, base)) {
+            const count = counts.get(dir) ?? { total: 0, matched: 0 };
+            count.total += 1;
+            if (matched.has(file)) count.matched += 1;
+            counts.set(dir, count);
+        }
+    }
+    const isCovered = (dir: string) => counts.get(dir)!.total === counts.get(dir)!.matched;
+    const paths = new Set<string>();
+    for (const file of matched) {
+        // The highest directory that holds only matched files, so its children are not listed one by one
+        const coveredDir = dirsFromBase(file, base).find(isCovered);
+        paths.add(coveredDir === undefined ? file : `${coveredDir}/`);
+    }
+    return [...paths].sort();
+};
+
+interface ResolvedTestFiles {
+    /** Every file the glob matches, as repo-root-relative POSIX paths, sorted */
+    files: string[];
+    /**
+     * The same files as few paths as possible: directories (ending with `/`) that hold only matched files, and the
+     * other matched files one by one. Sorted.
+     */
+    paths: string[];
+}
+
+/**
+ * Finds the files the glob matches. `cwd` is the repo root. Only the glob's static base (`test/platform` for
+ * `test/platform/{daily,hourly}/**`) is walked.
+ */
+export const resolveTestFilesGlob = async (glob: string, cwd: string): Promise<ResolvedTestFiles> => {
+    const isMatch = createTestFilesMatcher(glob);
+    // normalize turns `./test` into `test`, the way git prints paths
+    const base = path.posix.normalize(picomatch.scan(glob).base || '.');
+    const listing = await listFiles(cwd, base);
+    const files = listing.files.filter(isMatch).sort();
+    return { files, paths: toCoveringPaths(listing, new Set(files), base) };
+};