@datadog/datadog-ci 0.17.12 → 0.17.13

package/dist/commands/lambda/prompt.js

@@ -0,0 +1,187 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestFunctionSelection = exports.requestChangesConfirmation = exports.requestDatadogEnvVars = exports.requestAWSCredentials = exports.functionSelectionQuestion = exports.confirmationQuestion = exports.datadogEnvVarsQuestions = exports.datadogApiKeyTypeQuestion = void 0;
+const chalk_1 = require("chalk");
+const inquirer_1 = require("inquirer");
+const constants_1 = require("./constants");
+const commons_1 = require("./functions/commons");
+const awsCredentialsQuestions = [
+    {
+        // AWS_ACCESS_KEY_ID question
+        message: 'Enter AWS Access Key ID:',
+        name: constants_1.AWS_ACCESS_KEY_ID_ENV_VAR,
+        type: 'input',
+        validate: (value) => {
+            if (!value || !commons_1.sentenceMatchesRegEx(value, constants_1.AWS_ACCESS_KEY_ID_REG_EXP)) {
+                return 'Enter a valid AWS Access Key ID.';
+            }
+            return true;
+        },
+    },
+    {
+        // AWS_SECRET_ACCESS_KEY_ENV_VAR question
+        mask: true,
+        message: 'Enter AWS Secret Access Key:',
+        name: constants_1.AWS_SECRET_ACCESS_KEY_ENV_VAR,
+        type: 'password',
+        validate: (value) => {
+            if (!value || !commons_1.sentenceMatchesRegEx(value, constants_1.AWS_SECRET_ACCESS_KEY_REG_EXP)) {
+                return 'Enter a valid AWS Secret Access Key.';
+            }
+            return true;
+        },
+    },
+    {
+        // AWS_SESSION_TOKEN
+        mask: true,
+        message: 'Enter AWS Session Token (optional):',
+        name: constants_1.AWS_SESSION_TOKEN_ENV_VAR,
+        type: 'password',
+    },
+    {
+        // AWS_DEFAULT_REGION
+        choices: constants_1.AWS_REGIONS,
+        default: 0,
+        message: 'Select an AWS region:',
+        name: constants_1.AWS_DEFAULT_REGION_ENV_VAR,
+        type: 'list',
+    },
+];
+const datadogApiKeyTypeQuestion = (datadogSite) => ({
+    choices: [
+        {
+            name: `Plain text ${chalk_1.bold('API Key')} (Recommended for trial users) `,
+            value: {
+                envVar: constants_1.CI_API_KEY_ENV_VAR,
+                message: 'API Key:',
+            },
+        },
+        new inquirer_1.Separator(),
+        {
+            name: `API key encrypted with AWS Key Management Service ${chalk_1.bold('(KMS) API Key')}`,
+            value: {
+                envVar: constants_1.CI_KMS_API_KEY_ENV_VAR,
+                message: 'KMS Encrypted API Key:',
+            },
+        },
+        {
+            name: `AWS Secrets Manager ${chalk_1.bold('API Key Secret ARN')}`,
+            value: {
+                envVar: constants_1.CI_API_KEY_SECRET_ARN_ENV_VAR,
+                message: 'API Key Secret ARN:',
+            },
+        },
+    ],
+    message: `Which type of Datadog API Key you want to set? \nLearn more at ${chalk_1.blueBright(`https://app.${datadogSite}/organization-settings/api-keys`)}`,
+    name: 'type',
+    type: 'list',
+});
+exports.datadogApiKeyTypeQuestion = datadogApiKeyTypeQuestion;
+const datadogSiteQuestion = {
+    // DATADOG SITE
+    choices: constants_1.SITES,
+    message: `Select the Datadog site to send data. \nLearn more at ${chalk_1.blueBright('https://docs.datadoghq.com/getting_started/site/')}`,
+    name: constants_1.CI_SITE_ENV_VAR,
+    type: 'list',
+};
+const datadogEnvVarsQuestions = (datadogApiKeyType) => ({
+    // DATADOG API KEY given type
+    default: process.env[datadogApiKeyType.envVar],
+    message: datadogApiKeyType.message,
+    name: datadogApiKeyType.envVar,
+    type: 'input',
+    validate: (value) => {
+        if (!value || !commons_1.sentenceMatchesRegEx(value, constants_1.DATADOG_API_KEY_REG_EXP)) {
+            return 'Enter a valid Datadog API Key.';
+        }
+        return true;
+    },
+});
+exports.datadogEnvVarsQuestions = datadogEnvVarsQuestions;
+const confirmationQuestion = (message) => ({
+    message,
+    name: 'confirmation',
+    type: 'confirm',
+});
+exports.confirmationQuestion = confirmationQuestion;
+const functionSelectionQuestion = (functionNames) => ({
+    choices: functionNames,
+    message: 'Select the functions to modify',
+    name: 'functions',
+    type: 'checkbox',
+    validate: (selectedFunctions) => {
+        if (selectedFunctions.length < 1) {
+            return 'You must choose at least one function.';
+        }
+        return true;
+    },
+});
+exports.functionSelectionQuestion = functionSelectionQuestion;
+const requestAWSCredentials = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const awsCredentialsAnswers = yield inquirer_1.prompt(awsCredentialsQuestions);
+        process.env[constants_1.AWS_ACCESS_KEY_ID_ENV_VAR] = awsCredentialsAnswers[constants_1.AWS_ACCESS_KEY_ID_ENV_VAR];
+        process.env[constants_1.AWS_SECRET_ACCESS_KEY_ENV_VAR] = awsCredentialsAnswers[constants_1.AWS_SECRET_ACCESS_KEY_ENV_VAR];
+        process.env[constants_1.AWS_DEFAULT_REGION_ENV_VAR] = awsCredentialsAnswers[constants_1.AWS_DEFAULT_REGION_ENV_VAR];
+        if (awsCredentialsAnswers[constants_1.AWS_SESSION_TOKEN_ENV_VAR] !== undefined) {
+            process.env[constants_1.AWS_SESSION_TOKEN_ENV_VAR] = awsCredentialsAnswers[constants_1.AWS_SESSION_TOKEN_ENV_VAR];
+        }
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            throw Error(`Couldn't set AWS Credentials. ${e.message}`);
+        }
+    }
+});
+exports.requestAWSCredentials = requestAWSCredentials;
+const requestDatadogEnvVars = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const datadogSiteAnswer = yield inquirer_1.prompt(datadogSiteQuestion);
+        const selectedDatadogSite = datadogSiteAnswer[constants_1.CI_SITE_ENV_VAR];
+        process.env[constants_1.CI_SITE_ENV_VAR] = selectedDatadogSite;
+        const datadogApiKeyTypeAnswer = yield inquirer_1.prompt(exports.datadogApiKeyTypeQuestion(selectedDatadogSite));
+        const datadogApiKeyType = datadogApiKeyTypeAnswer.type;
+        const datadogEnvVars = yield inquirer_1.prompt(exports.datadogEnvVarsQuestions(datadogApiKeyType));
+        const selectedDatadogApiKeyEnvVar = datadogApiKeyType.envVar;
+        process.env[selectedDatadogApiKeyEnvVar] = datadogEnvVars[selectedDatadogApiKeyEnvVar];
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            throw Error(`Couldn't set Datadog Environment Variables. ${e.message}`);
+        }
+    }
+});
+exports.requestDatadogEnvVars = requestDatadogEnvVars;
+const requestChangesConfirmation = (message) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const confirmationAnswer = yield inquirer_1.prompt(exports.confirmationQuestion(message));
+        return confirmationAnswer.confirmation;
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            throw Error(`Couldn't receive confirmation. ${e.message}`);
+        }
+    }
+});
+exports.requestChangesConfirmation = requestChangesConfirmation;
+const requestFunctionSelection = (functionNames) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const selectedFunctionsAnswer = yield inquirer_1.prompt(exports.functionSelectionQuestion(functionNames));
+        return selectedFunctionsAnswer.functions;
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            throw Error(`Couldn't receive selected functions. ${e.message}`);
+        }
+    }
+});
+exports.requestFunctionSelection = requestFunctionSelection;

