loadtest 5.2.0 → 6.1.0

package/lib/options.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+import {readFile} from 'fs/promises'
+import * as path from 'path'
+import * as urlLib from 'url'
+import {addHeaders} from '../lib/headers.js'
+import {loadConfig} from '../lib/config.js'
+
+
+export async function processOptions(options) {
+	const packageJson = JSON.parse(await readFile(new URL('../package.json', import.meta.url)))
+	if (!options.url) {
+		throw new Error('Missing URL in options')
+	}
+	options.concurrency = options.concurrency || 1;
+	if (options.requestsPerSecond) {
+		options.requestsPerSecond = options.requestsPerSecond / options.concurrency;
+	}
+	if (!options.url.startsWith('http://') && !options.url.startsWith('https://') && !options.url.startsWith('ws://')) {
+		throw new Error(`Invalid URL ${options.url}, must be http://, https:// or ws://'`)
+	}
+	if (options.url.startsWith('ws:')) {
+		if (options.requestsPerSecond) {
+			throw new Error(`"requestsPerSecond" not supported for WebSockets`);
+		}
+	}
+	const configuration = loadConfig();
+
+	options.agentKeepAlive = options.keepalive || options.agent || configuration.agentKeepAlive;
+	options.indexParam = options.index || configuration.indexParam;
+
+	//TODO: add index Param
+	// Allow a post body string in options
+	// Ex -P '{"foo": "bar"}'
+	if (options.postBody) {
+		options.method = 'POST';
+		options.body = options.postBody;
+	}
+	if (options.postFile) {
+		options.method = 'POST';
+		options.body = await readBody(options.postFile, '-p');
+	}
+	if (options.data) {
+		options.body = options.data
+	}
+	if (options.method) {
+		const acceptedMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'get', 'post', 'put', 'delete', 'patch'];
+		if (acceptedMethods.indexOf(options.method) === -1) {
+			options.method = 'GET';
+		}
+	}
+	if (options.putFile) {
+		options.method = 'PUT';
+		options.body = await readBody(options.putFile, '-u');
+	}
+	if (options.patchBody) {
+		options.method = 'PATCH';
+		options.body = options.patchBody;
+	}
+	if (options.patchFile) {
+		options.method = 'PATCH';
+		options.body = await readBody(options.patchFile, '-a');
+	}
+	if (!options.method) {
+		options.method = configuration.method;
+	}
+	if (!options.body) {
+		if(configuration.body) {
+			options.body = configuration.body;
+		} else if (configuration.file) {
+			options.body = await readBody(configuration.file, 'configuration.request.file');
+		}
+	}
+	options.requestsPerSecond = options.rps ? parseFloat(options.rps) : configuration.requestsPerSecond;
+	if (!options.key) {
+		options.key = configuration.key;
+	}
+	if (options.key) {
+		options.key = await readFile(options.key)
+	}
+	if (!options.cert) {
+		options.cert = configuration.cert;
+	}
+	if (options.cert) {
+		options.cert = await readFile(options.cert);
+	}
+
+	const defaultHeaders = options.headers || !configuration.headers ? {} : configuration.headers;
+	defaultHeaders['host'] = urlLib.parse(options.url).host;
+	defaultHeaders['user-agent'] = 'loadtest/' + packageJson.version;
+	defaultHeaders['accept'] = '*/*';
+
+	if (options.headers) {
+		addHeaders(options.headers, defaultHeaders);
+		console.log('headers: %s, %j', typeof defaultHeaders, defaultHeaders);
+	}
+	options.headers = defaultHeaders;
+
+	if (!options.requestGenerator) {
+		options.requestGenerator = configuration.requestGenerator;
+	}
+	if (typeof options.requestGenerator == 'string') {
+		options.requestGenerator = await import(options.requestGenerator)
+	}
+
+	// Use configuration file for other values
+	if(!options.maxRequests) {
+		options.maxRequests = configuration.maxRequests;
+	}
+	if(!options.concurrency) {
+		options.concurrency = configuration.concurrency;
+	}
+	if(!options.maxSeconds) {
+		options.maxSeconds = configuration.maxSeconds;
+	}
+	if(!options.timeout && configuration.timeout) {
+		options.timeout = configuration.timeout;
+	}
+	if(!options.contentType) {
+		options.contentType = configuration.contentType;
+	}
+	if(!options.cookies) {
+		options.cookies = configuration.cookies;
+	}
+	if(!options.secureProtocol) {
+		options.secureProtocol = configuration.secureProtocol;
+	}
+	if(!options.insecure) {
+		options.insecure = configuration.insecure;
+	}
+	if(!options.recover) {
+		options.recover = configuration.recover;
+	}
+	if(!options.proxy) {
+		options.proxy = configuration.proxy;
+	}
+}
+
+async function readBody(filename, option) {
+	if (typeof filename !== 'string') {
+		throw new Error(`Invalid file to open with ${option}: ${filename}`);
+	}
+
+	if (path.extname(filename) === '.js') {
+		return await import(new URL(filename, `file://${process.cwd()}/`))
+	}
+
+	const ret = await readFile(filename, {encoding: 'utf8'}).replace("\n", "");
+
+	return ret;
+}
+

