@depup/artillery 2.0.30-depup.0

package/lib/telemetry.js

@@ -0,0 +1,78 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+
+
+const { version: artilleryVersion } = require('../package.json');
+const { isCI, name: ciName } = require('ci-info');
+const debug = require('debug')('telemetry');
+
+const POSTHOG_TOKEN = '_uzX-_WJoVmE_tsLvu0OFD2tpd0HGz72D5sU1zM2hbs';
+
+const notice = () => {
+  console.log(
+    'Anonymized telemetry is on. Learn more: https://artillery.io/docs/resources/core/telemetry.html'
+  );
+};
+
+const isEnabled = () => {
+  return typeof process.env.ARTILLERY_DISABLE_TELEMETRY === 'undefined';
+};
+
+async function capture(eventName, data) {
+  if (!isEnabled()) {
+    return;
+  }
+
+  const debugEnabled =
+    typeof process.env.ARTILLERY_TELEMETRY_DEBUG !== 'undefined';
+
+  const url = 'https://us.i.posthog.com/i/v0/e/';
+  const headers = {
+    'Content-Type': 'application/json'
+  };
+
+  let telemetryDefaults = {};
+  try {
+    telemetryDefaults = JSON.parse(process.env.ARTILLERY_TELEMETRY_DEFAULTS);
+  } catch (_err) {
+    /* empty */
+  }
+
+  const properties = Object.assign(
+    {
+      ...data,
+      $process_person_profile: false,
+      version: artilleryVersion,
+      os: process.platform,
+      isCi: isCI,
+      ciName: isCI ? ciName : undefined,
+      $ip: 'not-collected'
+    },
+    telemetryDefaults
+  );
+
+  const payload = {
+    api_key: POSTHOG_TOKEN,
+    event: eventName,
+    distinct_id: data.distinctId || 'artillery-core',
+    properties
+  };
+
+  if (debugEnabled) {
+    console.log(`Telemetry data: ${JSON.stringify(payload.properties)}`);
+  }
+
+  try {
+    await fetch(url, {
+      method: 'POST',
+      headers: headers,
+      body: JSON.stringify(payload)
+    });
+  } catch (err) {
+    debug(err);
+  }
+}
+
+module.exports = { notice, capture, isEnabled };

package/lib/util/await-on-ee.js

@@ -0,0 +1,24 @@
+const sleep = require('./sleep');
+
+async function awaitOnEE(ee, message, pollMs = 1000, maxWaitMs = Infinity) {
+  let messageFired = false;
+  let args = null;
+  let waitedMs = 0;
+
+  ee.once(message, (...eventArgs) => {
+    messageFired = true;
+    args = eventArgs;
+  });
+
+  while (true && waitedMs < maxWaitMs) {
+    if (messageFired) {
+      break;
+    }
+    await sleep(pollMs);
+    waitedMs += pollMs;
+  }
+
+  return args;
+}
+
+module.exports = awaitOnEE;

package/lib/util/generate-id.js

@@ -0,0 +1,9 @@
+const { customAlphabet } = require('nanoid');
+
+function generateId(prefix = '') {
+  const idf = customAlphabet('3456789abcdefghjkmnpqrtwxyz');
+  const testRunId = `${prefix}${idf(4)}_${idf(29)}_${idf(4)}`;
+  return testRunId;
+}
+
+module.exports = generateId;

package/lib/util/parse-tag-string.js

@@ -0,0 +1,21 @@
+module.exports = function parseTagString(input) {
+  const result = {
+    tags: [],
+    errors: []
+  };
+
+  if (!input) {
+    return result;
+  }
+
+  const tagList = input.split(',').map((x) => x.trim());
+  for (const t of tagList) {
+    const cs = t.split(':');
+    if (cs.length !== 2) {
+      result.errors.push(t);
+    } else {
+      result.tags.push({ name: cs[0].trim(), value: cs[1].trim() });
+    }
+  }
+  return result;
+};