package/dist/commands/lambda/uninstrument.d.ts

@@ -5,6 +5,7 @@ export declare class UninstrumentCommand extends Command {
     private dryRun;
     private forwarder?;
     private functions;
+    private interactive;
     private regExPattern?;
     private region?;
     execute(): Promise<1 | 0>;

package/dist/commands/lambda/uninstrument.js

@@ -14,55 +14,91 @@ const aws_sdk_1 = require("aws-sdk");
 const chalk_1 = require("chalk");
 const clipanion_1 = require("clipanion");
 const utils_1 = require("../../helpers/utils");
+const constants_1 = require("./constants");
 const commons_1 = require("./functions/commons");
 const uninstrument_1 = require("./functions/uninstrument");
+const prompt_1 = require("./prompt");
 class UninstrumentCommand extends clipanion_1.Command {
     constructor() {
         super(...arguments);
         this.config = {
             functions: [],
-            region: process.env.AWS_DEFAULT_REGION,
+            region: process.env[constants_1.AWS_DEFAULT_REGION_ENV_VAR],
         };
         this.dryRun = false;
         this.functions = [];
+        this.interactive = false;
     }
     execute() {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             const lambdaConfig = { lambda: this.config };
             this.config = (yield utils_1.parseConfigFile(lambdaConfig, this.configPath)).lambda;
-            const hasSpecifiedFuntions = this.functions.length !== 0 || this.config.functions.length !== 0;
+            let hasSpecifiedFunctions = this.functions.length !== 0 || this.config.functions.length !== 0;
+            if (this.interactive) {
+                try {
+                    if (commons_1.isMissingAWSCredentials()) {
+                        this.context.stdout.write(`${chalk_1.bold(chalk_1.yellow('[!]'))} No existing AWS credentials found, let's set them up!\n`);
+                        yield prompt_1.requestAWSCredentials();
+                    }
+                }
+                catch (e) {
+                    this.context.stdout.write(`${chalk_1.red('[Error]')} ${e}\n`);
+                    return 1;
+                }
+                const region = (_b = (_a = this.region) !== null && _a !== void 0 ? _a : this.config.region) !== null && _b !== void 0 ? _b : process.env[constants_1.AWS_DEFAULT_REGION_ENV_VAR];
+                this.region = region;
+                if (!hasSpecifiedFunctions) {
+                    try {
+                        const lambda = new aws_sdk_1.Lambda({ region });
+                        this.context.stdout.write('Fetching Lambda functions, this might take a while.\n');
+                        const functionNames = (_c = (yield commons_1.getAllLambdaFunctionConfigs(lambda)).map((config) => config.FunctionName).sort()) !== null && _c !== void 0 ? _c : [];
+                        if (functionNames.length === 0) {
+                            this.context.stdout.write(`${chalk_1.red('[Error]')} Couldn't find any Lambda functions in the specified region.\n`);
+                            return 1;
+                        }
+                        const functions = yield prompt_1.requestFunctionSelection(functionNames);
+                        this.functions = functions;
+                    }
+                    catch (err) {
+                        this.context.stdout.write(`${chalk_1.red('[Error]')} Couldn't fetch Lambda functions. ${err}\n`);
+                        return 1;
+                    }
+                }
+            }
+            hasSpecifiedFunctions = this.functions.length !== 0 || this.config.functions.length !== 0;
             const hasSpecifiedRegExPattern = this.regExPattern !== undefined && this.regExPattern !== '';
-            if (!hasSpecifiedFuntions && !hasSpecifiedRegExPattern) {
-                this.context.stdout.write('No functions specified for un-instrumentation.\n');
+            if (!hasSpecifiedFunctions && !hasSpecifiedRegExPattern) {
+                this.context.stdout.write(`${chalk_1.red('[Error]')} No functions specified for un-instrumentation.\n`);
                 return 1;
             }
             const configGroups = [];
             // Fetch lambda function configurations that are
             // available to be un-instrumented.
             if (hasSpecifiedRegExPattern) {
-                if (hasSpecifiedFuntions) {
+                if (hasSpecifiedFunctions) {
                     const usedCommand = this.functions.length !== 0 ? '"--functions"' : 'Functions in config file';
-                    this.context.stdout.write(`${usedCommand} and "--functions-regex" should not be used at the same time.\n`);
+                    this.context.stdout.write(`${chalk_1.red('[Error]')} ${usedCommand} and "--functions-regex" should not be used at the same time.\n`);
                     return 1;
                 }
                 if (this.regExPattern.match(':')) {
-                    this.context.stdout.write(`"--functions-regex" isn't meant to be used with ARNs.\n`);
+                    this.context.stdout.write(`${chalk_1.red('[Error]')} "--functions-regex" isn't meant to be used with ARNs.\n`);
                     return 1;
                 }
                 const region = this.region || this.config.region;
                 if (!region) {
-                    this.context.stdout.write('No default region specified. Use `-r`, `--region`.');
+                    this.context.stdout.write(`${chalk_1.red('[Error]')} No default region specified. Use \`-r\`, \`--region\`.`);
                     return 1;
                 }
                 try {
                     const cloudWatchLogs = new aws_sdk_1.CloudWatchLogs({ region });
                     const lambda = new aws_sdk_1.Lambda({ region });
-                    this.context.stdout.write('Fetching lambda functions, this might take a while.\n');
+                    this.context.stdout.write('Fetching Lambda functions, this might take a while.\n');
                     const configs = yield uninstrument_1.getUninstrumentedFunctionConfigsFromRegEx(lambda, cloudWatchLogs, this.regExPattern, this.forwarder);
                     configGroups.push({ configs, lambda, cloudWatchLogs });
                 }
                 catch (err) {
-                    this.context.stdout.write(`Couldn't fetch lambda functions. ${err}\n`);
+                    this.context.stdout.write(`${chalk_1.red('[Error]')} Couldn't fetch Lambda functions. ${err}\n`);
                     return 1;
                 }
             }
@@ -72,7 +108,7 @@ class UninstrumentCommand extends clipanion_1.Command {
                     functionGroups = commons_1.collectFunctionsByRegion(this.functions.length !== 0 ? this.functions : this.config.functions, this.region || this.config.region);
                 }
                 catch (err) {
-                    this.context.stdout.write(`Couldn't group functions. ${err}`);
+                    this.context.stdout.write(`${chalk_1.red('[Error]')} Couldn't group functions. ${err}`);
                     return 1;
                 }
                 for (const [region, functionARNs] of Object.entries(functionGroups)) {
@@ -83,7 +119,7 @@ class UninstrumentCommand extends clipanion_1.Command {
                         configGroups.push({ configs, lambda, cloudWatchLogs });
                     }
                     catch (err) {
-                        this.context.stdout.write(`${chalk_1.red('[Error]')} Couldn't fetch lambda functions. ${err}\n`);
+                        this.context.stdout.write(`${chalk_1.red('[Error]')} Couldn't fetch Lambda functions. ${err}\n`);
                         return 1;
                     }
                 }
@@ -93,6 +129,15 @@ class UninstrumentCommand extends clipanion_1.Command {
             if (this.dryRun || configList.length === 0) {
                 return 0;
             }
+            const willUpdate = commons_1.willUpdateFunctionConfigs(configList);
+            if (this.interactive && willUpdate) {
+                this.context.stdout.write(`${chalk_1.yellow('[!]')} Confirmation needed.\n`);
+                const isConfirmed = yield prompt_1.requestChangesConfirmation('Do you want to apply the changes?');
+                if (!isConfirmed) {
+                    return 0;
+                }
+                this.context.stdout.write(`${chalk_1.yellow('[!]')} Uninstrumenting functions.\n`);
+            }
             // Un-instrument functions.
             const promises = Object.values(configGroups).map((group) => {
                 commons_1.updateLambdaFunctionConfigs(group.lambda, group.cloudWatchLogs, group.configs);
@@ -108,18 +153,9 @@ class UninstrumentCommand extends clipanion_1.Command {
         });
     }
     printPlannedActions(configs) {
-        var _a;
         const prefix = this.dryRun ? chalk_1.bold(chalk_1.cyan('[Dry Run] ')) : '';
-        let anyUpdates = false;
-        for (const config of configs) {
-            if (config.updateRequest !== undefined ||
-                ((_a = config.logGroupConfiguration) === null || _a === void 0 ? void 0 : _a.deleteSubscriptionFilterRequest) !== undefined ||
-                (config === null || config === void 0 ? void 0 : config.tagConfiguration) !== undefined) {
-                anyUpdates = true;
-                break;
-            }
-        }
-        if (!anyUpdates) {
+        const willUpdate = commons_1.willUpdateFunctionConfigs(configs);
+        if (!willUpdate) {
             this.context.stdout.write(`${prefix}No updates will be applied\n`);
             return;
         }
@@ -149,18 +185,20 @@ UninstrumentCommand.addOption('region', clipanion_1.Command.String('-r,--region'
 UninstrumentCommand.addOption('configPath', clipanion_1.Command.String('--config'));
 UninstrumentCommand.addOption('dryRun', clipanion_1.Command.Boolean('-d,--dry'));
 UninstrumentCommand.addOption('forwarder', clipanion_1.Command.String('--forwarder'));
-UninstrumentCommand.addOption('regExPattern', clipanion_1.Command.String('--functions-regex'));
+UninstrumentCommand.addOption('regExPattern', clipanion_1.Command.String('--functions-regex,--functionsRegex'));
+UninstrumentCommand.addOption('interactive', clipanion_1.Command.Boolean('-i,--interactive'));
 /**
  * Commands that are not really in use, but to
  * make uninstrumentation easier for the user.
  */
-UninstrumentCommand.addOption('extensionVersion', clipanion_1.Command.String('-e,--extensionVersion', { hidden: true }));
-UninstrumentCommand.addOption('layerVersion', clipanion_1.Command.String('-v,--layerVersion', { hidden: true }));
+UninstrumentCommand.addOption('extensionVersion', clipanion_1.Command.String('-e,--extension-version,--extensionVersion', { hidden: true }));
+UninstrumentCommand.addOption('layerVersion', clipanion_1.Command.String('-v,--layer-version,--layerVersion', { hidden: true }));
 UninstrumentCommand.addOption('tracing', clipanion_1.Command.String('--tracing', { hidden: true }));
-UninstrumentCommand.addOption('mergeXrayTraces', clipanion_1.Command.String('--mergeXrayTraces', { hidden: true }));
-UninstrumentCommand.addOption('flushMetricsToLogs', clipanion_1.Command.String('--flushMetricsToLogs', { hidden: true }));
-UninstrumentCommand.addOption('logLevel', clipanion_1.Command.String('--logLevel', { hidden: true }));
+UninstrumentCommand.addOption('mergeXrayTraces', clipanion_1.Command.String('--merge-xray-traces,--mergeXrayTraces', { hidden: true }));
+UninstrumentCommand.addOption('flushMetricsToLogs', clipanion_1.Command.String('--flush-metrics-to-logs,--flushMetricsToLogs', { hidden: true }));
+UninstrumentCommand.addOption('logLevel', clipanion_1.Command.String('--log-level,--logLevel', { hidden: true }));
 UninstrumentCommand.addOption('service', clipanion_1.Command.String('--service', { hidden: true }));
 UninstrumentCommand.addOption('environment', clipanion_1.Command.String('--env', { hidden: true }));
 UninstrumentCommand.addOption('version', clipanion_1.Command.String('--version', { hidden: true }));
-UninstrumentCommand.addOption('extraTags', clipanion_1.Command.String('--extra-tags', { hidden: true }));
+UninstrumentCommand.addOption('extraTags', clipanion_1.Command.String('--extra-tags,--extraTags', { hidden: true }));
+UninstrumentCommand.addOption('captureLambdaPayload', clipanion_1.Command.String('--capture-lambda-payload,--captureLambdaPayload', { hidden: true }));

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

@@ -144,6 +144,7 @@ describe('run-test', () => {
                 publicIds: ['ran-dom-id'],
                 subdomain: 'ppa',
                 tunnel: true,
+                variableStrings: [],
             };
             jest.spyOn(ciUtils, 'getConfig').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return overrideConfigFile; }));
             const command = new command_1.RunTestCommand();

package/dist/commands/synthetics/__tests__/fixtures.js

@@ -54,6 +54,7 @@ exports.ciConfig = {
     publicIds: [],
     subdomain: 'app',
     tunnel: false,
+    variableStrings: [],
 };
 const getApiTest = (publicId) => ({
     config: {

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

@@ -32,6 +32,7 @@ const ciUtils = __importStar(require("../../../helpers/utils"));
 const errors_1 = require("../errors");
 const interfaces_1 = require("../interfaces");
 const runTests = __importStar(require("../run-test"));
+const tunnel_1 = require("../tunnel");
 const utils = __importStar(require("../utils"));
 const fixtures_1 = require("./fixtures");
 describe('run-test', () => {
@@ -95,6 +96,39 @@ describe('run-test', () => {
             ]), expect.anything());
             expect(apiHelper.getPresignedURL).not.toHaveBeenCalled();
         }));
+        test('open and close tunnel for successful runs', () => __awaiter(void 0, void 0, void 0, function* () {
+            const location = {
+                display_name: 'us1',
+                id: 1,
+                is_active: true,
+                name: 'us1',
+                region: 'us1',
+            };
+            jest.spyOn(utils, '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(utils, 'getTestsToTrigger').mockReturnValue(Promise.resolve({
+                overriddenTestsToTrigger: [],
+                summary: utils.createSummary(),
+                tests: [{ options: { ci: { executionRule: interfaces_1.ExecutionRule.BLOCKING } }, public_id: '123-456-789' }],
+            }));
+            jest.spyOn(utils, 'runTests').mockReturnValue(Promise.resolve({
+                locations: [location],
+                results: [{ device: 'chrome_laptop.large', location: 1, public_id: '123-456-789', result_id: '1' }],
+                triggered_check_ids: [],
+            }));
+            const apiHelper = {
+                getPresignedURL: () => ({ url: 'url' }),
+                pollResults: () => fixtures_1.mockPollResultResponse,
+                triggerTests: () => fixtures_1.mockTestTriggerResponse,
+            };
+            jest.spyOn(runTests, 'getApiHelper').mockImplementation(() => apiHelper);
+            yield runTests.executeTests(fixtures_1.mockReporter, Object.assign(Object.assign({}, fixtures_1.ciConfig), { failOnCriticalErrors: true, publicIds: ['123-456-789'], tunnel: true }));
+            expect(startTunnelSpy).toHaveBeenCalledTimes(1);
+            expect(stopTunnelSpy).toHaveBeenCalledTimes(1);
+        }));
         test('getTestsList throws', () => __awaiter(void 0, void 0, void 0, function* () {
             const serverError = new Error('Server Error');
             serverError.response = { data: { errors: ['Bad Gateway'] }, status: 502 };
@@ -137,6 +171,10 @@ describe('run-test', () => {
             yield expect(runTests.executeTests(fixtures_1.mockReporter, Object.assign(Object.assign({}, fixtures_1.ciConfig), { publicIds: ['public-id-1', 'public-id-2'], tunnel: true }))).rejects.toMatchError(new errors_1.CriticalError('UNAVAILABLE_TUNNEL_CONFIG'));
         }));
         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(utils, 'getTestsToTrigger').mockReturnValue(Promise.resolve({
                 overriddenTestsToTrigger: [],
                 summary: utils.createSummary(),
@@ -146,12 +184,14 @@ describe('run-test', () => {
             serverError.response = { data: { errors: ['Bad Gateway'] }, status: 502 };
             serverError.config = { baseURL: 'baseURL', url: 'url' };
             const apiHelper = {
+                getPresignedURL: () => ({ url: 'url' }),
                 triggerTests: jest.fn(() => {
                     throw serverError;
                 }),
             };
             jest.spyOn(runTests, 'getApiHelper').mockImplementation(() => apiHelper);
-            yield expect(runTests.executeTests(fixtures_1.mockReporter, Object.assign(Object.assign({}, fixtures_1.ciConfig), { publicIds: ['public-id-1', 'public-id-2'] }))).rejects.toMatchError(new errors_1.CriticalError('TRIGGER_TESTS_FAILED'));
+            yield expect(runTests.executeTests(fixtures_1.mockReporter, Object.assign(Object.assign({}, fixtures_1.ciConfig), { publicIds: ['public-id-1', 'public-id-2'], tunnel: true }))).rejects.toMatchError(new errors_1.CriticalError('TRIGGER_TESTS_FAILED'));
+            expect(stopTunnelSpy).toHaveBeenCalledTimes(1);
         }));
         test('waitForResults throws', () => __awaiter(void 0, void 0, void 0, function* () {
             const location = {
@@ -161,6 +201,10 @@ describe('run-test', () => {
                 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(utils, 'getTestsToTrigger').mockReturnValue(Promise.resolve({
                 overriddenTestsToTrigger: [],
                 summary: utils.createSummary(),
@@ -175,12 +219,14 @@ describe('run-test', () => {
             serverError.response = { data: { errors: ['Bad Gateway'] }, status: 502 };
             serverError.config = { baseURL: 'baseURL', url: 'url' };
             const apiHelper = {
+                getPresignedURL: () => ({ url: 'url' }),
                 pollResults: jest.fn(() => {
                     throw serverError;
                 }),
             };
             jest.spyOn(runTests, 'getApiHelper').mockImplementation(() => apiHelper);
-            yield expect(runTests.executeTests(fixtures_1.mockReporter, Object.assign(Object.assign({}, fixtures_1.ciConfig), { failOnCriticalErrors: true, publicIds: ['public-id-1', 'public-id-2'] }))).rejects.toMatchError(new errors_1.CriticalError('POLL_RESULTS_FAILED'));
+            yield expect(runTests.executeTests(fixtures_1.mockReporter, Object.assign(Object.assign({}, fixtures_1.ciConfig), { failOnCriticalErrors: true, publicIds: ['public-id-1', 'public-id-2'], tunnel: true }))).rejects.toMatchError(new errors_1.CriticalError('POLL_RESULTS_FAILED'));
+            expect(stopTunnelSpy).toHaveBeenCalledTimes(1);
         }));
     });
     describe('getDatadogHost', () => {

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

@@ -625,4 +625,15 @@ describe('utils', () => {
             expect(counter).toBe(3);
         }));
     });
+    test('parseVariablesFromCli', () => {
+        const mockLogFunction = (message) => undefined;
+        expect(utils.parseVariablesFromCli(['TEST=42'], mockLogFunction)).toEqual({ TEST: '42' });
+        expect(utils.parseVariablesFromCli(['TEST=42 with some spaces'], mockLogFunction)).toEqual({
+            TEST: '42 with some spaces',
+        });
+        expect(utils.parseVariablesFromCli(['TEST=42=43=44'], mockLogFunction)).toEqual({ TEST: '42=43=44' });
+        expect(utils.parseVariablesFromCli(['TEST='], mockLogFunction)).toEqual({ TEST: '' });
+        expect(utils.parseVariablesFromCli([''], mockLogFunction)).toBeUndefined();
+        expect(utils.parseVariablesFromCli(undefined, mockLogFunction)).toBeUndefined();
+    });
 });

package/dist/commands/synthetics/command.d.ts

@@ -17,6 +17,7 @@ export declare class RunTestCommand extends Command {
     private subdomain?;
     private testSearchQuery?;
     private tunnel?;
+    private variableStrings?;
     execute(): Promise<1 | 0>;
     private getAppBaseURL;
     private renderResults;

package/dist/commands/synthetics/command.js

@@ -38,6 +38,7 @@ exports.DEFAULT_COMMAND_CONFIG = {
     publicIds: [],
     subdomain: 'app',
     tunnel: false,
+    variableStrings: [],
 };
 class RunTestCommand extends clipanion_1.Command {
     constructor() {
@@ -190,6 +191,10 @@ class RunTestCommand extends clipanion_1.Command {
                 testSearchQuery: this.testSearchQuery,
                 tunnel: this.tunnel,
             }));
+            // Override with Global CLI parameters
+            this.config.global = deep_extend_1.default(this.config.global, utils_1.removeUndefinedValues({
+                variables: utils_2.parseVariablesFromCli(this.variableStrings, (log) => { var _a; return (_a = this.reporter) === null || _a === void 0 ? void 0 : _a.log(log); }),
+            }));
             if (typeof this.config.files === 'string') {
                 this.reporter.log('[DEPRECATED] "files" should be an array of string instead of a string.\n');
                 this.config.files = [this.config.files];
@@ -217,14 +222,15 @@ exports.RunTestCommand = RunTestCommand;
 RunTestCommand.addPath('synthetics', 'run-tests');
 RunTestCommand.addOption('apiKey', clipanion_1.Command.String('--apiKey'));
 RunTestCommand.addOption('appKey', clipanion_1.Command.String('--appKey'));
-RunTestCommand.addOption('failOnCriticalErrors', clipanion_1.Command.Boolean('--failOnCriticalErrors'));
 RunTestCommand.addOption('configPath', clipanion_1.Command.String('--config'));
 RunTestCommand.addOption('datadogSite', clipanion_1.Command.String('--datadogSite'));
-RunTestCommand.addOption('files', clipanion_1.Command.Array('-f,--files'));
+RunTestCommand.addOption('failOnCriticalErrors', clipanion_1.Command.Boolean('--failOnCriticalErrors'));
 RunTestCommand.addOption('failOnTimeout', clipanion_1.Command.Boolean('--failOnTimeout'));
+RunTestCommand.addOption('files', clipanion_1.Command.Array('-f,--files'));
+RunTestCommand.addOption('jUnitReport', clipanion_1.Command.String('-j,--jUnitReport'));
 RunTestCommand.addOption('publicIds', clipanion_1.Command.Array('-p,--public-id'));
-RunTestCommand.addOption('testSearchQuery', clipanion_1.Command.String('-s,--search'));
+RunTestCommand.addOption('runName', clipanion_1.Command.String('-n,--runName'));
 RunTestCommand.addOption('subdomain', clipanion_1.Command.Boolean('--subdomain'));
+RunTestCommand.addOption('testSearchQuery', clipanion_1.Command.String('-s,--search'));
 RunTestCommand.addOption('tunnel', clipanion_1.Command.Boolean('-t,--tunnel'));
-RunTestCommand.addOption('jUnitReport', clipanion_1.Command.String('-j,--jUnitReport'));
-RunTestCommand.addOption('runName', clipanion_1.Command.String('-n,--runName'));
+RunTestCommand.addOption('variableStrings', clipanion_1.Command.Array('-v,--variable'));

package/dist/commands/synthetics/interfaces.d.ts

@@ -179,12 +179,16 @@ export declare enum Operator {
     doesNotContain = "doesNotContain",
     is = "is",
     isNot = "isNot",
+    isInLessThan = "isInLessThan",
+    isInMoreThan = "isInMoreThan",
     lessThan = "lessThan",
+    lessThanOrEqual = "lessThanOrEqual",
+    moreThan = "moreThan",
+    moreThanOrEqual = "moreThanOrEqual",
     matches = "matches",
     doesNotMatch = "doesNotMatch",
-    validates = "validates",
-    isInMoreThan = "isInMoreThan",
-    isInLessThan = "isInLessThan"
+    validatesJSONPath = "validatesJSONPath",
+    validatesXPath = "validatesXPath"
 }
 export interface User {
     email: string;
@@ -335,6 +339,7 @@ export interface SyntheticsCIConfig {
     subdomain: string;
     testSearchQuery?: string;
     tunnel: boolean;
+    variableStrings: string[];
 }
 export interface CommandConfig extends SyntheticsCIConfig {
     failOnTimeout: boolean;

package/dist/commands/synthetics/interfaces.js

@@ -13,12 +13,16 @@ var Operator;
     Operator["doesNotContain"] = "doesNotContain";
     Operator["is"] = "is";
     Operator["isNot"] = "isNot";
+    Operator["isInLessThan"] = "isInLessThan";
+    Operator["isInMoreThan"] = "isInMoreThan";
     Operator["lessThan"] = "lessThan";
+    Operator["lessThanOrEqual"] = "lessThanOrEqual";
+    Operator["moreThan"] = "moreThan";
+    Operator["moreThanOrEqual"] = "moreThanOrEqual";
     Operator["matches"] = "matches";
     Operator["doesNotMatch"] = "doesNotMatch";
-    Operator["validates"] = "validates";
-    Operator["isInMoreThan"] = "isInMoreThan";
-    Operator["isInLessThan"] = "isInLessThan";
+    Operator["validatesJSONPath"] = "validatesJSONPath";
+    Operator["validatesXPath"] = "validatesXPath";
 })(Operator = exports.Operator || (exports.Operator = {}));
 var ExecutionRule;
 (function (ExecutionRule) {

package/dist/commands/synthetics/reporters/default.js

@@ -50,9 +50,13 @@ const readableOperation = {
     [interfaces_1.Operator.lessThan]: 'should be less than',
     [interfaces_1.Operator.matches]: 'should match',
     [interfaces_1.Operator.doesNotMatch]: 'should not match',
-    [interfaces_1.Operator.validates]: 'will expire in less than',
     [interfaces_1.Operator.isInLessThan]: 'will expire in less than',
     [interfaces_1.Operator.isInMoreThan]: 'will expire in more than',
+    [interfaces_1.Operator.lessThanOrEqual]: 'should be less than or equal to',
+    [interfaces_1.Operator.moreThan]: 'should be more than',
+    [interfaces_1.Operator.moreThanOrEqual]: 'should be less than or equal to',
+    [interfaces_1.Operator.validatesJSONPath]: 'assert on JSONPath extracted value',
+    [interfaces_1.Operator.validatesXPath]: 'assert on XPath extracted value',
 };
 const renderApiError = (errorCode, errorMessage, color) => {
     if (errorCode === 'INCORRECT_ASSERTION') {

package/dist/commands/synthetics/run-test.js

@@ -98,9 +98,11 @@ const executeTests = (reporter, config) => __awaiter(void 0, void 0, void 0, fun
     }
     catch (error) {
         const isCriticalError = api_1.is5xxError(error);
-        yield stopTunnel();
         throw new (isCriticalError ? errors_1.CriticalError : errors_1.CiError)('POLL_RESULTS_FAILED');
     }
+    finally {
+        yield stopTunnel();
+    }
     return { results, summary, tests, triggers };
 });
 exports.executeTests = executeTests;