@artilleryio/int-core 2.27.0 → 2.28.0-670d2fa

package/dist/lib/engine_socketio.js

@@ -0,0 +1,347 @@
+/* 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/. */
+import { engine_util as engineUtil } from '@artilleryio/int-commons';
+import async from 'async';
+import createDebug from 'debug';
+import deepEqual from 'fast-deep-equal';
+import _ from 'lodash';
+import io from 'socket.io-client';
+import sioWildcard from 'socketio-wildcard';
+import EngineHttp from "./engine_http.js";
+const wildcardPatch = sioWildcard(io.Manager);
+const debug = createDebug('socketio');
+const template = engineUtil.template;
+export default SocketIoEngine;
+function SocketIoEngine(script) {
+    this.config = script.config;
+    this.socketioOpts = this.config.socketio || {};
+    this.httpDelegate = new EngineHttp(script);
+}
+SocketIoEngine.prototype.init = async function () {
+    await this.httpDelegate.init();
+};
+SocketIoEngine.prototype.createScenario = function (scenarioSpec, ee) {
+    // Adds scenario overridden configuration into the static config
+    this.socketioOpts = { ...this.socketioOpts, ...scenarioSpec.socketio };
+    const tasks = _.map(scenarioSpec.flow, (rs) => {
+        if (typeof rs.think !== 'undefined') {
+            return engineUtil.createThink(rs, _.get(this.config, 'defaults.think', {}));
+        }
+        return this.step(rs, ee);
+    });
+    return this.compile(tasks, scenarioSpec.flow, ee);
+};
+function markEndTime(ee, _, startedAt) {
+    const endedAt = process.hrtime(startedAt);
+    const delta = endedAt[0] * 1e9 + endedAt[1];
+    ee.emit('histogram', 'socketio.response_time', delta / 1e6);
+}
+function isResponseRequired(spec) {
+    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 && !isValid(data, response)) {
+        debug('data is not valid:');
+        debug(data);
+        debug(response);
+        const err = 'data is not valid';
+        ee.emit('error', err);
+        return callback(err, context);
+    }
+    // If no capture or match specified, then we consider it a success at this point...
+    if (!response.capture && !response.match) {
+        return callback(null, context);
+    }
+    // Construct the (HTTP) response...
+    const fauxResponse = { body: JSON.stringify(data) };
+    // Handle the capture or match clauses...
+    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);
+        }
+        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, (v, k) => {
+                    context.vars[k] = v.value;
+                });
+            }
+            // Replace the base object context
+            // Question: Should this be JSON object or String?
+            context.vars.$ = fauxResponse.body;
+            // Increment the success count...
+            context._successCount++;
+            return callback(null, context);
+        }
+    });
+}
+SocketIoEngine.prototype.step = function (requestSpec, ee) {
+    const self = this;
+    if (requestSpec.loop) {
+        const steps = _.map(requestSpec.loop, (rs) => {
+            if (!rs.emit && !rs.loop) {
+                return self.httpDelegate.step(rs, ee);
+            }
+            return self.step(rs, ee);
+        });
+        return engineUtil.createLoopWithCount(requestSpec.count || -1, steps, {
+            loopValue: requestSpec.loopValue,
+            loopElement: requestSpec.loopElement || '$loopElement',
+            overValues: requestSpec.over,
+            whileTrue: self.config.processor
+                ? self.config.processor[requestSpec.whileTrue]
+                : undefined
+        });
+    }
+    const f = (context, callback) => {
+        // Only process emit requests; delegate the rest to the HTTP engine (or think utility)
+        if (requestSpec.think) {
+            return engineUtil.createThink(requestSpec, _.get(self.config, 'defaults.think', {}));
+        }
+        if (!requestSpec.emit) {
+            const delegateFunc = self.httpDelegate.step(requestSpec, ee);
+            return delegateFunc(context, callback);
+        }
+        ee.emit('counter', 'socketio.emit', 1);
+        ee.emit('rate', 'socketio.emit_rate');
+        const startedAt = process.hrtime();
+        const socketio = context.sockets[requestSpec.namespace] || null;
+        if (!(requestSpec.emit && socketio)) {
+            debug('invalid arguments');
+            ee.emit('error', 'invalid arguments');
+            // TODO: Provide a more helpful message
+            callback(new Error('socketio: invalid arguments'));
+        }
+        const outgoing = requestSpec.emit.channel
+            ? [
+                template(requestSpec.emit.channel, context),
+                template(requestSpec.emit.data, context)
+            ]
+            : Array.from(requestSpec.emit).map((arg) => template(arg, context));
+        const endCallback = (err, context, needEmit) => {
+            if (err) {
+                debug(err);
+            }
+            if (isAcknowledgeRequired(requestSpec)) {
+                const ackCallback = (...args) => {
+                    const response = {
+                        data: template(requestSpec.acknowledge.data || requestSpec.acknowledge.args, context),
+                        capture: template(requestSpec.acknowledge.capture, context),
+                        match: template(requestSpec.acknowledge.match, context)
+                    };
+                    // Make sure data, capture or match has a default json spec for parsing socketio responses
+                    _.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, (err) => {
+                        if (!err) {
+                            markEndTime(ee, context, startedAt);
+                        }
+                        return callback(err, context);
+                    });
+                };
+                // Acknowledge required so add callback to emit
+                if (needEmit) {
+                    socketio.emit(...outgoing, ackCallback);
+                }
+                else {
+                    ackCallback();
+                }
+            }
+            else {
+                // No acknowledge data is expected, so emit without a listener
+                if (needEmit) {
+                    socketio.emit(...outgoing);
+                }
+                markEndTime(ee, context, startedAt);
+                return callback(err, context);
+            }
+        }; // endCallback
+        if (isResponseRequired(requestSpec)) {
+            const response = {
+                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;
+            const responseData = [];
+            socketio.on(response.channel, function receive(...args) {
+                responseData.push(...args);
+                if (isValid(responseData, response)) {
+                    done = true;
+                    processResponse(ee, responseData, response, context, (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
+            socketio.emit(...outgoing);
+            // If we don't get a response within the timeout, fire an error
+            const waitTime = (self.config.timeout || 10) * 1000;
+            setTimeout(function responseTimeout() {
+                if (!done) {
+                    if (responseData.length) {
+                        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;
+                    }
+                    const err = 'response timeout';
+                    ee.emit('error', err);
+                    return callback(err, context);
+                }
+            }, waitTime);
+        }
+        else {
+            endCallback(null, context, true);
+        }
+    };
+    function preStep(context, callback) {
+        // Set default namespace in emit action
+        requestSpec.namespace = template(requestSpec.namespace, context) || '';
+        self.loadContextSocket(requestSpec.namespace, context, (err) => {
+            if (err) {
+                debug(err);
+                ee.emit('error', err.message);
+                return callback(err, context);
+            }
+            return f(context, callback);
+        });
+    }
+    if (requestSpec.emit) {
+        return preStep;
+    }
+    else {
+        return f;
+    }
+};
+SocketIoEngine.prototype.loadContextSocket = function (namespace, context, cb) {
+    context.sockets = context.sockets || {};
+    if (!context.sockets[namespace]) {
+        const target = this.config.target + namespace;
+        const tls = this.config.tls || {};
+        const socketioOpts = template(this.socketioOpts, context);
+        const options = _.extend({}, socketioOpts, // templated
+        tls);
+        const socket = io(target, options);
+        context.sockets[namespace] = socket;
+        wildcardPatch(socket);
+        socket.on('*', () => {
+            context.__receivedMessageCount++;
+        });
+        socket.once('connect', () => {
+            cb(null, socket);
+        });
+        socket.once('connect_error', (err) => {
+            cb(err, null);
+        });
+        socket.once('error', (err) => {
+            cb(err, socket);
+        });
+    }
+    else {
+        return cb(null, context.sockets[namespace]);
+    }
+};
+SocketIoEngine.prototype.closeContextSockets = (context) => {
+    if (context.sockets && Object.keys(context.sockets).length > 0) {
+        const namespaces = Object.keys(context.sockets);
+        namespaces.forEach((namespace) => {
+            context.sockets[namespace].disconnect();
+        });
+    }
+};
+SocketIoEngine.prototype.compile = function (tasks, scenarioSpec, ee) {
+    const self = this;
+    function zero(callback, context) {
+        context.__receivedMessageCount = 0;
+        ee.emit('started');
+        self.loadContextSocket('', context, function done(err) {
+            if (err) {
+                ee.emit('error', err);
+                return callback(err, context);
+            }
+            return callback(null, context);
+        });
+    }
+    return function scenario(initialContext, callback) {
+        initialContext = self.httpDelegate.setInitialContext(initialContext);
+        initialContext._pendingRequests = _.size(_.reject(scenarioSpec, (rs) => typeof rs.think === 'number'));
+        const steps = _.flatten([
+            function z(cb) {
+                return zero(cb, initialContext);
+            },
+            tasks
+        ]);
+        async.waterfall(steps, function scenarioWaterfallCb(err, context) {
+            if (err) {
+                debug(err);
+            }
+            if (context) {
+                self.closeContextSockets(context);
+            }
+            return callback(err, context);
+        });
+    };
+};

package/dist/lib/engine_ws.js

@@ -0,0 +1,278 @@
+/* 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/. */
+import url from 'node:url';
+import { engine_util as engineUtil } from '@artilleryio/int-commons';
+import async from 'async';
+import createDebug from 'debug';
+import HttpsProxyAgent from 'https-proxy-agent';
+import _ from 'lodash';
+import WebSocket from 'ws';
+const debug = createDebug('ws');
+const template = engineUtil.template;
+// Injectable dependencies - module namespaces are frozen, so tests
+// replace the WebSocket implementation through this mutable object
+export const _deps = { WebSocket };
+export default WSEngine;
+function WSEngine(script) {
+    this.config = script.config;
+}
+WSEngine.prototype.createScenario = function (scenarioSpec, ee) {
+    const tasks = _.map(scenarioSpec.flow, (rs) => {
+        if (typeof rs.think !== 'undefined') {
+            return engineUtil.createThink(rs, _.get(this.config, 'defaults.think', {}));
+        }
+        return this.step(rs, ee);
+    });
+    return this.compile(tasks, scenarioSpec.flow, ee);
+};
+function getMessageHandler(context, params, ee, timeout, callback) {
+    let done = false;
+    setTimeout(() => {
+        if (!done) {
+            const err = 'response timeout';
+            ee.emit('error', err);
+            return callback(err, context);
+        }
+    }, timeout * 1000);
+    return function messageHandler(event) {
+        ee.emit('counter', 'websocket.messages_received', 1);
+        ee.emit('rate', 'websocket.receive_rate');
+        done = true;
+        const { data } = event;
+        debug('WS receive: %s', data);
+        if (!data) {
+            return callback(new Error('Empty response from WS server'), context);
+        }
+        let fauxResponse;
+        try {
+            fauxResponse = { body: JSON.parse(data) };
+        }
+        catch (_err) {
+            fauxResponse = { body: event.data };
+        }
+        engineUtil.captureOrMatch(params, fauxResponse, context, function captured(err, result) {
+            if (err) {
+                ee.emit('error', err.message || err.code);
+                return callback(err, context);
+            }
+            const { captures = {}, matches = {} } = result;
+            debug('matches: ', matches);
+            debug('captures: ', captures);
+            // match and capture are strict by default:
+            const haveFailedMatches = _.some(result.matches, (v) => !v.success && v.strict !== false);
+            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, (v) => {
+                ee.emit('match', v.success, {
+                    expected: v.expected,
+                    got: v.got,
+                    expression: v.expression,
+                    strict: v.strict
+                });
+            });
+            _.each(result.captures, (v, k) => {
+                _.set(context.vars, k, v.value);
+            });
+            return callback(null, context);
+        });
+    };
+}
+WSEngine.prototype.step = function (requestSpec, ee) {
+    if (requestSpec.loop) {
+        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: this.config.processor
+                ? this.config.processor[requestSpec.whileTrue]
+                : undefined
+        });
+    }
+    if (requestSpec.think) {
+        return engineUtil.createThink(requestSpec, _.get(this.config, 'defaults.think', {}));
+    }
+    if (requestSpec.function) {
+        return (context, callback) => {
+            const processFunc = this.config.processor[requestSpec.function];
+            if (processFunc) {
+                if (processFunc.constructor.name === 'Function') {
+                    processFunc(context, ee, () => callback(null, context));
+                }
+                else {
+                    return processFunc(context, ee)
+                        .then(() => {
+                        callback(null, context);
+                    })
+                        .catch((err) => {
+                        callback(err, context);
+                    });
+                }
+            }
+        };
+    }
+    if (requestSpec.log) {
+        return (context, callback) => {
+            console.log(template(requestSpec.log, context));
+            return process.nextTick(() => {
+                callback(null, context);
+            });
+        };
+    }
+    if (requestSpec.connect) {
+        return (context, callback) => process.nextTick(() => {
+            callback(null, context);
+        });
+    }
+    const f = (context, callback) => {
+        const params = requestSpec.wait || requestSpec.send;
+        // match exists on a string, so check match is not a prototype
+        const captureOrMatch = _.has(params, 'capture') || _.has(params, 'match');
+        if (captureOrMatch) {
+            // only process response if we're capturing
+            const timeout = this.config.timeout || _.get(this.config, 'ws.timeout') || 10;
+            context.ws.onmessage = getMessageHandler(context, params, ee, timeout, callback);
+        }
+        else {
+            // Reset onmessage to stop steps interfering with each other
+            context.ws.onmessage = undefined;
+        }
+        // Backwards compatible with previous version of `send` api
+        let payload = captureOrMatch ? params.payload : params;
+        if (payload !== undefined) {
+            payload = template(payload, context);
+            if (typeof payload === 'object') {
+                payload = JSON.stringify(payload);
+            }
+            else {
+                payload = _.toString(payload);
+            }
+            ee.emit('counter', 'websocket.messages_sent', 1);
+            ee.emit('rate', 'websocket.send_rate');
+            debug('WS send: %s', payload);
+            context.ws.send(payload, (err) => {
+                if (err) {
+                    debug(err);
+                    ee.emit('error', err);
+                    return callback(err, null);
+                }
+                // End step if we're not capturing
+                if (!captureOrMatch) {
+                    return callback(null, context);
+                }
+            });
+        }
+        else if (captureOrMatch) {
+            debug('WS wait: %j', params);
+        }
+        else {
+            // in the end, we could not send anything, so report it and stop
+            const err = 'invalid_step';
+            debug(err, requestSpec);
+            ee.emit('error', err);
+            return callback(err, context);
+        }
+    };
+    return f;
+};
+function getWsOptions(config) {
+    const options = getWsConfig(config);
+    const subprotocols = _.get(config, 'ws.subprotocols', []);
+    const headers = _.get(config, 'ws.headers', {});
+    const subprotocolHeader = _.find(headers, (_value, headerName) => {
+        return headerName.toLowerCase() === 'sec-websocket-protocol';
+    });
+    if (typeof subprotocolHeader !== 'undefined') {
+        // NOTE: subprotocols defined via config.ws.subprotocols take precedence:
+        subprotocols.push(...subprotocolHeader.split(',').map((s) => s.trim()));
+    }
+    return { options, subprotocols };
+}
+function getWsInstance(config, scenarioSpec, context, cb) {
+    let wsArgs = {
+        ...getWsOptions(config),
+        target: config.target
+    };
+    const [{ connect }] = scenarioSpec;
+    if (connect) {
+        if (connect.function && config.processor[connect.function]) {
+            const processFn = config.processor[connect.function];
+            return processFn(wsArgs, context, (err) => {
+                if (err) {
+                    debug('connect.function', err);
+                    return cb(err, null);
+                }
+                context.wsArgs = wsArgs;
+                return cb(null, context);
+            });
+        }
+        else if (_.isPlainObject(connect)) {
+            const { target = config.target, headers = _.get(config, 'ws.headers', {}), subprotocols = _.get(config, 'ws.subprotocols', []), ...instanceConfig } = connect;
+            const opt = getWsOptions({
+                tls: config.tls,
+                ws: { subprotocols, headers, ...instanceConfig }
+            });
+            wsArgs = {
+                target: template(target, context),
+                ...opt
+            };
+        }
+        else {
+            wsArgs.target = template(connect, context);
+        }
+    }
+    debug('new WebSocket instance:', wsArgs);
+    context.wsArgs = wsArgs;
+    return cb(null, context);
+}
+WSEngine.prototype.compile = function (tasks, scenarioSpec, ee) {
+    const config = this.config;
+    return function scenario(initialContext, callback) {
+        function zero(cb) {
+            ee.emit('started');
+            getWsInstance(config, scenarioSpec, initialContext, cb);
+        }
+        function one(context, cb) {
+            const { wsArgs, ...contextWithoutWsArgs } = context;
+            const ws = new _deps.WebSocket(wsArgs.target, wsArgs.subprotocols, wsArgs.options);
+            ws.on('open', () => {
+                contextWithoutWsArgs.ws = ws;
+                return cb(null, contextWithoutWsArgs);
+            });
+            ws.once('error', (err) => {
+                debug(err);
+                ee.emit('error', err.message || err.code);
+                return cb(err, {});
+            });
+        }
+        initialContext._successCount = 0;
+        const steps = _.flatten([zero, one, tasks]);
+        async.waterfall(steps, function scenarioWaterfallCb(err, context) {
+            if (err) {
+                ee.emit('error', err.code || err.message);
+                debug(err);
+            }
+            if (context?.ws) {
+                context.ws.close();
+            }
+            return callback(err, context);
+        });
+    };
+};
+function getWsConfig(config) {
+    const tls = config.tls || {};
+    const { proxy, ...options } = config.ws || {};
+    if (proxy) {
+        const { url: proxyUrl, ...proxyOptions } = proxy;
+        debug('Set proxy: %s, options: %s', proxyUrl, proxyOptions);
+        const agent = new HttpsProxyAgent({
+            ...url.parse(proxyUrl),
+            ...proxyOptions
+        });
+        options.agent = agent;
+    }
+    return _.extend(tls, options);
+}

package/dist/lib/is-idle-phase.js

@@ -0,0 +1,9 @@
+/* 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/. */
+export default function isIdlePhase(phase) {
+    return ((phase.arrivalRate === 0 && !phase.rampTo) ||
+        phase.arrivalCount === 0 ||
+        phase.maxVusers === 0 ||
+        phase.pause > 0);
+}