@datadog/datadog-ci 2.4.1 → 2.5.0

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

@@ -1,933 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (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 command_1 = require("../command");
-const errors_1 = require("../errors");
-const interfaces_1 = require("../interfaces");
-const mobile = __importStar(require("../mobile"));
-const utils = __importStar(require("../utils"));
-const fixtures_1 = require("./fixtures");
-beforeEach(() => {
-    jest.restoreAllMocks();
-});
-describe('utils', () => {
-    const apiConfiguration = {
-        apiKey: '123',
-        appKey: '123',
-        baseIntakeUrl: 'baseintake',
-        baseUnstableUrl: 'baseUnstable',
-        baseUrl: 'base',
-        proxyOpts: { protocol: 'http' },
-    };
-    const api = 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', () => {
-        afterEach(() => {
-            jest.restoreAllMocks();
-        });
-        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', () => {
-        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('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 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',
-                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 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([
-                { executionRule: interfaces_1.ExecutionRule.BLOCKING, public_id: '123-456-789' },
-                { executionRule: interfaces_1.ExecutionRule.SKIPPED, public_id: 'ski-ppe-d01' },
-            ]);
-            const expectedSummary = {
-                criticalErrors: 0,
-                failed: 0,
-                failedNonBlocking: 0,
-                passed: 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({}, 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(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(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(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 ${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(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(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, 'uploadApplicationAndOverrideConfig').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).toBeCalledTimes(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 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, fixtures_1.getSummary())).rejects.toThrow('Failed to get test: could not query https://app.datadoghq.com/example\nForbidden\n');
-        }));
-        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, 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, fixtures_1.getSummary(), true)).toEqual(expect.objectContaining({ test: expect.objectContaining({ public_id: '123-456-789', type: 'browser' }) }));
-        }));
-        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, 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).');
-        }));
-    });
-    describe('getOverriddenConfig', () => {
-        test('empty config returns simple payload', () => {
-            const publicId = 'abc-def-ghi';
-            expect(utils.getOverriddenConfig({ public_id: publicId }, publicId, fixtures_1.mockReporter)).toEqual({
-                executionRule: interfaces_1.ExecutionRule.BLOCKING,
-                public_id: publicId,
-            });
-        });
-        test('strictest executionRule is forwarded', () => {
-            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;
-                expect(utils.getExecutionRule(fakeTest, configOverride)).toBe(expectedExecutionRule);
-                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 => BLOCKING
-            expectHandledConfigToBe(BLOCKING);
-            // CI config overrides only
-            expectHandledConfigToBe(BLOCKING, BLOCKING);
-            expectHandledConfigToBe(NON_BLOCKING, NON_BLOCKING);
-            expectHandledConfigToBe(SKIPPED, SKIPPED);
-            // Test config only
-            expectHandledConfigToBe(BLOCKING, undefined, BLOCKING);
-            expectHandledConfigToBe(NON_BLOCKING, undefined, NON_BLOCKING);
-            expectHandledConfigToBe(SKIPPED, 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: '.*',
-                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('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)('Test execution rule: %s, result execution rule: %s. Expected rule: %s', (testRule, resultRule, expectedRule) => {
-            const test = 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, "passed" /* Passed */],
-            [true, interfaces_1.ExecutionRule.NON_BLOCKING, "passed-non-blocking" /* PassedNonBlocking */],
-            [false, interfaces_1.ExecutionRule.BLOCKING, "failed" /* Failed */],
-            [false, interfaces_1.ExecutionRule.NON_BLOCKING, "failed-non-blocking" /* FailedNonBlocking */],
-        ];
-        test.each(cases)('Result passed: %s, execution rule: %s. Expected outcome: %s', (resultPassed, resultRule, expectedOutcome) => {
-            jest.spyOn(utils, 'getExecutionRule').mockReturnValue(resultRule);
-            const test = fixtures_1.getApiTest('abc-def-ghi');
-            const result = fixtures_1.getApiResult('1', test);
-            result.executionRule = resultRule;
-            result.passed = resultPassed;
-            expect(utils.getResultOutcome(result)).toEqual(expectedOutcome);
-        });
-    });
-    describe('waitForResults', () => {
-        beforeAll(() => {
-            // We still wait a few milliseconds to avoid the test going crazy on a infinite loop
-            // if case of mistakes in the code or test.
-            jest.spyOn(utils, 'wait').mockImplementation(() => new Promise((r) => setTimeout(r, 10)));
-        });
-        const batch = fixtures_1.getBatch();
-        const apiTest = fixtures_1.getApiTest(batch.results[0].test_public_id);
-        const result = {
-            executionRule: interfaces_1.ExecutionRule.BLOCKING,
-            location: fixtures_1.mockLocation.display_name,
-            passed: true,
-            result: fixtures_1.getBrowserServerResult({ passed: true }),
-            resultId: batch.results[0].result_id,
-            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 JSON.parse(JSON.stringify(batch)); })));
-            const pollResultsMock = jest
-                .spyOn(api, 'pollResults')
-                .mockImplementation(pollResultsImplementation || (() => __awaiter(void 0, void 0, void 0, function* () { return JSON.parse(JSON.stringify([pollResult])); })));
-            return { getBatchMock, pollResultsMock };
-        };
-        test('should poll result ids', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockApi();
-            expect(yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 120000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual([result]);
-            expect(fixtures_1.mockReporter.resultReceived).toHaveBeenCalledWith(batch.results[0]);
-        }));
-        test('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: [batch.results[0], Object.assign(Object.assign({}, batch.results[0]), { result_id: '3' })],
-                        status: 'in_progress',
-                    });
-                }),
-                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
-                    return [
-                        deep_extend_1.default({}, pollResult),
-                        // The test object from the second result has an overridden start URL
-                        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], { maxPollingTimeout: 0, failOnCriticalErrors: false }, 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 global pollingTimeout is exceeded', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockApi({
-                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
-                    return ({
-                        results: [batch.results[0], Object.assign(Object.assign({}, batch.results[0]), { result_id: '3', timed_out: undefined })],
-                        status: 'in_progress',
-                    });
-                }),
-                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' }),
-                    ];
-                }),
-            });
-            expect(yield utils.waitForResults(api, trigger, [result.test, result.test], { maxPollingTimeout: 0, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual([
-                result,
-                Object.assign(Object.assign({}, result), { result: Object.assign(Object.assign({}, result.result), { failure: { code: 'TIMEOUT', message: 'Result timed out' }, passed: false }), resultId: '3', timedOut: true }),
-            ]);
-        }));
-        test('results failure should ignore if timed-out', () => __awaiter(void 0, void 0, void 0, function* () {
-            // The original failure of a result received between timing-out in batch poll
-            // and retrieving it should be ignored in favor of timeout.
-            mockApi({
-                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
-                    return ({
-                        results: [Object.assign(Object.assign({}, batch.results[0]), { timed_out: undefined })],
-                        status: 'in_progress',
-                    });
-                }),
-                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], { maxPollingTimeout: 0, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toStrictEqual([
-                Object.assign(Object.assign({}, result), { result: Object.assign(Object.assign({}, result.result), { failure: { code: 'TIMEOUT', message: 'Result timed out' }, passed: false }), timedOut: true }),
-            ]);
-        }));
-        test('results should be timed out if batch result is timed out', () => __awaiter(void 0, void 0, void 0, function* () {
-            const batchWithTimeoutResult = Object.assign(Object.assign({}, batch), { results: [Object.assign(Object.assign({}, batch.results[0]), { timed_out: true })] });
-            mockApi({ getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return batchWithTimeoutResult; }) });
-            expect(yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 120000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual([
-                Object.assign(Object.assign({}, result), { result: Object.assign(Object.assign({}, result.result), { failure: { code: 'TIMEOUT', message: 'Result timed out' }, passed: false }), timedOut: true }),
-            ]);
-        }));
-        test('wait between batch polling', () => __awaiter(void 0, void 0, void 0, function* () {
-            jest.restoreAllMocks();
-            const waitMock = jest.spyOn(utils, 'wait').mockImplementation(() => new Promise((r) => setTimeout(r, 10)));
-            let counter = 0;
-            mockApi({
-                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
-                    counter += 1;
-                    return counter === 3 ? batch : Object.assign(Object.assign({}, batch), { status: 'in_progress' });
-                }),
-            });
-            expect(yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 120000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual([result]);
-            expect(counter).toBe(3);
-            expect(waitMock).toHaveBeenCalledTimes(2);
-        }));
-        test('correct number of pass and timeout results', () => __awaiter(void 0, void 0, void 0, function* () {
-            const pollTimeoutResult = Object.assign(Object.assign({}, pollResult), { resultID: 'another-id' });
-            const batchWithTimeoutResult = Object.assign(Object.assign({}, batch), { results: [batch.results[0], Object.assign(Object.assign({}, batch.results[0]), { timed_out: true, result_id: pollTimeoutResult.resultID })] });
-            mockApi({
-                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return batchWithTimeoutResult; }),
-                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return [pollResult, pollTimeoutResult]; }),
-            });
-            expect(yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 2000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual([result, Object.assign(Object.assign({}, result), { resultId: pollTimeoutResult.resultID, timedOut: true })]);
-        }));
-        test('tunnel failure', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockApi();
-            const mockTunnel = {
-                keepAlive: () => __awaiter(void 0, void 0, void 0, function* () {
-                    throw new Error('keepAlive failed');
-                }),
-            };
-            yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 2000, failOnCriticalErrors: true }, fixtures_1.mockReporter, mockTunnel);
-            expect(fixtures_1.mockReporter.error).toBeCalledWith('The tunnel has stopped working, this may have affected the results.');
-        }));
-        test('location when tunnel', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockApi();
-            const mockTunnel = { keepAlive: () => __awaiter(void 0, void 0, void 0, function* () { return true; }) };
-            let results = yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 2000, failOnCriticalErrors: true }, fixtures_1.mockReporter, mockTunnel);
-            expect(results[0].location).toBe('Tunneled');
-            const newTest = Object.assign({}, result.test);
-            newTest.type = 'api';
-            newTest.subtype = 'http';
-            results = yield utils.waitForResults(api, trigger, [newTest], { maxPollingTimeout: 2000, failOnCriticalErrors: true }, fixtures_1.mockReporter, mockTunnel);
-            expect(results[0].location).toBe('Tunneled');
-            newTest.type = 'api';
-            newTest.subtype = 'ssl';
-            results = yield utils.waitForResults(api, trigger, [newTest], { failOnCriticalErrors: true, maxPollingTimeout: 2000 }, fixtures_1.mockReporter, mockTunnel);
-            expect(results[0].location).toBe('Frankfurt (AWS)');
-        }));
-        test('pollResults throws', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { pollResultsMock } = mockApi({
-                pollResultsImplementation: () => {
-                    throw fixtures_1.getAxiosHttpError(502, { message: 'Poll results server error' });
-                },
-            });
-            yield expect(utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 2000 }, fixtures_1.mockReporter)).rejects.toThrowError('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 fixtures_1.getAxiosHttpError(502, { message: 'Get batch server error' });
-                },
-            });
-            yield expect(utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 2000 }, fixtures_1.mockReporter)).rejects.toThrowError('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.toThrowError('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();
-    });
-    test('getAppBaseURL', () => {
-        // Usual datadog site.
-        expect(utils.getAppBaseURL({ datadogSite: 'datadoghq.com', subdomain: '' })).toBe('https://app.datadoghq.com/');
-        expect(utils.getAppBaseURL({ datadogSite: 'datadoghq.com', subdomain: 'app' })).toBe('https://app.datadoghq.com/');
-        expect(utils.getAppBaseURL({ datadogSite: 'datadoghq.com', subdomain: 'myorg' })).toBe('https://myorg.datadoghq.com/');
-        // Different top-level domain.
-        expect(utils.getAppBaseURL({ datadogSite: 'datadoghq.eu', subdomain: '' })).toBe('https://app.datadoghq.eu/');
-        expect(utils.getAppBaseURL({ datadogSite: 'datadoghq.eu', subdomain: 'app' })).toBe('https://app.datadoghq.eu/');
-        expect(utils.getAppBaseURL({ datadogSite: 'datadoghq.eu', subdomain: 'myorg' })).toBe('https://myorg.datadoghq.eu/');
-        // US3/US5-type datadog site: the datadog site's subdomain is replaced by `subdomain` when `subdomain` is custom.
-        // The correct Main DC (US3 in this case) is resolved automatically.
-        expect(utils.getAppBaseURL({ datadogSite: 'us3.datadoghq.com', subdomain: '' })).toBe('https://us3.datadoghq.com/');
-        expect(utils.getAppBaseURL({ datadogSite: 'us3.datadoghq.com', subdomain: 'app' })).toBe('https://us3.datadoghq.com/');
-        expect(utils.getAppBaseURL({ datadogSite: 'us3.datadoghq.com', subdomain: 'myorg' })).toBe('https://myorg.datadoghq.com/');
-    });
-    describe('sortResultsByOutcome', () => {
-        const results = fixtures_1.getResults([
-            { executionRule: interfaces_1.ExecutionRule.NON_BLOCKING, passed: false },
-            { executionRule: interfaces_1.ExecutionRule.BLOCKING, passed: true },
-            { executionRule: interfaces_1.ExecutionRule.BLOCKING, passed: false },
-            { executionRule: interfaces_1.ExecutionRule.NON_BLOCKING, passed: true },
-        ]);
-        test('should sort tests with success, non_blocking failures then failures', () => __awaiter(void 0, void 0, void 0, function* () {
-            const sortedResults = [...results];
-            sortedResults.sort(utils.sortResultsByOutcome());
-            expect(sortedResults.map((r) => r.resultId)).toStrictEqual(['3', '1', '0', '2']);
-        }));
-    });
-    describe('Render results', () => {
-        const emptySummary = 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), { passed: 1 }),
-                },
-                failOnCriticalErrors: false,
-                failOnTimeout: false,
-                results: fixtures_1.getResults([{ passed: true }]),
-                summary: Object.assign({}, emptySummary),
-            },
-            {
-                description: '1 API test with 1 config override, 1 result (failed timeout), no fail on timeout, no fail on critical errors',
-                expected: {
-                    exitCode: 0,
-                    summary: Object.assign(Object.assign({}, emptySummary), { passed: 1, timedOut: 1 }),
-                },
-                failOnCriticalErrors: false,
-                failOnTimeout: false,
-                results: fixtures_1.getResults([{ timedOut: true }]),
-                summary: Object.assign({}, emptySummary),
-            },
-            {
-                description: '1 API test with 1 config override, 1 result (failed timeout), fail on timeout, no fail on critical errors',
-                expected: {
-                    exitCode: 1,
-                    summary: Object.assign(Object.assign({}, emptySummary), { failed: 1 }),
-                },
-                failOnCriticalErrors: false,
-                failOnTimeout: true,
-                results: fixtures_1.getResults([{ timedOut: true }]),
-                summary: Object.assign({}, emptySummary),
-            },
-            {
-                description: '1 API test with 1 config override, 1 result (failed critical error), no fail on timeout, no fail on critical errors',
-                expected: {
-                    exitCode: 0,
-                    summary: Object.assign(Object.assign({}, emptySummary), { passed: 1, criticalErrors: 1 }),
-                },
-                failOnCriticalErrors: false,
-                failOnTimeout: false,
-                results: fixtures_1.getResults([{ unhealthy: true }]),
-                summary: Object.assign({}, emptySummary),
-            },
-            {
-                description: '1 API test with 1 config override, 1 result (failed critical error), no fail on timeout, fail on critical errors',
-                expected: {
-                    exitCode: 1,
-                    summary: Object.assign(Object.assign({}, emptySummary), { criticalErrors: 0, failed: 1 }),
-                },
-                failOnCriticalErrors: true,
-                failOnTimeout: false,
-                results: fixtures_1.getResults([{ unhealthy: true }]),
-                summary: Object.assign({}, emptySummary),
-            },
-            {
-                description: '1 API test (blocking) with 4 config overrides (1 skipped), 3 results (1 passed, 1 failed, 1 failed non-blocking)',
-                expected: {
-                    exitCode: 1,
-                    summary: Object.assign(Object.assign({}, emptySummary), { failed: 1, failedNonBlocking: 1, passed: 1, skipped: 1 }),
-                },
-                failOnCriticalErrors: false,
-                failOnTimeout: false,
-                results: fixtures_1.getResults([{ passed: true }, { executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }, {}]),
-                summary: Object.assign(Object.assign({}, emptySummary), { skipped: 1 }),
-            },
-            {
-                description: '1 API test (non-blocking) with 4 config overrides (1 skipped), 3 results (1 passed, 1 failed, 1 failed non-blocking)',
-                expected: {
-                    exitCode: 0,
-                    summary: Object.assign(Object.assign({}, emptySummary), { failedNonBlocking: 2, passed: 1, skipped: 1 }),
-                },
-                failOnCriticalErrors: false,
-                failOnTimeout: false,
-                results: fixtures_1.getResults([
-                    {
-                        executionRule: interfaces_1.ExecutionRule.NON_BLOCKING,
-                        testExecutionRule: interfaces_1.ExecutionRule.NON_BLOCKING,
-                    },
-                    { passed: true, testExecutionRule: interfaces_1.ExecutionRule.NON_BLOCKING },
-                    {
-                        testExecutionRule: interfaces_1.ExecutionRule.NON_BLOCKING,
-                    },
-                ]),
-                summary: Object.assign(Object.assign({}, emptySummary), { skipped: 1 }),
-            },
-            {
-                description: '3 API tests (blocking) with 1 config override each, 3 results (1 failed non-blocking, 1 failed, 1 passed)',
-                expected: {
-                    exitCode: 1,
-                    summary: Object.assign(Object.assign({}, emptySummary), { failed: 1, failedNonBlocking: 1, passed: 1 }),
-                },
-                failOnCriticalErrors: false,
-                failOnTimeout: false,
-                results: fixtures_1.getResults([{}, { passed: true }, { executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }]),
-                summary: Object.assign({}, emptySummary),
-            },
-        ];
-        test.each(cases)('$description', (testCase) => __awaiter(void 0, void 0, void 0, function* () {
-            testCase.results.forEach((result) => (result.passed = utils.hasResultPassed(result.result, result.timedOut, testCase.failOnCriticalErrors, testCase.failOnTimeout)));
-            const config = Object.assign(Object.assign({}, command_1.DEFAULT_COMMAND_CONFIG), { failOnCriticalErrors: testCase.failOnCriticalErrors, failOnTimeout: testCase.failOnTimeout });
-            const startTime = Date.now();
-            const exitCode = utils.renderResults({
-                config,
-                reporter: fixtures_1.mockReporter,
-                results: testCase.results,
-                startTime,
-                summary: testCase.summary,
-            });
-            expect(fixtures_1.mockReporter.reportStart).toHaveBeenCalledWith({ startTime });
-            expect(fixtures_1.mockReporter.resultEnd).toHaveBeenCalledTimes(testCase.results.length);
-            const baseUrl = `https://${command_1.DEFAULT_COMMAND_CONFIG.subdomain}.${command_1.DEFAULT_COMMAND_CONFIG.datadogSite}/`;
-            for (const result of testCase.results) {
-                expect(fixtures_1.mockReporter.resultEnd).toHaveBeenCalledWith(result, baseUrl);
-            }
-            expect(testCase.summary).toEqual(testCase.expected.summary);
-            expect(fixtures_1.mockReporter.runEnd).toHaveBeenCalledWith(testCase.expected.summary, baseUrl);
-            expect(exitCode).toBe(testCase.expected.exitCode);
-        }));
-    });
-    describe('getDatadogHost', () => {
-        beforeEach(() => {
-            jest.restoreAllMocks();
-        });
-        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');
-        }));
-    });
-});
-//# sourceMappingURL=utils.test.js.map