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

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

@@ -59,7 +59,21 @@ const amazonActor = actorConfig('junglee/amazon-crawler', 'actors/junglee_Amazon
     'shared',
 ]);
 
-const commits = [{ sha: 'Commit1', author: '', date: '', message: '' }];
+const range = { fromRef: 'Commit0', toRef: 'Commit1' };
+
+// What a PR (functional changes only) or a release (isLatest, all changes) builds, in config order
+const changedActorsFor = async ({
+    isLatest = false,
+    ...options
+}: Parameters<typeof getChangedActors>[0] & { isLatest?: boolean }): Promise<ActorConfig[]> => {
+    const { functional, cosmetic } = await getChangedActors(options);
+    const changed = isLatest ? [...functional, ...cosmetic] : functional;
+    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(() => {
@@ -68,51 +82,51 @@ describe('getChangedActors', () => {
     });
 
     it('returns empty array when no files changed', async () => {
-        expect(await getChangedActors({ filepathsChanged: [], actorConfigs, commits })).toEqual([]);
+        expect(await changedActorsFor({ filepathsChanged: [], actorConfigs, range })).toEqual([]);
     });
 
     it('returns empty array when only ignored top-level files changed', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['.gitignore', 'README.md', '.husky/pre-commit', '.vscode/settings.json'],
             actorConfigs,
-            commits,
+            range,
         });
         expect(result).toEqual([]);
     });
 
     it('does not ignore source files whose names contain an ignored file name', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['actors/foo_bar/src/.gitignore-helper.ts'],
             actorConfigs,
-            commits,
+            range,
         });
         expect(result).toEqual([miniActor]);
     });
 
     it('returns the actor when a functional file in its folder changes', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['actors/foo_bar/src/main.ts'],
             actorConfigs,
-            commits,
+            range,
         });
         expect(result).toEqual([miniActor]);
     });
 
     it('returns actor when isLatest and README in actor folder changed (cosmetic)', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['actors/foo_bar/README.md'],
             actorConfigs,
-            commits,
+            range,
             isLatest: true,
         });
         expect(result).toEqual([miniActor]);
     });
 
     it('does not return actor when not isLatest and only README changed (cosmetic)', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['actors/foo_bar/README.md'],
             actorConfigs,
-            commits,
+            range,
             isLatest: false,
         });
         expect(result).toEqual([]);
@@ -120,10 +134,10 @@ describe('getChangedActors', () => {
 
     it('returns actor when isLatest and JSON file has only cosmetic changes', async () => {
         vi.spyOn(DiffJsonSchema, 'isCosmeticOnlyJsonSchemaChange').mockResolvedValue(true);
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['actors/foo_bar/.actor/actor.json'],
             actorConfigs,
-            commits,
+            range,
             isLatest: true,
         });
         expect(result).toEqual([miniActor]);
@@ -131,30 +145,30 @@ describe('getChangedActors', () => {
 
     it('does not return actor when not isLatest and JSON file has only cosmetic changes', async () => {
         vi.spyOn(DiffJsonSchema, 'isCosmeticOnlyJsonSchemaChange').mockResolvedValue(true);
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['actors/foo_bar/.actor/actor.json'],
             actorConfigs,
-            commits,
+            range,
             isLatest: false,
         });
         expect(result).toEqual([]);
     });
 
     it('returns actor when JSON file has functional changes', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['actors/foo_bar/.actor/actor.json'],
             actorConfigs,
-            commits,
+            range,
         });
         expect(result).toEqual([miniActor]);
     });
 
     it('JSON file in actor folder but outside .actor/ is functional, not checked for cosmetic', async () => {
         vi.spyOn(DiffJsonSchema, 'isCosmeticOnlyJsonSchemaChange').mockResolvedValue(true);
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['actors/foo_bar/package.json'],
             actorConfigs,
-            commits,
+            range,
             isLatest: false,
         });
         expect(result).toEqual([miniActor]);
