@datadog/datadog-ci 2.40.0 → 2.40.2

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

@@ -0,0 +1,1526 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('glob');
+jest.mock('fs');
+jest.mock('child_process');
+jest.unmock('chalk');
+jest.mock('path', () => {
+    const actualPath = jest.requireActual('path');
+    return Object.assign(Object.assign({}, actualPath), { relative: (from, to) => {
+            if (from === '/path/to/project' && to === '/path/to/another-project') {
+                return '../another-project';
+            }
+            if (from === '/path/to/project' && to === '/other-path/to/project') {
+                return '../../../other-path/to/project';
+            }
+            if (from === '/path/to/git/repository' && to === '/path/to/another-project') {
+                return '../../another-project';
+            }
+            if (from === '/path/to/git/repository' && to === '/other-path/to/project') {
+                return '../../../../other-path/to/project';
+            }
+            if (from.endsWith('subfolder') || to.endsWith('subfolder')) {
+                return 'subfolder';
+            }
+            if (to === '..') {
+                return '..';
+            }
+            return '.';
+        } });
+});
+const child_process_1 = __importDefault(require("child_process"));
+const fs = __importStar(require("fs"));
+const process_1 = __importDefault(require("process"));
+const axios_1 = __importDefault(require("axios"));
+const deep_extend_1 = __importDefault(require("deep-extend"));
+const glob_1 = require("glob");
+process_1.default.env.DATADOG_SYNTHETICS_CI_TRIGGER_APP = 'env_default';
+const ciHelpers = __importStar(require("../../../../helpers/ci"));
+const api_1 = require("../../api");
+const errors_1 = require("../../errors");
+const interfaces_1 = require("../../interfaces");
+const mobile = __importStar(require("../../mobile"));
+const run_tests_command_1 = require("../../run-tests-command");
+const utils = __importStar(require("../../utils/public"));
+const fixtures_1 = require("../fixtures");
+describe('utils', () => {
+    const apiConfiguration = {
+        apiKey: '123',
+        appKey: '123',
+        baseIntakeUrl: 'baseintake',
+        baseUnstableUrl: 'baseUnstable',
+        baseUrl: 'base',
+        proxyOpts: { protocol: 'http' },
+    };
+    const api = (0, api_1.apiConstructor)(apiConfiguration);
+    describe('getSuites', () => {
+        const GLOB = 'testGlob';
+        const FILES = ['file1', 'file2'];
+        const FILES_CONTENT = {
+            file1: '{"tests":"file1"}',
+            file2: '{"tests":"file2"}',
+        };
+        jest.spyOn(glob_1.glob, 'glob').mockResolvedValue(FILES);
+        fs.readFile.mockImplementation((path, opts, callback) => callback(undefined, FILES_CONTENT[path]));
+        child_process_1.default.exec.mockImplementation((command, callback) => callback(undefined, '.', ''));
+        test('should get suites', () => __awaiter(void 0, void 0, void 0, function* () {
+            const suites = yield utils.getSuites(GLOB, fixtures_1.mockReporter);
+            expect(JSON.stringify(suites)).toBe(`[{"name":"file1","content":${FILES_CONTENT.file1}},{"name":"file2","content":${FILES_CONTENT.file2}}]`);
+        }));
+    });
+    describe('getFilePathRelativeToRepo', () => {
+        test('datadog-ci is not run in a git repository', () => __awaiter(void 0, void 0, void 0, function* () {
+            const pathToProject = '/path/to/project';
+            jest.spyOn(process_1.default, 'cwd').mockImplementation(() => pathToProject);
+            child_process_1.default.exec.mockImplementation((command, callback) => callback(Error('Not a git repository'), '', ''));
+            // Use the process working directory instead of the git repository's top level.
+            yield expect(utils.getFilePathRelativeToRepo('config.json')).resolves.toEqual('config.json');
+            yield expect(utils.getFilePathRelativeToRepo('./config.json')).resolves.toEqual('config.json');
+            yield expect(utils.getFilePathRelativeToRepo(`${pathToProject}/config.json`)).resolves.toEqual('config.json');
+            // Those cases will show a broken hyperlink in the GitLab test report because the file is outside of the project.
+            yield expect(utils.getFilePathRelativeToRepo('../config.json')).resolves.toEqual('../config.json');
+            yield expect(utils.getFilePathRelativeToRepo('/path/to/another-project/config.json')).resolves.toEqual('../another-project/config.json');
+            yield expect(utils.getFilePathRelativeToRepo('/other-path/to/project/config.json')).resolves.toEqual('../../../other-path/to/project/config.json');
+        }));
+        test('datadog-ci is run in the root of a git repository', () => __awaiter(void 0, void 0, void 0, function* () {
+            const pathToGitRepository = '/path/to/git/repository';
+            jest.spyOn(process_1.default, 'cwd').mockImplementation(() => pathToGitRepository);
+            child_process_1.default.exec.mockImplementation((command, callback) => callback(undefined, pathToGitRepository, ''));
+            yield expect(utils.getFilePathRelativeToRepo('config.json')).resolves.toEqual('config.json');
+            yield expect(utils.getFilePathRelativeToRepo('./config.json')).resolves.toEqual('config.json');
+            yield expect(utils.getFilePathRelativeToRepo(`${pathToGitRepository}/config.json`)).resolves.toEqual('config.json');
+            yield expect(utils.getFilePathRelativeToRepo('subfolder/config.json')).resolves.toEqual('subfolder/config.json');
+            yield expect(utils.getFilePathRelativeToRepo('./subfolder/config.json')).resolves.toEqual('subfolder/config.json');
+            yield expect(utils.getFilePathRelativeToRepo(`${pathToGitRepository}/subfolder/config.json`)).resolves.toEqual('subfolder/config.json');
+            // Those cases will show a broken hyperlink in the GitLab test report because the file is outside of the repository.
+            yield expect(utils.getFilePathRelativeToRepo('../config.json')).resolves.toEqual('../config.json');
+            yield expect(utils.getFilePathRelativeToRepo('/path/to/another-project/config.json')).resolves.toEqual('../../another-project/config.json');
+            yield expect(utils.getFilePathRelativeToRepo('/other-path/to/project/config.json')).resolves.toEqual('../../../../other-path/to/project/config.json');
+        }));
+        test('datadog-ci is run in a subfolder of a git repository', () => __awaiter(void 0, void 0, void 0, function* () {
+            const pathToGitRepositorySubfolder = '/path/to/git/repository/subfolder';
+            jest.spyOn(process_1.default, 'cwd').mockImplementation(() => pathToGitRepositorySubfolder);
+            child_process_1.default.exec.mockImplementation((command, callback) => callback(undefined, '/path/to/git/repository', ''));
+            // ...so the relative path must be prefixed with the subfolder.
+            yield expect(utils.getFilePathRelativeToRepo('config.json')).resolves.toEqual('subfolder/config.json');
+            yield expect(utils.getFilePathRelativeToRepo('./config.json')).resolves.toEqual('subfolder/config.json');
+            yield expect(utils.getFilePathRelativeToRepo(`${pathToGitRepositorySubfolder}/config.json`)).resolves.toEqual('subfolder/config.json');
+        }));
+    });
+    describe('runTest', () => {
+        beforeEach(() => {
+            jest.restoreAllMocks();
+        });
+        const fakeId = '123-456-789';
+        const fakeTrigger = {
+            batch_id: 'bid',
+            locations: [],
+        };
+        test('should run test', () => __awaiter(void 0, void 0, void 0, function* () {
+            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);
+        }));
+        test('runTests sends batch metadata', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(ciHelpers, 'getCIMetadata').mockImplementation(() => undefined);
+            const payloadMetadataSpy = jest.fn();
+            jest.spyOn(axios_1.default, 'create').mockImplementation((() => (request) => {
+                payloadMetadataSpy(request.data.metadata);
+                if (request.url === '/synthetics/tests/trigger/ci') {
+                    return { data: fakeTrigger };
+                }
+            }));
+            yield utils.runTests(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }]);
+            expect(payloadMetadataSpy).toHaveBeenCalledWith(undefined);
+            const metadata = {
+                ci: { job: { name: 'job' }, pipeline: {}, provider: { name: 'jest' }, stage: {} },
+                git: { commit: { author: {}, committer: {}, message: 'test' } },
+            };
+            jest.spyOn(ciHelpers, 'getCIMetadata').mockImplementation(() => metadata);
+            yield utils.runTests(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }]);
+            expect(payloadMetadataSpy).toHaveBeenCalledWith(metadata);
+        }));
+        test('runTests api call includes trigger app header', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(ciHelpers, 'getCIMetadata').mockImplementation(() => undefined);
+            const headersMetadataSpy = jest.fn();
+            jest.spyOn(axios_1.default, 'create').mockImplementation((() => (request) => {
+                headersMetadataSpy(request.headers);
+                if (request.url === '/synthetics/tests/trigger/ci') {
+                    return { data: fakeTrigger };
+                }
+            }));
+            yield utils.runTests(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }]);
+            expect(headersMetadataSpy).toHaveBeenCalledWith(expect.objectContaining({ 'X-Trigger-App': 'env_default' }));
+            utils.setCiTriggerApp('unit_test');
+            yield utils.runTests(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }]);
+            expect(headersMetadataSpy).toHaveBeenCalledWith(expect.objectContaining({ 'X-Trigger-App': 'unit_test' }));
+        }));
+        test('runTests api call does not send deprecated properties', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(ciHelpers, 'getCIMetadata').mockImplementation(() => undefined);
+            const testsPayloadSpy = jest.fn();
+            jest.spyOn(axios_1.default, 'create').mockImplementation((() => (request) => {
+                testsPayloadSpy(request.data.tests);
+                if (request.url === '/synthetics/tests/trigger/ci') {
+                    return { data: fakeTrigger };
+                }
+            }));
+            yield utils.runTests(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING, pollingTimeout: 1 }]);
+            expect(testsPayloadSpy).toHaveBeenCalledWith([
+                {
+                    public_id: fakeId,
+                    executionRule: interfaces_1.ExecutionRule.NON_BLOCKING,
+                    // no pollingTimeout
+                },
+            ]);
+        }));
+        test('should run test with publicId from url', () => __awaiter(void 0, void 0, void 0, function* () {
+            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,
+                    public_id: `http://localhost/synthetics/tests/details/${fakeId}`,
+                },
+            ]);
+            expect(output).toEqual(fakeTrigger);
+        }));
+        test('triggerTests throws', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(api, 'triggerTests').mockImplementation(() => {
+                throw (0, fixtures_1.getAxiosHttpError)(502, { message: 'Server Error' });
+            });
+            yield expect(utils.runTests(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }])).rejects.toThrow(/Failed to trigger tests:/);
+        }));
+    });
+    describe('getTestsToTrigger', () => {
+        const fakeTests = {
+            '123-456-789': {
+                config: { request: { url: 'http://example.org/' } },
+                name: 'Fake Test',
+                public_id: '123-456-789',
+                suite: 'Suite 1',
+            },
+            'mob-ile-tes': {
+                config: {},
+                name: 'Fake Mobile Test',
+                options: {
+                    mobileApplication: {
+                        applicationId: 'appId',
+                        referenceId: 'versionId',
+                        referenceType: 'version',
+                    },
+                },
+                public_id: 'mob-ile-tes',
+                suite: 'Suite 3',
+                type: 'mobile',
+            },
+            'ski-ppe-d01': {
+                config: { request: { url: 'http://example.org/' } },
+                name: 'Skipped Fake Test',
+                options: { ci: { executionRule: 'skipped' } },
+                public_id: 'ski-ppe-d01',
+                suite: 'Suite 3',
+            },
+        };
+        beforeEach(() => {
+            const axiosMock = jest.spyOn(axios_1.default, 'create');
+            axiosMock.mockImplementation((() => (e) => {
+                const publicId = e.url.slice(18);
+                if (fakeTests[publicId]) {
+                    return { data: fakeTests[publicId] };
+                }
+                throw (0, fixtures_1.getAxiosHttpError)(404, { errors: ['Not found'] });
+            }));
+        });
+        test('only existing tests are returned', () => __awaiter(void 0, void 0, void 0, function* () {
+            const triggerConfigs = [
+                { suite: 'Suite 1', config: {}, id: '123-456-789' },
+                { suite: 'Suite 2', config: {}, id: '987-654-321' },
+                { suite: 'Suite 3', config: {}, id: 'ski-ppe-d01' },
+            ];
+            const { tests, overriddenTestsToTrigger, initialSummary } = yield utils.getTestsToTrigger(api, triggerConfigs, fixtures_1.mockReporter);
+            expect(tests).toStrictEqual([fakeTests['123-456-789']]);
+            expect(overriddenTestsToTrigger).toStrictEqual([{ public_id: '123-456-789' }, { public_id: 'ski-ppe-d01' }]);
+            const expectedSummary = {
+                criticalErrors: 0,
+                expected: 0,
+                failed: 0,
+                failedNonBlocking: 0,
+                passed: 0,
+                previouslyPassed: 0,
+                skipped: 1,
+                testsNotFound: new Set(['987-654-321']),
+                timedOut: 0,
+            };
+            expect(initialSummary).toEqual(expectedSummary);
+        }));
+        test('no tests triggered throws an error', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(utils.getTestsToTrigger(api, [], fixtures_1.mockReporter)).rejects.toEqual(new errors_1.CiError('NO_TESTS_TO_RUN'));
+        }));
+        describe('too many tests to trigger', () => {
+            const fakeApi = Object.assign(Object.assign({}, api), { getTest: (id) => {
+                    if (id === 'missing') {
+                        throw new Error('Request error');
+                    }
+                    const test = Object.assign({}, (0, fixtures_1.getApiTest)(id));
+                    if (id === 'skipped') {
+                        test.options.ci = { executionRule: interfaces_1.ExecutionRule.SKIPPED };
+                    }
+                    return Promise.resolve(test);
+                } });
+            test('trim and warn if from search', () => __awaiter(void 0, void 0, void 0, function* () {
+                const tooManyTests = Array(run_tests_command_1.MAX_TESTS_TO_TRIGGER + 10).fill({ id: 'stu-vwx-yza' });
+                const tests = yield utils.getTestsToTrigger(fakeApi, tooManyTests, fixtures_1.mockReporter, true);
+                expect(tests.tests.length).toBe(run_tests_command_1.MAX_TESTS_TO_TRIGGER);
+                expect(fixtures_1.mockReporter.initErrors).toMatchSnapshot();
+            }));
+            test('fails outside of search', () => __awaiter(void 0, void 0, void 0, function* () {
+                const tooManyTests = Array(run_tests_command_1.MAX_TESTS_TO_TRIGGER + 10).fill({ id: 'stu-vwx-yza' });
+                yield expect(utils.getTestsToTrigger(fakeApi, tooManyTests, fixtures_1.mockReporter, false)).rejects.toEqual(new Error(`Cannot trigger more than ${run_tests_command_1.MAX_TESTS_TO_TRIGGER} tests (received ${tooManyTests.length})`));
+            }));
+            test('does not account for skipped/not found tests outside of search', () => __awaiter(void 0, void 0, void 0, function* () {
+                const tooManyTests = [
+                    ...Array(run_tests_command_1.MAX_TESTS_TO_TRIGGER).fill({ id: 'stu-vwx-yza' }),
+                    { id: 'skipped' },
+                    { id: 'missing' },
+                ];
+                const tests = yield utils.getTestsToTrigger(fakeApi, tooManyTests, fixtures_1.mockReporter, true);
+                expect(tests.tests.length).toBe(run_tests_command_1.MAX_TESTS_TO_TRIGGER);
+            }));
+        });
+        test('call uploadApplicationAndOverrideConfig on mobile test', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest.spyOn(mobile, 'uploadMobileApplicationsAndUpdateOverrideConfigs').mockImplementation();
+            const triggerConfigs = [
+                { suite: 'Suite 1', config: {}, id: '123-456-789' },
+                { suite: 'Suite 3', config: {}, id: 'mob-ile-tes' },
+            ];
+            yield utils.getTestsToTrigger(api, triggerConfigs, fixtures_1.mockReporter);
+            expect(spy).toHaveBeenCalledTimes(1);
+        }));
+    });
+    describe('getTestAndOverrideConfig', () => {
+        test('Forbidden error when getting a test', () => __awaiter(void 0, void 0, void 0, function* () {
+            const axiosMock = jest.spyOn(axios_1.default, 'create');
+            axiosMock.mockImplementation((() => (e) => {
+                throw (0, fixtures_1.getAxiosHttpError)(403, { message: 'Forbidden' });
+            }));
+            const triggerConfig = { suite: 'Suite 1', config: {}, id: '123-456-789' };
+            yield expect(() => utils.getTestAndOverrideConfig(api, triggerConfig, fixtures_1.mockReporter, (0, fixtures_1.getSummary)())).rejects.toThrow('Failed to get test: could not query https://app.datadoghq.com/example\nForbidden\n');
+        }));
+        test('Passes when public ID is valid', () => __awaiter(void 0, void 0, void 0, function* () {
+            const axiosMock = jest.spyOn(axios_1.default, 'create');
+            axiosMock.mockImplementation((() => (e) => {
+                return { data: { subtype: 'http', public_id: '123-456-789' } };
+            }));
+            const triggerConfig = { suite: 'Suite 1', config: {}, id: '123-456-789' };
+            expect(yield utils.getTestAndOverrideConfig(api, triggerConfig, fixtures_1.mockReporter, (0, fixtures_1.getSummary)())).toEqual(expect.objectContaining({ test: expect.objectContaining({ public_id: '123-456-789', subtype: 'http' }) }));
+        }));
+        test('Fails when public ID is NOT valid', () => __awaiter(void 0, void 0, void 0, function* () {
+            const expectedError = new errors_1.CiError('INVALID_CONFIG', `No valid public ID found in: \`a123-456-789\``);
+            const triggerConfig = { suite: 'Suite 1', config: {}, id: 'a123-456-789' };
+            yield expect(utils.getTestAndOverrideConfig(api, triggerConfig, fixtures_1.mockReporter, (0, fixtures_1.getSummary)())).rejects.toThrow(expectedError);
+        }));
+        test('Passes when the tunnel is enabled for HTTP test', () => __awaiter(void 0, void 0, void 0, function* () {
+            const axiosMock = jest.spyOn(axios_1.default, 'create');
+            axiosMock.mockImplementation((() => (e) => {
+                return { data: { subtype: 'http', public_id: '123-456-789' } };
+            }));
+            const triggerConfig = { suite: 'Suite 1', config: {}, id: '123-456-789' };
+            expect(yield utils.getTestAndOverrideConfig(api, triggerConfig, fixtures_1.mockReporter, (0, fixtures_1.getSummary)(), true)).toEqual(expect.objectContaining({ test: expect.objectContaining({ public_id: '123-456-789', subtype: 'http' }) }));
+        }));
+        test('Passes when the tunnel is enabled for Browser test', () => __awaiter(void 0, void 0, void 0, function* () {
+            const axiosMock = jest.spyOn(axios_1.default, 'create');
+            axiosMock.mockImplementation((() => (e) => {
+                return { data: { type: 'browser', public_id: '123-456-789' } };
+            }));
+            const triggerConfig = { suite: 'Suite 1', config: {}, id: '123-456-789' };
+            expect(yield utils.getTestAndOverrideConfig(api, triggerConfig, fixtures_1.mockReporter, (0, fixtures_1.getSummary)(), true)).toEqual(expect.objectContaining({ test: expect.objectContaining({ public_id: '123-456-789', type: 'browser' }) }));
+        }));
+        test('Passes when the tunnel is enabled for Multi step test with HTTP steps only', () => __awaiter(void 0, void 0, void 0, function* () {
+            const axiosMock = jest.spyOn(axios_1.default, 'create');
+            axiosMock.mockImplementation((() => (e) => {
+                return {
+                    data: {
+                        type: 'api',
+                        subtype: 'multi',
+                        config: { steps: [{ subtype: 'http' }, { subtype: 'http' }] },
+                        public_id: '123-456-789',
+                    },
+                };
+            }));
+            const triggerConfig = { suite: 'Suite 1', config: {}, id: '123-456-789' };
+            expect(yield utils.getTestAndOverrideConfig(api, triggerConfig, fixtures_1.mockReporter, (0, fixtures_1.getSummary)(), true)).toEqual(expect.objectContaining({
+                test: expect.objectContaining({
+                    public_id: '123-456-789',
+                    type: 'api',
+                    subtype: 'multi',
+                    config: { steps: [{ subtype: 'http' }, { subtype: 'http' }] },
+                }),
+            }));
+        }));
+        test('Fails when the tunnel is enabled for an unsupported test type', () => __awaiter(void 0, void 0, void 0, function* () {
+            const axiosMock = jest.spyOn(axios_1.default, 'create');
+            axiosMock.mockImplementation((() => (e) => {
+                return { data: { subtype: 'grpc', type: 'api', public_id: '123-456-789' } };
+            }));
+            const triggerConfig = { suite: 'Suite 1', config: {}, id: '123-456-789' };
+            yield expect(() => utils.getTestAndOverrideConfig(api, triggerConfig, fixtures_1.mockReporter, (0, fixtures_1.getSummary)(), true)).rejects.toThrow('The tunnel is only supported with HTTP API tests and Browser tests (public ID: 123-456-789, type: api, sub-type: grpc).');
+        }));
+        test('Fails when the tunnel is enabled for unsupported steps in a Multi step test', () => __awaiter(void 0, void 0, void 0, function* () {
+            const axiosMock = jest.spyOn(axios_1.default, 'create');
+            axiosMock.mockImplementation((() => (e) => {
+                return {
+                    data: {
+                        type: 'api',
+                        subtype: 'multi',
+                        config: { steps: [{ subtype: 'dns' }, { subtype: 'ssl' }, { subtype: 'http' }] },
+                        public_id: '123-456-789',
+                    },
+                };
+            }));
+            const triggerConfig = { suite: 'Suite 1', config: {}, id: '123-456-789' };
+            yield expect(() => utils.getTestAndOverrideConfig(api, triggerConfig, fixtures_1.mockReporter, (0, fixtures_1.getSummary)(), true)).rejects.toThrow('The tunnel is only supported with HTTP API tests and Browser tests (public ID: 123-456-789, type: api, sub-type: multi, step sub-types: [dns, ssl]).');
+        }));
+    });
+    describe('normalizePublicId', () => {
+        test('should normalize public ID', () => {
+            expect(utils.normalizePublicId('http://localhost/synthetics/tests/details/123-456-789')).toBe('123-456-789');
+            expect(utils.normalizePublicId('123-456-789')).toBe('123-456-789');
+        });
+        test('should be undefined if id is invalid', () => {
+            expect(utils.normalizePublicId('http://localhost/synthetics/tests/details/123-456-7890')).toBe(undefined);
+            expect(utils.normalizePublicId('0123-456-789')).toBe(undefined);
+        });
+    });
+    describe('getOverriddenConfig', () => {
+        test('empty config returns simple payload', () => {
+            const publicId = 'abc-def-ghi';
+            expect(utils.getOverriddenConfig({ public_id: publicId }, publicId, fixtures_1.mockReporter)).toEqual({
+                public_id: publicId,
+            });
+        });
+        test('strictest executionRule is forwarded when it has to be', () => {
+            const expectHandledConfigToBe = (expectedExecutionRule, configExecutionRule, testExecutionRule) => {
+                const publicId = 'abc-def-ghi';
+                const fakeTest = {
+                    config: { request: { url: 'http://example.org/path' } },
+                    options: {},
+                    public_id: publicId,
+                };
+                if (testExecutionRule) {
+                    fakeTest.options.ci = { executionRule: testExecutionRule };
+                }
+                const configOverride = configExecutionRule ? { executionRule: configExecutionRule } : undefined;
+                const overriddenConfig = utils.getOverriddenConfig(fakeTest, publicId, fixtures_1.mockReporter, configOverride);
+                expect(overriddenConfig.public_id).toBe(publicId);
+                expect(overriddenConfig.executionRule).toBe(expectedExecutionRule);
+            };
+            const BLOCKING = interfaces_1.ExecutionRule.BLOCKING;
+            const NON_BLOCKING = interfaces_1.ExecutionRule.NON_BLOCKING;
+            const SKIPPED = interfaces_1.ExecutionRule.SKIPPED;
+            // No override => nothing, let the backend decide
+            expectHandledConfigToBe(undefined);
+            // CI config overrides only
+            expectHandledConfigToBe(BLOCKING, BLOCKING);
+            expectHandledConfigToBe(NON_BLOCKING, NON_BLOCKING);
+            expectHandledConfigToBe(SKIPPED, SKIPPED);
+            // Test config only => nothing, let the backend decide
+            expectHandledConfigToBe(undefined, undefined, BLOCKING);
+            expectHandledConfigToBe(undefined, undefined, NON_BLOCKING);
+            expectHandledConfigToBe(undefined, undefined, SKIPPED);
+            // Strictest executionRule is forwarded
+            expectHandledConfigToBe(NON_BLOCKING, BLOCKING, NON_BLOCKING);
+            expectHandledConfigToBe(SKIPPED, SKIPPED, BLOCKING);
+            expectHandledConfigToBe(SKIPPED, NON_BLOCKING, SKIPPED);
+            expectHandledConfigToBe(SKIPPED, SKIPPED, NON_BLOCKING);
+        });
+        test('startUrl is not parsable', () => {
+            const envVars = Object.assign({}, process_1.default.env);
+            process_1.default.env = { CUSTOMVAR: '/newPath' };
+            const publicId = 'abc-def-ghi';
+            const fakeTest = {
+                config: { request: { url: 'http://{{ FAKE_VAR }}/path' } },
+                public_id: publicId,
+                type: 'browser',
+            };
+            const configOverride = {
+                startUrl: 'https://{{FAKE_VAR}}/newPath?oldPath={{CUSTOMVAR}}',
+            };
+            const expectedUrl = 'https://{{FAKE_VAR}}/newPath?oldPath=/newPath';
+            const overriddenConfig = utils.getOverriddenConfig(fakeTest, publicId, fixtures_1.mockReporter, configOverride);
+            expect(overriddenConfig.public_id).toBe(publicId);
+            expect(overriddenConfig.startUrl).toBe(expectedUrl);
+            process_1.default.env = envVars;
+        });
+        test('config overrides are applied', () => {
+            const publicId = 'abc-def-ghi';
+            const fakeTest = {
+                config: { request: { url: 'http://example.org/path' } },
+                public_id: publicId,
+                type: 'browser',
+            };
+            const configOverride = {
+                allowInsecureCertificates: true,
+                basicAuth: { username: 'user', password: 'password' },
+                body: 'body',
+                bodyType: 'application/json',
+                cookies: 'name=value;',
+                defaultStepTimeout: 15,
+                deviceIds: ['device_id'],
+                executionRule: interfaces_1.ExecutionRule.NON_BLOCKING,
+                followRedirects: true,
+                headers: { 'header-name': 'value' },
+                locations: ['location'],
+                pollingTimeout: 60 * 1000,
+                retry: { count: 5, interval: 30 },
+                startUrl: 'http://127.0.0.1:60/newPath',
+                startUrlSubstitutionRegex: '.*',
+                testTimeout: 360,
+                tunnel: { host: 'host', id: 'id', privateKey: 'privateKey' },
+                variables: { VAR_1: 'value' },
+            };
+            expect(utils.getOverriddenConfig(fakeTest, publicId, fixtures_1.mockReporter, configOverride)).toEqual(Object.assign(Object.assign({}, configOverride), { public_id: publicId }));
+        });
+    });
+    describe('getTestOverridesCount', () => {
+        test('should count overrides', () => {
+            expect(utils.getTestOverridesCount({})).toBe(0);
+            // If the user sets anything, even an empty array or object, it counts as an override
+            expect(utils.getTestOverridesCount({ deviceIds: [] })).toBe(1);
+            expect(utils.getTestOverridesCount({ headers: {} })).toBe(1);
+            expect(utils.getTestOverridesCount({ deviceIds: ['a'] })).toBe(1);
+            expect(utils.getTestOverridesCount({ pollingTimeout: 123 })).toBe(1);
+            // Should ignore the default value for the pollingTimeout
+            expect(utils.getTestOverridesCount({ pollingTimeout: run_tests_command_1.DEFAULT_POLLING_TIMEOUT })).toBe(0);
+        });
+    });
+    describe('hasResultPassed', () => {
+        test('complete result', () => {
+            const result = {
+                device: { height: 1100, id: 'chrome.laptop_large', width: 1440 },
+                duration: 0,
+                passed: true,
+                startUrl: '',
+                stepDetails: [],
+            };
+            expect(utils.hasResultPassed(result, false, false, true)).toBeTruthy();
+            expect(utils.hasResultPassed(result, false, true, true)).toBeTruthy();
+            result.passed = false;
+            expect(utils.hasResultPassed(result, false, false, true)).toBeFalsy();
+            expect(utils.hasResultPassed(result, false, true, true)).toBeFalsy();
+        });
+        test('result with error', () => {
+            const result = {
+                device: { height: 1100, id: 'chrome.laptop_large', width: 1440 },
+                duration: 0,
+                failure: {
+                    code: 'ERRABORTED',
+                    message: 'Connection aborted',
+                },
+                passed: false,
+                startUrl: '',
+                stepDetails: [],
+            };
+            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: 1100, id: 'chrome.laptop_large', width: 1440 },
+                duration: 0,
+                failure: {
+                    code: 'ERRABORTED',
+                    message: 'Connection aborted',
+                },
+                passed: false,
+                startUrl: '',
+                stepDetails: [],
+                unhealthy: true,
+            };
+            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: 1100, id: 'chrome.laptop_large', width: 1440 },
+                duration: 0,
+                passed: false,
+                startUrl: '',
+                stepDetails: [],
+            };
+            expect(utils.hasResultPassed(result, true, true, true)).toBeFalsy();
+            expect(utils.hasResultPassed(result, true, true, false)).toBeTruthy();
+        });
+    });
+    describe('getExecutionRule', () => {
+        const cases = [
+            [undefined, undefined, interfaces_1.ExecutionRule.BLOCKING],
+            [undefined, interfaces_1.ExecutionRule.BLOCKING, interfaces_1.ExecutionRule.BLOCKING],
+            [undefined, interfaces_1.ExecutionRule.NON_BLOCKING, interfaces_1.ExecutionRule.NON_BLOCKING],
+            [interfaces_1.ExecutionRule.BLOCKING, undefined, interfaces_1.ExecutionRule.BLOCKING],
+            [interfaces_1.ExecutionRule.BLOCKING, interfaces_1.ExecutionRule.BLOCKING, interfaces_1.ExecutionRule.BLOCKING],
+            [interfaces_1.ExecutionRule.BLOCKING, interfaces_1.ExecutionRule.NON_BLOCKING, interfaces_1.ExecutionRule.NON_BLOCKING],
+            [interfaces_1.ExecutionRule.NON_BLOCKING, undefined, interfaces_1.ExecutionRule.NON_BLOCKING],
+            [interfaces_1.ExecutionRule.NON_BLOCKING, interfaces_1.ExecutionRule.BLOCKING, interfaces_1.ExecutionRule.NON_BLOCKING],
+            [interfaces_1.ExecutionRule.NON_BLOCKING, interfaces_1.ExecutionRule.NON_BLOCKING, interfaces_1.ExecutionRule.NON_BLOCKING],
+        ];
+        test.each(cases)('execution rule: %s, result execution rule: %s. Expected rule: %s', (testRule, resultRule, expectedRule) => {
+            const test = (0, fixtures_1.getApiTest)('abc-def-ghi');
+            expect(utils.getExecutionRule(testRule ? Object.assign(Object.assign({}, test), { options: Object.assign(Object.assign({}, test.options), { ci: { executionRule: testRule } }) }) : test, resultRule ? { executionRule: resultRule } : {})).toEqual(expectedRule);
+        });
+    });
+    describe('getResultOutcome', () => {
+        const cases = [
+            [true, interfaces_1.ExecutionRule.BLOCKING, undefined, "passed" /* utils.ResultOutcome.Passed */],
+            [
+                true,
+                interfaces_1.ExecutionRule.SKIPPED,
+                { decision: 'skip', reason: 'passed', linked_result_id: '' },
+                "previously-passed" /* utils.ResultOutcome.PreviouslyPassed */,
+            ],
+            [true, interfaces_1.ExecutionRule.NON_BLOCKING, undefined, "passed-non-blocking" /* utils.ResultOutcome.PassedNonBlocking */],
+            [false, interfaces_1.ExecutionRule.BLOCKING, undefined, "failed" /* utils.ResultOutcome.Failed */],
+            [false, interfaces_1.ExecutionRule.NON_BLOCKING, undefined, "failed-non-blocking" /* utils.ResultOutcome.FailedNonBlocking */],
+        ];
+        test.each(cases)('Result passed: %s, execution rule: %s. Expected outcome: %s', (passed, resultRule, selectiveRerun, expectedOutcome) => {
+            jest.spyOn(utils, 'getExecutionRule').mockReturnValue(resultRule);
+            const test = (0, fixtures_1.getApiTest)('abc-def-ghi');
+            const result = (0, fixtures_1.getApiResult)('1', test);
+            result.executionRule = resultRule;
+            result.passed = passed;
+            result.selectiveRerun = selectiveRerun;
+            expect(utils.getResultOutcome(result)).toEqual(expectedOutcome);
+        });
+    });
+    describe('waitForResults', () => {
+        beforeEach(() => {
+            jest.useFakeTimers();
+            jest.spyOn(utils, 'wait').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return jest.advanceTimersByTime(5000); }));
+        });
+        afterEach(() => {
+            jest.useRealTimers();
+            jest.restoreAllMocks();
+        });
+        const batch = (0, fixtures_1.getBatch)();
+        const apiTest = (0, fixtures_1.getApiTest)('pid');
+        const incompleteServerResult = { eventType: 'created' };
+        const result = {
+            executionRule: interfaces_1.ExecutionRule.BLOCKING,
+            location: fixtures_1.mockLocation.display_name,
+            passed: true,
+            result: (0, fixtures_1.getBrowserServerResult)({ passed: true }),
+            resultId: 'rid',
+            retries: 0,
+            selectiveRerun: undefined,
+            test: apiTest,
+            timedOut: false,
+            timestamp: 0,
+        };
+        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 (0, deep_extend_1.default)({}, batch); })));
+            const pollResultsMock = jest
+                .spyOn(api, 'pollResults')
+                .mockImplementation(pollResultsImplementation || (() => __awaiter(void 0, void 0, void 0, function* () { return [(0, deep_extend_1.default)({}, pollResult)]; })));
+            return { getBatchMock, pollResultsMock };
+        };
+        const waiter = {
+            promise: Promise.resolve(),
+            resolve: () => { },
+            start() {
+                this.promise = new Promise((resolve) => (this.resolve = resolve));
+            },
+        };
+        test('should poll result ids', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockApi();
+            expect(yield utils.waitForResults(api, trigger, [result.test], {
+                batchTimeout: 120000,
+                datadogSite: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+                failOnCriticalErrors: false,
+                subdomain: run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain,
+            }, fixtures_1.mockReporter)).toEqual([result]);
+        }));
+        test('should show results as they arrive', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(utils, 'wait').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return waiter.resolve(); }));
+            const tests = [result.test, Object.assign(Object.assign({}, result.test), { public_id: 'other-public-id' })];
+            // === STEP 1 === (batch 'in_progress')
+            waiter.start();
+            mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        status: 'in_progress',
+                        results: [
+                            Object.assign({}, (0, fixtures_1.getInProgressResultInBatch)()),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getInProgressResultInBatch)()), { result_id: 'rid-2' }),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getInProgressResultInBatch)()), { test_public_id: 'other-public-id', result_id: 'rid-3' }),
+                        ],
+                    });
+                }),
+                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return [(0, deep_extend_1.default)({}, pollResult)]; }),
+            });
+            const resultsPromise = utils.waitForResults(api, trigger, tests, {
+                batchTimeout: 120000,
+                datadogSite: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+                failOnCriticalErrors: false,
+                subdomain: run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain,
+            }, fixtures_1.mockReporter);
+            // Wait for the 2 tests (initial)
+            expect(fixtures_1.mockReporter.testsWait).toHaveBeenNthCalledWith(1, [tests[0], tests[1]], fixtures_1.MOCK_BASE_URL, trigger.batch_id);
+            yield waiter.promise;
+            // No results received
+            expect(fixtures_1.mockReporter.resultReceived).not.toHaveBeenCalled();
+            expect(fixtures_1.mockReporter.resultEnd).not.toHaveBeenCalled();
+            // Still waiting for the 2 tests
+            expect(fixtures_1.mockReporter.testsWait).toHaveBeenNthCalledWith(2, [tests[0], tests[1]], fixtures_1.MOCK_BASE_URL, trigger.batch_id, 0);
+            // === STEP 2 === (batch 'in_progress')
+            waiter.start();
+            mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        status: 'in_progress',
+                        results: [
+                            Object.assign({}, (0, fixtures_1.getInProgressResultInBatch)()),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()), { result_id: 'rid-2' }),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getInProgressResultInBatch)()), { test_public_id: 'other-public-id', result_id: 'rid-3' }),
+                        ],
+                    });
+                }),
+                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return [
+                        (0, deep_extend_1.default)({}, pollResult),
+                        (0, deep_extend_1.default)({}, pollResult, { resultID: 'rid-2' }),
+                        (0, deep_extend_1.default)({}, pollResult, { resultID: 'rid-3' }),
+                    ];
+                }),
+            });
+            yield waiter.promise;
+            // One result received
+            expect(fixtures_1.mockReporter.resultReceived).toHaveBeenNthCalledWith(1, Object.assign(Object.assign({}, batch.results[0]), { status: 'passed', result_id: 'rid-2' }));
+            expect(fixtures_1.mockReporter.resultEnd).toHaveBeenNthCalledWith(1, Object.assign(Object.assign({}, result), { resultId: 'rid-2' }), fixtures_1.MOCK_BASE_URL, 'bid');
+            // Still waiting for 2 tests
+            expect(fixtures_1.mockReporter.testsWait).toHaveBeenNthCalledWith(3, [tests[0], tests[1]], fixtures_1.MOCK_BASE_URL, trigger.batch_id, 0);
+            // === STEP 3 === (batch 'in_progress')
+            waiter.start();
+            mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        status: 'in_progress',
+                        results: [
+                            Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()), { result_id: 'rid-2' }),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getInProgressResultInBatch)()), { test_public_id: 'other-public-id', result_id: 'rid-3' }),
+                        ],
+                    });
+                }),
+                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return [
+                        (0, deep_extend_1.default)({}, pollResult),
+                        (0, deep_extend_1.default)({}, pollResult, { resultID: 'rid-2' }),
+                        (0, deep_extend_1.default)({}, pollResult, { resultID: 'rid-3' }),
+                    ];
+                }),
+            });
+            yield waiter.promise;
+            // One result received
+            expect(fixtures_1.mockReporter.resultReceived).toHaveBeenNthCalledWith(2, Object.assign(Object.assign({}, batch.results[0]), { status: 'passed' }));
+            expect(fixtures_1.mockReporter.resultEnd).toHaveBeenNthCalledWith(2, result, fixtures_1.MOCK_BASE_URL, 'bid');
+            // Now waiting for 1 test
+            expect(fixtures_1.mockReporter.testsWait).toHaveBeenNthCalledWith(4, [tests[1]], fixtures_1.MOCK_BASE_URL, trigger.batch_id, 0);
+            // === STEP 4 === (batch 'in_progress')
+            waiter.start();
+            mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        status: 'in_progress',
+                        results: [
+                            Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()), { result_id: 'rid-2' }),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getInProgressResultInBatch)()), { retries: 0, test_public_id: 'other-public-id', timed_out: false, result_id: 'rid-3' }),
+                        ],
+                    });
+                }),
+                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return [
+                        (0, deep_extend_1.default)({}, pollResult),
+                        (0, deep_extend_1.default)({}, pollResult, { resultID: 'rid-2' }),
+                        (0, deep_extend_1.default)({}, pollResult, { resultID: 'rid-3' }),
+                    ];
+                }),
+            });
+            yield waiter.promise;
+            // One result received
+            expect(fixtures_1.mockReporter.resultReceived).toHaveBeenNthCalledWith(3, Object.assign(Object.assign({}, batch.results[0]), { status: 'in_progress', test_public_id: 'other-public-id', result_id: 'rid-3' }));
+            expect(fixtures_1.mockReporter.resultEnd).toHaveBeenNthCalledWith(3, Object.assign(Object.assign({}, result), { resultId: 'rid-3' }), fixtures_1.MOCK_BASE_URL, 'bid');
+            // Now waiting for 1 test
+            expect(fixtures_1.mockReporter.testsWait).toHaveBeenNthCalledWith(5, [tests[1]], fixtures_1.MOCK_BASE_URL, trigger.batch_id, 0);
+            // === STEP 5 === (batch 'passed')
+            mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        status: 'passed',
+                        results: [
+                            Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()), { result_id: 'rid-2' }),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()), { retries: 1, test_public_id: 'other-public-id', result_id: 'rid-3-final' }),
+                        ],
+                    });
+                }),
+                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return [
+                        (0, deep_extend_1.default)({}, pollResult),
+                        (0, deep_extend_1.default)({}, pollResult, { resultID: 'rid-2' }),
+                        (0, deep_extend_1.default)({}, pollResult, { resultID: 'rid-3-final' }),
+                    ];
+                }),
+            });
+            expect(yield resultsPromise).toEqual([
+                result,
+                Object.assign(Object.assign({}, result), { resultId: 'rid-2' }),
+                Object.assign(Object.assign({}, result), { resultId: 'rid-3-final', retries: 1 }),
+            ]);
+            // One result received
+            expect(fixtures_1.mockReporter.resultReceived).toHaveBeenNthCalledWith(4, Object.assign(Object.assign({}, batch.results[0]), { status: 'passed', test_public_id: 'other-public-id', result_id: 'rid-3-final', retries: 1 }));
+            expect(fixtures_1.mockReporter.resultEnd).toHaveBeenNthCalledWith(4, Object.assign(Object.assign({}, result), { resultId: 'rid-3-final', retries: 1 }), fixtures_1.MOCK_BASE_URL, 'bid');
+            // Do not report when there are no tests to wait anymore
+            expect(fixtures_1.mockReporter.testsWait).toHaveBeenCalledTimes(5);
+        }));
+        test('skipped results are reported as received', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(utils, 'wait').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return waiter.resolve(); }));
+            const tests = [result.test, Object.assign(Object.assign({}, result.test), { public_id: 'other-public-id' })];
+            // === STEP 1 === (batch 'in_progress')
+            waiter.start();
+            mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        status: 'in_progress',
+                        results: [
+                            Object.assign({}, (0, fixtures_1.getSkippedResultInBatch)()),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getInProgressResultInBatch)()), { test_public_id: 'other-public-id', result_id: 'rid-2' }),
+                        ],
+                    });
+                }),
+                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return [Object.assign(Object.assign({}, pollResult), { resultID: 'rid-2' })]; }),
+            });
+            const resultsPromise = utils.waitForResults(api, trigger, tests, {
+                batchTimeout: 120000,
+                datadogSite: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+                failOnCriticalErrors: false,
+                subdomain: run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain,
+            }, fixtures_1.mockReporter);
+            // Wait for the 2 tests (initial)
+            expect(fixtures_1.mockReporter.testsWait).toHaveBeenNthCalledWith(1, [tests[0], tests[1]], fixtures_1.MOCK_BASE_URL, trigger.batch_id);
+            yield waiter.promise;
+            // The skipped result is received
+            expect(fixtures_1.mockReporter.resultReceived).toHaveBeenNthCalledWith(1, Object.assign({}, (0, fixtures_1.getSkippedResultInBatch)()));
+            // And marked as passed because it's selective re-run
+            const skippedResult = {
+                executionRule: interfaces_1.ExecutionRule.SKIPPED,
+                passed: true,
+                resultId: '123',
+                selectiveRerun: { decision: 'skip', reason: 'passed', linked_result_id: '123' },
+                test: result.test,
+                timedOut: false,
+            };
+            expect(fixtures_1.mockReporter.resultEnd).toHaveBeenNthCalledWith(1, skippedResult, fixtures_1.MOCK_BASE_URL, 'bid');
+            // Now waiting for the remaining test
+            expect(fixtures_1.mockReporter.testsWait).toHaveBeenNthCalledWith(2, [tests[1]], fixtures_1.MOCK_BASE_URL, trigger.batch_id, 1);
+            // === STEP 2 === (batch 'passed')
+            mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        status: 'passed',
+                        results: [
+                            Object.assign({}, (0, fixtures_1.getSkippedResultInBatch)()),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()), { test_public_id: 'other-public-id', result_id: 'rid-2' }),
+                        ],
+                    });
+                }),
+                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return [(0, deep_extend_1.default)({}, pollResult, { resultID: 'rid-2' })]; }),
+            });
+            expect(yield resultsPromise).toEqual([Object.assign({}, skippedResult), Object.assign(Object.assign({}, result), { resultId: 'rid-2' })]);
+            // One result received
+            expect(fixtures_1.mockReporter.resultReceived).toHaveBeenNthCalledWith(2, Object.assign(Object.assign({}, batch.results[0]), { status: 'passed', test_public_id: 'other-public-id', result_id: 'rid-2' }));
+            expect(fixtures_1.mockReporter.resultEnd).toHaveBeenNthCalledWith(2, Object.assign(Object.assign({}, result), { resultId: 'rid-2' }), fixtures_1.MOCK_BASE_URL, 'bid');
+            expect(fixtures_1.mockReporter.testsWait).toHaveBeenCalledTimes(2);
+        }));
+        test('should wait for incomplete results', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(utils, 'wait').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return waiter.resolve(); }));
+            const tests = [result.test, Object.assign(Object.assign({}, result.test), { public_id: 'other-public-id' })];
+            // === STEP 1 === (batch 'in_progress')
+            waiter.start();
+            mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        status: 'in_progress',
+                        results: [
+                            Object.assign({}, (0, fixtures_1.getInProgressResultInBatch)()),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()), { result_id: 'rid-2' }),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getInProgressResultInBatch)()), { test_public_id: 'other-public-id', result_id: 'rid-3' }),
+                        ],
+                    });
+                }),
+                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return [Object.assign(Object.assign({}, pollResult), { resultID: 'rid-2', result: incompleteServerResult })]; }),
+            });
+            const resultsPromise = utils.waitForResults(api, trigger, tests, {
+                batchTimeout: 120000,
+                datadogSite: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+                failOnCriticalErrors: false,
+                subdomain: run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain,
+            }, fixtures_1.mockReporter);
+            // Wait for the 2 tests (initial)
+            expect(fixtures_1.mockReporter.testsWait).toHaveBeenNthCalledWith(1, [tests[0], tests[1]], fixtures_1.MOCK_BASE_URL, trigger.batch_id);
+            yield waiter.promise;
+            // One result received
+            expect(fixtures_1.mockReporter.resultReceived).toHaveBeenNthCalledWith(1, Object.assign(Object.assign({}, batch.results[0]), { status: 'passed', result_id: 'rid-2' }));
+            // But the data from `/poll_results` data is not available yet, so we should wait more before reporting
+            expect(fixtures_1.mockReporter.resultEnd).not.toHaveBeenCalled();
+            // Still waiting for 2 tests
+            expect(fixtures_1.mockReporter.testsWait).toHaveBeenNthCalledWith(2, [tests[0], tests[1]], fixtures_1.MOCK_BASE_URL, trigger.batch_id, 0);
+            // === STEP 2 === (batch 'in_progress')
+            waiter.start();
+            mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        status: 'in_progress',
+                        results: [
+                            Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()), { result_id: 'rid-2' }),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getInProgressResultInBatch)()), { test_public_id: 'other-public-id', result_id: 'rid-3' }),
+                        ],
+                    });
+                }),
+                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return [
+                        Object.assign(Object.assign({}, pollResult), { result: incompleteServerResult }),
+                        (0, deep_extend_1.default)({}, pollResult, { resultID: 'rid-2' }), // just became available
+                    ];
+                }),
+            });
+            yield waiter.promise;
+            // One result received
+            expect(fixtures_1.mockReporter.resultReceived).toHaveBeenNthCalledWith(2, Object.assign(Object.assign({}, batch.results[0]), { status: 'passed' }));
+            // Result 2 just became available, so it should be reported
+            expect(fixtures_1.mockReporter.resultEnd).toHaveBeenNthCalledWith(1, Object.assign(Object.assign({}, result), { resultId: 'rid-2' }), fixtures_1.MOCK_BASE_URL, 'bid');
+            // Now waiting for 1 test
+            expect(fixtures_1.mockReporter.testsWait).toHaveBeenNthCalledWith(3, [tests[1]], fixtures_1.MOCK_BASE_URL, trigger.batch_id, 0);
+            // === STEP 3 === (batch 'passed')
+            mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        status: 'passed',
+                        results: [
+                            Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()), { result_id: 'rid-2' }),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()), { test_public_id: 'other-public-id', result_id: 'rid-3' }),
+                        ],
+                    });
+                }),
+                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return [
+                        Object.assign(Object.assign({}, pollResult), { result: incompleteServerResult }),
+                        (0, deep_extend_1.default)({}, pollResult, { resultID: 'rid-2' }),
+                        (0, deep_extend_1.default)({}, pollResult, { resultID: 'rid-3' }),
+                    ];
+                }),
+            });
+            expect(yield resultsPromise).toEqual([
+                Object.assign(Object.assign({}, result), { resultId: 'rid', result: incompleteServerResult }),
+                Object.assign(Object.assign({}, result), { resultId: 'rid-2' }),
+                Object.assign(Object.assign({}, result), { resultId: 'rid-3' }),
+            ]);
+            // One result received
+            expect(fixtures_1.mockReporter.resultReceived).toHaveBeenNthCalledWith(3, Object.assign(Object.assign({}, batch.results[0]), { status: 'passed', test_public_id: 'other-public-id', result_id: 'rid-3' }));
+            // Result 3 was available instantly
+            expect(fixtures_1.mockReporter.resultEnd).toHaveBeenNthCalledWith(2, Object.assign(Object.assign({}, result), { resultId: 'rid-3' }), fixtures_1.MOCK_BASE_URL, 'bid');
+            // Result 1 never became available
+            expect(fixtures_1.mockReporter.resultEnd).toHaveBeenNthCalledWith(3, Object.assign(Object.assign({}, result), { resultId: 'rid', result: incompleteServerResult }), fixtures_1.MOCK_BASE_URL, 'bid');
+            expect(fixtures_1.mockReporter.error).toHaveBeenCalledWith('The full information for result rid was incomplete at the end of the batch.\n\n');
+            // Do not report when there are no tests to wait anymore
+            expect(fixtures_1.mockReporter.testsWait).toHaveBeenCalledTimes(3);
+        }));
+        test('object in each result should be different even if they share the same public ID (config overrides)', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        results: [(0, fixtures_1.getPassedResultInBatch)(), Object.assign(Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()), { result_id: '3' })],
+                        status: 'passed',
+                    });
+                }),
+                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return [
+                        (0, deep_extend_1.default)({}, pollResult),
+                        // The test object from the second result has an overridden start URL
+                        (0, deep_extend_1.default)({}, pollResult, { check: { config: { request: { url: 'https://reddit.com/' } } }, resultID: '3' }),
+                    ];
+                }),
+            });
+            const results = yield utils.waitForResults(api, trigger, [result.test, result.test], {
+                batchTimeout: 0,
+                datadogSite: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+                failOnCriticalErrors: false,
+                subdomain: run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain,
+            }, fixtures_1.mockReporter);
+            expect(results.map(({ test }) => test.config.request.url)).toEqual(['http://fake.url', 'https://reddit.com/']);
+        }));
+        test('results should be timed out if the backend says so', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        status: 'failed',
+                        results: [Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()), Object.assign(Object.assign({}, (0, fixtures_1.getFailedResultInBatch)()), { result_id: '3', timed_out: true })],
+                    });
+                }),
+                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return [
+                        Object.assign(Object.assign({}, pollResult), { result: Object.assign({}, pollResult.result) }),
+                        Object.assign(Object.assign({}, pollResult), { result: Object.assign({}, pollResult.result), resultID: '3' }),
+                    ];
+                }),
+            });
+            const expectedTimeoutResult = Object.assign(Object.assign({}, result), { result: Object.assign(Object.assign({}, result.result), { failure: { code: 'TIMEOUT', message: 'The batch timed out before receiving the result.' }, passed: false }), resultId: '3', timedOut: true });
+            expect(yield utils.waitForResults(api, trigger, [result.test, result.test], {
+                batchTimeout: 3000,
+                datadogSite: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+                failOnCriticalErrors: false,
+                subdomain: run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain,
+            }, fixtures_1.mockReporter)).toEqual([result, expectedTimeoutResult]);
+            expect(fixtures_1.mockReporter.resultReceived).toHaveBeenCalledTimes(2);
+            // `resultEnd` should return the same data as `waitForResults`
+            expect(fixtures_1.mockReporter.resultEnd).toHaveBeenNthCalledWith(1, result, fixtures_1.MOCK_BASE_URL, 'bid');
+            expect(fixtures_1.mockReporter.resultEnd).toHaveBeenNthCalledWith(2, expectedTimeoutResult, fixtures_1.MOCK_BASE_URL, 'bid');
+            // Failed directly.
+            expect(utils.wait).toHaveBeenCalledTimes(0);
+        }));
+        test('results should be timed out with a different error if the backend did not say so', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        status: 'in_progress',
+                        results: [
+                            Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()),
+                            Object.assign(Object.assign({}, (0, fixtures_1.getInProgressResultInBatch)()), { result_id: '3' }),
+                        ],
+                    });
+                }),
+                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return [
+                        Object.assign(Object.assign({}, pollResult), { result: Object.assign({}, pollResult.result) }),
+                        Object.assign(Object.assign({}, pollResult), { result: Object.assign({}, pollResult.result), resultID: '3' }),
+                    ];
+                }),
+            });
+            const expectedDeadlineResult = Object.assign(Object.assign({}, result), { result: Object.assign(Object.assign({}, result.result), { failure: {
+                        code: 'BATCH_TIMEOUT_RUNAWAY',
+                        message: "The batch didn't timeout after the expected timeout period.",
+                    }, passed: false }), resultId: '3', timedOut: true });
+            yield expect(utils.waitForResults(api, trigger, [result.test, result.test], {
+                batchTimeout: 3000,
+                datadogSite: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+                failOnCriticalErrors: false,
+                subdomain: run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain,
+            }, fixtures_1.mockReporter)).rejects.toThrow(new errors_1.BatchTimeoutRunawayError());
+            // Residual results are never 'received': we force-end them.
+            expect(fixtures_1.mockReporter.resultReceived).toHaveBeenCalledTimes(1);
+            // `resultEnd` should return the same data as `waitForResults`
+            expect(fixtures_1.mockReporter.resultEnd).toHaveBeenNthCalledWith(1, result, fixtures_1.MOCK_BASE_URL, 'bid');
+            expect(fixtures_1.mockReporter.resultEnd).toHaveBeenNthCalledWith(2, expectedDeadlineResult, fixtures_1.MOCK_BASE_URL, 'bid');
+            // Initial wait + 3 polling cycles.
+            expect(utils.wait).toHaveBeenCalledTimes(4);
+        }));
+        test('results failure should be ignored 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({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        status: 'failed',
+                        results: [Object.assign(Object.assign({}, (0, fixtures_1.getFailedResultInBatch)()), { timed_out: true })],
+                    });
+                }),
+                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return [
+                        Object.assign(Object.assign({}, pollResult), { passed: false, 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], {
+                batchTimeout: 0,
+                datadogSite: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+                failOnCriticalErrors: false,
+                subdomain: run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain,
+            }, fixtures_1.mockReporter)).toStrictEqual([
+                Object.assign(Object.assign({}, result), { result: Object.assign(Object.assign({}, result.result), { failure: { code: 'TIMEOUT', message: 'The batch timed out before receiving the result.' }, 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({}, (0, fixtures_1.getFailedResultInBatch)()), { timed_out: true })] });
+            mockApi({ getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return batchWithTimeoutResult; }) });
+            expect(yield utils.waitForResults(api, trigger, [result.test], {
+                batchTimeout: 120000,
+                datadogSite: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+                failOnCriticalErrors: false,
+                subdomain: run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain,
+            }, fixtures_1.mockReporter)).toEqual([
+                Object.assign(Object.assign({}, result), { result: Object.assign(Object.assign({}, result.result), { failure: { code: 'TIMEOUT', message: 'The batch timed out before receiving the result.' }, passed: false }), timedOut: true }),
+            ]);
+        }));
+        test('wait between batch polling', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { getBatchMock } = mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return getBatchMock.mock.calls.length === 3 ? batch : Object.assign(Object.assign({}, batch), { status: 'in_progress' });
+                }),
+            });
+            expect(yield utils.waitForResults(api, trigger, [result.test], {
+                batchTimeout: 120000,
+                datadogSite: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+                failOnCriticalErrors: false,
+                subdomain: run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain,
+            }, fixtures_1.mockReporter)).toEqual([result]);
+            expect(getBatchMock).toHaveBeenCalledTimes(3);
+            expect(utils.wait).toHaveBeenCalledTimes(2);
+        }));
+        test('correct number of passed and timed out results', () => __awaiter(void 0, void 0, void 0, function* () {
+            const pollTimeoutResult = Object.assign(Object.assign({}, (0, deep_extend_1.default)({}, pollResult)), { resultID: 'another-id' });
+            const batchWithTimeoutResult = Object.assign(Object.assign({}, batch), { results: [
+                    Object.assign({}, (0, fixtures_1.getPassedResultInBatch)()),
+                    Object.assign(Object.assign({}, (0, fixtures_1.getFailedResultInBatch)()), { 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], {
+                batchTimeout: 2000,
+                datadogSite: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+                failOnCriticalErrors: false,
+                failOnTimeout: false,
+                subdomain: run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain,
+            }, fixtures_1.mockReporter)).toEqual([
+                Object.assign(Object.assign({}, result), { passed: true, timedOut: false }),
+                Object.assign(Object.assign({}, result), { passed: true, timedOut: true, resultId: pollTimeoutResult.resultID, result: Object.assign(Object.assign({}, result.result), { failure: {
+                            code: 'TIMEOUT',
+                            message: 'The batch timed out before receiving the result.',
+                        }, passed: false }) }),
+            ]);
+            expect(fixtures_1.mockReporter.resultReceived).toHaveBeenCalledTimes(2);
+            expect(fixtures_1.mockReporter.resultEnd).toHaveBeenCalledTimes(2);
+        }));
+        test('tunnel failure', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockApi();
+            const mockTunnel = {
+                keepAlive: () => __awaiter(void 0, void 0, void 0, function* () {
+                    throw new Error('keepAlive failed');
+                }),
+            };
+            yield utils.waitForResults(api, trigger, [result.test], {
+                batchTimeout: 2000,
+                datadogSite: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+                failOnCriticalErrors: true,
+                subdomain: run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain,
+            }, fixtures_1.mockReporter, mockTunnel);
+            expect(fixtures_1.mockReporter.error).toHaveBeenCalledWith('The tunnel has stopped working, this may have affected the results.');
+        }));
+        test('location when tunnel', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockApi();
+            const mockTunnel = { keepAlive: () => __awaiter(void 0, void 0, void 0, function* () { return true; }) };
+            let results = yield utils.waitForResults(api, trigger, [result.test], {
+                batchTimeout: 2000,
+                datadogSite: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+                failOnCriticalErrors: true,
+                subdomain: run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain,
+            }, fixtures_1.mockReporter, mockTunnel);
+            expect(results[0].location).toBe('Tunneled');
+            const newTest = Object.assign({}, result.test);
+            newTest.type = 'api';
+            newTest.subtype = 'http';
+            results = yield utils.waitForResults(api, trigger, [newTest], {
+                batchTimeout: 2000,
+                datadogSite: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+                failOnCriticalErrors: true,
+                subdomain: run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain,
+            }, fixtures_1.mockReporter, mockTunnel);
+            expect(results[0].location).toBe('Tunneled');
+            newTest.type = 'api';
+            newTest.subtype = 'ssl';
+            results = yield utils.waitForResults(api, trigger, [newTest], {
+                batchTimeout: 2000,
+                datadogSite: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+                failOnCriticalErrors: true,
+                subdomain: run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain,
+            }, fixtures_1.mockReporter, mockTunnel);
+            expect(results[0].location).toBe('Frankfurt (AWS)');
+        }));
+        test('pollResults throws', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { pollResultsMock } = mockApi({
+                pollResultsImplementation: () => {
+                    throw (0, fixtures_1.getAxiosHttpError)(502, { message: 'Poll results server error' });
+                },
+            });
+            yield expect(utils.waitForResults(api, trigger, [result.test], {
+                batchTimeout: 2000,
+                datadogSite: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+                subdomain: run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain,
+            }, fixtures_1.mockReporter)).rejects.toThrow('Failed to poll results: could not query https://app.datadoghq.com/example\nPoll results server error\n');
+            expect(pollResultsMock).toHaveBeenCalledWith([result.resultId]);
+        }));
+        test('getBatch throws', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { getBatchMock } = mockApi({
+                getBatchImplementation: () => {
+                    throw (0, fixtures_1.getAxiosHttpError)(502, { message: 'Get batch server error' });
+                },
+            });
+            yield expect(utils.waitForResults(api, trigger, [result.test], {
+                batchTimeout: 2000,
+                datadogSite: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+                subdomain: run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain,
+            }, fixtures_1.mockReporter)).rejects.toThrow('Failed to get batch: could not query https://app.datadoghq.com/example\nGet batch server error\n');
+            expect(getBatchMock).toHaveBeenCalledWith(trigger.batch_id);
+        }));
+    });
+    test('getStrictestExecutionRule', () => {
+        const BLOCKING = interfaces_1.ExecutionRule.BLOCKING;
+        const NON_BLOCKING = interfaces_1.ExecutionRule.NON_BLOCKING;
+        const SKIPPED = interfaces_1.ExecutionRule.SKIPPED;
+        expect(utils.getStrictestExecutionRule(BLOCKING, NON_BLOCKING)).toBe(NON_BLOCKING);
+        expect(utils.getStrictestExecutionRule(NON_BLOCKING, BLOCKING)).toBe(NON_BLOCKING);
+        expect(utils.getStrictestExecutionRule(NON_BLOCKING, SKIPPED)).toBe(SKIPPED);
+        expect(utils.getStrictestExecutionRule(BLOCKING, undefined)).toBe(BLOCKING);
+        expect(utils.getStrictestExecutionRule(SKIPPED, undefined)).toBe(SKIPPED);
+    });
+    describe('retry', () => {
+        test('retry works fine', () => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield utils.retry(() => __awaiter(void 0, void 0, void 0, function* () { return 42; }), () => 1);
+            expect(result).toBe(42);
+        }));
+        test('retry works fine after some retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            let counter = 0;
+            const start = +new Date();
+            const result = yield utils.retry(() => __awaiter(void 0, void 0, void 0, function* () {
+                if (counter === 3) {
+                    return 42;
+                }
+                counter += 1;
+                throw new Error('');
+            }), (retries) => 100 * (retries + 1));
+            const end = +new Date();
+            const approximateWait = 100 + 100 * 2 + 100 * 3;
+            expect(result).toBe(42);
+            expect(counter).toBe(3);
+            expect(end - start - approximateWait < 50).toBeTruthy();
+        }));
+        test('retry rethrows after some retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            let counter = 0;
+            yield expect(utils.retry(() => __awaiter(void 0, void 0, void 0, function* () {
+                counter += 1;
+                throw new Error('FAILURE');
+            }), (retries) => {
+                if (retries < 2) {
+                    return 1;
+                }
+            })).rejects.toThrow('FAILURE');
+            expect(counter).toBe(3);
+        }));
+    });
+    test('parseVariablesFromCli', () => {
+        const mockLogFunction = (message) => undefined;
+        expect(utils.parseVariablesFromCli(['TEST=42'], mockLogFunction)).toEqual({ TEST: '42' });
+        expect(utils.parseVariablesFromCli(['TEST=42 with some spaces'], mockLogFunction)).toEqual({
+            TEST: '42 with some spaces',
+        });
+        expect(utils.parseVariablesFromCli(['TEST=42=43=44'], mockLogFunction)).toEqual({ TEST: '42=43=44' });
+        expect(utils.parseVariablesFromCli(['TEST='], mockLogFunction)).toEqual({ TEST: '' });
+        expect(utils.parseVariablesFromCli([''], mockLogFunction)).toBeUndefined();
+        expect(utils.parseVariablesFromCli(undefined, mockLogFunction)).toBeUndefined();
+    });
+    describe('sortResultsByOutcome', () => {
+        const results = (0, 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 = (0, fixtures_1.getSummary)();
+        const cases = [
+            {
+                description: '1 API test with 1 config override, 1 result (passed)',
+                expected: {
+                    exitCode: 0,
+                    summary: Object.assign(Object.assign({}, emptySummary), { expected: 1, passed: 1 }),
+                },
+                failOnCriticalErrors: false,
+                failOnTimeout: false,
+                results: (0, 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), { expected: 1, passed: 1, timedOut: 1 }),
+                },
+                failOnCriticalErrors: false,
+                failOnTimeout: false,
+                results: (0, 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), { expected: 1, failed: 1 }),
+                },
+                failOnCriticalErrors: false,
+                failOnTimeout: true,
+                results: (0, 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), { expected: 1, passed: 1, criticalErrors: 1 }),
+                },
+                failOnCriticalErrors: false,
+                failOnTimeout: false,
+                results: (0, 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), { expected: 1, criticalErrors: 0, failed: 1 }),
+                },
+                failOnCriticalErrors: true,
+                failOnTimeout: false,
+                results: (0, 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), { expected: 3, failed: 1, failedNonBlocking: 1, passed: 1, skipped: 1 }),
+                },
+                failOnCriticalErrors: false,
+                failOnTimeout: false,
+                results: (0, 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), { expected: 3, failedNonBlocking: 2, passed: 1, skipped: 1 }),
+                },
+                failOnCriticalErrors: false,
+                failOnTimeout: false,
+                results: (0, 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), { expected: 3, failed: 1, failedNonBlocking: 1, passed: 1 }),
+                },
+                failOnCriticalErrors: false,
+                failOnTimeout: false,
+                results: (0, fixtures_1.getResults)([{}, { passed: true }, { executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }]),
+                summary: Object.assign({}, emptySummary),
+            },
+            {
+                description: '4 API tests, 3 results (2 passed, of which 1 comes from previous CI run, 1 skipped)',
+                expected: {
+                    exitCode: 0,
+                    summary: Object.assign(Object.assign({}, emptySummary), { expected: 2, passed: 2, previouslyPassed: 1, skipped: 1 }),
+                },
+                failOnCriticalErrors: false,
+                failOnTimeout: false,
+                results: (0, fixtures_1.getResults)([
+                    { passed: true },
+                    {
+                        executionRule: interfaces_1.ExecutionRule.SKIPPED,
+                        selectiveRerun: { decision: 'skip', reason: 'passed', linked_result_id: '' },
+                    },
+                ]),
+                summary: Object.assign(Object.assign({}, emptySummary), { skipped: 1 }),
+            },
+        ];
+        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);
+            });
+            jest.spyOn(api, 'getSyntheticsOrgSettings').mockResolvedValue({ onDemandConcurrencyCap: 1 });
+            const config = Object.assign(Object.assign({}, run_tests_command_1.DEFAULT_COMMAND_CONFIG), { failOnCriticalErrors: testCase.failOnCriticalErrors, failOnTimeout: testCase.failOnTimeout, appKey: 'appKey', apiKey: 'apiKey' });
+            const startTime = Date.now();
+            utils.renderResults({
+                config,
+                orgSettings: { onDemandConcurrencyCap: 1 },
+                reporter: fixtures_1.mockReporter,
+                results: testCase.results,
+                startTime,
+                summary: testCase.summary,
+            });
+            const exitCode = utils.toExitCode(utils.getExitReason(config, { results: testCase.results }));
+            expect(fixtures_1.mockReporter.reportStart).toHaveBeenCalledWith({ startTime });
+            const baseUrl = `https://${run_tests_command_1.DEFAULT_COMMAND_CONFIG.subdomain}.${run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite}/`;
+            expect(testCase.summary).toEqual(testCase.expected.summary);
+            expect(fixtures_1.mockReporter.runEnd).toHaveBeenCalledWith(testCase.expected.summary, baseUrl, {
+                onDemandConcurrencyCap: 1,
+            });
+            expect(exitCode).toBe(testCase.expected.exitCode);
+        }));
+    });
+    describe('getExitReason', () => {
+        test('should return failing-tests if any tests have failed', () => {
+            const config = run_tests_command_1.DEFAULT_COMMAND_CONFIG;
+            const results = (0, fixtures_1.getResults)([{ passed: false }]);
+            expect(utils.getExitReason(config, { results })).toBe('failing-tests');
+        });
+        test.each([
+            { failOnMissingTests: true, errorCode: 'NO_TESTS_TO_RUN', expectedExitReason: 'missing-tests' },
+            { failOnMissingTests: true, errorCode: 'MISSING_TESTS', expectedExitReason: 'missing-tests' },
+            { failOnMissingTests: false, errorCode: 'NO_TESTS_TO_RUN', expectedExitReason: 'passed' },
+            { failOnMissingTests: false, errorCode: 'MISSING_TESTS', expectedExitReason: 'passed' },
+        ])('should return $expectedExitReason when $errorCode if failOnMissingTests flag is $failOnMissingTests', ({ failOnMissingTests, errorCode, expectedExitReason: exitReason }) => {
+            const config = Object.assign(Object.assign({}, run_tests_command_1.DEFAULT_COMMAND_CONFIG), { failOnMissingTests });
+            const error = new errors_1.CiError(errorCode);
+            expect(utils.getExitReason(config, { error })).toBe(exitReason);
+        });
+        test.each([
+            { failOnCriticalErrorsFlag: true, exitReason: 'critical-error' },
+            { failOnCriticalErrorsFlag: false, exitReason: 'passed' },
+        ])('should return $exitReason when failOnCriticalErrors flag is $failOnCriticalErrorsFlag', ({ failOnCriticalErrorsFlag, exitReason }) => {
+            const config = Object.assign(Object.assign({}, run_tests_command_1.DEFAULT_COMMAND_CONFIG), { failOnCriticalErrors: failOnCriticalErrorsFlag });
+            const error = new errors_1.CriticalError('AUTHORIZATION_ERROR');
+            expect(utils.getExitReason(config, { error })).toBe(exitReason);
+        });
+        test('should return passed if all tests have passed and there were no errors', () => {
+            const config = run_tests_command_1.DEFAULT_COMMAND_CONFIG;
+            const results = (0, fixtures_1.getResults)([{ passed: true }]);
+            expect(utils.getExitReason(config, { results })).toBe('passed');
+        });
+    });
+    describe('getDatadogHost', () => {
+        test('should default to datadog us api', () => __awaiter(void 0, void 0, void 0, function* () {
+            process_1.default.env = {};
+            expect(utils.getDatadogHost({ useIntake: false, apiVersion: 'v1', config: fixtures_1.ciConfig })).toBe('https://api.datadoghq.com/api/v1');
+            expect(utils.getDatadogHost({ useIntake: false, apiVersion: 'unstable', config: fixtures_1.ciConfig })).toBe('https://api.datadoghq.com/api/unstable');
+            expect(utils.getDatadogHost({ useIntake: true, apiVersion: 'v1', config: fixtures_1.ciConfig })).toBe('https://intake.synthetics.datadoghq.com/api/v1');
+        }));
+        test('should use DD_API_HOST_OVERRIDE', () => __awaiter(void 0, void 0, void 0, function* () {
+            process_1.default.env = { DD_API_HOST_OVERRIDE: 'https://foobar' };
+            expect(utils.getDatadogHost({ useIntake: true, apiVersion: 'v1', config: fixtures_1.ciConfig })).toBe('https://foobar/api/v1');
+            expect(utils.getDatadogHost({ useIntake: true, apiVersion: 'v1', config: fixtures_1.ciConfig })).toBe('https://foobar/api/v1');
+        }));
+        test('should use Synthetics intake endpoint', () => __awaiter(void 0, void 0, void 0, function* () {
+            process_1.default.env = {};
+            expect(utils.getDatadogHost({
+                apiVersion: 'v1',
+                config: Object.assign(Object.assign({}, fixtures_1.ciConfig), { datadogSite: 'datadoghq.com' }),
+                useIntake: true,
+            })).toBe('https://intake.synthetics.datadoghq.com/api/v1');
+            expect(utils.getDatadogHost({
+                apiVersion: 'v1',
+                config: Object.assign(Object.assign({}, fixtures_1.ciConfig), { datadogSite: 'datad0g.com' }),
+                useIntake: true,
+            })).toBe('https://intake.synthetics.datad0g.com/api/v1');
+        }));
+    });
+    describe('getSyntheticsOrgSettings', () => {
+        beforeEach(() => {
+            jest.restoreAllMocks();
+        });
+        test('failing to get org settings is not important enough to throw', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(api, 'getSyntheticsOrgSettings').mockImplementation(() => {
+                throw (0, fixtures_1.getAxiosHttpError)(502, { message: 'Server Error' });
+            });
+            const config = apiConfiguration;
+            expect(yield utils.getOrgSettings(fixtures_1.mockReporter, config)).toBeUndefined();
+        }));
+    });
+    describe('reportCiError', () => {
+        test.each([
+            'NO_TESTS_TO_RUN',
+            'MISSING_TESTS',
+            'AUTHORIZATION_ERROR',
+            'INVALID_CONFIG',
+            'MISSING_APP_KEY',
+            'MISSING_API_KEY',
+            'POLL_RESULTS_FAILED',
+            'TUNNEL_START_FAILED',
+            'TOO_MANY_TESTS_TO_TRIGGER',
+            'TRIGGER_TESTS_FAILED',
+            'UNAVAILABLE_TEST_CONFIG',
+            'UNAVAILABLE_TUNNEL_CONFIG',
+        ])('should report %s error', (errorCode) => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new errors_1.CiError(errorCode);
+            utils.reportCiError(error, fixtures_1.mockReporter);
+            expect(fixtures_1.mockReporter.error).toMatchSnapshot();
+        }));
+        test('should report default Error if no CiError was matched', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new errors_1.CiError('ERROR');
+            utils.reportCiError(error, fixtures_1.mockReporter);
+            expect(fixtures_1.mockReporter.error).toMatchSnapshot();
+        }));
+    });
+});
+//# sourceMappingURL=public.test.js.map