@gatling.io/cli 3.11.7 → 3.12.0

package/target/commands/options.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForRunEndOptionValue = exports.waitForRunEndOption = exports.runDescriptionOptionValue = exports.runDescriptionOption = exports.runTitleOptionValue = exports.runTitleOption = exports.enterpriseSimulationOptionValue = exports.enterpriseSimulationOption = exports.packageDescriptorFilenameOptionValue = exports.packageDescriptorFilenameOption = exports.controlPlaneUrlOptionValue = exports.controlPlaneUrlOption = exports.apiTokenOptionValue = exports.apiTokenOption = exports.urlOptionValue = exports.urlOption = exports.parseRunParametersArgument = exports.runParametersArgument = exports.nonInteractiveOptionValue = exports.nonInteractiveOption = exports.memoryOptionValue = exports.memoryOption = exports.jvmClasspathMandatoryOptionValue = exports.jvmClasspathMandatoryOption = exports.graalvmHomeMandatoryOptionValue = exports.graalvmHomeMandatoryOption = exports.typescriptOptionValueWithDefaults = exports.typescriptOption = exports.resultsFolderOptionValue = exports.resultsFolderOption = exports.resourcesFolderOptionValue = exports.resourcesFolderOption = exports.packageFileOptionValue = exports.packageFileOption = exports.bundleFileOptionValue = exports.bundleFileOption = exports.simulationMandatoryOptionValue = exports.simulationMandatoryOption = exports.simulationOptionValueWithDefaults = exports.simulationOption = exports.sourcesFolderOptionValue = exports.sourcesFolderOption = exports.gatlingHomeOptionValueWithDefaults = exports.gatlingHomeOption = void 0;
+const commander_1 = require("commander");
+const os_1 = __importDefault(require("os"));
+const readline_1 = require("../readline");
+const log_1 = require("../log");
+const getStringValueOptional = (option) => (options) => {
+    const value = options[option.attributeName()];
+    if (typeof value === "string" || typeof value === "undefined") {
+        return value;
+    }
+    else {
+        throw Error(`Expected type string|undefined for attribute ${option.attributeName()}, got ${typeof value} - please report this as a bug.`);
+    }
+};
+const getStringValueMandatory = (option) => (options) => {
+    const value = options[option.attributeName()];
+    if (typeof value === "string") {
+        return value;
+    }
+    else {
+        throw Error(`Expected type string for attribute ${option.attributeName()}, got ${typeof value} - please report this as a bug.`);
+    }
+};
+const getBooleanValueOptional = (option) => (options) => {
+    const value = options[option.attributeName()];
+    if (typeof value === "boolean" || typeof value === "undefined") {
+        return value;
+    }
+    else {
+        throw Error(`Expected type boolean|undefined for attribute ${option.attributeName()}, got ${typeof value} - please report this as a bug.`);
+    }
+};
+const getBooleanValueMandatory = (option) => (options) => {
+    const value = options[option.attributeName()];
+    if (typeof value === "boolean") {
+        return value;
+    }
+    else {
+        throw Error(`Expected type boolean for attribute ${option.attributeName()}, got ${typeof value} - please report this as a bug.`);
+    }
+};
+const getNumberValueOptional = (option) => (options) => {
+    const value = options[option.attributeName()];
+    if (typeof value === "number" || typeof value === "undefined") {
+        return value;
+    }
+    else {
+        throw Error(`Expected type number|undefined for attribute ${option.attributeName()}, got ${typeof value} - please report this as a bug.`);
+    }
+};
+exports.gatlingHomeOption = new commander_1.Option("--gatling-home <value>", 'The folder used to download and install Gatling components (default: "~/.gatling")');
+const gatlingHomeOptionValueWithDefaults = (options) => getStringValueOptional(exports.gatlingHomeOption)(options) || `${os_1.default.homedir()}/.gatling`;
+exports.gatlingHomeOptionValueWithDefaults = gatlingHomeOptionValueWithDefaults;
+exports.sourcesFolderOption = new commander_1.Option("--sources-folder <value>", "The sources folder path").default("src");
+exports.sourcesFolderOptionValue = getStringValueMandatory(exports.sourcesFolderOption);
+exports.simulationOption = new commander_1.Option("--simulation <value>", "The simulation entry point function name (default: if only one *.gatling.js or *.gatling.ts file is found, will execute that simulation)");
+const simulationOptionValueWithDefaults = (options, simulationsFound, interactive) => {
+    const declaredSimulation = getStringValueOptional(exports.simulationOption)(options);
+    if (declaredSimulation !== undefined) {
+        return declaredSimulation;
+    }
+    else if (simulationsFound.length === 1) {
+        return simulationsFound[0].name;
+    }
+    else if (simulationsFound.length === 0) {
+        throw new Error("No simulation found, simulations must be defined in a <simulation name>.gatling.js or <simulation name>.gatling.ts file)");
+    }
+    else if (interactive) {
+        const idx = (0, readline_1.keyInSelectPaginated)(simulationsFound.map((s) => s.name).sort((a, b) => a.localeCompare(b)), "Choose a simulation to run");
+        if (idx >= 0) {
+            const simulation = simulationsFound[idx].name;
+            log_1.logger.info(`Simulation '${simulation}' was chosen.`);
+            return simulation;
+        }
+        else {
+            throw new Error("Simulation choice was cancelled.");
+        }
+    }
+    else {
+        throw new Error(`Several simulations found, specify one using the --simulation option (available simulations: ${simulationsFound.map((s) => s.name)})`);
+    }
+};
+exports.simulationOptionValueWithDefaults = simulationOptionValueWithDefaults;
+exports.simulationMandatoryOption = new commander_1.Option("--simulation <value>", "The simulation entry point function name").makeOptionMandatory(true);
+exports.simulationMandatoryOptionValue = getStringValueMandatory(exports.simulationMandatoryOption);
+exports.bundleFileOption = new commander_1.Option("--bundle-file <value>", "The target bundle file path when building simulations (must have a .js extension)")
+    .default("target/bundle.js")
+    .argParser((value) => {
+    if (!value.endsWith(".js")) {
+        throw Error(`'${value}' is not a valid bundle file path: should have a .js extension`);
+    }
+    return value;
+});
+exports.bundleFileOptionValue = getStringValueMandatory(exports.bundleFileOption);
+exports.packageFileOption = new commander_1.Option("--package-file <value>", "The target package file path when packaging simulations for Gatling Enterprise (must have a .zip extension)")
+    .default("target/package.zip")
+    .argParser((value) => {
+    if (!value.endsWith(".zip")) {
+        throw Error(`'${value}' is not a valid package file path: should have a .zip extension`);
+    }
+    return value;
+});
+exports.packageFileOptionValue = getStringValueMandatory(exports.packageFileOption);
+exports.resourcesFolderOption = new commander_1.Option("--resources-folder <value>", "The resources folder path").default("resources");
+exports.resourcesFolderOptionValue = getStringValueMandatory(exports.resourcesFolderOption);
+exports.resultsFolderOption = new commander_1.Option("--results-folder <value>", "The results folder path").default("target/gatling");
+exports.resultsFolderOptionValue = getStringValueMandatory(exports.resultsFolderOption);
+exports.typescriptOption = new commander_1.Option("--typescript", "Use the typescript compiler to compile your code (default: true if the sourcesFolder contains any *.gatling.ts file, false otherwise)");
+const typescriptOptionValueWithDefaults = (options, simulationsFound) => {
+    const value = getBooleanValueOptional(exports.typescriptOption)(options);
+    return value !== undefined ? value : simulationsFound.findIndex((s) => s.type === "typescript") >= 0;
+};
+exports.typescriptOptionValueWithDefaults = typescriptOptionValueWithDefaults;
+exports.graalvmHomeMandatoryOption = new commander_1.Option("--graalvm-home <value>", "Path to the GraalVM home").makeOptionMandatory(true);
+exports.graalvmHomeMandatoryOptionValue = getStringValueMandatory(exports.graalvmHomeMandatoryOption);
+exports.jvmClasspathMandatoryOption = new commander_1.Option("--jvm-classpath <value>", "The classpath containing all Gatling JVM components").makeOptionMandatory(true);
+exports.jvmClasspathMandatoryOptionValue = getStringValueMandatory(exports.jvmClasspathMandatoryOption);
+exports.memoryOption = new commander_1.Option("--memory <value>", "Heap space memory size in MiB for Gatling. Half the total available memory is usually a good default, as the Gatling process will use more memory than just the heap space.").argParser((value) => {
+    const parsedValue = parseInt(value, 10);
+    if (isNaN(parsedValue)) {
+        throw new Error(`${value} is not a valid memory size, must be an integer number`);
+    }
+    return parsedValue;
+});
+exports.memoryOptionValue = getNumberValueOptional(exports.memoryOption);
+exports.nonInteractiveOption = new commander_1.Option("--non-interactive", "Switch to non-interactive mode and fail if no simulation is explicitly specified").default(false);
+exports.nonInteractiveOptionValue = getBooleanValueMandatory(exports.nonInteractiveOption);
+exports.runParametersArgument = new commander_1.Argument("[optionKey=optionValue...]", "Specify one or more parameter which can be read in the simulation script with the getParameter() function; format must be key=value");
+const parseRunParametersArgument = (args) => {
+    const parsedParameters = {};
+    for (const arg of args) {
+        const i = arg.indexOf("=");
+        if (i < 0) {
+            throw Error(`Parameter '${arg}' is not valid: format should be key=value`);
+        }
+        else {
+            const key = arg.slice(0, i).trim();
+            parsedParameters[key] = arg.slice(i + 1);
+        }
+    }
+    return parsedParameters;
+};
+exports.parseRunParametersArgument = parseRunParametersArgument;
+exports.urlOption = new commander_1.Option("--url <value>", "URL of Gatling Enterprise")
+    .default("https://cloud.gatling.io")
+    .hideHelp();
+exports.urlOptionValue = getStringValueMandatory(exports.urlOption);
+exports.apiTokenOption = new commander_1.Option("--api-token <value>", "API Token on Gatling Enterprise. Prefer configuration using `GATLING_ENTERPRISE_API_TOKEN` environment variable.");
+exports.apiTokenOptionValue = getStringValueOptional(exports.apiTokenOption);
+// Plugin configuration
+exports.controlPlaneUrlOption = new commander_1.Option("--control-plane-url <value>", "URL of a control plane for Gatling Enterprise providing a private repository. If this parameter is provided, packages will be registered as private packages and uploaded through this private control plane.");
+exports.controlPlaneUrlOptionValue = getStringValueOptional(exports.controlPlaneUrlOption);
+// Descriptor file
+exports.packageDescriptorFilenameOption = new commander_1.Option("--package-descriptor-filename <value>", "Path to a package descriptor inside the .gatling folder").default("package.conf");
+exports.packageDescriptorFilenameOptionValue = getStringValueMandatory(exports.packageDescriptorFilenameOption);
+// Deployment info
+exports.enterpriseSimulationOption = new commander_1.Option("--enterprise-simulation <value>", "Specify the simulation name directly to bypass the prompt using the following command.");
+exports.enterpriseSimulationOptionValue = getStringValueOptional(exports.enterpriseSimulationOption);
+exports.runTitleOption = new commander_1.Option("--run-title <value>", "Allows setting a title for your run reports.");
+exports.runTitleOptionValue = getStringValueOptional(exports.runTitleOption);
+exports.runDescriptionOption = new commander_1.Option("--run-description <value>", "Allows setting a description for your run reports summary.");
+exports.runDescriptionOptionValue = getStringValueOptional(exports.runDescriptionOption);
+exports.waitForRunEndOption = new commander_1.Option("--wait-for-run-end", "Wait for the result after starting the simulation on Gatling Enterprise, and complete with an error if the simulation ends with any error status").default(false);
+exports.waitForRunEndOptionValue = getBooleanValueMandatory(exports.waitForRunEndOption);