package/lib/util/prepare-test-execution-plan.js

@@ -0,0 +1,216 @@
+const csv = require('csv-parse');
+const fs = require('node:fs');
+const path = require('node:path');
+const p = require('node:util').promisify;
+const debug = require('debug')('artillery');
+
+const {
+  readScript,
+  parseScript,
+  addOverrides,
+  addVariables,
+  addDefaultPlugins,
+  resolveConfigTemplates,
+  checkConfig,
+  resolveConfigPath
+} = require('../../util');
+
+const validateScript = require('./validate-script');
+
+const _ = require('lodash');
+
+async function prepareTestExecutionPlan(inputFiles, flags, _args) {
+  const scriptPath = inputFiles[0];
+  let script1 = {};
+
+  for (const fn of inputFiles) {
+    const fn2 = fn.toLowerCase();
+    const absoluteFn = path.resolve(process.cwd(), fn);
+    if (
+      fn2.endsWith('.yml') ||
+      fn2.endsWith('.yaml') ||
+      fn2.endsWith('.json')
+    ) {
+      const data = await readScript(absoluteFn);
+      const parsedData = await parseScript(data);
+      script1 = _.merge(script1, parsedData);
+    } else {
+      if (fn2.endsWith('.js')) {
+        const parsedData = require(absoluteFn);
+        script1 = _.merge(script1, parsedData);
+      } else if (fn2.endsWith('.ts')) {
+        const outputPath = path.join(
+          path.dirname(absoluteFn),
+          `dist/${path.basename(fn)}.js`
+        );
+
+        const entryPoint = path.resolve(process.cwd(), fn);
+        // TODO: external packages will have to be specified externally to the script
+        transpileTypeScript(entryPoint, outputPath, []);
+        debug('transpiled TypeScript file into JS. Bundled file:', outputPath);
+        const parsedData = require(outputPath);
+        script1 = _.merge(script1, parsedData);
+        // These magic properties are used by the worker to load the transpiled file
+        script1.__transpiledTypeScriptPath = outputPath;
+        script1.__originalScriptPath = entryPoint;
+      } else {
+        console.log('Unknown file type', fn);
+        console.log(
+          'Only JSON (.json), YAML (.yml/.yaml) and TypeScript (.ts) files are supported'
+        );
+        console.log('https://docs.art/e/file-types');
+        throw new Error('Unknown file type');
+      }
+    }
+  }
+
+  // We run the check here because subsequent steps can overwrite the target to undefined in
+  // cases where the value of config.target is set to a value from the environment which
+  // is not available at this point in time. Example: target is set to an environment variable
+  // the value of which is only available at runtime in AWS Fargate
+  const hasOriginalTarget =
+    typeof script1.config.target !== 'undefined' ||
+    typeof script1.config.environments?.[flags.environment]?.target !==
+      'undefined';
+
+  script1 = await checkConfig(script1, scriptPath, flags);
+
+  const script2 = await resolveConfigPath(script1, flags, scriptPath);
+
+  const script3 = await addOverrides(script2, flags);
+  const script4 = await addVariables(script3, flags);
+  // The resolveConfigTemplates function expects the config and script path to be passed explicitly because it is used in Fargate as well where the two arguments will not be available on the script
+  const script5 = await resolveConfigTemplates(
+    script4,
+    flags,
+    script4._configPath,
+    script4._scriptPath
+  );
+
+  if (!script5.config.target && !hasOriginalTarget) {
+    throw new Error('No target specified and no environment chosen');
+  }
+
+  const validationError = validateScript(script5);
+
+  if (validationError) {
+    console.log(`Scenario validation error: ${validationError}`);
+
+    process.exit(1);
+  }
+
+  const script6 = await readPayload(script5);
+
+  if (typeof script6.config.phases === 'undefined' || flags.solo) {
+    script6.config.phases = [
+      {
+        duration: 1,
+        arrivalCount: 1
+      }
+    ];
+  }
+
+  script6.config.statsInterval = script6.config.statsInterval || 30;
+
+  const script7 = addDefaultPlugins(script5);
+  const script8 = replaceProcessorIfTypescript(script7, scriptPath);
+
+  return script8;
+}
+
+async function readPayload(script) {
+  if (!script.config.payload) {
+    return script;
+  }
+
+  for (const payloadSpec of script.config.payload) {
+    const data = fs.readFileSync(payloadSpec.path, 'utf-8');
+
+    const csvOpts = Object.assign(
+      {
+        skip_empty_lines:
+          typeof payloadSpec.skipEmptyLines === 'undefined'
+            ? true
+            : payloadSpec.skipEmptyLines,
+        cast: typeof payloadSpec.cast === 'undefined' ? true : payloadSpec.cast,
+        from_line: payloadSpec.skipHeader === true ? 2 : 1,
+        delimiter: payloadSpec.delimiter || ','
+      },
+      payloadSpec.options
+    );
+      const parsedData = await p(csv)(data, csvOpts);
+      payloadSpec.data = parsedData;
+  }
+
+  return script;
+}
+
+function transpileTypeScript(entryPoint, outputPath, userExternalPackages) {
+  const esbuild = require('esbuild-wasm');
+
+  esbuild.buildSync({
+    entryPoints: [entryPoint],
+    outfile: outputPath,
+    bundle: true,
+    platform: 'node',
+    format: 'cjs',
+    sourcemap: 'inline',
+    external: ['@playwright/test', ...userExternalPackages]
+  });
+
+  return outputPath;
+}
+
+function replaceProcessorIfTypescript(script, scriptPath) {
+  const relativeProcessorPath = script.config.processor;
+  const userExternalPackages = script.config.bundling?.external || [];
+
+  if (!relativeProcessorPath) {
+    return script;
+  }
+  const extensionType = path.extname(relativeProcessorPath);
+
+  if (extensionType !== '.ts') {
+    return script;
+  }
+
+  const actualProcessorPath = path.resolve(
+    path.dirname(scriptPath),
+    relativeProcessorPath
+  );
+  const processorFileName = path.basename(actualProcessorPath, extensionType);
+
+  const processorDir = path.dirname(actualProcessorPath);
+  const newProcessorPath = path.join(
+    processorDir,
+    `dist/${processorFileName}.js`
+  );
+
+  //TODO: move require to top of file when Lambda bundle size issue is solved
+  //must be conditionally required for now as this package is removed in Lambda for now to avoid bigger package sizes
+  const esbuild = require('esbuild-wasm');
+
+  try {
+    esbuild.buildSync({
+      entryPoints: [actualProcessorPath],
+      outfile: newProcessorPath,
+      bundle: true,
+      platform: 'node',
+      format: 'cjs',
+      sourcemap: 'inline',
+      external: ['@playwright/test', ...userExternalPackages]
+    });
+  } catch (error) {
+    throw new Error(`Failed to compile Typescript processor\n${error.message}`);
+  }
+
+  global.artillery.hasTypescriptProcessor = newProcessorPath;
+  console.log(
+    `Bundled Typescript file into JS. New processor path: ${newProcessorPath}`
+  );
+
+  script.config.processor = newProcessorPath;
+  return script;
+}
+
+module.exports = prepareTestExecutionPlan;

