postman-runtime 7.28.4 → 7.29.2

package/lib/runner/extensions/item.command.js

@@ -77,6 +77,7 @@ getResponseJSON = function (response) {
 /**
  * Add options
  * stopOnError:Boolean
+ *
  * @type {Object}
  */
 module.exports = {
@@ -89,12 +90,12 @@ module.exports = {
 
     process: {
         /**
-         * @param {Function=} callback
-         * @param {Object} payload
-         * @param {Function} next
+         * @param {Function=} callback -
+         * @param {Object} payload -
+         * @param {Function} next -
          * @todo  validate payload
          */
-        item: function (callback, payload, next) {
+        item (callback, payload, next) {
             // adjust for polymorphic instructions
             if (!next && _.isFunction(payload) && !_.isFunction(callback)) {
                 next = payload;
@@ -196,7 +197,7 @@ module.exports = {
                             this.triggers.item(null, coords, item); // @todo - should this trigger receive error?
 
                             return callback && callback.call(this, requestError, {
-                                request: request
+                                request
                             });
                         }
 

package/lib/runner/extensions/request.command.js

@@ -6,15 +6,15 @@ var _ = require('lodash'),
     /**
      * Resolve variables in item and auth in context.
      *
-     * @param {ItemContext} context
-     * @param {Item} [context.item]
-     * @param {RequestAuth} [context.auth]
-     * @param {Object} payload
-     * @param {VariableScope} payload._variables
-     * @param {Object} payload.data
-     * @param {VariableScope} payload.environment
-     * @param {VariableScope} payload.collectionVariables
-     * @param {VariableScope} payload.globals
+     * @param {ItemContext} context -
+     * @param {Item} [context.item] -
+     * @param {RequestAuth} [context.auth] -
+     * @param {Object} payload -
+     * @param {VariableScope} payload._variables -
+     * @param {Object} payload.data -
+     * @param {VariableScope} payload.environment -
+     * @param {VariableScope} payload.collectionVariables -
+     * @param {VariableScope} payload.globals -
      */
     resolveVariables = function (context, payload) {
         if (!(context.item && context.item.request)) { return; }
@@ -36,7 +36,7 @@ var _ = require('lodash'),
         // @todo - no need to sync variables when SDK starts supporting resolution from scope directly
         // @todo - avoid resolving the entire item as this unnecessarily resolves URL
         item = context.item = new sdk.Item(context.item.toObjectResolved(null,
-            variableDefinitions, {ignoreOwnVariables: true}));
+            variableDefinitions, { ignoreOwnVariables: true }));
 
         auth = context.auth;
 
@@ -51,7 +51,7 @@ var _ = require('lodash'),
 
         // resolve variables in auth
         auth && (context.auth = new sdk.RequestAuth(auth.toObjectResolved(null,
-            variableDefinitions, {ignoreOwnVariables: true})));
+            variableDefinitions, { ignoreOwnVariables: true })));
     };
 
 module.exports = {
@@ -62,7 +62,7 @@ module.exports = {
     triggers: ['response'],
 
     process: {
-        request: function (payload, next) {
+        request (payload, next) {
             var abortOnError = _.has(payload, 'abortOnError') ? payload.abortOnError : this.options.abortOnError,
 
                 // helper function to trigger `response` callback anc complete the command

package/lib/runner/extensions/waterfall.command.js

@@ -9,7 +9,7 @@ var _ = require('lodash'),
 /**
  * Returns a hash of IDs and Names of items in an array
  *
- * @param {Array} items
+ * @param {Array} items -
  * @returns {Object}
  */
 prepareLookupHash = function (items) {
@@ -111,12 +111,12 @@ module.exports = {
         /**
          * This processor simply queues scripts and requests in a linear chain.
          *
-         * @param {Object} payload
-         * @param {Object} payload.coords
-         * @param {Boolean} [payload.static=false]
-         * @param {Function} next
+         * @param {Object} payload -
+         * @param {Object} payload.coords -
+         * @param {Boolean} [payload.static=false] -
+         * @param {Function} next -
          */
-        waterfall: function (payload, next) {
+        waterfall (payload, next) {
             // we procure the coordinates that we have to pick item and data from. the data is
             var coords = payload.static ? payload.coords : this.waterfall.whatnext(payload.coords),
                 item = this.state.items[coords.position],

package/lib/runner/extract-runnable-items.js

@@ -9,7 +9,7 @@ var sdk = require('postman-collection'),
      * Accumulate all items in order if entry point is a collection/folder.
      * If an item is passed returns an array with that item.
      *
-     * @param {ItemGroup|Item} node
+     * @param {ItemGroup|Item} node -
      *
      * @returns {Array<Item>}
      *
@@ -34,8 +34,8 @@ var sdk = require('postman-collection'),
     /**
      * Finds an item or item group based on id or name.
      *
-     * @param {ItemGroup} itemGroup
-     * @param {?String} match
+     * @param {ItemGroup} itemGroup -
+     * @param {?String} match -
      *
      * @returns {Item|ItemGroup|undefined}
      */
@@ -72,7 +72,7 @@ var sdk = require('postman-collection'),
      * @returns {Object} Found Items or ItemGroups.
      */
     findItemsOrGroups = function (itemGroup, entrypointSubset, _continueAccumulation, _accumulatedItems) {
-        !_accumulatedItems && (_accumulatedItems = {members: [], reference: {}});
+        !_accumulatedItems && (_accumulatedItems = { members: [], reference: {} });
 
         if (!itemGroup || !itemGroup.items) { return _accumulatedItems; }
 
@@ -109,11 +109,11 @@ var sdk = require('postman-collection'),
     /**
      * Finds an item or group from a path. The path should be an array of ids from the parent chain.
      *
-     * @param {Collection} collection
-     * @param {Object} options
-     * @param {String} options.execute
-     * @param {?Array<String>} [options.path]
-     * @param {Function} callback
+     * @param {Collection} collection -
+     * @param {Object} options -
+     * @param {String} options.execute -
+     * @param {?Array<String>} [options.path] -
+     * @param {Function} callback -
      */
     lookupByPath = function (collection, options, callback) {
         var lookupPath,
@@ -139,10 +139,10 @@ var sdk = require('postman-collection'),
     /**
      * Finds an item or group on a collection with a matching id or name.
      *
-     * @param {Collection} collection
-     * @param {Object} options
-     * @param {String} [options.execute]
-     * @param {Function} callback
+     * @param {Collection} collection -
+     * @param {Object} options -
+     * @param {String} [options.execute] -
+     * @param {Function} callback -
      */
     lookupByIdOrName = function (collection, options, callback) {
         var match = options.execute,
@@ -161,10 +161,10 @@ var sdk = require('postman-collection'),
      *
      * @note runnable items follows the order in which the items are defined in the collection
      *
-     * @param {Collection} collection
-     * @param {Object} options
-     * @param {Array<String>} [options.execute]
-     * @param {Function} callback
+     * @param {Collection} collection -
+     * @param {Object} options -
+     * @param {Array<String>} [options.execute] -
+     * @param {Function} callback -
      */
     lookupByMultipleIdOrName = function (collection, options, callback) {
         var entrypoints = options.execute,
@@ -216,10 +216,10 @@ var sdk = require('postman-collection'),
      *
      * @note runnable items follows the order of entrypoints
      *
-     * @param {Collection} collection
-     * @param {Object} options
-     * @param {Array<String>} [options.execute]
-     * @param {Function} callback
+     * @param {Collection} collection -
+     * @param {Object} options -
+     * @param {Array<String>} [options.execute] -
+     * @param {Function} callback -
      */
     lookupByOrder = function (collection, options, callback) {
         var entrypoints = options.execute,
@@ -267,13 +267,13 @@ var sdk = require('postman-collection'),
     /**
      * Extracts all the items on a collection starting from the entrypoint.
      *
-     * @param {Collection} collection
-     * @param {?Object} [entrypoint]
+     * @param {Collection} collection -
+     * @param {?Object} [entrypoint] -
      * @param {String} [entrypoint.execute] id of item or group to execute (can be name when used with `idOrName`)
      * @param {Array<String>} [entrypoint.path] path leading to the item or group selected (only for `path` strategy)
      * @param {String} [entrypoint.lookupStrategy=idOrName] strategy to use for entrypoint lookup [idOrName, path]
      * @param {Boolean} [entrypoint.preserveOrder] option to preserve the order of folder/items when specified.
-     * @param {Function} callback
+     * @param {Function} callback -
      */
     extractRunnableItems = function (collection, entrypoint, callback) {
         var lookupFunction,
@@ -292,5 +292,5 @@ var sdk = require('postman-collection'),
     };
 
 module.exports = {
-    extractRunnableItems: extractRunnableItems
+    extractRunnableItems
 };

package/lib/runner/index.js

@@ -21,7 +21,7 @@ var _ = require('lodash'),
 /**
  * @constructor
  *
- * @param {Object} [options]
+ * @param {Object} [options] -
  */
 Runner = function PostmanCollectionRunner (options) { // eslint-disable-line func-name-matching
     this.options = _.assign({}, options);
@@ -31,13 +31,13 @@ _.assign(Runner.prototype, {
     /**
      * Prepares `run` config by combining `runner` config with given run options.
      *
-     * @param {Object} [options]
-     * @param {Object} [options.timeout]
-     * @param {Object} [options.timeout.global]
-     * @param {Object} [options.timeout.request]
-     * @param {Object} [options.timeout.script]
+     * @param {Object} [options] -
+     * @param {Object} [options.timeout] -
+     * @param {Object} [options.timeout.global] -
+     * @param {Object} [options.timeout.request] -
+     * @param {Object} [options.timeout.script] -
      */
-    prepareRunConfig: function (options) {
+    prepareRunConfig (options) {
         // combine runner config and make a copy
         var runOptions = _.merge(_.omit(options, ['environment', 'globals', 'data']), this.options.run) || {};
 
@@ -58,26 +58,25 @@ _.assign(Runner.prototype, {
     /**
      * Runs a collection or a folder.
      *
-     * @param {Collection} collection
-     * @param {Object} [options]
-     * @param {Array.<Item>} options.items
-     * @param {Array.<Object>}  [options.data]
-     * @param {Object} [options.globals]
-     * @param {Object} [options.environment]
-     * @param {Number} [options.iterationCount]
-     * @param {CertificateList} [options.certificates]
-     * @param {ProxyConfigList} [options.proxies]
-     * @param {Array} [options.data]
-     * @param {Object} [options.entrypoint]
+     * @param {Collection} collection -
+     * @param {Object} [options] -
+     * @param {Array.<Item>} options.items -
+     * @param {Array.<Object>}  [options.data] -
+     * @param {Object} [options.globals] -
+     * @param {Object} [options.environment] -
+     * @param {Number} [options.iterationCount] -
+     * @param {CertificateList} [options.certificates] -
+     * @param {ProxyConfigList} [options.proxies] -
+     * @param {Object} [options.entrypoint] -
      * @param {String} [options.entrypoint.execute] ID of the item-group to be run.
      * Can be Name if `entrypoint.lookupStrategy` is `idOrName`
      * @param {String} [options.entrypoint.lookupStrategy=idOrName] strategy to lookup the entrypoint [idOrName, path]
      * @param {Array<String>} [options.entrypoint.path] path to lookup
      * @param {Object} [options.run] Run-specific options, such as options related to the host
      *
-     * @param {Function} callback
+     * @param {Function} callback -
      */
-    run: function (collection, options, callback) {
+    run (collection, options, callback) {
         var self = this,
             runOptions = this.prepareRunConfig(options);
 
@@ -130,7 +129,7 @@ _.assign(Runner, {
      *
      * @type {Run}
      */
-    Run: Run
+    Run
 });
 
 module.exports = Runner;

package/lib/runner/instruction.js

@@ -92,10 +92,10 @@ pool = function (processors) {
     /**
      * Shortcut to `new Instruction(...);`
      *
-     * @param {Function} processor
-     * @param {String} name
-     * @param {Object} [payload]
-     * @param {Array} [args]
+     * @param {Function} processor -
+     * @param {String} name -
+     * @param {Object} [payload] -
+     * @param {Array} [args] -
      *
      * @returns {Instruction}
      */
@@ -113,8 +113,8 @@ pool = function (processors) {
     /**
      * Executes an instruction with previously saved payload and arguments
      *
-     * @param {Function} callback
-     * @param {*} [scope]
+     * @param {Function} callback -
+     * @param {*} [scope] -
      *
      * @todo: use timeback and control it via options sent during pool creation as an option
      */
@@ -148,7 +148,7 @@ pool = function (processors) {
                     _.isArray(this._done) && _.invokeMap(this._done, _.apply, scope, _.tail(arguments));
                 }
 
-                setTimeout(callback.bind.apply(callback, args), 0);
+                setTimeout(callback.bind(...args), 0);
             }.bind(this);
 
         // add two additional arguments at the end of the arguments saved - i.e. the payload and a function to call the
@@ -186,20 +186,20 @@ pool = function (processors) {
     };
 
     Instruction.shift = function () {
-        return Instruction._queue.shift.apply(Instruction._queue, arguments);
+        return Instruction._queue.shift(...arguments);
     };
 
     Instruction.unshift = function () {
-        return Instruction._queue.unshift.apply(Instruction._queue, arguments);
+        return Instruction._queue.unshift(...arguments);
     };
 
     Instruction.push = function () {
-        return Instruction._queue.push.apply(Instruction._queue, arguments);
+        return Instruction._queue.push(...arguments);
     };
 
     return Instruction;
 };
 
 module.exports = {
-    pool: pool
+    pool
 };

package/lib/runner/replay-controller.js

@@ -10,8 +10,8 @@ var _ = require('lodash'),
  * Handles replay logic with replayState from context.
  * Makes sure request replays do not go into an infinite loop.
  *
- * @param {ReplayState} replayState
- * @param {Run} run
+ * @param {ReplayState} replayState -
+ * @param {Run} run -
  *
  * @constructor
  */
@@ -25,13 +25,13 @@ _.assign(ReplayController.prototype, /** @lends ReplayController.prototype */{
     /**
      * Sends a request in the item. This takes care of limiting the total number of replays for a request.
      *
-     * @param {Object} context
-     * @param {Request} item
+     * @param {Object} context -
+     * @param {Request} item -
      * @param {Object} desiredPayload a partial payload to use for the replay request
      * @param {Function} success this callback is invoked when replay controller sent the request
      * @param {Function} failure this callback is invoked when replay controller decided not to send the request
      */
-    requestReplay: function (context, item, desiredPayload, success, failure) {
+    requestReplay (context, item, desiredPayload, success, failure) {
         // max retries exceeded
         if (this.count >= MAX_REPLAY_COUNT) {
             return failure(new Error('runtime: maximum intermediate request limit exceeded'));
@@ -66,7 +66,7 @@ _.assign(ReplayController.prototype, /** @lends ReplayController.prototype */{
      *
      * @returns {ReplayState}
      */
-    getReplayState: function () {
+    getReplayState () {
         /**
          * Defines the current replay state of a request.
          *

package/lib/runner/request-helpers-postsend.js

@@ -32,7 +32,8 @@ module.exports = [
         authHandler.post(authInterface, context.response, function (err, success) {
             // sync all auth system parameters to the original auth
             originalAuthParams && auth.parameters().each(function (param) {
-                param && param.system && originalAuthParams.upsert({key: param.key, value: param.value, system: true});
+                param && param.system &&
+                    originalAuthParams.upsert({ key: param.key, value: param.value, system: true });
             });
 
             // sync auth state back to item request
@@ -41,12 +42,10 @@ module.exports = [
             // there was an error in auth post hook
             // warn the user but don't bubble it up
             if (err) {
-                run.triggers.console(
-                    context.coords,
+                run.triggers.console(context.coords,
                     'warn',
                     'runtime~' + auth.type + '.auth: there was an error validating auth: ' + (err.message || err),
-                    err
-                );
+                    err);
 
                 return done();
             }
@@ -55,7 +54,7 @@ module.exports = [
             if (success) { return done(); }
 
             // request a replay of request
-            done(null, {replay: true, helper: auth.type + DOT_AUTH});
+            done(null, { replay: true, helper: auth.type + DOT_AUTH });
         });
     }
 ];

package/lib/runner/request-helpers-presend.js

@@ -43,9 +43,9 @@ module.exports = [
         async.waterfall([async.constant(data), {
             // form data parsing simply "enriches" all form parameters having file data type by replacing / setting the
             // value as a read stream
-            formdata: function (formdata, next) {
+            formdata (formdata, next) {
                 // ensure that we only process the file type
-                async.eachSeries(_.filter(formdata.all(), {type: 'file'}), function (formparam, callback) {
+                async.eachSeries(_.filter(formdata.all(), { type: 'file' }), function (formparam, callback) {
                     if (!formparam || formparam.disabled) {
                         return callback(); // disabled params will be filtered in body-builder.
                     }
@@ -100,7 +100,7 @@ module.exports = [
                                 return next(); // swallow the error
                             }
 
-                            next(null, {src: src, value: stream});
+                            next(null, { src: src, value: stream });
                         });
                     }, function (err, results) {
                         if (err) {
@@ -123,7 +123,7 @@ module.exports = [
                 }, next);
             },
             // file data
-            file: function (filedata, next) {
+            file (filedata, next) {
                 // eslint-disable-next-line security/detect-non-literal-fs-filename
                 util.createReadStream(resolver, filedata.src, function (err, stream) {
                     if (err) {
@@ -175,8 +175,7 @@ module.exports = [
                     run.triggers.console(context.coords,
                         'warn',
                         'runtime~' + authType + '.auth: could not sign the request: ' + (err.message || err),
-                        err
-                    );
+                        err);
 
                     // swallow the error, we've warned the user
                     done();
@@ -211,8 +210,7 @@ module.exports = [
                     run.triggers.console(context.coords,
                         'warn',
                         'runtime~' + authType + '.auth: could not validate the request: ' + (err.message || err),
-                        err
-                    );
+                        err);
 
                     // swallow the error, we've warned the user
                     return done();
@@ -221,7 +219,7 @@ module.exports = [
                 // sync all auth system parameters to the original auth
                 originalAuthParams && auth.parameters().each(function (param) {
                     param && param.system &&
-                        originalAuthParams.upsert({key: param.key, value: param.value, system: true});
+                        originalAuthParams.upsert({ key: param.key, value: param.value, system: true });
                 });
 
                 // authHandler gave a go, sign the request
@@ -232,14 +230,14 @@ module.exports = [
 
                 // prepare for sending intermediate request
                 var replayController = new ReplayController(context.replayState, run),
-                    item = new sdk.Item({request: request});
+                    item = new sdk.Item({ request });
 
                 // auth handler gave a no go, and an intermediate request.
                 // make the intermediate request the response is passed to `init` hook
                 replayController.requestReplay(context,
                     item,
                     // marks the auth as source for intermediate request
-                    {source: auth.type + DOT_AUTH},
+                    { source: auth.type + DOT_AUTH },
                     function (err, response) {
                         // errors for intermediate requests are passed to request callback
                         // passing it here will add it to original request as well, so don't do it
@@ -263,14 +261,12 @@ module.exports = [
                     function (err) {
                         // warn users that maximum retries have exceeded
                         if (err) {
-                            run.triggers.console(
-                                context.coords, 'warn', 'runtime~' + authType + '.auth: ' + (err.message || err)
-                            );
+                            run.triggers.console(context.coords,
+                                'warn', 'runtime~' + authType + '.auth: ' + (err.message || err));
                         }
                         // but don't bubble up the error with the request
                         done();
-                    }
-                );
+                    });
             });
         };