package/target/commands/recorder.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+declare const _default: (program: Command) => void;
+export default _default;

package/target/commands/recorder.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const options_1 = require("./options");
+const simulations_1 = require("../simulations");
+const dependencies_1 = require("../dependencies");
+const log_1 = require("../log");
+const run_1 = require("../run");
+exports.default = (program) => {
+    program
+        .command("recorder")
+        .description("Run the Gatling recorder")
+        .addOption(options_1.gatlingHomeOption)
+        .addOption(options_1.sourcesFolderOption)
+        .addOption(options_1.typescriptOption)
+        .addOption(options_1.resourcesFolderOption)
+        .action(async (options) => {
+        const gatlingHome = (0, options_1.gatlingHomeOptionValueWithDefaults)(options);
+        const sourcesFolder = (0, options_1.sourcesFolderOptionValue)(options);
+        const resourcesFolder = (0, options_1.resourcesFolderOptionValue)(options);
+        const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
+        const typescript = (0, options_1.typescriptOptionValueWithDefaults)(options, simulations);
+        const { graalvmHome, coursierBinary, jvmClasspath } = await (0, dependencies_1.installRecorder)({ gatlingHome });
+        log_1.logger.debug(`graalvmHome=${graalvmHome}`);
+        log_1.logger.debug(`coursierBinary=${coursierBinary}`);
+        log_1.logger.debug(`jvmClasspath=${jvmClasspath}`);
+        await (0, run_1.runRecorder)({ graalvmHome, jvmClasspath, sourcesFolder, typescript, resourcesFolder });
+    });
+};