package/lib/util/sleep.js

@@ -0,0 +1,7 @@
+async function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+module.exports = sleep;

package/lib/util/validate-script.js

@@ -0,0 +1,132 @@
+const Joi = require('joi').defaults((schema) =>
+  schema.options({ allowUnknown: true, abortEarly: true })
+);
+
+const config = Joi.object({
+  target: Joi.string().when('environments', {
+    not: Joi.exist(),
+    then: Joi.required()
+  }),
+  http: Joi.object({
+    extendedMetrics: Joi.boolean(),
+    maxSockets: Joi.number(),
+    timeout: Joi.alternatives(Joi.number(), Joi.string())
+  }),
+  environments: Joi.object(),
+  processor: Joi.string(),
+  phases: Joi.array(),
+  engines: Joi.object()
+  // payload: Joi.alternatives(Joi.object(), Joi.array())
+});
+
+const capture = Joi.object({
+  as: Joi.string().required()
+});
+
+const httpMethodProps = {
+  url: Joi.string().required(),
+  headers: Joi.object(),
+  cookie: Joi.object(),
+  followRedirect: Joi.boolean(),
+  qs: Joi.object(),
+  gzip: Joi.boolean(),
+  auth: Joi.object({
+    user: Joi.string(),
+    pass: Joi.string()
+  }),
+  beforeRequest: Joi.array().items(Joi.string()).single(),
+  afterResponse: Joi.array().items(Joi.string()).single(),
+  capture: Joi.array().items(capture).single()
+};
+
+const httpItems = {
+  get: Joi.object(httpMethodProps),
+  post: Joi.object(httpMethodProps),
+  put: Joi.object(httpMethodProps),
+  patch: Joi.object(httpMethodProps),
+  delete: Joi.object(httpMethodProps)
+};
+
+const socketioItems = {
+  emit: Joi.any().when(Joi.ref('....engine'), {
+    is: 'socketio',
+    then: Joi.alternatives(
+      Joi.object({
+        channel: Joi.string(),
+        concat: Joi.boolean(),
+        data: Joi.any()
+      }),
+      Joi.array().items(Joi.string())
+    ),
+    otherwise: Joi.any()
+  })
+};
+
+const wsItems = {
+  connect: Joi.any().when(Joi.ref('....engine'), {
+    is: 'ws',
+    then: Joi.alternatives(Joi.object(), Joi.string()),
+    otherwise: Joi.any()
+  }),
+  send: Joi.any()
+};
+
+const flowItemSchema = Joi.object({
+  function: Joi.string(),
+  log: Joi.string(),
+  think: Joi.alternatives(Joi.number(), Joi.string()),
+  loop: Joi.array(),
+  ...httpItems,
+  ...wsItems,
+  ...socketioItems
+}).when('.loop', {
+  is: Joi.exist(),
+  then: Joi.object({
+    count: Joi.alternatives(Joi.number(), Joi.string()),
+    over: Joi.alternatives(Joi.array(), Joi.string())
+  }),
+  otherwise: Joi.when('...engine', {
+    is: Joi.exist().valid('socketio'),
+    then: Joi.object().max(4),
+    otherwise: Joi.object().length(1)
+  })
+});
+
+const scenarioItem = Joi.object({
+  name: Joi.string(),
+  engine: Joi.string(),
+  beforeScenario: Joi.array().items(Joi.string()).single(),
+  afterScenario: Joi.array().items(Joi.string()).single(),
+  flow: Joi.any().when('engine', {
+    is: Joi.valid('socketio', 'ws', 'http'),
+    then: Joi.array().items(flowItemSchema).required(),
+    otherwise: Joi.array().items(Joi.any())
+  })
+});
+
+const beforeAfterSchema = Joi.object({
+  flow: Joi.when('engine', {
+    is: Joi.exist(),
+    then: Joi.when('engine', {
+      is: Joi.valid('socketio', 'ws', 'http'),
+      then: Joi.array().items(flowItemSchema).required(),
+      otherwise: Joi.array().items(Joi.any())
+    }),
+    otherwise: Joi.array().items(flowItemSchema).required()
+  })
+});
+
+const schema = Joi.object({
+  config: config,
+  scenarios: Joi.array().items(scenarioItem).required(),
+  before: beforeAfterSchema,
+  after: beforeAfterSchema
+});
+
+module.exports = (script) => {
+  const { error } = schema.validate(script);
+
+  if (error?.details.length) {
+    return error.details[0].message;
+  }
+};