apify-test-tools 0.10.1-beta.6 → 0.10.1

package/test/unit/bin/dockerignore.test.ts

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import { buildDockerIgnoreMatcher, loadDockerIgnore } from '../../../bin/dockerignore.js';
+import { RelativeDir, RelativeFile } from '../../../bin/utils/path/repo-relative.js';
 
 const { fsMock } = vi.hoisted(() => ({
     fsMock: {
@@ -19,69 +20,72 @@ describe('loadDockerIgnore', () => {
         fsMock.readFileSync.mockImplementation(() => {
             throw new Error('ENOENT');
         });
-        const matcher = loadDockerIgnore('actors/my-actor');
+        const matcher = loadDockerIgnore(new RelativeDir('actors/my-actor'));
         expect(matcher('actors/my-actor/src/main.ts')).toBe(false);
         expect(matcher('actors/my-actor/node_modules/foo.js')).toBe(false);
     });
 
     it('matches files listed in .dockerignore', () => {
         fsMock.readFileSync.mockReturnValue('node_modules\n*.log\n');
-        const matcher = loadDockerIgnore('');
+        const matcher = loadDockerIgnore(new RelativeDir(''));
         expect(matcher('node_modules/foo/bar.js')).toBe(true);
         expect(matcher('debug.log')).toBe(true);
     });
 
     it('does not match files not in .dockerignore', () => {
         fsMock.readFileSync.mockReturnValue('node_modules\n');
-        const matcher = loadDockerIgnore('');
+        const matcher = loadDockerIgnore(new RelativeDir(''));
         expect(matcher('src/main.ts')).toBe(false);
     });
 
     it.each(['dist', 'dist/'])('handles directory pattern "%s"', (pattern) => {
         fsMock.readFileSync.mockReturnValue(`${pattern}\n`);
-        const matcher = loadDockerIgnore('');
+        const matcher = loadDockerIgnore(new RelativeDir(''));
         expect(matcher('dist/bundle.js')).toBe(true);
         expect(matcher('src/dist-utils.ts')).toBe(false);
     });
 
     it('handles negation patterns', () => {
         fsMock.readFileSync.mockReturnValue('*.log\n!important.log\n');
-        const matcher = loadDockerIgnore('');
+        const matcher = loadDockerIgnore(new RelativeDir(''));
         expect(matcher('debug.log')).toBe(true);
         expect(matcher('important.log')).toBe(false);
     });
 
     it('strips dockerContextDir prefix before matching', () => {
         fsMock.readFileSync.mockReturnValue('node_modules\n');
-        const matcher = loadDockerIgnore('actors/shopify');
+        const matcher = loadDockerIgnore(new RelativeDir('actors/shopify'));
         expect(matcher('actors/shopify/node_modules/foo.js')).toBe(true);
         expect(matcher('actors/shopify/src/main.ts')).toBe(false);
     });
 
     it('returns false for files outside dockerContextDir', () => {
         fsMock.readFileSync.mockReturnValue('*\n');
-        const matcher = loadDockerIgnore('actors/shopify');
+        const matcher = loadDockerIgnore(new RelativeDir('actors/shopify'));
         expect(matcher('other-actor/src/main.ts')).toBe(false);
     });
 
-    it('reads .dockerignore from the resolved, absolute dockerContextDir root', () => {
+    it('treats dockerContextDir paths as case-sensitive', () => {
+        fsMock.readFileSync.mockReturnValue('*\n');
+        const matcher = loadDockerIgnore(new RelativeDir('actors/shopify'));
+        expect(matcher('Actors/shopify/src/main.ts')).toBe(false);
+    });
+
+    it('reads .dockerignore from the resolved dockerContextDir root', () => {
         fsMock.readFileSync.mockReturnValue('');
-        loadDockerIgnore('actors/shopify');
-        expect(fsMock.readFileSync).toHaveBeenCalledWith(
-            path.join(path.resolve('actors/shopify'), '.dockerignore'),
-            'utf-8',
-        );
+        loadDockerIgnore(new RelativeDir('actors/shopify'));
+        expect(fsMock.readFileSync).toHaveBeenCalledWith(path.join('actors/shopify', '.dockerignore'), 'utf-8');
     });
 
     it('reads .dockerignore from the resolved repo root when dockerContextDir is empty', () => {
         fsMock.readFileSync.mockReturnValue('');
-        loadDockerIgnore('');
-        expect(fsMock.readFileSync).toHaveBeenCalledWith(path.join(path.resolve(''), '.dockerignore'), 'utf-8');
+        loadDockerIgnore(new RelativeDir(''));
+        expect(fsMock.readFileSync).toHaveBeenCalledWith(path.join('.', '.dockerignore'), 'utf-8');
     });
 
     it('handles comments and blank lines', () => {
         fsMock.readFileSync.mockReturnValue('# this is a comment\n\nnode_modules\n');
-        const matcher = loadDockerIgnore('');
+        const matcher = loadDockerIgnore(new RelativeDir(''));
         expect(matcher('node_modules/foo.js')).toBe(true);
         expect(matcher('src/main.ts')).toBe(false);
     });
@@ -90,7 +94,8 @@ describe('loadDockerIgnore', () => {
         // The common real-world .dockerignore style: every pattern prefixed with "./",
         // including a negation re-including one of the otherwise-matched files.
         fsMock.readFileSync.mockReturnValue('./node_modules\n./*.log\n!./keep.log\n');
-        const matcher = loadDockerIgnore('');
+        const matcher = loadDockerIgnore(new RelativeDir(''));
+        // expect(new RelativeDir('').path).toBe('maemresmtioear');
         expect(matcher('node_modules/foo.js')).toBe(true);
         expect(matcher('debug.log')).toBe(true);
         expect(matcher('keep.log')).toBe(false);
@@ -99,25 +104,20 @@ describe('loadDockerIgnore', () => {
 });
 
 describe('buildDockerIgnoreMatcher', () => {
-    it('treats paths as already relative to absoluteRootDir when hoistFrom is left at its default', () => {
+    it('Matcher correctly resolves paths relative to the .dockerignore file', () => {
+        const rootDir = new RelativeDir('repo/actors/shopify');
         fsMock.readFileSync.mockReturnValue('test/\n*.log\n');
-        const matcher = buildDockerIgnoreMatcher('/repo/actors/shopify');
-        expect(matcher('test/fixture.json')).toBe(true);
-        expect(matcher('debug.log')).toBe(true);
+        const matcher = buildDockerIgnoreMatcher(rootDir.joinFile('.dockerignore'));
+        expect(matcher(`${rootDir.path}/test/fixture.json`)).toBe(true);
+        expect(matcher(`${rootDir.path}/debug.log`)).toBe(true);
         expect(matcher('main.js')).toBe(false);
     });
 
-    it('reads .dockerignore from the given absoluteRootDir', () => {
-        fsMock.readFileSync.mockReturnValue('');
-        buildDockerIgnoreMatcher('/repo/actors/shopify');
-        expect(fsMock.readFileSync).toHaveBeenCalledWith('/repo/actors/shopify/.dockerignore', 'utf-8');
-    });
-
     it('returns no-op matcher when .dockerignore is absent', () => {
         fsMock.readFileSync.mockImplementation(() => {
             throw new Error('ENOENT');
         });
-        const matcher = buildDockerIgnoreMatcher('/repo/actors/shopify');
+        const matcher = buildDockerIgnoreMatcher(new RelativeFile('repo/actors/shopify/.dockerignore'));
         expect(matcher('main.js')).toBe(false);
     });
 });

package/test/unit/bin/utils/config/load-config.test.ts

@@ -69,6 +69,44 @@ describe('loadActorConfig', () => {
         expect(loadActorConfig(entry()).dockerContextDir.path).toBe('actors/shopify');
     });
 
+    it.each([
+        ['dockerfile', 'Dockerfile'],
+        ['readme', 'README.md'],
+        ['changelog', 'CHANGELOG.md'],
+    ] as const)('follows Apify default locations for %s', async (field, filename) => {
+        await writeActorJson();
+
+        expect(loadActorConfig(entry()).actorJson[field]).toBeUndefined();
+
+        await writeFiles({ [`actors/shopify/${filename}`]: '' });
+        expect(loadActorConfig(entry()).actorJson[field]?.path).toBe(`actors/shopify/${filename}`);
+
+        await writeFiles({ [`actors/shopify/.actor/${filename}`]: '' });
+        expect(loadActorConfig(entry()).actorJson[field]?.path).toBe(`actors/shopify/.actor/${filename}`);
+
+        await writeActorJson({ [field]: '../custom-file' });
+        expect(loadActorConfig(entry()).actorJson[field]?.path).toBe('actors/shopify/custom-file');
+    });
+
+    it.each([
+        ['dockerfile', 'Dockerfile'],
+        ['readme', 'rEaDmE.md'],
+        ['changelog', 'CHANGELOG.md'],
+    ] as const)(
+        'matches default %s filenames case insensitively and returns the actual path',
+        async (field, filename) => {
+            await writeActorJson();
+            await writeFiles({
+                [`actors/shopify/.actor/${filename.toLowerCase()}`]: '',
+                [`actors/shopify/${filename}`]: '',
+            });
+
+            expect(loadActorConfig(entry()).actorJson[field]?.path).toBe(
+                `actors/shopify/.actor/${filename.toLowerCase()}`,
+            );
+        },
+    );
+
     it('resolves path fields from actor.json while allowing inline schemas', async () => {
         await writeActorJson({
             readme: '../README.md',
@@ -176,13 +214,22 @@ describe('readConfigFile', () => {
             'actors/shopify/.actor/actor.json': actorJson({}),
         });
 
-        expect(await readConfigFile(emptyActorSelection)).toEqual([
+        const actors = await readConfigFile(emptyActorSelection);
+        expect(
+            actors.map(({ actorFullName, folder, tokenEnvVar, dockerContextDir, contextPaths }) => ({
+                actorFullName,
+                folder: folder.path,
+                tokenEnvVar,
+                dockerContextDir: dockerContextDir.path,
+                contextPaths: contextPaths.map((contextPath) => contextPath.path),
+            })),
+        ).toEqual([
             {
                 actorFullName: 'apify/root',
-                folder: '',
+                folder: '.',
                 tokenEnvVar: 'APIFY_TOKEN_APIFY',
-                dockerContextDir: '',
-                contextPaths: [''],
+                dockerContextDir: '.',
+                contextPaths: ['.'],
             },
             {
                 actorFullName: 'myteam/shopify',
@@ -192,6 +239,9 @@ describe('readConfigFile', () => {
                 contextPaths: ['actors/shopify', 'packages'],
             },
         ]);
+        expect(actors.every((actor) => actor.folder instanceof ExistingDir)).toBe(true);
+        expect(actors.every((actor) => actor.dockerContextDir instanceof RelativeDir)).toBe(true);
+        expect(actors.every((actor) => actor.actorJson.file instanceof ExistingFile)).toBe(true);
     });
 
     it('throws when config file is missing', async () => {

package/test/unit/bin/utils/path/repo-relative.test.ts

@@ -34,6 +34,12 @@ describe('ExistingDir', () => {
 });
 
 describe('ExistingFile', () => {
+    it('checks whether a relative file exists before asserting it', () => {
+        expect(file('package.json').exists()).toBe(true);
+        expect(file('missing.txt').exists()).toBe(false);
+        expect(file('bin').exists()).toBe(false);
+    });
+
     it('validates files through initialize', () => {
         expect(ExistingFile.initialize(file('package.json')).path).toBe('package.json');
         expect(() => ExistingFile.initialize(file('package.json/missing'))).toThrow();

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

@@ -1,34 +1,65 @@
-import type { MockInstance } from 'vitest';
-import { beforeEach, describe, expect, test, vi } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { afterAll, describe, expect, test } from 'vitest';
 
 import { getChangedActors } from '../../bin/diff-changes.js';
-import * as DiffJsonSchema from '../../bin/diff-json-schema.js';
 import type { ActorConfig, Commit } from '../../bin/types.js';
+import { ExistingDir, ExistingFile, RelativeDir, RelativeFile } from '../../bin/utils/path/repo-relative.js';
+
+const originalCwd = process.cwd();
+const fixtureRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'apify-should-build-'));
+process.chdir(fixtureRoot);
+
+afterAll(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(fixtureRoot, { recursive: true, force: true });
+});
+
+const actorConfig = (
+    actorFullName: string,
+    folder: string,
+    tokenEnvVar: string,
+    dockerContextDir = '.',
+): ActorConfig => {
+    const actorJsonPath = path.posix.join(folder, '.actor/actor.json');
+    fs.mkdirSync(path.posix.dirname(actorJsonPath), { recursive: true });
+    fs.writeFileSync(actorJsonPath, '{}');
+    const contextPath = new RelativeDir(dockerContextDir);
+    return {
+        actorFullName,
+        folder: new ExistingDir(folder),
+        tokenEnvVar,
+        actorJson: {
+            file: new ExistingFile(actorJsonPath),
+            dockerContextDir: contextPath,
+            changelog: new RelativeFile('CHANGELOG.md'),
+        },
+        dockerContextDir: contextPath,
+        contextPaths: [contextPath],
+    };
+};
 
 describe('Should build and test parser', () => {
     // From https://github.com/apify-store/testing-repo-for-github-actions
     const ACTOR_CONFIGS: ActorConfig[] = [
-        {
-            actorFullName: 'lukaskrivka/testing-github-integration-1',
-            folder: 'actors/lukaskrivka_testing-github-integration-1',
-            tokenEnvVar: 'APIFY_TOKEN_LUKASKRIVKA',
-            dockerContextDir: '',
-            contextPaths: [''],
-        },
-        {
-            actorFullName: 'lukaskrivka/testing-github-integration-2',
-            folder: 'actors/lukaskrivka_testing-github-integration-2',
-            tokenEnvVar: 'APIFY_TOKEN_LUKASKRIVKA',
-            dockerContextDir: '',
-            contextPaths: [''],
-        },
-        {
-            actorFullName: 'lukaskrivka/test-standalone',
-            folder: 'standalone-actors/lukaskrivka_test-standalone',
-            tokenEnvVar: 'APIFY_TOKEN_LUKASKRIVKA',
-            dockerContextDir: 'standalone-actors/lukaskrivka_test-standalone',
-            contextPaths: ['standalone-actors/lukaskrivka_test-standalone'],
-        },
+        actorConfig(
+            'lukaskrivka/testing-github-integration-1',
+            'actors/lukaskrivka_testing-github-integration-1',
+            'APIFY_TOKEN_LUKASKRIVKA',
+        ),
+        actorConfig(
+            'lukaskrivka/testing-github-integration-2',
+            'actors/lukaskrivka_testing-github-integration-2',
+            'APIFY_TOKEN_LUKASKRIVKA',
+        ),
+        actorConfig(
+            'lukaskrivka/test-standalone',
+            'standalone-actors/lukaskrivka_test-standalone',
+            'APIFY_TOKEN_LUKASKRIVKA',
+            'standalone-actors/lukaskrivka_test-standalone',
+        ),
     ];
 
     const commits: Commit[] = [
@@ -36,15 +67,6 @@ describe('Should build and test parser', () => {
         { sha: 'Commit3', author: '', date: '', message: '' },
     ];
 
-    let isCosmeticOnlyJsonSchemaSpy: MockInstance;
-
-    beforeEach(() => {
-        // Default: JSON changes are functional (triggers build/test)
-        isCosmeticOnlyJsonSchemaSpy = vi
-            .spyOn(DiffJsonSchema, 'isCosmeticOnlyJsonSchemaChange')
-            .mockResolvedValue(false);
-    });
-
     test('Ignores dev-only readme', async () => {
         const FILES = ['README.md', 'code/README.md', 'shared/README.md'];
 
@@ -59,7 +81,7 @@ describe('Should build and test parser', () => {
     });
 
     test('Ignores other ignored files and folders', async () => {
-        const FILES = ['.vscode/', '.gitignore', '.husky/', '.eslintrc', '.editorconfig'];
+        const FILES = ['.vscode/settings.json', '.gitignore', '.husky/pre-commit', '.eslintrc', '.editorconfig'];
 
         const actorsChanged = await getChangedActors({
             actorConfigs: ACTOR_CONFIGS,
@@ -84,8 +106,8 @@ describe('Should build and test parser', () => {
         expect(actorsChanged).toEqual(ACTOR_CONFIGS.slice(0, 2));
     });
 
-    test('Root-level changelog is cosmetic for every actor, only on latest', async () => {
-        const FILES = ['shared/CHANGELOG.md', 'CHANGELOG.md'];
+    test('Configured changelog is cosmetic for every actor, only on latest', async () => {
+        const FILES = ['CHANGELOG.md'];
 
         const actorsChangedNotLatest = await getChangedActors({
             actorConfigs: ACTOR_CONFIGS,
@@ -104,7 +126,7 @@ describe('Should build and test parser', () => {
         expect(actorsChangedLatest).toEqual(ACTOR_CONFIGS);
     });
 
-    test('A changelog nested inside one actor own folder is excluded for sibling actors, only triggers that actor', async () => {
+    test('A changelog nested inside one actor own folder is excluded for sibling actors', async () => {
         const FILES = ['actors/lukaskrivka_testing-github-integration-1/CHANGELOG.md'];
 
         const actorsChanged = await getChangedActors({
@@ -135,7 +157,6 @@ describe('Should build and test parser', () => {
             'actors/lukaskrivka_testing-github-integration-1/.actor/actor.json',
             'standalone-actors/lukaskrivka_test-standalone/Dockerfile',
         ];
-        // Default mock returns false = functional change
 
         const actorsChanged = await getChangedActors({
             actorConfigs: ACTOR_CONFIGS,
@@ -166,7 +187,6 @@ describe('Should build and test parser', () => {
             'code/src/main.ts',
             'standalone-actors/lukaskrivka_test-standalone/Dockerfile',
         ];
-        // Default mock returns false = functional change for the JSON file
 
         const actorsChanged = await getChangedActors({
             actorConfigs: ACTOR_CONFIGS,
@@ -180,8 +200,8 @@ describe('Should build and test parser', () => {
 
     test('Specific Actor non-functional configs updated', async () => {
         const FILES = [
-            'actors/lukaskrivka_testing-github-integration-2/.actor/README.md',
-            'standalone-actors/lukaskrivka_test-standalone/CHANGELOG.md',
+            'actors/lukaskrivka_testing-github-integration-2/README.md',
+            'standalone-actors/lukaskrivka_test-standalone/README.md',
         ];
 
         const actorsChanged = await getChangedActors({
@@ -194,9 +214,8 @@ describe('Should build and test parser', () => {
         expect(actorsChanged).toEqual([]);
     });
 
-    test('JSON file with cosmetic-only changes in PR context (isLatest=false) skips tests', async () => {
+    test('Actor JSON changes in PR context trigger tests', async () => {
         const FILES = ['actors/lukaskrivka_testing-github-integration-1/.actor/actor.json'];
-        isCosmeticOnlyJsonSchemaSpy.mockResolvedValue(true);
 
         const actorsChanged = await getChangedActors({
             actorConfigs: ACTOR_CONFIGS,
@@ -205,12 +224,11 @@ describe('Should build and test parser', () => {
             commits,
         });
 
-        expect(actorsChanged).toEqual([]);
+        expect(actorsChanged).toEqual([ACTOR_CONFIGS[0]]);
     });
 
-    test('JSON file with cosmetic-only changes in latest context still triggers build', async () => {
+    test('Actor JSON changes in latest context trigger builds', async () => {
         const FILES = ['actors/lukaskrivka_testing-github-integration-1/.actor/actor.json'];
-        isCosmeticOnlyJsonSchemaSpy.mockResolvedValue(true);
 
         const actorsChanged = await getChangedActors({
             actorConfigs: ACTOR_CONFIGS,
@@ -224,7 +242,6 @@ describe('Should build and test parser', () => {
 
     test('JSON file with functional changes triggers tests', async () => {
         const FILES = ['actors/lukaskrivka_testing-github-integration-1/.actor/actor.json'];
-        // Default mock returns false = functional change
 
         const actorsChanged = await getChangedActors({
             actorConfigs: ACTOR_CONFIGS,
@@ -236,15 +253,11 @@ describe('Should build and test parser', () => {
         expect(actorsChanged).toEqual([ACTOR_CONFIGS[0]]);
     });
 
-    test('Mix: one actor has cosmetic-only JSON change, another has functional JSON change', async () => {
+    test('JSON changes in two actor folders trigger both actors', async () => {
         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(
-            async (_commits, filepath: string) => !filepath.includes('input_schema.json'),
-        );
 
         const actorsChanged = await getChangedActors({
             actorConfigs: ACTOR_CONFIGS,
@@ -253,13 +266,11 @@ describe('Should build and test parser', () => {
             commits,
         });
 
-        // Only the second actor (functional change) should be built and tested
-        expect(actorsChanged).toEqual([ACTOR_CONFIGS[1]]);
+        expect(actorsChanged).toEqual(ACTOR_CONFIGS.slice(0, 2));
     });
 
-    test('Narrow-context actor with cosmetic-only JSON change in PR context skips tests', async () => {
+    test('Narrow-context actor JSON change in PR context triggers tests', async () => {
         const FILES = ['standalone-actors/lukaskrivka_test-standalone/.actor/actor.json'];
-        isCosmeticOnlyJsonSchemaSpy.mockResolvedValue(true);
 
         const actorsChanged = await getChangedActors({
             actorConfigs: ACTOR_CONFIGS,
@@ -268,7 +279,7 @@ describe('Should build and test parser', () => {
             commits,
         });
 
-        expect(actorsChanged).toEqual([]);
+        expect(actorsChanged).toEqual([ACTOR_CONFIGS[2]]);
     });
 
     test('Google Maps real user-case that had undefined', async () => {
@@ -288,70 +299,36 @@ describe('Should build and test parser', () => {
         ];
 
         const ACTOR_CONFIGS_GOOGLE_MAPS: ActorConfig[] = [
-            {
-                // Edge case of capitals in actor name :)
-                actorFullName: 'compass/Google-Maps-Reviews-Scraper',
-                folder: 'actors/compass_Google-Maps-Reviews-Scraper',
-                tokenEnvVar: 'APIFY_TOKEN_COMPASS',
-                dockerContextDir: '',
-                contextPaths: [''],
-            },
-            {
-                actorFullName: 'compass/crawler-google-places',
-                folder: 'actors/compass_crawler-google-places',
-                tokenEnvVar: 'APIFY_TOKEN_COMPASS',
-                dockerContextDir: '',
-                contextPaths: [''],
-            },
-            {
-                actorFullName: 'compass/easy-google-maps',
-                folder: 'actors/compass_easy-google-maps',
-                tokenEnvVar: 'APIFY_TOKEN_COMPASS',
-                dockerContextDir: '',
-                contextPaths: [''],
-            },
-            {
-                actorFullName: 'compass/google-maps-extractor',
-                folder: 'actors/compass_google-maps-extractor',
-                tokenEnvVar: 'APIFY_TOKEN_COMPASS',
-                dockerContextDir: '',
-                contextPaths: [''],
-            },
-            {
-                actorFullName: 'compass/google-places-api',
-                folder: 'actors/compass_google-places-api',
-                tokenEnvVar: 'APIFY_TOKEN_COMPASS',
-                dockerContextDir: '',
-                contextPaths: [''],
-            },
-            {
-                actorFullName: 'lukaskrivka/google-maps-with-contact-details',
-                folder: 'actors/lukaskrivka_google-maps-with-contact-details',
-                tokenEnvVar: 'APIFY_TOKEN_LUKASKRIVKA',
-                dockerContextDir: '',
-                contextPaths: [''],
-            },
-            {
-                actorFullName: 'natasha.lekh/gas-prices-scraper',
-                folder: 'actors/natasha.lekh_gas-prices-scraper',
-                tokenEnvVar: 'APIFY_TOKEN_NATASHA_LEKH',
-                dockerContextDir: '',
-                contextPaths: [''],
-            },
-            {
-                actorFullName: 'natasha.lekh/vegan-places-finder',
-                folder: 'actors/natasha.lekh_vegan-places-finder',
-                tokenEnvVar: 'APIFY_TOKEN_NATASHA_LEKH',
-                dockerContextDir: '',
-                contextPaths: [''],
-            },
-            {
-                actorFullName: 'lukaskrivka/google-maps-scraper-orchestrator',
-                folder: 'standalone-actors/lukaskrivka_google-maps-scraper-orchestrator',
-                tokenEnvVar: 'APIFY_TOKEN_LUKASKRIVKA',
-                dockerContextDir: 'standalone-actors/lukaskrivka_google-maps-scraper-orchestrator',
-                contextPaths: ['standalone-actors/lukaskrivka_google-maps-scraper-orchestrator'],
-            },
+            actorConfig(
+                'compass/Google-Maps-Reviews-Scraper',
+                'actors/compass_Google-Maps-Reviews-Scraper',
+                'APIFY_TOKEN_COMPASS',
+            ),
+            actorConfig('compass/crawler-google-places', 'actors/compass_crawler-google-places', 'APIFY_TOKEN_COMPASS'),
+            actorConfig('compass/easy-google-maps', 'actors/compass_easy-google-maps', 'APIFY_TOKEN_COMPASS'),
+            actorConfig('compass/google-maps-extractor', 'actors/compass_google-maps-extractor', 'APIFY_TOKEN_COMPASS'),
+            actorConfig('compass/google-places-api', 'actors/compass_google-places-api', 'APIFY_TOKEN_COMPASS'),
+            actorConfig(
+                'lukaskrivka/google-maps-with-contact-details',
+                'actors/lukaskrivka_google-maps-with-contact-details',
+                'APIFY_TOKEN_LUKASKRIVKA',
+            ),
+            actorConfig(
+                'natasha.lekh/gas-prices-scraper',
+                'actors/natasha.lekh_gas-prices-scraper',
+                'APIFY_TOKEN_NATASHA_LEKH',
+            ),
+            actorConfig(
+                'natasha.lekh/vegan-places-finder',
+                'actors/natasha.lekh_vegan-places-finder',
+                'APIFY_TOKEN_NATASHA_LEKH',
+            ),
+            actorConfig(
+                'lukaskrivka/google-maps-scraper-orchestrator',
+                'standalone-actors/lukaskrivka_google-maps-scraper-orchestrator',
+                'APIFY_TOKEN_LUKASKRIVKA',
+                'standalone-actors/lukaskrivka_google-maps-scraper-orchestrator',
+            ),
         ];
 
         const actorsChanged = await getChangedActors({