apify-test-tools 0.5.7-beta.2 → 0.5.7-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify-test-tools",
-  "version": "0.5.7-beta.2",
+  "version": "0.5.7-beta.4",
   "type": "module",
   "description": "TBD",
   "repository": {

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

@@ -0,0 +1,175 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { getChangedActors, maybeParseActorFolder } from '../../../bin/diff-changes.js';
+import * as DiffJsonSchema from '../../../bin/diff-json-schema.js';
+import type { ActorConfig } from '../../../bin/types.js';
+
+const miniActor: ActorConfig = { actorName: 'foo/bar', folder: 'actors/foo_bar', isStandalone: false };
+const standaloneActor: ActorConfig = { actorName: 'standalone', folder: 'standalone-actors/standalone', isStandalone: true };
+const actorConfigs = [miniActor, standaloneActor];
+
+const commits = [{ sha: 'Commit1', author: '', date: '', message: '' }];
+
+describe('maybeParseActorFolder', () => {
+    it('returns actorName for actors/ path', () => {
+        expect(maybeParseActorFolder('actors/foo_bar/actor.json')).toEqual({ isActorFolder: true, actorName: 'foo/bar' });
+    });
+
+    it('returns actorName for standalone-actors/ path', () => {
+        expect(maybeParseActorFolder('standalone-actors/my_actor/main.ts')).toEqual({ isActorFolder: true, actorName: 'my/actor' });
+    });
+
+    it('returns false for top-level file', () => {
+        expect(maybeParseActorFolder('package.json')).toEqual({ isActorFolder: false });
+    });
+
+    it('returns false for path with no file inside actor folder', () => {
+        expect(maybeParseActorFolder('actors/foo_bar')).toEqual({ isActorFolder: false });
+    });
+
+    it('returns false for unrelated folder', () => {
+        expect(maybeParseActorFolder('src/utils.ts')).toEqual({ isActorFolder: false });
+    });
+});
+
+describe('getChangedActors', () => {
+    beforeEach(() => {
+        vi.spyOn(DiffJsonSchema, 'isCosmeticOnlyJsonSchemaChange').mockReturnValue(false);
+    });
+
+    it('returns empty array when no files changed', () => {
+        expect(getChangedActors({ filepathsChanged: [], actorConfigs, commits })).toEqual([]);
+    });
+
+    it('returns empty array when only ignored top-level files changed', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['.gitignore', 'README.md', '.husky/pre-commit', '.vscode/settings.json'],
+            actorConfigs,
+            commits,
+        });
+        expect(result).toEqual([]);
+    });
+
+    it('returns the actor when a functional file in its folder changes', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['actors/foo_bar/src/main.ts'],
+            actorConfigs,
+            commits,
+        });
+        expect(result).toEqual([miniActor]);
+    });
+
+    it('returns actor when isLatest and README in actor folder changed (cosmetic)', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['actors/foo_bar/README.md'],
+            actorConfigs,
+            commits,
+            isLatest: true,
+        });
+        expect(result).toEqual([miniActor]);
+    });
+
+    it('does not return actor when not isLatest and only README changed (cosmetic)', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['actors/foo_bar/README.md'],
+            actorConfigs,
+            commits,
+            isLatest: false,
+        });
+        expect(result).toEqual([]);
+    });
+
+    it('returns actor when isLatest and JSON file has only cosmetic changes', () => {
+        vi.spyOn(DiffJsonSchema, 'isCosmeticOnlyJsonSchemaChange').mockReturnValue(true);
+        const result = getChangedActors({
+            filepathsChanged: ['actors/foo_bar/actor.json'],
+            actorConfigs,
+            commits,
+            isLatest: true,
+        });
+        expect(result).toEqual([miniActor]);
+    });
+
+    it('does not return actor when not isLatest and JSON file has only cosmetic changes', () => {
+        vi.spyOn(DiffJsonSchema, 'isCosmeticOnlyJsonSchemaChange').mockReturnValue(true);
+        const result = getChangedActors({
+            filepathsChanged: ['actors/foo_bar/actor.json'],
+            actorConfigs,
+            commits,
+            isLatest: false,
+        });
+        expect(result).toEqual([]);
+    });
+
+    it('returns actor when JSON file has functional changes', () => {
+        vi.spyOn(DiffJsonSchema, 'isCosmeticOnlyJsonSchemaChange').mockReturnValue(false);
+        const result = getChangedActors({
+            filepathsChanged: ['actors/foo_bar/actor.json'],
+            actorConfigs,
+            commits,
+        });
+        expect(result).toEqual([miniActor]);
+    });
+
+    it('returns all non-standalone actors when a non-actor-folder functional file changes', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['shared/utils.ts'],
+            actorConfigs,
+            commits,
+        });
+        expect(result).toContainEqual(miniActor);
+        expect(result).not.toContainEqual(standaloneActor);
+    });
+
+    it('does not include standalone actor in all-actors expansion from changelog', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['CHANGELOG.md'],
+            actorConfigs,
+            commits,
+            isLatest: true,
+        });
+        expect(result).toContainEqual(miniActor);
+        expect(result).not.toContainEqual(standaloneActor);
+    });
+
+    it('includes standalone actor when its own folder changes', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['standalone-actors/standalone/src/main.ts'],
+            actorConfigs,
+            commits,
+        });
+        expect(result).toContainEqual(standaloneActor);
+    });
+
+    it('deduplicates actors when multiple files in same actor folder change', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['actors/foo_bar/src/main.ts', 'actors/foo_bar/package.json'],
+            actorConfigs,
+            commits,
+        });
+        expect(result).toHaveLength(1);
+        expect(result).toContainEqual(miniActor);
+    });
+
+    it('handles mixed changes: returns both mini and standalone actors', () => {
+        const result = getChangedActors({
+            filepathsChanged: [
+                'actors/foo_bar/src/main.ts',
+                'standalone-actors/standalone/Dockerfile',
+            ],
+            actorConfigs,
+            commits,
+        });
+        expect(result).toContainEqual(miniActor);
+        expect(result).toContainEqual(standaloneActor);
+    });
+
+    it('file paths are matched case-insensitively', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['Actors/FOO_BAR/Main.ts'],
+            actorConfigs,
+            commits,
+        });
+        expect(result).toEqual([miniActor]);
+    });
+});

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

