loadtest 6.0.0 → 6.2.0

package/lib/options.js

@@ -1,25 +1,18 @@
-#!/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'
 
+const acceptedMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'get', 'post', 'put', 'delete', 'patch'];
 
-export function processOptions(options, callback) {
-	processOptionsAsync(options).then(result => callback(null, result)).catch(error => callback(error))
-}
 
-async function processOptionsAsync(options) {
+export async function processOptions(options) {
+	const processed = {}
 	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://'`)
 	}
@@ -28,129 +21,88 @@ async function processOptionsAsync(options) {
 			throw new Error(`"requestsPerSecond" not supported for WebSockets`);
 		}
 	}
+	processed.url = options.url
 	const configuration = loadConfig();
-
-	options.agentKeepAlive = options.keepalive || options.agent || configuration.agentKeepAlive;
-	options.indexParam = options.index || configuration.indexParam;
-
-	//TODO: add index Param
+	processed.concurrency = options.concurrency || configuration.concurrency || 1
+	const rps = options.rps ? parseFloat(options.rps) : null
+	processed.requestsPerSecond = options.requestsPerSecond || rps || configuration.requestsPerSecond
+	processed.agentKeepAlive = options.keepalive || options.agent || options.agentKeepAlive || configuration.agentKeepAlive;
+	processed.indexParam = options.index || options.indexParam || configuration.indexParam;
+	processed.method = options.method || configuration.method || 'GET'
 	// Allow a post body string in options
 	// Ex -P '{"foo": "bar"}'
 	if (options.postBody) {
-		options.method = 'POST';
-		options.body = options.postBody;
+		processed.method = 'POST';
+		processed.body = options.postBody;
 	}
 	if (options.postFile) {
-		options.method = 'POST';
-		options.body = await readBody(options.postFile, '-p');
+		processed.method = 'POST';
+		processed.body = await readBody(options.postFile, '-p');
 	}
 	if (options.data) {
-		options.body = JSON.parse(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';
-		}
+		processed.body = options.data
 	}
 	if (options.putFile) {
-		options.method = 'PUT';
-		options.body = await readBody(options.putFile, '-u');
+		processed.method = 'PUT';
+		processed.body = await readBody(options.putFile, '-u');
 	}
 	if (options.patchBody) {
-		options.method = 'PATCH';
-		options.body = options.patchBody;
+		processed.method = 'PATCH';
+		processed.body = options.patchBody;
 	}
 	if (options.patchFile) {
-		options.method = 'PATCH';
-		options.body = await readBody(options.patchFile, '-a');
+		processed.method = 'PATCH';
+		processed.body = await readBody(options.patchFile, '-a');
 	}
-	if (!options.method) {
-		options.method = configuration.method;
+	// sanity check
+	if (acceptedMethods.indexOf(processed.method) === -1) {
+		throw new Error(`Invalid method ${processed.method}`)
 	}
 	if (!options.body) {
 		if(configuration.body) {
-			options.body = configuration.body;
+			processed.body = configuration.body;
 		} else if (configuration.file) {
-			options.body = await readBody(configuration.file, 'configuration.request.file');
+			processed.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 || configuration.key) {
+		processed.key = await readFile(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);
+	if (options.cert || configuration.cert) {
+		processed.cert = await readFile(options.cert || configuration.cert);
 	}
-
-	const defaultHeaders = options.headers || !configuration.headers ? {} : configuration.headers;
-	defaultHeaders['host'] = urlLib.parse(options.url).host;
-	defaultHeaders['user-agent'] = 'loadtest/' + packageJson.version;
-	defaultHeaders['accept'] = '*/*';
+	processed.headers = configuration.headers || {}
+	processed.headers['host'] = urlLib.parse(options.url).host;
+	processed.headers['user-agent'] = 'loadtest/' + packageJson.version;
+	processed.headers['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;
-	}
+		addHeaders(options.headers, processed.headers);
+	}
+	processed.requestGenerator = options.requestGenerator || configuration.requestGenerator
+	if (typeof processed.requestGenerator == 'string') {
+		processed.requestGenerator = await import(processed.requestGenerator)
+	}
+	processed.maxRequests = options.maxRequests || configuration.maxRequests
+	processed.maxSeconds = options.maxSeconds || configuration.maxSeconds
+	processed.cookies = options.cookies || configuration.cookies
+	processed.contentType = options.contentType || configuration.contentType
+	processed.timeout = options.timeout || configuration.timeout
+	processed.secureProtocol = options.secureProtocol || configuration.secureProtocol
+	processed.insecure = options.insecure || configuration.insecure
+	processed.recover = options.recover || configuration.recover
+	processed.proxy = options.proxy || configuration.proxy
+	processed.quiet = options.quiet || configuration.quiet
+	return processed
 }
 
 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;
+	return await readFile(filename, {encoding: 'utf8'}).replace("\n", "");
 }
 

