@datadog/datadog-ci 1.6.0 → 1.7.2-alpha

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

@@ -43,6 +43,9 @@ const errors_1 = require("../errors");
 const interfaces_1 = require("../interfaces");
 const utils = __importStar(require("../utils"));
 const fixtures_1 = require("./fixtures");
+beforeEach(() => {
+    jest.restoreAllMocks();
+});
 describe('utils', () => {
     const apiConfiguration = {
         apiKey: '123',
@@ -69,19 +72,11 @@ describe('utils', () => {
     describe('runTest', () => {
         const fakeId = '123-456-789';
         const fakeTrigger = {
-            results: [],
-            triggered_check_ids: [fakeId],
+            batch_id: 'bid',
+            locations: [],
         };
-        afterAll(() => {
-            jest.clearAllMocks();
-        });
         test('should run test', () => __awaiter(void 0, void 0, void 0, function* () {
-            const axiosMock = jest.spyOn(axios_1.default, 'create');
-            axiosMock.mockImplementation((() => (e) => {
-                if (e.url === '/synthetics/tests/trigger/ci') {
-                    return { data: fakeTrigger };
-                }
-            }));
+            jest.spyOn(api, 'triggerTests').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return fakeTrigger; }));
             const output = yield utils.runTests(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }]);
             expect(output).toEqual(fakeTrigger);
         }));
@@ -120,12 +115,7 @@ describe('utils', () => {
             expect(headersMetadataSpy).toHaveBeenCalledWith(expect.objectContaining({ 'X-Trigger-App': 'unit_test' }));
         }));
         test('should run test with publicId from url', () => __awaiter(void 0, void 0, void 0, function* () {
-            const axiosMock = jest.spyOn(axios_1.default, 'create');
-            axiosMock.mockImplementation((() => (e) => {
-                if (e.url === '/synthetics/tests/trigger/ci') {
-                    return { data: fakeTrigger };
-                }
-            }));
+            jest.spyOn(api, 'triggerTests').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return fakeTrigger; }));
             const output = yield utils.runTests(api, [
                 {
                     executionRule: interfaces_1.ExecutionRule.NON_BLOCKING,
@@ -143,11 +133,9 @@ describe('utils', () => {
                     status: 502,
                 },
             });
-            const requestMock = jest.fn();
-            requestMock.mockImplementation(() => {
+            jest.spyOn(api, 'triggerTests').mockImplementation(() => {
                 throw serverError;
             });
-            jest.spyOn(axios_1.default, 'create').mockImplementation((() => requestMock));
             yield expect(utils.runTests(api, [{ public_id: fakeId, executionRule: interfaces_1.ExecutionRule.NON_BLOCKING }])).rejects.toThrow(/Failed to trigger tests:/);
         }));
     });
@@ -167,7 +155,7 @@ describe('utils', () => {
                 suite: 'Suite 3',
             },
         };
