@datadog/datadog-ci 1.7.1 → 1.7.3-alpha

package/dist/commands/synthetics/__tests__/utils.test.js

@@ -42,7 +42,11 @@ const api_1 = require("../api");
 const errors_1 = require("../errors");
 const interfaces_1 = require("../interfaces");
 const utils = __importStar(require("../utils"));
+const command_1 = require("../command");
 const fixtures_1 = require("./fixtures");
+beforeEach(() => {
+    jest.restoreAllMocks();
+});
 describe('utils', () => {
     const apiConfiguration = {
         apiKey: '123',
@@ -69,19 +73,11 @@ describe('utils', () => {
     describe('runTest', () => {
         const fakeId = '123-456-789';
         const fakeTrigger = {
-            results: [],
-            triggered_check_ids: [fakeId],
+            batch_id: 'bid',
+            locations: [],
         };
-        afterAll(() => {
-            jest.clearAllMocks();
-        });
         test('should run test', () => __awaiter(void 0, void 0, void 0, function* () {
-            const axiosMock = jest.spyOn(axios_1.default, 'create');
-            axiosMock.mockImplementation((() => (e) => {
-                if (e.url === '/synthetics/tests/trigger/ci') {
-                    return { data: fakeTrigger };
-                }
-            }));
+            jest.spyOn(api, 'triggerTests').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return fakeTrigger; }));
             const output = yield utils.runTests(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }]);
             expect(output).toEqual(fakeTrigger);
         }));
@@ -120,12 +116,7 @@ describe('utils', () => {
             expect(headersMetadataSpy).toHaveBeenCalledWith(expect.objectContaining({ 'X-Trigger-App': 'unit_test' }));
         }));
         test('should run test with publicId from url', () => __awaiter(void 0, void 0, void 0, function* () {
-            const axiosMock = jest.spyOn(axios_1.default, 'create');
-            axiosMock.mockImplementation((() => (e) => {
-                if (e.url === '/synthetics/tests/trigger/ci') {
-                    return { data: fakeTrigger };
-                }
-            }));
+            jest.spyOn(api, 'triggerTests').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return fakeTrigger; }));
             const output = yield utils.runTests(api, [
                 {
                     executionRule: interfaces_1.ExecutionRule.NON_BLOCKING,
@@ -143,11 +134,9 @@ describe('utils', () => {
                     status: 502,
                 },
             });
-            const requestMock = jest.fn();
-            requestMock.mockImplementation(() => {
+            jest.spyOn(api, 'triggerTests').mockImplementation(() => {
                 throw serverError;
             });
-            jest.spyOn(axios_1.default, 'create').mockImplementation((() => requestMock));
             yield expect(utils.runTests(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }])).rejects.toThrow(/Failed to trigger tests:/);
         }));
     });
@@ -167,7 +156,7 @@ describe('utils', () => {
                 suite: 'Suite 3',
             },
         };
