apify-test-tools 0.9.1-beta.4 → 0.9.1-beta.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify-test-tools",
-  "version": "0.9.1-beta.4",
+  "version": "0.9.1-beta.5",
   "type": "module",
   "description": "TBD",
   "repository": {
@@ -20,7 +20,8 @@
     "@slack/web-api": "^7.9.2",
     "apify-client": "^2.22.2",
     "ignore": "^7.0.5",
-    "yargs": "^18.0.0"
+    "yargs": "^18.0.0",
+    "zod": "^4.6.5"
   },
   "devDependencies": {
     "@apify/eslint-config": "^1.0.0",

package/test/fixtures/bin/utils/files/array.json

@@ -0,0 +1 @@
+[{ "a": 1 }]

package/test/fixtures/bin/utils/files/comments.jsonc

@@ -0,0 +1,4 @@
+{
+    // this is a comment
+    "a": 3,
+}

package/test/fixtures/bin/utils/files/empty-object.json

@@ -0,0 +1 @@
+{}

package/test/fixtures/bin/utils/files/malformed.json

@@ -0,0 +1 @@
+{ "a": 1

package/test/fixtures/bin/utils/files/nested.json

@@ -0,0 +1,6 @@
+{
+    "storages": { "datasets": { "default": { "title": "Default" } } },
+    "overrideActorContext": ["../shared", "."],
+    "changelog": null,
+    "nested": [{ "deep": [1, 2, { "deeper": true }] }]
+}

package/test/fixtures/bin/utils/files/no-json-extension.actorrc

@@ -0,0 +1 @@
+{ "a": 1 }

package/test/fixtures/bin/utils/files/null.json

@@ -0,0 +1 @@
+null

package/test/fixtures/bin/utils/files/number.json

@@ -0,0 +1 @@
+42

package/test/fixtures/bin/utils/files/unreadable.json

@@ -0,0 +1 @@
+{ "a": 1 }

package/test/tsconfig.json

@@ -1,13 +1,15 @@
 {
     "extends": "@apify/tsconfig",
     "compilerOptions": {
-        "module": "ES2022",
+        "module": "nodenext",
+        "moduleResolution": "nodenext",
         "target": "ES2022",
         "outDir": "dist",
         "noUnusedLocals": false,
         "noEmit": true,
+        "rootDir": "..",
         "lib": ["DOM", "es2021"],
         "skipLibCheck": true
     },
-    "include": ["./**/*"]
+    "include": ["./**/*", "../bin/**/*", "../lib/**/*"]
 }

package/test/unit/bin/{utils.test.ts → utils/actor-config.test.ts}

@@ -1,36 +1,102 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import { CONFIG_FILE_NAME, readConfigFile } from '../../../bin/utils.js';
-
-const { fsMock } = vi.hoisted(() => ({
-    fsMock: {
-        readFile: vi.fn(),
-    },
-}));
-
-vi.mock('node:fs/promises', () => ({ default: fsMock }));
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import {
+    CONFIG_FILE_NAME,
+    loadActorConfig,
+    parseConfigFile,
+    readConfigFile,
+    resolveRawConfig,
+} from '../../../../bin/utils/config/load-config.js';
+
+// `readConfigFile` resolves every path against the process's working directory, so these tests give it
+// a real one: a throwaway repo in a temp dir. Reading actual files rather than a mocked
+// `node:fs/promises` is what makes the path handling (the ".actor/" hop, a dockerContextDir escaping
+// the repo root) worth asserting on — against a mock those assertions only describe the mock.
+let repoDir: string;
+let originalCwd: string;
+
+beforeEach(async () => {
+    originalCwd = process.cwd();
+    // `realpath` because macOS hands out a symlinked temp dir, while `process.cwd()` reports the target.
+    repoDir = await fs.realpath(await fs.mkdtemp(path.join(os.tmpdir(), 'apify-test-tools-config-')));
+    process.chdir(repoDir);
+});
 
-afterEach(() => vi.restoreAllMocks());
+afterEach(async () => {
+    process.chdir(originalCwd);
+    await fs.rm(repoDir, { recursive: true, force: true });
+});
 
 const emptyActorSelection = { actors: [], ignore: [] };
 
 const validConfig = (actors: object[]) => JSON.stringify({ actors });
 const actorJson = (fields: Record<string, unknown> = {}) => JSON.stringify(fields);
 
-const expectFileRead = (filePath: string) => {
-    expect(fsMock.readFile).toHaveBeenCalledWith(filePath, expect.anything());
-};
+const writeFiles = async (files: Record<string, string>) =>
+    Promise.all(
+        Object.entries(files).map(async ([filePath, contents]) => {
+            const absPath = path.join(repoDir, filePath);
+            await fs.mkdir(path.dirname(absPath), { recursive: true });
+            await fs.writeFile(absPath, contents);
+        }),
+    );
+
+// Stages 2-4 are callable on their own, which is the point: a differently shaped config file only
+// has to reach `resolveRawConfig`'s output to work with everything downstream.
+describe('the parse/resolve/load seam', () => {
+    it('parseConfigFile validates the file shape without touching the filesystem', () => {
+        const entry = { folder: 'actors/shopify', actorFullName: 'myteam/shopify', tokenEnvVar: 'APIFY_TOKEN' };
+
+        expect(parseConfigFile({ actors: [entry] })).toEqual({ actors: [entry] });
+        expect(() => parseConfigFile({ actors: [{ ...entry, folder: 123 }] })).toThrow(/Invalid "folder"/);
+    });
 
-const mockFiles = (files: Record<string, string>) => {
-    fsMock.readFile.mockImplementation(async (filePath: string) => {
-        if (filePath in files) return Promise.resolve(files[filePath]);
-        return Promise.reject(new Error(`ENOENT: ${filePath}`));
+    it('resolveRawConfig is where the repo root becomes "" and trailing slashes go', () => {
+        const result = resolveRawConfig({
+            actors: [
+                { folder: '.', actorFullName: 'myteam/root', tokenEnvVar: 'APIFY_TOKEN' },
+                {
+                    folder: 'actors/shopify/',
+                    actorFullName: 'myteam/shopify',
+                    tokenEnvVar: 'APIFY_TOKEN',
+                    overrideActorContext: ['packages/'],
+                },
+            ],
+        });
+
+        expect(result).toEqual([
+            { folder: '', actorFullName: 'myteam/root', tokenEnvVar: 'APIFY_TOKEN', overrideActorContext: undefined },
+            {
+                folder: 'actors/shopify',
+                actorFullName: 'myteam/shopify',
+                tokenEnvVar: 'APIFY_TOKEN',
+                overrideActorContext: ['packages'],
+            },
+        ]);
     });
-};
+
+    it('loadActorConfig resolves data coming from actor.json', async () => {
+        await writeFiles({ 'actors/shopify/.actor/actor.json': actorJson({ dockerContextDir: '..' }) });
+
+        expect(
+            loadActorConfig({ folder: 'actors/shopify', actorFullName: 'myteam/shopify', tokenEnvVar: 'APIFY_TOKEN' }),
+        ).toEqual({
+            actorFullName: 'myteam/shopify',
+            folder: 'actors/shopify',
+            tokenEnvVar: 'APIFY_TOKEN',
+            dockerContextDir: 'actors/shopify',
+            contextPaths: ['actors/shopify'],
+        });
+    });
+});
 
 describe('readConfigFile', () => {
     it('returns correct ActorConfig[] for a valid config', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify',
@@ -42,7 +108,6 @@ describe('readConfigFile', () => {
         });
 
         const result = await readConfigFile(emptyActorSelection);
-        expectFileRead('actors/shopify/.actor/actor.json');
         expect(result).toEqual([
             {
                 actorFullName: 'myteam/shopify-scraper',
@@ -55,7 +120,7 @@ describe('readConfigFile', () => {
     });
 
     it('normalizes folder "." to ""', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: '.', actorFullName: 'apify/my-actor', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
             ]),
@@ -64,11 +129,10 @@ describe('readConfigFile', () => {
 
         const result = await readConfigFile(emptyActorSelection);
         expect(result[0].folder).toBe('');
-        expectFileRead('.actor/actor.json');
     });
 
     it('defaults dockerContextDir to actor folder when absent from actor.json', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: 'actors/web-scraper', actorFullName: 'apify/web-scraper', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
             ]),
@@ -81,7 +145,7 @@ describe('readConfigFile', () => {
     });
 
     it('resolves dockerContextDir relative to .actor/ folder', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: 'actors/shopify', actorFullName: 'myteam/shopify', tokenEnvVar: 'APIFY_TOKEN' },
             ]),
@@ -92,8 +156,19 @@ describe('readConfigFile', () => {
         expect(result[0].dockerContextDir).toBe('');
     });
 
+    it('throws when dockerContextDir resolves outside the repository root', async () => {
+        await writeFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                { folder: 'actors/shopify', actorFullName: 'myteam/shopify', tokenEnvVar: 'APIFY_TOKEN' },
+            ]),
+            'actors/shopify/.actor/actor.json': actorJson({ dockerContextDir: '../../../..' }),
+        });
+
+        await expect(readConfigFile(emptyActorSelection)).rejects.toThrow(/resolves outside the repository root/);
+    });
+
     it('resolves contextPaths from overrideActorContext', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify',
@@ -110,7 +185,7 @@ describe('readConfigFile', () => {
     });
 
     it('handles multiple actors', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: 'actors/web-scraper', actorFullName: 'apify/web-scraper', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
                 {
@@ -130,22 +205,26 @@ describe('readConfigFile', () => {
     });
 
     it('throws when config file is missing', async () => {
-        fsMock.readFile.mockRejectedValue(new Error('ENOENT'));
         await expect(readConfigFile(emptyActorSelection)).rejects.toThrow('not found');
     });
 
     it('throws when config file contains invalid JSON', async () => {
-        fsMock.readFile.mockResolvedValue('{bad json');
+        await writeFiles({ [CONFIG_FILE_NAME]: '{bad json' });
         await expect(readConfigFile(emptyActorSelection)).rejects.toThrow('invalid JSON');
     });
 
     it('throws when actors array is missing', async () => {
-        fsMock.readFile.mockResolvedValue(JSON.stringify({ notActors: [] }));
+        await writeFiles({ [CONFIG_FILE_NAME]: JSON.stringify({ notActors: [] }) });
+        await expect(readConfigFile(emptyActorSelection)).rejects.toThrow('"actors" array');
+    });
+
+    it('throws when the config file is not a JSON object', async () => {
+        await writeFiles({ [CONFIG_FILE_NAME]: JSON.stringify([{ folder: 'actors/shopify' }]) });
         await expect(readConfigFile(emptyActorSelection)).rejects.toThrow('"actors" array');
     });
 
     it('throws on duplicate folders', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: 'actors/shopify', actorFullName: 'apify/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
                 { folder: 'actors/shopify', actorFullName: 'other/shopify', tokenEnvVar: 'APIFY_TOKEN_OTHER' },
@@ -157,7 +236,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws on duplicate folders after normalization ("." and "")', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: '.', actorFullName: 'apify/actor-a', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
                 { folder: '', actorFullName: 'other/actor-b', tokenEnvVar: 'APIFY_TOKEN_OTHER' },
@@ -169,7 +248,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when actor.json is missing', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: 'actors/shopify', actorFullName: 'apify/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
             ]),
@@ -179,7 +258,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when folder is missing', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([{ actorFullName: 'apify/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' }]),
         });
 
@@ -187,7 +266,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when folder is not a string', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: 123, actorFullName: 'apify/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
             ]),