package/lib/show.js

@@ -0,0 +1,47 @@
+
+
+/**
+ * Show result of a load test.
+ */
+export function showResult(options, result) {
+	console.info('');
+	console.info('Target URL:          %s', options.url);
+	if (options.maxRequests) {
+		console.info('Max requests:        %s', options.maxRequests);
+	} else if (options.maxSeconds) {
+		console.info('Max time (s):        %s', options.maxSeconds);
+	}
+	console.info('Concurrency level:   %s', options.concurrency);
+	let agent = 'none';
+	if (options.agentKeepAlive) {
+		agent = 'keepalive';
+	}
+	console.info('Agent:               %s', agent);
+	if (options.requestsPerSecond) {
+		console.info('Requests per second: %s', options.requestsPerSecond * options.concurrency);
+	}
+	console.info('');
+	console.info('Completed requests:  %s', result.totalRequests);
+	console.info('Total errors:        %s', result.totalErrors);
+	console.info('Total time:          %s s', result.totalTimeSeconds);
+	console.info('Requests per second: %s', result.rps);
+	console.info('Mean latency:        %s ms', result.meanLatencyMs);
+	console.info('');
+	console.info('Percentage of the requests served within a certain time');
+
+	Object.keys(result.percentiles).forEach(percentile => {
+		console.info('  %s%      %s ms', percentile, result.percentiles[percentile]);
+	});
+
+	console.info(' 100%      %s ms (longest request)', result.maxLatencyMs);
+	if (result.totalErrors) {
+		console.info('');
+		Object.keys(result.errorCodes).forEach(errorCode => {
+			const padding = ' '.repeat(errorCode.length < 4 ? 4 - errorCode.length : 1);
+			console.info(' %s%s:   %s errors', padding, errorCode, result.errorCodes[errorCode]);
+		});
+	}
+}
+
+
+

package/lib/testserver.js

@@ -1,24 +1,9 @@
-'use strict';
+import * as http from 'http'
+import {server as WebSocketServer} from 'websocket'
+import * as util from 'util'
+import * as net from 'net'
+import {Latency} from './latency.js'
 
-/**
- * Test server to load test.
- * (C) 2013 Alex Fernández.
- */
-
-
-// requires
-const testing = require('testing');
-const http = require('http');
-const WebSocketServer = require('websocket').server;
-const util = require('util');
-const net = require('net');
-const Log = require('log');
-const {Latency} = require('./latency.js');
-
-// globals
-const log = new Log('info');
-
-// constants
 const PORT = 7357;
 const LOG_HEADERS_INTERVAL_SECONDS = 1;
 