package/lib/result.js

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

package/lib/testserver.js

@@ -23,7 +23,7 @@ class TestServer {
 
 	/**
 	 * 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) {
@@ -45,10 +45,8 @@ class TestServer {
 			return this.createError('Could not start server on port ' + this.port + ': ' + error, callback);
 		});
 		this.server.listen(this.port, () => {
-			console.info(`Listening on http://localhost:${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.
@@ -61,19 +59,16 @@ class TestServer {
 				}
 			});
 			connection.on('close', () => {
-				console.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 console.error(message);
-		}
 		callback(message);
 	}
 
@@ -106,7 +101,7 @@ class TestServer {
 	 */
 	socketListen(socket) {
 		socket.on('error', error => {
-			console.error('socket error: %s', error);
+			if (!this.options.quiet) console.error('socket error: %s', error);
 			socket.end();
 		});
 		socket.on('data', data => this.readData(data));
@@ -116,16 +111,16 @@ class TestServer {
 	 * Read some data off the socket.
 	 */
 	readData(data) {
-		console.info('data: %s', data);
+		if (!this.options.quiet) console.info('data: %s', data);
 	}
 
 	/**
 	 * Debug headers and other interesting information: POST body.
 	 */
 	debug(request) {
-		console.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) {
-			console.info('Body: %s', request.body);
+			if (!this.options.quiet) console.info('Body: %s', request.body);
 		}
 	}
 
@@ -152,7 +147,7 @@ class TestServer {
 		}
 		const percent = parseInt(this.options.percent, 10);
 		if (!percent) {
-			console.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);
@@ -160,16 +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 (deprecated).
- *	- 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.
+ * 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.
  */
 export function startServer(options, callback) {
 	const server = new TestServer(options);
-	return server.start(callback);
+	if (callback) {
+		return server.start(callback)
+	}
+	return new Promise((resolve, reject) => {
+		server.start((error, result) => {
+			if (error) return reject(error)
+			return resolve(result)
+		})
+	})
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "loadtest",
-	"version": "6.0.0",
+	"version": "6.2.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",
@@ -19,7 +19,7 @@
 		"confinode": "^2.1.1",
 		"https-proxy-agent": "^2.2.1",
 		"stdio": "0.2.7",
-		"testing": "^3.0.3",
+		"testing": "^3.1.0",
 		"websocket": "^1.0.34"
 	},
 	"devDependencies": {

package/sample/request-generator.js

@@ -25,11 +25,11 @@ const options = {
 	}
 };
 
-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/body-generator.js

@@ -6,16 +6,17 @@ const PORT = 10453;
 
 
 function testBodyGenerator(callback) {
-	const server = startServer({port: PORT}, error => {
+	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,
+			requestsPerSecond: 1000,
 			maxRequests: 100,
 			concurrency: 10,
 			postFile: 'sample/post-file.js',
+			quiet: true,
 		}
 		loadTest(options, (error, result) => {
 			if (error) {

package/test/integration.js

@@ -4,13 +4,17 @@ import {join} from 'path'
 import {loadTest, startServer} from '../index.js'
 
 const PORT = 10408;
+const serverOptions = {
+	port: PORT,
+	quiet: true,
+}
 
 
 /**
  * Run an integration test.
  */
 function testIntegration(callback) {
-	const server = startServer({ port: PORT }, error => {
+	const server = startServer(serverOptions, error => {
 		if (error) {
 			return callback(error);
 		}
@@ -22,6 +26,7 @@ function testIntegration(callback) {
 			body: {
 				hi: 'there',
 			},
+			quiet: true,
 		};
 		loadTest(options, (error, result) => {
 			if (error) {
@@ -31,7 +36,7 @@ function testIntegration(callback) {
 				if (error) {
 					return callback(error);
 				}
-				return callback(null, 'Test results: ' + JSON.stringify(result));
+				return callback(null, 'Test result: ' + JSON.stringify(result));
 			});
 		});
 	});
@@ -42,12 +47,13 @@ function testIntegration(callback) {
  * Run an integration test using configuration file.
  */
 function testIntegrationFile(callback) {
-	const server = startServer({ port: PORT }, error => {
+	const server = startServer(serverOptions, error => {
 		if (error) {
 			return callback(error);
 		}
 		execFile('node',
-			[join('./', 'bin', 'loadtest.js'), `http://localhost:${PORT}/`, '-n', '100'],
+			[join('./', 'bin', 'loadtest.js'), `http://localhost:${PORT}/`,
+				'-n', '100', '--quiet'],
 			(error, stdout) => {
 				if (error) {
 					return callback(error);
@@ -56,7 +62,7 @@ function testIntegrationFile(callback) {
 					if (error) {
 						return callback(error);
 					}
-					return callback(null, 'Test results: ' + stdout);
+					return callback(null, 'Test result: ' + stdout);
 				});
 			});
 	});
@@ -68,7 +74,7 @@ function testIntegrationFile(callback) {
  * Run an integration test.
  */
 function testWSIntegration(callback) {
-	const server = startServer({ port: PORT }, error => {
+	const server = startServer(serverOptions, error => {
 		if (error) {
 			return callback(error);
 		}
@@ -85,6 +91,7 @@ function testWSIntegration(callback) {
 				type: 'ping',
 				hi: 'there',
 			},
+			quiet: true,
 		};
 		loadTest(options, (error, result) => {
 			if (error) {
@@ -94,7 +101,7 @@ function testWSIntegration(callback) {
 				if (error) {
 					return callback(error);
 				}
-				return callback(null, 'Test results: ' + JSON.stringify(result));
+				return callback(null, 'Test result: ' + JSON.stringify(result));
 			});
 		});
 	});
@@ -105,17 +112,19 @@ function testWSIntegration(callback) {
  */
 function testDelay(callback) {
 	const delay = 10;
-	let options = {
+	const serverOptions = {
 		port: PORT + 1,
-		delay: delay,
+		delay,
+		quiet: true,
 	};
-	const server = startServer(options, error => {
+	const server = startServer(serverOptions, error => {
 		if (error) {
 			return callback(error);
 		}
-		options = {
+		const options = {
 			url: 'http://localhost:' + (PORT + 1),
 			maxRequests: 10,
+			quiet: true,
 		};
 		loadTest(options, (error, result) => {
 			if (error) {
@@ -133,10 +142,29 @@ function testDelay(callback) {
 	});
 }
 
+async function testPromise() {
+	const server = await startServer(serverOptions)
+	const options = {
+		url: 'http://localhost:' + PORT,
+		maxRequests: 100,
+		concurrency: 10,
+		method: 'POST',
+		body: {
+			hi: 'there',
+		},
+		quiet: true,
+	};
+	const result = await loadTest(options)
+	await server.close()
+	return 'Test result: ' + JSON.stringify(result)
+}
+
 /**
  * Run all tests.
  */
 export function test(callback) {
-	testing.run([testIntegration, testIntegrationFile, testDelay, testWSIntegration], 4000, callback);
+	testing.run([
+		testIntegration, testIntegrationFile, testDelay, testWSIntegration, testPromise,
+	], 4000, callback);
 }
 

package/test/latency.js

@@ -49,7 +49,7 @@ function testLatencyPercentiles(callback) {
 	};
 	const latency = new Latency(options, error => {
 		testing.check(error, 'Error while testing latency percentiles', callback);
-		const percentiles = latency.getResults().percentiles;
+		const percentiles = latency.getResult().percentiles;
 
 		Object.keys(percentiles).forEach(percentile => {
 			testing.assert(percentiles[percentile] !== false, 'Empty percentile for %s', percentile, callback);