mirror of https://gitee.com/bigwinds/arangodb
1527 lines
50 KiB
JavaScript
1527 lines
50 KiB
JavaScript
/*jshint strict: false */
|
|
/*global require, exports */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief General unittest framework
|
|
///
|
|
/// @file
|
|
///
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2014 triagens GmbH, Cologne, Germany
|
|
///
|
|
/// Licensed under the Apache License, Version 2.0 (the "License");
|
|
/// you may not use this file except in compliance with the License.
|
|
/// You may obtain a copy of the License at
|
|
///
|
|
/// http://www.apache.org/licenses/LICENSE-2.0
|
|
///
|
|
/// Unless required by applicable law or agreed to in writing, software
|
|
/// distributed under the License is distributed on an "AS IS" BASIS,
|
|
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
/// See the License for the specific language governing permissions and
|
|
/// limitations under the License.
|
|
///
|
|
/// Copyright holder is triAGENS GmbH, Cologne, Germany
|
|
///
|
|
/// @author Max Neunhoeffer
|
|
/// @author Copyright 2014, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @fn JSF_UnitTest
|
|
/// @brief framework to perform unittests
|
|
///
|
|
/// This function gets one or two arguments, the first describes which tests
|
|
/// to perform and the second is an options object. For `which` the following
|
|
/// values are allowed:
|
|
/// Empty will give you a complete list.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var functionsDocumentation = {
|
|
'all' : " do all tests (marked with [x])",
|
|
"shell_server_perf" : "bulk tests intended to get an overview of executiontime needed.",
|
|
"single_client" : "run one test suite isolated via the arangosh; options required\n" +
|
|
" Run without to get more detail",
|
|
"single_server" : "run one test suite on the server; options required\n" +
|
|
" Run without to get more detail"
|
|
};
|
|
|
|
var optionsDocumentation = [
|
|
'',
|
|
' The following properties of `options` are defined:',
|
|
'',
|
|
' - `jsonReply`: if set a json is returned which the caller has to ',
|
|
' present the user',
|
|
' - `force`: if set to true the tests are continued even if one fails',
|
|
' - `skipBoost`: if set to true the boost unittests are skipped',
|
|
' - `skipGeo`: if set to true the geo index tests are skipped',
|
|
' - `skipAhuacatl`: if set to true the ahuacatl tests are skipped',
|
|
' - `skipAql`: if set to true the AQL tests are skipped',
|
|
' - `skipRanges`: if set to true the ranges tests are skipped',
|
|
' - `skipTimeCritical`: if set to true, time critical tests will be skipped.',
|
|
'',
|
|
' - `cluster`: if set to true the tests are run with the coordinator',
|
|
' of a small local cluster',
|
|
' - `test`: path to single test to execute for "single" test target',
|
|
' - `cleanup`: if set to true (the default), the cluster data files',
|
|
' and logs are removed after termination of the test.',
|
|
' - `jasmineReportFormat`: this option is passed on to the `format`',
|
|
' option of the Jasmine options object, only for Jasmine tests.',
|
|
'',
|
|
' - `valgrind`: if set to true the arangods are run with the valgrind',
|
|
' memory checker',
|
|
' - `valgrindXmlFileBase`: string to prepend to the xml report name',
|
|
' - `valgrindargs`: list of commandline parameters to add to valgrind',
|
|
'',
|
|
' - `extraargs`: list of extra commandline arguments to add to arangod',
|
|
' - `portOffset`: move our base port by n ports up',
|
|
''
|
|
];
|
|
|
|
var _ = require("underscore");
|
|
var cleanupDirectories = [];
|
|
var testFuncs = {'all': function(){}};
|
|
var print = require("internal").print;
|
|
var time = require("internal").time;
|
|
var fs = require("fs");
|
|
var download = require("internal").download;
|
|
var wait = require("internal").wait;
|
|
var executeExternal = require("internal").executeExternal;
|
|
var killExternal = require("internal").killExternal;
|
|
var statusExternal = require("internal").statusExternal;
|
|
var executeExternalAndWait = require("internal").executeExternalAndWait;
|
|
var base64Encode = require("internal").base64Encode;
|
|
|
|
var PortFinder = require("org/arangodb/cluster").PortFinder;
|
|
var Planner = require("org/arangodb/cluster").Planner;
|
|
var Kickstarter = require("org/arangodb/cluster").Kickstarter;
|
|
|
|
var endpointToURL = require("org/arangodb/cluster/planner").endpointToURL;
|
|
|
|
var optionsDefaults = { "cluster": false,
|
|
"valgrind": false,
|
|
"force": true,
|
|
"skipBoost": false,
|
|
"skipGeo": false,
|
|
"skipAhuacatl": false,
|
|
"skipTimeCritical": false,
|
|
"skipAql": false,
|
|
"skipRanges": false,
|
|
"username": "root",
|
|
"password": "",
|
|
"test": undefined,
|
|
"cleanup": true,
|
|
"jsonReply": false,
|
|
"portOffset": 0,
|
|
"valgrindargs": [],
|
|
"valgrindXmlFileBase" : "",
|
|
"extraargs": []
|
|
|
|
|
|
};
|
|
var allTests =
|
|
[
|
|
"config",
|
|
"boost",
|
|
"shell_server",
|
|
"shell_server_ahuacatl",
|
|
"shell_server_aql",
|
|
"http_server",
|
|
"ssl_server",
|
|
"shell_client",
|
|
"dump",
|
|
"arangob",
|
|
"importing",
|
|
"upgrade",
|
|
"authentication",
|
|
"authentication_parameters"
|
|
];
|
|
|
|
|
|
function printUsage () {
|
|
print();
|
|
print("Usage: UnitTest( which, options )");
|
|
print();
|
|
print(' where "which" is one of:\n');
|
|
var i;
|
|
var checkAll;
|
|
var oneFunctionDocumentation;
|
|
for (i in testFuncs) {
|
|
if (testFuncs.hasOwnProperty(i)) {
|
|
if (functionsDocumentation.hasOwnProperty(i)) {
|
|
oneFunctionDocumentation = ' - ' + functionsDocumentation[i];
|
|
}
|
|
else {
|
|
oneFunctionDocumentation = '';
|
|
}
|
|
if (allTests.indexOf(i) !== -1) {
|
|
checkAll = '[x]';
|
|
}
|
|
else {
|
|
checkAll = ' ';
|
|
}
|
|
print(' ' + checkAll + ' '+i+' ' + oneFunctionDocumentation);
|
|
}
|
|
}
|
|
for (i in optionsDocumentation) {
|
|
if (optionsDocumentation.hasOwnProperty(i)) {
|
|
print(optionsDocumentation[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
function filterTestcaseByOptions (testname, options, whichFilter) {
|
|
if ((testname.indexOf("-cluster") !== -1) && (options.cluster === false)) {
|
|
whichFilter.filter = 'noncluster';
|
|
return false;
|
|
}
|
|
|
|
if (testname.indexOf("-noncluster") !== -1 && (options.cluster === true)) {
|
|
whichFilter.filter = 'cluster';
|
|
return false;
|
|
}
|
|
|
|
if (testname.indexOf("-timecritical") !== -1 && (options.skipTimeCritical === true)) {
|
|
whichFilter.filter = 'timecritical';
|
|
return false;
|
|
}
|
|
|
|
if (testname.indexOf("-geo") !== -1 && options.skipGeo) {
|
|
whichFilter.filter = 'geo';
|
|
return false;
|
|
}
|
|
|
|
if (testname.indexOf("-disabled") !== -1) {
|
|
whichFilter.filter = 'disabled';
|
|
return false;
|
|
}
|
|
|
|
if (testname.indexOf("replication") !== -1) {
|
|
whichFilter.filter = 'replication';
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function findTopDir () {
|
|
var topDir = fs.normalize(fs.makeAbsolute("."));
|
|
if (! fs.exists("3rdParty") && ! fs.exists("arangod") &&
|
|
! fs.exists("arangosh") && ! fs.exists("UnitTests")) {
|
|
throw "Must be in ArangoDB topdir to execute unit tests.";
|
|
}
|
|
return topDir;
|
|
}
|
|
|
|
function makeTestingArgs () {
|
|
var topDir = findTopDir();
|
|
return [ "--configuration", "none",
|
|
"--server.keyfile", fs.join(topDir, "UnitTests", "server.pem"),
|
|
"--database.maximal-journal-size", "1048576",
|
|
"--database.force-sync-properties", "false",
|
|
"--javascript.app-path", fs.join(topDir, "js", "apps"),
|
|
"--javascript.startup-directory", fs.join(topDir, "js"),
|
|
"--ruby.modules-path", fs.join(topDir,"mr", "common", "modules"),
|
|
"--server.threads", "20",
|
|
"--javascript.v8-contexts", "5",
|
|
"--server.disable-authentication", "true",
|
|
"--server.allow-use-database", "true" ];
|
|
}
|
|
|
|
function makeTestingArgsClient (options) {
|
|
var topDir = findTopDir();
|
|
return [ "--configuration", "none",
|
|
"--javascript.startup-directory", fs.join(topDir, "js"),
|
|
"--no-colors",
|
|
"--quiet",
|
|
"--server.username", options.username,
|
|
"--server.password", options.password ];
|
|
}
|
|
|
|
function makeAuthorisationHeaders (options) {
|
|
return {"headers":
|
|
{"Authorization": "Basic " + base64Encode(options.username+":"+
|
|
options.password)}};
|
|
}
|
|
|
|
function startInstance (protocol, options, addArgs, testname) {
|
|
// protocol must be one of ["tcp", "ssl", "unix"]
|
|
var topDir = findTopDir();
|
|
var instanceInfo = {};
|
|
instanceInfo.topDir = topDir;
|
|
var tmpDataDir = fs.getTempFile();
|
|
|
|
instanceInfo.flatTmpDataDir = tmpDataDir;
|
|
|
|
tmpDataDir = fs.join(tmpDataDir, testname);
|
|
fs.makeDirectoryRecursive(tmpDataDir);
|
|
instanceInfo.tmpDataDir = tmpDataDir;
|
|
|
|
var endpoint;
|
|
var pos;
|
|
var valgrindopts = [];
|
|
var dispatcher;
|
|
if (options.cluster) {
|
|
var extraargs = makeTestingArgs();
|
|
extraargs = extraargs.concat(options.extraargs);
|
|
if (addArgs !== undefined) {
|
|
extraargs = extraargs.concat(addArgs);
|
|
}
|
|
dispatcher = {"endpoint":"tcp://localhost:",
|
|
"arangodExtraArgs": extraargs,
|
|
"username": "root",
|
|
"password": ""};
|
|
print("Temporary cluster data and logs are in",tmpDataDir);
|
|
|
|
var runInValgrind = "";
|
|
var valgrindXmlFileBase = "";
|
|
if (typeof(options.valgrind) === 'string') {
|
|
runInValgrind = options.valgrind;
|
|
valgrindopts = options.valgrindargs;
|
|
valgrindXmlFileBase = options.valgrindXmlFileBase;
|
|
}
|
|
|
|
var p = new Planner({"numberOfDBservers" : 2,
|
|
"numberOfCoordinators" : 1,
|
|
"dispatchers" : {"me": dispatcher},
|
|
"dataPath" : tmpDataDir,
|
|
"logPath" : tmpDataDir,
|
|
"useSSLonCoordinators" : protocol === "ssl",
|
|
"valgrind" : runInValgrind,
|
|
"valgrindopts" : valgrindopts,
|
|
"valgrindXmlFileBase" : valgrindXmlFileBase,
|
|
"valgrindTestname" : testname
|
|
});
|
|
instanceInfo.kickstarter = new Kickstarter(p.getPlan());
|
|
instanceInfo.kickstarter.launch();
|
|
var runInfo = instanceInfo.kickstarter.runInfo;
|
|
var j = runInfo.length-1;
|
|
while (j > 0 && runInfo[j].isStartServers === undefined) {
|
|
j--;
|
|
}
|
|
var roles = runInfo[j].roles;
|
|
var endpoints = runInfo[j].endpoints;
|
|
pos = roles.indexOf("Coordinator");
|
|
endpoint = endpoints[pos];
|
|
}
|
|
else { // single instance mode
|
|
// We use the PortFinder to find a free port for our subinstance,
|
|
// to this end, we have to fake a dummy dispatcher:
|
|
dispatcher = {endpoint: "tcp://localhost:", avoidPorts: {}, id: "me"};
|
|
var pf = new PortFinder([8529 + options.portOffset],dispatcher);
|
|
var port = pf.next();
|
|
instanceInfo.port = port;
|
|
var args = makeTestingArgs();
|
|
args.push("--server.endpoint");
|
|
endpoint = protocol+"://127.0.0.1:"+port;
|
|
args.push(endpoint);
|
|
args.push("--database.directory");
|
|
args.push(fs.join(tmpDataDir,"data"));
|
|
fs.makeDirectoryRecursive(fs.join(tmpDataDir,"data"));
|
|
args.push("--log.file");
|
|
args.push(fs.join(tmpDataDir,"log"));
|
|
if (protocol === "ssl") {
|
|
args.push("--server.keyfile");
|
|
args.push(fs.join("UnitTests","server.pem"));
|
|
}
|
|
args = args.concat(options.extraargs);
|
|
if (addArgs !== undefined) {
|
|
args = args.concat(addArgs);
|
|
}
|
|
if (typeof(options.valgrind) === 'string') {
|
|
var run = fs.join("bin","arangod");
|
|
valgrindopts = options.valgrindargs.concat(
|
|
["--xml-file="+options.valgrindXmlFileBase + '_' + testname + '.%p.xml',
|
|
"--log-file="+options.valgrindXmlFileBase + '_' + testname + '.%p.valgrind.log']);
|
|
var newargs=valgrindopts.concat([run]).concat(args);
|
|
var cmdline = options.valgrind;
|
|
instanceInfo.pid = executeExternal(cmdline, newargs);
|
|
}
|
|
else {
|
|
instanceInfo.pid = executeExternal(fs.join("bin","arangod"), args);
|
|
}
|
|
}
|
|
|
|
// Wait until the server/coordinator is up:
|
|
var url = endpointToURL(endpoint);
|
|
while (true) {
|
|
wait(0.5);
|
|
var r = download(url+"/_api/version","",makeAuthorisationHeaders(options));
|
|
if (!r.error && r.code === 200) {
|
|
break;
|
|
}
|
|
}
|
|
instanceInfo.endpoint = endpoint;
|
|
instanceInfo.url = url;
|
|
|
|
return instanceInfo;
|
|
}
|
|
|
|
|
|
function copy (src, dst) {
|
|
var fs = require("fs");
|
|
var buffer = fs.readBuffer(src);
|
|
|
|
fs.write(dst, buffer);
|
|
}
|
|
|
|
function checkInstanceAlive(instanceInfo, options) {
|
|
var storeArangodPath;
|
|
if (options.cluster === false) {
|
|
var res = statusExternal(instanceInfo.pid, false);
|
|
var ret = res.status === "RUNNING";
|
|
if (! ret) {
|
|
print("ArangoD with PID " + instanceInfo.pid.pid + " gone:");
|
|
instanceInfo.exitStatus = res;
|
|
print(instanceInfo);
|
|
if (res.hasOwnProperty('signal') &&
|
|
(res.signal === 11))
|
|
{
|
|
storeArangodPath = "/var/tmp/arangod_" + instanceInfo.pid.pid;
|
|
print("Core dump written; copying arangod to " +
|
|
storeArangodPath + " for later analysis.");
|
|
res.gdbHint = "Run debugger with 'gdb " +
|
|
storeArangodPath +
|
|
" /var/tmp/core*" + instanceInfo.pid.pid + "*'";
|
|
copy("bin/arangod", storeArangodPath);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
var ClusterFit = true;
|
|
for (var part in instanceInfo.kickstarter.runInfo) {
|
|
if (instanceInfo.kickstarter.runInfo[part].hasOwnProperty("pids")) {
|
|
for (var pid in instanceInfo.kickstarter.runInfo[part].pids) {
|
|
if (instanceInfo.kickstarter.runInfo[part].pids.hasOwnProperty(pid)) {
|
|
var checkpid = instanceInfo.kickstarter.runInfo[part].pids[pid];
|
|
var ress = statusExternal(checkpid, false);
|
|
if (ress.hasOwnProperty('signal') &&
|
|
(ress.signal === 11)) {
|
|
storeArangodPath = "/var/tmp/arangod_" + checkpid.pid;
|
|
print("Core dump written; copying arangod to " +
|
|
storeArangodPath + " for later analysis.");
|
|
instanceInfo.exitStatus = ress;
|
|
ress.gdbHint = "Run debugger with 'gdb " +
|
|
storeArangodPath +
|
|
" /var/tmp/core*" + checkpid.pid + "*'";
|
|
copy("bin/arangod", storeArangodPath);
|
|
ClusterFit = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ClusterFit && instanceInfo.kickstarter.isHealthy();
|
|
}
|
|
|
|
function shutdownInstance (instanceInfo, options) {
|
|
if (options.cluster) {
|
|
instanceInfo.kickstarter.shutdown();
|
|
if (options.cleanup) {
|
|
instanceInfo.kickstarter.cleanup();
|
|
}
|
|
}
|
|
else {
|
|
if (typeof(instanceInfo.exitStatus) === 'undefined') {
|
|
download(instanceInfo.url+"/_admin/shutdown","",
|
|
makeAuthorisationHeaders(options));
|
|
|
|
if (typeof(options.valgrind) === 'string') {
|
|
print("Waiting for server shut down");
|
|
var res = statusExternal(instanceInfo.pid, true);
|
|
print("Server gone: ");
|
|
print(res);
|
|
}
|
|
else {
|
|
wait(10);
|
|
killExternal(instanceInfo.pid);
|
|
}
|
|
}
|
|
else {
|
|
print("Server already dead, doing nothing.");
|
|
}
|
|
|
|
}
|
|
cleanupDirectories = cleanupDirectories.concat([instanceInfo.tmpDataDir, instanceInfo.flatTmpDataDir]);
|
|
}
|
|
|
|
function cleanupDBDirectories(options) {
|
|
if (options.cleanup) {
|
|
for (var i in cleanupDirectories) {
|
|
if (cleanupDirectories.hasOwnProperty(i)) {
|
|
fs.removeDirectoryRecursive(cleanupDirectories[i], true);
|
|
// print("deleted " + cleanupDirectories[i]);
|
|
}
|
|
}
|
|
cleanupDirectories = [];
|
|
}
|
|
}
|
|
|
|
function makePath (path) {
|
|
return fs.join.apply(null,path.split("/"));
|
|
}
|
|
|
|
var foundTests = false;
|
|
|
|
var tests_shell_common;
|
|
var tests_shell_server_only;
|
|
var tests_shell_client_only;
|
|
var tests_shell_server;
|
|
var tests_shell_client;
|
|
var tests_shell_server_ahuacatl;
|
|
var tests_shell_server_ahuacatl_extended;
|
|
var tests_shell_server_aql;
|
|
var tests_shell_server_aql_extended;
|
|
var tests_shell_server_aql_performance;
|
|
|
|
function findTests () {
|
|
if (foundTests) {
|
|
return;
|
|
}
|
|
tests_shell_common = _.filter(fs.list(makePath("js/common/tests")),
|
|
function (p) {
|
|
return p.substr(0,6) === "shell-" &&
|
|
p.substr(-3) === ".js";
|
|
}).map(
|
|
function(x) {
|
|
return fs.join(makePath("js/common/tests"),x);
|
|
}).sort();
|
|
tests_shell_server_only = _.filter(fs.list(makePath("js/server/tests")),
|
|
function (p) {
|
|
return p.substr(0,6) === "shell-" &&
|
|
p.substr(-3) === ".js";
|
|
}).map(
|
|
function(x) {
|
|
return fs.join(makePath("js/server/tests"),x);
|
|
}).sort();
|
|
tests_shell_client_only = _.filter(fs.list(makePath("js/client/tests")),
|
|
function (p) {
|
|
return p.substr(0,6) === "shell-" &&
|
|
p.substr(-3) === ".js";
|
|
}).map(
|
|
function(x) {
|
|
return fs.join(makePath("js/client/tests"),x);
|
|
}).sort();
|
|
tests_shell_server_ahuacatl = _.filter(fs.list(makePath("js/server/tests")),
|
|
function (p) {
|
|
return p.substr(0,9) === "ahuacatl-" &&
|
|
p.substr(-3) === ".js" &&
|
|
p.indexOf("ranges-combined") === -1;
|
|
}).map(
|
|
function(x) {
|
|
return fs.join(makePath("js/server/tests"),x);
|
|
}).sort();
|
|
tests_shell_server_ahuacatl_extended =
|
|
_.filter(fs.list(makePath("js/server/tests")),
|
|
function (p) {
|
|
return p.substr(0,9) === "ahuacatl-" &&
|
|
p.substr(-3) === ".js" &&
|
|
p.indexOf("ranges-combined") !== -1;
|
|
}).map(
|
|
function(x) {
|
|
return fs.join(makePath("js/server/tests"),x);
|
|
}).sort();
|
|
tests_shell_server_aql = _.filter(fs.list(makePath("js/server/tests")),
|
|
function (p) {
|
|
return p.substr(0,4) === "aql-" &&
|
|
p.substr(-3) === ".js" &&
|
|
p.indexOf("ranges-combined") === -1;
|
|
}).map(
|
|
function(x) {
|
|
return fs.join(makePath("js/server/tests"),x);
|
|
}).sort();
|
|
tests_shell_server_aql_extended =
|
|
_.filter(fs.list(makePath("js/server/tests")),
|
|
function (p) {
|
|
return p.substr(0,4) === "aql-" &&
|
|
p.substr(-3) === ".js" &&
|
|
p.indexOf("ranges-combined") !== -1;
|
|
}).map(
|
|
function(x) {
|
|
return fs.join(makePath("js/server/tests"),x);
|
|
}).sort();
|
|
tests_shell_server_aql_performance =
|
|
_.filter(fs.list(makePath("js/server/perftests")),
|
|
function (p) {
|
|
return p.substr(-3) === ".js";
|
|
}).map(
|
|
function(x) {
|
|
return fs.join(makePath("js/server/perftests"),x);
|
|
}).sort();
|
|
|
|
tests_shell_server = tests_shell_common.concat(tests_shell_server_only);
|
|
tests_shell_client = tests_shell_common.concat(tests_shell_client_only);
|
|
foundTests = true;
|
|
}
|
|
|
|
function runThere (options, instanceInfo, file) {
|
|
var r;
|
|
try {
|
|
var t;
|
|
if (file.indexOf("-spec") === -1) {
|
|
t = 'var runTest = require("jsunity").runTest; '+
|
|
'return runTest(' + JSON.stringify(file) + ');';
|
|
}
|
|
else {
|
|
var jasmineReportFormat = options.jasmineReportFormat || 'progress';
|
|
t = 'var executeTestSuite = require("jasmine").executeTestSuite; '+
|
|
'return executeTestSuite([' + JSON.stringify(file) + '],{"format": '+
|
|
JSON.stringify(jasmineReportFormat) + '});';
|
|
}
|
|
var o = makeAuthorisationHeaders(options);
|
|
o.method = "POST";
|
|
o.timeout = 24*3600;
|
|
o.returnBodyOnError = true;
|
|
r = download(instanceInfo.url+"/_admin/execute?returnAsJSON=true",t,o);
|
|
if (!r.error && r.code === 200) {
|
|
r = JSON.parse(r.body);
|
|
}
|
|
if (file.indexOf("-spec") !== -1) {
|
|
// remoting a jasmine suite...
|
|
r = {status: r, message: ''};
|
|
}
|
|
}
|
|
catch (err) {
|
|
r = err;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
function executeAndWait (cmd, args) {
|
|
var startTime = time();
|
|
var res = executeExternalAndWait(cmd, args);
|
|
var deltaTime = time() - startTime;
|
|
var errorMessage = ' - ';
|
|
|
|
if (res.status === "TERMINATED") {
|
|
print("Finished: " + res.status + " exit code: " + res.exit + " Time elapsed: " + deltaTime);
|
|
if (res.exit === 0) {
|
|
return { status: true, message: "", duration: deltaTime};
|
|
}
|
|
else {
|
|
return { status: false, message: "exit code was " + res.exit, duration: deltaTime};
|
|
}
|
|
}
|
|
else if (res.status === "ABORTED") {
|
|
if (typeof(res.errorMessage) !== 'undefined') {
|
|
errorMessage += res.errorMessage;
|
|
}
|
|
print("Finished: " + res.status + " Signal: " + res.signal + " Time elapsed: " + deltaTime + errorMessage);
|
|
return {
|
|
status: false,
|
|
message: "irregular termination: " + res.status + " exit signal: " + res.signal + errorMessage,
|
|
duration: deltaTime
|
|
};
|
|
}
|
|
else {
|
|
if (typeof(res.errorMessage) !== 'undefined') {
|
|
errorMessage += res.errorMessage;
|
|
}
|
|
print("Finished: " + res.status + " exit code: " + res.signal + " Time elapsed: " + deltaTime + errorMessage);
|
|
return {
|
|
status: false,
|
|
message: "irregular termination: " + res.status + " exit code: " + res.exit + errorMessage,
|
|
duration: deltaTime
|
|
};
|
|
}
|
|
}
|
|
|
|
function runInArangosh (options, instanceInfo, file, addArgs) {
|
|
var args = makeTestingArgsClient(options);
|
|
var topDir = findTopDir();
|
|
args.push("--server.endpoint");
|
|
args.push(instanceInfo.endpoint);
|
|
args.push("--javascript.unit-tests");
|
|
args.push(fs.join(topDir,file));
|
|
if (addArgs !== undefined) {
|
|
args = args.concat(addArgs);
|
|
}
|
|
var arangosh = fs.join("bin","arangosh");
|
|
return executeAndWait(arangosh, args);
|
|
}
|
|
|
|
function runArangoshCmd (options, instanceInfo, cmds) {
|
|
var args = makeTestingArgsClient(options);
|
|
args.push("--server.endpoint");
|
|
args.push(instanceInfo.endpoint);
|
|
args = args.concat(cmds);
|
|
var arangosh = fs.join("bin","arangosh");
|
|
return executeAndWait(arangosh, args);
|
|
}
|
|
|
|
function performTests(options, testList, testname) {
|
|
var instanceInfo = startInstance("tcp", options, [], testname);
|
|
var results = {};
|
|
var i;
|
|
var te;
|
|
var continueTesting = true;
|
|
var filtered = {};
|
|
|
|
for (i = 0; i < testList.length; i++) {
|
|
te = testList[i];
|
|
if (filterTestcaseByOptions(te, options, filtered)) {
|
|
if (!continueTesting) {
|
|
print("Skipping, " + te + " server is gone.");
|
|
results[te] = {status: false, message: instanceInfo.exitStatus};
|
|
instanceInfo.exitStatus = "server is gone.";
|
|
continue;
|
|
}
|
|
|
|
print("\nTrying",te,"...");
|
|
var r = runThere(options, instanceInfo, te);
|
|
if (r.hasOwnProperty('status')) {
|
|
results[te] = r;
|
|
}
|
|
else {
|
|
results[te] = {status: false, message: r};
|
|
}
|
|
if (r !== true && !options.force) {
|
|
break;
|
|
}
|
|
continueTesting = checkInstanceAlive(instanceInfo, options);
|
|
}
|
|
else {
|
|
print("Skipped " + te + " because of " + filtered.filter);
|
|
}
|
|
}
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo,options);
|
|
print("done.");
|
|
return results;
|
|
}
|
|
|
|
function single_usage (testsuite, list) {
|
|
print("single_" + testsuite + ": No test specified!\n Available tests:");
|
|
var filelist = "";
|
|
|
|
for (var fileNo in list) {
|
|
if (/\.js$/.test(list[fileNo])) {
|
|
filelist += " " + list[fileNo];
|
|
}
|
|
}
|
|
print(filelist);
|
|
print("usage: single_" + testsuite + " '{\"test\":\"<testfilename>\"}'");
|
|
print(" where <testfilename> is one from the list above.");
|
|
return { status: false, message: "No test specified!"};
|
|
}
|
|
|
|
|
|
testFuncs.single_server = function (options) {
|
|
var result = { };
|
|
if (options.test !== undefined) {
|
|
var instanceInfo = startInstance("tcp", options, [], "single_server");
|
|
var te = options.test;
|
|
print("\nTrying",te,"on server...");
|
|
result = {};
|
|
result[te] = runThere(options, instanceInfo, makePath(te));
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo,options);
|
|
print("done.");
|
|
return result;
|
|
}
|
|
else {
|
|
findTests();
|
|
return single_usage("server", tests_shell_server);
|
|
}
|
|
};
|
|
|
|
testFuncs.single_client = function (options) {
|
|
var result = { };
|
|
if (options.test !== undefined) {
|
|
var instanceInfo = startInstance("tcp", options, [], "single_client");
|
|
var te = options.test;
|
|
print("\nTrying ",te," on client...");
|
|
result[te] = runInArangosh(options, instanceInfo, te);
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo,options);
|
|
print("done.");
|
|
return result;
|
|
}
|
|
else {
|
|
findTests();
|
|
return single_usage("client", tests_shell_client);
|
|
}
|
|
};
|
|
|
|
testFuncs.shell_server_perf = function(options) {
|
|
findTests();
|
|
return performTests(options,
|
|
tests_shell_server_aql_performance,
|
|
'shell_server_perf');
|
|
};
|
|
|
|
testFuncs.shell_server = function (options) {
|
|
findTests();
|
|
return performTests(options, tests_shell_server, 'shell_server');
|
|
};
|
|
|
|
testFuncs.shell_server_only = function (options) {
|
|
findTests();
|
|
return performTests(options,
|
|
tests_shell_server_only,
|
|
'shell_server_only');
|
|
};
|
|
|
|
testFuncs.shell_server_ahuacatl = function(options) {
|
|
findTests();
|
|
if (! options.skipAhuacatl) {
|
|
if (options.skipRanges) {
|
|
return performTests(options,
|
|
tests_shell_server_ahuacatl,
|
|
'shell_server_ahuacatl_skipranges');
|
|
}
|
|
else {
|
|
return performTests(options,
|
|
tests_shell_server_ahuacatl.concat(
|
|
tests_shell_server_ahuacatl_extended),
|
|
'shell_server_ahuacatl');
|
|
}
|
|
}
|
|
return "skipped";
|
|
};
|
|
|
|
testFuncs.shell_server_aql = function(options) {
|
|
findTests();
|
|
if (! options.skipAql) {
|
|
if (options.skipRanges) {
|
|
return performTests(options,
|
|
tests_shell_server_aql,
|
|
'shell_server_aql_skipranges');
|
|
}
|
|
else {
|
|
return performTests(options,
|
|
tests_shell_server_aql.concat(
|
|
tests_shell_server_aql_extended),
|
|
'shell_server_aql');
|
|
}
|
|
}
|
|
return "skipped";
|
|
};
|
|
|
|
testFuncs.shell_client = function(options) {
|
|
findTests();
|
|
var instanceInfo = startInstance("tcp", options, [], "shell_client");
|
|
var results = {};
|
|
var i;
|
|
var te;
|
|
var continueTesting = true;
|
|
var filtered = {};
|
|
|
|
for (i = 0; i < tests_shell_client.length; i++) {
|
|
te = tests_shell_client[i];
|
|
if (filterTestcaseByOptions(te, options, filtered)) {
|
|
|
|
if (!continueTesting) {
|
|
print("Skipping, " + te + " server is gone.");
|
|
results[te] = {status: false, message: instanceInfo.exitStatus};
|
|
instanceInfo.exitStatus = "server is gone.";
|
|
continue;
|
|
}
|
|
|
|
print("\nTrying",te,"...");
|
|
|
|
var r = runInArangosh(options, instanceInfo, te);
|
|
results[te] = r;
|
|
if (r !== 0 && !options.force) {
|
|
break;
|
|
}
|
|
|
|
continueTesting = checkInstanceAlive(instanceInfo, options);
|
|
}
|
|
else {
|
|
print("Skipped " + te + " because of " + filtered.filter);
|
|
}
|
|
}
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo, options);
|
|
print("done.");
|
|
return results;
|
|
};
|
|
|
|
testFuncs.config = function () {
|
|
var topDir = findTopDir();
|
|
var results = {};
|
|
var ts = ["arangod", "arangob", "arangodump", "arangoimp", "arangorestore",
|
|
"arangosh"];
|
|
var t;
|
|
var i;
|
|
for (i = 0; i < ts.length; i++) {
|
|
t = ts[i];
|
|
results[t] = executeAndWait(fs.join(topDir,"bin",t),
|
|
["--configuration", fs.join(topDir,"etc","arangodb",t+".conf"),
|
|
"--help"]);
|
|
print("Config test "+t+"...",results[t].status);
|
|
}
|
|
for (i = 0; i < ts.length; i++) {
|
|
t = ts[i];
|
|
results[t+"_rel"] = executeAndWait(fs.join(topDir,"bin",t),
|
|
["--configuration", fs.join(topDir,"etc","relative",
|
|
t+".conf"), "--help"]);
|
|
print("Config test "+t+" (relative)...",results[t+"_rel"].status);
|
|
}
|
|
|
|
return results;
|
|
};
|
|
|
|
testFuncs.boost = function (options) {
|
|
var topDir = findTopDir();
|
|
var results = {};
|
|
if (!options.skipBoost) {
|
|
results.basics = executeAndWait(fs.join(topDir,"UnitTests","basics_suite"),
|
|
["--show_progress"]);
|
|
}
|
|
if (!options.skipGeo) {
|
|
results.geo_suite = executeAndWait(
|
|
fs.join(topDir,"UnitTests","geo_suite"),
|
|
["--show_progress"]);
|
|
}
|
|
return results;
|
|
};
|
|
|
|
function rubyTests (options, ssl) {
|
|
var instanceInfo;
|
|
if (ssl) {
|
|
instanceInfo = startInstance("ssl", options, [], "ssl_server");
|
|
}
|
|
else {
|
|
instanceInfo = startInstance("tcp", options, [], "http_server");
|
|
}
|
|
|
|
var tmpname = fs.getTempFile()+".rb";
|
|
fs.write(tmpname,'RSpec.configure do |c|\n'+
|
|
' c.add_setting :ARANGO_SERVER\n'+
|
|
' c.ARANGO_SERVER = "' +
|
|
instanceInfo.endpoint.substr(6) + '"\n'+
|
|
' c.add_setting :ARANGO_SSL\n'+
|
|
' c.ARANGO_SSL = "' + (ssl ? '1' : '0') + '"\n'+
|
|
' c.add_setting :ARANGO_USER\n'+
|
|
' c.ARANGO_USER = "' + options.username + '"\n'+
|
|
' c.add_setting :ARANGO_PASSWORD\n'+
|
|
' c.ARANGO_PASSWORD = "' + options.password + '"\n'+
|
|
'end\n');
|
|
var logsdir = fs.join(findTopDir(),"logs");
|
|
try {
|
|
fs.makeDirectory(logsdir);
|
|
}
|
|
catch (err) {
|
|
}
|
|
var files = fs.list(fs.join("UnitTests","HttpInterface"));
|
|
var filtered = {};
|
|
var result = {};
|
|
var args;
|
|
var i;
|
|
var continueTesting = true;
|
|
|
|
for (i = 0; i < files.length; i++) {
|
|
var te = files[i];
|
|
if (te.substr(0,4) === "api-" && te.substr(-3) === ".rb") {
|
|
if (filterTestcaseByOptions(te, options, filtered)) {
|
|
|
|
args = ["--color", "-I", fs.join("UnitTests","HttpInterface"),
|
|
"--format", "d", "--require", tmpname,
|
|
fs.join("UnitTests","HttpInterface", te)];
|
|
|
|
if (!continueTesting) {
|
|
print("Skipping " + te + " server is gone.");
|
|
result[te] = {status: false, message: instanceInfo.exitStatus};
|
|
instanceInfo.exitStatus = "server is gone.";
|
|
continue;
|
|
}
|
|
print("\nTrying ",te,"...");
|
|
|
|
result[te] = executeAndWait("rspec", args);
|
|
if (result[te].status === false && !options.force) {
|
|
break;
|
|
}
|
|
|
|
continueTesting = checkInstanceAlive(instanceInfo, options);
|
|
|
|
}
|
|
else {
|
|
print("Skipped " + te + " because of " + filtered.filter);
|
|
}
|
|
}
|
|
}
|
|
|
|
print("Shutting down...");
|
|
fs.remove(tmpname);
|
|
shutdownInstance(instanceInfo,options);
|
|
print("done.");
|
|
return result;
|
|
}
|
|
|
|
testFuncs.http_server = function (options) {
|
|
return rubyTests(options, false);
|
|
};
|
|
|
|
testFuncs.ssl_server = function (options) {
|
|
return rubyTests(options, true);
|
|
};
|
|
|
|
function runArangoImp (options, instanceInfo, what) {
|
|
var topDir = findTopDir();
|
|
var args = ["--server.username", options.username,
|
|
"--server.password", options.password,
|
|
"--server.endpoint", instanceInfo.endpoint,
|
|
"--file", fs.join(topDir,what.data),
|
|
"--collection", what.coll,
|
|
"--type", what.type];
|
|
if (what.create !== undefined) {
|
|
args.push("--create-collection");
|
|
args.push(what.create);
|
|
}
|
|
if (what.backslash !== undefined) {
|
|
args.push("--backslash-escape");
|
|
args.push(what.backslash);
|
|
}
|
|
if (what.separator !== undefined) {
|
|
args.push("--separator");
|
|
args.push(what.separator);
|
|
}
|
|
var arangoimp = fs.join("bin","arangoimp");
|
|
return executeAndWait(arangoimp, args);
|
|
}
|
|
|
|
function runArangoDumpRestore (options, instanceInfo, which, database) {
|
|
var args = ["--configuration", "none",
|
|
"--server.username", options.username,
|
|
"--server.password", options.password,
|
|
"--server.endpoint", instanceInfo.endpoint,
|
|
"--server.database", database];
|
|
var exe;
|
|
if (which === "dump") {
|
|
args.push("--output-directory");
|
|
args.push(fs.join(instanceInfo.tmpDataDir,"dump"));
|
|
exe = fs.join("bin","arangodump");
|
|
}
|
|
else {
|
|
args.push("--input-directory");
|
|
args.push(fs.join(instanceInfo.tmpDataDir,"dump"));
|
|
exe = fs.join("bin","arangorestore");
|
|
}
|
|
return executeAndWait(exe, args);
|
|
}
|
|
|
|
function runArangoBenchmark (options, instanceInfo, cmds) {
|
|
var args = ["--configuration", "none",
|
|
"--quiet",
|
|
"--server.username", options.username,
|
|
"--server.password", options.password,
|
|
"--server.endpoint", instanceInfo.endpoint];
|
|
args = args.concat(cmds);
|
|
var exe = fs.join("bin","arangob");
|
|
return executeAndWait(exe, args);
|
|
}
|
|
|
|
var impTodo = [
|
|
{id: "json1", data: makePath("UnitTests/import-1.json"),
|
|
coll: "UnitTestsImportJson1", type: "json", create: undefined},
|
|
{id: "json2", data: makePath("UnitTests/import-2.json"),
|
|
coll: "UnitTestsImportJson2", type: "json", create: undefined},
|
|
{id: "json3", data: makePath("UnitTests/import-3.json"),
|
|
coll: "UnitTestsImportJson3", type: "json", create: undefined},
|
|
{id: "json4", data: makePath("UnitTests/import-4.json"),
|
|
coll: "UnitTestsImportJson4", type: "json", create: undefined},
|
|
{id: "csv1", data: makePath("UnitTests/import-1.csv"),
|
|
coll: "UnitTestsImportCsv1", type: "csv", create: "true"},
|
|
{id: "csv2", data: makePath("UnitTests/import-2.csv"),
|
|
coll: "UnitTestsImportCsv2", type: "csv", create: "true"},
|
|
{id: "csv3", data: makePath("UnitTests/import-3.csv"),
|
|
coll: "UnitTestsImportCsv3", type: "csv", create: "true"},
|
|
{id: "csv4", data: makePath("UnitTests/import-4.csv"),
|
|
coll: "UnitTestsImportCsv4", type: "csv", create: "true", separator: ";", backslash: true},
|
|
{id: "tsv1", data: makePath("UnitTests/import-1.tsv"),
|
|
coll: "UnitTestsImportTsv1", type: "tsv", create: "true"},
|
|
{id: "tsv2", data: makePath("UnitTests/import-2.tsv"),
|
|
coll: "UnitTestsImportTsv2", type: "tsv", create: "true"},
|
|
{id: "edge", data: makePath("UnitTests/import-edges.json"),
|
|
coll: "UnitTestsImportEdge", type: "json", create: "false"}
|
|
];
|
|
|
|
testFuncs.importing = function (options) {
|
|
if (options.cluster) {
|
|
print("Skipped because of cluster.");
|
|
return {"ok":true, "skipped":0};
|
|
}
|
|
|
|
var instanceInfo = startInstance("tcp", options, [ ], "importing");
|
|
|
|
var result = {};
|
|
try {
|
|
var r = runInArangosh(options, instanceInfo,
|
|
makePath("js/server/tests/import-setup.js"));
|
|
result.setup = r;
|
|
if (r !== 0) {
|
|
throw "banana";
|
|
}
|
|
var i;
|
|
for (i = 0; i < impTodo.length; i++) {
|
|
r = runArangoImp(options, instanceInfo, impTodo[i]);
|
|
result[impTodo[i].id] = r;
|
|
if (r !== 0 && !options.force) {
|
|
throw "banana";
|
|
}
|
|
}
|
|
r = runInArangosh(options, instanceInfo,
|
|
makePath("js/server/tests/import.js"));
|
|
result.check = r;
|
|
r = runInArangosh(options, instanceInfo,
|
|
makePath("js/server/tests/import-teardown.js"));
|
|
result.teardown = r;
|
|
}
|
|
catch (banana) {
|
|
print("A banana of the following form was caught:",JSON.stringify(banana));
|
|
}
|
|
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo,options);
|
|
print("done.");
|
|
return result;
|
|
};
|
|
|
|
testFuncs.upgrade = function (options) {
|
|
if (options.cluster) {
|
|
return true;
|
|
}
|
|
|
|
var result = {};
|
|
|
|
var tmpDataDir = fs.getTempFile();
|
|
fs.makeDirectoryRecursive(tmpDataDir);
|
|
|
|
// We use the PortFinder to find a free port for our subinstance,
|
|
// to this end, we have to fake a dummy dispatcher:
|
|
var dispatcher = {endpoint: "tcp://localhost:", avoidPorts: [], id: "me"};
|
|
var pf = new PortFinder([8529],dispatcher);
|
|
var port = pf.next();
|
|
var args = makeTestingArgs();
|
|
args.push("--server.endpoint");
|
|
var endpoint = "tcp://127.0.0.1:"+port;
|
|
args.push(endpoint);
|
|
args.push("--database.directory");
|
|
args.push(fs.join(tmpDataDir,"data"));
|
|
fs.makeDirectoryRecursive(fs.join(tmpDataDir,"data"));
|
|
args.push("--upgrade");
|
|
result.first = executeAndWait(fs.join("bin","arangod"), args);
|
|
|
|
if (result.first !== 0 && !options.force) {
|
|
return result;
|
|
}
|
|
result.second = executeAndWait(fs.join("bin","arangod"), args);
|
|
|
|
fs.removeDirectoryRecursive(tmpDataDir);
|
|
|
|
return result;
|
|
};
|
|
|
|
testFuncs.foxx_manager = function (options) {
|
|
print("foxx_manager tests...");
|
|
var instanceInfo = startInstance("tcp", options, [], "foxx_manager");
|
|
var results = {};
|
|
|
|
results.update = runArangoshCmd(options, instanceInfo,
|
|
["--configuration",
|
|
"etc/relative/foxx-manager.conf",
|
|
"update"]);
|
|
if (results.update === 0 || options.force) {
|
|
results.search = runArangoshCmd(options, instanceInfo,
|
|
["--configuration",
|
|
"etc/relative/foxx-manager.conf",
|
|
"search","itzpapalotl"]);
|
|
}
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo,options);
|
|
print("done.");
|
|
return results;
|
|
};
|
|
|
|
testFuncs.dump = function (options) {
|
|
var cluster;
|
|
|
|
if (options.cluster) {
|
|
cluster = "-cluster";
|
|
}
|
|
else {
|
|
cluster = "";
|
|
}
|
|
print("dump tests...");
|
|
var instanceInfo = startInstance("tcp",options, [], "dump");
|
|
var results = {};
|
|
results.setup = runInArangosh(options, instanceInfo,
|
|
makePath("js/server/tests/dump-setup"+cluster+".js"));
|
|
if (results.setup === 0) {
|
|
results.dump = runArangoDumpRestore(options, instanceInfo, "dump",
|
|
"UnitTestsDumpSrc");
|
|
results.restore = runArangoDumpRestore(options, instanceInfo, "restore",
|
|
"UnitTestsDumpDst");
|
|
results.test = runInArangosh(options, instanceInfo,
|
|
makePath("js/server/tests/dump"+cluster+".js"),
|
|
[ "--server.database", "UnitTestsDumpDst" ]);
|
|
results.tearDown = runInArangosh(options, instanceInfo,
|
|
makePath("js/server/tests/dump-teardown"+cluster+".js"));
|
|
}
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo,options);
|
|
print("done.");
|
|
return results;
|
|
};
|
|
|
|
var benchTodo = [
|
|
["--requests","10000","--concurrency","2","--test","version", "--keep-alive","false"],
|
|
["--requests","10000","--concurrency","2","--test","version", "--async","true"],
|
|
["--requests","20000","--concurrency","1","--test","version", "--async","true"],
|
|
["--requests","100000","--concurrency","2","--test","shapes", "--batch-size","16", "--complexity","2"],
|
|
["--requests","100000","--concurrency","2","--test","shapes-append", "--batch-size","16", "--complexity","4"],
|
|
["--requests","100000","--concurrency","2","--test","random-shapes", "--batch-size","16", "--complexity","2"],
|
|
["--requests","1000","--concurrency","2","--test","version", "--batch-size", "16"],
|
|
["--requests","100","--concurrency","1","--test","version", "--batch-size", "0"],
|
|
["--requests","100","--concurrency","2","--test","document", "--batch-size",
|
|
"10", "--complexity", "1"],
|
|
["--requests","2000","--concurrency","2","--test","crud", "--complexity", "1"],
|
|
["--requests","4000","--concurrency","2","--test","crud-append", "--complexity", "4"],
|
|
["--requests","4000","--concurrency","2","--test","edge", "--complexity", "4"],
|
|
["--requests","5000","--concurrency","2","--test","hash","--complexity","1"],
|
|
["--requests","5000","--concurrency","2","--test","skiplist","--complexity","1"],
|
|
["--requests","500","--concurrency","3","--test","aqltrx","--complexity","1"],
|
|
["--requests","100","--concurrency","3","--test","counttrx"],
|
|
["--requests","500","--concurrency","3","--test","multitrx"]
|
|
];
|
|
|
|
testFuncs.arangob = function (options) {
|
|
print("arangob tests...");
|
|
var instanceInfo = startInstance("tcp",options, [], "arangob");
|
|
var results = {};
|
|
var i,r;
|
|
var continueTesting = true;
|
|
|
|
for (i = 0; i < benchTodo.length; i++) {
|
|
// On the cluster we do not yet have working transaction functionality:
|
|
if (!options.cluster ||
|
|
(benchTodo[i].indexOf("counttrx") === -1 &&
|
|
benchTodo[i].indexOf("multitrx") === -1)) {
|
|
|
|
if (!continueTesting) {
|
|
print("Skipping " + benchTodo[i] + ", server is gone.");
|
|
results[i] = {status: false, message: instanceInfo.exitStatus};
|
|
instanceInfo.exitStatus = "server is gone.";
|
|
continue;
|
|
}
|
|
|
|
r = runArangoBenchmark(options, instanceInfo, benchTodo[i]);
|
|
results[i] = r;
|
|
|
|
continueTesting = checkInstanceAlive(instanceInfo, options);
|
|
|
|
if (r !== 0 && !options.force) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo,options);
|
|
print("done.");
|
|
return results;
|
|
};
|
|
|
|
testFuncs.authentication = function (options) {
|
|
print("Authentication tests...");
|
|
var instanceInfo = startInstance("tcp", options,
|
|
["--server.disable-authentication", "false"],
|
|
"authentication");
|
|
var results = {};
|
|
results.auth = runInArangosh(options, instanceInfo,
|
|
fs.join("js","client","tests","auth.js"));
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo,options);
|
|
print("done.");
|
|
return results;
|
|
};
|
|
|
|
var urlsTodo = [
|
|
"/_api/",
|
|
"/_api",
|
|
"/_api/version",
|
|
"/_admin/html",
|
|
"/_admin/html/",
|
|
"/test",
|
|
"/the-big-fat-fox"
|
|
];
|
|
|
|
testFuncs.authentication_parameters = function (options) {
|
|
print("Authentication with parameters tests...");
|
|
var results = {};
|
|
// With full authentication:
|
|
var instanceInfo = startInstance("tcp", options,
|
|
["--server.disable-authentication", "false",
|
|
"--server.authenticate-system-only", "false"],
|
|
"authentication_parameters_1");
|
|
var r;
|
|
var i;
|
|
var expectAuthFullRC = [401, 401, 401, 401, 401, 401, 401];
|
|
var all_ok = true;
|
|
var continueTesting = true;
|
|
|
|
print("Starting Full test");
|
|
results.auth_full = {};
|
|
for (i = 0; i < urlsTodo.length; i++) {
|
|
|
|
if (!continueTesting) {
|
|
print("Skipping " + urlsTodo[i] + ", server is gone.");
|
|
results.auth_full[urlsTodo[i]] = {status: false, message: instanceInfo.exitStatus};
|
|
instanceInfo.exitStatus = "server is gone.";
|
|
all_ok = false;
|
|
continue;
|
|
}
|
|
|
|
r = download(instanceInfo.url+urlsTodo[i],"",{followRedirects:false,returnBodyOnError:true});
|
|
if (r.code === expectAuthFullRC[i]) {
|
|
results.auth_full[urlsTodo[i]] = { status: true, message: ""};
|
|
}
|
|
else {
|
|
results.auth_full[urlsTodo[i]] = {
|
|
status: false,
|
|
message: "we expected " + expectAuthFullRC[i] + " and we got " + r.code + " Full Status: " + JSON.stringify(r)
|
|
};
|
|
all_ok = false;
|
|
}
|
|
continueTesting = checkInstanceAlive(instanceInfo, options);
|
|
}
|
|
results.auth_full.status = all_ok;
|
|
|
|
print("Shutting down Full test...");
|
|
shutdownInstance(instanceInfo,options);
|
|
print("done with Full test.");
|
|
// Only system authentication:
|
|
continueTesting = true;
|
|
instanceInfo = startInstance("tcp", options,
|
|
["--server.disable-authentication", "false",
|
|
"--server.authenticate-system-only", "true"],
|
|
"authentication_parameters_2");
|
|
var expectAuthSystemRC = [401, 401, 401, 401, 401, 404, 404];
|
|
all_ok = true;
|
|
print("Starting System test");
|
|
results.auth_system = {};
|
|
for (i = 0;i < urlsTodo.length;i++) {
|
|
if (!continueTesting) {
|
|
print("Skipping " + urlsTodo[i] + " server is gone.");
|
|
results.auth_full[urlsTodo[i]] = {status: false, message: instanceInfo.exitStatus};
|
|
instanceInfo.exitStatus = "server is gone.";
|
|
all_ok = false;
|
|
continue;
|
|
}
|
|
r = download(instanceInfo.url+urlsTodo[i],"",{followRedirects:false,returnBodyOnError:true});
|
|
if (r.code === expectAuthSystemRC[i]) {
|
|
results.auth_system[urlsTodo[i]] = { status: true, message: ""};
|
|
}
|
|
else {
|
|
results.auth_system[urlsTodo[i]] = {
|
|
status: false,
|
|
message: "we expected " + expectAuthSystemRC[i] + " and we got " + r.code + " Full Status: " + JSON.stringify(r)
|
|
};
|
|
all_ok = false;
|
|
}
|
|
continueTesting = checkInstanceAlive(instanceInfo, options);
|
|
}
|
|
results.auth_system.status = all_ok;
|
|
|
|
print("Shutting down System test...");
|
|
shutdownInstance(instanceInfo,options);
|
|
print("done with System test.");
|
|
// No authentication:
|
|
instanceInfo = startInstance("tcp", options,
|
|
["--server.disable-authentication", "true",
|
|
"--server.authenticate-system-only", "true"],
|
|
"authentication_parameters_3");
|
|
var expectAuthNoneRC = [404, 404, 200, 301, 301, 404, 404];
|
|
results.auth_none = {};
|
|
all_ok = true;
|
|
continueTesting = true;
|
|
print("Starting None test");
|
|
for (i = 0;i < urlsTodo.length;i++) {
|
|
if (!continueTesting) {
|
|
print("Skipping " + urlsTodo[i] + " server is gone.");
|
|
results.auth_full[urlsTodo[i]] = {status: false, message: instanceInfo.exitStatus};
|
|
instanceInfo.exitStatus = "server is gone.";
|
|
all_ok = false;
|
|
continue;
|
|
}
|
|
|
|
r = download(instanceInfo.url+urlsTodo[i],"",{followRedirects:false,returnBodyOnError:true});
|
|
if (r.code === expectAuthNoneRC[i]) {
|
|
results.auth_none[urlsTodo[i]] = { status: true, message: ""};
|
|
}
|
|
else {
|
|
results.auth_none[urlsTodo[i]] = {
|
|
status: false,
|
|
message: "we expected " + expectAuthNoneRC[i] + " and we got " + r.code + " Full Status: " + JSON.stringify(r)
|
|
};
|
|
all_ok = false;
|
|
}
|
|
continueTesting = checkInstanceAlive(instanceInfo, options);
|
|
}
|
|
results.auth_none.status = all_ok;
|
|
|
|
print("Shutting down None test...");
|
|
shutdownInstance(instanceInfo,options);
|
|
print("done with None test.");
|
|
return results;
|
|
};
|
|
|
|
var internalMembers = ["code", "error", "status", "duration", "failed", "total"];
|
|
|
|
function unitTestPrettyPrintResults(r) {
|
|
var testrun;
|
|
var test;
|
|
var oneTest;
|
|
var testFail = 0;
|
|
var testSuiteFail = 0;
|
|
|
|
try {
|
|
for (testrun in r) {
|
|
if (r.hasOwnProperty(testrun) && (testrun !== 'all_ok')) {
|
|
print("Testrun: " + testrun);
|
|
for (test in r[testrun]) {
|
|
if (r[testrun].hasOwnProperty(test) && (test !== 'ok')) {
|
|
if (r[testrun][test].status) {
|
|
print(" " + test + ": Success");
|
|
}
|
|
else {
|
|
testSuiteFail++;
|
|
if (r[testrun][test].hasOwnProperty('message')) {
|
|
print(" " + test + ": Fail - Whole testsuite failed!");
|
|
if (typeof r[testrun][test].message === "object" &&
|
|
r[testrun][test].message.hasOwnProperty('body')) {
|
|
print(r[testrun][test].message.body);
|
|
}
|
|
else {
|
|
print(r[testrun][test].message);
|
|
}
|
|
}
|
|
else {
|
|
print(" " + test + ": Fail");
|
|
for (oneTest in r[testrun][test]) {
|
|
if ((r[testrun][test].hasOwnProperty(oneTest)) &&
|
|
(internalMembers.indexOf(oneTest) === -1) &&
|
|
(!r[testrun][test][oneTest].status)) {
|
|
testFail++;
|
|
print(" -> " + oneTest + " Failed; Verbose message:");
|
|
print(r[testrun][test][oneTest].message);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
print("Overall state: " + ((r.all_ok === true) ? "Success" : "Fail"));
|
|
if (r.all_ok !== true) {
|
|
print(" Suites failed: " + testSuiteFail + " Tests Failed: " + testFail);
|
|
}
|
|
}
|
|
catch (x) {
|
|
print("exception caught while pretty printing result: ");
|
|
print(x.message);
|
|
print(JSON.stringify(r));
|
|
}
|
|
}
|
|
|
|
function UnitTest (which, options) {
|
|
var allok = true;
|
|
var results = {};
|
|
if (typeof options !== "object") {
|
|
options = {};
|
|
}
|
|
_.defaults(options, optionsDefaults);
|
|
if (which === undefined) {
|
|
printUsage();
|
|
return;
|
|
}
|
|
var jsonReply = options.jsonReply;
|
|
delete options.jsonReply;
|
|
var i;
|
|
var ok;
|
|
if (which === "all") {
|
|
var n;
|
|
for (n = 0;n < allTests.length;n++) {
|
|
print("Doing test",allTests[n],"with options",options);
|
|
results[allTests[n]] = r = testFuncs[allTests[n]](options);
|
|
ok = true;
|
|
for (i in r) {
|
|
if (r.hasOwnProperty(i)) {
|
|
if (r[i].status !== true) {
|
|
ok = false;
|
|
}
|
|
}
|
|
}
|
|
r.ok = ok;
|
|
if (!ok) {
|
|
allok = false;
|
|
}
|
|
results.all_ok = allok;
|
|
}
|
|
results.all_ok = allok;
|
|
if (allok) {
|
|
cleanupDBDirectories(options);
|
|
}
|
|
else {
|
|
print("since some tests weren't successfully, not cleaning up: ");
|
|
print(cleanupDirectories);
|
|
}
|
|
if (jsonReply === true ) {
|
|
return results;
|
|
}
|
|
else {
|
|
unitTestPrettyPrintResults(results);
|
|
return allok;
|
|
}
|
|
}
|
|
else if (!testFuncs.hasOwnProperty(which)) {
|
|
printUsage();
|
|
throw 'Unknown test "' + which + '"';
|
|
}
|
|
else {
|
|
var r;
|
|
results[which] = r = testFuncs[which](options);
|
|
ok = true;
|
|
for (i in r) {
|
|
if (r.hasOwnProperty(i) &&
|
|
(which !== "single" || i !== "test")) {
|
|
if (r[i].status !== true) {
|
|
ok = false;
|
|
allok = false;
|
|
}
|
|
}
|
|
}
|
|
r.ok = ok;
|
|
results.all_ok = ok;
|
|
|
|
if (allok) {
|
|
cleanupDBDirectories(options);
|
|
}
|
|
else {
|
|
print("since some tests weren't successfully, not cleaning up: ");
|
|
print(cleanupDirectories);
|
|
}
|
|
if (jsonReply === true ) {
|
|
return results;
|
|
}
|
|
else {
|
|
unitTestPrettyPrintResults(results);
|
|
return allok;
|
|
}
|
|
}
|
|
}
|
|
|
|
exports.UnitTest = UnitTest;
|
|
exports.unitTestPrettyPrintResults = unitTestPrettyPrintResults;
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- END-OF-FILE
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// Local Variables:
|
|
// mode: outline-minor
|
|
// outline-regexp: "\\(/// @brief\\|/// @addtogroup\\|// --SECTION--\\|/// @page\\|/// @\\}\\)"
|
|
// End:
|