npm - loadtest - Versions diffs - 6.1.0 → 6.2.1 - Mend

loadtest 6.1.0 → 6.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/README.md CHANGED Viewed

@@ -481,7 +481,28 @@ thus allowing you to load test your application in your own tests.
 ### Invoke Load Test
-To run a load test, just call the exported function `loadTest()` with a set of options and an optional callback:
+To run a load test, just `await` for the exported function `loadTest()` with the desired options, described below:
+```javascript
+import {loadTest} from 'loadtest'
+const options = {
+	url: 'http://localhost:8000',
+	maxRequests: 1000,
+}
+const result = await loadTest(options)
+result.show()
+console.log('Tests run successfully')
+})
+```
+The call returns a `Result` object that contains all info about the load test, also described below.
+Call `result.show()` to display the results in the standard format on the console.
+As a legacy from before promises existed,
+if an optional callback is passed as second parameter then it will not behave as `async`:
+the callback `function(error, result)` will be invoked when the max number of requests is reached,
+or when the max number of seconds has elapsed.
 ```javascript
 import {loadTest} from 'loadtest'
@@ -494,16 +515,51 @@ loadTest(options, function(error, result) {
 	if (error) {
 		return console.error('Got an error: %s', error)
 	}
+	result.show()
 	console.log('Tests run successfully')
 })
 ```
-The callback `function(error, result)` will be invoked when the max number of requests is reached,
-or when the max number of seconds has elapsed.
 Beware: if there are no `maxRequests` and no `maxSeconds`, then tests will run forever
 and will not call the callback.
+### Result
+The latency result returned at the end of the load test contains a full set of data, including:
+mean latency, number of errors and percentiles.
+An example follows:
+```javascript
+{
+  url: 'http://localhost:80/',
+  maxRequests: 1000,
+  maxSeconds: 0,
+  concurrency: 10,
+  agent: 'none',
+  requestsPerSecond: undefined,
+  totalRequests: 1000,
+  percentiles: {
+	'50': 7,
+	'90': 10,
+	'95': 11,
+	'99': 15
+  },
+  rps: 2824,
+  totalTimeSeconds: 0.354108,
+  meanLatencyMs: 7.72,
+  maxLatencyMs: 20,
+  totalErrors: 3,
+  errorCodes: {
+	'0': 1,
+	'500': 2
+  },
+}
+```
+The `result` object also has a `result.show()` function
+that displays the results on the console in the standard format.
 ### Options
 All options but `url` are, as their name implies, optional.
@@ -591,6 +647,9 @@ function(params, options, client, callback) {
 }
 ```
+See [`sample/request-generator.js`](sample/request-generator.js) for some sample code including a body
+(or [`sample/request-generator.ts`](sample/request-generator.ts) for ES6/TypeScript).
 #### `agentKeepAlive`
 Use an agent with 'Connection: Keep-alive'.
@@ -677,6 +736,19 @@ In addition, the following three properties are added to the `result` object:
 You will need to check if `error` is populated in order to determine which object to check for these properties.
+The second parameter contains info about the current request:
+```javascript
+{
+	host: 'localhost',
+	path: '/',
+	method: 'GET',
+	statusCode: 200,
+	body: '<html><body>hi</body></html>',
+	headers: [...]
+}
+```
 Example:
 ```javascript
@@ -703,7 +775,6 @@ loadTest(options, function(error) {
     console.log('Tests run successfully')
 })
 ```
 In some situations request data needs to be available in the statusCallBack.
 This data can be assigned to `request.labels` in the requestGenerator:
@@ -757,46 +828,6 @@ function contentInspector(result) {
     }
 },
 ```
-### Result
-The latency result passed to your callback at the end of the load test contains a full set of data, including:
-mean latency, number of errors and percentiles.
-An example follows:
-```javascript
-{
-  totalRequests: 1000,
-  percentiles: {
-	'50': 7,
-	'90': 10,
-	'95': 11,
-	'99': 15
-  },
-  rps: 2824,
-  totalTimeSeconds: 0.354108,
-  meanLatencyMs: 7.72,
-  maxLatencyMs: 20,
-  totalErrors: 3,
-  errorCodes: {
-	'0': 1,
-	'500': 2
-  }
-}
-```
-The second parameter contains info about the current request:
-```javascript
-{
-	host: 'localhost',
-	path: '/',
-	method: 'GET',
-	statusCode: 200,
-	body: '<html><body>hi</body></html>',
-	headers: [...]
-}
-```
 ### Start Test Server
