apify-test-tools 0.10.2-beta.19 → 0.10.2-beta.20

package/.github/workflows/public_platform-tests-claude-investigate-and-fix.yaml

@@ -22,7 +22,7 @@ name: 'Platform tests: Claude failure investigation and fix'
 #     platformTestsCore:
 #         uses: apify/apify-test-tools/.github/workflows/public_platform-tests.yaml@workflows-v0
 #         with:
-#             subtest: core
+#             test-files-glob: 'test/platform/hourly/**'
 #             report-slack-channel: '#notif-my-repo'
 #         secrets:
 #             TESTER_APIFY_TOKEN: ${{ secrets.TESTER_APIFY_TOKEN }}

package/.github/workflows/public_platform-tests.yaml

@@ -3,15 +3,10 @@ name: Platform tests
 on:
     workflow_call:
         inputs:
-            # Deprecated, use `test-files-glob`
-            subtest:
-                type: string
-                default: ''
-                required: false
-            # Specify what tests you want to run, relative to `test/platform`
+            # Glob of the test files to run, from the repo root, e.g. `test/platform/{hourly,hourly-without-pr}/**`
             test-files-glob:
                 type: string
-                default: ''
+                default: 'test/platform/**'
                 required: false
             # Slack channel for failed tests. Empty skips Slack.
             report-slack-channel:
@@ -64,9 +59,12 @@ jobs:
               shell: bash
               env:
                   TESTER_APIFY_TOKEN: ${{ secrets.TESTER_APIFY_TOKEN }}
+                  # Passed through the environment and quoted, so the shell doesn't expand the glob itself
+                  # An empty input, e.g. from an expression that picks the glob, runs everything, like the default
+                  TEST_FILES_GLOB: ${{ inputs.test-files-glob || 'test/platform/**' }}
               run: |
                   apify-test-tools get-actor-configs \
-                    | apify-test-tools test ./test/platform/${{ inputs.test-files-glob || inputs.subtest }} \
+                    | apify-test-tools test --test-files-glob "$TEST_FILES_GLOB" \
                         --reporter github-actions --vitest-output-file ./test-output.json > test-report.json
 
             # Posts only when the tests failed, but checks the Slack token on every run that has a channel. Runs

package/.github/workflows/public_pr-build-test.yaml

@@ -7,10 +7,11 @@ on:
                 type: boolean
                 default: false
                 required: false
-            # Specify what tests you want to run, relative to `test/platform`
+            # Glob of the test files to run, from the repo root, e.g. `test/platform/{daily,hourly}/**`. Which changed
+            # files count as test changes is `platformTestsGlob` in apify-test-tools.config.json, not this.
             test-files-glob:
                 type: string
-                default: ''
+                default: 'test/platform/**'
                 required: false
             # Fail the build unless the env var names of version 0.99 match the default version's
             require-env-vars-in-sync:
@@ -86,16 +87,12 @@ jobs:
               run: |
                   base_commit=$(cat base_commit.txt 2>/dev/null || echo "")
                   echo "Last validated (base) commit to be used for build & test: $base_commit"
-                  args=(
-                    --base "origin/$BASE_REF"
-                    # TODO: Temporary hotfix until build glob matching aligns with Vitest's test selection glob.
-                    --test-files-glob 'test/platform/**'
-                  )
+                  args=(--base "origin/$BASE_REF")
                   [ -n "$base_commit" ] && args+=(--since "$base_commit")
                   apify-test-tools get-affected-actors "${args[@]}" > affected.json
 
-            # Cosmetic-only changes need no tests, so only the functionally changed Actors are built, into the
-            # test version 0.99 that users never run.
+            # Cosmetic-only changes need no tests, so only the Actors with functional or platform test changes are
+            # built, into the test version 0.99 that users never run.
             # run-with-apify-tokens.mjs reads the token names from in apify-test-tools.config.json
             # and hands the build those secrets and nothing else, so the tokens stay in this one command instead of the whole job.
             # The library never sees secrets it doesn't need
@@ -107,7 +104,7 @@ jobs:
                   SCRIPTS_PATH: ${{ steps.setup.outputs.scripts-path }}
                   REQUIRE_ENV_VARS_IN_SYNC: ${{ inputs.require-env-vars-in-sync }}
               run: |
