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

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

@@ -13,83 +13,83 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
     let gitCommandSpy: MockInstance;
 
     beforeEach(() => {
-        gitCommandSpy = vi.spyOn(Utils, 'spawnCommandInGhWorkspace');
+        gitCommandSpy = vi.spyOn(Utils, 'runGitCommand');
     });
 
     const mockGitCalls = (oldJson: string, newJson: string) => {
-        gitCommandSpy.mockReturnValueOnce(oldJson).mockReturnValueOnce(newJson);
+        gitCommandSpy.mockResolvedValueOnce(oldJson).mockResolvedValueOnce(newJson);
     };
 
-    test('returns true when nothing changed', () => {
+    test('returns true when nothing changed', async () => {
         const json = JSON.stringify({ type: 'string', title: 'My field' });
         mockGitCalls(json, json);
-        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
-    test('returns true when only title changes', () => {
+    test('returns true when only title changes', async () => {
         mockGitCalls(
             JSON.stringify({ type: 'string', title: 'Old title' }),
             JSON.stringify({ type: 'string', title: 'New title' }),
         );
-        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
-    test('returns true when only description changes', () => {
+    test('returns true when only description changes', async () => {
         mockGitCalls(
             JSON.stringify({ type: 'string', description: 'Old desc' }),
             JSON.stringify({ type: 'string', description: 'New desc' }),
         );
-        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
-    test('returns true when only example changes', () => {
+    test('returns true when only example changes', async () => {
         mockGitCalls(
             JSON.stringify({ type: 'string', example: 'foo' }),
             JSON.stringify({ type: 'string', example: 'bar' }),
         );
-        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
-    test('returns true when only enumTitles changes', () => {
+    test('returns true when only enumTitles changes', async () => {
         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);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
-    test('returns true when only sectionCaption changes', () => {
+    test('returns true when only sectionCaption changes', async () => {
         mockGitCalls(
             JSON.stringify({ sectionCaption: 'Old caption' }),
             JSON.stringify({ sectionCaption: 'New caption' }),
         );
-        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
-    test('returns true when only sectionDescription changes', () => {
+    test('returns true when only sectionDescription changes', async () => {
         mockGitCalls(JSON.stringify({ sectionDescription: 'Old' }), JSON.stringify({ sectionDescription: 'New' }));
-        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
-    test('returns false when a functional field (type) changes', () => {
+    test('returns false when a functional field (type) changes', async () => {
         mockGitCalls(
             JSON.stringify({ type: 'string', title: 'My field' }),
             JSON.stringify({ type: 'integer', title: 'My field' }),
         );
-        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
-    test('returns false when a functional field is added', () => {
+    test('returns false when a functional field is added', async () => {
         mockGitCalls(JSON.stringify({ title: 'My field' }), JSON.stringify({ title: 'My field', type: 'string' }));
-        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
-    test('returns false when a functional field is removed', () => {
+    test('returns false when a functional field is removed', async () => {
         mockGitCalls(JSON.stringify({ type: 'string', title: 'My field' }), JSON.stringify({ title: 'My field' }));
-        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
-    test('returns true when non-functional fields change at nested level (input schema properties)', () => {
+    test('returns true when non-functional fields change at nested level (input schema properties)', async () => {
         mockGitCalls(
             JSON.stringify({
                 type: 'object',
@@ -104,10 +104,10 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
                 },
             }),
         );
-        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
-    test('returns false when a functional nested field changes alongside non-functional ones', () => {
+    test('returns false when a functional nested field changes alongside non-functional ones', async () => {
         mockGitCalls(
             JSON.stringify({
                 type: 'object',
@@ -118,49 +118,54 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
                 properties: { myField: { type: 'integer', title: 'New title' } },
             }),
         );
-        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
-    test('returns false when a new property is added to input schema', () => {
+    test('returns false when a new property is added to input schema', async () => {
         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);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
-    test('returns false when a property is removed from input schema', () => {
+    test('returns false when a property is removed from input schema', async () => {
         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);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
-    test('returns false when invalid JSON in old content', () => {
+    test('returns false when invalid JSON in old content', async () => {
         mockGitCalls('not json', '{}');
-        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
-    test('returns false when invalid JSON in new content', () => {
+    test('returns false when invalid JSON in new content', async () => {
         mockGitCalls('{}', 'not json');
-        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
-    test('returns false when array content changes (not under a non-functional key)', () => {
+    test('returns false when git cannot read a schema version', async () => {
+        gitCommandSpy.mockRejectedValueOnce(new Error('missing schema'));
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
+    });
+
+    test('returns false when array content changes (not under a non-functional key)', async () => {
         mockGitCalls(JSON.stringify({ enum: [1, 2, 3] }), JSON.stringify({ enum: [1, 2, 4] }));
-        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
-    test('returns true when example array changes (non-functional key)', () => {
+    test('returns true when example array changes (non-functional key)', async () => {
         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);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
-    test('returns true for a realistic actor.json with only title/description change', () => {
+    test('returns true for a realistic actor.json with only title/description change', async () => {
         mockGitCalls(
             JSON.stringify({
                 actorSpecification: 1,
@@ -177,10 +182,10 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
                 version: '1.0',
             }),
         );
-        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
-    test('returns true when fields under properties are reordered', () => {
+    test('returns true when fields under properties are reordered', async () => {
         mockGitCalls(
             JSON.stringify({
                 type: 'object',
@@ -191,22 +196,22 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
                 properties: { fieldC: { type: 'boolean' }, fieldA: { type: 'string' }, fieldB: { type: 'integer' } },
             }),
         );
-        expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
-    test('returns false for a realistic actor.json with version change', () => {
+    test('returns false for a realistic actor.json with version change', async () => {
         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);
+        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
-    it('uses correct git refs: first-commit parent for old, last commit for new', () => {
+    it('uses correct git refs: first-commit parent for old, last commit for new', async () => {
         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');
+        await isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json');
+        expect(gitCommandSpy).toHaveBeenCalledWith(['show', 'Commit1~:actors/foo/actor.json']);
+        expect(gitCommandSpy).toHaveBeenCalledWith(['show', 'Commit3:actors/foo/actor.json']);
     });
 });

package/test/unit/bin/git-command.test.ts

@@ -0,0 +1,71 @@
+import os from 'node:os';
+import path from 'node:path';
+
+import { describe, expect, it } from 'vitest';
+
+import { getGitignoredPaths, GitCommandError, listRepoFilePaths, runGitCommand } from '../../../bin/utils.js';
+
+describe('runGitCommand', () => {
+    it('returns trimmed Git output', async () => {
+        await expect(
+            runGitCommand(['rev-parse', '--is-inside-work-tree'], {
+                cwd: process.cwd(),
+                operation: 'check whether the current directory is in a Git repository',
+            }),
+        ).resolves.toBe('true');
+    });
+
+    it('rejects on git exit code, not stderr', async () => {
+        const error: unknown = await runGitCommand(['rev-parse', '--verify', '--quiet'], {
+            cwd: process.cwd(),
+            operation: 'verify a commit',
+        }).catch((failure: unknown) => failure);
+        expect(error).toBeInstanceOf(GitCommandError);
+        if (error instanceof GitCommandError) {
+            expect(error.exitCode).toBe(1);
+            expect(error.gitError).toContain('Command failed: git rev-parse --verify --quiet');
+            expect(error.message).toContain('Failed to verify a commit.\nCommand:');
+            expect(error.stack).toContain('Failed to verify a commit.');
+            expect(error.cause).toBeInstanceOf(Error);
+        }
+    });
+
+    it('passes arguments literally and rejects Git failures', async () => {
+        await expect(
+            runGitCommand(['rev-parse', '--verify', 'HEAD; echo injected'], {
+                operation: 'verify a commit reference',
+            }),
+        ).rejects.toThrow('Command: git "rev-parse" "--verify" "HEAD; echo injected"\nGit error:');
+    });
+});
+
+describe('listRepoFilePaths', () => {
+    it('lists files under a subdirectory relative to the repository root', async () => {
+        const repoRoot = process.cwd();
+        await expect(listRepoFilePaths(repoRoot, path.join(repoRoot, 'bin'))).resolves.toContain('bin/utils.ts');
+    });
+});
+
+describe('getGitignoredPaths', () => {
+    it('returns an empty set for no paths', async () => {
+        await expect(getGitignoredPaths([])).resolves.toStrictEqual(new Set());
+    });
+
+    it('returns only paths ignored by the repository rules', async () => {
+        await expect(
+            getGitignoredPaths(['node_modules/example.js', 'bin/utils.ts', '.DS_Store'], process.cwd()),
+        ).resolves.toStrictEqual(new Set(['node_modules/example.js', '.DS_Store']));
+    });
+
+    it('returns an empty set when Git exits with code 1', async () => {
+        await expect(getGitignoredPaths(['bin/utils.ts'], process.cwd())).resolves.toStrictEqual(new Set());
+    });
+
+    it('rejects unexpected Git errors', async () => {
+        await expect(getGitignoredPaths(['bin/utils.ts'], os.tmpdir())).rejects.toThrow(
+            'Failed to check which repository paths are ignored.\n' +
+                'Command: git "check-ignore" "--" "bin/utils.ts"\n' +
+                'Git error: fatal: not a git repository',
+        );
+    });
+});