apify-test-tools 0.10.2-beta.1 → 0.10.2-beta.11

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

@@ -59,7 +59,17 @@ 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));
+};
 
 describe('getChangedActors', () => {
     beforeEach(() => {
@@ -68,51 +78,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 +130,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 +141,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 +173,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 +208,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 +232,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 +272,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 +303,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 +319,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 +335,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 +346,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 +359,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 +373,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,30 +386,30 @@ 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 () => {
         vi.spyOn(Dockerignore, 'loadDockerIgnore').mockReturnValue((filePath) => filePath.startsWith('test/'));
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['test/platform/daily/foo.test.ts'],
             actorConfigs: [miniActor],
-            commits,
+            range,
             testFilesGlob: 'test/platform/**',
         });
         expect(result).toEqual([miniActor]);
@@ -407,28 +417,28 @@ describe('getChangedActors', () => {
 
     it('test file listed in .dockerignore stays ignored without a test files glob', async () => {
         vi.spyOn(Dockerignore, 'loadDockerIgnore').mockReturnValue((filePath) => filePath.startsWith('test/'));
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['test/platform/daily/foo.test.ts'],
             actorConfigs: [miniActor],
-            commits,
+            range,
         });
         expect(result).toEqual([]);
     });
 
     it('test files 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 changedActorsFor({
             filepathsChanged: ['Test/Platform/Foo.test.ts'],
             actorConfigs: [miniActor],
-            commits,
+            range,
             testFilesGlob: 'test/platform/**',
         });
         expect(result).toEqual([miniActor]);
         expect(
-            await getChangedActors({
+            await changedActorsFor({
                 filepathsChanged: ['actors/foo_bar/node_modules/foo.js'],
                 actorConfigs: [miniActor],
-                commits,
+                range,
                 testFilesGlob: 'test/platform/**',
             }),
         ).toEqual([]);
@@ -436,10 +446,10 @@ describe('getChangedActors', () => {
 
     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,
+            range,
             testFilesGlob: 'test/platform/**',
         });
         expect(result).toEqual([]);
@@ -451,85 +461,85 @@ describe('getChangedActors', () => {
             ...standaloneActor,
             contextPaths: [...standaloneActor.contextPaths, new RelativeDir('test')],
         };
-        const result = await getChangedActors({
+        const result = await changedActorsFor({
             filepathsChanged: ['test/platform/standalone.test.ts'],
             actorConfigs: [actorWithTests],
-            commits,
+            range,
             testFilesGlob: '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({
+        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 +557,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 +574,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 +591,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 +600,8 @@ 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',
         ]);
     });
 
@@ -601,7 +613,7 @@ describe('getChangedActors logging', () => {
         await getChangedActors({
             filepathsChanged: ['test/platform/standalone.test.ts'],
             actorConfigs: [standaloneActor],
-            commits,
+            range,
             testFilesGlob: 'test/platform/**',
         });
 
@@ -609,10 +621,10 @@ describe('getChangedActors logging', () => {
     });
 
     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,
+            range,
             testFilesGlob: 'test/platform/**',
         });
 
@@ -624,7 +636,7 @@ describe('getChangedActors logging', () => {
         await getChangedActors({
             filepathsChanged: ['test/platform/foo.test.ts', 'test/platform/README.md', 'test/platform/CHANGELOG.md'],
             actorConfigs: [miniActor],
-            commits,
+            range,
             testFilesGlob: 'test/platform/**',
         });
 
@@ -635,11 +647,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] });
+    });
+
+    it('returns empty lists when nothing relevant changed', async () => {
+        expect(
+            await getChangedActors({ filepathsChanged: ['.vscode/settings.json'], actorConfigs, range }),
+        ).toStrictEqual({ functional: [], cosmetic: [] });
     });
 });