@@ -34,14 +19,11 @@ class TestServer {
 		this.wsServer = null;
 		this.latency = new Latency({});
 		this.debuggedTime = Date.now();
-		if (options.quiet) {
-			log.level = 'notice';
-		}
 	}
 
 	/**
 	 * Start the server.
-	 * An optional callback will be called after the server has started.
+	 * The callback parameter will be called after the server has started.
 	 */
 	start(callback) {
 		if (this.options.socket) {
@@ -63,38 +45,30 @@ class TestServer {
 			return this.createError('Could not start server on port ' + this.port + ': ' + error, callback);
 		});
 		this.server.listen(this.port, () => {
-			log.info('Listening on port %s', this.port);
-			if (callback) {
-				callback();
-			}
+			if (!this.options.quiet) console.info(`Listening on http://localhost:${this.port}/`)
+			callback(null, this.server)
 		});
 		this.wsServer.on('request', request => {
 			// explicity omitting origin check here.
 			const connection = request.accept(null, request.origin);
-			log.debug(' Connection accepted.');
 			connection.on('message', message => {
 				if (message.type === 'utf8') {
-					log.debug('Received Message: ' + message.utf8Data);
 					connection.sendUTF(message.utf8Data);
 				} else if (message.type === 'binary') {
-					log.debug('Received Binary Message of ' + message.binaryData.length + ' bytes');
 					connection.sendBytes(message.binaryData);
 				}
 			});
 			connection.on('close', () => {
-				log.info('Peer %s disconnected', connection.remoteAddress);
+				if (!this.options.quiet) console.info('Peer %s disconnected', connection.remoteAddress);
 			});
 		});
-		return this.server;
+		return this.server
 	}
 
 	/**
 	 * Log an error, or send to the callback if present.
 	 */
 	createError(message, callback) {
-		if (!callback) {
-			return log.error(message);
-		}
 		callback(message);
 	}
 
