loadtest 6.2.2 → 6.3.1

package/README.md

@@ -1,4 +1,3 @@
-[![Build Status](https://secure.travis-ci.org/alexfernandez/loadtest.svg)](http://travis-ci.org/alexfernandez/loadtest)
 [![run on repl.it](http://repl.it/badge/github/alexfernandez/loadtest)](https://repl.it/github/alexfernandez/loadtest)
 
 [![NPM](https://nodei.co/npm/loadtest.png?downloads=true)](https://nodei.co/npm/loadtest/)
@@ -90,9 +89,13 @@ so that you can abort deployment e.g. if 99% of the requests don't finish in 10
 ### Usage Don'ts
 
 `loadtest` saturates a single CPU pretty quickly.
-Do not use `loadtest` if the Node.js process is above 100% usage in `top`, which happens approx. when your load is above 1000~4000 rps.
+Do not use `loadtest` in this mode
+if the Node.js process is above 100% usage in `top`, which happens approx. when your load is above 1000~4000 rps.
 (You can measure the practical limits of `loadtest` on your specific test machines by running it against a simple
-Apache or nginx process and seeing when it reaches 100% CPU.)
+[test server](#test-server)
+and seeing when it reaches 100% CPU.)
+In this case try using in multi-process mode using the `--cores` parameter,
+see below.
 
 There are better tools for that use case:
 
@@ -260,8 +263,9 @@ The following parameters are _not_ compatible with Apache ab.
 #### `--rps requestsPerSecond`
 
 Controls the number of requests per second that are sent.
-Can be fractional, e.g. `--rps 0.5` sends one request every two seconds.
-Not used by default: each request is sent as soon as the previous one is responded.
+Cannot be fractional, e.g. `--rps 0.5`.
+In this mode each request is not sent as soon as the previous one is responded,
+but periodically even if previous requests have not been responded yet.
 
 Note: Concurrency doesn't affect the final number of requests per second,
 since rps will be shared by all the clients. E.g.:
@@ -276,6 +280,19 @@ to send all of the rps, adjust it with `-c` if needed.
 
 Note: --rps is not supported for websockets.
 
+#### `--cores number`
+
+Start `loadtest` in multi-process mode on a number of cores simultaneously.
+Useful when a single CPU is saturated.
+Forks the requested number of processes using the
+[Node.js cluster module](https://nodejs.org/api/cluster.html).
+
+In this mode the total number of requests and the rps rate are shared among all processes.
+The result returned is the aggregation of results from all cores.
+
+Note: this option is not available in the API,
+where it runs just in the provided process.
+
 #### `--timeout milliseconds`
 
 Timeout for each generated request in milliseconds.
@@ -337,11 +354,11 @@ Sets the certificate for the http client to use. Must be used with `--key`.
 
 Sets the key for the http client to use. Must be used with `--cert`.
 
-### Server
+### Test Server
 
 loadtest bundles a test server. To run it:
 
-    $ testserver-loadtest [--delay ms] [error 5xx] [percent yy] [port]
+    $ testserver-loadtest [options] [port]
 
 This command will show the number of requests received per second,
 the latency in answering requests and the headers for selected requests.
@@ -354,6 +371,27 @@ The optional delay instructs the server to wait for the given number of millisec
 before answering each request, to simulate a busy server.
 You can also simulate errors on a given percent of requests.
 
+The following optional parameters are available.
+
+#### `--delay ms`
+
+Wait the specified number of milliseconds before answering each request.
+
+#### `--error 5xx`
+
+Return the given error for every request.
+
+#### `--percent yy`
+
+Return an error (default 500) only for the specified % of requests.
+
+#### `--cores number`
+
+Number of cores to use. If not 1, will start in multi-process mode.
+
+Note: since version v6.3.0 the test server uses half the available cores by default;
+use `--cores 1` to use in single-process mode.
+
 ### Complete Example
 
 Let us now see how to measure the performance of the test server.
@@ -364,8 +402,9 @@ First we install `loadtest` globally:
 
 Now we start the test server:
 
-    $ testserver-loadtest
-    Listening on port 7357
+    $ testserver-loadtest --cores 2
+    Listening on http://localhost:7357/
+    Listening on http://localhost:7357/
 
 On a different console window we run a load test against it for 20 seconds
 with concurrency 10 (only relevant results are shown):
@@ -458,7 +497,7 @@ The result (with the same test server) is impressive:
     99%      10 ms
     100%      25 ms (longest request)
 
-Now you're talking! The steady rate also goes up to 2 krps:
+Now we're talking! The steady rate also goes up to 2 krps:
 
     $ loadtest http://localhost:7357/ -t 20 -c 10 --keepalive --rps 2000
     ...
@@ -528,7 +567,7 @@ and will not call the callback.
 
 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:
+A simplified example follows:
 
 ```javascript
 {
@@ -545,8 +584,8 @@ An example follows:
 	'95': 11,
 	'99': 15
   },
-  rps: 2824,
-  totalTimeSeconds: 0.354108,
+  effectiveRps: 2824,
+  elapsedSeconds: 0.354108,
   meanLatencyMs: 7.72,
   maxLatencyMs: 20,
   totalErrors: 3,

package/bin/loadtest.js

@@ -3,6 +3,8 @@
 import {readFile} from 'fs/promises'
 import * as stdio from 'stdio'
 import {loadTest} from '../lib/loadtest.js'
+import {runTask} from '../lib/cluster.js'
+import {Result} from '../lib/result.js'
 
 
 const options = stdio.getopt({
@@ -32,8 +34,9 @@ const options = stdio.getopt({
 	key: {args: 1, description: 'The client key to use'},
 	cert: {args: 1, description: 'The client certificate to use'},
 	quiet: {description: 'Do not log any messages'},
+	cores: {args: 1, description: 'Number of cores to use', default: 1},
 	agent: {description: 'Use a keep-alive http agent (deprecated)'},
-	debug: {description: 'Show debug messages (deprecated)'}
+	debug: {description: 'Show debug messages (deprecated)'},
 });
 
 async function processAndRun(options) {
@@ -51,21 +54,62 @@ async function processAndRun(options) {
 		help();
 	}
 	options.url = options.args[0];
-	try {
-		const result = await loadTest(options)
-		result.show()
-	} catch(error) {
-		console.error(error.message)
-		help()
+	options.cores = parseInt(options.cores) || 1
+	const results = await runTask(options.cores, async workerId => await startTest(options, workerId))
+	if (!results) {
+		process.exit(0)
+		return
+	}
+	showResults(results)
+}
+
+function showResults(results) {
+	if (results.length == 1) {
+		results[0].show()
+		return
+	}
+	const combined = new Result()
+	for (const result of results) {
+		combined.combine(result)
+	}
+	combined.show()
+}
+
+async function startTest(options, workerId) {
+	if (!workerId) {
+		// standalone; controlled errors
+		try {
+			return await loadTest(options)
+		} catch(error) {
+			console.error(error.message)
+			return help()
+		}
+	}
+	shareWorker(options, workerId)
+	return await loadTest(options)
+}
+
+function shareWorker(options, workerId) {
+	options.maxRequests = shareOption(options.maxRequests, workerId, options.cores)
+	options.rps = shareOption(options.rps, workerId, options.cores)
+}
+
+function shareOption(option, workerId, cores) {
+	if (!option) return null
+	const total = parseInt(option)
+	const shared = Math.round(total / cores)
+	if (workerId == cores) {
+		// last worker gets remainder
+		return total - shared * (cores - 1)
+	} else {
+		return shared
 	}
 }
 
 await processAndRun(options)
 
-/**
- * Show online help.
- */
 function help() {
 	options.printHelp();
 	process.exit(1);
 }
+

package/bin/testserver.js

@@ -3,40 +3,51 @@
 import * as stdio from 'stdio'
 import {startServer} from '../lib/testserver.js'
 import {loadConfig} from '../lib/config.js'
+import {getHalfCores, runTask} from '../lib/cluster.js'
 
+const options = readOptions()
+start(options)
 
-const options = stdio.getopt({
-	delay: {key: 'd', args: 1, description: 'Delay the response for the given milliseconds'},
-	error: {key: 'e', args: 1, description: 'Return an HTTP error code'},
-	percent: {key: 'p', args: 1, description: 'Return an error (default 500) only for some % of requests'},
-});
-const configuration = loadConfig()
-if (options.args && options.args.length == 1) {
-	options.port = parseInt(options.args[0], 10);
-	if (!options.port) {
-		console.error('Invalid port');
-		options.printHelp();
-		process.exit(1);
+
+function readOptions() {
+	const options = stdio.getopt({
+		delay: {key: 'd', args: 1, description: 'Delay the response for the given milliseconds'},
+		error: {key: 'e', args: 1, description: 'Return an HTTP error code'},
+		percent: {key: 'p', args: 1, description: 'Return an error (default 500) only for some % of requests'},
+		cores: {key: 'c', args: 1, description: 'Number of cores to use, default is half the total', default: getHalfCores()}
+	});
+	const configuration = loadConfig()
+	if (options.args && options.args.length == 1) {
+		options.port = parseInt(options.args[0], 10);
+		if (!options.port) {
+			console.error('Invalid port');
+			options.printHelp();
+			process.exit(1);
+		}
 	}
-}
-if(options.delay) {
-	if(isNaN(options.delay)) {
-		console.error('Invalid delay');
-		options.printHelp();
-		process.exit(1);
+	if(options.delay) {
+		if(isNaN(options.delay)) {
+			console.error('Invalid delay');
+			options.printHelp();
+			process.exit(1);
+		}
+		options.delay = parseInt(options.delay, 10);
 	}
-	options.delay = parseInt(options.delay, 10);
-}
 
-if(!options.delay) {
-	options.delay = configuration.delay
-}
-if(!options.error) {
-	options.error = configuration.error
+	if(!options.delay) {
+		options.delay = configuration.delay
+	}
+	if(!options.error) {
+		options.error = configuration.error
+	}
+	if(!options.percent) {
+		options.percent = configuration.percent
+	}
+	return options
 }
-if(!options.percent) {
-	options.percent = configuration.percent
+
+function start(options) {
+	runTask(options.cores, async () => await startServer(options))
 }
 
-startServer(options);
 

package/lib/cluster.js

@@ -0,0 +1,42 @@
+process.env.NODE_CLUSTER_SCHED_POLICY = 'none'
+
+import {cpus} from 'os'
+// dynamic import as workaround: https://github.com/nodejs/node/issues/49240
+const cluster = await import('cluster')
+
+
+export function getHalfCores() {
+	const totalCores = cpus().length
+	return Math.round(totalCores / 2) || 1
+}
+
+export async function runTask(cores, task) {
+	if (cores == 1) {
+		return [await task()]
+	}
+	if (cluster.isPrimary) {
+		return await runWorkers(cores)
+	} else {
+		const result = await task(cluster.worker.id)
+		process.send(result)
+	}
+}
+
+function runWorkers(cores) {
+	return new Promise((resolve, reject) => {
+		const results = []
+		for (let index = 0; index < cores; index++) {
+			const worker = cluster.fork()
+			worker.on('message', message => {
+				results.push(message)
+				if (results.length === cores) {
+					return resolve(results)
+				}
+			})
+			worker.on('error', error => {
+				return reject(error)
+			})
+		}
+	})
+}
+

package/lib/latency.js

@@ -17,8 +17,8 @@ export class Latency {
 		this.partialRequests = 0;
 		this.partialTime = 0;
 		this.partialErrors = 0;
-		this.lastShown = this.getTime();
-		this.initialTime = this.getTime();
+		this.lastShownNs = this.getTimeNs();
+		this.startTimeNs = this.getTimeNs();
 		this.totalRequests = 0;
 		this.totalTime = 0;
 		this.totalErrors = 0;
@@ -45,7 +45,7 @@ export class Latency {
 	 */
 	start(requestId) {
 		requestId = requestId || createId();
-		this.requests[requestId] = this.getTime();
+		this.requests[requestId] = this.getTimeNs();
 		this.requestIdToIndex[requestId] = this.requestIndex++;
 		return requestId;
 	}
@@ -61,7 +61,7 @@ export class Latency {
 		if (!this.running) {
 			return -1;
 		}
-		const elapsed = this.getElapsed(this.requests[requestId]);
+		const elapsed = this.getElapsedMs(this.requests[requestId]);
 		this.add(elapsed, errorCode);
 		delete this.requests[requestId];
 		return elapsed;
@@ -105,7 +105,7 @@ export class Latency {
 	 * Show latency for partial requests.
 	 */
 	showPartial() {
-		const elapsedSeconds = this.getElapsed(this.lastShown) / 1000;
+		const elapsedSeconds = this.getElapsedMs(this.lastShownNs) / 1000;
 		const meanTime = this.partialTime / this.partialRequests || 0.0;
 		const result = {
 			meanLatencyMs: Math.round(meanTime * 10) / 10,
@@ -125,25 +125,26 @@ export class Latency {
 		this.partialTime = 0;
 		this.partialRequests = 0;
 		this.partialErrors = 0;
-		this.lastShown = this.getTime();
+		this.lastShownNs = this.getTimeNs();
 	}
 
 	/**
-	 * Returns the current high-resolution real time in a [seconds, nanoseconds] tuple Array
+	 * Returns the current high-resolution real time in nanoseconds as a big int.
 	 * @return {*}
 	 */
-	getTime() {
-		return process.hrtime();
+	getTimeNs() {
+		return process.hrtime.bigint();
 	}
 
 	/**
-	 * calculates the elapsed time between the assigned startTime and now
-	 * @param startTime
+	 * Calculates the elapsed time between the assigned start time and now in ms.
+	 * @param startTimeNs time in nanoseconds (bigint)
 	 * @return {Number} the elapsed time in milliseconds
 	 */
-	getElapsed(startTime) {
-		const elapsed = process.hrtime(startTime);
-		return elapsed[0] * 1000 + elapsed[1] / 1000000;
+	getElapsedMs(startTimeNs) {
+		const endTimeNs = this.getTimeNs()
+		const elapsedNs = endTimeNs - startTimeNs
+		return Number(elapsedNs / 1000000n)
 	}
 
 	/**
@@ -153,7 +154,7 @@ export class Latency {
 		if (this.options.maxRequests && this.totalRequests >= this.options.maxRequests) {
 			return true;
 		}
-		const elapsedSeconds = this.getElapsed(this.initialTime) / 1000;
+		const elapsedSeconds = this.getElapsedMs(this.startTimeNs) / 1000;
 		if (this.options.maxSeconds && elapsedSeconds >= this.options.maxSeconds) {
 			return true;
 		}
@@ -165,6 +166,7 @@ export class Latency {
 	 */
 	finish() {
 		this.running = false;
+		this.endTimeNs = this.getTimeNs()
 		if (this.callback) {
 			return this.callback(null, this.getResult());
 		}
@@ -174,38 +176,11 @@ export class Latency {
 	 * Get final result.
 	 */
 	getResult() {
-		const result = new Result(this.options, this)
+		const result = new Result()
+		result.compute(this.options, this)
 		return result
 	}
 
-	/**
-	 * Compute the percentiles.
-	 */
-	computePercentiles() {
-		const percentiles = {
-			50: false,
-			90: false,
-			95: false,
-			99: false
-		};
-		let counted = 0;
-
-		for (let ms = 0; ms <= this.maxLatencyMs; ms++) {
-			if (!this.histogramMs[ms]) {
-				continue;
-			}
-			counted += this.histogramMs[ms];
-			const percent = counted / this.totalRequests * 100;
-
-			Object.keys(percentiles).forEach(percentile => {
-				if (!percentiles[percentile] && percent > percentile) {
-					percentiles[percentile] = ms;
-				}
-			});
-		}
-		return percentiles;
-	}
-
 	/**
 	 * Show final result.
 	 */

package/lib/loadtest.js

@@ -160,7 +160,7 @@ class Operation {
 	 */
 	stop() {
 		this.running = false;
-		this.latency.running = false;
+		this.latency.finish()
 		if (this.showTimer) {
 			this.showTimer.stop();
 		}

package/lib/result.js

@@ -4,26 +4,114 @@
  * Result of a load test.
  */
 export class Result {
-	constructor(options, latency) {
-		// options
+	constructor() {
+		this.url = null
+		this.cores = 0
+		this.maxRequests = 0
+		this.maxSeconds = 0
+		this.concurrency = 0
+		this.agent = null
+		this.requestsPerSecond = 0
+		this.startTimeMs = Number.MAX_SAFE_INTEGER
+		this.endTimeMs = 0
+		this.elapsedSeconds = 0
+		this.totalRequests = 0
+		this.totalErrors = 0
+		this.totalTimeSeconds = 0
+		this.accumulatedMs = 0
+		this.maxLatencyMs = 0
+		this.minLatencyMs = Number.MAX_SAFE_INTEGER
+		this.errorCodes = {}
+		this.histogramMs = {}
+	}
+
+	compute(options, latency) {
+		// configuration
 		this.url = options.url
-		this.maxRequests = options.maxRequests
-		this.maxSeconds = options.maxSeconds
-		this.concurrency = options.concurrency
+		this.cores = options.cores
+		this.maxRequests = parseInt(options.maxRequests)
+		this.maxSeconds = parseInt(options.maxSeconds)
+		this.concurrency = parseInt(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.requestsPerSecond = parseInt(options.requestsPerSecond)
+		// result
+		this.startTimeMs = Number(latency.startTimeNs / 1000000n)
+		this.endTimeMs = Number(latency.endTimeNs / 1000000n)
 		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.accumulatedMs = latency.totalTime
 		this.maxLatencyMs = latency.maxLatencyMs
 		this.minLatencyMs = latency.minLatencyMs
-		this.percentiles = latency.computePercentiles()
 		this.errorCodes = latency.errorCodes
+		this.histogramMs = latency.histogramMs
+		this.computeDerived()
+	}
+
+	computeDerived() {
+		this.elapsedSeconds = (this.endTimeMs - this.startTimeMs) / 1000
+		this.totalTimeSeconds = this.elapsedSeconds // backwards compatibility
+		const meanTime = this.accumulatedMs / this.totalRequests
+		this.meanLatencyMs = Math.round(meanTime * 10) / 10
+		this.effectiveRps = Math.round(this.totalRequests / this.elapsedSeconds)
+		this.rps = this.effectiveRps // backwards compatibility
+		this.computePercentiles()
+	}
+
+	computePercentiles() {
+		this.percentiles = {
+			50: false,
+			90: false,
+			95: false,
+			99: false
+		};
+		let counted = 0;
+
+		for (let ms = 0; ms <= this.maxLatencyMs; ms++) {
+			if (!this.histogramMs[ms]) {
+				continue;
+			}
+			counted += this.histogramMs[ms];
+			const percent = counted / this.totalRequests * 100;
+
+			Object.keys(this.percentiles).forEach(percentile => {
+				if (!this.percentiles[percentile] && percent > percentile) {
+					this.percentiles[percentile] = ms;
+				}
+			});
+		}
+	}
+
+	combine(result) {
+		// configuration
+		this.url = this.url || result.url
+		this.cores += 1
+		this.maxRequests += result.maxRequests
+		this.maxSeconds = this.maxSeconds || result.maxSeconds
+		this.concurrency = this.concurrency || result.concurrency
+		this.agent = this.agent || result.agent
+		this.requestsPerSecond += result.requestsPerSecond || 0
+		// result
+		this.startTimeMs = Math.min(this.startTimeMs, result.startTimeMs)
+		this.endTimeMs = Math.max(this.endTimeMs, result.endTimeMs)
+		this.totalRequests += result.totalRequests
+		this.totalErrors += result.totalErrors
+		this.accumulatedMs += result.accumulatedMs
+		this.maxLatencyMs = Math.max(this.maxLatencyMs, result.maxLatencyMs)
+		this.minLatencyMs = Math.min(this.minLatencyMs, result.minLatencyMs)
+		this.combineMap(this.errorCodes, result.errorCodes)
+		this.combineMap(this.histogramMs, result.histogramMs)
+		this.computeDerived()
+	}
+
+	combineMap(originalMap, addedMap) {
+		for (const key in {...originalMap, ...addedMap}) {
+			if (!originalMap[key]) {
+				originalMap[key] = 0
+			}
+			if (addedMap[key]) {
+				originalMap[key] += addedMap[key]
+			}
+		}
 	}
 
 	/**
@@ -38,16 +126,19 @@ export class Result {
 			console.info('Max time (s):        %s', this.maxSeconds);
 		}
 		console.info('Concurrency level:   %s', this.concurrency);
+		if (this.cores) {
+			console.info('Running on cores:    %s', this.cores);
+		}
 		console.info('Agent:               %s', this.agent);
 		if (this.requestsPerSecond) {
-			console.info('Requests per second: %s', this.requestsPerSecond);
+			console.info('Target rps:          %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('Total time:          %s s', this.elapsedSeconds);
 		console.info('Mean latency:        %s ms', this.meanLatencyMs);
+		console.info('Effective rps:       %s', this.effectiveRps);
 		console.info('');
 		console.info('Percentage of the requests served within a certain time');
 

package/lib/testserver.js

@@ -8,6 +8,30 @@ const PORT = 7357;
 const LOG_HEADERS_INTERVAL_MS = 5000;
 
 
+/**
+ * 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);
+	if (callback) {
+		return server.start(callback)
+	}
+	return new Promise((resolve, reject) => {
+		server.start((error, result) => {
+			if (error) return reject(error)
+			return resolve(result)
+		})
+	})
+}
+
 /**
  * A test server, with the given options (see below on startServer()).
  */
@@ -82,6 +106,11 @@ class TestServer {
 		request.on('data', data => {
 			request.body += data.toString();
 		});
+		request.on('error', () => {
+			// ignore request
+			response.end()
+			this.latency.end(id, -1);
+		})
 		request.on('end', () => {
 			this.totalRequests += 1
 			const elapsedMs = Date.now() - this.debuggedTime
@@ -165,27 +194,3 @@ class TestServer {
 	}
 }
 
-/**
- * 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);
-	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.2.2",
+	"version": "6.3.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",

package/test/all.js

@@ -14,6 +14,7 @@ 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'
+import {test as testResult} from './result.js'
 
 
 /**
@@ -23,7 +24,7 @@ function test() {
 	const tests = [
 		testHrtimer, testHeaders, testLatency, testHttpClient,
 		testServer, integrationTest, testLoadtest, testWebsocket,
-		testRequestGenerator, testBodyGenerator,
+		testRequestGenerator, testBodyGenerator, testResult,
 	];
 	testing.run(tests, 4200);
 }

package/test/result.js

@@ -0,0 +1,48 @@
+import testing from 'testing'
+import {Result} from '../lib/result.js'
+
+
+function testCombineEmptyResults(callback) {
+	const result = new Result()
+	result.combine(new Result())
+	testing.assert(!result.url, callback)
+	testing.success(callback)
+}
+
+function testCombineResults(callback) {
+	const combined = new Result()
+	const url = 'https://pinchito.es/'
+	for (let index = 0; index < 3; index++) {
+		const result = {
+			url,
+			cores: 7,
+			maxRequests: 1000,
+			concurrency: 10,
+			agent: 'none',
+			requestsPerSecond: 100,
+			totalRequests: 330,
+			totalErrors: 10,
+			startTimeMs: 1000 + index * 1000,
+			endTimeMs: 1000 + index * 2000,
+			accumulatedMs: 5000,
+			maxLatencyMs: 350 + index,
+			minLatencyMs: 2 + index,
+			errorCodes: {200: 100, 100: 200},
+			histogramMs: {2: 1, 3: 4, 100: 300},
+		}
+		combined.combine(result)
+	}
+	testing.assertEquals(combined.url, url, callback)
+	testing.assertEquals(combined.cores, 3, callback)
+	testing.assertEquals(combined.totalErrors, 30, callback)
+	testing.assertEquals(combined.elapsedSeconds, 4, callback)
+	testing.success(callback)
+}
+
+export function test(callback) {
+	const tests = [
+		testCombineEmptyResults, testCombineResults,
+	];
+	testing.run(tests, callback);
+}
+