@@ -163,34 +177,34 @@ describe('getChangedActors', () => {
 
     it('JSON file under .actor/ inside actor folder is checked for cosmetic changes', async () => {
         vi.spyOn(DiffJsonSchema, 'isCosmeticOnlyJsonSchemaChange').mockResolvedValue(true);
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['actors/foo_bar/.actor/input_schema.json'],
             actorConfigs,
-            commits,
+            range,
             isLatest: false,
         });
         expect(result).toEqual([]);
         expect(DiffJsonSchema.isCosmeticOnlyJsonSchemaChange).toHaveBeenCalledWith(
-            commits,
+            range,
             'actors/foo_bar/.actor/input_schema.json',
         );
     });
 
     it('does not trigger narrow-context actor when shared file changes', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['shared/utils.ts'],
             actorConfigs,
-            commits,
+            range,
         });
         expect(result).toContainEqual(miniActor);
         expect(result).not.toContainEqual(standaloneActor);
     });
 
     it('root-level changelog outside any actor folder is cosmetic for every actor when isLatest', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['CHANGELOG.md'],
             actorConfigs,
-            commits,
+            range,
             isLatest: true,
         });
         expect(result).toEqual(expect.arrayContaining([miniActor, standaloneActor]));
@@ -198,20 +212,20 @@ describe('getChangedActors', () => {
     });
 
     it('root-level changelog is not cosmetic-triggered when not isLatest', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['CHANGELOG.md'],
             actorConfigs,
-            commits,
+            range,
             isLatest: false,
         });
         expect(result).toEqual([]);
     });
 
     it('treats any changelog filename as cosmetic regardless of configured paths', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['docs/CHANGELOG.md'],
             actorConfigs: [miniActor, standaloneActor],
-            commits,
+            range,
             isLatest: true,
         });
         expect(result).toEqual([miniActor, standaloneActor]);
@@ -222,39 +236,39 @@ describe('getChangedActors', () => {
             ...standaloneActor,
             actorJson: { ...standaloneActor.actorJson, readme: new RelativeFile('docs/guide.md') },
         };
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['docs/guide.md'],
             actorConfigs: [configuredActor],
-            commits,
+            range,
             isLatest: true,
         });
         expect(result).toEqual([]);
     });
 
     it('triggers narrow-context actor when its own folder changes', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['standalone-actors/standalone/src/main.ts'],
             actorConfigs,
-            commits,
+            range,
         });
         expect(result).toContainEqual(standaloneActor);
     });
 
     it('deduplicates actors when multiple files in same actor folder change', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['actors/foo_bar/src/main.ts', 'actors/foo_bar/package.json'],
             actorConfigs,
-            commits,
+            range,
         });
         expect(result).toHaveLength(1);
         expect(result).toContainEqual(miniActor);
     });
 
     it('handles mixed changes: returns both broad and narrow-context actors', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['actors/foo_bar/src/main.ts', 'standalone-actors/standalone/Dockerfile'],
             actorConfigs,
-            commits,
+            range,
         });
         expect(result).toContainEqual(miniActor);
         expect(result).toContainEqual(standaloneActor);
@@ -262,29 +276,29 @@ describe('getChangedActors', () => {
 
     it('matches folder where folder name differs from actor name', async () => {
         const ownerlessActor = actorConfig('myteam/shopify-scraper', 'actors/shopify', 'APIFY_TOKEN_MYTEAM', '', ['']);
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['actors/shopify/src/main.ts'],
             actorConfigs: [ownerlessActor],
-            commits,
+            range,
         });
         expect(result).toEqual([ownerlessActor]);
     });
 
     it('in single-actor repo, .actor/ changes trigger builds', async () => {
         const rootActor = actorConfig('myteam/my-actor', '', 'BUILDER_APIFY_TOKEN', '', ['']);
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['.actor/actor.json'],
             actorConfigs: [rootActor],
-            commits,
+            range,
         });
         expect(result).toEqual([rootActor]);
     });
 
     it('in multi-actor repo, .actor/ changes only trigger broad-context actors', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['.actor/actor.json'],
             actorConfigs,
-            commits,
+            range,
         });
         expect(result).toEqual([miniActor]);
     });
@@ -293,10 +307,10 @@ describe('getChangedActors', () => {
         const narrowActor = actorConfig('foo/bar', 'actors/foo_bar', 'APIFY_TOKEN_FOO', 'actors/foo_bar', [
             'actors/foo_bar',
         ]);
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['Actors/FOO_BAR/Main.ts'],
             actorConfigs: [narrowActor],
-            commits,
+            range,
         });
         expect(result).toEqual([]);
     });