@@ -805,11 +836,14 @@ To start the test server use the exported function `startServer()` with a set of
 ```javascript
 import {startServer} from 'loadtest'
 const server = await startServer({port: 8000})
+// do your thing
+await server.close()
 ```
-This function returns an HTTP server which can be `close()`d when it is no longer useful.
+This function returns when the server is up and running,
+with an HTTP server which can be `close()`d when it is no longer useful.
 As a legacy from before promises existed,
-if the optional callback is passed then it will not behave as `async`:
+if an optional callback is passed as second parameter then it will not behave as `async`:
 ```
 const server = startServer({port: 8000}, error => console.error(error))

package/bin/loadtest.js CHANGED Viewed

@@ -3,7 +3,6 @@
 import {readFile} from 'fs/promises'
 import * as stdio from 'stdio'
 import {loadTest} from '../lib/loadtest.js'
-import {showResult} from '../lib/show.js'
 const options = stdio.getopt({
@@ -54,7 +53,7 @@ async function processAndRun(options) {
 	options.url = options.args[0];
 	try {
 		const result = await loadTest(options)
-		showResult(options, result)
+		result.show()
 	} catch(error) {
 		console.error(error.message)
 		help()

package/lib/httpClient.js CHANGED Viewed

@@ -28,6 +28,7 @@ class HttpClient {
 	constructor(operation, params) {
 		this.operation = operation
 		this.params = params
+		this.stopped = false
 		this.init();
 	}
@@ -36,20 +37,21 @@ class HttpClient {
 	 */
 	init() {
 		this.options = urlLib.parse(this.params.url);
-		this.options.headers = {};
-		if (this.params.headers) {
-			this.options.headers = this.params.headers;
-		}
+		this.options.headers = this.params.headers || {}
 		if (this.params.cert && this.params.key) {
 			this.options.cert = this.params.cert;
 			this.options.key = this.params.key;
 		}
 		this.options.agent = false;
+		if (this.params.requestsPerSecond) {
+			// rps for each client is total / concurrency (# of clients)
+			this.options.requestsPerSecond = this.params.requestsPerSecond / this.params.concurrency
+		}
 		if (this.params.agentKeepAlive) {
-			const KeepAlive = (this.options.protocol == 'https:') ? agentkeepalive.HttpsAgent : agentkeepalive;
+			const KeepAlive = (this.options.protocol == 'https:') ? agentkeepalive.HttpsAgent : agentkeepalive.default;
 			let maxSockets = 10;
-			if (this.params.requestsPerSecond) {
-				maxSockets += Math.floor(this.params.requestsPerSecond);
+			if (this.options.requestsPerSecond) {
+				maxSockets += Math.floor(this.options.requestsPerSecond);
 			}
 			this.options.agent = new KeepAlive({
 				maxSockets: maxSockets,
@@ -71,7 +73,7 @@ class HttpClient {
 			} else if (typeof this.params.body == 'function') {
 				this.generateMessage = this.params.body;
 			} else {
-				console.error('Unrecognized body: %s', typeof this.params.body);
+				throw new Error(`Unrecognized body: ${typeof this.params.body}`);
 			}
 			this.options.headers['Content-Type'] = this.params.contentType || 'text/plain';
 		}
@@ -81,7 +83,7 @@ class HttpClient {
 			} else if (typeof this.params.cookies == 'string') {
 				this.options.headers.Cookie = this.params.cookies;
 			} else {
-				console.error('Invalid cookies %j, please use an array or a string', this.params.cookies);
+				throw new Error(`Invalid cookies ${JSON.stringify(this.params.cookies)}, please use an array or a string`);
 			}
 		}
 		addUserAgent(this.options.headers);
@@ -94,10 +96,15 @@ class HttpClient {
 	 * Start the HTTP client.
 	 */
 	start() {
-		if (!this.params.requestsPerSecond) {
+		if (this.stopped) {
+			// solves testing issue: with requestsPerSecond clients are started at random,
+			// so sometimes they are stopped before they have even started
+			return
+		}
+		if (!this.options.requestsPerSecond) {
 			return this.makeRequest();
 		}
-		const interval = 1000 / this.params.requestsPerSecond;
+		const interval = 1000 / this.options.requestsPerSecond;
 		this.requestTimer = new HighResolutionTimer(interval, () => this.makeRequest());
 	}
@@ -105,6 +112,7 @@ class HttpClient {
 	 * Stop the HTTP client.
 	 */
 	stop() {
+		this.stopped = true
 		if (this.requestTimer) {
 			this.requestTimer.stop();
 		}
@@ -133,7 +141,6 @@ class HttpClient {
 		// adding proxy configuration
 		if (this.params.proxy) {
 			const proxy = this.params.proxy;
-			//console.log('using proxy server %j', proxy);
 			const agent = new HttpsProxyAgent(proxy);
 			this.options.agent = agent;
 		}
@@ -154,7 +161,8 @@ class HttpClient {
 			delete this.options.headers['Content-Length'];
 		}
 		if (typeof this.params.requestGenerator == 'function') {
-			request = this.params.requestGenerator(this.params, this.options, lib.request, this.getConnect(id, requestFinished, this.params.contentInspector));
+			const connect = this.getConnect(id, requestFinished, this.params.contentInspector)
+			request = this.params.requestGenerator(this.params, this.options, lib.request, connect);
 		} else {
 			request = lib.request(this.options, this.getConnect(id, requestFinished, this.params.contentInspector));
 		}
@@ -205,7 +213,7 @@ class HttpClient {
 				result.instanceIndex = this.operation.instanceIndex;
 			}
 			let callback;
-			if (!this.params.requestsPerSecond) {
+			if (!this.options.requestsPerSecond) {
 				callback = this.makeRequest.bind(this);
 			}
 			this.operation.callback(error, result, callback);

package/lib/latency.js CHANGED Viewed

@@ -1,5 +1,5 @@
 import * as crypto from 'crypto'
-import {showResult} from './show.js'
+import {Result} from './result.js'
 /**
@@ -174,19 +174,8 @@ export class Latency {
 	 * Get final result.
 	 */
 	getResult() {
-		const elapsedSeconds = this.getElapsed(this.initialTime) / 1000;
-		const meanTime = this.totalTime / this.totalRequests;
-		return {
-			totalRequests: this.totalRequests,
-			totalErrors: this.totalErrors,
-			totalTimeSeconds: elapsedSeconds,
-			rps: Math.round(this.totalRequests / elapsedSeconds),
-			meanLatencyMs: Math.round(meanTime * 10) / 10,
-			maxLatencyMs: this.maxLatencyMs,
-			minLatencyMs: this.minLatencyMs,
-			percentiles: this.computePercentiles(),
-			errorCodes: this.errorCodes
-		};
+		const result = new Result(this.options, this)
+		return result
 	}
 	/**
@@ -226,11 +215,10 @@ export class Latency {
 		}
 		this.totalsShown = true;
 		const result = this.getResult();
-		showResult(this.options, result)
+		result.show()
 	}
 }
 /**
  * Create a unique, random token.
  */

package/lib/loadtest.js CHANGED Viewed

@@ -16,19 +16,21 @@ https.globalAgent.maxSockets = 1000;
  * Run a load test.
  * Parameters:
  * - `options`: an object which may have:
- *	 - url: mandatory URL to access.
- *	 - concurrency: how many concurrent clients to use.
- *	 - maxRequests: how many requests to send
- *	 - maxSeconds: how long to run the tests.
- *	 - cookies: a string or an array of strings, each with name:value.
- *	 - headers: a map with headers: {key1: value1, key2: value2}.
- *	 - method: the method to use: POST, PUT. Default: GET, what else.
- *	 - body: the contents to send along a POST or PUT request.
- *	 - contentType: the MIME type to use for the body, default text/plain.
- *	 - requestsPerSecond: how many requests per second to send.
+ *	 - url [string]: URL to access (mandatory).
+ *	 - concurrency [number]: how many concurrent clients to use.
+ *	 - maxRequests [number]: how many requests to send
+ *	 - maxSeconds [number]: how long to run the tests.
+ *	 - cookies [array]: a string or an array of strings, each with name:value.
+ *	 - headers [map]: a map with headers: {key1: value1, key2: value2}.
+ *	 - method [string]: the method to use: POST, PUT. Default: GET, what else.
+ *	 - body [string]: the contents to send along a POST or PUT request.
+ *	 - contentType [string]: the MIME type to use for the body, default text/plain.
+ *	 - requestsPerSecond [number]: how many requests per second to send.
  *	 - agentKeepAlive: if true, then use connection keep-alive.
- *	 - indexParam: string to replace with a unique index.
+ *	 - indexParam [string]: string to replace with a unique index.
  *	 - insecure: allow https using self-signed certs.
+ *	 - secureProtocol [string]: TLS/SSL secure protocol method to use.
+ *	 - proxy [string]: use a proxy for requests e.g. http://localhost:8080.
  *	 - quiet: do not log any messages.
  *	 - debug: show debug messages (deprecated).
  * - `callback`: optional `function(result, error)` called if/when the test finishes;
@@ -38,12 +40,12 @@ export function loadTest(options, callback) {
 	if (!callback) {
 		return loadTestAsync(options)
 	}
-	loadTestAsync(options).then(result => callback(null, result)).catch(error => callback(null, error))
+	loadTestAsync(options).then(result => callback(null, result)).catch(error => callback(error))
 }
 async function loadTestAsync(options) {
-	await processOptions(options)
-	return await runOperation(options)
+	const processed = await processOptions(options)
+	return await runOperation(processed)
 }
 function runOperation(options) {
@@ -157,15 +159,14 @@ class Operation {
 	 * Stop clients.
 	 */
 	stop() {
+		this.running = false;
+		this.latency.running = false;
 		if (this.showTimer) {
 			this.showTimer.stop();
 		}
 		if (this.stopTimeout) {
 			clearTimeout(this.stopTimeout);
 		}
-		this.running = false;
-		this.latency.running = false;
 		Object.keys(this.clients).forEach(index => {
 			this.clients[index].stop();
 		});

package/lib/options.js CHANGED Viewed

@@ -1,152 +1,131 @@
-#!/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 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 processed = new Options(options)
+	await processed.process()
+	return processed
+}
+class Options {
+	constructor(options) {
+		this.url = this.getUrl(options)
+		const configuration = loadConfig();
+		this.concurrency = options.concurrency || configuration.concurrency || 1
+		const rps = options.rps ? parseFloat(options.rps) : null
+		this.requestsPerSecond = options.requestsPerSecond || rps || configuration.requestsPerSecond
+		this.agentKeepAlive = options.keepalive || options.agent || options.agentKeepAlive || configuration.agentKeepAlive;
+		this.indexParam = options.index || options.indexParam || configuration.indexParam;
+		this.method = options.method || configuration.method || 'GET'
+		this.readBodyAndMethod(options, configuration)
+		this.key = null
+		this.keyFile = options.key || configuration.key
+		this.cert = null
+		this.certFile = options.cert || configuration.cert
+		this.headers = configuration.headers || {}
+		this.headers['host'] = urlLib.parse(options.url).host;
+		this.headers['accept'] = '*/*';
+		if (options.headers) {
+			addHeaders(options.headers, this.headers);
 		}
+		this.requestGenerator = options.requestGenerator || configuration.requestGenerator
+		this.maxRequests = options.maxRequests || configuration.maxRequests
+		this.maxSeconds = options.maxSeconds || configuration.maxSeconds
+		this.cookies = options.cookies || configuration.cookies
+		this.contentType = options.contentType || configuration.contentType
+		this.timeout = options.timeout || configuration.timeout
+		this.secureProtocol = options.secureProtocol || configuration.secureProtocol
+		this.insecure = options.insecure || configuration.insecure
+		this.recover = options.recover || configuration.recover
+		this.proxy = options.proxy || configuration.proxy
+		this.quiet = options.quiet || configuration.quiet
 	}
-	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';
+	getUrl(options) {
+		if (!options.url) {
+			throw new Error('Missing URL in options')
 		}
-	}
-	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');
+		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`);
+			}
+		}
+		return options.url
 	}
