apify-test-tools 0.10.2-beta.6 → 0.10.2-beta.8

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

@@ -124,9 +124,12 @@ describe('getChangedFiles', () => {
         expect(changedFiles).toStrictEqual(['file1.txt', 'folder/file2.txt']);
 
         expect(gitCommandSpy).toHaveBeenCalledTimes(1);
-        expect(gitCommandSpy).toHaveBeenCalledWith(['diff', '--name-only', `${firstSha}~..${lastSha}`], {
-            operation: 'get the list of changed files between commits',
-        });
+        expect(gitCommandSpy).toHaveBeenCalledWith(
+            ['diff', '--name-only', '--no-renames', `${firstSha}~..${lastSha}`],
+            {
+                operation: 'get the list of changed files between commits',
+            },
+        );
     });
 
     it('should throw without running git when the commit list is empty', async () => {
@@ -147,7 +150,7 @@ describe('getChangedFiles', () => {
         expect(changedFiles).toStrictEqual(['file1.txt', 'folder/file2.txt']);
 
         expect(gitCommandSpy).toHaveBeenCalledTimes(1);
-        expect(gitCommandSpy).toHaveBeenCalledWith(['diff', '--name-only', `${onlySha}~..${onlySha}`], {
+        expect(gitCommandSpy).toHaveBeenCalledWith(['diff', '--name-only', '--no-renames', `${onlySha}~..${onlySha}`], {
             operation: 'get the list of changed files between commits',
         });
     });
@@ -412,7 +415,7 @@ describe('getChangedFilesBetween', () => {
             'src/main.ts',
             'CHANGELOG.md',
         ]);
-        expect(spy).toHaveBeenCalledWith(['diff', '--name-only', 'base-sha..head-sha'], {
+        expect(spy).toHaveBeenCalledWith(['diff', '--name-only', '--no-renames', 'base-sha..head-sha'], {
             operation: 'get the list of changed files between commits',
         });
     });

package/test/unit/run-checks.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest';
+
+import { checkRun } from '../../lib/run-checks.js';
+import type { RunTestResult } from '../../lib/run-test-result.js';
+
+const fakeRun = (overrides: { status?: string; log?: string; stats?: object; chargedEventCounts?: object } = {}) =>
+    ({
+        status: overrides.status ?? 'SUCCEEDED',
+        getRunInfo: async () => ({
+            stats: { durationMillis: 5_000 },
+            chargedEventCounts: overrides.chargedEventCounts,
+        }),
+        getDataset: async () => ({ items: new Array(10) }),
+        getStatistics: async () => ({
+            requestsFailed: 0,
+            requestsRetries: 1,
+            requestRetryHistogram: [5, 1],
+            ...overrides.stats,
+        }),
+        getLog: async () => overrides.log ?? 'all good',
+    }) as unknown as RunTestResult;
+
+const failures = async (run: RunTestResult, options: Parameters<typeof checkRun>[1]) =>
+    (await checkRun(run, options)).filter(({ pass }) => !pass).map(({ name }) => name);
+
+describe('checkRun()', () => {
+    it('passes a run matching the defaults', async () => {
+        expect(await failures(fakeRun(), { datasetItemCount: 10 })).toEqual([]);
+    });
+
+    it('reports every failing check at once', async () => {
+        const run = fakeRun({ status: 'FAILED', log: 'TypeError: x', stats: { requestsFailed: 2 } });
+        expect(await failures(run, { datasetItemCount: { min: 11 } })).toEqual([
+            'status',
+            'datasetItemCount',
+            'failedRequests',
+            'forbiddenLogs',
+        ]);
+    });
+
+    it('disables a check with null', async () => {
+        const run = fakeRun({ stats: { requestsFailed: 2 } });
+        expect(await failures(run, { datasetItemCount: 10, failedRequests: null })).toEqual([]);
+    });
+
+    it('treats explicitly undefined options as disabled checks', async () => {
+        const options = { datasetItemCount: 10, duration: undefined, maxRetriesPerRequest: undefined };
+        expect(await failures(fakeRun(), options)).toEqual([]);
+    });
+
+    it('checks the longest retry chain only when asked to', async () => {
+        expect(await failures(fakeRun(), { datasetItemCount: 10, maxRetriesPerRequest: 0 })).toEqual([
+            'maxRetriesPerRequest',
+        ]);
+        expect(await failures(fakeRun(), { datasetItemCount: 10, maxRetriesPerRequest: 1 })).toEqual([]);
+    });
+
+    describe('chargedEventCounts', () => {
+        const run = fakeRun({ chargedEventCounts: { start: 1, item: 7 } });
+
+        it('passes matching counts and intervals', async () => {
+            const options = { datasetItemCount: 10, chargedEventCounts: { start: 1, item: { min: 5 } } };
+            expect(await failures(run, options)).toEqual([]);
+        });
+
+        it('expects unlisted charged events to not happen', async () => {
+            const options = { datasetItemCount: 10, chargedEventCounts: { start: 1 } as Record<string, number> };
+            expect(await failures(run, options)).toEqual(['chargedEventCounts.item']);
+        });
+
+        it('fails an expected event that was never charged', async () => {
+            const options = { datasetItemCount: 10, chargedEventCounts: { start: 1, item: 7, extra: { min: 0 } } };
+            expect(await failures(run, options)).toEqual(['chargedEventCounts.extra']);
+        });
+    });
+});

package/test/unit/run-test-result.test.ts

@@ -0,0 +1,44 @@
+import type { ActorRun, ApifyClient } from 'apify-client';
+import { describe, expect, it, vi } from 'vitest';
+
+import { RunTestResult } from '../../lib/run-test-result.js';
+
+const run = { id: 'run', status: 'SUCCEEDED', defaultDatasetId: 'ds', defaultKeyValueStoreId: 'kvs' } as ActorRun;
+
+describe('RunTestResult', () => {
+    it('fetches the log once, even when empty or requested concurrently', async () => {
+        const get = vi.fn(async () => '');
+        const client = { run: () => ({ log: () => ({ get }) }) } as unknown as ApifyClient;
+        const result = new RunTestResult(client, run);
+
+        await Promise.all([result.getLog(), result.getLog()]);
+        await result.getLog();
+
+        expect(get).toHaveBeenCalledTimes(1);
+    });
+
+    it('retries after a failed fetch', async () => {
+        const get = vi.fn().mockRejectedValueOnce(new Error('boom')).mockResolvedValueOnce('log');
+        const client = { run: () => ({ log: () => ({ get }) }) } as unknown as ApifyClient;
+        const result = new RunTestResult(client, run);
+
+        await expect(result.getLog()).rejects.toThrow('boom');
+        expect(await result.getLog()).toBe('log');
+    });
+
+    it('pages through the dataset instead of listing it in one response', async () => {
+        const total = 25_000;
+        const listItems = vi.fn(async ({ offset, limit }: { offset: number; limit: number }) => ({
+            total,
+            items: Array.from({ length: Math.min(limit, total - offset) }, (_, i) => offset + i),
+        }));
+        const client = { dataset: () => ({ listItems }) } as unknown as ApifyClient;
+        const result = new RunTestResult(client, run);
+
+        const { items } = await result.getDataset<number>();
+
+        expect(items).toHaveLength(total);
+        expect(items[24_999]).toBe(24_999);
+        expect(listItems).toHaveBeenCalledTimes(25);
+    });
+});