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

package/test/unit/bin/diff-changes.test.ts

@@ -71,6 +71,10 @@ const changedActorsFor = async ({
     return options.actorConfigs.filter((config) => changed.includes(config));
 };
 
+// The Actors whose platform tests run because of a test change
+const testChangedActorsFor = async (options: Parameters<typeof getChangedActors>[0]): Promise<ActorConfig[]> =>
+    (await getChangedActors(options)).test;
+
 describe('getChangedActors', () => {
     beforeEach(() => {
         vi.restoreAllMocks();
@@ -404,34 +408,58 @@ describe('getChangedActors', () => {
         expect(result).toEqual([miniActor]);
     });
 
-    it('test file listed in .dockerignore triggers a build when it matches the test files glob', async () => {
+    it('test file listed in .dockerignore is a test change when it matches the platform tests glob', async () => {
         vi.spyOn(Dockerignore, 'loadDockerIgnore').mockReturnValue((filePath) => filePath.startsWith('test/'));
-        const result = await changedActorsFor({
+        const options = {
             filepathsChanged: ['test/platform/daily/foo.test.ts'],
             actorConfigs: [miniActor],
             range,
-            testFilesGlob: 'test/platform/**',
+            platformTestsGlob: 'test/platform/**',
+        };
+        expect(await testChangedActorsFor(options)).toEqual([miniActor]);
+        // A test change needs no build of its own, neither for a PR nor for a release
+        expect(await changedActorsFor({ ...options, isLatest: true })).toEqual([]);
+    });
+
+    it('a test change that is not listed in .dockerignore is still only a test change', async () => {
+        vi.spyOn(Dockerignore, 'loadDockerIgnore').mockReturnValue(() => false);
+        const options = {
+            filepathsChanged: ['test/platform/utils.ts'],
+            actorConfigs: [miniActor],
+            range,
+            platformTestsGlob: 'test/platform/**',
+        };
+        expect(await testChangedActorsFor(options)).toEqual([miniActor]);
+        expect(await changedActorsFor({ ...options, isLatest: true })).toEqual([]);
+    });
+
+    it('lists an Actor with both source and test changes as functional and as test changed', async () => {
+        const result = await getChangedActors({
+            filepathsChanged: ['test/platform/daily/foo.test.ts', 'actors/foo_bar/src/main.ts'],
+            actorConfigs: [miniActor],
+            range,
+            platformTestsGlob: 'test/platform/**',
         });
-        expect(result).toEqual([miniActor]);
+        expect(result).toStrictEqual({ functional: [miniActor], cosmetic: [], test: [miniActor] });
     });
 
-    it('test file listed in .dockerignore stays ignored without a test files glob', async () => {
+    it('test file listed in .dockerignore stays ignored without a platform tests glob', async () => {
         vi.spyOn(Dockerignore, 'loadDockerIgnore').mockReturnValue((filePath) => filePath.startsWith('test/'));
-        const result = await changedActorsFor({
+        const result = await getChangedActors({
             filepathsChanged: ['test/platform/daily/foo.test.ts'],
             actorConfigs: [miniActor],
             range,
         });
-        expect(result).toEqual([]);
+        expect(result).toStrictEqual({ functional: [], cosmetic: [], test: [] });
     });
 
-    it('test files glob matches case-insensitively and does not bypass .dockerignore for other files', async () => {
+    it('platform tests glob matches case-insensitively and does not bypass .dockerignore for other files', async () => {
         vi.spyOn(Dockerignore, 'loadDockerIgnore').mockReturnValue(() => true);
-        const result = await changedActorsFor({
+        const result = await testChangedActorsFor({
             filepathsChanged: ['Test/Platform/Foo.test.ts'],
             actorConfigs: [miniActor],
             range,
-            testFilesGlob: 'test/platform/**',
+            platformTestsGlob: 'test/platform/**',
         });
         expect(result).toEqual([miniActor]);
         expect(
@@ -439,7 +467,7 @@ describe('getChangedActors', () => {
                 filepathsChanged: ['actors/foo_bar/node_modules/foo.js'],
                 actorConfigs: [miniActor],
                 range,
-                testFilesGlob: 'test/platform/**',
+                platformTestsGlob: 'test/platform/**',
             }),
         ).toEqual([]);
     });
@@ -450,7 +478,7 @@ describe('getChangedActors', () => {
             filepathsChanged: ['test/platform/daily/foo.test.ts'],
             actorConfigs: [standaloneActor],
             range,
-            testFilesGlob: 'test/platform/**',
+            platformTestsGlob: 'test/platform/**',
         });
         expect(result).toEqual([]);
     });
@@ -461,11 +489,11 @@ describe('getChangedActors', () => {
             ...standaloneActor,
             contextPaths: [...standaloneActor.contextPaths, new RelativeDir('test')],
         };
-        const result = await changedActorsFor({
+        const result = await testChangedActorsFor({
             filepathsChanged: ['test/platform/standalone.test.ts'],
             actorConfigs: [actorWithTests],
             range,
-            testFilesGlob: 'test/platform/**',
+            platformTestsGlob: 'test/platform/**',
         });
         expect(result).toEqual([actorWithTests]);
     });
@@ -602,6 +630,7 @@ describe('getChangedActors logging', () => {
             '[DIFF]: Changes specific to actor team/actor-b: actors/b/b-only.ts',
             '[DIFF]: Actors with functional changes: team/actor-a, team/actor-b',
             '[DIFF]: Actors with only cosmetic changes: none',
+            '[DIFF]: Actors with platform test changes: none',
         ]);
     });
 
@@ -614,7 +643,7 @@ describe('getChangedActors logging', () => {
             filepathsChanged: ['test/platform/standalone.test.ts'],
             actorConfigs: [standaloneActor],
             range,
-            testFilesGlob: 'test/platform/**',
+            platformTestsGlob: 'test/platform/**',
         });
 
         expect(logger.warn).toHaveBeenCalledWith(outsideContextWarning('test/platform/standalone.test.ts'));
@@ -625,7 +654,7 @@ describe('getChangedActors logging', () => {
             filepathsChanged: ['test/platform/standalone.test.ts', 'standalone-actors/standalone/src/main.ts'],
             actorConfigs: [standaloneActor],
             range,
-            testFilesGlob: 'test/platform/**',
+            platformTestsGlob: 'test/platform/**',
         });
 
         expect(result).toEqual([standaloneActor]);
@@ -637,7 +666,7 @@ describe('getChangedActors logging', () => {
             filepathsChanged: ['test/platform/foo.test.ts', 'test/platform/README.md', 'test/platform/CHANGELOG.md'],
             actorConfigs: [miniActor],
             range,
-            testFilesGlob: 'test/platform/**',
+            platformTestsGlob: 'test/platform/**',
         });
 
         expect(logger.warn).not.toHaveBeenCalled();
@@ -672,12 +701,12 @@ describe('getChangedActors split by impact', () => {
             actorConfigs,
             range,
         });
-        expect(result).toStrictEqual({ functional: [miniActor], cosmetic: [standaloneActor] });
+        expect(result).toStrictEqual({ functional: [miniActor], cosmetic: [standaloneActor], test: [] });
     });
 
     it('returns empty lists when nothing relevant changed', async () => {
         expect(
             await getChangedActors({ filepathsChanged: ['.vscode/settings.json'], actorConfigs, range }),
-        ).toStrictEqual({ functional: [], cosmetic: [] });
+        ).toStrictEqual({ functional: [], cosmetic: [], test: [] });
     });
 });

package/test/unit/bin/test-cli.test.ts

@@ -45,6 +45,15 @@ test('owner/a: fails', () => {
 });
 `,
         );
+
+        // Outside test/platform, so the tests that run test/platform don't see them
+        for (const folder of ['with-pr', 'without-pr']) {
+            await mkdir(path.join(repoDir, 'test/glob', folder), { recursive: true });
+            await writeFile(
+                path.join(repoDir, 'test/glob', folder, `${folder}.test.ts`),
+                `import { test } from 'vitest';\n\ntest('owner/a: ${folder}', () => {});\n`,
+            );
+        }
     });
 
     afterAll(async () => {
@@ -92,17 +101,46 @@ test('owner/a: fails', () => {
         expect(JSON.parse(result.stdout)).toMatchObject({ success: false, summary: { passed: 1, failed: 1 } });
     });
 
-    it('adds the reporters it is given to the default and JSON ones, also before the test files', () => {
+    it('passes vitest a folder whose files all match as one filter, and adds the reporters it is given', () => {
         const result = run(
-            ['--log-level', 'debug', 'test', '--reporter', 'dot', '--reporter', 'verbose', 'test/platform'],
+            ['--log-level', 'debug', 'test', '--reporter', 'dot', '--reporter', 'verbose'],
             JSON.stringify([build]),
         );
+        // The default glob test/platform/** matches every file in test/platform, so vitest gets just that folder
         expect(result.stderr).toMatch(
-            /Running vitest: \S+ run test\/platform --reporter=default --reporter=json --reporter=dot --reporter=verbose /,
+            /Running vitest: \S+ run \S+\/test\/platform\/ --reporter=default --reporter=json --reporter=dot --reporter=verbose /,
         );
         expect(JSON.parse(result.stdout)).toMatchObject({ summary: { passed: 1, failed: 1 } });
     });
 
+    it('runs only the test files that --test-files-glob matches from the repo root', () => {
+        const result = run(['test', '--test-files-glob', 'test/glob/{with-pr,other}/**'], JSON.stringify([build]));
+        expect(result.status, result.stderr).toBe(0);
+        expect(result.stderr).toContain('Running the 1 file(s) that match --test-files-glob');
+        expect(JSON.parse(result.stdout)).toMatchObject({
+            success: true,
+            summary: { total: 1, passed: 1 },
+            tests: [{ name: 'owner/a: with-pr', file: 'test/glob/with-pr/with-pr.test.ts' }],
+        });
+    });
+
+    it('fails when --test-files-glob matches no file instead of running every test', () => {
+        // Relative to test/platform, the way the workflows took it before
+        const result = run(['test', '--test-files-glob', 'hourly'], JSON.stringify([build]));
+        expect(result.status).toBe(1);
+        expect(result.stderr).toContain('No files match --test-files-glob "hourly"');
+        expect(result.stdout).toBe('');
+    });
+
+    it('rejects test paths given the old way, as arguments, instead of running every test', () => {
+        const result = run(['test', 'test/platform/core'], JSON.stringify([build]));
+        expect(result.status).toBe(1);
+        // The help that comes with it shows --test-files-glob
+        expect(result.stderr).toContain('Unknown command: test/platform/core');
+        expect(result.stderr).toContain('--test-files-glob');
+        expect(result.stdout).toBe('');
+    });
+
     it('fails without TESTER_APIFY_TOKEN instead of passing with every test skipped', () => {
         const result = run(['test'], JSON.stringify([build]), repoDir, { ...env, TESTER_APIFY_TOKEN: '' });
         expect(result.status).toBe(1);

package/test/unit/bin/test-files-glob.test.ts

@@ -0,0 +1,118 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+
+import { createTestFilesMatcher, resolveTestFilesGlob } from '../../../bin/test-files-glob.js';
+
+describe('createTestFilesMatcher', () => {
+    it('matches repo-root-relative paths, ignoring case and including dot files', () => {
+        const isMatch = createTestFilesMatcher('test/platform/{daily,hourly}/**');
+        expect(isMatch('test/platform/daily/a.test.ts')).toBe(true);
+        expect(isMatch('Test/Platform/Hourly/.b.test.ts')).toBe(true);
+        expect(isMatch('test/platform/daily-without-pr/a.test.ts')).toBe(false);
+        expect(isMatch('test/platform/utils.ts')).toBe(false);
+    });
+
+    it('matches nothing without a glob', () => {
+        expect(createTestFilesMatcher(undefined)('test/platform/a.test.ts')).toBe(false);
+    });
+
+    it('rejects an absolute glob', () => {
+        expect(() => createTestFilesMatcher('/repo/test/platform/**')).toThrow('must be relative to the repo root');
+    });
+});
+
+describe('resolveTestFilesGlob', () => {
+    let repoDir: string;
+
+    beforeAll(async () => {
+        repoDir = await mkdtemp(path.join(os.tmpdir(), 'apify-test-files-glob-'));
+        for (const file of [
+            'test/platform/utils.ts',
+            'test/platform/daily/a.test.ts',
+            'test/platform/daily-without-pr/b.test.ts',
+            'test/platform/hourly/nested/c.test.ts',
+            'test/platform/node_modules/d.test.ts',
+            'other/test/platform/daily/e.test.ts',
+        ]) {
+            await mkdir(path.join(repoDir, path.dirname(file)), { recursive: true });
+            await writeFile(path.join(repoDir, file), '');
+        }
+    });
+
+    afterAll(async () => {
+        if (repoDir) await rm(repoDir, { recursive: true, force: true });
+    });
+
+    const files = async (glob: string) => (await resolveTestFilesGlob(glob, repoDir)).files;
+    const paths = async (glob: string) => (await resolveTestFilesGlob(glob, repoDir)).paths;
+
+    it('lists the matched files from the repo root, sorted, skipping node_modules', async () => {
+        expect(await files('test/platform/**')).toEqual([
+            'test/platform/daily-without-pr/b.test.ts',
+            'test/platform/daily/a.test.ts',
+            'test/platform/hourly/nested/c.test.ts',
+            'test/platform/utils.ts',
+        ]);
+    });
+
+    it('selects folders with a brace pattern', async () => {
+        expect(await files('test/platform/{daily,hourly}/**')).toEqual([
+            'test/platform/daily/a.test.ts',
+            'test/platform/hourly/nested/c.test.ts',
+        ]);
+    });
+
+    it('accepts a leading ./', async () => {
+        expect(await files('./test/platform/daily/**')).toEqual(['test/platform/daily/a.test.ts']);
+    });
+
+    it('walks the whole repo when the glob has no static base', async () => {
+        expect(await files('**/daily/*.test.ts')).toEqual([
+            'other/test/platform/daily/e.test.ts',
+            'test/platform/daily/a.test.ts',
+        ]);
+    });
+
+    it('resolves a glob without wildcards to the file itself', async () => {
+        expect(await resolveTestFilesGlob('test/platform/utils.ts', repoDir)).toStrictEqual({
+            files: ['test/platform/utils.ts'],
+            paths: ['test/platform/utils.ts'],
+        });
+    });
+
+    it('matches no file with a glob relative to test/platform or a folder without **', async () => {
+        expect(await files('daily/**')).toEqual([]);
+        expect(await files('test/platform/daily')).toEqual([]);
+    });
+
+    it('gives a folder whose files all match as one path, ending with / so it is not a prefix of a sibling', async () => {
+        expect(await paths('test/platform/{daily,hourly}/**')).toEqual([
+            'test/platform/daily/',
+            'test/platform/hourly/',
+        ]);
+    });
+
+    it('lists the matched files one by one in a folder that also holds files the glob leaves out', async () => {
+        // test/platform/utils.ts is left out, so test/platform/ can't be one path
+        expect(await paths('test/platform/**/*.test.ts')).toEqual([
+            'test/platform/daily-without-pr/',
+            'test/platform/daily/',
+            'test/platform/hourly/',
+        ]);
+        // other/ holds only the matched file, so it is the highest folder that can be one path
+        expect(await paths('**/daily/*.test.ts')).toEqual(['other/', 'test/platform/daily/']);
+    });
+
+    it('never gives a folder that holds a skipped node_modules as one path', async () => {
+        // test/platform/node_modules/ is not walked, so test/platform/ might hold files the glob leaves out
+        expect(await paths('test/platform/**')).toEqual([
+            'test/platform/daily-without-pr/',
+            'test/platform/daily/',
+            'test/platform/hourly/',
+            'test/platform/utils.ts',
+        ]);
+    });
+});

package/test/unit/bin/utils/config/parser.test.ts

@@ -4,7 +4,12 @@ import path from 'node:path';
 
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 
-import { _privates, parseConfigFile, parseResolvedConfigFile } from '../../../../../bin/utils/config/parser.js';
+import {
+    _privates,
+    parseConfigFile,
+    parseRepoSettings,
+    parseResolvedConfigFile,
+} from '../../../../../bin/utils/config/parser.js';
 import { CONFIG_FILE_STRATEGY, type ResolvedActorConfig } from '../../../../../bin/utils/config/structures/base.js';
 import { GROUPED_PARSER } from '../../../../../bin/utils/config/structures/grouped.js';
 import { LEGACY_PARSER } from '../../../../../bin/utils/config/structures/legacy.js';
@@ -228,3 +233,21 @@ describe('parseConfigFile', () => {
         ).toThrow('Duplicate folder "test"');
     });
 });
+
+describe('parseRepoSettings', () => {
+    it('defaults platformTestsGlob to test/platform/**', () => {
+        expect(parseRepoSettings({ actors: [actor()] })).toStrictEqual({ platformTestsGlob: 'test/platform/**' });
+    });
+
+    it('reads platformTestsGlob next to the Actor entries, in any mode', () => {
+        expect(parseRepoSettings({ platformTestsGlob: 'e2e/**', actors: [actor()] })).toStrictEqual({
+            platformTestsGlob: 'e2e/**',
+        });
+        expect(parseConfigFile({ platformTestsGlob: 'e2e/**', actors: [actor({ folder: 'bin' })] })).toHaveLength(1);
+    });
+
+    it('rejects an empty or non-string platformTestsGlob', () => {
+        expect(() => parseRepoSettings({ platformTestsGlob: '' })).toThrow(/platformTestsGlob/);
+        expect(() => parseRepoSettings({ platformTestsGlob: ['test/**'] })).toThrow(/platformTestsGlob/);
+    });
+});