@datadog/datadog-ci 3.4.0 → 3.6.0

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

@@ -1,907 +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 });
-const axios_1 = __importDefault(require("axios"));
-const deep_extend_1 = __importDefault(require("deep-extend"));
-const fixtures_1 = require("../../../helpers/__tests__/fixtures");
-const ciHelpers = __importStar(require("../../../helpers/ci"));
-process.env.DATADOG_SYNTHETICS_CI_TRIGGER_APP = 'env_default';
-const api_1 = require("../api");
-const batch_1 = require("../batch");
-const errors_1 = require("../errors");
-const interfaces_1 = require("../interfaces");
-const run_tests_lib_1 = require("../run-tests-lib");
-const internalUtils = __importStar(require("../utils/internal"));
-const utils = __importStar(require("../utils/public"));
-const fixtures_2 = require("./fixtures");
-const apiConfiguration = {
-    apiKey: '123',
-    appKey: '123',
-    baseIntakeUrl: 'baseintake',
-    baseUnstableUrl: 'baseUnstable',
-    baseUrl: 'base',
-    proxyOpts: { protocol: 'http' },
-};
-const api = (0, api_1.apiConstructor)(apiConfiguration);
-const DEFAULT_COMMAND_CONFIG = (0, run_tests_lib_1.getDefaultConfig)();
-describe('runTests', () => {
-    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 (0, batch_1.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 (0, batch_1.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 (0, batch_1.runTests)(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }]);
-        expect(payloadMetadataSpy).toHaveBeenCalledWith(metadata);
-    }));
-    test('runTests api call has the right payload and trigger app header', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest.spyOn(ciHelpers, 'getCIMetadata').mockImplementation(() => undefined);
-        const testsPayloadSpy = jest.fn();
-        const headersMetadataSpy = jest.fn();
-        jest.spyOn(axios_1.default, 'create').mockImplementation((() => (request) => {
-            testsPayloadSpy(request.data.tests);
-            headersMetadataSpy(request.headers);
-            if (request.url === '/synthetics/tests/trigger/ci') {
-                return { data: fakeTrigger };
-            }
-        }));
-        yield (0, batch_1.runTests)(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }]);
-        expect(headersMetadataSpy).toHaveBeenCalledWith(expect.objectContaining({ 'X-Trigger-App': 'env_default' }));
-        expect(testsPayloadSpy).toHaveBeenCalledWith([
-            {
-                public_id: fakeId,
-                executionRule: interfaces_1.ExecutionRule.NON_BLOCKING,
-            },
-        ]);
-        utils.setCiTriggerApp('unit_test');
-        yield (0, batch_1.runTests)(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }]);
-        expect(headersMetadataSpy).toHaveBeenCalledWith(expect.objectContaining({ 'X-Trigger-App': 'unit_test' }));
-        expect(testsPayloadSpy).toHaveBeenCalledWith([
-            {
-                public_id: fakeId,
-                executionRule: interfaces_1.ExecutionRule.NON_BLOCKING,
-            },
-        ]);
-    }));
-    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 (0, batch_1.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.getAxiosError)(502, { message: 'Server Error' });
-        });
-        yield expect((0, batch_1.runTests)(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }])).rejects.toThrow(/Failed to trigger tests:/);
-    }));
-});
-describe('waitForResults', () => {
-    beforeEach(() => {
-        jest.useFakeTimers({ now: 123 });
-        jest.spyOn(internalUtils, 'wait').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return jest.advanceTimersByTime(5000); }));
-    });
-    afterEach(() => {
-        jest.useRealTimers();
-        jest.restoreAllMocks();
-    });
-    const batch = (0, fixtures_2.getBatch)();
-    const apiTest = (0, fixtures_2.getApiTest)('pid');
-    const result = {
-        duration: 1000,
-        executionRule: interfaces_1.ExecutionRule.BLOCKING,
-        initialResultId: undefined,
-        isNonFinal: false,
-        location: fixtures_2.mockLocation.display_name,
-        passed: true,
-        result: (0, fixtures_2.getBrowserServerResult)({ passed: true }),
-        resultId: 'rid',
-        retries: 0,
-        maxRetries: 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_2.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 (0, batch_1.waitForResults)(api, trigger, [result.test], {
-            batchTimeout: 120000,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            failOnCriticalErrors: false,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.mockReporter)).toEqual([result]);
-    }));
-    test('should show results as they arrive', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest.spyOn(internalUtils, '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_2.getInProgressResultInBatch)()),
-                        Object.assign(Object.assign({}, (0, fixtures_2.getInProgressResultInBatch)()), { result_id: 'rid-2' }),
-                        Object.assign(Object.assign({}, (0, fixtures_2.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 = (0, batch_1.waitForResults)(api, trigger, tests, {
-            batchTimeout: 120000,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            failOnCriticalErrors: false,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.mockReporter);
-        // Wait for the 2 tests (initial)
-        expect(fixtures_2.mockReporter.testsWait).toHaveBeenNthCalledWith(1, [tests[0], tests[1]], fixtures_1.MOCK_BASE_URL, trigger.batch_id);
-        yield waiter.promise;
-        // No results received
-        expect(fixtures_2.mockReporter.resultReceived).not.toHaveBeenCalled();
-        expect(fixtures_2.mockReporter.resultEnd).not.toHaveBeenCalled();
-        // Still waiting for the 2 tests
-        expect(fixtures_2.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_2.getInProgressResultInBatch)()),
-                        Object.assign(Object.assign({}, (0, fixtures_2.getPassedResultInBatch)()), { result_id: 'rid-2' }),
-                        Object.assign(Object.assign({}, (0, fixtures_2.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_2.mockReporter.resultReceived).toHaveBeenNthCalledWith(1, Object.assign(Object.assign({}, batch.results[0]), { status: 'passed', result_id: 'rid-2' }));
-        expect(fixtures_2.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_2.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_2.getPassedResultInBatch)()),
-                        Object.assign(Object.assign({}, (0, fixtures_2.getPassedResultInBatch)()), { result_id: 'rid-2' }),
-                        Object.assign(Object.assign({}, (0, fixtures_2.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_2.mockReporter.resultReceived).toHaveBeenNthCalledWith(2, Object.assign(Object.assign({}, batch.results[0]), { status: 'passed' }));
-        expect(fixtures_2.mockReporter.resultEnd).toHaveBeenNthCalledWith(2, result, fixtures_1.MOCK_BASE_URL, 'bid');
-        // Now waiting for 1 test
-        expect(fixtures_2.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_2.getPassedResultInBatch)()),
-                        Object.assign(Object.assign({}, (0, fixtures_2.getPassedResultInBatch)()), { result_id: 'rid-2' }),
-                        Object.assign(Object.assign({}, (0, fixtures_2.getInProgressResultInBatch)()), { duration: 1000, 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_2.mockReporter.resultReceived).toHaveBeenNthCalledWith(3, Object.assign(Object.assign({}, batch.results[0]), { duration: 1000, status: 'in_progress', test_public_id: 'other-public-id', result_id: 'rid-3' }));
-        expect(fixtures_2.mockReporter.resultEnd).toHaveBeenNthCalledWith(3, Object.assign(Object.assign({}, result), { isNonFinal: true, resultId: 'rid-3', passed: false }), // the first attempt failed, so it's being retried
-        fixtures_1.MOCK_BASE_URL, 'bid');
-        // Now waiting for 1 test
-        expect(fixtures_2.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_2.getPassedResultInBatch)()),
-                        Object.assign(Object.assign({}, (0, fixtures_2.getPassedResultInBatch)()), { result_id: 'rid-2' }),
-                        Object.assign(Object.assign({}, (0, fixtures_2.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_2.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_2.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_2.mockReporter.testsWait).toHaveBeenCalledTimes(5);
-    }));
-    test('skipped results are reported as received', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest.spyOn(internalUtils, '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_2.getSkippedResultInBatch)()),
-                        Object.assign(Object.assign({}, (0, fixtures_2.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 = (0, batch_1.waitForResults)(api, trigger, tests, {
-            batchTimeout: 120000,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            failOnCriticalErrors: false,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.mockReporter);
-        // Wait for the 2 tests (initial)
-        expect(fixtures_2.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_2.mockReporter.resultReceived).toHaveBeenNthCalledWith(1, Object.assign({}, (0, fixtures_2.getSkippedResultInBatch)()));
-        // And marked as passed because it's selective rerun
-        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_2.mockReporter.resultEnd).toHaveBeenNthCalledWith(1, skippedResult, fixtures_1.MOCK_BASE_URL, 'bid');
-        // Now waiting for the remaining test
-        expect(fixtures_2.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_2.getSkippedResultInBatch)()),
-                        Object.assign(Object.assign({}, (0, fixtures_2.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_2.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_2.mockReporter.resultEnd).toHaveBeenNthCalledWith(2, Object.assign(Object.assign({}, result), { resultId: 'rid-2' }), fixtures_1.MOCK_BASE_URL, 'bid');
-        expect(fixtures_2.mockReporter.testsWait).toHaveBeenCalledTimes(2);
-    }));
-    test('should wait for incomplete results', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest.spyOn(internalUtils, '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_2.getInProgressResultInBatch)()),
-                        Object.assign(Object.assign({}, (0, fixtures_2.getPassedResultInBatch)()), { result_id: 'rid-2' }),
-                        Object.assign(Object.assign({}, (0, fixtures_2.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: (0, fixtures_2.getIncompleteServerResult)() })]; }),
-        });
-        const resultsPromise = (0, batch_1.waitForResults)(api, trigger, tests, {
-            batchTimeout: 120000,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            failOnCriticalErrors: false,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.mockReporter);
-        // Wait for the 2 tests (initial)
-        expect(fixtures_2.mockReporter.testsWait).toHaveBeenNthCalledWith(1, [tests[0], tests[1]], fixtures_1.MOCK_BASE_URL, trigger.batch_id);
-        yield waiter.promise;
-        // One result received
-        expect(fixtures_2.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_2.mockReporter.resultEnd).not.toHaveBeenCalled();
-        // Still waiting for 2 tests
-        expect(fixtures_2.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_2.getPassedResultInBatch)()),
-                        Object.assign(Object.assign({}, (0, fixtures_2.getPassedResultInBatch)()), { result_id: 'rid-2' }),
-                        Object.assign(Object.assign({}, (0, fixtures_2.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: (0, fixtures_2.getIncompleteServerResult)() }),
-                    (0, deep_extend_1.default)({}, pollResult, { resultID: 'rid-2' }), // just became available
-                ];
-            }),
-        });
-        yield waiter.promise;
-        // One result received
-        expect(fixtures_2.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_2.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_2.mockReporter.testsWait).toHaveBeenNthCalledWith(3, [tests[1]], fixtures_1.MOCK_BASE_URL, trigger.batch_id, 0);
-        // === STEP 3 === (batch 'failed')
-        mockApi({
-            getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
-                return ({
-                    status: 'failed',
-                    results: [
-                        Object.assign({}, (0, fixtures_2.getFailedResultInBatch)()),
-                        Object.assign(Object.assign({}, (0, fixtures_2.getPassedResultInBatch)()), { result_id: 'rid-2' }),
-                        Object.assign(Object.assign({}, (0, fixtures_2.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: (0, fixtures_2.getIncompleteServerResult)() }),
-                    (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', passed: false, result: undefined }),
-            Object.assign(Object.assign({}, result), { resultId: 'rid-2' }),
-            Object.assign(Object.assign({}, result), { resultId: 'rid-3' }),
-        ]);
-        // One result received
-        expect(fixtures_2.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_2.mockReporter.resultEnd).toHaveBeenNthCalledWith(2, Object.assign(Object.assign({}, result), { resultId: 'rid-3' }), fixtures_1.MOCK_BASE_URL, 'bid');
-        // Result 1 never became available (but the batch says it did not pass)
-        expect(fixtures_2.mockReporter.resultEnd).toHaveBeenNthCalledWith(3, Object.assign(Object.assign({}, result), { passed: false, resultId: 'rid', result: undefined }), fixtures_1.MOCK_BASE_URL, 'bid');
-        expect(fixtures_2.mockReporter.error).toHaveBeenCalledWith('The information for result rid of test pid was incomplete at the end of the batch.\n\n');
-        // Do not report when there are no tests to wait anymore
-        expect(fixtures_2.mockReporter.testsWait).toHaveBeenCalledTimes(3);
-    }));
-    test('should wait for incomplete results caused by 404', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest.spyOn(internalUtils, '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_2.getInProgressResultInBatch)()),
-                        Object.assign(Object.assign({}, (0, fixtures_2.getInProgressResultInBatch)()), { test_public_id: 'other-public-id', result_id: 'rid-2' }),
-                    ],
-                });
-            }),
-            pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
-        });
-        const resultsPromise = (0, batch_1.waitForResults)(api, trigger, tests, {
-            batchTimeout: 120000,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            failOnCriticalErrors: false,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.mockReporter);
-        // Wait for the 2 tests (initial)
-        expect(fixtures_2.mockReporter.testsWait).toHaveBeenNthCalledWith(1, [tests[0], tests[1]], fixtures_1.MOCK_BASE_URL, trigger.batch_id);
-        yield waiter.promise;
-        // Still waiting for 2 tests
-        expect(fixtures_2.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_2.getPassedResultInBatch)()),
-                        Object.assign(Object.assign({}, (0, fixtures_2.getInProgressResultInBatch)()), { test_public_id: 'other-public-id', result_id: 'rid-2' }),
-                    ],
-                });
-            }),
-            pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
-                throw (0, fixtures_1.getAxiosError)(404, { message: 'Test results not found' });
-            }),
-        });
-        yield waiter.promise;
-        // One result received
-        expect(fixtures_2.mockReporter.resultReceived).toHaveBeenNthCalledWith(1, Object.assign(Object.assign({}, batch.results[0]), { status: 'passed' }));
-        // But not available
-        expect(fixtures_2.mockReporter.resultEnd).not.toHaveBeenCalled();
-        // Now waiting for 1 test
-        expect(fixtures_2.mockReporter.testsWait).toHaveBeenNthCalledWith(3, [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_2.getPassedResultInBatch)()),
-                        Object.assign(Object.assign({}, (0, fixtures_2.getInProgressResultInBatch)()), { 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), // became available
-                ];
-            }),
-        });
-        yield waiter.promise;
-        // Result 1 just became available, so it should be reported
-        expect(fixtures_2.mockReporter.resultEnd).toHaveBeenNthCalledWith(1, result, fixtures_1.MOCK_BASE_URL, 'bid');
-        // Still waiting for 1 test
-        expect(fixtures_2.mockReporter.testsWait).toHaveBeenNthCalledWith(3, [tests[1]], fixtures_1.MOCK_BASE_URL, trigger.batch_id, 0);
-        mockApi({
-            getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
-                return ({
-                    status: 'passed',
-                    results: [
-                        Object.assign({}, (0, fixtures_2.getPassedResultInBatch)()),
-                        Object.assign(Object.assign({}, (0, fixtures_2.getPassedResultInBatch)()), { test_public_id: 'other-public-id', result_id: 'rid-2' }),
-                    ],
-                });
-            }),
-            pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
-                throw (0, fixtures_1.getAxiosError)(404, { message: 'Test results not found' });
-            }),
-        });
-        expect(yield resultsPromise).toEqual([
-            result,
-            Object.assign(Object.assign({}, result), { resultId: 'rid-2', result: undefined, timestamp: 123, test: tests[1] }),
-        ]);
-        // One result received
-        expect(fixtures_2.mockReporter.resultReceived).toHaveBeenNthCalledWith(2, Object.assign(Object.assign({}, batch.results[0]), { status: 'passed', test_public_id: 'other-public-id', result_id: 'rid-2' }));
-        // Last result is reported without a poll result
-        expect(fixtures_2.mockReporter.resultEnd).toHaveBeenNthCalledWith(2, Object.assign(Object.assign({}, result), { resultId: 'rid-2', result: undefined, test: tests[1], timestamp: 123 }), fixtures_1.MOCK_BASE_URL, 'bid');
-        expect(fixtures_2.mockReporter.error).toHaveBeenCalledWith('The information for result rid-2 of test other-public-id was incomplete at the end of the batch.\n\n');
-        // Do not report when there are no tests to wait anymore
-        expect(fixtures_2.mockReporter.testsWait).toHaveBeenCalledTimes(4);
-    }));
-    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_2.getPassedResultInBatch)(), Object.assign(Object.assign({}, (0, fixtures_2.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 (0, batch_1.waitForResults)(api, trigger, [result.test, result.test], {
-            batchTimeout: 0,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            failOnCriticalErrors: false,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.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_2.getPassedResultInBatch)()), Object.assign(Object.assign({}, (0, fixtures_2.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 (0, batch_1.waitForResults)(api, trigger, [result.test, result.test], {
-            batchTimeout: 3000,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            failOnCriticalErrors: false,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.mockReporter)).toEqual([result, expectedTimeoutResult]);
-        expect(fixtures_2.mockReporter.resultReceived).toHaveBeenCalledTimes(2);
-        // `resultEnd` should return the same data as `waitForResults`
-        expect(fixtures_2.mockReporter.resultEnd).toHaveBeenNthCalledWith(1, result, fixtures_1.MOCK_BASE_URL, 'bid');
-        expect(fixtures_2.mockReporter.resultEnd).toHaveBeenNthCalledWith(2, expectedTimeoutResult, fixtures_1.MOCK_BASE_URL, 'bid');
-        // Failed directly.
-        expect(internalUtils.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_2.getPassedResultInBatch)()),
-                        Object.assign(Object.assign({}, (0, fixtures_2.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), { duration: 0, 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((0, batch_1.waitForResults)(api, trigger, [result.test, result.test], {
-            batchTimeout: 3000,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            failOnCriticalErrors: false,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.mockReporter)).rejects.toThrow(new errors_1.BatchTimeoutRunawayError());
-        // Residual results are never 'received': we force-end them.
-        expect(fixtures_2.mockReporter.resultReceived).toHaveBeenCalledTimes(1);
-        // `resultEnd` should return the same data as `waitForResults`
-        expect(fixtures_2.mockReporter.resultEnd).toHaveBeenNthCalledWith(1, result, fixtures_1.MOCK_BASE_URL, 'bid');
-        expect(fixtures_2.mockReporter.resultEnd).toHaveBeenNthCalledWith(2, expectedDeadlineResult, fixtures_1.MOCK_BASE_URL, 'bid');
-        // Initial wait + 3 polling cycles.
-        expect(internalUtils.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_2.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 (0, batch_1.waitForResults)(api, trigger, [result.test], {
-            batchTimeout: 0,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            failOnCriticalErrors: false,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.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_2.getFailedResultInBatch)()), { timed_out: true })] });
-        mockApi({ getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return batchWithTimeoutResult; }) });
-        expect(yield (0, batch_1.waitForResults)(api, trigger, [result.test], {
-            batchTimeout: 120000,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            failOnCriticalErrors: false,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.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 (0, batch_1.waitForResults)(api, trigger, [result.test], {
-            batchTimeout: 120000,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            failOnCriticalErrors: false,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.mockReporter)).toEqual([result]);
-        expect(getBatchMock).toHaveBeenCalledTimes(3);
-        expect(internalUtils.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_2.getPassedResultInBatch)()),
-                Object.assign(Object.assign({}, (0, fixtures_2.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 (0, batch_1.waitForResults)(api, trigger, [result.test], {
-            batchTimeout: 2000,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            failOnCriticalErrors: false,
-            failOnTimeout: false,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.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_2.mockReporter.resultReceived).toHaveBeenCalledTimes(2);
-        expect(fixtures_2.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 (0, batch_1.waitForResults)(api, trigger, [result.test], {
-            batchTimeout: 2000,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            failOnCriticalErrors: true,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.mockReporter, mockTunnel);
-        expect(fixtures_2.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 (0, batch_1.waitForResults)(api, trigger, [result.test], {
-            batchTimeout: 2000,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            failOnCriticalErrors: true,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.mockReporter, mockTunnel);
-        expect(results[0].location).toBe('Tunneled');
-        const newTest = Object.assign({}, result.test);
-        newTest.type = 'api';
-        newTest.subtype = 'http';
-        results = yield (0, batch_1.waitForResults)(api, trigger, [newTest], {
-            batchTimeout: 2000,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            failOnCriticalErrors: true,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.mockReporter, mockTunnel);
-        expect(results[0].location).toBe('Tunneled');
-        newTest.type = 'api';
-        newTest.subtype = 'ssl';
-        results = yield (0, batch_1.waitForResults)(api, trigger, [newTest], {
-            batchTimeout: 2000,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            failOnCriticalErrors: true,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.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.getAxiosError)(502, { message: 'Poll results server error' });
-            },
-        });
-        yield expect((0, batch_1.waitForResults)(api, trigger, [result.test], {
-            batchTimeout: 2000,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.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.getAxiosError)(502, { message: 'Get batch server error' });
-            },
-        });
-        yield expect((0, batch_1.waitForResults)(api, trigger, [result.test], {
-            batchTimeout: 2000,
-            datadogSite: DEFAULT_COMMAND_CONFIG.datadogSite,
-            subdomain: DEFAULT_COMMAND_CONFIG.subdomain,
-        }, fixtures_2.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);
-    }));
-});
-describe('getResultsToReport', () => {
-    test.each([false])('timed out retry - shouldContinuePolling=%s', (shouldContinuePolling) => {
-        const timedOutRetry = Object.assign(Object.assign({}, (0, fixtures_2.getFailedResultInBatch)()), { retries: 0, max_retries: 1, timed_out: true });
-        const batch = {
-            status: 'failed',
-            results: [timedOutRetry],
-        };
-        const resultsToReport = (0, batch_1.getResultsToReport)(shouldContinuePolling, batch, [], new Set(['rid']), new Set(), new Set(), fixtures_2.mockReporter);
-        expect(resultsToReport).toStrictEqual([timedOutRetry]);
-    });
-    test.each([false])('timed out retry never emitted before - shouldContinuePolling=%s', (shouldContinuePolling) => {
-        const timedOutRetry = Object.assign(Object.assign({}, (0, fixtures_2.getFailedResultInBatch)()), { retries: 0, max_retries: 1, timed_out: true });
-        const batch = {
-            status: 'failed',
-            results: [timedOutRetry],
-        };
-        const resultsToReport = (0, batch_1.getResultsToReport)(shouldContinuePolling, batch, [timedOutRetry], new Set(), new Set(), new Set(), fixtures_2.mockReporter);
-        expect(resultsToReport).toStrictEqual([timedOutRetry]);
-    });
-});
-describe('reportReceivedResults', () => {
-    test('skipped', () => {
-        const skippedResult = (0, fixtures_2.getSkippedResultInBatch)();
-        const batch = {
-            status: 'failed',
-            results: [skippedResult],
-        };
-        const emittedResultIds = new Set();
-        const receivedResults = (0, batch_1.reportReceivedResults)(batch, emittedResultIds, fixtures_2.mockReporter);
-        expect(receivedResults).toStrictEqual([skippedResult]);
-        expect(emittedResultIds).toContain('skipped-0');
-        expect(fixtures_2.mockReporter.resultReceived).toHaveBeenCalledWith(skippedResult);
-    });
-    test('final', () => {
-        const result = (0, fixtures_2.getPassedResultInBatch)();
-        const batch = {
-            status: 'passed',
-            results: [result],
-        };
-        const emittedResultIds = new Set();
-        const receivedResults = (0, batch_1.reportReceivedResults)(batch, emittedResultIds, fixtures_2.mockReporter);
-        expect(receivedResults).toStrictEqual([result]);
-        expect(emittedResultIds).toContain('rid');
-        expect(fixtures_2.mockReporter.resultReceived).toHaveBeenCalledWith(result);
-    });
-    test('non final', () => {
-        const result = Object.assign(Object.assign({}, (0, fixtures_2.getInProgressResultInBatch)()), { retries: 0, max_retries: 1 });
-        const batch = {
-            status: 'in_progress',
-            results: [result],
-        };
-        const emittedResultIds = new Set();
-        const receivedResults = (0, batch_1.reportReceivedResults)(batch, emittedResultIds, fixtures_2.mockReporter);
-        expect(receivedResults).toStrictEqual([result]);
-        expect(emittedResultIds).toContain('rid');
-        expect(fixtures_2.mockReporter.resultReceived).toHaveBeenCalledWith(result);
-    });
-    test('timed out', () => {
-        const timedOut = Object.assign(Object.assign({}, (0, fixtures_2.getFailedResultInBatch)()), { timed_out: true });
-        const batch = {
-            status: 'failed',
-            results: [timedOut],
-        };
-        const emittedResultIds = new Set();
-        const receivedResults = (0, batch_1.reportReceivedResults)(batch, emittedResultIds, fixtures_2.mockReporter);
-        expect(receivedResults).toStrictEqual([timedOut]);
-        expect(emittedResultIds).toContain('rid');
-        expect(fixtures_2.mockReporter.resultReceived).toHaveBeenCalledWith(timedOut);
-    });
-});
-//# sourceMappingURL=batch.test.js.map