@datadog/datadog-ci 2.48.0 → 3.0.1

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

@@ -0,0 +1,906 @@
+"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_command_1 = require("../run-tests-command");
+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);
+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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            failOnCriticalErrors: false,
+            subdomain: run_tests_command_1.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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            failOnCriticalErrors: false,
+            subdomain: run_tests_command_1.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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            failOnCriticalErrors: false,
+            subdomain: run_tests_command_1.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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            failOnCriticalErrors: false,
+            subdomain: run_tests_command_1.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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            failOnCriticalErrors: false,
+            subdomain: run_tests_command_1.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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            failOnCriticalErrors: false,
+            subdomain: run_tests_command_1.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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            failOnCriticalErrors: false,
+            subdomain: run_tests_command_1.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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            failOnCriticalErrors: false,
+            subdomain: run_tests_command_1.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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            failOnCriticalErrors: false,
+            subdomain: run_tests_command_1.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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            failOnCriticalErrors: false,
+            subdomain: run_tests_command_1.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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            failOnCriticalErrors: false,
+            subdomain: run_tests_command_1.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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            failOnCriticalErrors: false,
+            failOnTimeout: false,
+            subdomain: run_tests_command_1.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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            failOnCriticalErrors: true,
+            subdomain: run_tests_command_1.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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            failOnCriticalErrors: true,
+            subdomain: run_tests_command_1.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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            failOnCriticalErrors: true,
+            subdomain: run_tests_command_1.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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            failOnCriticalErrors: true,
+            subdomain: run_tests_command_1.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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            subdomain: run_tests_command_1.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: run_tests_command_1.DEFAULT_COMMAND_CONFIG.datadogSite,
+            subdomain: run_tests_command_1.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