package/target/commands/run.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+declare const _default: (program: Command) => void;
+export default _default;

package/target/commands/run.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const options_1 = require("./options");
+const simulations_1 = require("../simulations");
+const dependencies_1 = require("../dependencies");
+const log_1 = require("../log");
+const bundle_1 = require("../bundle");
+const run_1 = require("../run");
+exports.default = (program) => {
+    program
+        .command("run")
+        .description("Build and run a Gatling simulation, after installing all required components and dependencies for Gatling")
+        .addOption(options_1.sourcesFolderOption)
+        .addOption(options_1.simulationOption)
+        .addOption(options_1.typescriptOption)
+        .addOption(options_1.bundleFileOption)
+        .addOption(options_1.resourcesFolderOption)
+        .addOption(options_1.resultsFolderOption)
+        .addOption(options_1.gatlingHomeOption)
+        .addOption(options_1.memoryOption)
+        .addOption(options_1.nonInteractiveOption)
+        .addArgument(options_1.runParametersArgument)
+        .action(async (args, options) => {
+        const gatlingHome = (0, options_1.gatlingHomeOptionValueWithDefaults)(options);
+        const sourcesFolder = (0, options_1.sourcesFolderOptionValue)(options);
+        const bundleFile = (0, options_1.bundleFileOptionValue)(options);
+        const resourcesFolder = (0, options_1.resourcesFolderOptionValue)(options);
+        const resultsFolder = (0, options_1.resultsFolderOptionValue)(options);
+        const memory = (0, options_1.memoryOptionValue)(options);
+        const nonInteractive = (0, options_1.nonInteractiveOptionValue)(options);
+        const runParameters = (0, options_1.parseRunParametersArgument)(args);
+        const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
+        const typescript = (0, options_1.typescriptOptionValueWithDefaults)(options, simulations);
+        const simulation = (0, options_1.simulationOptionValueWithDefaults)(options, simulations, !nonInteractive);
+        const { graalvmHome, coursierBinary, jvmClasspath } = await (0, dependencies_1.installGatlingJs)({ gatlingHome });
+        log_1.logger.debug(`graalvmHome=${graalvmHome}`);
+        log_1.logger.debug(`coursierBinary=${coursierBinary}`);
+        log_1.logger.debug(`jvmClasspath=${jvmClasspath}`);
+        await (0, bundle_1.bundle)({ sourcesFolder, bundleFile, typescript, simulations });
+        await (0, run_1.runSimulation)({
+            graalvmHome,
+            jvmClasspath,
+            simulation,
+            bundleFile,
+            resourcesFolder,
+            resultsFolder,
+            memory,
+            runParameters
+        });
+    });
+};

