@datadog/datadog-ci 2.40.3 → 2.41.0

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

@@ -1,1526 +0,0 @@
-"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 = __importDefault(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"}',
-        };
-        fs.readFile.mockImplementation((path, opts, callback) => callback(undefined, FILES_CONTENT[path]));
-        glob_1.default.mockImplementation((query, callback) => callback(undefined, FILES));
-        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