@datadog/datadog-ci 2.48.0 → 3.0.0

package/dist/commands/synthetics/__tests__/run-tests-lib.test.js

@@ -0,0 +1,698 @@
+"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 fs_1 = __importDefault(require("fs"));
+const fixtures_1 = require("../../../helpers/__tests__/fixtures");
+const ciUtils = __importStar(require("../../../helpers/utils"));
+const api = __importStar(require("../api"));
+const batchUtils = __importStar(require("../batch"));
+const errors_1 = require("../errors");
+const interfaces_1 = require("../interfaces");
+const default_1 = require("../reporters/default");
+const junit_1 = require("../reporters/junit");
+const appUploadReporterModule = __importStar(require("../reporters/mobile/app-upload"));
+const runTests = __importStar(require("../run-tests-lib"));
+const testUtils = __importStar(require("../test"));
+const tunnel_1 = require("../tunnel");
+const internalUtils = __importStar(require("../utils/internal"));
+const utils = __importStar(require("../utils/public"));
+const fixtures_2 = require("./fixtures");
+describe('run-test', () => {
+    beforeEach(() => {
+        jest.restoreAllMocks();
+        jest.spyOn(ciUtils, 'getConfig').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return ({}); }));
+        process.env = {};
+    });
+    describe('executeTests', () => {
+        test('should apply config override for tests triggered by public id', () => __awaiter(void 0, void 0, void 0, function* () {
+            const getTestsToTriggersMock = jest.spyOn(testUtils, 'getTestsToTrigger').mockReturnValue(Promise.resolve({
+                initialSummary: utils.createInitialSummary(),
+                overriddenTestsToTrigger: [],
+                tests: [],
+            }));
+            jest.spyOn(batchUtils, 'runTests').mockImplementation();
+            const startUrl = '{{PROTOCOL}}//myhost{{PATHNAME}}{{PARAMS}}';
+            const locations = ['location1', 'location2'];
+            const userConfigOverride = { locations, startUrl };
+            const apiHelper = {};
+            jest.spyOn(api, 'getApiHelper').mockImplementation(() => ({}));
+            yield expect(runTests.executeTests(fixtures_2.mockReporter, Object.assign(Object.assign({}, fixtures_2.ciConfig), { defaultTestOverrides: userConfigOverride, publicIds: ['aaa-aaa-aaa', 'bbb-bbb-bbb'] }))).rejects.toThrow();
+            expect(getTestsToTriggersMock).toHaveBeenCalledWith(apiHelper, expect.arrayContaining([
+                expect.objectContaining({ id: 'aaa-aaa-aaa', testOverrides: userConfigOverride }),
+                expect.objectContaining({ id: 'bbb-bbb-bbb', testOverrides: userConfigOverride }),
+            ]), expect.anything(), false, false, false);
+        }));
+        test('Use appropriate list of locations for tests triggered by public id', () => __awaiter(void 0, void 0, void 0, function* () {
+            const getTestsToTriggersMock = jest.spyOn(testUtils, 'getTestsToTrigger').mockReturnValue(Promise.resolve({
+                initialSummary: utils.createInitialSummary(),
+                overriddenTestsToTrigger: [],
+                tests: [],
+            }));
+            const apiHelper = {};
+            jest.spyOn(api, 'getApiHelper').mockImplementation(() => ({}));
+            yield expect(runTests.executeTests(fixtures_2.mockReporter, Object.assign(Object.assign({}, fixtures_2.ciConfig), { defaultTestOverrides: { locations: ['defaultTestOverrides-location-1'] }, publicIds: ['aaa-aaa-aaa', 'bbb-bbb-bbb'] }))).rejects.toThrow(new errors_1.CiError('NO_TESTS_TO_RUN'));
+            expect(getTestsToTriggersMock).toHaveBeenCalledWith(apiHelper, expect.arrayContaining([
+                expect.objectContaining({ id: 'aaa-aaa-aaa', testOverrides: { locations: ['defaultTestOverrides-location-1'] } }),
+                expect.objectContaining({ id: 'bbb-bbb-bbb', testOverrides: { locations: ['defaultTestOverrides-location-1'] } }),
+            ]), expect.anything(), false, false, false);
+        }));
+        test('should not wait for `skipped` only tests batch results', () => __awaiter(void 0, void 0, void 0, function* () {
+            const getTestsToTriggersMock = jest.spyOn(testUtils, 'getTestsToTrigger').mockReturnValue(Promise.resolve({
+                initialSummary: utils.createInitialSummary(),
+                overriddenTestsToTrigger: [],
+                tests: [],
+            }));
+            const apiHelper = {};
+            const configOverride = { executionRule: interfaces_1.ExecutionRule.SKIPPED };
+            jest.spyOn(api, 'getApiHelper').mockImplementation(() => ({}));
+            yield expect(runTests.executeTests(fixtures_2.mockReporter, Object.assign(Object.assign({}, fixtures_2.ciConfig), { defaultTestOverrides: configOverride, publicIds: ['aaa-aaa-aaa', 'bbb-bbb-bbb'] }))).rejects.toThrow(new errors_1.CiError('NO_TESTS_TO_RUN'));
+            expect(getTestsToTriggersMock).toHaveBeenCalledWith(apiHelper, expect.arrayContaining([
+                expect.objectContaining({ id: 'aaa-aaa-aaa', testOverrides: configOverride }),
+                expect.objectContaining({ id: 'bbb-bbb-bbb', testOverrides: configOverride }),
+            ]), expect.anything(), false, false, false);
+        }));
+        test('should not open tunnel if no test to run', () => __awaiter(void 0, void 0, void 0, function* () {
+            const getTestsToTriggersMock = jest.spyOn(testUtils, 'getTestsToTrigger').mockReturnValue(Promise.resolve({
+                initialSummary: utils.createInitialSummary(),
+                overriddenTestsToTrigger: [],
+                tests: [],
+            }));
+            const apiHelper = {
+                getTunnelPresignedURL: jest.fn(),
+            };
+            const configOverride = { executionRule: interfaces_1.ExecutionRule.SKIPPED };
+            jest.spyOn(api, 'getApiHelper').mockImplementation(() => apiHelper);
+            yield expect(runTests.executeTests(fixtures_2.mockReporter, Object.assign(Object.assign({}, fixtures_2.ciConfig), { defaultTestOverrides: configOverride, publicIds: ['aaa-aaa-aaa', 'bbb-bbb-bbb'], tunnel: true }))).rejects.toThrow(new errors_1.CiError('NO_TESTS_TO_RUN'));
+            expect(getTestsToTriggersMock).toHaveBeenCalledWith(apiHelper, expect.arrayContaining([
+                expect.objectContaining({ id: 'aaa-aaa-aaa', testOverrides: configOverride }),
+                expect.objectContaining({ id: 'bbb-bbb-bbb', testOverrides: configOverride }),
+            ]), expect.anything(), false, false, true);
+            expect(apiHelper.getTunnelPresignedURL).not.toHaveBeenCalled();
+        }));
+        test('open and close tunnel for successful runs', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(internalUtils, 'wait').mockImplementation(() => new Promise((res) => setTimeout(res, 10)));
+            const startTunnelSpy = jest
+                .spyOn(tunnel_1.Tunnel.prototype, 'start')
+                .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return ({ host: 'host', id: 'id', privateKey: 'key' }); }));
+            const stopTunnelSpy = jest.spyOn(tunnel_1.Tunnel.prototype, 'stop');
+            jest.spyOn(testUtils, 'getTestsToTrigger').mockReturnValue(Promise.resolve({
+                initialSummary: utils.createInitialSummary(),
+                overriddenTestsToTrigger: [],
+                tests: [{ options: { ci: { executionRule: interfaces_1.ExecutionRule.BLOCKING } }, public_id: '123-456-789' }],
+            }));
+            jest.spyOn(batchUtils, 'runTests').mockResolvedValue(fixtures_2.mockTestTriggerResponse);
+            const apiHelper = {
+                getBatch: () => ({ results: [] }),
+                getTunnelPresignedURL: () => ({ url: 'url' }),
+                pollResults: () => [(0, fixtures_2.getApiResult)('1', (0, fixtures_2.getApiTest)())],
+                triggerTests: () => fixtures_2.mockTestTriggerResponse,
+            };
+            jest.spyOn(api, 'getApiHelper').mockImplementation(() => apiHelper);
+            yield runTests.executeTests(fixtures_2.mockReporter, Object.assign(Object.assign({}, fixtures_2.ciConfig), { failOnCriticalErrors: true, publicIds: ['123-456-789'], tunnel: true }));
+            expect(startTunnelSpy).toHaveBeenCalledTimes(1);
+            expect(stopTunnelSpy).toHaveBeenCalledTimes(1);
+        }));
+        const cases = [
+            [403, 'AUTHORIZATION_ERROR'],
+            [502, 'UNAVAILABLE_TEST_CONFIG'],
+        ];
+        describe.each(cases)('%s triggers %s', (status, error) => {
+            test(`getTestsList throws - ${status}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                const apiHelper = {
+                    searchTests: jest.fn(() => {
+                        throw (0, fixtures_1.getAxiosError)(status, { message: 'Server Error' });
+                    }),
+                };
+                jest.spyOn(api, 'getApiHelper').mockImplementation(() => apiHelper);
+                yield expect(runTests.executeTests(fixtures_2.mockReporter, Object.assign(Object.assign({}, fixtures_2.ciConfig), { testSearchQuery: 'a-search-query', tunnel: true }))).rejects.toThrow(new errors_1.CriticalError(error, 'Server Error'));
+            }));
+            test(`getTestsToTrigger throws - ${status}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                const apiHelper = {
+                    getTest: jest.fn(() => {
+                        throw (0, fixtures_1.getAxiosError)(status, { errors: ['Bad Gateway'] });
+                    }),
+                };
+                jest.spyOn(api, 'getApiHelper').mockImplementation(() => apiHelper);
+                yield expect(runTests.executeTests(fixtures_2.mockReporter, Object.assign(Object.assign({}, fixtures_2.ciConfig), { publicIds: ['aaa-aaa-aaa'], tunnel: true }))).rejects.toThrow(new errors_1.CriticalError(error, 'Failed to get test: query on https://app.datadoghq.com/example returned: "Bad Gateway"\n'));
+            }));
+        });
+        test('getTunnelPresignedURL throws', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(testUtils, 'getTestsToTrigger').mockReturnValue(Promise.resolve({
+                initialSummary: utils.createInitialSummary(),
+                overriddenTestsToTrigger: [],
+                tests: [{ options: { ci: { executionRule: interfaces_1.ExecutionRule.BLOCKING } }, public_id: 'publicId' }],
+            }));
+            const apiHelper = {
+                getTunnelPresignedURL: jest.fn(() => {
+                    throw (0, fixtures_1.getAxiosError)(502, { message: 'Server Error' });
+                }),
+            };
+            jest.spyOn(api, 'getApiHelper').mockImplementation(() => apiHelper);
+            yield expect(runTests.executeTests(fixtures_2.mockReporter, Object.assign(Object.assign({}, fixtures_2.ciConfig), { publicIds: ['aaa-aaa-aaa', 'bbb-bbb-bbb'], tunnel: true }))).rejects.toThrow(new errors_1.CriticalError('UNAVAILABLE_TUNNEL_CONFIG', 'Server Error'));
+        }));
+        test('getMobileApplicationPresignedURLs throws', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mobileTest = (0, fixtures_2.getMobileTest)();
+            jest.spyOn(testUtils, 'getTestAndOverrideConfig').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
+                return Promise.resolve({
+                    overriddenConfig: { executionRule: interfaces_1.ExecutionRule.NON_BLOCKING, public_id: mobileTest.public_id },
+                    test: mobileTest,
+                });
+            }));
+            // use /dev/null to create a valid empty fs.ReadStream
+            const testStream = fs_1.default.createReadStream('/dev/null');
+            jest.spyOn(fs_1.default, 'createReadStream').mockReturnValue(testStream);
+            const { AppUploadReporter } = jest.requireActual('../reporters/mobile/app-upload');
+            jest
+                .spyOn(appUploadReporterModule, 'AppUploadReporter')
+                .mockImplementation(() => new AppUploadReporter({ stdout: { write: jest.fn() } }));
+            const apiHelper = {
+                getMobileApplicationPresignedURLs: jest.fn(() => {
+                    throw (0, fixtures_1.getAxiosError)(502, { message: 'Server Error' });
+                }),
+            };
+            jest.spyOn(api, 'getApiHelper').mockImplementation(() => apiHelper);
+            yield expect(runTests.executeTests(fixtures_2.mockReporter, Object.assign(Object.assign({}, fixtures_2.ciConfig), { defaultTestOverrides: { mobileApplicationVersionFilePath: 'filePath' }, publicIds: [mobileTest.public_id] }))).rejects.toThrow('Failed to get presigned URL: could not query https://app.datadoghq.com/example');
+        }));
+        test('uploadMobileApplicationPart throws', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mobileTest = (0, fixtures_2.getMobileTest)();
+            jest.spyOn(testUtils, 'getTestAndOverrideConfig').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
+                return Promise.resolve({
+                    overriddenConfig: { executionRule: interfaces_1.ExecutionRule.NON_BLOCKING, public_id: mobileTest.public_id },
+                    test: mobileTest,
+                });
+            }));
+            // use /dev/null to create a valid empty fs.ReadStream
+            const testStream = fs_1.default.createReadStream('/dev/null');
+            jest.spyOn(fs_1.default, 'createReadStream').mockReturnValue(testStream);
+            const { AppUploadReporter } = jest.requireActual('../reporters/mobile/app-upload');
+            jest
+                .spyOn(appUploadReporterModule, 'AppUploadReporter')
+                .mockImplementation(() => new AppUploadReporter({ stdout: { write: jest.fn() } }));
+            jest.spyOn(fs_1.default.promises, 'readFile').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return Buffer.from('aa'); }));
+            const apiHelper = {
+                getMobileApplicationPresignedURLs: jest.fn(() => fixtures_2.MOBILE_PRESIGNED_URLS_PAYLOAD),
+                uploadMobileApplicationPart: jest.fn(() => {
+                    throw (0, fixtures_1.getAxiosError)(502, { message: 'Server Error' });
+                }),
+            };
+            jest.spyOn(api, 'getApiHelper').mockImplementation(() => apiHelper);
+            yield expect(runTests.executeTests(fixtures_2.mockReporter, Object.assign(Object.assign({}, fixtures_2.ciConfig), { defaultTestOverrides: { mobileApplicationVersionFilePath: 'filePath' }, publicIds: [mobileTest.public_id] }))).rejects.toThrow('Failed to upload mobile application: could not query https://app.datadoghq.com/example');
+        }));
+        test('runTests throws', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest
+                .spyOn(tunnel_1.Tunnel.prototype, 'start')
+                .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return ({ host: 'host', id: 'id', privateKey: 'key' }); }));
+            const stopTunnelSpy = jest.spyOn(tunnel_1.Tunnel.prototype, 'stop');
+            jest.spyOn(testUtils, 'getTestsToTrigger').mockReturnValue(Promise.resolve({
+                initialSummary: utils.createInitialSummary(),
+                overriddenTestsToTrigger: [],
+                tests: [{ options: { ci: { executionRule: interfaces_1.ExecutionRule.BLOCKING } }, public_id: 'publicId' }],
+            }));
+            const apiHelper = {
+                getTunnelPresignedURL: () => ({ url: 'url' }),
+                triggerTests: jest.fn(() => {
+                    throw (0, fixtures_1.getAxiosError)(502, { errors: ['Bad Gateway'] });
+                }),
+            };
+            jest.spyOn(api, 'getApiHelper').mockImplementation(() => apiHelper);
+            yield expect(runTests.executeTests(fixtures_2.mockReporter, Object.assign(Object.assign({}, fixtures_2.ciConfig), { publicIds: ['aaa-aaa-aaa', 'bbb-bbb-bbb'], tunnel: true }))).rejects.toThrow(new errors_1.CriticalError('TRIGGER_TESTS_FAILED', '[] Failed to trigger tests: query on https://app.datadoghq.com/example returned: "Bad Gateway"\n'));
+            expect(stopTunnelSpy).toHaveBeenCalledTimes(1);
+        }));
+        test('waitForResults throws', () => __awaiter(void 0, void 0, void 0, function* () {
+            const location = {
+                display_name: 'us1',
+                id: 1,
+                is_active: true,
+                name: 'us1',
+                region: 'us1',
+            };
+            jest
+                .spyOn(tunnel_1.Tunnel.prototype, 'start')
+                .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return ({ host: 'host', id: 'id', privateKey: 'key' }); }));
+            const stopTunnelSpy = jest.spyOn(tunnel_1.Tunnel.prototype, 'stop');
+            jest.spyOn(testUtils, 'getTestsToTrigger').mockReturnValue(Promise.resolve({
+                initialSummary: utils.createInitialSummary(),
+                overriddenTestsToTrigger: [],
+                tests: [{ options: { ci: { executionRule: interfaces_1.ExecutionRule.BLOCKING } }, public_id: 'publicId' }],
+            }));
+            jest.spyOn(batchUtils, 'runTests').mockReturnValue(Promise.resolve({
+                batch_id: 'bid',
+                locations: [location],
+            }));
+            const apiHelper = {
+                getBatch: () => ({ results: [] }),
+                getTunnelPresignedURL: () => ({ url: 'url' }),
+                pollResults: jest.fn(() => {
+                    throw (0, fixtures_1.getAxiosError)(502, { errors: ['Bad Gateway'] });
+                }),
+            };
+            jest.spyOn(api, 'getApiHelper').mockImplementation(() => apiHelper);
+            yield expect(runTests.executeTests(fixtures_2.mockReporter, Object.assign(Object.assign({}, fixtures_2.ciConfig), { failOnCriticalErrors: true, publicIds: ['aaa-aaa-aaa', 'bbb-bbb-bbb'], tunnel: true }))).rejects.toThrow(new errors_1.CriticalError('POLL_RESULTS_FAILED', 'Failed to poll results: query on https://app.datadoghq.com/example returned: "Bad Gateway"\n'));
+            expect(stopTunnelSpy).toHaveBeenCalledTimes(1);
+        }));
+        test('log when selective rerun is rate-limited', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(testUtils, 'getTestsToTrigger').mockReturnValue(Promise.resolve({
+                initialSummary: utils.createInitialSummary(),
+                overriddenTestsToTrigger: [],
+                tests: [{ options: { ci: { executionRule: interfaces_1.ExecutionRule.BLOCKING } }, public_id: 'aaa-aaa-aaa' }],
+            }));
+            jest.spyOn(batchUtils, 'runTests').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
+                return ({
+                    batch_id: 'bid',
+                    locations: [],
+                    selective_rerun_rate_limited: true,
+                });
+            }));
+            const apiHelper = {
+                getBatch: () => ({ results: [] }),
+                getTunnelPresignedURL: () => ({ url: 'url' }),
+                pollResults: () => [(0, fixtures_2.getApiResult)('1', (0, fixtures_2.getApiTest)())],
+                triggerTests: () => fixtures_2.mockTestTriggerResponse,
+            };
+            jest.spyOn(api, 'getApiHelper').mockImplementation(() => apiHelper);
+            yield runTests.executeTests(fixtures_2.mockReporter, Object.assign(Object.assign({}, fixtures_2.ciConfig), { publicIds: ['aaa-aaa-aaa'], selectiveRerun: true }));
+            expect(fixtures_2.mockReporter.error).toHaveBeenCalledWith('The selective rerun feature was rate-limited. All tests will be re-run.\n\n');
+        }));
+        test('selective rerun defaults to undefined', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(testUtils, 'getTestsToTrigger').mockReturnValue(Promise.resolve({
+                initialSummary: utils.createInitialSummary(),
+                overriddenTestsToTrigger: [],
+                tests: [{ options: { ci: { executionRule: interfaces_1.ExecutionRule.BLOCKING } }, public_id: 'aaa-aaa-aaa' }],
+            }));
+            const triggerTestsSpy = jest.fn(() => fixtures_2.mockTestTriggerResponse);
+            const apiHelper = {
+                getBatch: () => ({ results: [] }),
+                getTunnelPresignedURL: () => ({ url: 'url' }),
+                pollResults: () => [(0, fixtures_2.getApiResult)('1', (0, fixtures_2.getApiTest)())],
+                triggerTests: triggerTestsSpy,
+            };
+            jest.spyOn(api, 'getApiHelper').mockImplementation(() => apiHelper);
+            yield runTests.executeTests(fixtures_2.mockReporter, Object.assign(Object.assign({}, fixtures_2.ciConfig), { publicIds: ['aaa-aaa-aaa'] }));
+            expect(triggerTestsSpy).toHaveBeenCalledWith({
+                tests: [],
+                options: {
+                    batch_timeout: fixtures_2.ciConfig.batchTimeout,
+                    selective_rerun: undefined,
+                },
+            });
+        }));
+    });
+    describe('executeWithDetails', () => {
+        beforeEach(() => {
+            jest.restoreAllMocks();
+            jest.spyOn(api, 'getApiHelper').mockImplementation(() => ({
+                getSyntheticsOrgSettings: () => ({
+                    onDemandConcurrencyCap: 1,
+                }),
+            }));
+            jest.spyOn(runTests, 'executeTests').mockReturnValue(Promise.resolve({ results: [], summary: {} }));
+            jest.spyOn(utils, 'renderResults').mockImplementation(jest.fn());
+        });
+        test('should call executeTests and renderResults', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield runTests.executeWithDetails({}, {});
+            expect(runTests.executeTests).toHaveBeenCalled();
+            expect(utils.renderResults).toHaveBeenCalled();
+        }));
+        test('should extend config', () => __awaiter(void 0, void 0, void 0, function* () {
+            const runConfig = { apiKey: 'apiKey', appKey: 'appKey' };
+            yield runTests.executeWithDetails(runConfig, {});
+            expect(runTests.executeTests).toHaveBeenCalledWith(expect.anything(), expect.objectContaining(runConfig), undefined);
+        }));
+        test('should bypass files if suite is passed', () => __awaiter(void 0, void 0, void 0, function* () {
+            const suites = [{ content: { tests: [] } }];
+            yield runTests.executeWithDetails({}, { suites });
+            expect(runTests.executeTests).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ files: [] }), suites);
+        }));
+        test('should return values returned by executeTests, and an exitCode', () => __awaiter(void 0, void 0, void 0, function* () {
+            const returnValue = yield runTests.executeWithDetails({}, {});
+            expect(returnValue.results).toBeDefined();
+            expect(returnValue.summary).toBeDefined();
+            expect(returnValue.exitCode).toBeDefined();
+        }));
+        describe('reporters', () => {
+            beforeEach(() => {
+                jest.spyOn(utils, 'getReporter').mockImplementation(jest.fn());
+            });
+            test('should use default reporter with empty config', () => __awaiter(void 0, void 0, void 0, function* () {
+                yield runTests.executeWithDetails({}, {});
+                expect(utils.getReporter).toHaveBeenCalledWith(expect.arrayContaining([expect.any(default_1.DefaultReporter)]));
+            }));
+            test('should use custom reporters', () => __awaiter(void 0, void 0, void 0, function* () {
+                const CustomReporter = {};
+                yield runTests.executeWithDetails({}, { reporters: ['junit', CustomReporter] });
+                expect(utils.getReporter).toHaveBeenCalledWith(expect.arrayContaining([expect.any(junit_1.JUnitReporter), CustomReporter]));
+            }));
+        });
+    });
+    describe('execute', () => {
+        beforeEach(() => {
+            jest.restoreAllMocks();
+            jest
+                .spyOn(runTests, 'executeWithDetails')
+                .mockReturnValue(Promise.resolve({ results: [], summary: {}, exitCode: 0 }));
+        });
+        test('should call executeWithDetails', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield runTests.execute({}, {});
+            expect(runTests.executeWithDetails).toHaveBeenCalled();
+        }));
+        test('should return the exitCode returned by executeWithDetails', () => __awaiter(void 0, void 0, void 0, function* () {
+            const returnValue = yield runTests.execute({}, {});
+            expect(returnValue).toBe(0);
+        }));
+    });
+    describe('getTriggerConfigs', () => {
+        beforeEach(() => {
+            jest.restoreAllMocks();
+        });
+        const startUrl = 'fakeUrl';
+        const locations = ['aws:ap-northeast-1'];
+        const conf1 = {
+            tests: [{ testOverrides: { deviceIds: ['chrome.laptop_large'] }, id: 'abc-def-ghi' }],
+        };
+        const conf2 = {
+            tests: [{ testOverrides: { startUrl: 'someOtherFakeUrl' }, id: 'jkl-mno-pqr' }],
+        };
+        const fakeSuites = [
+            {
+                content: conf1,
+                name: 'Suite 1',
+            },
+            {
+                content: conf2,
+                name: 'Suite 2',
+            },
+        ];
+        const fakeApi = {
+            searchTests: () => ({
+                tests: [
+                    {
+                        public_id: 'stu-vwx-yza',
+                    },
+                ],
+            }),
+        };
+        test('should extend global config and execute all tests from test config files when no clue what to run', () => __awaiter(void 0, void 0, void 0, function* () {
+            const getSuitesMock = jest.spyOn(utils, 'getSuites').mockResolvedValue(fakeSuites);
+            const defaultTestOverrides = { locations, startUrl };
+            yield expect(runTests.getTriggerConfigs(fakeApi, Object.assign(Object.assign({}, fixtures_2.ciConfig), { defaultTestOverrides }), fixtures_2.mockReporter)).resolves.toEqual([
+                {
+                    testOverrides: { deviceIds: ['chrome.laptop_large'], startUrl, locations },
+                    id: 'abc-def-ghi',
+                    suite: 'Suite 1',
+                },
+                {
+                    testOverrides: { startUrl: 'someOtherFakeUrl', locations },
+                    id: 'jkl-mno-pqr',
+                    suite: 'Suite 2',
+                },
+            ]);
+            expect(getSuitesMock).toHaveBeenCalledTimes(1);
+            expect(getSuitesMock).toHaveBeenCalledWith('{,!(node_modules)/**/}*.synthetics.json', fixtures_2.mockReporter);
+        }));
+        test('should override and execute only publicIds that were defined in the global config', () => __awaiter(void 0, void 0, void 0, function* () {
+            const getSuitesMock = jest.spyOn(utils, 'getSuites');
+            const defaultTestOverrides = { locations, startUrl };
+            yield expect(runTests.getTriggerConfigs(fakeApi, Object.assign(Object.assign({}, fixtures_2.ciConfig), { defaultTestOverrides, publicIds: ['abc-def-ghi', '123-456-789'] }), fixtures_2.mockReporter)).resolves.toEqual([
+                {
+                    testOverrides: { startUrl, locations },
+                    id: 'abc-def-ghi',
+                },
+                {
+                    testOverrides: { startUrl, locations },
+                    id: '123-456-789',
+                },
+            ]);
+            expect(getSuitesMock).toHaveBeenCalledTimes(0);
+        }));
+        test('should override and execute only publicIds that were defined in the global config and use given globs', () => __awaiter(void 0, void 0, void 0, function* () {
+            const getSuitesMock = jest.spyOn(utils, 'getSuites').mockResolvedValue(fakeSuites);
+            const defaultTestOverrides = { locations, startUrl };
+            const files = ['glob'];
+            yield expect(runTests.getTriggerConfigs(fakeApi, Object.assign(Object.assign({}, fixtures_2.ciConfig), { defaultTestOverrides,
+                files, publicIds: ['abc-def-ghi'] }), fixtures_2.mockReporter)).resolves.toEqual([
+                {
+                    testOverrides: { startUrl, locations, deviceIds: ['chrome.laptop_large'] },
+                    id: 'abc-def-ghi',
+                    suite: 'Suite 1',
+                },
+            ]);
+            expect(getSuitesMock).toHaveBeenCalledTimes(1);
+            expect(getSuitesMock).toHaveBeenCalledWith('glob', fixtures_2.mockReporter);
+        }));
+        test('should search tests and extend global config', () => __awaiter(void 0, void 0, void 0, function* () {
+            const getSuitesMock = jest.spyOn(utils, 'getSuites');
+            const defaultTestOverrides = { locations, startUrl };
+            const searchQuery = 'fake search';
+            yield expect(runTests.getTriggerConfigs(fakeApi, Object.assign(Object.assign({}, fixtures_2.ciConfig), { defaultTestOverrides, testSearchQuery: searchQuery }), fixtures_2.mockReporter)).resolves.toEqual([
+                {
+                    testOverrides: { locations, startUrl },
+                    id: 'stu-vwx-yza',
+                    suite: 'Query: fake search',
+                },
+            ]);
+            expect(getSuitesMock).toHaveBeenCalledTimes(0);
+        }));
+        test('should not use testSearchQuery if global config has defined publicIds', () => __awaiter(void 0, void 0, void 0, function* () {
+            const defaultTestOverrides = { startUrl };
+            const searchQuery = 'fake search';
+            yield expect(runTests.getTriggerConfigs(fakeApi, Object.assign(Object.assign({}, fixtures_2.ciConfig), { defaultTestOverrides, publicIds: ['abc-def-ghi'], testSearchQuery: searchQuery }), fixtures_2.mockReporter)).resolves.toEqual([
+                {
+                    testOverrides: { startUrl },
+                    id: 'abc-def-ghi',
+                },
+            ]);
+        }));
+        test('should search tests with testSearchQuery and use given globs', () => __awaiter(void 0, void 0, void 0, function* () {
+            const getSuitesMock = jest.spyOn(utils, 'getSuites').mockResolvedValue(fakeSuites);
+            const defaultTestOverrides = { startUrl };
+            const searchQuery = 'fake search';
+            const files = ['glob'];
+            yield expect(runTests.getTriggerConfigs(fakeApi, Object.assign(Object.assign({}, fixtures_2.ciConfig), { defaultTestOverrides,
+                files, testSearchQuery: searchQuery }), fixtures_2.mockReporter)).resolves.toEqual([
+                {
+                    testOverrides: { startUrl },
+                    id: 'stu-vwx-yza',
+                    suite: 'Query: fake search',
+                },
+            ]);
+            expect(getSuitesMock).toHaveBeenCalledTimes(1);
+            expect(getSuitesMock).toHaveBeenCalledWith('glob', fixtures_2.mockReporter);
+        }));
+        test('should use given globs to get tests list', () => __awaiter(void 0, void 0, void 0, function* () {
+            const getSuitesMock = jest.spyOn(utils, 'getSuites').mockResolvedValue(fakeSuites);
+            const defaultTestOverrides = { startUrl };
+            const files = ['new glob', 'another one'];
+            yield runTests.getTriggerConfigs(fakeApi, Object.assign(Object.assign({}, fixtures_2.ciConfig), { defaultTestOverrides, files }), fixtures_2.mockReporter);
+            expect(getSuitesMock).toHaveBeenCalledTimes(2);
+            expect(getSuitesMock).toHaveBeenCalledWith('new glob', fixtures_2.mockReporter);
+            expect(getSuitesMock).toHaveBeenCalledWith('another one', fixtures_2.mockReporter);
+        }));
+        test('should return tests from provided suites with overrides', () => __awaiter(void 0, void 0, void 0, function* () {
+            const getSuitesMock = jest.spyOn(utils, 'getSuites');
+            const defaultTestOverrides = { startUrl };
+            const files = [];
+            const tests = yield runTests.getTriggerConfigs(fakeApi, Object.assign(Object.assign({}, fixtures_2.ciConfig), { defaultTestOverrides, files }), fixtures_2.mockReporter, fakeSuites);
+            expect(tests).toEqual([
+                {
+                    testOverrides: { deviceIds: ['chrome.laptop_large'], startUrl },
+                    id: conf1.tests[0].id,
+                    suite: fakeSuites[0].name,
+                },
+                { testOverrides: { startUrl: 'someOtherFakeUrl' }, id: conf2.tests[0].id, suite: fakeSuites[1].name },
+            ]);
+            expect(getSuitesMock).toHaveBeenCalledTimes(0);
+        }));
+        test('should merge getSuites and user provided suites', () => __awaiter(void 0, void 0, void 0, function* () {
+            const userSuites = [fakeSuites[0]];
+            const globSuites = [fakeSuites[1]];
+            const getSuitesMock = jest.spyOn(utils, 'getSuites').mockResolvedValue(globSuites);
+            const defaultTestOverrides = { startUrl };
+            const files = ['glob'];
+            const tests = yield runTests.getTriggerConfigs(fakeApi, Object.assign(Object.assign({}, fixtures_2.ciConfig), { defaultTestOverrides, files }), fixtures_2.mockReporter, userSuites);
+            expect(tests).toEqual([
+                {
+                    testOverrides: { deviceIds: ['chrome.laptop_large'], startUrl },
+                    id: conf1.tests[0].id,
+                    suite: fakeSuites[0].name,
+                },
+                { testOverrides: { startUrl: 'someOtherFakeUrl' }, id: conf2.tests[0].id, suite: fakeSuites[1].name },
+            ]);
+            expect(getSuitesMock).toHaveBeenCalledTimes(1);
+            expect(getSuitesMock).toHaveBeenCalledWith('glob', fixtures_2.mockReporter);
+        }));
+        test('should handle test configurations with the same test ID correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const suite = {
+                name: 'Suite with duplicate IDs',
+                content: {
+                    tests: [
+                        {
+                            id: 'abc-abc-abc',
+                            testOverrides: {
+                                allowInsecureCertificates: true,
+                                basicAuth: { username: 'test', password: 'test' },
+                                body: '{"fakeContent":true}',
+                                bodyType: 'application/json',
+                                cookies: 'name1=value1;name2=value2;',
+                                setCookies: 'name1=value1 \n name2=value2; Secure',
+                                defaultStepTimeout: 15,
+                                deviceIds: ['chrome.laptop_large'],
+                                executionRule: interfaces_1.ExecutionRule.NON_BLOCKING,
+                                followRedirects: true,
+                                headers: { NEW_HEADER: 'NEW VALUE' },
+                                locations: ['aws:us-east-1'],
+                                mobileApplicationVersion: '01234567-8888-9999-abcd-efffffffffff',
+                                mobileApplicationVersionFilePath: 'path/to/application.apk',
+                                retry: { count: 2, interval: 300 },
+                                testTimeout: 300,
+                                variables: { MY_VARIABLE: 'new title' },
+                            },
+                        },
+                        {
+                            id: 'abc-abc-abc',
+                            testOverrides: {
+                                executionRule: interfaces_1.ExecutionRule.SKIPPED,
+                            },
+                        },
+                    ],
+                },
+            };
+            jest.spyOn(utils, 'getSuites').mockResolvedValue([suite]);
+            const defaultTestOverrides = { locations: ['aws:us-east-1'], startUrl: 'fakeUrl' };
+            yield expect(runTests.getTriggerConfigs(fakeApi, Object.assign(Object.assign({}, fixtures_2.ciConfig), { defaultTestOverrides }), fixtures_2.mockReporter)).resolves.toEqual([
+                {
+                    testOverrides: {
+                        allowInsecureCertificates: true,
+                        basicAuth: { username: 'test', password: 'test' },
+                        body: '{"fakeContent":true}',
+                        bodyType: 'application/json',
+                        cookies: 'name1=value1;name2=value2;',
+                        setCookies: 'name1=value1 \n name2=value2; Secure',
+                        defaultStepTimeout: 15,
+                        deviceIds: ['chrome.laptop_large'],
+                        executionRule: 'non_blocking',
+                        followRedirects: true,
+                        headers: { NEW_HEADER: 'NEW VALUE' },
+                        locations: ['aws:us-east-1'],
+                        mobileApplicationVersion: '01234567-8888-9999-abcd-efffffffffff',
+                        mobileApplicationVersionFilePath: 'path/to/application.apk',
+                        retry: { count: 2, interval: 300 },
+                        testTimeout: 300,
+                        variables: { MY_VARIABLE: 'new title' },
+                        startUrl: 'fakeUrl',
+                    },
+                    id: 'abc-abc-abc',
+                    suite: 'Suite with duplicate IDs',
+                },
+                {
+                    testOverrides: {
+                        executionRule: 'skipped',
+                        startUrl: 'fakeUrl',
+                        locations: ['aws:us-east-1'],
+                    },
+                    id: 'abc-abc-abc',
+                    suite: 'Suite with duplicate IDs',
+                },
+            ]);
+        }));
+        test('should handle local test definitions', () => __awaiter(void 0, void 0, void 0, function* () {
+            const localTestDefinition = (0, fixtures_2.getApiTest)('bbb-bbb-bbb');
+            const suite = {
+                name: 'Suite with local test definitions',
+                content: {
+                    tests: [
+                        {
+                            id: 'aaa-aaa-aaa',
+                            testOverrides: {
+                                startUrl: 'fakeUrl',
+                            },
+                        },
+                        {
+                            localTestDefinition,
+                            testOverrides: {
+                                startUrl: 'fakeUrl',
+                            },
+                        },
+                    ],
+                },
+            };
+            jest.spyOn(utils, 'getSuites').mockResolvedValue([suite]);
+            yield expect(runTests.getTriggerConfigs(fakeApi, fixtures_2.ciConfig, fixtures_2.mockReporter)).resolves.toEqual([
+                {
+                    id: 'aaa-aaa-aaa',
+                    suite: 'Suite with local test definitions',
+                    testOverrides: { startUrl: 'fakeUrl' },
+                },
+                {
+                    localTestDefinition,
+                    suite: 'Suite with local test definitions',
+                    testOverrides: { startUrl: 'fakeUrl' },
+                },
+            ]);
+        }));
+        test('should handle local test definitions selected with publicIds', () => __awaiter(void 0, void 0, void 0, function* () {
+            const localTestDefinition = (0, fixtures_2.getApiTest)('bbb-bbb-bbb');
+            const suite = {
+                name: 'Suite with local test definitions',
+                content: {
+                    tests: [
+                        {
+                            id: 'aaa-aaa-aaa',
+                            testOverrides: {
+                                startUrl: 'fakeUrl',
+                            },
+                        },
+                        {
+                            localTestDefinition,
+                            testOverrides: {
+                                startUrl: 'fakeUrl',
+                            },
+                        },
+                    ],
+                },
+            };
+            jest.spyOn(utils, 'getSuites').mockResolvedValue([suite]);
+            yield expect(runTests.getTriggerConfigs(fakeApi, Object.assign(Object.assign({}, fixtures_2.ciConfig), { files: ['glob'], publicIds: ['bbb-bbb-bbb'] }), fixtures_2.mockReporter)).resolves.toEqual([
+                {
+                    localTestDefinition,
+                    suite: 'Suite with local test definitions',
+                    testOverrides: { startUrl: 'fakeUrl' },
+                },
+            ]);
+        }));
+    });
+});
+//# sourceMappingURL=run-tests-lib.test.js.map