loadtest 5.1.2 → 6.0.0

package/sample/request-generator.js

@@ -1,12 +1,10 @@
-'use strict';
-
 /**
  * Sample request generator usage.
  * Contributed by jjohnsonvng:
  * https://github.com/alexfernandez/loadtest/issues/86#issuecomment-211579639
  */
 
-const loadtest = require('../lib/loadtest.js');
+import {loadTest} from '../index.js'
 
 const options = {
 	url: 'http://yourHost',
@@ -27,7 +25,7 @@ const options = {
 	}
 };
 
-loadtest.loadTest(options, (error, results) => {
+loadTest(options, (error, results) => {
 	if (error) {
 		return console.error('Got an error: %s', error);
 	}

package/test/all.js

@@ -0,0 +1,33 @@
+/**
+ * Run package tests.
+ * (C) 2013 Alex Fernández.
+ */
+
+import testing from 'testing'
+import {test as testHrtimer} from './hrtimer.js'
+import {test as testHeaders} from './headers.js'
+import {test as testLatency} from './latency.js'
+import {test as testHttpClient} from './httpClient.js'
+import {test as testServer} from './testserver.js'
+import {test as testRequestGenerator} from './request-generator.js'
+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'
+
+
+/**
+ * Run all module tests.
+ */
+function test() {
+	const tests = [
+		testHrtimer, testHeaders, testLatency, testHttpClient,
+		testServer, integrationTest, testLoadtest, testWebsocket,
+		testRequestGenerator, testBodyGenerator,
+	];
+	testing.run(tests, 4200);
+}
+
+test()
+
+

package/test/body-generator.js

@@ -0,0 +1,41 @@
+import testing from 'testing'
+import {loadTest} from '../lib/loadtest.js'
+import {startServer} from '../lib/testserver.js'
+
+const PORT = 10453;
+
+
+function testBodyGenerator(callback) {
+	const server = startServer({port: PORT}, error => {
+		if (error) {
+			return callback('Could not start test server');
+		}
+		const options = {
+			url: 'http://localhost:' + PORT,
+			requestsPerSecond: 100,
+			maxRequests: 100,
+			concurrency: 10,
+			postFile: 'sample/post-file.js',
+		}
+		loadTest(options, (error, result) => {
+			if (error) {
+				console.error(error)
+				return callback(`Could not run load test with postFile: ${error.message}`);
+			}
+			server.close(error => {
+				if (error) {
+					return callback('Could not close test server');
+				}
+				return callback(null, 'bodyGenerator succeeded: ' + JSON.stringify(result));
+			});
+		});
+	});
+}
+
+/**
+ * Run all tests.
+ */
+export function test(callback) {
+	testing.run([testBodyGenerator], 4000, callback);
+}
+

package/test/headers.js

@@ -0,0 +1,51 @@
+import testing from 'testing'
+import {addHeaders, addUserAgent} from '../lib/headers.js'
+
+
+function testAddHeaders(callback) {
+	const tests = [ {
+		raw: 'k:v',
+		headers: { 'k': 'v' }
+	}, {
+		raw: ['k:v', 'k:v2'],
+		headers:  { 'k': 'v2' }
+	}, {
+		raw: ['k:v', 'k2:v2'],
+		headers: { 'k': 'v', 'k2': 'v2' }
+	}, {
+		raw: 'K:v',
+		headers: { 'k': 'v' }
+	}, {
+		raw: 'k:v:w',
+		headers: { 'k': 'v:w' }
+	}
+	];
+	tests.forEach(function(test) {
+		const headers = {};
+		addHeaders(test.raw, headers);
+		testing.assertEquals(headers, test.headers, 'Wrong headers', callback);
+	});
+	testing.success(callback);
+}
+
+function testAddUserAgent(callback) {
+	const headers =  {'k': 'v', 'q': 'r' };
+	addUserAgent(headers);
+	testing.assertEquals(Object.keys(headers).length, 3, 'Did not add user agent', callback);
+	const userAgent = headers['user-agent'];
+	testing.assert(userAgent.includes('bot'), 'Invalid user agent', callback);
+	addUserAgent(headers);
+	testing.assertEquals(Object.keys(headers).length, 3, 'Should not add user agent', callback);
+	testing.success(callback);
+}
+
+/**
+ * Run all tests.
+ */
+export function test(callback) {
+	testing.run([
+		testAddHeaders,
+		testAddUserAgent,
+	], callback);
+}
+

package/test/hrtimer.js

@@ -0,0 +1,39 @@
+/**
+ * Measure latency for a load test.
+ * (C) 2013 Alex Fernández.
+ */
+
+
+import testing from 'testing';
+import {HighResolutionTimer} from '../lib/hrtimer.js'
+
+
+/**
+ * Test a high resolution timer.
+ */
+function testTimerStop(callback) {
+	const timer = new HighResolutionTimer(10, callback);
+	setImmediate(() => timer.stop())
+}
+
+function testTimerRun(callback) {
+	let run = 0
+	const timer = new HighResolutionTimer(100, () => run++)
+	setTimeout(() => {
+		testing.equals(run, 3, callback)
+		timer.stop()
+		testing.success(callback)
+	}, 250)
+}
+
+/**
+ * Run package tests.
+ */
+export function test(callback) {
+	const tests = [
+		testTimerStop,
+		testTimerRun,
+	];
+	testing.run(tests, callback);
+}
+

package/test/httpClient.js

@@ -0,0 +1,22 @@
+import testing from 'testing'
+import {create} from '../lib/httpClient.js'
+
+
+function testHttpClient(callback) {
+	const options = {
+		url: 'http://localhost:7357/',
+		maxSeconds: 0.1,
+		concurrency: 1,
+	};
+	create({}, options);
+	testing.success(callback);
+}
+
+
+/**
+ * Run all tests.
+ */
+export function test(callback) {
+	testing.run([testHttpClient], callback)
+}
+

package/{lib → test}/integration.js

@@ -1,23 +1,8 @@
-'use strict';
+import * as testing from 'testing'
+import {execFile} from 'child_process'
+import {join} from 'path'
+import {loadTest, startServer} from '../index.js'
 
-/**
- * API usage examples
- * (C) 2013 Alex Fernández.
- */
-
-
-// requires
-const loadtest = require('./loadtest.js');
-const testserver = require('./testserver.js');
-const testing = require('testing');
-const Log = require('log');
-const { execFile } = require('child_process');
-const { join } = require('path');
-
-// globals
-const log = new Log('info');
-
-// constants
 const PORT = 10408;
 
 
@@ -25,7 +10,7 @@ const PORT = 10408;
  * Run an integration test.
  */
 function testIntegration(callback) {
-	const server = testserver.startServer({ port: PORT }, error => {
+	const server = startServer({ port: PORT }, error => {
 		if (error) {
 			return callback(error);
 		}
@@ -38,7 +23,7 @@ function testIntegration(callback) {
 				hi: 'there',
 			},
 		};
-		loadtest.loadTest(options, (error, result) => {
+		loadTest(options, (error, result) => {
 			if (error) {
 				return callback(error);
 			}
@@ -57,13 +42,12 @@ function testIntegration(callback) {
  * Run an integration test using configuration file.
  */
 function testIntegrationFile(callback) {
-	const server = testserver.startServer({ port: PORT }, error => {
+	const server = startServer({ port: PORT }, error => {
 		if (error) {
 			return callback(error);
 		}
 		execFile('node',
-			[join(__dirname, '..', 'bin', 'loadtest.js'), 'http://localhost:' + PORT],
-			{ cwd: join(__dirname, '..', 'test') },
+			[join('./', 'bin', 'loadtest.js'), `http://localhost:${PORT}/`, '-n', '100'],
 			(error, stdout) => {
 				if (error) {
 					return callback(error);
@@ -84,7 +68,7 @@ function testIntegrationFile(callback) {
  * Run an integration test.
  */
 function testWSIntegration(callback) {
-	const server = testserver.startServer({ port: PORT }, error => {
+	const server = startServer({ port: PORT }, error => {
 		if (error) {
 			return callback(error);
 		}
@@ -102,7 +86,7 @@ function testWSIntegration(callback) {
 				hi: 'there',
 			},
 		};
-		loadtest.loadTest(options, (error, result) => {
+		loadTest(options, (error, result) => {
 			if (error) {
 				return callback(error);
 			}
@@ -125,7 +109,7 @@ function testDelay(callback) {
 		port: PORT + 1,
 		delay: delay,
 	};
-	const server = testserver.startServer(options, error => {
+	const server = startServer(options, error => {
 		if (error) {
 			return callback(error);
 		}
@@ -133,7 +117,7 @@ function testDelay(callback) {
 			url: 'http://localhost:' + (PORT + 1),
 			maxRequests: 10,
 		};
-		loadtest.loadTest(options, (error, result) => {
+		loadTest(options, (error, result) => {
 			if (error) {
 				return callback(error);
 			}
@@ -152,13 +136,7 @@ function testDelay(callback) {
 /**
  * Run all tests.
  */
-exports.test = function(callback) {
-	log.debug('Running all tests');
+export function test(callback) {
 	testing.run([testIntegration, testIntegrationFile, testDelay, testWSIntegration], 4000, callback);
-};
-
-// start load test if invoked directly
-if (__filename == process.argv[1]) {
-	exports.test(testing.show);
 }
 

package/test/latency.js

@@ -0,0 +1,81 @@
+import testing from 'testing'
+import {Latency} from '../lib/latency.js'
+
+
+/**
+ * Test latency ids.
+ */
+function testLatencyIds(callback) {
+	const latency = new Latency({});
+	const firstId = latency.start();
+	testing.assert(firstId, 'Invalid first latency id %s', firstId, callback);
+	const secondId = latency.start();
+	testing.assert(secondId, 'Invalid second latency id', callback);
+	testing.assert(firstId != secondId, 'Repeated latency ids', callback);
+	testing.success(callback);
+}
+
+/**
+ * Test latency measurements.
+ */
+function testLatencyRequests(callback) {
+	const options = {
+		maxRequests: 10,
+	};
+	const errorCode = '500';
+	const latency = new Latency(options, (error, result) => {
+		testing.check(error, 'Could not compute latency', callback);
+		testing.assertEquals(result.totalRequests, 10, 'Invalid total requests', callback);
+		testing.assertEquals(result.totalErrors, 1, 'Invalid total errors', callback);
+		testing.assert(errorCode in result.errorCodes, 'Error code not found', callback);
+		testing.assertEquals(result.errorCodes[errorCode], 1, 'Should have one ' + errorCode, callback);
+		testing.success(callback);
+	});
+	let id;
+	for (let i = 0; i < 9; i++) {
+		id = latency.start();
+		latency.end(id);
+	}
+	id = latency.start();
+	latency.end(id, errorCode);
+}
+
+/**
+ * Check that percentiles are correct.
+ */
+function testLatencyPercentiles(callback) {
+	const options = {
+		maxRequests: 10
+	};
+	const latency = new Latency(options, error => {
+		testing.check(error, 'Error while testing latency percentiles', callback);
+		const percentiles = latency.getResults().percentiles;
+
+		Object.keys(percentiles).forEach(percentile => {
+			testing.assert(percentiles[percentile] !== false, 'Empty percentile for %s', percentile, callback);
+		});
+
+		testing.success(percentiles, callback);
+	});
+	for (let ms = 1; ms <= 10; ms++) {
+		(function() {
+			const id = latency.start();
+			setTimeout(() => {
+				latency.end(id);
+			}, ms);
+		})();
+	}
+}
+
+/**
+ * Run package tests.
+ */
+export function test(callback) {
+	const tests = [
+		testLatencyIds,
+		testLatencyRequests,
+		testLatencyPercentiles,
+	];
+	testing.run(tests, callback);
+}
+

package/test/loadtest.js

@@ -0,0 +1,87 @@
+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/',
+		maxSeconds: 0.1,
+		concurrency: 1,
+	};
+	loadTest(options, callback);
+}
+
+
+/**
+ * A load test with max seconds.
+ */
+function testWSEcho(callback) {
+	const options = {
+		url: 'ws://localhost:7357/',
+		maxSeconds: 0.1,
+		concurrency: 1,
+	};
+	loadTest(options, callback);
+}
+
+function testIndexParam(callback) {
+	const options = {
+		url: 'http://localhost:7357/replace',
+		concurrency:1,
+		maxSeconds: 0.1,
+		indexParam: "replace"
+	};
+	loadTest(options, callback);
+}
+
+function testIndexParamWithBody(callback) {
+	const options = {
+		url: 'http://localhost:7357/replace',
+		concurrency:1,
+		maxSeconds: 0.1,
+		indexParam: "replace",
+		body: '{"id": "replace"}'
+	};
+	loadTest(options, callback);
+}
+
+function testIndexParamWithCallback(callback) {
+	const options = {
+		url: 'http://localhost:7357/replace',
+		concurrency:1,
+		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);
+		}
+	};
+	loadTest(options, callback);
+}
+
+function testIndexParamWithCallbackAndBody(callback) {
+	const options = {
+		url: 'http://localhost:7357/replace',
+		concurrency:1,
+		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);
+		}
+	};
+	loadTest(options, callback);
+}
+
+
+/**
+ * Run all tests.
+ */
+export function test(callback) {
+	testing.run([testMaxSeconds, testWSEcho, testIndexParam, testIndexParamWithBody, testIndexParamWithCallback, testIndexParamWithCallbackAndBody], callback);
+}
+

package/{lib → test}/request-generator.js

@@ -1,26 +1,19 @@
-'use strict';
+import testing from 'testing'
+import {loadTest} from '../lib/loadtest.js'
+import {startServer} from '../lib/testserver.js'
 
-const loadtest = require('./loadtest.js');
-const testserver = require('./testserver.js');
-const testing = require('testing');
-const Log = require('log');
-
-// globals
-const log = new Log('info');
-
-// constants
 const PORT = 10453;
 
 
 function testRequestGenerator(callback) {
-	const server = testserver.startServer({port: PORT}, error => {
+	const server = startServer({port: PORT}, error => {
 		if (error) {
 			return callback('Could not start test server');
 		}
 		const options = {
 			url: 'http://localhost:' + PORT,
 			method: 'POST',
-			requestsPerSecond: 20,
+			requestsPerSecond: 100,
 			maxRequests: 100,
 			concurrency: 10,
 			requestGenerator: (params, options, client, callback) => {
@@ -32,9 +25,10 @@ function testRequestGenerator(callback) {
 				return request;
 			},
 		};
-		loadtest.loadTest(options, (error, result) => {
+		loadTest(options, (error, result) => {
 			if (error) {
-				return callback('Could not run load test with requestGenerator');
+				console.error(error)
+				return callback(`Could not run load test with requestGenerator: ${error.message}`);
 			}
 			server.close(error => {
 				if (error) {
@@ -49,13 +43,7 @@ function testRequestGenerator(callback) {
 /**
  * Run all tests.
  */
-exports.test = function(callback) {
-	log.debug('Running all tests');
+export function test(callback) {
 	testing.run([testRequestGenerator], 4000, callback);
-};
-
-// start load test if invoked directly
-if (__filename == process.argv[1]) {
-	exports.test(testing.show);
 }
 

package/test/testserver.js

@@ -0,0 +1,24 @@
+import testing from 'testing'
+import {startServer} from '../lib/testserver.js'
+
+
+function testStartServer(callback) {
+	const options = {
+		port: 10530,
+	};
+	const server = startServer(options, error => {
+		testing.check(error, 'Could not start server', callback);
+		server.close(error => {
+			testing.check(error, 'Could not stop server', callback);
+			testing.success(callback);
+		});
+	});
+}
+
+/**
+ * Run the tests.
+ */
+export function test(callback) {
+	testing.run([testStartServer], 5000, callback);
+}
+

package/test/websocket.js

@@ -0,0 +1,23 @@
+import testing from 'testing'
+import {create} from '../lib/websocket.js'
+
+
+function testWebsocketClient(callback) {
+	const options = {
+		url: 'ws://localhost:7357/',
+		maxSeconds: 0.1,
+		concurrency: 1,
+	};
+	create({}, options);
+	testing.success(callback);
+}
+
+/**
+ * Run tests, currently nothing.
+ */
+export function test(callback) {
+	testing.run([
+		testWebsocketClient,
+	], callback);
+}
+

package/test.js

@@ -1,36 +0,0 @@
-'use strict';
-
-/**
- * Run package tests.
- * (C) 2013 Alex Fernández.
- */
-
-// requires
-const testing = require('testing');
-const Log = require('log');
-
-// globals
-const log = new Log('info');
-
-
-/**
- * Run all module tests.
- */
-exports.test = function(callback)
-{
-	log.debug('Running tests');
-	const tests = {};
-	const libs = ['hrtimer', 'latency', 'integration', 'loadtest', 'headers', 'testserver', 'websocket', 'httpClient'];
-	libs.forEach(function(lib)
-	{
-		tests[lib] = require('./lib/' + lib + '.js').test;
-	});
-	testing.run(tests, 4200, callback);
-};
-
-// run tests if invoked directly
-if (__filename == process.argv[1])
-{
-	exports.test();
-}
-