loadtest 6.2.0 → 6.2.2

package/lib/httpClient.js

@@ -37,10 +37,7 @@ 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;

package/lib/options.js

@@ -8,97 +8,120 @@ const acceptedMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'get', 'post',
 
 
 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')
-	}
-	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
 	}
-	processed.url = options.url
-	const configuration = loadConfig();
-	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) {
-		processed.method = 'POST';
-		processed.body = options.postBody;
-	}
-	if (options.postFile) {
-		processed.method = 'POST';
-		processed.body = await readBody(options.postFile, '-p');
-	}
-	if (options.data) {
-		processed.body = options.data
-	}
-	if (options.putFile) {
-		processed.method = 'PUT';
-		processed.body = await readBody(options.putFile, '-u');
-	}
-	if (options.patchBody) {
-		processed.method = 'PATCH';
-		processed.body = options.patchBody;
-	}
-	if (options.patchFile) {
-		processed.method = 'PATCH';
-		processed.body = await readBody(options.patchFile, '-a');
-	}
-	// sanity check
-	if (acceptedMethods.indexOf(processed.method) === -1) {
-		throw new Error(`Invalid method ${processed.method}`)
-	}
-	if (!options.body) {
-		if(configuration.body) {
-			processed.body = configuration.body;
-		} else if (configuration.file) {
-			processed.body = await readBody(configuration.file, 'configuration.request.file');
+
+	getUrl(options) {
+		if (!options.url) {
+			throw new Error('Missing URL in options')
 		}
+		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
 	}
-	if (options.key || configuration.key) {
-		processed.key = await readFile(options.key || configuration.key)
-	}
-	if (options.cert || configuration.cert) {
-		processed.cert = await readFile(options.cert || configuration.cert);
-	}
-	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, processed.headers);
+	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
+			}
+		}
 	}
-	processed.requestGenerator = options.requestGenerator || configuration.requestGenerator
-	if (typeof processed.requestGenerator == 'string') {
-		processed.requestGenerator = await import(processed.requestGenerator)
+
+	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);
+		}
 	}
-	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) {
+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()}/`))

package/lib/testserver.js

@@ -5,7 +5,7 @@ import * as net from 'net'
 import {Latency} from './latency.js'
 
 const PORT = 7357;
-const LOG_HEADERS_INTERVAL_SECONDS = 1;
+const LOG_HEADERS_INTERVAL_MS = 5000;
 
 
 /**
@@ -18,6 +18,7 @@ class TestServer {
 		this.server = null;
 		this.wsServer = null;
 		this.latency = new Latency({});
+		this.totalRequests = 0
 		this.debuggedTime = Date.now();
 	}
 
@@ -82,10 +83,10 @@ class TestServer {
 			request.body += data.toString();
 		});
 		request.on('end', () => {
-			const now = Date.now();
-			if (now - this.debuggedTime > LOG_HEADERS_INTERVAL_SECONDS * 1000) {
-				this.debug(request);
-				this.debuggedTime = now;
+			this.totalRequests += 1
+			const elapsedMs = Date.now() - this.debuggedTime
+			if (elapsedMs > LOG_HEADERS_INTERVAL_MS) {
+				this.debug(request, elapsedMs);
 			}
 			if (!this.options.delay) {
 				return this.end(response, id);
@@ -118,10 +119,20 @@ class TestServer {
 	 * Debug headers and other interesting information: POST body.
 	 */
 	debug(request) {
-		if (!this.options.quiet) console.info('Headers for %s to %s: %s', request.method, request.url, util.inspect(request.headers));
+		if (this.options.quiet) return
+		const headers = util.inspect(request.headers)
+		const now = Date.now()
+		const elapsedMs = now - this.debuggedTime
+		const rps = (this.totalRequests / elapsedMs) * 1000
+		if (rps > 1) {
+			console.info(`Requests per second: ${rps.toFixed(0)}`)
+		}
+		console.info(`Headers for ${request.method} to ${request.url}: ${headers}`)
 		if (request.body) {
-			if (!this.options.quiet) console.info('Body: %s', request.body);
+			console.info(`Body: ${request.body}`);
 		}
+		this.debuggedTime = now;
+		this.totalRequests = 0
 	}
 
 	/**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "loadtest",
-	"version": "6.2.0",
+	"version": "6.2.2",
 	"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",