urlExists(url, function(err, exists) {
if(!exists)
res.send("not_valid");
else
{
var options = {
url: url,
concurrency: 5,
maxRequests: 10,
maxSeconds: 30
};
loadtest.loadTest(options, function(error, result)
{
if (error)
{
var data={};
data.title = "error";
data.msg = error;
res.send(JSON.stringify(data));
return console.error('Got an error: %s', error);
}
else
{
var data={};
data.title = "success";
data.msg = result;
//console.log('Tests run successfully');
console.log(data);
res.send(JSON.stringify(data));
}
});
}
});
var prequest = function () {
// jwt option is enable and custom jwt header exists ?
if (_.isString(jwtToken) && !_.isEmpty(items.jwt) && _.has(entry.headers, items.jwt)) {
// change header for token validity
entry.headers[items.jwt] = jwtToken;
}
// load test
loadtest.loadTest(_.extend(entry, {
maxRequests : items.users,
timeout : items.timeout,
concurrency : items.users,
requestsPerSecond : items.requestsPerSecond,
insecure : items.insecure
}), function (error, result) {
// push data on storage array
report.result.push(_.extend({},
{ url : entry.url }, _.omit(error ? error : result,
[ 'body', 'headers', 'instanceIndex', 'requestIndex' ])));
// verbose process
verbose([ 'Load for [', pages.id, '] - [',
entry.url, '] was ending' ].join(' '), items.verbose, true);
verbose([ 'Sleeping', items.wait, 'Ms before next request' ].join(' '),
items.verbose);
// process request with config latency
sleep.usleep(items.wait);
// stop snipper
sp.stop(false);
// process next entry
nextEntry();
});
};
test('HomePage should handle 300 requests in a second',(done)=>{
// function statusCallback(latency, result, error) {
// console.log('Current latency %j, result %j', latency, error ? JSON.stringify(error) + result.toString() : result);
// console.log('----');
// console.log('Request elapsed milliseconds: ', error ? error.requestElapsed : result.requestElapsed);
// console.log('Request index: ', error ? error.requestIndex : result.requestIndex);
// console.log('Request loadtest() instance index: ', error ? error.instanceIndex : result.instanceIndex);
// }
let options = {
url:'http://localhost:8000',
concurrency: 4,
maxRequests: 300,
//statusCallback: statusCallback
};
loadtest.loadTest(options, (err,result)=>{
expect(!err);
//expect(result.totalTimeSeconds < 1);
done();
});
});
load(options) {
loadtest.loadTest(options, (error, result) => {
if (error) {
console.log('Got an error: %s', error);
} else {
console.log(result);
}
});
}
test('Homepage handling 250 requests', function(done){
var options = {
url: 'http://localhost:3000',
concurrency: parallel,
maxRequests: maxRequ
};
loadtest.loadTest(options, function(err,result){
expect(!err);
expect(result.totalTimeSeconds < 1);
done();
});
});
test('Homepage should handle 200 responses in a second',function(done){
var options={
url:"http://localhost:3000",
concurrency:4,
maxRequests:200
};
loadtest.loadTest(options,function(err,result){
expect(!err);
expect(result.totalTimeSeconds<1);
done();
});
});
test('Homepage should handle 50 requests in under a second', function(done) {
var options = {
url: 'http://localhost:3000',
concurrency: 4,
maxRequests: 50,
};
loadtest.loadTest(options, function(err,result) {
expect(!err);
expect(result.totalTimeSeconds < 1);
done();
});
});
it("maintains performance", function(done) {
loadtest.loadTest(options, function(error, result) {
if (error) {
return console.error('Got an error: %s', error);
}
expect(result.totalErrors).toBe(0);
expect(result.meanLatencyMs).toBeLessThan(1600);
done();
});
},specTime);
test('Homepage should handle 100 requests in a second', function (done) {
var options = {
url: 'http://192.168.2.167:3000',
// concurrency: 4,
maxRequests: 100
};
loadtest.loadTest(options, function (err, result) {
// expect(!err);
// expect(result.totalTimeSeconds < 1);
done();
});
});
it('GET /abc/123, load test 5000 requests, expect < 30 sec', function(done) {
this.timeout(30000);
var options = {
url: 'http://' + testUsername + ':' + testPassword + '@' + host + ':' + port + '/api/' + apiVersion + '/abc/123',
concurrency: 10,
maxRequests: 5000
};
loadtest.loadTest(options, function(err, result) {
should.not.exist(err);
(result.totalTimeSeconds < 30).should.equal(true);
done();
});
});
it('get-request', function (done) {
var url = 'http://localhost:3000';
var path = '/get-request';
var queryString = '?q=Ruby&l=LA&e=100';
var options = {
url: url + path + queryString,
concurrency: 4,
maxRequests: 100
};
loadtest.loadTest(options, function(err,result){
expect(!err);
expect(result.totalTimeSeconds < 1);
console.log(result);
done();
});
});
it("performance testing /ping", function(done) {
this.timeout(1000 * 60);
var options = {
"url": host + '/ping',
"maxSeconds": 30,
"concurrency": 25,
"statusCallback": statusCallback
};
var gLatency;
function statusCallback(latency, result, error) {
gLatency = latency;
}
var operation = loadtest.loadTest(options, function(error) {
if (error) {
console.error('Got an error: %s', error);
} else if (operation.running == false) {
console.info("\n=========================================================================================================\n")
console.info("\tThreshold : No of request per hour = " + noRequestPerHour + ", Avg request time in millis = " + avgRequestTime)
console.info("\n=========================================================================================================\n")
console.info("Total Requests :", gLatency.totalRequests);
console.info("Total Failures :", gLatency.totalErrors);
console.info("Requests Per Second :", gLatency.rps);
console.info("Requests Per Hour :", (gLatency.rps * 3600));
console.info("Average Request Time(Mills) :", gLatency.meanLatencyMs);
console.info("Minimum Request Time(Mills) :", gLatency.minLatencyMs);
console.info("Maximum Request Time(Mills) :", gLatency.maxLatencyMs);
console.info("Percentiles :", gLatency.percentiles)
console.info("\n=========================================================================================================\n")
gLatency.totalErrors.should.equal(0);
(gLatency.rps * 3600).should.be.greaterThan(noRequestPerHour);
(gLatency.meanLatencyMs).should.be.below(avgRequestTime);
done();
}
});
});
function spawnBenchmarkClient() {
var self = this;
var targetPort = self.ports.httpPort;
if (self.opts.relay) {
targetPort = self.ports.egressPort;
}
var options = {
url: 'http://127.0.0.1:' + targetPort,
concurrency: self.opts.numClients,
maxRequests: self.opts.numRequests,
agentKeepAlive: self.opts.keepAlive
};
loadtest.loadTest(options, function onLoad(error, result) {
if (error) {
console.error('benchmark failed with', error);
} else {
console.log('benchmark result', result);
}
self.close();
});
};
var server = serverLib.start(TEST_PORT, function()
{
var options = {
url: 'http://localhost:' + TEST_PORT + '/8',
maxRequests: 1000,
concurrency: 10,
method: 'POST',
body: {
hi: 'there',
},
};
loadtest.loadTest(options, function(error, result)
{
if (error)
{
return callback(error);
}
log.info('Latency results: %s', util.inspect(result));
testing.assertEquals(result.totalRequests, 1000, 'Not enough requests received', callback);
testing.assert(result.meanLatencyMs < 12, 'Invalid latency ' + result.meanLatencyMs, callback);
server.close(callback);
});
});
getUrls(function (urls) {
console.log(urls);
var options = {
url: '{url}',
indexParam: '{url}',
paramValues: urls,
maxRequests: 1000,
headers: {
accept: "application/json,text/plain,text/html"
},
concurrency: 4,
requestsPerSecond: 10
}
loadtest.loadTest(options, function (error, result) {
if (error) {
return console.error('Got an error: %s', error);
}
console.log('Tests run successfully');
console.log(result);
});
});
'use strict';
const test = require('loadtest');
var server = test.startServer({ port: 7357 }); //localhost
const fns = {};
var options = {
url: 'http://new.locator-app.com/',
maxRequests: 100,
};
module.exports =test.loadTest(options, function(error, result)
{
if (error)
{
return console.error('Got an error: %s', error);
}
console.log('Tests run successfully');
console.log(result);
});
server.close();
//module.exports = fns;
db.table('users').then(function (users) {
res.writeHead(200,{"content-type":"application/json"})
res.write(JSON.stringify(users))
res.end()
}).catch(function (err) {
res.writeHead(503,{"content-type":"application/json"})
res.write(err)
res.end()
})
}).listen(8000)
var options = {
url: 'http://localhost:8000',
maxRequests: 1000
};
console.time("Database");
loadtest.loadTest(options, function(error, result) {
if (error) {
return console.error('Got an error: %s', error);
}
console.log(result);
console.log('Tests run successfully');
console.timeEnd("Database")
server.close()
db.destroy()
process.exit(0)
});
// Run high loads of this request to burn cpu.
var add_coffee = {
url: 'http://localhost:' + 3000 + '/api/Coffees',
maxRequests: max_requests,
concurrency: 10,
method: 'POST',
contentType: 'application/json',
body: {"Name": "Hawaiian Kona Coffee", "RoastType": "Medium"}
};
loadtest.loadTest(add_coffee, function(error, result)
{
console.log(error);
if (error)
{
return console.error('Got an error: %s', error);
}
console.log('Added coffee');
console.log(result);
});
var add_beans = {
url: 'http://localhost:3000/api/Coffees/beans',
maxRequests: max_requests,
concurrency: concurrency,
method: "POST",
body: 'I am a bean'
};
loadtest.loadTest(add_beans, function(error, result)
{
'use strict';
const loadtest = require('loadtest');
const options = {
url: 'http://localhost:8080',
maxRequests: 5000,
concurrency: 100
};
loadtest.loadTest(options, (error, result) => {
console.log('Benchmarks', JSON.stringify(result, null, 2));
});
function (item, nextRoute) {
// check if item is enable
if (!item.enable) {
this.logger.info('[ YoctoLoad.start ] -loadtests is disable for route : ' + item.path);
return nextRoute;
}
// object that will be sent to client
var options = _.merge({
url : this.apiUrl + item.path
}, _.omit(item, [ 'enable', 'path' ]));
// TODO : set jwt process
if (!_.isNull(this.jwtToken)) {
this.logger.debug('[ YoctoLoad.start ] - x-jwt token was set into header for routes',
item.path);
// Set jwt header
options.headers = _.merge(options.headers, {
'x-jwt-access-token' : this.jwtToken
});
}
var date = new Date();
// object that will added on reports lists
var report = {
request : _.merge(options, {
startAt : date.toISOString()
})
};
this.logger.info('[ YoctoLoad.start.loadtest ] - process start for path : ' + item.path +
' [' + item.method + ']');
// Use load test to start load test
loadtest.loadTest(options, function (error, result) {
// retrieve date instance
var date = new Date();
// add the response to reports
report.response = _.merge({
endAt : date.toISOString()
}, error ? error : result);
this.reports.push(report);
// check if an error occured
if (error) {
// break the async process to show the error
this.logger.error('[ YoctoLoad.start.loadtest ] - an error occured : ' + error);
return nextRoute(error);
}
this.logger.info('[ YoctoLoad.start.loadtest ] - process succes for path : ' + item.path +
' , result is :' +
'\n --> Total Requests : ' + result.totalRequests +
'\n --> Total Errors : ' + result.totalErrors +
'\n --> Requests per seconds : ' + result.rps +
'\n --> Duration test (s) : ' + result.totalTimeSeconds +
'\n --> Min latency (ms) : ' + result.minLatencyMs +
'\n --> Max latency (ms) : ' + result.maxLatencyMs +
'\n --> Mean latency (ms) : ' + result.meanLatencyMs
);
// call next route
nextRoute();
}.bind(this));
}.bind(this), function done (error) {