package/target/commands/runOnly.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+declare const _default: (program: Command) => void;
+export default _default;

package/target/commands/runOnly.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const options_1 = require("./options");
+const run_1 = require("../run");
+exports.default = (program) => {
+    program
+        .command("run-only")
+        .description("Run a Gatling simulation from an already built bundle")
+        .addOption(options_1.graalvmHomeMandatoryOption)
+        .addOption(options_1.jvmClasspathMandatoryOption)
+        .addOption(options_1.simulationMandatoryOption)
+        .addOption(options_1.bundleFileOption)
+        .addOption(options_1.resourcesFolderOption)
+        .addOption(options_1.resultsFolderOption)
+        .addOption(options_1.memoryOption)
+        .addArgument(options_1.runParametersArgument)
+        .action(async (args, options) => {
+        const graalvmHome = (0, options_1.graalvmHomeMandatoryOptionValue)(options);
+        const jvmClasspath = (0, options_1.jvmClasspathMandatoryOptionValue)(options);
+        const simulation = (0, options_1.simulationMandatoryOptionValue)(options);
+        const bundleFile = (0, options_1.bundleFileOptionValue)(options);
+        const resourcesFolder = (0, options_1.resourcesFolderOptionValue)(options);
+        const resultsFolder = (0, options_1.resultsFolderOptionValue)(options);
+        const memory = (0, options_1.memoryOptionValue)(options);
+        const runParameters = (0, options_1.parseRunParametersArgument)(args);
+        await (0, run_1.runSimulation)({
+            graalvmHome,
+            jvmClasspath,
+            simulation: simulation,
+            bundleFile,
+            resourcesFolder,
+            resultsFolder,
+            memory,
+            runParameters
+        });
+    });
+};