-        beforeAll(() => {
+        beforeEach(() => {
             const axiosMock = jest.spyOn(axios_1.default, 'create');
             axiosMock.mockImplementation((() => (e) => {
                 const publicId = e.url.slice(18);
@@ -179,9 +168,6 @@ describe('utils', () => {
                 throw error;
             }));
         });
-        afterAll(() => {
-            jest.clearAllMocks();
-        });
         test('only existing tests are returned', () => __awaiter(void 0, void 0, void 0, function* () {
             const triggerConfigs = [
                 { suite: 'Suite 1', config: {}, id: '123-456-789' },
@@ -344,71 +330,59 @@ describe('utils', () => {
             const result = {
                 device: { height: 0, id: 'laptop_large', width: 0 },
                 duration: 0,
-                eventType: 'finished',
                 passed: true,
                 startUrl: '',
                 stepDetails: [],
             };
-            expect(utils.hasResultPassed(result, false, true)).toBeTruthy();
-            expect(utils.hasResultPassed(result, true, true)).toBeTruthy();
+            expect(utils.hasResultPassed(result, false, false, true)).toBeTruthy();
+            expect(utils.hasResultPassed(result, false, true, true)).toBeTruthy();
             result.passed = false;
-            expect(utils.hasResultPassed(result, false, true)).toBeFalsy();
-            expect(utils.hasResultPassed(result, true, true)).toBeFalsy();
+            expect(utils.hasResultPassed(result, false, false, true)).toBeFalsy();
+            expect(utils.hasResultPassed(result, false, true, true)).toBeFalsy();
         });
         test('result with error', () => {
             const result = {
                 device: { height: 0, id: 'laptop_large', width: 0 },
                 duration: 0,
-                errorCode: 'ERRABORTED',
-                eventType: 'finished',
+                failure: {
+                    code: 'ERRABORTED',
+                    message: 'Connection aborted',
+                },
                 passed: false,
                 startUrl: '',
                 stepDetails: [],
             };
-            expect(utils.hasResultPassed(result, false, true)).toBeFalsy();
-            expect(utils.hasResultPassed(result, true, true)).toBeFalsy();
+            expect(utils.hasResultPassed(result, false, false, true)).toBeFalsy();
+            expect(utils.hasResultPassed(result, false, true, true)).toBeFalsy();
         });
         test('result with unhealthy result', () => {
             const result = {
                 device: { height: 0, id: 'laptop_large', width: 0 },
                 duration: 0,
-                errorCode: 'ERRABORTED',
-                eventType: 'finished',
+                failure: {
+                    code: 'ERRABORTED',
+                    message: 'Connection aborted',
+                },
                 passed: false,
                 startUrl: '',
                 stepDetails: [],
                 unhealthy: true,
             };
-            expect(utils.hasResultPassed(result, false, true)).toBeTruthy();
-            expect(utils.hasResultPassed(result, true, true)).toBeFalsy();
+            expect(utils.hasResultPassed(result, false, false, true)).toBeTruthy();
+            expect(utils.hasResultPassed(result, false, true, true)).toBeFalsy();
         });
         test('result with timeout result', () => {
             const result = {
                 device: { height: 0, id: 'laptop_large', width: 0 },
                 duration: 0,
-                error: interfaces_1.ERRORS.TIMEOUT,
-                eventType: 'finished',
                 passed: false,
                 startUrl: '',
                 stepDetails: [],
             };
-            expect(utils.hasResultPassed(result, true, true)).toBeFalsy();
-            expect(utils.hasResultPassed(result, true, false)).toBeTruthy();
+            expect(utils.hasResultPassed(result, true, true, true)).toBeFalsy();
+            expect(utils.hasResultPassed(result, true, true, false)).toBeTruthy();
         });
     });
-    test('result with endpoint failure result', () => {
-        const result = {
-            device: { height: 0, id: 'laptop_large', width: 0 },
-            duration: 0,
-            error: interfaces_1.ERRORS.ENDPOINT,
-            eventType: 'finished',
-            passed: false,
-            startUrl: '',
-            stepDetails: [],
-        };
-        expect(utils.hasResultPassed(result, false, true)).toBeTruthy();
-        expect(utils.hasResultPassed(result, true, true)).toBeFalsy();
-    });
     describe('getExecutionRule', () => {
         const cases = [
             [undefined, undefined, interfaces_1.ExecutionRule.BLOCKING],
@@ -437,211 +411,142 @@ describe('utils', () => {
             jest.spyOn(utils, 'getExecutionRule').mockReturnValue(resultRule);
             const test = fixtures_1.getApiTest('abc-def-ghi');
             const result = fixtures_1.getApiResult('1', test);
+            result.executionRule = resultRule;
             result.passed = resultPassed;
             expect(utils.getResultOutcome(result)).toEqual(expectedOutcome);
         });
     });
     describe('waitForResults', () => {
-        const mockAxiosWithDefaultResult = () => {
-            jest.spyOn(axios_1.default, 'create').mockImplementation((() => (r) => __awaiter(void 0, void 0, void 0, function* () {
-                yield utils.wait(100);
-                const results = JSON.parse(r.params.result_ids)
-                    .filter((resultId) => resultId !== 'timingOutTest')
-                    .map((resultId) => getPassingPollResult(resultId));
-                return { data: { results } };
-            })));
-        };
-        afterAll(() => {
-            jest.clearAllMocks();
+        beforeAll(() => {
+            // We still wait a few milliseconds to avoid the test going crazy on a infinite loop
+            // if case of mistakes in the code or test.
+            jest.spyOn(utils, 'wait').mockImplementation(() => new Promise((r) => setTimeout(r, 10)));
         });
-        const testConfig = fixtures_1.getApiTest('abc-def-ghi');
-        const getPassingPollResult = (resultId) => {
-            const result = getPassingResult(resultId);
-            return {
-                check: result.test,
-                enrichment: result.enrichment,
-                result: result.result,
-                resultID: result.resultId,
-                timestamp: result.timestamp,
-            };
-        };
-        const getPassingResult = (resultId) => ({
+        const batch = fixtures_1.getBatch();
+        const apiTest = fixtures_1.getApiTest(batch.results[0].test_public_id);
+        const result = {
+            executionRule: interfaces_1.ExecutionRule.BLOCKING,
             location: fixtures_1.mockLocation.display_name,
             passed: true,
-            result: fixtures_1.getBrowserServerResult({ error: interfaces_1.ERRORS.TIMEOUT, passed: false }),
-            resultId,
-            test: testConfig,
+            result: fixtures_1.getBrowserServerResult({ passed: true }),
+            resultId: batch.results[0].result_id,
+            test: apiTest,
+            timedOut: false,
             timestamp: 0,
-        });
-        const getTestAndResult = (publicId = 'abc-def-ghi', resultId = '0123456789') => {
-            const triggerResult = {
-                device: 'laptop_large',
-                location: fixtures_1.mockLocation.id,
-                public_id: publicId,
-                result_id: resultId,
-            };
-            const triggerConfig = {
-                config: {},
-                id: publicId,
-                suite: 'Suite 1',
-            };
-            const passingResult = getPassingResult(resultId);
-            return {
-                passingResult,
-                test: passingResult.test,
-                trigger: { locations: [fixtures_1.mockLocation], results: [triggerResult] },
-                triggerConfig,
-                triggerResult,
-            };
+        };
+        const pollResult = {
+            check: result.test,
+            result: result.result,
+            resultID: result.resultId,
+            timestamp: result.timestamp,
+        };
+        const trigger = { batch_id: 'bid', locations: [fixtures_1.mockLocation] };
+        const mockApi = ({ getBatchImplementation, pollResultsImplementation, } = {}) => {
+            const getBatchMock = jest
+                .spyOn(api, 'getBatch')
+                .mockImplementation(getBatchImplementation || (() => __awaiter(void 0, void 0, void 0, function* () { return JSON.parse(JSON.stringify(batch)); })));
+            const pollResultsMock = jest
+                .spyOn(api, 'pollResults')
+                .mockImplementation(pollResultsImplementation || (() => __awaiter(void 0, void 0, void 0, function* () { return JSON.parse(JSON.stringify([pollResult])); })));
+            return { getBatchMock, pollResultsMock };
         };
         test('should poll result ids', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockAxiosWithDefaultResult();
-            const { test, trigger, passingResult, triggerConfig } = getTestAndResult();
-            const waitMock = jest.spyOn(utils, 'wait');
-            waitMock.mockImplementation();
-            const expectedResults = [passingResult];
-            expect(yield utils.waitForResults(api, trigger, [triggerConfig], [test], { defaultTimeout: 120000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual(expectedResults);
-            expect(fixtures_1.mockReporter.resultReceived).toHaveBeenCalledWith(passingResult);
+            mockApi();
+            expect(yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 120000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual([result]);
+            expect(fixtures_1.mockReporter.resultReceived).toHaveBeenCalledWith(batch.results[0]);
         }));
-        test('results should be timed-out if global pollingTimeout is exceeded', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { test, trigger, triggerResult } = getTestAndResult();
-            const expectedResults = [
-                {
-                    location: fixtures_1.mockLocation.display_name,
-                    passed: true,
-                    result: fixtures_1.getBrowserServerResult({
-                        device: { height: 0, id: triggerResult.device, width: 0 },
-                        error: interfaces_1.ERRORS.TIMEOUT,
-                        passed: false,
-                    }),
-                    resultId: triggerResult.result_id,
-                    test,
-                    timestamp: 0,
-                },
-            ];
-            expect(yield utils.waitForResults(api, trigger, [], [test], { defaultTimeout: 0, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual(expectedResults);
+        test('results should be timed out if global pollingTimeout is exceeded', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockApi({ getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return (Object.assign(Object.assign({}, batch), { status: 'in_progress' })); }) });
+            expect(yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 0, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual([
+                Object.assign(Object.assign({}, result), { result: Object.assign(Object.assign({}, result.result), { failure: { code: 'TIMEOUT', message: 'Result timed out' }, passed: false }), timedOut: true }),
+            ]);
         }));
-        test('results should be timeout-ed if test pollingTimeout is exceeded', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { test, trigger, triggerResult } = getTestAndResult();
-            const expectedResults = [
-                {
-                    location: fixtures_1.mockLocation.display_name,
-                    passed: true,
-                    result: fixtures_1.getBrowserServerResult({
-                        device: { height: 0, id: triggerResult.device, width: 0 },
-                        error: interfaces_1.ERRORS.TIMEOUT,
-                        passed: false,
-                    }),
-                    resultId: triggerResult.result_id,
-                    test,
-                    timestamp: 0,
-                },
-            ];
-            const testTriggerConfig = {
-                config: { pollingTimeout: 0 },
-                id: triggerResult.public_id,
-                suite: 'Suite 1',
-            };
-            expect(yield utils.waitForResults(api, trigger, [testTriggerConfig], [test], { defaultTimeout: 120000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual(expectedResults);
+        test('results failure should ignore if timed-out', () => __awaiter(void 0, void 0, void 0, function* () {
+            // The original failure of a result received between timing-out in batch poll
+            // and retrieving it should be ignored in favor of timeout.
+            mockApi({
+                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return [
+                        Object.assign(Object.assign({}, pollResult), { result: Object.assign(Object.assign({}, pollResult.result), { failure: { code: 'FAILURE', message: 'Original failure, should be ignored' }, passed: false }) }),
+                    ];
+                }),
+            });
+            expect(yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 0, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toStrictEqual([
+                Object.assign(Object.assign({}, result), { result: Object.assign(Object.assign({}, result.result), { failure: { code: 'TIMEOUT', message: 'Result timed out' }, passed: false }), timedOut: true }),
+            ]);
+        }));
+        test('results should be timed out if batch result is timed out', () => __awaiter(void 0, void 0, void 0, function* () {
+            const batchWithTimeoutResult = Object.assign(Object.assign({}, batch), { results: [Object.assign(Object.assign({}, batch.results[0]), { timed_out: true })] });
+            mockApi({ getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return batchWithTimeoutResult; }) });
+            expect(yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 120000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual([
+                Object.assign(Object.assign({}, result), { result: Object.assign(Object.assign({}, result.result), { failure: { code: 'TIMEOUT', message: 'Result timed out' }, passed: false }), timedOut: true }),
+            ]);
+        }));
+        test('wait between batch polling', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.restoreAllMocks();
+            const waitMock = jest.spyOn(utils, 'wait').mockImplementation(() => new Promise((r) => setTimeout(r, 10)));
+            let counter = 0;
+            mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    counter += 1;
+                    return counter === 3 ? batch : Object.assign(Object.assign({}, batch), { status: 'in_progress' });
+                }),
+            });
+            expect(yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 120000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual([result]);
+            expect(counter).toBe(3);
+            expect(waitMock).toHaveBeenCalledTimes(2);
         }));
         test('correct number of pass and timeout results', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockAxiosWithDefaultResult();
-            const { test, trigger, triggerResult, passingResult } = getTestAndResult();
-            const waitMock = jest.spyOn(utils, 'wait');
-            waitMock.mockImplementation();
-            const triggerResultTimeOut = Object.assign(Object.assign({}, triggerResult), { result_id: 'timingOutTest' });
-            const expectedResults = [
-                passingResult,
-                {
-                    location: fixtures_1.mockLocation.display_name,
-                    passed: true,
-                    result: fixtures_1.getBrowserServerResult({
-                        device: { height: 0, id: triggerResultTimeOut.device, width: 0 },
-                        error: interfaces_1.ERRORS.TIMEOUT,
-                        passed: false,
-                    }),
-                    resultId: triggerResultTimeOut.result_id,
-                    test,
-                    timestamp: 0,
-                },
-            ];
-            trigger.results = [triggerResult, triggerResultTimeOut];
-            expect(yield utils.waitForResults(api, trigger, [], [test], { defaultTimeout: 2000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual(expectedResults);
+            const pollTimeoutResult = Object.assign(Object.assign({}, pollResult), { resultID: 'another-id' });
+            const batchWithTimeoutResult = Object.assign(Object.assign({}, batch), { results: [batch.results[0], Object.assign(Object.assign({}, batch.results[0]), { timed_out: true, result_id: pollTimeoutResult.resultID })] });
+            mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return batchWithTimeoutResult; }),
+                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return [pollResult, pollTimeoutResult]; }),
+            });
+            expect(yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 2000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual([result, Object.assign(Object.assign({}, result), { resultId: pollTimeoutResult.resultID, timedOut: true })]);
         }));
         test('tunnel failure', () => __awaiter(void 0, void 0, void 0, function* () {
-            const waitMock = jest.spyOn(utils, 'wait');
-            waitMock.mockImplementation();
-            const { test, trigger, triggerResult } = getTestAndResult();
-            // Fake pollResults to not update results and iterate until the isTunnelConnected is equal to false
-            jest
-                .spyOn(axios_1.default, 'create')
-                .mockImplementation((() => (r) => __awaiter(void 0, void 0, void 0, function* () { return ({ data: { results: [] } }); })));
+            mockApi();
             const mockTunnel = {
                 keepAlive: () => __awaiter(void 0, void 0, void 0, function* () {
                     throw new Error('keepAlive failed');
                 }),
             };
-            const expectedResults = [
-                {
-                    location: 'Tunneled',
-                    passed: false,
-                    result: fixtures_1.getBrowserServerResult({
-                        device: { height: 0, id: triggerResult.device, width: 0 },
-                        error: interfaces_1.ERRORS.TUNNEL,
-                        passed: false,
-                    }),
-                    resultId: triggerResult.result_id,
-                    test,
-                    timestamp: 0,
-                },
-            ];
-            expect(yield utils.waitForResults(api, trigger, [], [test], { defaultTimeout: 2000, failOnCriticalErrors: true }, fixtures_1.mockReporter, mockTunnel)).toEqual(expectedResults);
-            expect(yield utils.waitForResults(api, trigger, [], [test], { defaultTimeout: 2000, failOnCriticalErrors: false }, fixtures_1.mockReporter, mockTunnel)).toEqual(expectedResults);
+            yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 2000, failOnCriticalErrors: true }, fixtures_1.mockReporter, mockTunnel);
+            expect(fixtures_1.mockReporter.error).toBeCalledWith('The tunnel has stopped working, this may have affected the results.');
         }));
         test('location when tunnel', () => __awaiter(void 0, void 0, void 0, function* () {
-            const waitMock = jest.spyOn(utils, 'wait');
-            waitMock.mockImplementation();
-            const { test, trigger } = getTestAndResult();
-            const mockTunnel = {
-                keepAlive: () => __awaiter(void 0, void 0, void 0, function* () { return true; }),
-            };
-            let results = yield utils.waitForResults(api, trigger, [], [test], { defaultTimeout: 2000, failOnCriticalErrors: true }, fixtures_1.mockReporter, mockTunnel);
+            mockApi();
+            const mockTunnel = { keepAlive: () => __awaiter(void 0, void 0, void 0, function* () { return true; }) };
+            let results = yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 2000, failOnCriticalErrors: true }, fixtures_1.mockReporter, mockTunnel);
             expect(results[0].location).toBe('Tunneled');
-            const newTest = Object.assign({}, test);
+            const newTest = Object.assign({}, result.test);
             newTest.type = 'api';
             newTest.subtype = 'http';
-            results = yield utils.waitForResults(api, trigger, [], [newTest], { defaultTimeout: 2000, failOnCriticalErrors: true }, fixtures_1.mockReporter, mockTunnel);
+            results = yield utils.waitForResults(api, trigger, [newTest], { maxPollingTimeout: 2000, failOnCriticalErrors: true }, fixtures_1.mockReporter, mockTunnel);
             expect(results[0].location).toBe('Tunneled');
             newTest.type = 'api';
             newTest.subtype = 'ssl';
-            results = yield utils.waitForResults(api, trigger, [], [newTest], { defaultTimeout: 2000, failOnCriticalErrors: true }, fixtures_1.mockReporter, mockTunnel);
+            results = yield utils.waitForResults(api, trigger, [newTest], { failOnCriticalErrors: true, maxPollingTimeout: 2000 }, fixtures_1.mockReporter, mockTunnel);
             expect(results[0].location).toBe('Frankfurt (AWS)');
         }));
         test('pollResults throws', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { test, trigger, triggerResult } = getTestAndResult();
-            jest.spyOn(utils, 'wait').mockImplementation();
-            const axiosMock = jest.spyOn(axios_1.default, 'create');
-            const serverError = new Error('Server Error');
-            serverError.response = { status: 502 };
-            axiosMock.mockImplementation((() => (r) => __awaiter(void 0, void 0, void 0, function* () {
-                throw serverError;
-            })));
-            const mockTunnel = { keepAlive: () => __awaiter(void 0, void 0, void 0, function* () { return Promise.reject(); }) };
-            expect(yield utils.waitForResults(api, trigger, [], [test], { defaultTimeout: 2000, failOnCriticalErrors: false }, fixtures_1.mockReporter, mockTunnel)).toEqual([
-                {
-                    location: 'Tunneled',
-                    passed: true,
-                    result: fixtures_1.getBrowserServerResult({
-                        device: { height: 0, id: triggerResult.device, width: 0 },
-                        error: interfaces_1.ERRORS.ENDPOINT,
-                        passed: false,
-                    }),
-                    resultId: triggerResult.result_id,
-                    test,
-                    timestamp: 0,
+            const { pollResultsMock } = mockApi({
+                pollResultsImplementation: () => {
+                    throw new Error('Poll results server error');
                 },
-            ]);
-            yield expect(utils.waitForResults(api, trigger, [], [test], { defaultTimeout: 2000, failOnCriticalErrors: true }, fixtures_1.mockReporter, mockTunnel)).rejects.toThrow();
+            });
+            yield expect(utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 2000 }, fixtures_1.mockReporter)).rejects.toThrowError('Failed to poll results: Poll results server error');
+            expect(pollResultsMock).toHaveBeenCalledWith([result.resultId]);
+        }));
+        test('getBatch throws', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { getBatchMock } = mockApi({
+                getBatchImplementation: () => {
+                    throw new Error('Get batch server error');
+                },
+            });
+            yield expect(utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 2000 }, fixtures_1.mockReporter)).rejects.toThrowError('Failed to get batch: Get batch server error');
+            expect(getBatchMock).toHaveBeenCalledWith(trigger.batch_id);
         }));
     });
     test('getStrictestExecutionRule', () => {
@@ -699,5 +604,144 @@ describe('utils', () => {
         expect(utils.parseVariablesFromCli([''], mockLogFunction)).toBeUndefined();
         expect(utils.parseVariablesFromCli(undefined, mockLogFunction)).toBeUndefined();
     });
+    test('getAppBaseURL', () => {
+        expect(utils.getAppBaseURL({ datadogSite: 'datadoghq.eu', subdomain: 'custom' })).toBe('https://custom.datadoghq.eu/');
+    });
+    describe('sortResultsByOutcome', () => {
+        const results = fixtures_1.getResults([
+            { executionRule: interfaces_1.ExecutionRule.NON_BLOCKING, passed: false },
+            { executionRule: interfaces_1.ExecutionRule.BLOCKING, passed: true },
+            { executionRule: interfaces_1.ExecutionRule.BLOCKING, passed: false },
+            { executionRule: interfaces_1.ExecutionRule.NON_BLOCKING, passed: true },
+        ]);
+        test('should sort tests with success, non_blocking failures then failures', () => __awaiter(void 0, void 0, void 0, function* () {
+            const sortedResults = [...results];
+            sortedResults.sort(utils.sortResultsByOutcome());
+            expect(sortedResults.map((r) => r.resultId)).toStrictEqual(['3', '1', '0', '2']);
+        }));
+    });
+    describe('Render results', () => {
+        const emptySummary = utils.createSummary();
+        const cases = [
+            {
+                description: '1 API test with 1 config override, 1 result (passed)',
+                expected: {
+                    exitCode: 0,
+                    summary: Object.assign(Object.assign({}, emptySummary), { passed: 1 }),
+                },
+                failOnCriticalErrors: false,
+                failOnTimeout: false,
+                results: fixtures_1.getResults([{ passed: true }]),
+                summary: Object.assign({}, emptySummary),
+            },
+            {
+                description: '1 API test with 1 config override, 1 result (failed timeout), no fail on timeout, no fail on critical errors',
+                expected: {
+                    exitCode: 0,
+                    summary: Object.assign(Object.assign({}, emptySummary), { passed: 1, timedOut: 1 }),
+                },
+                failOnCriticalErrors: false,
+                failOnTimeout: false,
+                results: fixtures_1.getResults([{ timedOut: true }]),
+                summary: Object.assign({}, emptySummary),
+            },
+            {
+                description: '1 API test with 1 config override, 1 result (failed timeout), fail on timeout, no fail on critical errors',
+                expected: {
+                    exitCode: 1,
+                    summary: Object.assign(Object.assign({}, emptySummary), { failed: 1 }),
+                },
+                failOnCriticalErrors: false,
+                failOnTimeout: true,
+                results: fixtures_1.getResults([{ timedOut: true }]),
+                summary: Object.assign({}, emptySummary),
+            },
+            {
+                description: '1 API test with 1 config override, 1 result (failed critical error), no fail on timeout, no fail on critical errors',
+                expected: {
+                    exitCode: 0,
+                    summary: Object.assign(Object.assign({}, emptySummary), { passed: 1, criticalErrors: 1 }),
+                },
+                failOnCriticalErrors: false,
+                failOnTimeout: false,
+                results: fixtures_1.getResults([{ unhealthy: true }]),
+                summary: Object.assign({}, emptySummary),
+            },
+            {
+                description: '1 API test with 1 config override, 1 result (failed critical error), no fail on timeout, fail on critical errors',
+                expected: {
+                    exitCode: 1,
+                    summary: Object.assign(Object.assign({}, emptySummary), { criticalErrors: 0, failed: 1 }),
+                },
+                failOnCriticalErrors: true,
+                failOnTimeout: false,
+                results: fixtures_1.getResults([{ unhealthy: true }]),
+                summary: Object.assign({}, emptySummary),
+            },
+            {
+                description: '1 API test (blocking) with 4 config overrides (1 skipped), 3 results (1 passed, 1 failed, 1 failed non-blocking)',
+                expected: {
+                    exitCode: 1,
+                    summary: Object.assign(Object.assign({}, emptySummary), { failed: 1, failedNonBlocking: 1, passed: 1, skipped: 1 }),
+                },
+                failOnCriticalErrors: false,
+                failOnTimeout: false,
+                results: fixtures_1.getResults([{ passed: true }, { executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }, {}]),
+                summary: Object.assign(Object.assign({}, emptySummary), { skipped: 1 }),
+            },
+            {
+                description: '1 API test (non-blocking) with 4 config overrides (1 skipped), 3 results (1 passed, 1 failed, 1 failed non-blocking)',
+                expected: {
+                    exitCode: 0,
+                    summary: Object.assign(Object.assign({}, emptySummary), { failedNonBlocking: 2, passed: 1, skipped: 1 }),
+                },
+                failOnCriticalErrors: false,
+                failOnTimeout: false,
+                results: fixtures_1.getResults([
+                    {
+                        executionRule: interfaces_1.ExecutionRule.NON_BLOCKING,
+                        testExecutionRule: interfaces_1.ExecutionRule.NON_BLOCKING,
+                    },
+                    { passed: true, testExecutionRule: interfaces_1.ExecutionRule.NON_BLOCKING },
+                    {
+                        testExecutionRule: interfaces_1.ExecutionRule.NON_BLOCKING,
+                    },
+                ]),
+                summary: Object.assign(Object.assign({}, emptySummary), { skipped: 1 }),
+            },
+            {
+                description: '3 API tests (blocking) with 1 config override each, 3 results (1 failed non-blocking, 1 failed, 1 passed)',
+                expected: {
+                    exitCode: 1,
+                    summary: Object.assign(Object.assign({}, emptySummary), { failed: 1, failedNonBlocking: 1, passed: 1 }),
+                },
+                failOnCriticalErrors: false,
+                failOnTimeout: false,
+                results: fixtures_1.getResults([{}, { passed: true }, { executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }]),
+                summary: Object.assign({}, emptySummary),
+            },
+        ];
+        test.each(cases)('$description', (testCase) => __awaiter(void 0, void 0, void 0, function* () {
+            testCase.results.forEach((result) => (result.passed = utils.hasResultPassed(result.result, result.timedOut, testCase.failOnCriticalErrors, testCase.failOnTimeout)));
+            const config = Object.assign(Object.assign({}, command_1.DEFAULT_COMMAND_CONFIG), { failOnCriticalErrors: testCase.failOnCriticalErrors, failOnTimeout: testCase.failOnTimeout });
+            const startTime = Date.now();
+            const exitCode = utils.renderResults({
+                config,
+                reporter: fixtures_1.mockReporter,
+                results: testCase.results,
+                startTime,
+                summary: testCase.summary,
+            });
+            expect(fixtures_1.mockReporter.reportStart).toHaveBeenCalledWith({ startTime });
+            expect(fixtures_1.mockReporter.resultEnd).toHaveBeenCalledTimes(testCase.results.length);
+            const baseUrl = `https://${command_1.DEFAULT_COMMAND_CONFIG.subdomain}.${command_1.DEFAULT_COMMAND_CONFIG.datadogSite}/`;
+            for (const result of testCase.results) {
+                expect(fixtures_1.mockReporter.resultEnd).toHaveBeenCalledWith(result, baseUrl);
+            }
+            expect(testCase.summary).toEqual(testCase.expected.summary);
+            expect(fixtures_1.mockReporter.runEnd).toHaveBeenCalledWith(testCase.expected.summary, baseUrl);
+            expect(exitCode).toBe(testCase.expected.exitCode);
+        }));
+    });
 });
 //# sourceMappingURL=utils.test.js.map