@@ -0,0 +1,214 @@
+import type { MockInstance } from 'vitest';
+import { beforeEach, describe, expect, it, test, vi } from 'vitest';
+
+import { isCosmeticOnlyJsonSchemaChange } from '../../../bin/diff-json-schema.js';
+import * as Utils from '../../../bin/utils.js';
+
+const commits = [
+    { sha: 'Commit1', author: '', date: '', message: '' },
+    { sha: 'Commit3', author: '', date: '', message: '' },
+];
+
+describe('isCosmeticOnlyJsonSchemaChange', () => {
+    let gitCommandSpy: MockInstance;
+
+    beforeEach(() => {
+        gitCommandSpy = vi.spyOn(Utils, 'spawnCommandInGhWorkspace');
+    });
+
+    const mockGitCalls = (oldJson: string, newJson: string) => {
+        gitCommandSpy
+            .mockReturnValueOnce(oldJson)
+            .mockReturnValueOnce(newJson);
+    };
+
+    test('returns true when nothing changed', () => {
+        const json = JSON.stringify({ type: 'string', title: 'My field' });
+        mockGitCalls(json, json);
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+    });
+
+    test('returns true when only title changes', () => {
+        mockGitCalls(
+            JSON.stringify({ type: 'string', title: 'Old title' }),
+            JSON.stringify({ type: 'string', title: 'New title' }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+    });
+
+    test('returns true when only description changes', () => {
+        mockGitCalls(
+            JSON.stringify({ type: 'string', description: 'Old desc' }),
+            JSON.stringify({ type: 'string', description: 'New desc' }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+    });
+
+    test('returns true when only example changes', () => {
+        mockGitCalls(
+            JSON.stringify({ type: 'string', example: 'foo' }),
+            JSON.stringify({ type: 'string', example: 'bar' }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+    });
+
+    test('returns true when only enumTitles changes', () => {
+        mockGitCalls(
+            JSON.stringify({ type: 'string', enum: ['a', 'b'], enumTitles: ['Option A', 'Option B'] }),
+            JSON.stringify({ type: 'string', enum: ['a', 'b'], enumTitles: ['Choice A', 'Choice B'] }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+    });
+
+    test('returns true when only sectionCaption changes', () => {
+        mockGitCalls(
+            JSON.stringify({ sectionCaption: 'Old caption' }),
+            JSON.stringify({ sectionCaption: 'New caption' }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+    });
+
+    test('returns true when only sectionDescription changes', () => {
+        mockGitCalls(
+            JSON.stringify({ sectionDescription: 'Old' }),
+            JSON.stringify({ sectionDescription: 'New' }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+    });
+
+    test('returns false when a functional field (type) changes', () => {
+        mockGitCalls(
+            JSON.stringify({ type: 'string', title: 'My field' }),
+            JSON.stringify({ type: 'integer', title: 'My field' }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
+    });
+
+    test('returns false when a functional field is added', () => {
+        mockGitCalls(
+            JSON.stringify({ title: 'My field' }),
+            JSON.stringify({ title: 'My field', type: 'string' }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
+    });
+
+    test('returns false when a functional field is removed', () => {
+        mockGitCalls(
+            JSON.stringify({ type: 'string', title: 'My field' }),
+            JSON.stringify({ title: 'My field' }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
+    });
+
+    test('returns true when non-functional fields change at nested level (input schema properties)', () => {
+        mockGitCalls(
+            JSON.stringify({
+                type: 'object',
+                properties: {
+                    myField: { type: 'string', title: 'Old title', description: 'Old desc', example: 'old' },
+                },
+            }),
+            JSON.stringify({
+                type: 'object',
+                properties: {
+                    myField: { type: 'string', title: 'New title', description: 'New desc', example: 'new' },
+                },
+            }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+    });
+
+    test('returns false when a functional nested field changes alongside non-functional ones', () => {
+        mockGitCalls(
+            JSON.stringify({
+                type: 'object',
+                properties: { myField: { type: 'string', title: 'Old title' } },
+            }),
+            JSON.stringify({
+                type: 'object',
+                properties: { myField: { type: 'integer', title: 'New title' } },
+            }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
+    });
+
+    test('returns false when a new property is added to input schema', () => {
+        mockGitCalls(
+            JSON.stringify({ properties: { fieldA: { type: 'string' } } }),
+            JSON.stringify({ properties: { fieldA: { type: 'string' }, fieldB: { type: 'integer' } } }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
+    });
+
+    test('returns false when a property is removed from input schema', () => {
+        mockGitCalls(
+            JSON.stringify({ properties: { fieldA: { type: 'string' }, fieldB: { type: 'integer' } } }),
+            JSON.stringify({ properties: { fieldA: { type: 'string' } } }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
+    });
+
+    test('returns false when invalid JSON in old content', () => {
+        mockGitCalls('not json', '{}');
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
+    });
+
+    test('returns false when invalid JSON in new content', () => {
+        mockGitCalls('{}', 'not json');
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
+    });
+
+    test('returns false when array content changes (not under a non-functional key)', () => {
+        mockGitCalls(
+            JSON.stringify({ enum: [1, 2, 3] }),
+            JSON.stringify({ enum: [1, 2, 4] }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
+    });
+
+    test('returns true when example array changes (non-functional key)', () => {
+        mockGitCalls(
+            JSON.stringify({ type: 'array', example: [1, 2, 3] }),
+            JSON.stringify({ type: 'array', example: [4, 5, 6] }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+    });
+
+    test('returns true for a realistic actor.json with only title/description change', () => {
+        mockGitCalls(
+            JSON.stringify({ actorSpecification: 1, name: 'my-actor', title: 'Old Title', description: 'Old description', version: '1.0' }),
+            JSON.stringify({ actorSpecification: 1, name: 'my-actor', title: 'New Title', description: 'New description', version: '1.0' }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+    });
+
+    test('returns true when fields under properties are reordered', () => {
+        mockGitCalls(
+            JSON.stringify({
+                type: 'object',
+                properties: { fieldA: { type: 'string' }, fieldB: { type: 'integer' }, fieldC: { type: 'boolean' } },
+            }),
+            JSON.stringify({
+                type: 'object',
+                properties: { fieldC: { type: 'boolean' }, fieldA: { type: 'string' }, fieldB: { type: 'integer' } },
+            }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+    });
+
+    test('returns false for a realistic actor.json with version change', () => {
+        mockGitCalls(
+            JSON.stringify({ actorSpecification: 1, name: 'my-actor', title: 'My Actor', version: '1.0' }),
+            JSON.stringify({ actorSpecification: 1, name: 'my-actor', title: 'My Actor', version: '1.1' }),
+        );
+        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
+    });
+
+    it('uses correct git refs: first-commit parent for old, last commit for new', () => {
+        const json = JSON.stringify({});
+        mockGitCalls(json, json);
+        isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json');
+        expect(gitCommandSpy).toHaveBeenCalledWith('git show Commit1~:actors/foo/actor.json');
+        expect(gitCommandSpy).toHaveBeenCalledWith('git show Commit3:actors/foo/actor.json');
+    });
+});

package/test/unit/parse-commit.test.ts

@@ -1,4 +1,5 @@
-import { describe, it, expect } from 'vitest';
+import { describe, expect, it } from 'vitest';
+
 import { GIT_FORMAT_SEPARATOR, parseCommit } from '../../bin/git.js';
 
 describe('parseCommit', () => {

package/test/unit/should-built-and-test.test.ts

@@ -1,7 +1,9 @@
-import { describe, expect, test } from 'vitest';
+import type { MockInstance } from 'vitest';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
 
-import type { ActorConfig } from '../../bin/types.js';
-import { getChangedActors } from '../../bin/utils.js';
+import { getChangedActors } from '../../bin/diff-changes.js';
+import * as DiffJsonSchema from '../../bin/diff-json-schema.js';
+import type { ActorConfig, Commit } from '../../bin/types.js';
 
 describe('Should build and test parser', () => {
     // From https://github.com/apify-store/testing-repo-for-github-actions
@@ -23,85 +25,168 @@ describe('Should build and test parser', () => {
         },
     ];
 
-    test('Ignores dev-only readme', async () => {
+    const commits: Commit[] = [
+        { sha: 'Commit1', author: '', date: '', message: '' },
+        { sha: 'Commit3', author: '', date: '', message: '' },
+    ];
+
+    let isCosmeticOnlyJsonSchemaSpy: MockInstance;
+
+    beforeEach(() => {
+        // Default: JSON changes are functional (triggers build/test)
+        isCosmeticOnlyJsonSchemaSpy = vi.spyOn(DiffJsonSchema, 'isCosmeticOnlyJsonSchemaChange').mockReturnValue(false);
+    });
+
+    test('Ignores dev-only readme', () => {
         const FILES = ['README.md', 'code/README.md', 'shared/README.md'];
 
-        const { actorsChanged, codeChanged } = await getChangedActors({ actorConfigs: ACTOR_CONFIGS, isLatest: false, filepathsChanged: FILES });
+        const actorsChanged = getChangedActors({ actorConfigs: ACTOR_CONFIGS, isLatest: false, filepathsChanged: FILES, commits });
 
         expect(actorsChanged).toEqual([]);
-        expect(codeChanged).toBe(false);
     });
 
-    test('Ignores other ignored files and folders', async () => {
+    test('Ignores other ignored files and folders', () => {
         const FILES = ['.vscode/', '.gitignore', '.husky/', '.eslintrc', '.editorconfig', '.actor/'];
 
-        const { actorsChanged, codeChanged } = await getChangedActors({ actorConfigs: ACTOR_CONFIGS, isLatest: false, filepathsChanged: FILES });
+        const actorsChanged = getChangedActors({ actorConfigs: ACTOR_CONFIGS, isLatest: false, filepathsChanged: FILES, commits });
 
         expect(actorsChanged).toEqual([]);
-        expect(codeChanged).toBe(false);
     });
 
-    test('Only builds latest for all Actors', async () => {
+    test('Only builds latest for all Actors', () => {
         const FILES = ['shared/CHANGELOG.md', 'CHANGELOG.md'];
 
-        const { actorsChanged, codeChanged } = await getChangedActors({ actorConfigs: ACTOR_CONFIGS, isLatest: true, filepathsChanged: FILES });
+        const actorsChanged = getChangedActors({ actorConfigs: ACTOR_CONFIGS, isLatest: true, filepathsChanged: FILES, commits });
 
         expect(actorsChanged).toEqual(ACTOR_CONFIGS.filter(({ isStandalone }) => !isStandalone));
-        expect(codeChanged).toBe(false);
     });
 
-    test('Code updated, tests miniactors', async () => {
+    test('Code updated, tests miniactors', () => {
         const FILES = ['code/src/main.ts', 'package.json'];
 
-        const { actorsChanged, codeChanged } = await getChangedActors({ actorConfigs: ACTOR_CONFIGS, isLatest: false, filepathsChanged: FILES });
+        const actorsChanged = getChangedActors({ actorConfigs: ACTOR_CONFIGS, isLatest: false, filepathsChanged: FILES, commits });
 
         expect(actorsChanged).toEqual(ACTOR_CONFIGS.filter(({ isStandalone }) => !isStandalone));
-        expect(codeChanged).toBe(true);
     });
 
-    test('Specific Actor functionality configs updated', async () => {
+    test('Specific Actor functionality configs updated', () => {
         const FILES = ['actors/lukaskrivka_testing-github-integration-1/.actor/actor.json', 'standalone-actors/lukaskrivka_test-standalone/Dockerfile'];
+        // Default mock returns false = functional change
 
-        const { actorsChanged, codeChanged } = await getChangedActors({ actorConfigs: ACTOR_CONFIGS, isLatest: false, filepathsChanged: FILES });
+        const actorsChanged = getChangedActors({ actorConfigs: ACTOR_CONFIGS, isLatest: false, filepathsChanged: FILES, commits });
 
         expect(actorsChanged).toEqual([ACTOR_CONFIGS[0], ACTOR_CONFIGS[2]]);
-        expect(codeChanged).toBe(false);
     });
 
-    test('src/main.ts updated', async () => {
+    test('src/main.ts updated', () => {
         const FILES = [
             'src/main.ts',
         ];
 
-        const { actorsChanged, codeChanged } = await getChangedActors({ actorConfigs: ACTOR_CONFIGS, isLatest: true, filepathsChanged: FILES });
+        const actorsChanged = getChangedActors({ actorConfigs: ACTOR_CONFIGS, isLatest: true, filepathsChanged: FILES, commits });
 
         expect(actorsChanged).toEqual(ACTOR_CONFIGS.slice(0, 2));
-        expect(codeChanged).toBe(false);
     });
 
-    test('Miniactor, Code and standalone actor updated,', async () => {
+    test('Miniactor, Code and standalone actor updated,', () => {
         const FILES = [
             'actors/lukaskrivka_testing-github-integration-1/.actor/actor.json',
             'code/src/main.ts',
             'standalone-actors/lukaskrivka_test-standalone/Dockerfile',
         ];
+        // Default mock returns false = functional change for the JSON file
 
-        const { actorsChanged, codeChanged } = await getChangedActors({ actorConfigs: ACTOR_CONFIGS, isLatest: false, filepathsChanged: FILES });
+        const actorsChanged = getChangedActors({ actorConfigs: ACTOR_CONFIGS, isLatest: false, filepathsChanged: FILES, commits });
 
         expect(actorsChanged).toEqual(ACTOR_CONFIGS);
-        expect(codeChanged).toBe(true);
     });
 
-    test('Specific Actor non-functional configs updated', async () => {
+    test('Specific Actor non-functional configs updated', () => {
         const FILES = ['actors/lukaskrivka_testing-github-integration-2/.actor/README.md', 'standalone-actors/lukaskrivka_test-standalone/CHANGELOG.md'];
 
-        const { actorsChanged, codeChanged } = await getChangedActors({ actorConfigs: ACTOR_CONFIGS, isLatest: false, filepathsChanged: FILES });
+        const actorsChanged = getChangedActors({ actorConfigs: ACTOR_CONFIGS, isLatest: false, filepathsChanged: FILES, commits });
+
+        expect(actorsChanged).toEqual([]);
+    });
+
+    test('JSON file with cosmetic-only changes in PR context (isLatest=false) skips tests', () => {
+        const FILES = ['actors/lukaskrivka_testing-github-integration-1/.actor/actor.json'];
+        isCosmeticOnlyJsonSchemaSpy.mockReturnValue(true);
+
+        const actorsChanged = getChangedActors({
+            actorConfigs: ACTOR_CONFIGS,
+            isLatest: false,
+            filepathsChanged: FILES,
+            commits,
+        });
+
+        expect(actorsChanged).toEqual([]);
+    });
+
+    test('JSON file with cosmetic-only changes in latest context still triggers build', () => {
+        const FILES = ['actors/lukaskrivka_testing-github-integration-1/.actor/actor.json'];
+        isCosmeticOnlyJsonSchemaSpy.mockReturnValue(true);
+
+        const actorsChanged = getChangedActors({
+            actorConfigs: ACTOR_CONFIGS,
+            isLatest: true,
+            filepathsChanged: FILES,
+            commits,
+        });
+
+        expect(actorsChanged).toEqual([ACTOR_CONFIGS[0]]);
+    });
+
+    test('JSON file with functional changes triggers tests', () => {
+        const FILES = ['actors/lukaskrivka_testing-github-integration-1/.actor/actor.json'];
+        // Default mock returns false = functional change
+
+        const actorsChanged = getChangedActors({
+            actorConfigs: ACTOR_CONFIGS,
+            isLatest: false,
+            filepathsChanged: FILES,
+            commits,
+        });
+
+        expect(actorsChanged).toEqual([ACTOR_CONFIGS[0]]);
+    });
+
+    test('Mix: one actor has cosmetic-only JSON change, another has functional JSON change', () => {
+        const FILES = [
+            'actors/lukaskrivka_testing-github-integration-1/.actor/actor.json',
+            'actors/lukaskrivka_testing-github-integration-2/.actor/input_schema.json',
+        ];
+        // Actor 1 JSON is cosmetic-only, actor 2 JSON is functional
+        isCosmeticOnlyJsonSchemaSpy.mockImplementation((_commits, filepath: string) =>
+            !filepath.includes('input_schema.json'),
+        );
+
+        const actorsChanged = getChangedActors({
+            actorConfigs: ACTOR_CONFIGS,
+            isLatest: false,
+            filepathsChanged: FILES,
+            commits,
+        });
+
+        // Only the second actor (functional change) should be built and tested
+        expect(actorsChanged).toEqual([ACTOR_CONFIGS[1]]);
+    });
+
+    test('Standalone actor with cosmetic-only JSON change in PR context skips tests', () => {
+        const FILES = ['standalone-actors/lukaskrivka_test-standalone/.actor/actor.json'];
+        isCosmeticOnlyJsonSchemaSpy.mockReturnValue(true);
+
+        const actorsChanged = getChangedActors({
+            actorConfigs: ACTOR_CONFIGS,
+            isLatest: false,
+            filepathsChanged: FILES,
+            commits,
+        });
 
         expect(actorsChanged).toEqual([]);
-        expect(codeChanged).toBe(false);
     });
 
-    test('Google Maps real user-case that had undefined', async () => {
+    test('Google Maps real user-case that had undefined', () => {
         const FILES = ['actors/compass_Google-Maps-Reviews-Scraper/.actor/INPUT_SCHEMA.json', 'actors/compass_crawler-google-places/.actor/INPUT_SCHEMA.json',
             'code/src/consts.ts', 'code/src/crawlers/cheerio/routes.ts', 'code/src/detail_page_handle.ts', 'code/src/enqueue_places.ts',
             'code/src/helper-classes/initialize-all.ts', 'code/src/helper-classes/stats.ts', 'code/src/helper-classes/unmatched-categories.ts',
@@ -156,11 +241,10 @@ describe('Should build and test parser', () => {
             },
         ];
 
-        const { actorsChanged, codeChanged } = await getChangedActors({
-            actorConfigs: ACTOR_CONFIGS_GOOGLE_MAPS, isLatest: false, filepathsChanged: FILES,
+        const actorsChanged = getChangedActors({
+            actorConfigs: ACTOR_CONFIGS_GOOGLE_MAPS, isLatest: false, filepathsChanged: FILES, commits,
         });
 
         expect(actorsChanged).toEqual(ACTOR_CONFIGS_GOOGLE_MAPS.filter(({ isStandalone }) => !isStandalone));
-        expect(codeChanged).toBe(true);
     });
 });