package/target/dependencies/index.d.ts

@@ -1,3 +1,4 @@
+export { versions } from "./versions";
 export interface DependenciesOptions {
     gatlingHome: string;
 }

package/target/dependencies/index.js

@@ -3,10 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.installRecorder = exports.installGatlingJs = void 0;
+exports.installRecorder = exports.installGatlingJs = exports.versions = void 0;
 const promises_1 = __importDefault(require("fs/promises"));
 const coursier_1 = require("./coursier");
 const graalVm_1 = require("./graalVm");
+var versions_1 = require("./versions");
+Object.defineProperty(exports, "versions", { enumerable: true, get: function () { return versions_1.versions; } });
 const installGatlingJs = async (options) => {
     const downloadDir = `${options.gatlingHome}/tmp/download`;
     await promises_1.default.mkdir(downloadDir, { recursive: true });

package/target/dependencies/versions.js

@@ -8,8 +8,8 @@ exports.versions = {
     },
     coursier: "2.1.10",
     gatling: {
-        core: "3.11.5",
+        core: "3.12.0",
         enterprisePluginCommons: "1.9.6",
-        jsAdapter: "3.11.7"
+        jsAdapter: "3.12.0"
     }
 };

package/target/enterprise.js

@@ -8,7 +8,7 @@ const archiver_1 = __importDefault(require("archiver"));
 const fs_1 = __importDefault(require("fs"));
 const promises_1 = require("stream/promises");
 const zlib_1 = require("zlib");
-const versions_1 = require("./dependencies/versions");
+const dependencies_1 = require("./dependencies");
 const java_1 = require("./java");
 const log_1 = require("./log");
 const enterprisePackage = async (options) => {
@@ -41,11 +41,11 @@ const generateManifest = (simulationNames) => {
         "Manifest-Version: 1.0",
         "Specification-Vendor: GatlingCorp",
         "Gatling-Context: js",
-        `Gatling-Version: ${versions_1.versions.gatling.core}`,
+        `Gatling-Version: ${dependencies_1.versions.gatling.core}`,
         "Gatling-Packager: js-cli",
-        `Gatling-Packager-Version: ${versions_1.versions.gatling.jsAdapter}`,
+        `Gatling-Packager-Version: ${dependencies_1.versions.gatling.jsAdapter}`,
         `Gatling-Simulations: ${simulationNames.join(",")}`,
-        `Java-Version: ${versions_1.versions.graalvm.jdk.split(".")[0]}`
+        `Java-Version: ${dependencies_1.versions.graalvm.jdk.split(".")[0]}`
     ];
     const pkg = getPackageNameAndVersion();
     lines.push(`Implementation-Title: ${pkg.name}`);
@@ -119,7 +119,7 @@ const javaArgsFromPluginOptions = (options) => {
         javaArgs.push(`-Dgatling.enterprise.controlPlaneUrl=${options.controlPlaneUrl}`);
     }
     javaArgs.push("-Dgatling.enterprise.buildTool=js-cli");
-    javaArgs.push(`-Dgatling.enterprise.pluginVersion=${versions_1.versions.gatling.jsAdapter}`);
+    javaArgs.push(`-Dgatling.enterprise.pluginVersion=${dependencies_1.versions.gatling.jsAdapter}`);
     if (options.nonInteractive) {
         javaArgs.push(`-Dgatling.enterprise.batchMode=true`);
     }