-	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)
+	readBodyAndMethod(options, configuration) {
+		if (options.data) {
+			this.body = options.data
+		}
+		// Allow a post body string in options
+		// Ex -P '{"foo": "bar"}'
+		if (options.postBody) {
+			this.method = 'POST';
+			this.body = options.postBody
+		}
+		if (options.postFile) {
+			this.method = 'POST';
+			this.bodyFile = options.postFile
+		}
+		if (options.putFile) {
+			this.method = 'PUT';
+			this.bodyFile = options.putFile
+		}
+		if (options.patchBody) {
+			this.method = 'PATCH';
+			this.body = options.patchBody
+		}
+		if (options.patchFile) {
+			this.method = 'PATCH';
+			this.bodyFile = options.patchFile
+		}
+		// sanity check
+		if (acceptedMethods.indexOf(this.method) === -1) {
+			throw new Error(`Invalid method ${this.method}`)
+		}
+		if (!options.body) {
+			if (configuration.body) {
+				this.body = configuration.body;
+			} else if (configuration.file) {
+				this.bodyFile = configuration.file
+			}
+		}
 	}
-	// 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 process() {
+		const packageJson = JSON.parse(await readFile(new URL('../package.json', import.meta.url)))
+		this.headers['user-agent'] = 'loadtest/' + packageJson.version;
+		if (this.keyFile) {
+			this.key = await readFile(this.keyFile)
+		}
+		if (this.certFile) {
+			this.cert = await readFile(this.certFile);
+		}
+		if (typeof this.requestGenerator == 'string') {
+			this.requestGenerator = await import(this.requestGenerator)
+		}
+		if (this.bodyFile) {
+			this.body = await readBody(this.bodyFile);
+		}
 	}
 }