@@ -197,7 +276,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when actorFullName is missing', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([{ folder: 'actors/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' }]),
             'actors/shopify/.actor/actor.json': actorJson({}),
         });
@@ -206,7 +285,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when actorFullName has no slash', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: 'actors/shopify', actorFullName: 'shopify-scraper', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
             ]),
@@ -217,7 +296,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when actorFullName has empty parts', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: 'actors/shopify', actorFullName: '/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
             ]),
@@ -227,8 +306,29 @@ describe('readConfigFile', () => {
         await expect(readConfigFile(emptyActorSelection)).rejects.toThrow('Invalid "actorFullName"');
     });
 
+    it('throws when tokenEnvVar is missing', async () => {
+        await writeFiles({
+            [CONFIG_FILE_NAME]: validConfig([{ folder: 'actors/shopify', actorFullName: 'apify/shopify' }]),
+            'actors/shopify/.actor/actor.json': actorJson({}),
+        });
+
+        await expect(readConfigFile(emptyActorSelection)).rejects.toThrow('Invalid "tokenEnvVar"');
+    });
+
+    it('reports every invalid field at once instead of only the first', async () => {
+        await writeFiles({
+            [CONFIG_FILE_NAME]: validConfig([{ folder: 123, actorFullName: 'shopify', overrideActorContext: 'nope' }]),
+        });
+
+        const promise = readConfigFile(emptyActorSelection);
+        await expect(promise).rejects.toThrow(/Invalid "folder"/);
+        await expect(promise).rejects.toThrow(/Invalid "actorFullName"/);
+        await expect(promise).rejects.toThrow(/Invalid "tokenEnvVar"/);
+        await expect(promise).rejects.toThrow(/Invalid "overrideActorContext"/);
+    });
+
     it('throws when overrideActorContext is not an array', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify',
@@ -244,7 +344,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when overrideActorContext contains non-strings', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify',
@@ -260,7 +360,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when overrideActorContext entries overlap (one is a prefix of another)', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify',
@@ -276,7 +376,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when overrideActorContext contains the repo root alongside another entry', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify',
@@ -292,7 +392,7 @@ describe('readConfigFile', () => {
     });
 
     it('adds the actor own folder automatically when overrideActorContext does not cover it', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify',
@@ -309,7 +409,7 @@ describe('readConfigFile', () => {
     });
 
     it('strips trailing slashes from folder and overrideActorContext entries', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify/',
@@ -327,7 +427,7 @@ describe('readConfigFile', () => {
     });
 
     it('allows overrideActorContext with disjoint sibling paths that all reach the actor folder via one entry', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify',
@@ -344,8 +444,8 @@ describe('readConfigFile', () => {
     });
 
     describe('actor selection', () => {
-        const twoActors = () =>
-            mockFiles({
+        const twoActors = async () =>
+            writeFiles({
                 [CONFIG_FILE_NAME]: validConfig([
                     { folder: 'actors/a', actorFullName: 'team/a', tokenEnvVar: 'TOKEN' },
                     { folder: 'actors/b', actorFullName: 'team/b', tokenEnvVar: 'TOKEN' },
@@ -357,22 +457,22 @@ describe('readConfigFile', () => {
         const fullNames = (result: { actorFullName: string }[]) => result.map((c) => c.actorFullName);
 
         it('returns all actors when the selection is empty', async () => {
-            twoActors();
+            await twoActors();
             expect(fullNames(await readConfigFile(emptyActorSelection))).toEqual(['team/a', 'team/b']);
         });
 
         it('keeps only the selected actors', async () => {
-            twoActors();
+            await twoActors();
             expect(fullNames(await readConfigFile({ actors: ['team/a'], ignore: [] }))).toEqual(['team/a']);
         });
 
         it('drops ignored actors', async () => {
-            twoActors();
+            await twoActors();
             expect(fullNames(await readConfigFile({ actors: [], ignore: ['team/a'] }))).toEqual(['team/b']);
         });
 
         it('throws on an unknown actor name', async () => {
-            twoActors();
+            await twoActors();
             await expect(readConfigFile({ actors: ['team/nope'], ignore: [] })).rejects.toThrow(
                 'do not exist: team/nope',
             );

package/test/unit/bin/utils/files.test.ts

@@ -0,0 +1,158 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { safeReadJsonObjectFile } from '../../../../bin/utils/json-file.js';
+
+// These tests read real fixture files rather than mocking `node:fs`: the whole point of
+// `safeReadJsonObjectFile` is how it reacts to real stat/readFile outcomes (missing path, directory,
+// symlink, unreadable file), so mocking those away would only assert the mock back to itself.
+const FIXTURE_DIR = fileURLToPath(new URL('../../../fixtures/bin/utils/files/', import.meta.url));
+
+const fixture = (name: string) => path.join(FIXTURE_DIR, name);
+
+const NESTED_FIXTURE = {
+    storages: { datasets: { default: { title: 'Default' } } },
+    overrideActorContext: ['../shared', '.'],
+    changelog: null,
+    nested: [{ deep: [1, 2, { deeper: true }] }],
+};
+
+describe('safeReadJsonObjectFile', () => {
+    describe('valid JSON objects', () => {
+        it('returns the parsed contents, preserving nested objects, arrays and null values', () => {
+            const result = safeReadJsonObjectFile(fixture('nested.json'));
+
+            expect(result).toStrictEqual({ success: true, contents: NESTED_FIXTURE });
+        });
+
+        it('accepts an empty JSON object', () => {
+            const result = safeReadJsonObjectFile(fixture('empty-object.json'));
+
+            expect(result).toStrictEqual({ success: true, contents: {} });
+        });
+
+        it('reads files that are not named *.json', () => {
+            const result = safeReadJsonObjectFile(fixture('no-json-extension.actorrc'));
+
+            expect(result).toStrictEqual({ success: true, contents: { a: 1 } });
+        });
+    });
+
+    describe('filesystem-level handling', () => {
+        it('fails when the path does not exist', () => {
+            const filePath = fixture('does-not-exist.json');
+
+            const result = safeReadJsonObjectFile(filePath);
+
+            expect(result).toMatchObject({
+                success: false,
+                reason: 'unreadable',
+            });
+        });
+
+        // The fixture is named `directory.json` on purpose — the check is `stat().isFile()`, not the extension.
+        it('fails when the path is a directory', () => {
+            const filePath = fixture('directory.json');
+
+            const result = safeReadJsonObjectFile(filePath);
+
+            expect(result).toMatchObject({
+                success: false,
+                reason: 'not-a-file',
+            });
+        });
+
+        // Regression guard: `lstat` would report the link itself as "not a file" and reject it, even
+        // though `readFile` follows symlinks and would have read the target without complaint.
+        it('follows a symlink to its target file', () => {
+            const result = safeReadJsonObjectFile(fixture('symlink-to-valid.json'));
+
+            expect(result).toStrictEqual({ success: true, contents: NESTED_FIXTURE });
+        });
+
+        // Git only tracks the executable bit, so this is the one case whose fixture cannot carry its own
+        // mode — `unreadable.json` is committed readable and stripped of permissions just for this test.
+        describe('unreadable file', () => {
+            const filePath = fixture('unreadable.json');
+
+            afterEach(async () => fs.chmod(filePath, 0o644));
+
+            it.runIf(process.getuid?.() !== 0)('fails when the file exists but cannot be read', async () => {
+                await fs.chmod(filePath, 0o000);
+
+                const result = safeReadJsonObjectFile(filePath);
+
+                expect(result).toMatchObject({
+                    success: false,
+                    reason: 'unreadable',
+                });
+            });
+        });
+    });
+
+    describe('JSON that is not an object', () => {
+        it('rejects a JSON array', () => {
+            const filePath = fixture('array.json');
+
+            const result = safeReadJsonObjectFile(filePath);
+
+            expect(result).toMatchObject({
+                success: false,
+                reason: 'not-an-object',
+            });
+        });
+
+        it('rejects JSON null', () => {
+            const filePath = fixture('null.json');
+
+            const result = safeReadJsonObjectFile(filePath);
+
+            expect(result).toMatchObject({
+                success: false,
+                reason: 'not-an-object',
+            });
+        });
+
+        it('rejects a JSON primitive', () => {
+            const filePath = fixture('number.json');
+
+            const result = safeReadJsonObjectFile(filePath);
+
+            expect(result).toMatchObject({
+                success: false,
+                reason: 'not-an-object',
+            });
+        });
+    });
+
+    describe('unparseable files', () => {
+        it('fails on malformed JSON', () => {
+            const filePath = fixture('malformed.json');
+
+            const result = safeReadJsonObjectFile(filePath);
+
+            expect(result).toMatchObject({ success: false, reason: 'invalid-json' });
+            expect((result as { failure: Error }).failure.message).toContain(`Failed to parse ${filePath}`);
+        });
+
+        it('fails on an empty file', () => {
+            const filePath = fixture('empty.json');
+
+            const result = safeReadJsonObjectFile(filePath);
+
+            expect(result).toMatchObject({ success: false, reason: 'invalid-json' });
+            expect((result as { failure: Error }).failure.message).toContain(`Failed to parse ${filePath}`);
+        });
+
+        it.fails('reads jsonc', () => {
+            const filePath = fixture('comments.jsonc');
+
+            const result = safeReadJsonObjectFile(filePath);
+
+            expect(result).toMatchObject({ success: true, contents: { a: 3 } });
+        });
+    });
+});

package/dist/test/unit/bin/utils.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=utils.test.d.ts.map

package/dist/test/unit/bin/utils.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../../../test/unit/bin/utils.test.ts"],"names":[],"mappings":""}