@@ -127,7 +101,7 @@ class TestServer {
 	 */
 	socketListen(socket) {
 		socket.on('error', error => {
-			log.error('socket error: %s', error);
+			if (!this.options.quiet) console.error('socket error: %s', error);
 			socket.end();
 		});
 		socket.on('data', data => this.readData(data));
@@ -137,16 +111,16 @@ class TestServer {
 	 * Read some data off the socket.
 	 */
 	readData(data) {
-		log.info('data: %s', data);
+		if (!this.options.quiet) console.info('data: %s', data);
 	}
 
 	/**
 	 * Debug headers and other interesting information: POST body.
 	 */
 	debug(request) {
-		log.info('Headers for %s to %s: %s', request.method, request.url, util.inspect(request.headers));
+		if (!this.options.quiet) console.info('Headers for %s to %s: %s', request.method, request.url, util.inspect(request.headers));
 		if (request.body) {
-			log.info('Body: %s', request.body);
+			if (!this.options.quiet) console.info('Body: %s', request.body);
 		}
 	}
 
@@ -173,7 +147,7 @@ class TestServer {
 		}
 		const percent = parseInt(this.options.percent, 10);
 		if (!percent) {
-			log.error('Invalid error percent %s', this.options.percent);
+			if (!this.options.quiet) console.error('Invalid error percent %s', this.options.percent);
 			return false;
 		}
 		return (Math.random() < percent / 100);
@@ -181,45 +155,26 @@ class TestServer {
 }
 
 /**
- * Start a test server. Options can contain:
- *	- port: the port to use, default 7357.
- *	- delay: wait the given milliseconds before answering.
- *	- quiet: do not log any messages.
- *	- percent: give an error (default 500) on some % of requests.
- *	- error: set an HTTP error code, default is 500.
- * An optional callback is called after the server has started.
- * In this case the quiet option is enabled.
+ * Start a test server. Parameters:
+ * - `options`, can contain:
+ *	 - port: the port to use, default 7357.
+ *	 - delay: wait the given milliseconds before answering.
+ *	 - quiet: do not log any messages.
+ *	 - percent: give an error (default 500) on some % of requests.
+ *	 - error: set an HTTP error code, default is 500.
+ * - `callback`: optional callback, called after the server has started.
+ *   If not present will return a promise.
  */
-exports.startServer = function(options, callback) {
+export function startServer(options, callback) {
+	const server = new TestServer(options);
 	if (callback) {
-		options.quiet = true;
+		return server.start(callback)
 	}
-	const server = new TestServer(options);
-	return server.start(callback);
-};
-
-function testStartServer(callback) {
-	const options = {
-		port: 10530,
-	};
-	const server = exports.startServer(options, error => {
-		testing.check(error, 'Could not start server', callback);
-		server.close(error => {
-			testing.check(error, 'Could not stop server', callback);
-			testing.success(callback);
-		});
-	});
-}
-
-/**
- * Run the tests.
- */
-exports.test = function(callback) {
-	testing.run([testStartServer], 5000, callback);
-};
-
-// start server if invoked directly
-if (__filename == process.argv[1]) {
-	exports.test(testing.show);
+	return new Promise((resolve, reject) => {
+		server.start((error, result) => {
+			if (error) return reject(error)
+			return resolve(result)
+		})
+	})
 }
 

package/lib/websocket.js

@@ -1,28 +1,15 @@
-'use strict';
+import websocket from 'websocket'
+import {BaseClient} from './baseClient.js'
 
-/**
- * Load test a websocket.
- * (C) 2013 Alex Fernández.
- */
-
-
-// requires
-const WebSocketClient = require('websocket').client;
-const testing = require('testing');
-const Log = require('log');
-const BaseClient = require('./baseClient.js').BaseClient;
-
-// globals
-const log = new Log('info');
 let latency;
 
 
 /**
  * Create a client for a websocket.
  */
-exports.create = function(operation, params) {
+export function create(operation, params) {
 	return new WebsocketClient(operation, params);
-};
+}
 
 /**
  * A client that connects to a websocket.
@@ -40,13 +27,10 @@ class WebsocketClient extends BaseClient {
 	 * Start the websocket client.
 	 */
 	start() {
-		this.client = new WebSocketClient();
-		this.client.on('connectFailed', error => {
-			log.debug('WebSocket client connection error ' + error);
-		});
+		this.client = new websocket.client();
+		this.client.on('connectFailed', () => {});
 		this.client.on('connect', connection => this.connect(connection));
 		this.client.connect(this.params.url, []);
-		log.debug('WebSocket client connected to ' + this.params.url);
 	}
 
 	/**
@@ -55,7 +39,6 @@ class WebsocketClient extends BaseClient {
 	stop() {
 		if (this.connection) {
 			this.connection.close();
-			log.debug('WebSocket client disconnected from ' + this.params.url);
 		}
 	}
 
@@ -100,7 +83,7 @@ class WebsocketClient extends BaseClient {
 				ended = true;
 
 				if (message.type != 'utf8') {
-					log.error('Invalid message type ' + message.type);
+					console.error('Invalid message type ' + message.type);
 					return;
 				}
 				let json;
@@ -108,12 +91,10 @@ class WebsocketClient extends BaseClient {
 					json = JSON.parse(message.utf8Data);
 				}
 				catch(e) {
-					log.error('Invalid JSON: ' + message.utf8Data);
+					console.error('Invalid JSON: ' + message.utf8Data);
 					return;
 				}
 
-				log.debug("Received response %j", json);
-
 				// eat the client_connected message we get at the beginning
 				if ((json && json[0] && json[0][0] == 'client_connected')) {
 					ended = false;
@@ -123,7 +104,6 @@ class WebsocketClient extends BaseClient {
 				if (this.lastCall) {
 					const newCall = new Date().getTime();
 					latency.add(newCall - this.lastCall);
-					log.debug('latency: ' + (newCall - this.lastCall));
 					this.lastCall = null;
 				}
 
@@ -152,29 +132,3 @@ class WebsocketClient extends BaseClient {
 	}
 }
 
-
-function testWebsocketClient(callback) {
-	const options = {
-		url: 'ws://localhost:7357/',
-		maxSeconds: 0.1,
-		concurrency: 1,
-		quiet: true,
-	};
-	exports.create({}, options);
-	testing.success(callback);
-}
-
-/**
- * Run tests, currently nothing.
- */
-exports.test = function(callback) {
-	testing.run([
-		testWebsocketClient,
-	], callback);
-};
-
-// start tests if invoked directly
-if (__filename == process.argv[1]) {
-	exports.test(testing.show);
-}
-

package/package.json

@@ -1,6 +1,7 @@
 {
 	"name": "loadtest",
-	"version": "5.2.0",
+	"version": "6.1.0",
+	"type": "module",
 	"description": "Run load tests for your web application. Mostly ab-compatible interface, with an option to force requests per second. Includes an API for automated load testing.",
 	"homepage": "https://github.com/alexfernandez/loadtest",
 	"contributors": [
@@ -17,13 +18,12 @@
 		"agentkeepalive": "^2.0.3",
 		"confinode": "^2.1.1",
 		"https-proxy-agent": "^2.2.1",
-		"log": "1.4.*",
-		"stdio": "^0.2.3",
-		"testing": "^1.1.1",
-		"websocket": "^1.0.28"
+		"stdio": "0.2.7",
+		"testing": "^3.0.3",
+		"websocket": "^1.0.34"
 	},
 	"devDependencies": {
-		"eslint": "^4.19.1"
+		"eslint": "^8.47.0"
 	},
 	"keywords": [
 		"testing",
@@ -35,7 +35,7 @@
 		"black box"
 	],
 	"engines": {
-		"node": ">=10"
+		"node": ">=16"
 	},
 	"bin": {
 		"loadtest": "bin/loadtest.js",
@@ -43,7 +43,7 @@
 	},
 	"preferGlobal": true,
 	"scripts": {
-		"test": "node test.js",
+		"test": "node test/all.js",
 		"posttest": "eslint ."
 	},
 	"publishConfig": {

package/sample/post-file.js

@@ -0,0 +1,13 @@
+/**
+ * Sample post-file content for test.
+ * Contains a single exported function that generates the body.
+ */
+
+export default function bodyGenerator(requestId) {
+	// this object will be serialized to JSON and sent in the body of the request
+	return {
+		key: 'value',
+		requestId: requestId
+	}
+}
+

package/sample/request-generator.js

@@ -1,12 +1,10 @@
-'use strict';
-
 /**
  * Sample request generator usage.
  * Contributed by jjohnsonvng:
  * https://github.com/alexfernandez/loadtest/issues/86#issuecomment-211579639
  */
 
-const loadtest = require('../lib/loadtest.js');
+import {loadTest} from '../index.js'
 
 const options = {
 	url: 'http://yourHost',
@@ -27,11 +25,11 @@ const options = {
 	}
 };
 
-loadtest.loadTest(options, (error, results) => {
+loadTest(options, (error, result) => {
 	if (error) {
 		return console.error('Got an error: %s', error);
 	}
-	console.log(results);
+	console.log(result);
 	console.log('Tests run successfully');
 });
 

package/sample/request-generator.ts

@@ -25,9 +25,9 @@ const options: loadtest.LoadTestOptions = {
     },
 }
 
-loadtest.loadTest(options, (error, results) => {
+loadtest.loadTest(options, (error, result) => {
     if (error) {
         return console.error(`Got an error: ${error}`)
     }
-    console.log("Tests run successfully", {results})
+    console.log("Tests run successfully", {result})
 })

package/test/all.js

@@ -0,0 +1,33 @@
+/**
+ * Run package tests.
+ * (C) 2013 Alex Fernández.
+ */
+
+import testing from 'testing'
+import {test as testHrtimer} from './hrtimer.js'
+import {test as testHeaders} from './headers.js'
+import {test as testLatency} from './latency.js'
+import {test as testHttpClient} from './httpClient.js'
+import {test as testServer} from './testserver.js'
+import {test as testRequestGenerator} from './request-generator.js'
+import {test as testBodyGenerator} from './body-generator.js'
+import {test as testLoadtest} from './loadtest.js'
+import {test as testWebsocket} from './websocket.js'
+import {test as integrationTest} from './integration.js'
+
+
+/**
+ * Run all module tests.
+ */
+function test() {
+	const tests = [
+		testHrtimer, testHeaders, testLatency, testHttpClient,
+		testServer, integrationTest, testLoadtest, testWebsocket,
+		testRequestGenerator, testBodyGenerator,
+	];
+	testing.run(tests, 4200);
+}
+
+test()
+
+

package/test/body-generator.js

@@ -0,0 +1,42 @@
+import testing from 'testing'
+import {loadTest} from '../lib/loadtest.js'
+import {startServer} from '../lib/testserver.js'
+
+const PORT = 10453;
+
+
+function testBodyGenerator(callback) {
+	const server = startServer({port: PORT, quiet: true}, error => {
+		if (error) {
+			return callback('Could not start test server');
+		}
+		const options = {
+			url: 'http://localhost:' + PORT,
+			requestsPerSecond: 100,
+			maxRequests: 100,
+			concurrency: 10,
+			postFile: 'sample/post-file.js',
+			quiet: true,
+		}
+		loadTest(options, (error, result) => {
+			if (error) {
+				console.error(error)
+				return callback(`Could not run load test with postFile: ${error.message}`);
+			}
+			server.close(error => {
+				if (error) {
+					return callback('Could not close test server');
+				}
+				return callback(null, 'bodyGenerator succeeded: ' + JSON.stringify(result));
+			});
+		});
+	});
+}
+
+/**
+ * Run all tests.
+ */
+export function test(callback) {
+	testing.run([testBodyGenerator], 4000, callback);
+}
+