-async function readBody(filename, option) {
+async function readBody(filename) {
 	if (typeof filename !== 'string') {
-		throw new Error(`Invalid file to open with ${option}: ${filename}`);
+		throw new Error(`Invalid file to open for body: ${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 ADDED Viewed

@@ -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/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
 	"name": "loadtest",
-	"version": "6.1.0",
+	"version": "6.2.1",
 	"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/test/body-generator.js CHANGED Viewed

@@ -12,7 +12,7 @@ function testBodyGenerator(callback) {
 		}
 		const options = {
 			url: 'http://localhost:' + PORT,
-			requestsPerSecond: 100,
+			requestsPerSecond: 1000,
 			maxRequests: 100,
 			concurrency: 10,
 			postFile: 'sample/post-file.js',

package/test/integration.js CHANGED Viewed

@@ -112,16 +112,16 @@ 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,

package/test/loadtest.js CHANGED Viewed

@@ -2,9 +2,6 @@ import testing from 'testing'
 import {loadTest} from '../lib/loadtest.js'
-/**
- * A load test with max seconds.
- */
 function testMaxSeconds(callback) {
 	const options = {
 		url: 'http://localhost:7357/',
@@ -15,10 +12,6 @@ function testMaxSeconds(callback) {
 	loadTest(options, callback);
 }
-/**
- * A load test with max seconds.
- */
 function testWSEcho(callback) {
 	const options = {
 		url: 'ws://localhost:7357/',
@@ -83,6 +76,34 @@ function testIndexParamWithCallbackAndBody(callback) {
 	loadTest(options, callback);
 }
+function testError(callback) {
+	const options = {
+		maxSeconds: 0.1,
+		concurrency: 1,
+		quiet: true,
+	};
+	loadTest(options, (error) => {
+		if (!error) {
+			return callback('Should error without URL')
+		}
+		return callback(false, 'OK')
+	});
+}
+/**
+ * A load test with keep-alive.
+ */
+function testKeepAlive(callback) {
+	const options = {
+		url: 'http://localhost:7357/',
+		maxSeconds: 0.1,
+		concurrency: 1,
+		quiet: true,
+		keepalive: true,
+	};
+	loadTest(options, callback)
+}
 /**
  * Run all tests.
@@ -91,6 +112,7 @@ export function test(callback) {
 	testing.run([
 		testMaxSeconds, testWSEcho, testIndexParam, testIndexParamWithBody,
 		testIndexParamWithCallback, testIndexParamWithCallbackAndBody,
+		testError, testKeepAlive,
 	], callback);
 }

package/test/request-generator.js CHANGED Viewed

@@ -13,7 +13,7 @@ function testRequestGenerator(callback) {
 		const options = {
 			url: 'http://localhost:' + PORT,
 			method: 'POST',
-			requestsPerSecond: 100,
+			requestsPerSecond: 1000,
 			maxRequests: 100,
 			concurrency: 10,
 			requestGenerator: (params, options, client, callback) => {

package/lib/show.js DELETED Viewed

@@ -1,47 +0,0 @@
-/**
- * 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]);
-		});
-	}
-}