loadtest 5.0.4 → 5.2.0

package/README.md

@@ -603,6 +603,25 @@ will be:
 * ...
 * body will also be replaced `body:{ userid: id_value }` will be `body:{ userid: id_1 }`
 
+#### `indexParamCallback`
+
+A function that would be executed to replace the value identified through `indexParam` through a custom value generator.
+
+E.g.: if URL is `http://test.com/value` and `indexParam=value` and
+```javascript
+indexParamCallback: function customCallBack() {
+  return Math.floor(Math.random() * 10); //returns a random integer from 0 to 9
+}
+``` 
+then the URL could be:
+
+* http://test.com/1 (Randomly generated integer 1)
+* http://test.com/5 (Randomly generated integer 5)
+* http://test.com/6 (Randomly generated integer 6)
+* http://test.com/8 (Randomly generated integer 8)
+* ...
+* body will also be replaced `body:{ userid: id_value }` will be `body:{ userid: id_<value from callback> }`
+
 #### `insecure`
 
 Allow invalid and self-signed certificates over https.
@@ -632,7 +651,7 @@ loadtest.loadTest(options, function(error) {
 
 #### `statusCallback`
 
-Execution this function after every request operation completes. Provides immediate access to test results while the
+If present, this function executes after every request operation completes. Provides immediate access to test results while the
 test batch is still running. This can be used for more detailed custom logging or developing your own spreadsheet or
 statistical analysis of results.
 
@@ -673,6 +692,31 @@ loadtest.loadTest(options, function(error) {
 });
 ```
 
+ 
+In some situations request data needs to be available in the statusCallBack.
+This data can be assigned to `request.labels` in the requestGenerator:
+```javascript
+const options = {
+	// ...
+	requestGenerator: (params, options, client, callback) => {
+		// ...
+        const randomInputData = Math.random().toString().substr(2, 8);
+        const message = JSON.stringify({ randomInputData })
+		const request = client(options, callback);
+        request.labels = randomInputData;
+		request.write(message);
+		return request;
+	}
+};
+```
+
+Then in statusCallBack the labels can be accessed through `result.labels`:
+```javascript
+function statusCallback(error, result, latency) {
+    console.log(result.labels);
+}
+```
+
 **Warning**: The format for `statusCallback` has changed in version 2.0.0 onwards.
 It used to be `statusCallback(latency, result, error)`,
 it has been changed to conform to the usual Node.js standard.
@@ -690,7 +734,7 @@ The `result` object passed to this callback function has the same fields as the
 Example:
 
 ```javascript
-fucntion contentInspector (result) => {
+function contentInspector(result) {
     if (result.statusCode == 200) {
         const body = JSON.parse(result.body)
         // how to examine the body depends on the content that the service returns

package/index.d.ts

@@ -1,6 +1,10 @@
 declare namespace loadtest {
-	export function loadTest(options: LoadTestOptions, err: Function): void;
-
+	export function loadTest(options: LoadTestOptions, err: Function): Operation;
+	
+    export interface Operation {
+        completedRequests: number
+    }
+	
 	export interface LoadTestOptions {
 		url: string;
 		concurrency?: number;
@@ -21,6 +25,7 @@ declare namespace loadtest {
 		secureProtocol?: string;
 		statusCallback?(error: Error, result: any, latency: LoadTestResult): void;
 		contentInspector?(result: any): void;
+		indexParamCallback?(): string;
 	}
 
 	export interface LoadTestResult {

package/lib/httpClient.js

@@ -248,14 +248,18 @@ class HttpClient {
 				callback('Connection ' + id + ' failed: ' + error, '1');
 			});
 			connection.on('end', () => {
+				const client = connection.connection || connection.client
 				const result = {
-					host: connection.connection._host,
+					host: client._host,
 					path: connection.req.path,
 					method: connection.req.method,
 					statusCode: connection.statusCode,
 					body: body,
 					headers: connection.headers,
 				};
+				if (connection.req.labels) {
+					result.labels = connection.req.labels
+				}
 				if (contentInspector) {
 					contentInspector(result)
 				}

package/lib/loadtest.js

@@ -88,8 +88,8 @@ let operationInstanceIndex = 0;
  */
 class Operation {
 	constructor(options, callback) {
-		this.options = options
-		this.finalCallback = callback
+		this.options = options;
+		this.finalCallback = callback;
 		this.running = true;
 		this.latency = null;
 		this.clients = {};
@@ -110,7 +110,7 @@ class Operation {
 			this.stopTimeout = setTimeout(() => this.stop(), this.options.maxSeconds * 1000).unref();
 		}
 		this.showTimer = new HighResolutionTimer(SHOW_INTERVAL_MS, () => this.latency.showPartial());
-		this.showTimer.unref()
+		this.showTimer.unref();
 	}
 
 	/**
@@ -139,14 +139,24 @@ class Operation {
 	 */
 	startClients() {
 		const url = this.options.url;
+		const strBody = JSON.stringify(this.options.body);
 		for (let index = 0; index < this.options.concurrency; index++) {
 			if (this.options.indexParam) {
-				this.options.url = url.replace(new RegExp(this.options.indexParam, 'g'), index);
-
-				if(this.options.body) {
-					let strBody = JSON.stringify(this.options.body);
-					strBody = strBody.replace(new RegExp(this.options.indexParam, 'g'), index);
-					this.options.body = JSON.parse(strBody);
+				let oldToken = new RegExp(this.options.indexParam, 'g');
+				if(this.options.indexParamCallback instanceof Function) {
+					let customIndex = this.options.indexParamCallback();
+					this.options.url = url.replace(oldToken, customIndex);
+					if(this.options.body) {
+						let body = strBody.replace(oldToken, customIndex);
+						this.options.body = JSON.parse(body);
+					}
+				}
+				else {
+					this.options.url = url.replace(oldToken, index);
+					if(this.options.body) {
+						let body = strBody.replace(oldToken, index);
+						this.options.body = JSON.parse(body);
+					}
 				}
 			}
 			let constructor = httpClient.create;
@@ -219,12 +229,66 @@ function testWSEcho(callback) {
 	exports.loadTest(options, callback);
 }
 
+function testIndexParam(callback) {
+	const options = {
+		url: 'http://localhost:7357/replace',
+		concurrency:1,
+		quiet: true,
+		maxSeconds: 0.1,
+		indexParam: "replace"
+	};
+	exports.loadTest(options, callback);
+}
+
+function testIndexParamWithBody(callback) {
+	const options = {
+		url: 'http://localhost:7357/replace',
+		concurrency:1,
+		quiet: true,
+		maxSeconds: 0.1,
+		indexParam: "replace",
+		body: '{"id": "replace"}'
+	};
+	exports.loadTest(options, callback);
+}
+
+function testIndexParamWithCallback(callback) {
+	const options = {
+		url: 'http://localhost:7357/replace',
+		concurrency:1,
+		quiet: true,
+		maxSeconds: 0.1,
+		indexParam: "replace",
+		indexParamCallback: function() {
+			//https://gist.github.com/6174/6062387
+			return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+		}
+	};
+	exports.loadTest(options, callback);
+}
+
+function testIndexParamWithCallbackAndBody(callback) {
+	const options = {
+		url: 'http://localhost:7357/replace',
+		concurrency:1,
+		quiet: true,
+		maxSeconds: 0.1,
+		body: '{"id": "replace"}',
+		indexParam: "replace",
+		indexParamCallback: function() {
+			//https://gist.github.com/6174/6062387
+			return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+		}
+	};
+	exports.loadTest(options, callback);
+}
+
 
 /**
  * Run all tests.
  */
 exports.test = function(callback) {
-	testing.run([testMaxSeconds, testWSEcho], callback);
+	testing.run([testMaxSeconds, testWSEcho, testIndexParam, testIndexParamWithBody, testIndexParamWithCallback, testIndexParamWithCallbackAndBody], callback);
 };
 
 // run tests if invoked directly

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "loadtest",
-	"version": "5.0.4",
+	"version": "5.2.0",
 	"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": [