@@ -309,10 +323,10 @@ describe('getChangedActors', () => {
             'actors/override',
             ['actors/override', 'packages'],
         );
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['packages/shared/utils.ts'],
             actorConfigs: [overrideActor],
-            commits,
+            range,
         });
         expect(result).toEqual([overrideActor]);
     });
@@ -325,10 +339,10 @@ describe('getChangedActors', () => {
             'actors/override',
             ['actors/override', 'packages'],
         );
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['other-dir/file.ts'],
             actorConfigs: [overrideActor],
-            commits,
+            range,
         });
         expect(result).toEqual([]);
     });
@@ -336,10 +350,10 @@ describe('getChangedActors', () => {
     it('broad-context actor skips files in sibling actor folders', async () => {
         const actorA = actorConfig('team/actor-a', 'actors/a', 'APIFY_TOKEN_TEAM', '', ['']);
         const actorB = actorConfig('team/actor-b', 'actors/b', 'APIFY_TOKEN_TEAM', '', ['']);
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['actors/b/src/main.ts'],
             actorConfigs: [actorA, actorB],
-            commits,
+            range,
         });
         expect(result).toEqual([actorB]);
     });
@@ -349,10 +363,10 @@ describe('getChangedActors', () => {
         const childActor = actorConfig('team/child', 'actors/child', 'APIFY_TOKEN_TEAM', 'actors/child', [
             'actors/child',
         ]);
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['actors/child/src/main.ts'],
             actorConfigs: [rootActor, childActor],
-            commits,
+            range,
         });
         expect(result).not.toContainEqual(rootActor);
         expect(result).toContainEqual(childActor);
@@ -363,10 +377,10 @@ describe('getChangedActors', () => {
         const childActor = actorConfig('team/child', 'actors/child', 'APIFY_TOKEN_TEAM', 'actors/child', [
             'actors/child',
         ]);
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['lib/shared-utils.ts'],
             actorConfigs: [rootActor, childActor],
-            commits,
+            range,
         });
         expect(result).toContainEqual(rootActor);
         expect(result).not.toContainEqual(childActor);
@@ -376,71 +390,95 @@ describe('getChangedActors', () => {
         vi.spyOn(Dockerignore, 'loadDockerIgnore').mockReturnValue(
             (filePath) => filePath === 'actors/foo_bar/node_modules/foo.js',
         );
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['actors/foo_bar/node_modules/foo.js'],
             actorConfigs: [miniActor],
-            commits,
+            range,
         });
         expect(result).toEqual([]);
     });
 
     it('file not matched by .dockerignore is classified normally', async () => {
         vi.spyOn(Dockerignore, 'loadDockerIgnore').mockReturnValue((filePath) => filePath.includes('node_modules'));
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['actors/foo_bar/src/main.ts'],
             actorConfigs: [miniActor],
-            commits,
+            range,
         });
         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 getChangedActors({
+        const options = {
             filepathsChanged: ['test/platform/daily/foo.test.ts'],
             actorConfigs: [miniActor],
-            commits,
-            testFilesGlob: 'test/platform/**',
+            range,
+            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 getChangedActors({
             filepathsChanged: ['test/platform/daily/foo.test.ts'],
             actorConfigs: [miniActor],
-            commits,
+            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 getChangedActors({
+        const result = await testChangedActorsFor({
             filepathsChanged: ['Test/Platform/Foo.test.ts'],
             actorConfigs: [miniActor],
-            commits,
-            testFilesGlob: 'test/platform/**',
+            range,
+            platformTestsGlob: 'test/platform/**',
         });
         expect(result).toEqual([miniActor]);
         expect(
-            await getChangedActors({
+            await changedActorsFor({
                 filepathsChanged: ['actors/foo_bar/node_modules/foo.js'],
                 actorConfigs: [miniActor],
-                commits,
-                testFilesGlob: 'test/platform/**',
+                range,
+                platformTestsGlob: 'test/platform/**',
             }),
         ).toEqual([]);
     });
 
     it('test file outside an actor context still does not trigger it', async () => {
         vi.spyOn(Dockerignore, 'loadDockerIgnore').mockReturnValue(() => true);
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['test/platform/daily/foo.test.ts'],
             actorConfigs: [standaloneActor],
-            commits,
-            testFilesGlob: 'test/platform/**',
+            range,
+            platformTestsGlob: 'test/platform/**',
         });
         expect(result).toEqual([]);
     });
@@ -451,85 +489,85 @@ describe('getChangedActors', () => {
             ...standaloneActor,
             contextPaths: [...standaloneActor.contextPaths, new RelativeDir('test')],
         };
-        const result = await getChangedActors({
+        const result = await testChangedActorsFor({
             filepathsChanged: ['test/platform/standalone.test.ts'],
             actorConfigs: [actorWithTests],
-            commits,
-            testFilesGlob: 'test/platform/**',
+            range,
+            platformTestsGlob: 'test/platform/**',
         });
         expect(result).toEqual([actorWithTests]);
     });
 
     it('JSON file in context but outside actor folder is functional (not checked for cosmetic)', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['lib/config.json'],
             actorConfigs: [miniActor],
-            commits,
+            range,
         });
         expect(result).toEqual([miniActor]);
     });
 
     it('README outside actor folder but inside context is ignored (not cosmetic)', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['docs/README.md'],
             actorConfigs: [miniActor],
-            commits,
+            range,
             isLatest: true,
         });
         expect(result).toEqual([]);
     });
 
     it('README inside actor folder is cosmetic', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['actors/foo_bar/README.md'],
             actorConfigs: [miniActor],
-            commits,
+            range,
             isLatest: true,
         });
         expect(result).toEqual([miniActor]);
     });
 
     it('ignores a standalone actor top-level dev file relative to its context', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['standalone-actors/standalone/.eslintrc'],
             actorConfigs,
-            commits,
+            range,
         });
         expect(result).toEqual([]);
     });
 