-                  jq '{ actors: .functionallyChangedActors }' affected.json \
+                  jq '{ actors: (.functionallyChangedActors + .testChangedActors) }' affected.json \
                     | node "$SCRIPTS_PATH/run-with-apify-tokens.mjs" apify-test-tools build --version-number 0.99 \
                         --require-env-vars-in-sync="$REQUIRE_ENV_VARS_IN_SYNC" \
                     | tee builds.json
@@ -116,9 +113,12 @@ jobs:
             - name: Test
               env:
                   TESTER_APIFY_TOKEN: ${{ secrets.TESTER_APIFY_TOKEN }}
+                  # Passed through the environment and quoted, so the shell doesn't expand the glob itself
+                  # An empty input, e.g. from an expression that picks the glob, runs everything, like the default
+                  TEST_FILES_GLOB: ${{ inputs.test-files-glob || 'test/platform/**' }}
               # The github-actions reporter annotates the PR with the failing tests
               run: |
-                  apify-test-tools test ./test/platform/${{ inputs.test-files-glob }} --reporter github-actions \
+                  apify-test-tools test --test-files-glob "$TEST_FILES_GLOB" --reporter github-actions \
                     < builds.json > test-report.json
 
             # NOTE: This is an optimization that if we did functional changes and later only cosmetic changes (e.g. dev readme), we will compare changes files only for the last commit. This must run after tests because we want to cache the latest commit only if the tests are successful

package/.github/workflows/public_push-build-latest.yaml

@@ -52,6 +52,7 @@ jobs:
 
             # A release ships cosmetic changes too (README, input schema descriptions), so both lists are built,
             # into each Actor's default version: the one its default build tag points to, which users run.
+            # testChangedActors is left out: a change to platform tests alone needs no release.
             # run-with-apify-tokens.mjs reads the token names from in apify-test-tools.config.json
             # and hands the build those secrets and nothing else, so the tokens stay in this one command instead of the whole job.
             # The library never sees secrets it doesn't need

package/CHANGELOG.md

