apify-test-tools 0.8.6 → 0.9.0-beta.0

package/lib/lib.ts

@@ -24,8 +24,8 @@ try {
 }
 
 const config = actorBuilds.reduce<Map<string, ActorBuild>>((map, cfg) => {
-    map.set(cfg.actorName, cfg);
-    map.set(cfg.actorId, cfg);
+    map.set(cfg.actorFullName, cfg);
+    map.set(cfg.actorRawId, cfg);
     return map;
 }, new Map<string, ActorBuild>());
 
@@ -51,8 +51,11 @@ const DEFAULT_TEST_ACTOR_OPTIONS: ActorTestOptions = {
     timeout: DEFAULT_TEST_RUN_DURATION_MS,
 };
 
+/**
+ * @param actorId - The actor's raw platform ID or its full name (`owner/name`, e.g. `"apify/web-scraper"`).
+ */
 export const testActor = <T>(
-    actorName: string,
+    actorId: string,
     testName: string,
     fn: TestFunction<{ run: ReturnType<typeof createStartRunFn<T>> }>,
     testOptions?: ActorTestOptions,
@@ -61,13 +64,13 @@ export const testActor = <T>(
         ...DEFAULT_TEST_ACTOR_OPTIONS,
         ...testOptions,
     };
-    const name = `${actorName}: ${testName}`;
-    const shouldRun = !!RUN_ALL_PLATFORM_TESTS || config.has(actorName);
+    const name = `${actorId}: ${testName}`;
+    const shouldRun = !!RUN_ALL_PLATFORM_TESTS || config.has(actorId);
     vitestTest.runIf(shouldRun)(name, options, async <TYPE extends TestContext>(context: TYPE) => {
         const { expect, ...rest } = context;
         await fn({
             expect: extendExpect(expect),
-            run: createStartRunFn(actorName, context),
+            run: createStartRunFn(actorId, context),
             ...rest,
         });
     });
@@ -79,9 +82,12 @@ export const testActor = <T>(
  *
  * Using task is just current shortcoming of standby feature but ideally we would use Actor directly
  */
+/**
+ * @param actorId - The actor's raw platform ID or its full name (`owner/name`, e.g. `"apify/web-scraper"`).
+ */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const testStandbyActor = <I = any, O = any>(
-    actorName: string,
+    actorId: string,
     testName: string,
     fn: TestFunction<{ callStandby: ReturnType<typeof createStartStandbyFn<I, O>> }>,
     testOptions?: ActorTestOptions,
@@ -90,11 +96,11 @@ export const testStandbyActor = <I = any, O = any>(
         ...DEFAULT_TEST_ACTOR_OPTIONS,
         ...testOptions,
     };
-    const name = `${actorName}: ${testName}`;
-    const shouldRun = !!RUN_ALL_PLATFORM_TESTS || config.has(actorName);
+    const name = `${actorId}: ${testName}`;
+    const shouldRun = !!RUN_ALL_PLATFORM_TESTS || config.has(actorId);
 
     vitestTest.runIf(shouldRun)(name, options, async <T extends TestContext>(context: T) => {
-        const standbyTask = await createStandbyTask(actorName, config.get(actorName)?.buildNumber);
+        const standbyTask = await createStandbyTask(actorId, config.get(actorId)?.buildNumber);
         const { expect, ...rest } = context;
 
         // NOTE: we wrap `fn` in try/finally so cleanup (deleting the task) always runs afterwards
@@ -193,20 +199,20 @@ interface StandbyTask {
  *
  * @throws if actor doesn't exist or it doesn't support standby mode.
  */
-const createStandbyTask = async (actorNameOrId: string, buildNumber?: string): Promise<StandbyTask> => {
-    const actor = apifyClient.actor(actorNameOrId);
+const createStandbyTask = async (actorId: string, buildNumber?: string): Promise<StandbyTask> => {
+    const actor = apifyClient.actor(actorId);
 
     const actorInfo = (await actor.get()) as Actor & { standbyUrl?: string };
     if (!actorInfo) {
-        throw new Error(`Actor "${actorNameOrId}" not found`);
+        throw new Error(`Actor "${actorId}" not found`);
     }
 
     if (!actorInfo.standbyUrl) {
-        throw new Error(`Actor "${actorNameOrId}" doesn't support standby mode`);
+        throw new Error(`Actor "${actorId}" doesn't support standby mode`);
     }
 
     if (!actorInfo.actorStandby) {
-        throw new Error(`Actor "${actorNameOrId} doesn't contain actorStandby options`);
+        throw new Error(`Actor "${actorId} doesn't contain actorStandby options`);
     }
     const { isEnabled, ...defaultActorStandby } = actorInfo.actorStandby;
     delete defaultActorStandby.disableStandbyFieldsOverride;
@@ -225,9 +231,9 @@ const createStandbyTask = async (actorNameOrId: string, buildNumber?: string): P
         const randomValue = Math.random().toString(10).slice(2).padEnd(randomValueLength, '0');
         const name = `test-${randomValue.slice(0, randomValueLength)}`;
         const newTask = (await apifyClient.tasks().create({
-            actId: actorNameOrId,
+            actId: actorId,
             actorStandby: actorStandbyOptions,
-            description: `Task for testing standby version ${build} of actor "${actorNameOrId}"`,
+            description: `Task for testing standby version ${build} of actor "${actorId}"`,
             title,
             name,
         })) as Task & { standbyUrl?: string };
@@ -247,9 +253,9 @@ const createStandbyTask = async (actorNameOrId: string, buildNumber?: string): P
     }
 };
 
-const createStartRunFn = <T>(actorNameOrId: string, testContext: TestContext) => {
+const createStartRunFn = <T>(actorId: string, testContext: TestContext) => {
     const { annotate, task } = testContext;
-    const actorConfig = config.get(actorNameOrId);
+    const actorConfig = config.get(actorId);
     const build = actorConfig?.buildNumber;
     const buildId = actorConfig?.buildId;
     return async (runOptions: RunOptions<T>) => {
@@ -263,10 +269,10 @@ const createStartRunFn = <T>(actorNameOrId: string, testContext: TestContext) =>
             return new RunTestResult(apifyClient, run);
         }
 
-        const actor = apifyClient.actor(actorNameOrId);
+        const actor = apifyClient.actor(actorId);
 
         const actorInput = {
-            ...(prefilledInput && (await getActorPrefilledInput(apifyClient, actorNameOrId, buildId))),
+            ...(prefilledInput && (await getActorPrefilledInput(apifyClient, actorId, buildId))),
             ...input,
         };
         const run = await actor.call(actorInput, { build, log: null, ...options });
@@ -277,7 +283,7 @@ const createStartRunFn = <T>(actorNameOrId: string, testContext: TestContext) =>
         task.meta = {
             runId: run.id,
             runLink,
-            actorName: actorNameOrId,
+            actorId: actorConfig?.actorFullName ?? actorId,
         };
 
         // waiting for datasetItemCount and chargedEventCounts to sync

package/lib/types.ts

@@ -3,9 +3,9 @@ import type { Assertion, TestOptions } from 'vitest';
 
 export type ActorBuild = {
     buildId: string;
-    actorId: string;
+    actorRawId: string;
     buildNumber: string;
-    actorName: string;
+    actorFullName: string;
 };
 
 export type RunOptions<T> = {

package/lib/utils.ts

@@ -6,11 +6,11 @@ import type { ApifyClient } from 'apify-client';
  */
 export const getActorPrefilledInput = async (
     apifyClient: ApifyClient,
-    actorNameOrId: string,
+    actorId: string,
     buildId: string | undefined,
 ) => {
     if (!buildId) {
-        const actorInfo = await apifyClient.actor(actorNameOrId).get();
+        const actorInfo = await apifyClient.actor(actorId).get();
 
         const defaultBuildTag = actorInfo?.defaultRunOptions.build;
 
@@ -19,7 +19,7 @@ export const getActorPrefilledInput = async (
         buildId = taggedBuild?.buildId;
 
         if (!buildId) {
-            console.error(`Coudn't find default build for actor ${actorNameOrId}. Prefilled values will not be used.`);
+            console.error(`Coudn't find default build for actor ${actorId}. Prefilled values will not be used.`);
             return {};
         }
     }
@@ -34,7 +34,7 @@ export const getActorPrefilledInput = async (
 
     if (!inputSchema) {
         console.error(
-            `Coudn't find input schema definition for actor ${actorNameOrId}, build ${buildId}.`,
+            `Coudn't find input schema definition for actor ${actorId}, build ${buildId}.`,
             'Prefilled values will not be used',
         );
         return {};

package/package.json

@@ -1,63 +1,64 @@
 {
-    "name": "apify-test-tools",
-    "version": "0.8.6",
-    "type": "module",
-    "description": "TBD",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/apify/apify-test-tools.git"
-    },
-    "engines": {
-        "node": ">=18.0.0"
-    },
-    "bin": {
-        "apify-test-tools": "dist/bin/main.js"
-    },
-    "types": "./dist/index.d.ts",
-    "main": "./dist/lib/lib.js",
-    "dependencies": {
-        "@apify/consts": "^2.43.0",
-        "@slack/web-api": "^7.9.2",
-        "apify-client": "^2.22.2",
-        "yargs": "^18.0.0"
-    },
-    "devDependencies": {
-        "@apify/eslint-config": "^1.0.0",
-        "@apify/tsconfig": "^0.1.1",
-        "@types/node": "^24.0.0",
-        "@types/yargs": "^17.0.33",
-        "eslint": "^9.29.0",
-        "eslint-config-prettier": "^10.1.5",
-        "globals": "^17.0.0",
-        "prettier": "^3.5.3",
-        "tsx": "^4.20.3",
-        "typescript": "^5.9.3",
-        "typescript-eslint": "^8.34.1",
-        "vitest": "^3.2.4",
-        "knip": "^5.65.0",
-        "husky": "^9.0.11",
-        "lint-staged": "^15.2.2"
-    },
-    "peerDependencies": {
-        "vitest": ">=3.2.4"
-    },
-    "scripts": {
-        "start": "npm run dist/bin/main.js",
-        "start:dev": "GITHUB_WORKSPACE=local-clone tsx bin/main.ts",
-        "build": "tsc && chmod +x ./dist/bin/main.js",
-        "lint": "eslint",
-        "lint:fix": "eslint --fix",
-        "format": "prettier --write .",
-        "format:check": "prettier --check .",
-        "type-check": "tsc --noEmit",
-        "test": "vitest run",
-        "check-unused": "npx knip",
-        "prepare": "husky .husky || true"
-    },
-    "lint-staged": {
-        "*.js": "eslint",
-        "*.ts": "eslint"
-    },
-    "author": "oklinov",
-    "license": "ISC"
+  "name": "apify-test-tools",
+  "version": "0.9.0-beta.0",
+  "type": "module",
+  "description": "TBD",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/apify/apify-test-tools.git"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "bin": {
+    "apify-test-tools": "dist/bin/main.js"
+  },
+  "types": "./dist/index.d.ts",
+  "main": "./dist/lib/lib.js",
+  "dependencies": {
+    "@apify/consts": "^2.43.0",
+    "@slack/web-api": "^7.9.2",
+    "apify-client": "^2.22.2",
+    "ignore": "^7.0.5",
+    "yargs": "^18.0.0"
+  },
+  "devDependencies": {
+    "@apify/eslint-config": "^1.0.0",
+    "@apify/tsconfig": "^0.1.1",
+    "@types/node": "^24.0.0",
+    "@types/yargs": "^17.0.33",
+    "eslint": "^9.29.0",
+    "eslint-config-prettier": "^10.1.5",
+    "globals": "^17.0.0",
+    "husky": "^9.0.11",
+    "knip": "^5.65.0",
+    "lint-staged": "^15.2.2",
+    "prettier": "^3.5.3",
+    "tsx": "^4.20.3",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.34.1",
+    "vitest": "^3.2.4"
+  },
+  "peerDependencies": {
+    "vitest": ">=3.2.4"
+  },
+  "scripts": {
+    "start": "npm run dist/bin/main.js",
+    "start:dev": "GITHUB_WORKSPACE=local-clone tsx bin/main.ts",
+    "build": "tsc && chmod +x ./dist/bin/main.js",
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "check-unused": "npx knip",
+    "prepare": "husky .husky || true"
+  },
+  "lint-staged": {
+    "*.js": "eslint",
+    "*.ts": "eslint"
+  },
+  "author": "oklinov",
+  "license": "ISC"
 }

package/test/unit/bin/build-from-local.test.ts

@@ -8,6 +8,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import {
     collectNonIgnoredFiles,
+    collectSourceFiles,
     flattenMonorepoContext,
     rewriteActorJsonPaths,
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -62,86 +63,76 @@ describe('build-from-local helpers', () => {
     });
 
     describe('flattenMonorepoContext', () => {
-        it('filters the .actor/ overlay through the same secret-pattern check as the rest of the context', async () => {
+        it("overlays the actor's own .actor/ files at the flattened root", async () => {
+            // Simulates flattening from a monorepo with an actors/<name>/.actor structure.
             const repoRoot = await mkTempDir('apify-test-tools-repo-');
             tempDirs.push(repoRoot);
-            initGitRepo(repoRoot);
 
             const absActorDir = path.join(repoRoot, 'actors', 'owner_actor');
-            await fs.mkdir(path.join(absActorDir, '.actor'), { recursive: true });
-            await fs.writeFile(
-                path.join(absActorDir, '.actor', 'actor.json'),
-                JSON.stringify({ actorSpecification: 1, name: 'actor' }),
-            );
-            // A stray secret file inside .actor/ must never survive into the build.
-            await fs.writeFile(path.join(absActorDir, '.actor', '.env'), 'SECRET=leaked');
-            await fs.writeFile(path.join(absActorDir, '.actor', 'INPUT_SCHEMA.json'), '{}');
+            const actorJsonPath = path.join(absActorDir, '.actor', 'actor.json');
+            const inputSchemaPath = path.join(absActorDir, '.actor', 'INPUT_SCHEMA.json');
+            const mainSrcPath = path.join(absActorDir, 'src', 'main.ts');
+            const packageJsonPath = path.join(repoRoot, 'package.json');
 
-            const keptContextFile = path.join(repoRoot, 'package.json');
-            await fs.writeFile(keptContextFile, '{}');
+            await fs.mkdir(path.join(absActorDir, '.actor'), { recursive: true });
+            await fs.mkdir(path.join(absActorDir, 'src'), { recursive: true });
+            await fs.writeFile(actorJsonPath, JSON.stringify({ actorSpecification: 1, name: 'actor' }));
+            await fs.writeFile(inputSchemaPath, '{}');
+            await fs.writeFile(mainSrcPath, 'console.log(1)');
+            await fs.writeFile(packageJsonPath, '{}');
 
-            // Nothing is gitignored here — isolates the assertion to the secret-pattern filter.
-            vi.spyOn(Utils, 'getGitignoredPaths').mockReturnValue(new Set());
+            const keptContextFiles = [packageJsonPath, mainSrcPath, actorJsonPath, inputSchemaPath];
 
-            const actorJson = JSON.parse(
-                await fs.readFile(path.join(absActorDir, '.actor', 'actor.json'), 'utf8'),
-            ) as Record<string, unknown>;
+            const actorJson = JSON.parse(await fs.readFile(actorJsonPath, 'utf8')) as Record<string, unknown>;
 
             const { tempDir: flattenedDir, filePaths } = await flattenMonorepoContext(
                 'test/actor',
                 absActorDir,
                 repoRoot,
                 actorJson,
-                [keptContextFile],
-                repoRoot,
+                keptContextFiles,
             );
             tempDirs.push(flattenedDir);
 
-            await expect(fs.access(path.join(flattenedDir, '.actor', '.env'))).rejects.toThrow();
-            await expect(fs.access(path.join(flattenedDir, '.actor', 'INPUT_SCHEMA.json'))).resolves.toBeUndefined();
+            const flattenedMainSrcPath = path.join(flattenedDir, 'actors', 'owner_actor', 'src', 'main.ts');
             await expect(fs.access(path.join(flattenedDir, '.actor', 'actor.json'))).resolves.toBeUndefined();
+            await expect(fs.access(path.join(flattenedDir, '.actor', 'INPUT_SCHEMA.json'))).resolves.toBeUndefined();
             await expect(fs.access(path.join(flattenedDir, 'package.json'))).resolves.toBeUndefined();
-
-            // The returned filePaths must match what actually landed on disk — no .env, everything else present.
-            expect(new Set(filePaths)).toStrictEqual(
-                new Set([
-                    path.join(flattenedDir, 'package.json'),
-                    path.join(flattenedDir, '.actor', 'INPUT_SCHEMA.json'),
-                    path.join(flattenedDir, '.actor', 'actor.json'),
-                ]),
-            );
+            await expect(fs.access(flattenedMainSrcPath)).resolves.toBeUndefined();
+            expect(filePaths).toContain(path.join(flattenedDir, '.actor', 'actor.json'));
+            expect(filePaths).toContain(path.join(flattenedDir, '.actor', 'INPUT_SCHEMA.json'));
+            expect(filePaths).toContain(flattenedMainSrcPath);
         });
 
         it("keeps another actor's .actor/ directory intact at its original nested path", async () => {
+            // Simulates flattening from a monorepo with an actors/<name>/.actor structure — two
+            // sibling actors share the same context, but only one is being flattened here.
             const repoRoot = await mkTempDir('apify-test-tools-repo-');
             tempDirs.push(repoRoot);
-            initGitRepo(repoRoot);
 
             const absActorDir = path.join(repoRoot, 'actors', 'owner_actor');
-            await fs.mkdir(path.join(absActorDir, '.actor'), { recursive: true });
-            await fs.writeFile(
-                path.join(absActorDir, '.actor', 'actor.json'),
-                JSON.stringify({ actorSpecification: 1, name: 'actor' }),
-            );
-
+            const actorJsonPath = path.join(absActorDir, '.actor', 'actor.json');
             const otherActorDir = path.join(repoRoot, 'actors', 'owner_other-actor');
-            await fs.mkdir(path.join(otherActorDir, '.actor'), { recursive: true });
             const otherActorSchemaFile = path.join(otherActorDir, '.actor', 'input_schema.json');
+
+            await fs.mkdir(path.join(absActorDir, '.actor'), { recursive: true });
+            await fs.writeFile(actorJsonPath, JSON.stringify({ actorSpecification: 1, name: 'actor' }));
+            await fs.mkdir(path.join(otherActorDir, '.actor'), { recursive: true });
             await fs.writeFile(otherActorSchemaFile, JSON.stringify({ schema: 'other' }));
 
-            vi.spyOn(Utils, 'getGitignoredPaths').mockReturnValue(new Set());
+            // Stands in for collectNonIgnoredFiles's already-filtered output: the current actor's own
+            // actor.json (always kept by collectNonIgnoredFiles's .actor/ bypass in the real flow —
+            // see the collectSourceFiles test below) plus the other actor's file.
+            const keptContextFiles = [actorJsonPath, otherActorSchemaFile];
 
-            const actorJson = JSON.parse(
-                await fs.readFile(path.join(absActorDir, '.actor', 'actor.json'), 'utf8'),
-            ) as Record<string, unknown>;
+            const actorJson = JSON.parse(await fs.readFile(actorJsonPath, 'utf8')) as Record<string, unknown>;
 
             const { tempDir: flattenedDir, filePaths } = await flattenMonorepoContext(
                 'test/actor',
                 absActorDir,
                 repoRoot,
                 actorJson,
-                [otherActorSchemaFile],
-                repoRoot,
+                keptContextFiles,
             );
             tempDirs.push(flattenedDir);
 
@@ -151,6 +142,33 @@ describe('build-from-local helpers', () => {
         });
     });
 
+    describe('collectSourceFiles', () => {
+        it("always collects the actor's own .actor/actor.json for a monorepo actor, since flattenMonorepoContext depends on it", async () => {
+            const repoRoot = await mkTempDir('apify-test-tools-collect-source-');
+            tempDirs.push(repoRoot);
+            initGitRepo(repoRoot);
+
+            const originalCwd = process.cwd();
+            // We simulate the working directory being the repo root, since collectSourceFiles uses relative paths to the repo root.
+            Utils.setCwd({ workspace: repoRoot });
+            try {
+                const cwd = process.cwd();
+                const actorDir = path.join(cwd, 'actors', 'owner_actor');
+                await fs.mkdir(path.join(actorDir, '.actor'), { recursive: true });
+                await fs.writeFile(
+                    path.join(actorDir, '.actor', 'actor.json'),
+                    JSON.stringify({ actorSpecification: 1, name: 'actor', dockerContextDir: '../../..' }),
+                );
+                await fs.writeFile(path.join(cwd, 'package.json'), '{}');
+
+                const sourceFiles = await collectSourceFiles('owner/actor', actorDir);
+                expect(sourceFiles.map((file) => file.name)).toContain('.actor/actor.json');
+            } finally {
+                process.chdir(originalCwd);
+            }
+        });
+    });
+
     describe('rewriteActorJsonPaths', () => {
         it('rewrites path fields that escape .actor/ relative to the new flattened location', async () => {
             const repoRoot = await mkTempDir('apify-test-tools-rewrite-');
@@ -182,83 +200,6 @@ describe('build-from-local helpers', () => {
     });
 });
 
-describe('getDockerignoredPaths', () => {
-    const tempDirs: string[] = [];
-
-    afterEach(async () => {
-        vi.mocked(spawnSync).mockClear();
-        await Promise.all(tempDirs.splice(0).map(async (dir) => fs.rm(dir, { recursive: true, force: true })));
-    });
-
-    it('returns an empty set without calling git when given no paths', () => {
-        const result = Utils.getDockerignoredPaths('/does/not/matter', []);
-
-        expect(result).toStrictEqual(new Set());
-        expect(spawnSync).not.toHaveBeenCalled();
-    });
-
-    it('returns an empty set when rootDir has no .dockerignore', async () => {
-        const rootDir = await mkTempDir('apify-test-tools-dockerignore-');
-        tempDirs.push(rootDir);
-        initGitRepo(rootDir);
-
-        expect(Utils.getDockerignoredPaths(rootDir, ['main.js'])).toStrictEqual(new Set());
-    });
-
-    it('returns the paths that match .dockerignore patterns rooted at rootDir', async () => {
-        const rootDir = await mkTempDir('apify-test-tools-dockerignore-');
-        tempDirs.push(rootDir);
-        initGitRepo(rootDir);
-
-        await fs.writeFile(path.join(rootDir, '.dockerignore'), 'test/\n*.log\n');
-
-        const result = Utils.getDockerignoredPaths(rootDir, ['main.js', 'test/fixture.json', 'debug.log']);
-
-        expect(result).toStrictEqual(new Set(['test/fixture.json', 'debug.log']));
-    });
-
-    it('matches "./"-prefixed patterns, which Docker treats as a no-op but git treats as literal text', async () => {
-        const rootDir = await mkTempDir('apify-test-tools-dockerignore-');
-        tempDirs.push(rootDir);
-        initGitRepo(rootDir);
-
-        // The common real-world .dockerignore style: every pattern prefixed with "./",
-        // including a negation re-including one of the otherwise-matched files.
-        await fs.writeFile(path.join(rootDir, '.dockerignore'), './node_modules\n./*.log\n!./keep.log\n');
-
-        const result = Utils.getDockerignoredPaths(rootDir, [
-            'node_modules/foo.js',
-            'debug.log',
-            'keep.log',
-            'main.js',
-        ]);
-
-        expect(result).toStrictEqual(new Set(['node_modules/foo.js', 'debug.log']));
-    });
-
-    it('matches already-tracked files too, since Docker excludes them regardless of git tracking', async () => {
-        const rootDir = await mkTempDir('apify-test-tools-dockerignore-');
-        tempDirs.push(rootDir);
-        initGitRepo(rootDir);
-        spawnSync('git', ['config', 'user.email', 'test@example.com'], { cwd: rootDir });
-        spawnSync('git', ['config', 'user.name', 'Test'], { cwd: rootDir });
-
-        // Husky hooks are committed to the repo, so this path is tracked by git — by default
-        // `git check-ignore` never reports a tracked file as ignored, which would otherwise mask
-        // this exact pattern from matching, unlike a real Docker build which excludes it anyway.
-        await fs.mkdir(path.join(rootDir, '.husky'));
-        await fs.writeFile(path.join(rootDir, '.husky', 'pre-commit'), '#!/bin/sh\n');
-        spawnSync('git', ['add', '.husky/pre-commit'], { cwd: rootDir });
-        spawnSync('git', ['commit', '-q', '-m', 'add husky hook'], { cwd: rootDir });
-
-        await fs.writeFile(path.join(rootDir, '.dockerignore'), './.husky\n');
-
-        const result = Utils.getDockerignoredPaths(rootDir, ['.husky/pre-commit', 'main.js']);
-
-        expect(result).toStrictEqual(new Set(['.husky/pre-commit']));
-    });
-});
-
 describe('getGitignoredPaths', () => {
     beforeEach(() => {
         vi.mocked(spawnSync).mockReset();