-    it('does not special-case code/ and shared/ prefixes anymore — must be declared via overrideActorContext', async () => {
-        const result = await getChangedActors({
+    it('does not special-case code/ and shared/ prefixes — they must be declared via overrideActorContext', async () => {
+        const result = await changedActorsFor({
             filepathsChanged: ['code/some/code.ts'],
             actorConfigs: [miniActor],
-            commits,
+            range,
         });
         expect(result).toEqual([miniActor]);
     });
 
     it('ignores code/.eslintrc when "code" is declared via overrideActorContext', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['code/.eslintrc'],
             actorConfigs: [amazonActor],
-            commits,
+            range,
         });
         expect(result).toEqual([]);
     });
 
     it('shared/Dockerfile declared via overrideActorContext is functional', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['shared/Dockerfile'],
             actorConfigs: [amazonActor],
-            commits,
+            range,
         });
         expect(result).toEqual([amazonActor]);
     });
 
     it('code/README.md declared via overrideActorContext is ignored (outside actor folder)', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['code/README.md'],
             actorConfigs: [amazonActor],
-            commits,
+            range,
             isLatest: true,
         });
         expect(result).toEqual([]);
@@ -547,13 +585,14 @@ describe('getChangedActors logging', () => {
         await getChangedActors({
             filepathsChanged: ['actors/foo_bar/src/main.ts'],
             actorConfigs: [miniActor],
-            commits,
+            range,
         });
 
         expect(logger.info).toHaveBeenCalledWith(
             '[DIFF]: Changes specific to actor foo/bar: actors/foo_bar/src/main.ts',
         );
-        expect(logger.info).toHaveBeenCalledWith('[DIFF]: Actors to be built and tested: foo/bar');
+        expect(logger.info).toHaveBeenCalledWith('[DIFF]: Actors with functional changes: foo/bar');
+        expect(logger.info).toHaveBeenCalledWith('[DIFF]: Actors with only cosmetic changes: none');
     });
 
     it('logs a single "shared" group when two actors are triggered by the exact same file', async () => {
@@ -563,14 +602,14 @@ describe('getChangedActors logging', () => {
         await getChangedActors({
             filepathsChanged: ['shared/shared.ts'],
             actorConfigs: [actorA, actorB],
-            commits,
+            range,
         });
 
         expect(logger.info).toHaveBeenCalledWith(
             '[DIFF]: Shared changes for actors team/actor-a, team/actor-b: shared/shared.ts',
         );
         expect(logger.info).not.toHaveBeenCalledWith(expect.stringContaining('Changes specific to actor'));
-        expect(logger.info).toHaveBeenCalledWith('[DIFF]: Actors to be built and tested: team/actor-a, team/actor-b');
+        expect(logger.info).toHaveBeenCalledWith('[DIFF]: Actors with functional changes: team/actor-a, team/actor-b');
     });
 
     it('logs shared and specific groups in descending-size order for partial overlap across actors', async () => {
@@ -580,7 +619,7 @@ describe('getChangedActors logging', () => {
         await getChangedActors({
             filepathsChanged: ['shared.ts', 'actors/a/a-only.ts', 'actors/b/b-only.ts'],
             actorConfigs: [actorA, actorB],
-            commits,
+            range,
         });
 
         const errorCalls = vi.mocked(logger.info).mock.calls.map((call) => call[0]);
@@ -589,7 +628,9 @@ describe('getChangedActors logging', () => {
             '[DIFF]: Shared changes for actors team/actor-a, team/actor-b: shared.ts',
             '[DIFF]: Changes specific to actor team/actor-a: actors/a/a-only.ts',
             '[DIFF]: Changes specific to actor team/actor-b: actors/b/b-only.ts',
-            '[DIFF]: Actors to be built and tested: team/actor-a, team/actor-b',
+            '[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',
         ]);
     });
 
@@ -601,19 +642,19 @@ describe('getChangedActors logging', () => {
         await getChangedActors({
             filepathsChanged: ['test/platform/standalone.test.ts'],
             actorConfigs: [standaloneActor],
-            commits,
-            testFilesGlob: 'test/platform/**',
+            range,
+            platformTestsGlob: 'test/platform/**',
         });
 
         expect(logger.warn).toHaveBeenCalledWith(outsideContextWarning('test/platform/standalone.test.ts'));
     });
 
     it('still warns when the same push also rebuilds an Actor', async () => {
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['test/platform/standalone.test.ts', 'standalone-actors/standalone/src/main.ts'],
             actorConfigs: [standaloneActor],
-            commits,
-            testFilesGlob: 'test/platform/**',
+            range,
+            platformTestsGlob: 'test/platform/**',
         });
 
         expect(result).toEqual([standaloneActor]);
@@ -624,8 +665,8 @@ describe('getChangedActors logging', () => {
         await getChangedActors({
             filepathsChanged: ['test/platform/foo.test.ts', 'test/platform/README.md', 'test/platform/CHANGELOG.md'],
             actorConfigs: [miniActor],
-            commits,
-            testFilesGlob: 'test/platform/**',
+            range,
+            platformTestsGlob: 'test/platform/**',
         });
 
         expect(logger.warn).not.toHaveBeenCalled();
@@ -635,11 +676,37 @@ describe('getChangedActors logging', () => {
         await getChangedActors({
             filepathsChanged: ['.gitignore', '.prettierrc'],
             actorConfigs,
-            commits,
+            range,
         });
 
         expect(logger.info).not.toHaveBeenCalledWith(expect.stringContaining('Shared changes'));
         expect(logger.info).not.toHaveBeenCalledWith(expect.stringContaining('Changes specific to'));
-        expect(logger.info).toHaveBeenCalledWith('[DIFF]: No relevant files changed, skipping builds and tests');
+        expect(logger.info).toHaveBeenCalledWith('[DIFF]: Actors with functional changes: none');
+        expect(logger.info).toHaveBeenCalledWith('[DIFF]: Actors with only cosmetic changes: none');
+    });
+});
+
+describe('getChangedActors split by impact', () => {
+    beforeEach(() => {
+        vi.spyOn(DiffJsonSchema, 'isCosmeticOnlyJsonSchemaChange').mockResolvedValue(false);
+    });
+
+    it('lists an Actor as functional when it has any functional change, and as cosmetic only otherwise', async () => {
+        const result = await getChangedActors({
+            filepathsChanged: [
+                'actors/foo_bar/README.md',
+                'standalone-actors/standalone/README.md',
+                'actors/foo_bar/src/main.ts',
+            ],
+            actorConfigs,
+            range,
+        });
+        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: [], test: [] });
     });
 });