apify-test-tools 0.6.0 → 0.6.2-beta.0

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

@@ -0,0 +1,212 @@
+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/bin/git.test.ts

@@ -1,14 +1,20 @@
-import { beforeEach, describe, expect, it, MockInstance, vi } from 'vitest';
-import { getChangedFiles, getCommits } from '../../../bin/git.js';
+import type { MockInstance } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { getChangedFiles, getCommits, parseBaseCommit } from '../../../bin/git.js';
 import * as Utils from '../../../bin/utils.js';
 
 describe('getCommits', () => {
     const sourceBranch = 'feature-branch';
     const targetBranch = 'main';
 
-    const commit1 = 'Commit1»¦«Author1»¦«Date1»¦«First Change On Feature';
-    const commit2 = 'Commit2»¦«Author1»¦«Date2»¦«Second Change On Feature';
-    const commit3 = 'Commit3»¦«Author1»¦«Date3»¦«Third Change On Feature';
+    const sha1 = '1'.repeat(40);
+    const sha2 = '2'.repeat(40);
+    const sha3 = '3'.repeat(40);
+
+    const commit1 = `${sha1}»¦«Author1»¦«Date1»¦«First Change On Feature`;
+    const commit2 = `${sha2}»¦«Author1»¦«Date2»¦«Second Change On Feature`;
+    const commit3 = `${sha3}»¦«Author1»¦«Date3»¦«Third Change On Feature`;
 
     let gitCommandSpy: MockInstance;
 
@@ -24,9 +30,9 @@ describe('getCommits', () => {
 
         // Assert
         expect(commits).toStrictEqual([
-            { sha: 'Commit1', author: 'Author1', date: 'Date1', message: 'First Change On Feature' },
-            { sha: 'Commit2', author: 'Author1', date: 'Date2', message: 'Second Change On Feature' },
-            { sha: 'Commit3', author: 'Author1', date: 'Date3', message: 'Third Change On Feature' },
+            { sha: sha1, author: 'Author1', date: 'Date1', message: 'First Change On Feature' },
+            { sha: sha2, author: 'Author1', date: 'Date2', message: 'Second Change On Feature' },
+            { sha: sha3, author: 'Author1', date: 'Date3', message: 'Third Change On Feature' },
         ]);
 
         expect(gitCommandSpy).toHaveBeenCalledTimes(1);
@@ -37,12 +43,12 @@ describe('getCommits', () => {
 
     it('should return commits after the base commit if provided', () => {
         // Act
-        const commits = getCommits({ sourceBranch, targetBranch, baseCommit: 'Commit1' });
+        const commits = getCommits({ sourceBranch, targetBranch, baseCommit: sha1 });
 
         // Assert
         expect(commits).toStrictEqual([
-            { sha: 'Commit2', author: 'Author1', date: 'Date2', message: 'Second Change On Feature' },
-            { sha: 'Commit3', author: 'Author1', date: 'Date3', message: 'Third Change On Feature' },
+            { sha: sha2, author: 'Author1', date: 'Date2', message: 'Second Change On Feature' },
+            { sha: sha3, author: 'Author1', date: 'Date3', message: 'Third Change On Feature' },
         ]);
 
         expect(gitCommandSpy).toHaveBeenCalledTimes(1);
@@ -53,13 +59,13 @@ describe('getCommits', () => {
 
     it('should return all commits if base commit is not found', () => {
         // Act
-        const commits = getCommits({ sourceBranch, targetBranch, baseCommit: 'NonExistingCommit' });
+        const commits = getCommits({ sourceBranch, targetBranch, baseCommit: 'a'.repeat(40) });
 
         // Assert
         expect(commits).toStrictEqual([
-            { sha: 'Commit1', author: 'Author1', date: 'Date1', message: 'First Change On Feature' },
-            { sha: 'Commit2', author: 'Author1', date: 'Date2', message: 'Second Change On Feature' },
-            { sha: 'Commit3', author: 'Author1', date: 'Date3', message: 'Third Change On Feature' },
+            { sha: sha1, author: 'Author1', date: 'Date1', message: 'First Change On Feature' },
+            { sha: sha2, author: 'Author1', date: 'Date2', message: 'Second Change On Feature' },
+            { sha: sha3, author: 'Author1', date: 'Date3', message: 'Third Change On Feature' },
         ]);
 
         expect(gitCommandSpy).toHaveBeenCalledTimes(1);
@@ -78,9 +84,11 @@ describe('getChangedFiles', () => {
 
     it('should return changed files between commits', () => {
         // Arrange
+        const firstSha = '1'.repeat(40);
+        const lastSha = '3'.repeat(40);
         const commits = [
-            { sha: 'Commit1', author: '', date: '', message: '' },
-            { sha: 'Commit3', author: '', date: '', message: '' },
+            { sha: firstSha, author: '', date: '', message: '' },
+            { sha: lastSha, author: '', date: '', message: '' },
         ];
 
         // Act
@@ -90,12 +98,13 @@ describe('getChangedFiles', () => {
         expect(changedFiles).toStrictEqual(['file1.txt', 'folder/file2.txt']);
 
         expect(gitCommandSpy).toHaveBeenCalledTimes(1);
-        expect(gitCommandSpy).toHaveBeenCalledWith(`git diff --name-only Commit1~..Commit3`);
+        expect(gitCommandSpy).toHaveBeenCalledWith(`git diff --name-only ${firstSha}~..${lastSha}`);
     });
 
     it('should handle only one commit', () => {
         // Arrange
-        const commits = [{ sha: 'Commit1', author: '', date: '', message: '' }];
+        const onlySha = '1'.repeat(40);
+        const commits = [{ sha: onlySha, author: '', date: '', message: '' }];
 
         // Act
         const changedFiles = getChangedFiles(commits);
@@ -104,6 +113,36 @@ describe('getChangedFiles', () => {
         expect(changedFiles).toStrictEqual(['file1.txt', 'folder/file2.txt']);
 
         expect(gitCommandSpy).toHaveBeenCalledTimes(1);
-        expect(gitCommandSpy).toHaveBeenCalledWith(`git diff --name-only Commit1~..Commit1`);
+        expect(gitCommandSpy).toHaveBeenCalledWith(`git diff --name-only ${onlySha}~..${onlySha}`);
+    });
+});
+
+const VALID_SHA = 'a'.repeat(40);
+const VALID_JSON = JSON.stringify({ sha: VALID_SHA, author: 'test', date: 'now', message: 'msg' });
+
+describe('parseBaseCommit', () => {
+    it('should return undefined for undefined input', () => {
+        expect(parseBaseCommit(undefined)).toBeUndefined();
+    });
+
+    it('should return undefined for empty string', () => {
+        expect(parseBaseCommit('')).toBeUndefined();
+    });
+
+    it('should accept a plain SHA string', () => {
+        expect(parseBaseCommit(VALID_SHA)).toBe(VALID_SHA);
+    });
+
+    it('should extract sha from a JSON commit object', () => {
+        expect(parseBaseCommit(VALID_JSON)).toBe(VALID_SHA);
+    });
+
+    it('should throw on an invalid SHA string', () => {
+        expect(() => parseBaseCommit('not-a-sha')).toThrow('Invalid base commit SHA');
+    });
+
+    it('should throw when JSON contains an invalid sha field', () => {
+        const badJson = JSON.stringify({ sha: 'bad', author: 'test', date: 'now', message: 'msg' });
+        expect(() => parseBaseCommit(badJson)).toThrow('Invalid base commit SHA');
     });
 });

package/test/unit/custom-matchers.test.ts

@@ -1,7 +1,8 @@
-import process from 'process';
-import { describe } from 'vitest';
+import process from 'node:process';
 
 import { ApifyClient } from 'apify-client';
+import { describe } from 'vitest';
+
 import { testStandbyActor, testTestActor } from '../../lib/lib.js';
 import { RunTestResult } from '../../lib/run-test-result.js';
 
@@ -11,13 +12,13 @@ enum PpeEventEnum {
     SEARCH_PAGE_SCRAPED = 'search-page-scraped',
     ADS_SCRAPED = 'ads-scraped',
 }
-const PPE_EVENT_CONST = {
-    ACTOR_START: 'actor-start',
-    ITEM_PUSHED: 'search-page-scraped',
-    ADS_SCRAPED: 'ads-scraped',
-} as const;
+type PPE_EVENT_CONST = {
+    ACTOR_START: 'actor-start';
+    ITEM_PUSHED: 'search-page-scraped';
+    ADS_SCRAPED: 'ads-scraped';
+};
 
-// TODO: Remake these tests. k5MNKmaDGHlABDn2I run doesn't exist and we probably don't want to depend on fixed run 
+// TODO: Remake these tests. k5MNKmaDGHlABDn2I run doesn't exist and we probably don't want to depend on fixed run
 describe.skip('custom-matchers', { timeout: 100_000 }, () => {
     testTestActor('basic', async ({ expect }) => {
         const apifyClient = new ApifyClient({ token: process.env.TESTER_APIFY_TOKEN });
@@ -43,7 +44,7 @@ describe.skip('custom-matchers', { timeout: 100_000 }, () => {
             },
         });
 
-        await expect(runResult).toFinishWith<(typeof PPE_EVENT_CONST)[keyof typeof PPE_EVENT_CONST]>({
+        await expect(runResult).toFinishWith<PPE_EVENT_CONST[keyof PPE_EVENT_CONST]>({
             datasetItemCount: { min: 1, max: 20 },
             chargedEventCounts: {
                 'actor-start': 1,

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', () => {