@@ -18,6 +18,7 @@ All notable changes to this project will be documented in this file.
 - Add impact & priority assessment to claude investigator ([#216](https://github.com/apify/apify-test-tools/pull/216)) ([fd16622](https://github.com/apify/apify-test-tools/commit/fd16622b910ec6e9b5515ea0bd26b0a41c22bd23)) by [@foxt451](https://github.com/foxt451), closes [#208](https://github.com/apify/apify-test-tools/issues/208)
 - Stale issue/pr workflow ([#236](https://github.com/apify/apify-test-tools/pull/236)) ([aff1fa7](https://github.com/apify/apify-test-tools/commit/aff1fa778adb846a60fdacdd26aa13a71729613d)) by [@JuanGalilea](https://github.com/JuanGalilea), closes [#35](https://github.com/apify/apify-test-tools/issues/35)
 - **workflows:** [**breaking**] Skip Slack when report-slack-channel is empty ([#238](https://github.com/apify/apify-test-tools/pull/238)) ([9a15b56](https://github.com/apify/apify-test-tools/commit/9a15b56de9ca42fb5ea753dc478116f9cd9c2c94)) by [@metalwarrior665](https://github.com/metalwarrior665)
+- [**breaking**] Repo-root test-files-glob, platformTestsGlob in the config, and drop subtest ([#239](https://github.com/apify/apify-test-tools/pull/239)) ([640bc97](https://github.com/apify/apify-test-tools/commit/640bc97d9f16cfa07501bc4eae400cd2b1bd0c9c)) by [@metalwarrior665](https://github.com/metalwarrior665), closes [#192](https://github.com/apify/apify-test-tools/issues/192)
 
 ### 🐛 Bug Fixes
 

package/CONTRIBUTING.md

@@ -172,7 +172,7 @@ brought:
   env:
       WORKFLOW_SECRETS: ${{ toJSON(secrets) }}
   run: |
-      jq '{ actors: .functionallyChangedActors }' affected.json \
+      jq '{ actors: (.functionallyChangedActors + .testChangedActors) }' affected.json \
         | node "${{ steps.setup.outputs.scripts-path }}/run-with-apify-tokens.mjs" \
           apify-test-tools build --version-number 0.99
 ```

package/README.md

@@ -16,7 +16,7 @@ Build, test and release Apify Actors from a Git repository or local source code.
 
     ```bash
     npx apify-test-tools get-affected-actors --base origin/master \
-      | jq '{ actors: .functionallyChangedActors }' \
+      | jq '{ actors: (.functionallyChangedActors + .testChangedActors) }' \
       | npx apify-test-tools build --version-number 0.99
     ```
 
@@ -180,14 +180,15 @@ group needs a `tokenEnvVar` and at least one Actor. Add another group for Actors
 Actors owned by another account.
 
 The orchestrator sets `overrideActorContext` because its tests live outside its own folder: without it, a change to
-only `test/platform/orchestrator` wouldn't build and test it. The other two already have the whole repo, tests
-included, as their context.
+only `test/platform/orchestrator` wouldn't test it. The other two already have the whole repo, tests included, as
+their context.
 
 | Field                  | Where          | Required | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | ---------------------- | -------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | `folder`               | Actor          | yes      | Relative path from repo root to the Actor's own project directory — the folder that directly contains `.actor/actor.json` (i.e. `<folder>/.actor/actor.json`), the Actor's README/CHANGELOG, and its source. Use `"."` for a single-Actor repo where `.actor/` is at the root.                                                                                                                                                                                                                         |
 | `actorFullName`        | Actor          | yes      | Full Actor identifier in `owner/name` format (e.g. `"apify/web-scraper"`). This is the source of truth for the Actor name — the `name` field in `actor.json` is not used.                                                                                                                                                                                                                                                                                                                              |
 | `tokenEnvVar`          | group or Actor | yes      | Name of the environment variable holding the Apify API token that builds the group's Actors. No fallback — if the env var is not set at build time, the build fails.                                                                                                                                                                                                                                                                                                                                   |
+| `platformTestsGlob`    | top level      | no       | Glob from the repo root of the platform tests and their helpers. Default `test/platform/**`. A changed file that matches it is a test change, also when `.dockerignore` lists it: the PR workflow builds and tests the Actor whose context holds it, and a release skips it. See [Change detection](docs/cli.md#change-detection).                                                                                                                                                                     |
 | `overrideActorContext` | group or Actor | no       | Array of paths (relative to repo root) that define which files are relevant to the Actor. When set, replaces the `dockerContextDir` from `actor.json` for change detection. Useful when an Actor depends on shared packages outside its Docker build context. Entries must not be prefixes of one another (e.g. `["", "code"]` or `["actors", "actors/foo"]` are rejected). The Actor's own `folder` is always part of its context — if none of the listed entries reach it, it's added automatically. |
 
 A value set on an Actor replaces the group's for that Actor only. Values are replaced, not merged: if the `myteam`
@@ -259,7 +260,8 @@ jobs:
 
 ### Scheduled tests (optional)
 
-How often to run which tests is up to you. For example, you can run every test once a day:
+How often to run which tests is up to you. `test-files-glob` is a glob from the repo root, see
+[Splitting the tests](docs/workflows.md#splitting-the-tests). For example, you can run the daily tests once a day:
 
 ```yaml
 name: Platform tests - Daily
@@ -273,12 +275,14 @@ on:
 jobs:
     platformTestsDaily:
         uses: apify/apify-test-tools/.github/workflows/public_platform-tests.yaml@workflows-v0
+        with:
+            test-files-glob: 'test/platform/{daily,daily-without-pr}/**'
         secrets:
             TESTER_APIFY_TOKEN: ${{ secrets.TESTER_APIFY_TOKEN }}
             SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
 ```
 
-and a few critical tests, kept in e.g. `test/platform/hourly`, every hour:
+and a few critical tests every hour:
 
 ```yaml
 name: Platform tests - Hourly
@@ -293,7 +297,7 @@ jobs:
     platformTestsHourly:
         uses: apify/apify-test-tools/.github/workflows/public_platform-tests.yaml@workflows-v0
         with:
-            test-files-glob: hourly
+            test-files-glob: 'test/platform/{hourly,hourly-without-pr}/**'
         secrets:
             TESTER_APIFY_TOKEN: ${{ secrets.TESTER_APIFY_TOKEN }}
             SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}

package/bin/affected-actors.ts

@@ -10,7 +10,7 @@ import {
 } from './git.js';
 import { logger } from './logger.js';
 import type { ActorConfig, Commit, GitRange } from './types.js';
-import { readConfigFile } from './utils/config/load-config.js';
+import { readConfigFile, readRepoSettings } from './utils/config/load-config.js';
 
 // The range always ends at the checked-out commit: check out what you want to inspect
 const HEAD = 'HEAD';
@@ -28,8 +28,6 @@ interface AffectedActorsOptions {
      * counts, and it must be an ancestor of HEAD (e.g. the last release).
      */
     since?: string;
-    /** Glob relative to the repo root. Matching files count as changes even when .dockerignore lists them. */
-    testFilesGlob?: string;
     actors: string[];
     ignore: string[];
 }
@@ -47,8 +45,17 @@ interface AffectedActors {
      * stays the source of truth for the rest.
      */
     functionallyChangedActors: { actorFullName: string }[];
-    /** Actors whose changes are all cosmetic (README, CHANGELOG, cosmetic .actor JSON). They only need a release build. */
+    /**
+     * Actors with cosmetic changes (README, CHANGELOG, cosmetic .actor JSON) and no functional one. They only need a
+     * release build.
+     */
     cosmeticallyChangedActors: { actorFullName: string }[];
+    /**
+     * Actors whose platform tests (`platformTestsGlob` in the config) changed in their context, whatever else
+     * changed. Their tests need to run, but a test change alone needs no release. An Actor can also be in one of the
+     * lists above.
+     */
+    testChangedActors: { actorFullName: string }[];
 }
 
 const names = (configs: ActorConfig[]) => configs.map(({ actorFullName }) => ({ actorFullName }));
@@ -114,7 +121,12 @@ const findValidatedSha = async (since: string, headSha: string): Promise<string
  *   base's change, which base already validated.
  */
 const intersectChangedInBranchVsSince = (branch: ChangedActors, sinceValidated: ChangedActors): ChangedActors => {
-    const narrowed: ChangedActors = { functional: [], cosmetic: [] };
+    const narrowed: ChangedActors = {
+        functional: [],
+        cosmetic: [],
+        // The same rule for tests: the branch changed them, and they changed again since they were last validated
+        test: branch.test.filter((actor) => sinceValidated.test.includes(actor)),
+    };
     // All checks are done for each Actor separately, that's cleanest and most accurate
     for (const actor of [...branch.functional, ...branch.cosmetic]) {
         // base...HEAD
@@ -145,7 +157,6 @@ const intersectChangedInBranchVsSince = (branch: ChangedActors, sinceValidated:
 export const getAffectedActors = async ({
     base,
     since: sinceOption,
-    testFilesGlob,
     actors,
     ignore,
 }: AffectedActorsOptions): Promise<AffectedActors> => {
@@ -156,6 +167,7 @@ export const getAffectedActors = async ({
     }
 
     const actorConfigs = await readConfigFile({ actors, ignore });
+    const { platformTestsGlob } = await readRepoSettings();
     const getChangedInRange = async (range: GitRange) => {
         const changedFiles = await getChangedFilesBetween(range.fromRef, range.toRef);
         return {
@@ -164,7 +176,7 @@ export const getAffectedActors = async ({
                 filepathsChanged: changedFiles,
                 actorConfigs,
                 range,
-                testFilesGlob,
+                platformTestsGlob,
             }),
         };
     };
@@ -194,5 +206,6 @@ export const getAffectedActors = async ({
         changelog: await getChangelogAdditions(rangeVsBase.fromRef, rangeVsBase.toRef, changedFiles),
         functionallyChangedActors: names(changedActors.functional),
         cosmeticallyChangedActors: names(changedActors.cosmetic),
+        testChangedActors: names(changedActors.test),
     };
 };

package/bin/diff-changes.ts

@@ -1,8 +1,7 @@
-import picomatch from 'picomatch';
-
 import { isCosmeticOnlyJsonSchemaChange } from './diff-json-schema.js';
 import { type DockerIgnoreMatcher, loadDockerIgnore } from './dockerignore.js';
 import { logger } from './logger.js';
+import { createTestFilesMatcher } from './test-files-glob.js';
 import type { ActorConfig, GitRange } from './types.js';
 import { type RelativeDir, RelativeFile } from './utils/path/repo-relative.js';
 
@@ -11,8 +10,11 @@ interface ShouldBuildAndTestOptions {
     actorConfigs: ActorConfig[];
     /** The range the files changed in, to compare `.actor` JSON files across. */
     range: GitRange;
-    // Glob relative to the repo root. Matching files count as changes even when .dockerignore lists them.
-    testFilesGlob?: string;
+    /**
+     * Glob of the platform test files, from the repo root (`platformTestsGlob` in the config). A change to a matching
+     * file is a test change, even when .dockerignore lists it.
+     */
+    platformTestsGlob?: string;
 }
 
 const IGNORED_TOP_LEVEL_FILES = [
@@ -34,6 +36,7 @@ type FileChangeForActor =
     | { impact: 'ignored' }
     | { impact: 'outside-context' }
     | { impact: 'cosmetic'; semanticallyVerified: boolean }
+    | { impact: 'test' }
     | { impact: 'functional' };
 
 /**
@@ -44,11 +47,13 @@ type FileChangeForActor =
  *    not one per actor, so it applies to every actor regardless of context/folder.
  * 2. Context matching (actorConfig.contextPaths) → outside-context if no match
  * 3. Hardcoded ignore list, checked against the path hoisted relative to the matched context entry → ignored
- * 4. .dockerignore filtering (patterns relative to dockerContextDir), skipped for the actor's own `.actor/`
- *    dir and for test files → ignored if matched
- * 5. README.md by filename → cosmetic if inside the actor's own folder, otherwise ignored
- * 6. .json inside the actor's own `.actor/` dir with only cosmetic schema diffs → cosmetic (semantically verified)
- * 7. Everything else → functional
+ * 4. Platform test files (`platformTestsGlob`) → test, even when .dockerignore lists them. A test change needs the
+ *    tests to run, but no release.
+ * 5. .dockerignore filtering (patterns relative to dockerContextDir), skipped for the actor's own `.actor/`
+ *    dir → ignored if matched
+ * 6. README.md by filename → cosmetic if inside the actor's own folder, otherwise ignored
+ * 7. .json inside the actor's own `.actor/` dir with only cosmetic schema diffs → cosmetic (semantically verified)
+ * 8. Everything else → functional
  */
 const classifyFileChange = async (
     changedFile: RelativeFile,
@@ -75,13 +80,17 @@ const classifyFileChange = async (
         return { impact: 'ignored' };
     }
 
+    // Test files are often in .dockerignore, but a change to them must still run the tests
+    if (isTestFile(changedFile.path)) {
+        return { impact: 'test' };
+    }
+
     const isUnderActorDotDir = actorConfig.actorJson.file.parent.contains(changedFile);
 
     // .actor/ can legitimately be listed in .dockerignore (the Apify platform evaluates it before
     // the Docker build, so excluding it from the build context is a valid caching optimization) —
     // that shouldn't cause changes to .actor/ itself to be ignored here.
-    // Test files are often in .dockerignore too, but a change to them must still build and test.
-    if (!isUnderActorDotDir && !isTestFile(changedFile.path) && dockerIgnoreMatcher(changedFile.path)) {
+    if (!isUnderActorDotDir && dockerIgnoreMatcher(changedFile.path)) {
         return { impact: 'ignored' };
     }
 
@@ -113,6 +122,8 @@ type ActorChangeEntry = {
     actorConfig: ActorConfig;
     files: string[];
     hasFunctionalChange: boolean;
+    hasCosmeticChange: boolean;
+    hasTestChange: boolean;
 };
 
 type ChangeGroup = { actors: string[]; files: string[] };
@@ -168,8 +179,13 @@ const logChangeGroups = (groups: ChangeGroup[]): void => {
 export interface ChangedActors {
     /** Actors with at least one functional change. They need a new build and tests. */
     functional: ActorConfig[];
-    /** Actors whose changes are all cosmetic. They only need a new build when released. */
+    /** Actors with cosmetic changes and no functional one. They only need a new build when released. */
     cosmetic: ActorConfig[];
+    /**
+     * Actors with at least one platform test change, whatever else changed. Their tests need to run, but test changes
+     * alone need no release. An Actor can be in this list and in one of the others.
+     */
+    test: ActorConfig[];
 }
 
 /** Finds the Actors the changed files belong to, split by the most impactful change each Actor has. */
@@ -177,11 +193,11 @@ export const getChangedActors = async ({
     filepathsChanged,
     actorConfigs,
     range,
-    testFilesGlob,
+    platformTestsGlob,
 }: ShouldBuildAndTestOptions): Promise<ChangedActors> => {
     const actorsChangedMap = new Map<string, ActorChangeEntry>();
     const testFilesInContext = new Set<string>();
-    const isTestFile = testFilesGlob ? picomatch(testFilesGlob, { nocase: true, dot: true }) : () => false;
+    const isTestFile = createTestFilesMatcher(platformTestsGlob);
 
     for (const actorConfig of actorConfigs) {
         const dockerIgnoreMatcher = loadDockerIgnore(actorConfig.dockerContextDir);
@@ -204,9 +220,13 @@ export const getChangedActors = async ({
                 actorConfig,
                 files: [],
                 hasFunctionalChange: false,
+                hasCosmeticChange: false,
+                hasTestChange: false,
             };
             entry.files.push(originalFilePath);
             entry.hasFunctionalChange ||= change.impact === 'functional';
+            entry.hasCosmeticChange ||= change.impact === 'cosmetic';
+            entry.hasTestChange ||= change.impact === 'test';
             actorsChangedMap.set(actorConfig.folder.path, entry);
         }
     }
@@ -226,11 +246,15 @@ export const getChangedActors = async ({
 
     const entries = Array.from(actorsChangedMap.values());
     const functional = entries.filter((entry) => entry.hasFunctionalChange).map((entry) => entry.actorConfig);
-    const cosmetic = entries.filter((entry) => !entry.hasFunctionalChange).map((entry) => entry.actorConfig);
+    const cosmetic = entries
+        .filter((entry) => !entry.hasFunctionalChange && entry.hasCosmeticChange)
+        .map((entry) => entry.actorConfig);
+    const test = entries.filter((entry) => entry.hasTestChange).map((entry) => entry.actorConfig);
 
     const names = (configs: ActorConfig[]) => configs.map((config) => config.actorFullName).join(', ') || 'none';
     logger.info(`[DIFF]: Actors with functional changes: ${names(functional)}`);
     logger.info(`[DIFF]: Actors with only cosmetic changes: ${names(cosmetic)}`);
+    logger.info(`[DIFF]: Actors with platform test changes: ${names(test)}`);
 
-    return { functional, cosmetic };
+    return { functional, cosmetic, test };
 };

package/bin/main.ts

@@ -56,10 +56,6 @@ const affectedRangeOptions = {
         type: 'string',
         describe: 'Only count commits after this one. Ignored with --base if it is not on the branch',
     },
-    'test-files-glob': {
-        type: 'string',
-        describe: 'Glob (from the repo root) of test files that count as changes even when .dockerignore lists them',
-    },
 } as const satisfies Record<string, Options>;
 
 /**
@@ -103,15 +99,19 @@ const envVarsSyncOptions = {
 
 /** 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, 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.
+        // 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>;
@@ -183,20 +183,12 @@ await yargs()
         },
     )
     .command(
-        'test [filters..]',
+        '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
-                .positional('filters', {
-                    type: 'string',
-                    array: true,
-                    default: ['test/platform'],
-                    describe: 'Test files to run, as vitest filters',
-                })
-                .options(testOptions),
+        (y) => y.options(testOptions),
         async (args) => {
             const report = await runTests({
-                filters: args.filters,
+                testFilesGlob: args.testFilesGlob,
                 targets: parseTestTargets(await readStdin()),
                 vitestOutputFile: args.vitestOutputFile,
                 reporters: args.reporter,
@@ -229,7 +221,8 @@ await yargs()
         async (args) => {
             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
+            // 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,

package/bin/run-tests.ts

@@ -9,6 +9,7 @@ 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';
 
 /**
@@ -29,9 +30,32 @@ const resolveVitestBin = async (cwd: string): Promise<string> => {
     }
 };
 
+/**
+ * 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 {
-    /** Vitest file filters, e.g. `test/platform/core` */
-    filters: string[];
+    /** 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 */
@@ -47,7 +71,7 @@ interface RunTestsOptions {
  * an error: the report is how the failure gets to `notify`.
  */
 export const runTests = async ({
-    filters,
+    testFilesGlob,
     targets,
     vitestOutputFile,
     reporters = [],
@@ -58,6 +82,7 @@ export const runTests = async ({
         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);
 
@@ -81,7 +106,7 @@ export const runTests = async ({
     const args = [
         vitestBin,
         'run',
-        ...filters,
+        ...vitestFilters,
         '--reporter=default',
         '--reporter=json',
         ...reporters.map((reporter) => `--reporter=${reporter}`),