@artilleryio/int-core 2.2.0-c1dac36 → 2.2.0-e388da1

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

@@ -61,19 +61,41 @@ function isAcknowledgeRequired(spec) {
   return spec.emit && spec.acknowledge;
 }
 
-function processResponse(ee, data, response, context, callback) {
-  function isValid(data, response) {
-    if (!Array.isArray(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 responseDataWithoutJson = _.isObject(response.data)
-        ? _.omit(response.data, 'json')
-        : response.data;
-      return deepEqual(data[0], responseDataWithoutJson);
+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('');
     }
 
-    return deepEqual(data, response.data);
+    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 && !isValid(data, response)) {
     debug('data is not valid:');
@@ -237,7 +259,7 @@ SocketIoEngine.prototype.step = function (requestSpec, ee) {
           socketio.emit(...outgoing);
         }
         markEndTime(ee, context, startedAt);
-        return callback(null, context);
+        return callback(err, context);
       }
     }; // endCallback
 
@@ -247,6 +269,7 @@ SocketIoEngine.prototype.step = function (requestSpec, ee) {
           requestSpec.response.channel || requestSpec.response.on,
           context
         ),
+        concat: template(requestSpec.response.concat, context),
         data: template(
           requestSpec.response.data || requestSpec.response.args,
           context
@@ -257,18 +280,23 @@ SocketIoEngine.prototype.step = function (requestSpec, ee) {
 
       // Listen for the socket.io response on the specified channel
       let done = false;
+      let responseData = [];
 
       socketio.on(response.channel, function receive(...args) {
-        done = true;
-        processResponse(ee, args, response, context, function (err) {
-          if (!err) {
-            markEndTime(ee, context, startedAt);
-          }
-          // Stop listening on the response channel
-          socketio.off(response.channel);
+        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
@@ -278,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);
@@ -339,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-c1dac36",
+  "version": "2.2.0-e388da1",
   "main": "./index.js",
   "license": "MPL-2.0",
   "dependencies": {
-    "@artilleryio/int-commons": "2.0.2-c1dac36",
+    "@artilleryio/int-commons": "2.0.2-e388da1",
     "@artilleryio/sketches-js": "^2.1.1",
     "agentkeepalive": "^4.1.0",
     "arrivals": "^2.1.2",