-        beforeAll(() => {
+        beforeEach(() => {
             const axiosMock = jest.spyOn(axios_1.default, 'create');
             axiosMock.mockImplementation((() => (e) => {
                 const publicId = e.url.slice(18);
@@ -179,9 +167,6 @@ describe('utils', () => {
                 throw error;
             }));
         });
-        afterAll(() => {
-            jest.clearAllMocks();
-        });
         test('only existing tests are returned', () => __awaiter(void 0, void 0, void 0, function* () {
             const triggerConfigs = [
                 { suite: 'Suite 1', config: {}, id: '123-456-789' },
@@ -197,6 +182,7 @@ describe('utils', () => {
             const expectedSummary = {
                 criticalErrors: 0,
                 failed: 0,
+                failedNonBlocking: 0,
                 passed: 0,
                 skipped: 1,
                 testsNotFound: new Set(['987-654-321']),
@@ -343,284 +329,203 @@ describe('utils', () => {
             const result = {
                 device: { height: 0, id: 'laptop_large', width: 0 },
                 duration: 0,
-                eventType: 'finished',
                 passed: true,
                 startUrl: '',
                 stepDetails: [],
             };
-            expect(utils.hasResultPassed(result, false, true)).toBeTruthy();
-            expect(utils.hasResultPassed(result, true, true)).toBeTruthy();
+            expect(utils.hasResultPassed(result, false, false, true)).toBeTruthy();
+            expect(utils.hasResultPassed(result, false, true, true)).toBeTruthy();
             result.passed = false;
-            expect(utils.hasResultPassed(result, false, true)).toBeFalsy();
-            expect(utils.hasResultPassed(result, true, true)).toBeFalsy();
+            expect(utils.hasResultPassed(result, false, false, true)).toBeFalsy();
+            expect(utils.hasResultPassed(result, false, true, true)).toBeFalsy();
         });
         test('result with error', () => {
             const result = {
                 device: { height: 0, id: 'laptop_large', width: 0 },
                 duration: 0,
                 errorCode: 'ERRABORTED',
-                eventType: 'finished',
                 passed: false,
                 startUrl: '',
                 stepDetails: [],
             };
-            expect(utils.hasResultPassed(result, false, true)).toBeFalsy();
-            expect(utils.hasResultPassed(result, true, true)).toBeFalsy();
+            expect(utils.hasResultPassed(result, false, false, true)).toBeFalsy();
+            expect(utils.hasResultPassed(result, false, true, true)).toBeFalsy();
         });
         test('result with unhealthy result', () => {
             const result = {
                 device: { height: 0, id: 'laptop_large', width: 0 },
                 duration: 0,
                 errorCode: 'ERRABORTED',
-                eventType: 'finished',
                 passed: false,
                 startUrl: '',
                 stepDetails: [],
                 unhealthy: true,
             };
-            expect(utils.hasResultPassed(result, false, true)).toBeTruthy();
-            expect(utils.hasResultPassed(result, true, true)).toBeFalsy();
+            expect(utils.hasResultPassed(result, false, false, true)).toBeTruthy();
+            expect(utils.hasResultPassed(result, false, true, true)).toBeFalsy();
         });
         test('result with timeout result', () => {
             const result = {
                 device: { height: 0, id: 'laptop_large', width: 0 },
                 duration: 0,
-                error: interfaces_1.ERRORS.TIMEOUT,
-                eventType: 'finished',
                 passed: false,
                 startUrl: '',
                 stepDetails: [],
             };
-            expect(utils.hasResultPassed(result, true, true)).toBeFalsy();
-            expect(utils.hasResultPassed(result, true, false)).toBeTruthy();
+            expect(utils.hasResultPassed(result, true, true, true)).toBeFalsy();
+            expect(utils.hasResultPassed(result, true, true, false)).toBeTruthy();
         });
     });
-    test('result with endpoint failure result', () => {
-        const result = {
-            device: { height: 0, id: 'laptop_large', width: 0 },
-            duration: 0,
-            error: interfaces_1.ERRORS.ENDPOINT,
-            eventType: 'finished',
-            passed: false,
-            startUrl: '',
-            stepDetails: [],
-        };
-        expect(utils.hasResultPassed(result, false, true)).toBeTruthy();
-        expect(utils.hasResultPassed(result, true, true)).toBeFalsy();
+    describe('getExecutionRule', () => {
+        const cases = [
+            [undefined, undefined, interfaces_1.ExecutionRule.BLOCKING],
+            [undefined, interfaces_1.ExecutionRule.BLOCKING, interfaces_1.ExecutionRule.BLOCKING],
+            [undefined, interfaces_1.ExecutionRule.NON_BLOCKING, interfaces_1.ExecutionRule.NON_BLOCKING],
+            [interfaces_1.ExecutionRule.BLOCKING, undefined, interfaces_1.ExecutionRule.BLOCKING],
+            [interfaces_1.ExecutionRule.BLOCKING, interfaces_1.ExecutionRule.BLOCKING, interfaces_1.ExecutionRule.BLOCKING],
+            [interfaces_1.ExecutionRule.BLOCKING, interfaces_1.ExecutionRule.NON_BLOCKING, interfaces_1.ExecutionRule.NON_BLOCKING],
+            [interfaces_1.ExecutionRule.NON_BLOCKING, undefined, interfaces_1.ExecutionRule.NON_BLOCKING],
+            [interfaces_1.ExecutionRule.NON_BLOCKING, interfaces_1.ExecutionRule.BLOCKING, interfaces_1.ExecutionRule.NON_BLOCKING],
+            [interfaces_1.ExecutionRule.NON_BLOCKING, interfaces_1.ExecutionRule.NON_BLOCKING, interfaces_1.ExecutionRule.NON_BLOCKING],
+        ];
+        test.each(cases)('Test execution rule: %s, result execution rule: %s. Expected rule: %s', (testRule, resultRule, expectedRule) => {
+            const test = fixtures_1.getApiTest('abc-def-ghi');
+            expect(utils.getExecutionRule(testRule ? Object.assign(Object.assign({}, test), { options: Object.assign(Object.assign({}, test.options), { ci: { executionRule: testRule } }) }) : test, resultRule ? { executionRule: resultRule } : {})).toEqual(expectedRule);
+        });
     });
-    test('hasTestSucceeded', () => {
-        const testConfiguration = fixtures_1.getApiTest('abc-def-ghi');
-        const passingResult = fixtures_1.getBrowserResult();
-        const passingPollResult = {
-            check: testConfiguration,
-            dc_id: 42,
-            result: passingResult,
-            resultID: '0123456789',
-            timestamp: 0,
-        };
-        const failingPollResult = {
-            check: testConfiguration,
-            dc_id: 42,
-            result: Object.assign(Object.assign({}, passingResult), { passed: false }),
-            resultID: '0123456789',
-            timestamp: 0,
-        };
-        const unhealthyPollResult = {
-            check: testConfiguration,
-            dc_id: 42,
-            result: Object.assign(Object.assign({}, passingResult), { passed: false, unhealthy: true }),
-            resultID: '0123456789',
-            timestamp: 0,
-        };
-        const endpointFailurePollResult = {
-            check: testConfiguration,
-            dc_id: 42,
-            result: Object.assign(Object.assign({}, passingResult), { passed: false, error: interfaces_1.ERRORS.ENDPOINT }),
-            resultID: '0123456789',
-            timestamp: 0,
-        };
-        const timeoutPollResult = {
-            check: testConfiguration,
-            dc_id: 42,
-            result: Object.assign(Object.assign({}, passingResult), { passed: false, error: interfaces_1.ERRORS.TIMEOUT }),
-            resultID: '0123456789',
-            timestamp: 0,
-        };
-        expect(utils.hasTestSucceeded([passingPollResult, failingPollResult], false, true)).toBeFalsy();
-        expect(utils.hasTestSucceeded([passingPollResult, unhealthyPollResult], true, true)).toBeFalsy();
-        expect(utils.hasTestSucceeded([passingPollResult, unhealthyPollResult], false, true)).toBeTruthy();
-        expect(utils.hasTestSucceeded([passingPollResult, endpointFailurePollResult], true, true)).toBeFalsy();
-        expect(utils.hasTestSucceeded([passingPollResult, endpointFailurePollResult], false, true)).toBeTruthy();
-        expect(utils.hasTestSucceeded([passingPollResult, passingPollResult], false, true)).toBeTruthy();
-        expect(utils.hasTestSucceeded([passingPollResult, timeoutPollResult], false, true)).toBeFalsy();
-        expect(utils.hasTestSucceeded([passingPollResult, timeoutPollResult], false, false)).toBeTruthy();
+    describe('getResultOutcome', () => {
+        const cases = [
+            [true, interfaces_1.ExecutionRule.BLOCKING, "passed" /* Passed */],
+            [true, interfaces_1.ExecutionRule.NON_BLOCKING, "passed-non-blocking" /* PassedNonBlocking */],
+            [false, interfaces_1.ExecutionRule.BLOCKING, "failed" /* Failed */],
+            [false, interfaces_1.ExecutionRule.NON_BLOCKING, "failed-non-blocking" /* FailedNonBlocking */],
+        ];
+        test.each(cases)('Result passed: %s, execution rule: %s. Expected outcome: %s', (resultPassed, resultRule, expectedOutcome) => {
+            jest.spyOn(utils, 'getExecutionRule').mockReturnValue(resultRule);
+            const test = fixtures_1.getApiTest('abc-def-ghi');
+            const result = fixtures_1.getApiResult('1', test);
+            result.executionRule = resultRule;
+            result.passed = resultPassed;
+            expect(utils.getResultOutcome(result)).toEqual(expectedOutcome);
+        });
     });
     describe('waitForResults', () => {
-        const mockAxiosWithDefaultResult = () => {
-            jest.spyOn(axios_1.default, 'create').mockImplementation((() => (r) => __awaiter(void 0, void 0, void 0, function* () {
-                yield utils.wait(100);
-                const results = JSON.parse(r.params.result_ids)
-                    .filter((resultId) => resultId !== 'timingOutTest')
-                    .map((resultId) => getPassingPollResult(resultId));
-                return { data: { results } };
-            })));
-        };
-        afterAll(() => {
-            jest.clearAllMocks();
+        beforeAll(() => {
+            // We still wait a few milliseconds to avoid the test going crazy on a infinite loop
+            // if case of mistakes in the code or test.
+            jest.spyOn(utils, 'wait').mockImplementation(() => new Promise((r) => setTimeout(r, 10)));
         });
-        const getTestConfig = (publicId = 'abc-def-ghi') => fixtures_1.getApiTest(publicId);
-        const getPassingPollResult = (resultId) => ({
-            check: getTestConfig(),
-            dc_id: 42,
-            result: fixtures_1.getBrowserResult({ error: interfaces_1.ERRORS.TIMEOUT, passed: false }),
-            resultID: resultId,
+        const batch = fixtures_1.getBatch();
+        const apiTest = fixtures_1.getApiTest(batch.results[0].test_public_id);
+        const result = {
+            executionRule: interfaces_1.ExecutionRule.BLOCKING,
+            location: fixtures_1.mockLocation.display_name,
+            passed: true,
+            result: fixtures_1.getBrowserServerResult({ passed: true }),
+            resultId: batch.results[0].result_id,
+            test: apiTest,
+            timedOut: false,
             timestamp: 0,
-        });
-        const getTestAndResult = (publicId = 'abc-def-ghi', resultId = '0123456789') => {
-            const triggerResult = {
-                device: 'laptop_large',
-                location: 42,
-                public_id: publicId,
-                result_id: resultId,
-            };
-            const triggerConfig = {
-                config: {},
-                id: publicId,
-                suite: 'Suite 1',
-            };
-            const passingPollResult = getPassingPollResult(resultId);
-            return { passingPollResult, triggerConfig, triggerResult };
+        };
+        const pollResult = {
+            check: result.test,
+            result: result.result,
+            resultID: result.resultId,
+            timestamp: result.timestamp,
+        };
+        const trigger = { batch_id: 'bid', locations: [fixtures_1.mockLocation] };
+        const mockApi = ({ getBatchImplementation, pollResultsImplementation, } = {}) => {
+            const getBatchMock = jest
+                .spyOn(api, 'getBatch')
+                .mockImplementation(getBatchImplementation || (() => __awaiter(void 0, void 0, void 0, function* () { return JSON.parse(JSON.stringify(batch)); })));
+            const pollResultsMock = jest
+                .spyOn(api, 'pollResults')
+                .mockImplementation(pollResultsImplementation || (() => __awaiter(void 0, void 0, void 0, function* () { return JSON.parse(JSON.stringify([pollResult])); })));
+            return { getBatchMock, pollResultsMock };
         };
         test('should poll result ids', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockAxiosWithDefaultResult();
-            const { triggerResult, passingPollResult, triggerConfig } = getTestAndResult();
-            const waitMock = jest.spyOn(utils, 'wait');
-            waitMock.mockImplementation();
-            const expectedResults = {};
-            expectedResults[triggerResult.public_id] = [passingPollResult];
-            expect(yield utils.waitForResults(api, [triggerResult], [triggerConfig], { defaultTimeout: 120000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual(expectedResults);
-            expect(fixtures_1.mockReporter.testResult).toHaveBeenCalledWith(triggerResult, passingPollResult);
+            mockApi();
+            expect(yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 120000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual([result]);
+            expect(fixtures_1.mockReporter.resultReceived).toHaveBeenCalledWith(batch.results[0]);
         }));
-        test('results should be timed-out if global pollingTimeout is exceeded', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { triggerResult } = getTestAndResult();
-            const expectedResults = {};
-            expectedResults[triggerResult.public_id] = [
-                {
-                    dc_id: triggerResult.location,
-                    result: fixtures_1.getBrowserResult({
-                        device: { height: 0, id: triggerResult.device, width: 0 },
-                        error: interfaces_1.ERRORS.TIMEOUT,
-                        passed: false,
-                    }),
-                    resultID: triggerResult.result_id,
-                    timestamp: 0,
-                },
-            ];
-            expect(yield utils.waitForResults(api, [triggerResult], [], { defaultTimeout: 0, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual(expectedResults);
+        test('results should be timed out if global pollingTimeout is exceeded', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockApi({ getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return (Object.assign(Object.assign({}, batch), { status: 'in_progress' })); }) });
+            expect(yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 0, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual([
+                Object.assign(Object.assign({}, result), { result: Object.assign(Object.assign({}, result.result), { error: 'Timeout', passed: false }), timedOut: true }),
+            ]);
         }));
-        test('results should be timeout-ed if test pollingTimeout is exceeded', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { triggerResult } = getTestAndResult();
-            const expectedResults = {};
-            expectedResults[triggerResult.public_id] = [
-                {
-                    dc_id: triggerResult.location,
-                    result: fixtures_1.getBrowserResult({
-                        device: { height: 0, id: triggerResult.device, width: 0 },
-                        error: interfaces_1.ERRORS.TIMEOUT,
-                        passed: false,
-                    }),
-                    resultID: triggerResult.result_id,
-                    timestamp: 0,
-                },
-            ];
-            const testTriggerConfig = {
-                config: { pollingTimeout: 0 },
-                id: triggerResult.public_id,
-                suite: 'Suite 1',
-            };
-            expect(yield utils.waitForResults(api, [triggerResult], [testTriggerConfig], { defaultTimeout: 120000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual(expectedResults);
+        test('results should be timed out if batch result is timed out', () => __awaiter(void 0, void 0, void 0, function* () {
+            const batchWithTimeoutResult = Object.assign(Object.assign({}, batch), { results: [Object.assign(Object.assign({}, batch.results[0]), { timed_out: true })] });
+            mockApi({ getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return batchWithTimeoutResult; }) });
+            expect(yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 120000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual([
+                Object.assign(Object.assign({}, result), { result: Object.assign(Object.assign({}, result.result), { error: 'Timeout', passed: false }), timedOut: true }),
+            ]);
+        }));
+        test('wait between batch polling', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.restoreAllMocks();
+            const waitMock = jest.spyOn(utils, 'wait').mockImplementation(() => new Promise((r) => setTimeout(r, 10)));
+            let counter = 0;
+            mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () {
+                    counter += 1;
+                    return counter === 3 ? batch : Object.assign(Object.assign({}, batch), { status: 'in_progress' });
+                }),
+            });
+            expect(yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 120000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual([result]);
+            expect(counter).toBe(3);
+            expect(waitMock).toHaveBeenCalledTimes(2);
         }));
         test('correct number of pass and timeout results', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockAxiosWithDefaultResult();
-            const { triggerResult, passingPollResult } = getTestAndResult();
-            const waitMock = jest.spyOn(utils, 'wait');
-            waitMock.mockImplementation();
-            const expectedResults = {};
-            const triggerResultPass = triggerResult;
-            const triggerResultTimeOut = Object.assign(Object.assign({}, triggerResult), { result_id: 'timingOutTest' });
-            expectedResults[triggerResult.public_id] = [
-                passingPollResult,
-                {
-                    dc_id: triggerResultTimeOut.location,
-                    result: fixtures_1.getBrowserResult({
-                        device: { height: 0, id: triggerResultTimeOut.device, width: 0 },
-                        error: interfaces_1.ERRORS.TIMEOUT,
-                        passed: false,
-                    }),
-                    resultID: triggerResultTimeOut.result_id,
-                    timestamp: 0,
-                },
-            ];
-            expect(yield utils.waitForResults(api, [triggerResultPass, triggerResultTimeOut], [], { defaultTimeout: 2000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual(expectedResults);
+            const pollTimeoutResult = Object.assign(Object.assign({}, pollResult), { resultID: 'another-id' });
+            const batchWithTimeoutResult = Object.assign(Object.assign({}, batch), { results: [batch.results[0], Object.assign(Object.assign({}, batch.results[0]), { timed_out: true, result_id: pollTimeoutResult.resultID })] });
+            mockApi({
+                getBatchImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return batchWithTimeoutResult; }),
+                pollResultsImplementation: () => __awaiter(void 0, void 0, void 0, function* () { return [pollResult, pollTimeoutResult]; }),
+            });
+            expect(yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 2000, failOnCriticalErrors: false }, fixtures_1.mockReporter)).toEqual([result, Object.assign(Object.assign({}, result), { resultId: pollTimeoutResult.resultID, timedOut: true })]);
         }));
         test('tunnel failure', () => __awaiter(void 0, void 0, void 0, function* () {
-            const waitMock = jest.spyOn(utils, 'wait');
-            waitMock.mockImplementation();
-            const { triggerResult } = getTestAndResult();
-            // Fake pollResults to not update results and iterate until the isTunnelConnected is equal to false
-            jest
-                .spyOn(axios_1.default, 'create')
-                .mockImplementation((() => (r) => __awaiter(void 0, void 0, void 0, function* () { return ({ data: { results: [] } }); })));
+            mockApi();
             const mockTunnel = {
                 keepAlive: () => __awaiter(void 0, void 0, void 0, function* () {
                     throw new Error('keepAlive failed');
                 }),
             };
-            const expectedResults = {
-                [triggerResult.public_id]: [
-                    {
-                        dc_id: triggerResult.location,
-                        result: fixtures_1.getBrowserResult({
-                            device: { height: 0, id: triggerResult.device, width: 0 },
-                            error: interfaces_1.ERRORS.TUNNEL,
-                            passed: false,
-                            tunnel: true,
-                        }),
-                        resultID: triggerResult.result_id,
-                        timestamp: 0,
-                    },
-                ],
-            };
-            expect(yield utils.waitForResults(api, [triggerResult], [], { defaultTimeout: 2000, failOnCriticalErrors: true }, fixtures_1.mockReporter, mockTunnel)).toEqual(expectedResults);
-            expect(yield utils.waitForResults(api, [triggerResult], [], { defaultTimeout: 2000, failOnCriticalErrors: false }, fixtures_1.mockReporter, mockTunnel)).toEqual(expectedResults);
+            yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 2000, failOnCriticalErrors: true }, fixtures_1.mockReporter, mockTunnel);
+            expect(fixtures_1.mockReporter.error).toBeCalledWith('The tunnel has stopped working, this may have affected the results.');
+        }));
+        test('location when tunnel', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockApi();
+            const mockTunnel = { keepAlive: () => __awaiter(void 0, void 0, void 0, function* () { return true; }) };
+            let results = yield utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 2000, failOnCriticalErrors: true }, fixtures_1.mockReporter, mockTunnel);
+            expect(results[0].location).toBe('Tunneled');
+            const newTest = Object.assign({}, result.test);
+            newTest.type = 'api';
+            newTest.subtype = 'http';
+            results = yield utils.waitForResults(api, trigger, [newTest], { maxPollingTimeout: 2000, failOnCriticalErrors: true }, fixtures_1.mockReporter, mockTunnel);
+            expect(results[0].location).toBe('Tunneled');
+            newTest.type = 'api';
+            newTest.subtype = 'ssl';
+            results = yield utils.waitForResults(api, trigger, [newTest], { failOnCriticalErrors: true, maxPollingTimeout: 2000 }, fixtures_1.mockReporter, mockTunnel);
+            expect(results[0].location).toBe('Frankfurt (AWS)');
         }));
         test('pollResults throws', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { triggerResult } = getTestAndResult();
-            jest.spyOn(utils, 'wait').mockImplementation();
-            const axiosMock = jest.spyOn(axios_1.default, 'create');
-            const serverError = new Error('Server Error');
-            serverError.response = { status: 502 };
-            axiosMock.mockImplementation((() => (r) => __awaiter(void 0, void 0, void 0, function* () {
-                throw serverError;
-            })));
-            const mockTunnel = { keepAlive: () => __awaiter(void 0, void 0, void 0, function* () { return Promise.reject(); }) };
-            const expectedResults = {
-                [triggerResult.public_id]: [
-                    {
-                        dc_id: triggerResult.location,
-                        result: fixtures_1.getBrowserResult({
-                            device: { height: 0, id: triggerResult.device, width: 0 },
-                            error: interfaces_1.ERRORS.ENDPOINT,
-                            passed: false,
-                            tunnel: true,
-                        }),
-                        resultID: triggerResult.result_id,
-                        timestamp: 0,
-                    },
-                ],
-            };
-            expect(yield utils.waitForResults(api, [triggerResult], [], { defaultTimeout: 2000, failOnCriticalErrors: false }, fixtures_1.mockReporter, mockTunnel)).toEqual(expectedResults);
-            yield expect(utils.waitForResults(api, [triggerResult], [], { defaultTimeout: 2000, failOnCriticalErrors: true }, fixtures_1.mockReporter, mockTunnel)).rejects.toThrow();
+            const { pollResultsMock } = mockApi({
+                pollResultsImplementation: () => {
+                    throw new Error('Poll results server error');
+                },
+            });
+            yield expect(utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 2000 }, fixtures_1.mockReporter)).rejects.toThrowError('Failed to poll results: Poll results server error');
+            expect(pollResultsMock).toHaveBeenCalledWith([result.resultId]);
+        }));
+        test('getBatch throws', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { getBatchMock } = mockApi({
+                getBatchImplementation: () => {
+                    throw new Error('Get batch server error');
+                },
+            });
+            yield expect(utils.waitForResults(api, trigger, [result.test], { maxPollingTimeout: 2000 }, fixtures_1.mockReporter)).rejects.toThrowError('Failed to get batch: Get batch server error');
+            expect(getBatchMock).toHaveBeenCalledWith(trigger.batch_id);
         }));
     });
     test('getStrictestExecutionRule', () => {