@artilleryio/int-core 2.21.0 → 2.22.0

package/lib/engine_socketio.js

@@ -2,8 +2,6 @@
  * 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/. */
 
-'use strict';
-
 const async = require('async');
 const _ = require('lodash');
 
@@ -26,22 +24,21 @@ function SocketIoEngine(script) {
 }
 
 SocketIoEngine.prototype.createScenario = function (scenarioSpec, ee) {
-  const self = this;
   // Adds scenario overridden configuration into the static config
   this.socketioOpts = { ...this.socketioOpts, ...scenarioSpec.socketio };
 
-  const tasks = _.map(scenarioSpec.flow, function (rs) {
+  const tasks = _.map(scenarioSpec.flow, (rs) => {
     if (typeof rs.think !== 'undefined') {
       return engineUtil.createThink(
         rs,
-        _.get(self.config, 'defaults.think', {})
+        _.get(this.config, 'defaults.think', {})
       );
     }
 
-    return self.step(rs, ee);
+    return this.step(rs, ee);
   });
 
-  return self.compile(tasks, scenarioSpec.flow, ee);
+  return this.compile(tasks, scenarioSpec.flow, ee);
 };
 
 function markEndTime(ee, _, startedAt) {
@@ -117,56 +114,51 @@ function processResponse(ee, data, response, context, callback) {
   const fauxResponse = { body: JSON.stringify(data) };
 
   // Handle the capture or match clauses...
-  engineUtil.captureOrMatch(
-    response,
-    fauxResponse,
-    context,
-    function (err, result) {
-      // Were we unable to invoke captureOrMatch?
-      if (err) {
-        debug(data);
-        ee.emit('error', err);
+  engineUtil.captureOrMatch(response, fauxResponse, context, (err, result) => {
+    // Were we unable to invoke captureOrMatch?
+    if (err) {
+      debug(data);
+      ee.emit('error', err);
 
-        return callback(err, context);
-      }
+      return callback(err, context);
+    }
 
-      if (result !== null) {
-        // Do we have any failed matches?
-        const failedMatches = _.filter(result.matches, (v) => {
-          return !v.success;
-        });
+    if (result !== null) {
+      // Do we have any failed matches?
+      const failedMatches = _.filter(result.matches, (v) => {
+        return !v.success;
+      });
 
-        // How to handle failed matches?
-        if (failedMatches.length > 0) {
-          debug(failedMatches);
-          // TODO: Should log the details of the match somewhere
-          ee.emit('error', 'Failed match');
-          return callback(new Error('Failed match'), context);
-        } else {
-          // Populate the context with captured values
-          _.each(result.captures, function (v, k) {
-            context.vars[k] = v.value;
-          });
-        }
+      // How to handle failed matches?
+      if (failedMatches.length > 0) {
+        debug(failedMatches);
+        // TODO: Should log the details of the match somewhere
+        ee.emit('error', 'Failed match');
+        return callback(new Error('Failed match'), context);
+      } else {
+        // Populate the context with captured values
+        _.each(result.captures, (v, k) => {
+          context.vars[k] = v.value;
+        });
+      }
 
-        // Replace the base object context
-        // Question: Should this be JSON object or String?
-        context.vars.$ = fauxResponse.body;
+      // Replace the base object context
+      // Question: Should this be JSON object or String?
+      context.vars.$ = fauxResponse.body;
 
-        // Increment the success count...
-        context._successCount++;
+      // Increment the success count...
+      context._successCount++;
 
-        return callback(null, context);
-      }
+      return callback(null, context);
     }
-  );
+  });
 }
 
 SocketIoEngine.prototype.step = function (requestSpec, ee) {
   const self = this;
 
   if (requestSpec.loop) {
-    const steps = _.map(requestSpec.loop, function (rs) {
+    const steps = _.map(requestSpec.loop, (rs) => {
       if (!rs.emit && !rs.loop) {
         return self.httpDelegate.step(rs, ee);
       }
@@ -183,7 +175,7 @@ SocketIoEngine.prototype.step = function (requestSpec, ee) {
     });
   }
 
-  const f = function (context, callback) {
+  const f = (context, callback) => {
     // Only process emit requests; delegate the rest to the HTTP engine (or think utility)
     if (requestSpec.think) {
       return engineUtil.createThink(
@@ -216,13 +208,13 @@ SocketIoEngine.prototype.step = function (requestSpec, ee) {
         ]
       : Array.from(requestSpec.emit).map((arg) => template(arg, context));
 
-    const endCallback = function (err, context, needEmit) {
+    const endCallback = (err, context, needEmit) => {
       if (err) {
         debug(err);
       }
 
       if (isAcknowledgeRequired(requestSpec)) {
-        const ackCallback = function (...args) {
+        const ackCallback = (...args) => {
           const response = {
             data: template(
               requestSpec.acknowledge.data || requestSpec.acknowledge.args,
@@ -232,14 +224,14 @@ SocketIoEngine.prototype.step = function (requestSpec, ee) {
             match: template(requestSpec.acknowledge.match, context)
           };
           // Make sure data, capture or match has a default json spec for parsing socketio responses
-          _.each(response, function (r) {
+          _.each(response, (r) => {
             if (_.isPlainObject(r) && !('json' in r)) {
               r.json = '$.0'; // Default to the first callback argument
             }
           });
 
           // Acknowledge data can take up multiple arguments of the emit callback
-          processResponse(ee, args, response, context, function (err) {
+          processResponse(ee, args, response, context, (err) => {
             if (!err) {
               markEndTime(ee, context, startedAt);
             }
@@ -280,14 +272,14 @@ SocketIoEngine.prototype.step = function (requestSpec, ee) {
 
       // Listen for the socket.io response on the specified channel
       let done = false;
-      let responseData = [];
+      const responseData = [];
 
       socketio.on(response.channel, function receive(...args) {
         responseData.push(...args);
         if (isValid(responseData, response)) {
           done = true;
 
-          processResponse(ee, responseData, response, context, function (err) {
+          processResponse(ee, responseData, response, context, (err) => {
             if (!err) {
               markEndTime(ee, context, startedAt);
             }
@@ -307,22 +299,16 @@ SocketIoEngine.prototype.step = function (requestSpec, ee) {
       setTimeout(function responseTimeout() {
         if (!done) {
           if (responseData.length) {
-            processResponse(
-              ee,
-              responseData,
-              response,
-              context,
-              function (err) {
-                if (!err) {
-                  markEndTime(ee, context, startedAt);
-                }
-                // Stop listening on the response channel
-                socketio.off(response.channel);
-
-                // called
-                return endCallback(err, context, false);
+            processResponse(ee, responseData, response, context, (err) => {
+              if (!err) {
+                markEndTime(ee, context, startedAt);
               }
-            );
+              // Stop listening on the response channel
+              socketio.off(response.channel);
+
+              // called
+              return endCallback(err, context, false);
+            });
 
             return;
           }
@@ -341,7 +327,7 @@ SocketIoEngine.prototype.step = function (requestSpec, ee) {
     // Set default namespace in emit action
     requestSpec.namespace = template(requestSpec.namespace, context) || '';
 
-    self.loadContextSocket(requestSpec.namespace, context, function (err) {
+    self.loadContextSocket(requestSpec.namespace, context, (err) => {
       if (err) {
         debug(err);
         ee.emit('error', err.message);
@@ -378,18 +364,18 @@ SocketIoEngine.prototype.loadContextSocket = function (namespace, context, cb) {
 
     wildcardPatch(socket);
 
-    socket.on('*', function () {
+    socket.on('*', () => {
       context.__receivedMessageCount++;
     });
 
-    socket.once('connect', function () {
+    socket.once('connect', () => {
       cb(null, socket);
     });
-    socket.once('connect_error', function (err) {
+    socket.once('connect_error', (err) => {
       cb(err, null);
     });
 
-    socket.once('error', function (err) {
+    socket.once('error', (err) => {
       cb(err, socket);
     });
   } else {
@@ -397,11 +383,11 @@ SocketIoEngine.prototype.loadContextSocket = function (namespace, context, cb) {
   }
 };
 
-SocketIoEngine.prototype.closeContextSockets = function (context) {
+SocketIoEngine.prototype.closeContextSockets = (context) => {
   if (context.sockets && Object.keys(context.sockets).length > 0) {
     const namespaces = Object.keys(context.sockets);
 
-    namespaces.forEach(function (namespace) {
+    namespaces.forEach((namespace) => {
       context.sockets[namespace].disconnect();
     });
   }
@@ -429,9 +415,7 @@ SocketIoEngine.prototype.compile = function (tasks, scenarioSpec, ee) {
     initialContext = self.httpDelegate.setInitialContext(initialContext);
 
     initialContext._pendingRequests = _.size(
-      _.reject(scenarioSpec, function (rs) {
-        return typeof rs.think === 'number';
-      })
+      _.reject(scenarioSpec, (rs) => typeof rs.think === 'number')
     );
 
     const steps = _.flatten([

package/lib/engine_ws.js

@@ -2,14 +2,12 @@
  * 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/. */
 
-'use strict';
-
 const async = require('async');
 const _ = require('lodash');
 const WebSocket = require('ws');
 const HttpsProxyAgent = require('https-proxy-agent');
 const debug = require('debug')('ws');
-const url = require('url');
+const url = require('node:url');
 const engineUtil = require('@artilleryio/int-commons').engine_util;
 const template = engineUtil.template;
 
@@ -20,19 +18,18 @@ function WSEngine(script) {
 }
 
 WSEngine.prototype.createScenario = function (scenarioSpec, ee) {
-  const self = this;
-  const tasks = _.map(scenarioSpec.flow, function (rs) {
+  const tasks = _.map(scenarioSpec.flow, (rs) => {
     if (typeof rs.think !== 'undefined') {
       return engineUtil.createThink(
         rs,
-        _.get(self.config, 'defaults.think', {})
+        _.get(this.config, 'defaults.think', {})
       );
     }
 
-    return self.step(rs, ee);
+    return this.step(rs, ee);
   });
 
-  return self.compile(tasks, scenarioSpec.flow, ee);
+  return this.compile(tasks, scenarioSpec.flow, ee);
 };
 
 function getMessageHandler(context, params, ee, timeout, callback) {
@@ -61,7 +58,7 @@ function getMessageHandler(context, params, ee, timeout, callback) {
     let fauxResponse;
     try {
       fauxResponse = { body: JSON.parse(data) };
-    } catch (err) {
+    } catch (_err) {
       fauxResponse = { body: event.data };
     }
 
@@ -81,20 +78,19 @@ function getMessageHandler(context, params, ee, timeout, callback) {
         debug('captures: ', captures);
 
         // match and capture are strict by default:
-        const haveFailedMatches = _.some(result.matches, function (v) {
-          return !v.success && v.strict !== false;
-        });
+        const haveFailedMatches = _.some(
+          result.matches,
+          (v) => !v.success && v.strict !== false
+        );
 
-        const haveFailedCaptures = _.some(result.captures, function (v) {
-          return v.failed;
-        });
+        const haveFailedCaptures = _.some(result.captures, (v) => v.failed);
 
         if (haveFailedMatches || haveFailedCaptures) {
           // TODO: Emit the details of each failed capture/match
           return callback(new Error('Failed capture or match'), context);
         }
 
-        _.each(result.matches, function (v) {
+        _.each(result.matches, (v) => {
           ee.emit('match', v.success, {
             expected: v.expected,
             got: v.got,
@@ -103,7 +99,7 @@ function getMessageHandler(context, params, ee, timeout, callback) {
           });
         });
 
-        _.each(result.captures, function (v, k) {
+        _.each(result.captures, (v, k) => {
           _.set(context.vars, k, v.value);
         });
 
@@ -114,18 +110,14 @@ function getMessageHandler(context, params, ee, timeout, callback) {
 }
 
 WSEngine.prototype.step = function (requestSpec, ee) {
-  const self = this;
-
   if (requestSpec.loop) {
-    const steps = _.map(requestSpec.loop, function (rs) {
-      return self.step(rs, ee);
-    });
+    const steps = _.map(requestSpec.loop, (rs) => this.step(rs, ee));
 
     return engineUtil.createLoopWithCount(requestSpec.count || -1, steps, {
       loopValue: requestSpec.loopValue || '$loopCount',
       overValues: requestSpec.over,
-      whileTrue: self.config.processor
-        ? self.config.processor[requestSpec.whileTrue]
+      whileTrue: this.config.processor
+        ? this.config.processor[requestSpec.whileTrue]
         : undefined
     });
   }
@@ -133,18 +125,16 @@ WSEngine.prototype.step = function (requestSpec, ee) {
   if (requestSpec.think) {
     return engineUtil.createThink(
       requestSpec,
-      _.get(self.config, 'defaults.think', {})
+      _.get(this.config, 'defaults.think', {})
     );
   }
 
   if (requestSpec.function) {
-    return function (context, callback) {
-      const processFunc = self.config.processor[requestSpec.function];
+    return (context, callback) => {
+      const processFunc = this.config.processor[requestSpec.function];
       if (processFunc) {
         if (processFunc.constructor.name === 'Function') {
-          processFunc(context, ee, function () {
-            return callback(null, context);
-          });
+          processFunc(context, ee, () => callback(null, context));
         } else {
           return processFunc(context, ee)
             .then(() => {
@@ -159,32 +149,31 @@ WSEngine.prototype.step = function (requestSpec, ee) {
   }
 
   if (requestSpec.log) {
-    return function (context, callback) {
+    return (context, callback) => {
       console.log(template(requestSpec.log, context));
-      return process.nextTick(function () {
+      return process.nextTick(() => {
         callback(null, context);
       });
     };
   }
 
   if (requestSpec.connect) {
-    return function (context, callback) {
-      return process.nextTick(function () {
+    return (context, callback) =>
+      process.nextTick(() => {
         callback(null, context);
       });
-    };
   }
 
-  const f = function (context, callback) {
+  const f = (context, callback) => {
     const params = requestSpec.wait || requestSpec.send;
 
     // match exists on a string, so check match is not a prototype
-    let captureOrMatch = _.has(params, 'capture') || _.has(params, 'match');
+    const captureOrMatch = _.has(params, 'capture') || _.has(params, 'match');
 
     if (captureOrMatch) {
       // only process response if we're capturing
-      let timeout =
-        self.config.timeout || _.get(self.config, 'ws.timeout') || 10;
+      const timeout =
+        this.config.timeout || _.get(this.config, 'ws.timeout') || 10;
       context.ws.onmessage = getMessageHandler(
         context,
         params,
@@ -212,7 +201,7 @@ WSEngine.prototype.step = function (requestSpec, ee) {
       ee.emit('rate', 'websocket.send_rate');
       debug('WS send: %s', payload);
 
-      context.ws.send(payload, function (err) {
+      context.ws.send(payload, (err) => {
         if (err) {
           debug(err);
           ee.emit('error', err);
@@ -228,7 +217,7 @@ WSEngine.prototype.step = function (requestSpec, ee) {
       debug('WS wait: %j', params);
     } else {
       // in the end, we could not send anything, so report it and stop
-      let err = 'invalid_step';
+      const err = 'invalid_step';
       debug(err, requestSpec);
       ee.emit('error', err);
       return callback(err, context);
@@ -243,7 +232,7 @@ function getWsOptions(config) {
   const subprotocols = _.get(config, 'ws.subprotocols', []);
   const headers = _.get(config, 'ws.headers', {});
 
-  const subprotocolHeader = _.find(headers, (value, headerName) => {
+  const subprotocolHeader = _.find(headers, (_value, headerName) => {
     return headerName.toLowerCase() === 'sec-websocket-protocol';
   });
 
@@ -323,13 +312,13 @@ WSEngine.prototype.compile = function (tasks, scenarioSpec, ee) {
         wsArgs.options
       );
 
-      ws.on('open', function () {
+      ws.on('open', () => {
         contextWithoutWsArgs.ws = ws;
 
         return cb(null, contextWithoutWsArgs);
       });
 
-      ws.once('error', function (err) {
+      ws.once('error', (err) => {
         debug(err);
         ee.emit('error', err.message || err.code);
 
@@ -347,7 +336,7 @@ WSEngine.prototype.compile = function (tasks, scenarioSpec, ee) {
         debug(err);
       }
 
-      if (context && context.ws) {
+      if (context?.ws) {
         context.ws.close();
       }
 

package/lib/phases.js

@@ -2,15 +2,13 @@
  * 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/. */
 
-'use strict';
-
 const EventEmitter = require('eventemitter3');
 const async = require('async');
 const _ = require('lodash');
 const isUndefined = _.isUndefined;
 const arrivals = require('arrivals');
 const debug = require('debug')('phases');
-const { randomUUID } = require('crypto');
+const { randomUUID } = require('node:crypto');
 const driftless = require('driftless');
 const ms = require('ms');
 
@@ -23,9 +21,9 @@ async function sleep(ms) {
 }
 
 function phaser(phaseSpecs) {
-  let ee = new EventEmitter();
+  const ee = new EventEmitter();
 
-  let tasks = _.map(phaseSpecs, function (spec, i) {
+  const tasks = _.map(phaseSpecs, (spec, i) => {
     [
       'arrivalRate',
       'arrivalCount',
@@ -33,12 +31,12 @@ function phaser(phaseSpecs) {
       'rampTo',
       'duration',
       'maxVusers'
-    ].forEach(function (k) {
-      if (isUndefined(spec[k]) || spec[k] == 'number') {
+    ].forEach((k) => {
+      if (isUndefined(spec[k]) || spec[k] === 'number') {
         return;
       }
 
-      if (k == 'duration' || k == 'pause') {
+      if (k === 'duration' || k === 'pause') {
         //if it's already a number in string format, don't apply ms, as it's the default behaviour, so we don't want to do ms calculations
         //otherwise, ms returns the value in milliseconds, so we need to convert to seconds
         const convertedDuration = Number.isInteger(_.toNumber(spec[k]))
@@ -91,8 +89,8 @@ function phaser(phaseSpecs) {
     console.log('Unknown phase spec\n%j\nThis should not happen', spec);
   });
 
-  ee.run = function () {
-    async.series(tasks, function (err) {
+  ee.run = () => {
+    async.series(tasks, (err) => {
       if (err) {
         debug(err);
       }
@@ -106,11 +104,11 @@ function phaser(phaseSpecs) {
 
 function createPause(spec, ee) {
   const duration = spec.pause * 1000;
-  const task = function (callback) {
+  const task = (callback) => {
     spec.startTime = Date.now();
     spec.id = randomUUID();
     ee.emit('phaseStarted', spec);
-    setTimeout(function () {
+    setTimeout(() => {
       spec.endTime = Date.now();
       ee.emit('phaseCompleted', spec);
       return callback(null);
@@ -164,7 +162,7 @@ function createRamp(spec, ee) {
   debug(`periodArrivals ${periodArrivals}`);
   debug(`periodTick ${periodTick}`);
 
-  return async function rampTask(callback) {
+  return async function rampTask(_callback) {
     spec.startTime = Date.now();
     spec.id = randomUUID();
     ee.emit('phaseStarted', spec);
@@ -193,7 +191,7 @@ function createRamp(spec, ee) {
     // ensure we don't go past 1s
     const delay = Math.min(periodTick[currentPeriod], 1000);
     let currentArrivals = 0;
-    let arrivalTimer = driftless.setDriftlessInterval(function arrivals() {
+    const arrivalTimer = driftless.setDriftlessInterval(function arrivals() {
       if (currentArrivals < periodArrivals[currentPeriod]) {
         ee.emit('arrival', spec);
         currentArrivals++;
@@ -207,7 +205,7 @@ function createRamp(spec, ee) {
 }
 
 function createArrivalCount(spec, ee) {
-  const task = function (callback) {
+  const task = (callback) => {
     spec.startTime = Date.now();
     spec.id = randomUUID();
     ee.emit('phaseStarted', spec);
@@ -216,10 +214,10 @@ function createArrivalCount(spec, ee) {
     if (spec.arrivalCount > 0) {
       const interval = duration / spec.arrivalCount;
       const p = arrivals.uniform.process(interval, duration);
-      p.on('arrival', function () {
+      p.on('arrival', () => {
         ee.emit('arrival', spec);
       });
-      p.on('finished', function () {
+      p.on('finished', () => {
         spec.endTime = Date.now();
         ee.emit('phaseCompleted', spec);
         return callback(null);
@@ -234,7 +232,7 @@ function createArrivalCount(spec, ee) {
 }
 
 function createArrivalRate(spec, ee) {
-  const task = function (callback) {
+  const task = (callback) => {
     spec.startTime = Date.now();
     spec.id = randomUUID();
     ee.emit('phaseStarted', spec);
@@ -242,10 +240,10 @@ function createArrivalRate(spec, ee) {
     const duration = spec.duration * 1000;
     debug('creating a %s process for arrivalRate', spec.mode);
     const p = arrivals[spec.mode].process(ar, duration);
-    p.on('arrival', function () {
+    p.on('arrival', () => {
       ee.emit('arrival', spec);
     });
-    p.on('finished', function () {
+    p.on('finished', () => {
       spec.endTime = Date.now();
       ee.emit('phaseCompleted', spec);
       return callback(null);

package/lib/readers.js

@@ -2,8 +2,6 @@
  * 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/. */
 
-'use strict';
-
 const _ = require('lodash');
 
 module.exports = createReader;
@@ -25,8 +23,8 @@ function createReader(order, spec) {
 
 function createSequencedReader() {
   let i = 0;
-  return function (data) {
-    let result = data[i];
+  return (data) => {
+    const result = data[i];
     if (i < data.length - 1) {
       i++;
     } else {
@@ -39,14 +37,14 @@ function createSequencedReader() {
 function createEverythingReader(spec) {
   let parsedData;
 
-  return function (data) {
+  return (data) => {
     if (!parsedData) {
       parsedData = [];
 
       // Parse the row into an object based on the fields spec
       if (spec.fields?.length > 0) {
         for (const row of data) {
-          let o = {};
+          const o = {};
           for (let i = 0; i < spec.fields.length; i++) {
             const fieldName = spec.fields[i];
             o[fieldName] = row[i];
@@ -64,7 +62,5 @@ function createEverythingReader(spec) {
 }
 
 function createRandomReader() {
-  return function (data) {
-    return data[Math.max(0, _.random(0, data.length - 1))];
-  };
+  return (data) => data[Math.max(0, _.random(0, data.length - 1))];
 }