@artilleryio/int-core 2.2.0-a4feb0d → 2.2.0-bfa0fe5

package/lib/engine_http.js

@@ -713,7 +713,17 @@ HttpEngine.prototype.step = function step(requestSpec, ee, opts) {
           .catch((gotErr) => {
             // TODO: Handle the error properly with run hooks
             debug(gotErr);
-            return callback(gotErr, context);
+            runOnErrorHooks(
+              onErrorHandlers,
+              config.processor,
+              gotErr,
+              requestParams,
+              context,
+              ee,
+              function (asyncErr) {
+                return callback(gotErr, context);
+              }
+            );
           });
       }
     ); // eachSeries

package/lib/engine_socketio.js

@@ -52,16 +52,52 @@ function markEndTime(ee, _, startedAt) {
 }
 
 function isResponseRequired(spec) {
-  return spec.emit && spec.response && spec.response.channel;
+  return (
+    spec.emit && spec.response && (spec.response.channel || spec.response.on)
+  );
 }
 
 function isAcknowledgeRequired(spec) {
   return spec.emit && spec.acknowledge;
 }
 
+function isValid(data, response) {
+  if (_.isArray(response.data)) {
+    //we check if it's an array first (as arrays are objects), and if it's an array, do a deep equality check between both arrays
+    return deepEqual(data, response.data);
+  }
+
+  if (_.isObject(response.data)) {
+    //`json` key is added at some point to the response.data object, to use with `captureOrMatch` function
+    //we should omit it when comparing the response to the data
+    const expectedResponse = _.omit(response.data, 'json');
+    const actualResponse = data[data.length - 1]; // if response.data is not an array, we compare it to the last element of the actual response
+
+    return deepEqual(actualResponse, expectedResponse);
+  }
+
+  if (_.isString(response.data)) {
+    const expectedResponse = response.data;
+    let actualResponse = data[data.length - 1]; // if response.data is not an array, we compare it to the last element of the actual response
+
+    // unless the user wants to test against the entire response
+    if (response.concat) {
+      actualResponse = data.join('');
+    }
+
+    debug(
+      `checking if string ${expectedResponse} is a partial match for string ${actualResponse}`
+    );
+    return actualResponse.includes(expectedResponse); //we accept a partial match if it's a string
+  }
+
+  debug(`unexpected data type for response.data: ${typeof response.data}`);
+  return false;
+}
+
 function processResponse(ee, data, response, context, callback) {
   // Do we have supplied data to validate?
-  if (response.data && !deepEqual(data, response.data)) {
+  if (response.data && !isValid(data, response)) {
     debug('data is not valid:');
     debug(data);
     debug(response);
@@ -186,9 +222,12 @@ SocketIoEngine.prototype.step = function (requestSpec, ee) {
       }
 
       if (isAcknowledgeRequired(requestSpec)) {
-        const ackCallback = function () {
+        const ackCallback = function (...args) {
           const response = {
-            data: template(requestSpec.acknowledge.data, context),
+            data: template(
+              requestSpec.acknowledge.data || requestSpec.acknowledge.args,
+              context
+            ),
             capture: template(requestSpec.acknowledge.capture, context),
             match: template(requestSpec.acknowledge.match, context)
           };
@@ -198,8 +237,9 @@ SocketIoEngine.prototype.step = function (requestSpec, ee) {
               r.json = '$.0'; // Default to the first callback argument
             }
           });
+
           // Acknowledge data can take up multiple arguments of the emit callback
-          processResponse(ee, arguments, response, context, function (err) {
+          processResponse(ee, args, response, context, function (err) {
             if (!err) {
               markEndTime(ee, context, startedAt);
             }
@@ -219,32 +259,44 @@ SocketIoEngine.prototype.step = function (requestSpec, ee) {
           socketio.emit(...outgoing);
         }
         markEndTime(ee, context, startedAt);
-        return callback(null, context);
+        return callback(err, context);
       }
     }; // endCallback
 
     if (isResponseRequired(requestSpec)) {
       const response = {
-        channel: template(requestSpec.response.channel, context),
-        data: template(requestSpec.response.data, context),
+        channel: template(
+          requestSpec.response.channel || requestSpec.response.on,
+          context
+        ),
+        concat: template(requestSpec.response.concat, context),
+        data: template(
+          requestSpec.response.data || requestSpec.response.args,
+          context
+        ),
         capture: template(requestSpec.response.capture, context),
         match: template(requestSpec.response.match, context)
       };
 
       // Listen for the socket.io response on the specified channel
       let done = false;
+      let responseData = [];
 
-      socketio.on(response.channel, function receive(data) {
-        done = true;
-        processResponse(ee, data, response, context, function (err) {
-          if (!err) {
-            markEndTime(ee, context, startedAt);
-          }
-          // Stop listening on the response channel
-          socketio.off(response.channel);
+      socketio.on(response.channel, function receive(...args) {
+        responseData.push(...args);
+        if (isValid(responseData, response)) {
+          done = true;
 
-          return endCallback(err, context, false);
-        });
+          processResponse(ee, responseData, response, context, function (err) {
+            if (!err) {
+              markEndTime(ee, context, startedAt);
+            }
+            // Stop listening on the response channel
+            socketio.off(response.channel);
+
+            return endCallback(err, context, false);
+          });
+        }
       });
 
       // Send the data on the specified socket.io channel
@@ -254,6 +306,27 @@ 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);
+              }
+            );
+
+            return;
+          }
+
           const err = 'response timeout';
           ee.emit('error', err);
           return callback(err, context);
@@ -315,6 +388,10 @@ SocketIoEngine.prototype.loadContextSocket = function (namespace, context, cb) {
     socket.once('connect_error', function (err) {
       cb(err, null);
     });
+
+    socket.once('error', function (err) {
+      cb(err, socket);
+    });
   } else {
     return cb(null, context.sockets[namespace]);
   }

package/lib/runner.js

@@ -327,8 +327,13 @@ function runScenario(script, metrics, runState, contextVars, options) {
   if (options.scenarioName) {
     let foundIndex;
     const foundScenario = script.scenarios.filter((scenario, index) => {
-      foundIndex = index;
-      return new RegExp(options.scenarioName).test(scenario.name);
+      const hasScenario = new RegExp(options.scenarioName).test(scenario.name);
+
+      if (hasScenario) {
+        foundIndex = index;
+      }
+
+      return hasScenario;
     });
 
     if (foundScenario?.length === 0) {

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@artilleryio/int-core",
-  "version": "2.2.0-a4feb0d",
+  "version": "2.2.0-bfa0fe5",
   "main": "./index.js",
   "license": "MPL-2.0",
   "dependencies": {
-    "@artilleryio/int-commons": "2.0.2-a4feb0d",
+    "@artilleryio/int-commons": "2.0.3-bfa0fe5",
     "@artilleryio/sketches-js": "^2.1.1",
     "agentkeepalive": "^4.1.0",
     "arrivals": "^2.1.2",