mirror of https://gitee.com/bigwinds/arangodb
4023 lines
108 KiB
JavaScript
4023 lines
108 KiB
JavaScript
/*jshint strict: false, sub: true */
|
|
/*global print, arango */
|
|
'use strict';
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2016 ArangoDB GmbH, Cologne, Germany
|
|
/// 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 ArangoDB GmbH, Cologne, Germany
|
|
///
|
|
/// @author Max Neunhoeffer
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
const functionsDocumentation = {
|
|
"all": "run all tests (marked with [x])",
|
|
"arangob": "arangob tests",
|
|
"arangosh": "arangosh exit codes tests",
|
|
"authentication": "authentication tests",
|
|
"authentication_parameters": "authentication parameters tests",
|
|
"boost": "boost test suites",
|
|
"config": "checks the config file parsing",
|
|
"dump": "dump tests",
|
|
"dump_authentication": "dump tests with authentication",
|
|
"dfdb": "start test",
|
|
"foxx_manager": "foxx manager tests",
|
|
"http_replication": "http replication tests",
|
|
"http_server": "http server tests",
|
|
"importing": "import tests",
|
|
"recovery": "run recovery tests",
|
|
"replication_ongoing": "replication ongoing tests",
|
|
"replication_static": "replication static tests",
|
|
"replication_sync": "replication sync tests",
|
|
"shell_client": "shell client tests",
|
|
"shell_replication": "shell replication tests",
|
|
"shell_server": "shell server tests",
|
|
"shell_server_aql": "AQL tests in the server",
|
|
"shell_server_only": "server specific tests",
|
|
"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 arguments to get more detail",
|
|
"single_server": "run one test suite on the server; options required\n" +
|
|
" run without arguments to get more detail",
|
|
"ssl_server": "https server tests",
|
|
"upgrade": "upgrade tests"
|
|
};
|
|
|
|
const 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',
|
|
'',
|
|
' - `skipAql`: if set to true the AQL tests are skipped',
|
|
' - `skipArangoBNonConnKeepAlive`: if set to true benchmark do not use keep-alive',
|
|
' - `skipArangoB`: if set to true benchmark tests are skipped',
|
|
' - `skipAuth : testing authentication and authentication_paramaters will be skipped.',
|
|
' - `skipBoost`: if set to true the boost unittests are skipped',
|
|
' - `skipConfig`: omit the noisy configuration tests',
|
|
' - `skipFoxxQueues`: omit the test for the foxx queues',
|
|
' - `skipGeo`: if set to true the geo index tests are skipped',
|
|
' - `skipGraph`: if set to true the graph tests are skipped',
|
|
' - `skipLogAnalysis`: don\'t try to crawl the server logs',
|
|
' - `skipMemoryIntense`: tests using lots of resources will be skipped.',
|
|
' - `skipNightly`: omit the nightly tests',
|
|
' - `skipRanges`: if set to true the ranges tests are skipped',
|
|
' - `skipSsl`: omit the ssl_server rspec tests.',
|
|
' - `skipTimeCritical`: if set to true, time critical tests will be skipped.',
|
|
' - `skipNondeterministic`: if set, nondeterministic tests are skipped.',
|
|
'',
|
|
' - `onlyNightly`: execute only the nightly tests',
|
|
' - `loopEternal`: to loop one test over and over.',
|
|
' - `loopSleepWhen`: sleep every nth iteration',
|
|
' - `loopSleepSec`: sleep seconds between iterations',
|
|
'',
|
|
' - `cluster`: if set to true the tests are run with the coordinator',
|
|
' of a small local cluster',
|
|
' - `clusterNodes`: number of DB-Servers to use',
|
|
' - valgrindHosts - configure which clustercomponents to run using valgrind',
|
|
' Coordinator - flag to run Coordinator with valgrind',
|
|
' DBServer - flag to run DBServers with valgrind',
|
|
' - `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.',
|
|
'',
|
|
' - benchargs : additional commandline arguments to arangob',
|
|
'',
|
|
' - `valgrind`: if set the programs are run with the valgrind',
|
|
' memory checker; should point to the valgrind executable',
|
|
' - `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',
|
|
' - `extremeVerbosity`: if set to true, then there will be more test run',
|
|
' output, especially for cluster tests.',
|
|
''
|
|
];
|
|
|
|
const optionsDefaults = {
|
|
"cleanup": true,
|
|
"cluster": false,
|
|
"clusterNodes": 2,
|
|
"concurrency": 3,
|
|
"coreDirectory": "/var/tmp",
|
|
"duration": 10,
|
|
"extraargs": [],
|
|
"extremeVerbosity": false,
|
|
"force": true,
|
|
"jsonReply": false,
|
|
"loopEternal": false,
|
|
"loopSleepSec": 1,
|
|
"loopSleepWhen": 1,
|
|
"onlyNightly": false,
|
|
"password": "",
|
|
"replication": false,
|
|
"skipAql": false,
|
|
"skipArangoB": false,
|
|
"skipArangoBNonConnKeepAlive": true,
|
|
"skipBoost": false,
|
|
"skipGeo": false,
|
|
"skipLogAnalysis": false,
|
|
"skipMemoryIntense": false,
|
|
"skipNightly": true,
|
|
"skipNondeterministic": false,
|
|
"skipRanges": false,
|
|
"skipSsl": false,
|
|
"skipTimeCritical": false,
|
|
"test": undefined,
|
|
"username": "root",
|
|
"valgrind": false,
|
|
"valgrindXmlFileBase": "",
|
|
"valgrindArgs": [],
|
|
"valgrindHosts": false,
|
|
"writeXmlReport": true
|
|
};
|
|
|
|
const _ = require("lodash");
|
|
const fs = require("fs");
|
|
const yaml = require("js-yaml");
|
|
|
|
const base64Encode = require("internal").base64Encode;
|
|
const download = require("internal").download;
|
|
const executeExternal = require("internal").executeExternal;
|
|
const executeExternalAndWait = require("internal").executeExternalAndWait;
|
|
const killExternal = require("internal").killExternal;
|
|
const sleep = require("internal").sleep;
|
|
const statusExternal = require("internal").statusExternal;
|
|
const testPort = require("internal").testPort;
|
|
const time = require("internal").time;
|
|
const toArgv = require("internal").toArgv;
|
|
const wait = require("internal").wait;
|
|
|
|
const Planner = require("@arangodb/cluster").Planner;
|
|
const Kickstarter = require("@arangodb/cluster").Kickstarter;
|
|
|
|
let cleanupDirectories = [];
|
|
let serverCrashed = false;
|
|
|
|
const makeResults = function(testname) {
|
|
const startTime = time();
|
|
|
|
return function(status, message) {
|
|
let duration = time() - startTime;
|
|
|
|
let results = {
|
|
status: status,
|
|
duration: duration
|
|
};
|
|
|
|
results[testname] = {
|
|
status: status,
|
|
duration: duration
|
|
};
|
|
|
|
if (message) {
|
|
results[testname].message = message;
|
|
}
|
|
|
|
return {
|
|
'testing.js': results
|
|
};
|
|
};
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief top-level directory
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function findTopDir() {
|
|
const 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;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief arguments for testing (server)
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function makeArgsArangod(options, appDir) {
|
|
const topDir = findTopDir();
|
|
|
|
if (appDir === undefined) {
|
|
appDir = fs.getTempPath();
|
|
}
|
|
|
|
fs.makeDirectoryRecursive(appDir, true);
|
|
|
|
return {
|
|
"configuration": "none",
|
|
"server.keyfile": fs.join(topDir, "UnitTests", "server.pem"),
|
|
"database.maximal-journal-size": "1048576",
|
|
"database.force-sync-properties": "false",
|
|
"javascript.app-path": appDir,
|
|
"javascript.startup-directory": fs.join(topDir, "js"),
|
|
"server.threads": "20",
|
|
"javascript.v8-contexts": "5",
|
|
"server.disable-authentication": "true",
|
|
"server.allow-use-database": "true"
|
|
};
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief arguments for testing (client)
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function makeArgsArangosh(options) {
|
|
const topDir = findTopDir();
|
|
|
|
return {
|
|
"configuration": "none",
|
|
"javascript.startup-directory": fs.join(topDir, "js"),
|
|
"server.username": options.username,
|
|
"server.password": options.password,
|
|
"flatCommands": ["--no-colors", "--quiet"]
|
|
};
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief adds authorization headers
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function makeAuthorizationHeaders(options) {
|
|
return {
|
|
"headers": {
|
|
"Authorization": "Basic " + base64Encode(options.username + ":" +
|
|
options.password)
|
|
}
|
|
};
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief converts endpoints to URL
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function endpointToURL(endpoint) {
|
|
if (endpoint.substr(0, 6) === "ssl://") {
|
|
return "https://" + endpoint.substr(6);
|
|
}
|
|
|
|
const pos = endpoint.indexOf("://");
|
|
|
|
if (pos === -1) {
|
|
return "http://" + endpoint;
|
|
}
|
|
|
|
return "http" + endpoint.substr(pos);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief scans the log files for important infos
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function readImportantLogLines(logPath) {
|
|
const list = fs.list(logPath);
|
|
let importantLines = {};
|
|
|
|
for (let i = 0; i < list.length; i++) {
|
|
let fnLines = [];
|
|
|
|
if (list[i].slice(0, 3) === 'log') {
|
|
const buf = fs.readBuffer(fs.join(logPath, list[i]));
|
|
let lineStart = 0;
|
|
let maxBuffer = buf.length;
|
|
|
|
for (let j = 0; j < maxBuffer; j++) {
|
|
if (buf[j] === 10) { // \n
|
|
const line = buf.asciiSlice(lineStart, j);
|
|
lineStart = j + 1;
|
|
|
|
// filter out regular INFO lines, and test related messages
|
|
let warn = line.search('WARNING about to execute:') !== -1;
|
|
let info = line.search(' INFO ') !== -1;
|
|
|
|
if (warn || info) {
|
|
continue;
|
|
}
|
|
|
|
fnLines.push(line);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fnLines.length > 0) {
|
|
importantLines[list[i]] = fnLines;
|
|
}
|
|
}
|
|
|
|
return importantLines;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief analyzes a core dump using gdb (Unix)
|
|
///
|
|
/// We assume the system has core files in /var/tmp/, and we have a gdb.
|
|
/// you can do this at runtime doing:
|
|
///
|
|
/// echo 1 > /proc/sys/kernel/core_uses_pid
|
|
/// echo /var/tmp/core-%e-%p-%t > /proc/sys/kernel/core_pattern
|
|
///
|
|
/// or at system startup by altering /etc/sysctl.d/corepattern.conf :
|
|
/// # We want core files to be located in a central location
|
|
/// # and know the PID plus the process name for later use.
|
|
/// kernel.core_uses_pid = 1
|
|
/// kernel.core_pattern = /var/tmp/core-%e-%p-%t
|
|
///
|
|
/// If you set coreDirectory to empty, this behavior is changed: The core file
|
|
/// expected to be named simply "core" and should exist in the current
|
|
/// directory.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function analyzeCoreDump(instanceInfo, options, storeArangodPath, pid) {
|
|
let command;
|
|
|
|
command = '(';
|
|
command += "printf 'bt full\\n thread apply all bt\\n';";
|
|
command += "sleep 10;";
|
|
command += "echo quit;";
|
|
command += "sleep 2";
|
|
command += ") | gdb " + storeArangodPath + " ";
|
|
|
|
if (options.coreDirectory === "") {
|
|
command += "core";
|
|
} else {
|
|
command += options.coreDirectory + "/*core*" + pid + '*';
|
|
}
|
|
|
|
const args = ['-c', command];
|
|
print(JSON.stringify(args));
|
|
|
|
executeExternalAndWait("/bin/bash", args);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief analyzes a core dump using cdb (Windows)
|
|
/// cdb is part of the WinDBG package.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function analyzeCoreDumpWindows(instanceInfo) {
|
|
const coreFN = instanceInfo.tmpDataDir + "\\" + "core.dmp";
|
|
|
|
if (!fs.exists(coreFN)) {
|
|
print("core file " + coreFN + " not found?");
|
|
return;
|
|
}
|
|
|
|
const dbgCmds = [
|
|
"kp", // print curren threads backtrace with arguments
|
|
"~*kb", // print all threads stack traces
|
|
"dv", // analyze local variables (if)
|
|
"!analyze -v", // print verbose analysis
|
|
"q" //quit the debugger
|
|
];
|
|
|
|
const args = [
|
|
"-z",
|
|
coreFN,
|
|
"-c",
|
|
dbgCmds.join("; ")
|
|
];
|
|
|
|
print("running cdb " + JSON.stringify(args));
|
|
executeExternalAndWait("cdb", args);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief checks of an instance is still alive
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function checkInstanceAliveSingleServer(instanceInfo, options) {
|
|
if (instanceInfo.hasOwnProperty('exitStatus')) {
|
|
return false;
|
|
}
|
|
|
|
const res = statusExternal(instanceInfo.pid, false);
|
|
const ret = res.status === "RUNNING";
|
|
|
|
if (!ret) {
|
|
print("ArangoD with PID " + instanceInfo.pid.pid + " gone:");
|
|
print(instanceInfo);
|
|
|
|
if (res.hasOwnProperty('signal') &&
|
|
((res.signal === 11) ||
|
|
(res.signal === 6) ||
|
|
// Windows sometimes has random numbers in signal...
|
|
(require("internal").platform.substr(0, 3) === 'win')
|
|
)
|
|
) {
|
|
const storeArangodPath = "/var/tmp/arangod_" + instanceInfo.pid.pid;
|
|
|
|
print("Core dump written; copying arangod to " +
|
|
instanceInfo.tmpDataDir + " for later analysis.");
|
|
|
|
let corePath = (options.coreDirectory === "") ?
|
|
"core" :
|
|
options.coreDirectory + "/core*" + instanceInfo.pid.pid + "*'";
|
|
|
|
res.gdbHint = "Run debugger with 'gdb " +
|
|
storeArangodPath + " " + corePath;
|
|
|
|
if (require("internal").platform.substr(0, 3) === 'win') {
|
|
// Windows: wait for procdump to do its job...
|
|
statusExternal(instanceInfo.monitor, true);
|
|
analyzeCoreDumpWindows(instanceInfo);
|
|
} else {
|
|
fs.copyFile("bin/arangod", storeArangodPath);
|
|
analyzeCoreDump(instanceInfo, options, storeArangodPath, instanceInfo.pid.pid);
|
|
}
|
|
}
|
|
|
|
instanceInfo.exitStatus = res;
|
|
}
|
|
|
|
if (!ret) {
|
|
print("marking crashy");
|
|
serverCrashed = true;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
function checkRemoteInstance(pid, wait, options) {
|
|
const debug = options.debug || false;
|
|
const p = JSON.stringify(pid);
|
|
const res = JSON.parse(arango.PUT("/_admin/execute",
|
|
`return require("internal").statusExternal(${p}, ${wait});`));
|
|
|
|
if (debug) {
|
|
print(`status of remote process ${p}: ${res.status}`);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
function checkInstanceAliveCluster(instanceInfo, options) {
|
|
let clusterFit = true;
|
|
|
|
for (let part in instanceInfo.kickstarter.runInfo) {
|
|
if (instanceInfo.kickstarter.runInfo[part].hasOwnProperty("pids")) {
|
|
for (let pid in instanceInfo.kickstarter.runInfo[part].pids) {
|
|
if (instanceInfo.kickstarter.runInfo[part].pids.hasOwnProperty(pid)) {
|
|
const checkpid = instanceInfo.kickstarter.runInfo[part].pids[pid];
|
|
const ress = checkRemoteInstance(checkpid, false, options);
|
|
|
|
if (ress.hasOwnProperty('signal') &&
|
|
((ress.signal === 11) || (ress.signal === 6))) {
|
|
const storeArangodPath = "/var/tmp/arangod_" + checkpid.pid;
|
|
|
|
print("Core dump written; copying arangod to " +
|
|
storeArangodPath + " for later analysis.");
|
|
|
|
ress.gdbHint = "Run debugger with 'gdb " +
|
|
storeArangodPath +
|
|
" /var/tmp/core*" + checkpid.pid + "*'";
|
|
|
|
if (require("internal").platform.substr(0, 3) === 'win') {
|
|
// Windows: wait for procdump to do its job...
|
|
checkRemoteInstance(instanceInfo.monitor, true, options);
|
|
analyzeCoreDumpWindows(instanceInfo);
|
|
} else {
|
|
fs.copyFile("bin/arangod", storeArangodPath);
|
|
analyzeCoreDump(instanceInfo, options, storeArangodPath, checkpid.pid);
|
|
}
|
|
|
|
instanceInfo.exitStatus = ress;
|
|
clusterFit = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (clusterFit && instanceInfo.kickstarter.isHealthy()) {
|
|
return true;
|
|
} else {
|
|
print("marking crashy");
|
|
serverCrashed = true;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function checkInstanceAlive(instanceInfo, options) {
|
|
if (options.cluster === false) {
|
|
return checkInstanceAliveSingleServer(instanceInfo, options);
|
|
}
|
|
|
|
return checkInstanceAliveCluster(instanceInfo, options);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief waits for garbage collection using /_admin/execute
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function waitOnServerForGC(instanceInfo, options, waitTime) {
|
|
try {
|
|
print("waiting " + waitTime + " for server GC");
|
|
const remoteCommand = 'require("internal").wait(' + waitTime + ', true);';
|
|
|
|
const requestOptions = makeAuthorizationHeaders(options);
|
|
requestOptions.method = "POST";
|
|
requestOptions.timeout = waitTime * 10;
|
|
requestOptions.returnBodyOnError = true;
|
|
|
|
const reply = download(
|
|
instanceInfo.url + "/_admin/execute?returnAsJSON=true",
|
|
remoteCommand,
|
|
requestOptions);
|
|
|
|
print("waiting " + waitTime + " for server GC - done.");
|
|
|
|
if (!reply.error && reply.code === 200) {
|
|
return JSON.parse(reply.body);
|
|
} else {
|
|
return {
|
|
status: false,
|
|
message: yaml.safedump(reply.body)
|
|
};
|
|
}
|
|
} catch (ex) {
|
|
return {
|
|
status: false,
|
|
message: ex.message || String(ex),
|
|
stack: ex.stack
|
|
};
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief cleans up the database direcory
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function cleanupDBDirectories(options) {
|
|
if (options.cleanup) {
|
|
while (cleanupDirectories.length) {
|
|
const cleanupDirectory = cleanupDirectories.shift();
|
|
|
|
// Avoid attempting to remove the same directory multiple times
|
|
if (cleanupDirectories.indexOf(cleanupDirectory) === -1) {
|
|
fs.removeDirectoryRecursive(cleanupDirectory, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief finds a free port
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function findFreePort() {
|
|
while (true) {
|
|
const port = Math.floor(Math.random() * (65536 - 1024)) + 1024;
|
|
const free = testPort("tcp://0.0.0.0:" + port);
|
|
|
|
if (free) {
|
|
return port;
|
|
}
|
|
}
|
|
|
|
return 8529;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief build a unix path
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function makePathUnix(path) {
|
|
return fs.join.apply(null, path.split("/"));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief build a generic path
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function makePathGeneric(path) {
|
|
return fs.join.apply(null, path.split(fs.pathSeparator));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief runs a remote unittest file using /_admin/execute
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function runThere(options, instanceInfo, file) {
|
|
try {
|
|
let testCode;
|
|
|
|
if (file.indexOf("-spec") === -1) {
|
|
testCode = 'const runTest = require("jsunity").runTest; ' +
|
|
'return runTest(' + JSON.stringify(file) + ', true);';
|
|
} else {
|
|
testCode = 'const runTest = require("@arangodb/mocha-runner"); ' +
|
|
'return runTest(' + JSON.stringify(file) + ', true);';
|
|
}
|
|
|
|
let httpOptions = makeAuthorizationHeaders(options);
|
|
httpOptions.method = "POST";
|
|
httpOptions.timeout = 3600;
|
|
|
|
if (options.valgrind) {
|
|
httpOptions.timeout *= 2;
|
|
}
|
|
|
|
httpOptions.returnBodyOnError = true;
|
|
|
|
const reply = download(instanceInfo.url + "/_admin/execute?returnAsJSON=true",
|
|
testCode,
|
|
httpOptions);
|
|
|
|
if (!reply.error && reply.code === 200) {
|
|
return JSON.parse(reply.body);
|
|
} else {
|
|
if (reply.hasOwnProperty('body')) {
|
|
return {
|
|
status: false,
|
|
message: reply.body
|
|
};
|
|
} else {
|
|
return {
|
|
status: false,
|
|
message: yaml.safeDump(reply)
|
|
};
|
|
}
|
|
}
|
|
} catch (ex) {
|
|
return {
|
|
status: false,
|
|
message: ex.message || String(ex),
|
|
stack: ex.stack
|
|
};
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief runs a list of tests
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function performTests(options, testList, testname) {
|
|
let instanceInfo = startInstance("tcp", options, {}, testname);
|
|
|
|
if (instanceInfo === false) {
|
|
return {
|
|
setup: {
|
|
status: false,
|
|
message: "failed to start server!"
|
|
}
|
|
};
|
|
}
|
|
|
|
if (testList.length === 0) {
|
|
print("Testsuite is empty!");
|
|
|
|
return {
|
|
"EMPTY TESTSUITE": {
|
|
status: false,
|
|
message: "no testsuites found!"
|
|
}
|
|
};
|
|
}
|
|
|
|
let results = {};
|
|
let continueTesting = true;
|
|
|
|
for (let i = 0; i < testList.length; i++) {
|
|
let te = testList[i];
|
|
let filtered = {};
|
|
|
|
if (filterTestcaseByOptions(te, options, filtered)) {
|
|
let first = true;
|
|
let loopCount = 0;
|
|
|
|
while (first || options.loopEternal) {
|
|
if (!continueTesting) {
|
|
print('oops!');
|
|
print("Skipping, " + te + " server is gone.");
|
|
|
|
results[te] = {
|
|
status: false,
|
|
message: instanceInfo.exitStatus
|
|
};
|
|
|
|
instanceInfo.exitStatus = "server is gone.";
|
|
|
|
break;
|
|
}
|
|
|
|
print("\n" + Date() + " arangod: Trying", te, "...");
|
|
|
|
let reply = runThere(options, instanceInfo, te);
|
|
|
|
if (reply.hasOwnProperty('status')) {
|
|
results[te] = reply;
|
|
|
|
if (results[te].status === false) {
|
|
options.cleanup = false;
|
|
}
|
|
|
|
if (!reply.status && !options.force) {
|
|
break;
|
|
}
|
|
} else {
|
|
results[te] = {
|
|
status: false,
|
|
message: reply
|
|
};
|
|
|
|
if (!options.force) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
continueTesting = checkInstanceAlive(instanceInfo, options);
|
|
|
|
first = false;
|
|
|
|
if (options.loopEternal) {
|
|
if (loopCount % options.loopSleepWhen === 0) {
|
|
print("sleeping...");
|
|
sleep(options.loopSleepSec);
|
|
print("continuing.");
|
|
}
|
|
|
|
++loopCount;
|
|
}
|
|
}
|
|
} else {
|
|
if (options.extremeVerbosity) {
|
|
print("Skipped " + te + " because of " + filtered.filter);
|
|
}
|
|
}
|
|
}
|
|
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo, options);
|
|
print("done.");
|
|
|
|
if ((!options.skipLogAnalysis) &&
|
|
instanceInfo.hasOwnProperty('importantLogLines') &&
|
|
Object.keys(instanceInfo.importantLogLines).length > 0) {
|
|
print("Found messages in the server logs: \n" +
|
|
yaml.safeDump(instanceInfo.importantLogLines));
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief runs a stress test on arangod
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function runStressTest(options, command, testname) {
|
|
const concurrency = options.concurrency;
|
|
|
|
let extra = {
|
|
"javascript.v8-contexts": concurrency + 2,
|
|
"server.threads": concurrency + 2
|
|
};
|
|
|
|
let instanceInfo = startInstance("tcp", options, extra, testname);
|
|
|
|
if (instanceInfo === false) {
|
|
return {
|
|
status: false,
|
|
message: "failed to start server!"
|
|
};
|
|
}
|
|
|
|
const requestOptions = makeAuthorizationHeaders(options);
|
|
requestOptions.method = "POST";
|
|
requestOptions.returnBodyOnError = true;
|
|
requestOptions.headers = {
|
|
"x-arango-async": "store"
|
|
};
|
|
|
|
const reply = download(
|
|
instanceInfo.url + "/_admin/execute?returnAsJSON=true",
|
|
command,
|
|
requestOptions);
|
|
|
|
if (reply.error || reply.code !== 202) {
|
|
print("cannot execute command: (" +
|
|
reply.code + ") " + reply.message);
|
|
|
|
shutdownInstance(instanceInfo, options);
|
|
|
|
return {
|
|
status: false,
|
|
message: reply.hasOwnProperty('body') ? reply.body : yaml.safeDump(reply)
|
|
};
|
|
}
|
|
|
|
const id = reply.headers["x-arango-async-id"];
|
|
|
|
const checkOpts = makeAuthorizationHeaders(options);
|
|
checkOpts.method = "PUT";
|
|
checkOpts.returnBodyOnError = true;
|
|
|
|
while (true) {
|
|
const check = download(
|
|
instanceInfo.url + "/_api/job/" + id,
|
|
"", checkOpts);
|
|
|
|
if (!check.error) {
|
|
if (check.code === 204) {
|
|
print("still running (" + (new Date()) + ")");
|
|
wait(60);
|
|
continue;
|
|
}
|
|
|
|
if (check.code === 200) {
|
|
print("stress test finished");
|
|
break;
|
|
}
|
|
}
|
|
|
|
print(yaml.safeDump(check));
|
|
|
|
shutdownInstance(instanceInfo, options);
|
|
|
|
return {
|
|
status: false,
|
|
message: check.hasOwnProperty('body') ? check.body : yaml.safeDump(check)
|
|
};
|
|
}
|
|
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo, options);
|
|
print("done.");
|
|
|
|
return {};
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief executes a command and wait for result
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function executeAndWait(cmd, args) {
|
|
const startTime = time();
|
|
const res = executeExternalAndWait(cmd, args);
|
|
const deltaTime = time() - startTime;
|
|
|
|
let 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
|
|
};
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief runs file in arangosh
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function runInArangosh(options, instanceInfo, file, addArgs) {
|
|
const topDir = findTopDir();
|
|
|
|
let args = makeArgsArangosh(options);
|
|
args["server.endpoint"] = instanceInfo.endpoint;
|
|
args["javascript.unit-tests"] = fs.join(topDir, file);
|
|
|
|
if (addArgs !== undefined) {
|
|
args = _.extend(args, addArgs);
|
|
}
|
|
|
|
const arangosh = fs.join("bin", "arangosh");
|
|
let rc = executeAndWait(arangosh, toArgv(args));
|
|
|
|
let result;
|
|
|
|
try {
|
|
result = JSON.parse(fs.read("testresult.json"));
|
|
} catch (x) {
|
|
return rc;
|
|
}
|
|
|
|
if ((typeof result[0] === 'object') &&
|
|
result[0].hasOwnProperty('status')) {
|
|
return result[0];
|
|
} else {
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief runs arangosh
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function runArangoshCmd(options, instanceInfo, addArgs, cmds) {
|
|
let args = makeArgsArangosh(options);
|
|
args["server.endpoint"] = instanceInfo.endpoint;
|
|
|
|
if (addArgs !== undefined) {
|
|
args = _.extend(args, addArgs);
|
|
}
|
|
|
|
const argv = toArgv(args).concat(cmds);
|
|
const arangosh = fs.join("bin", "arangosh");
|
|
return executeAndWait(arangosh, argv);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief runs arangodump or arangoimp
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function runArangoImp(options, instanceInfo, what) {
|
|
const topDir = findTopDir();
|
|
|
|
let 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["create-collection"] = what.create;
|
|
}
|
|
|
|
if (what.backslash !== undefined) {
|
|
args["backslash-escape"] = what.backslash;
|
|
}
|
|
|
|
if (what.separator !== undefined) {
|
|
args["separator"] = what.separator;
|
|
}
|
|
|
|
const arangoimp = fs.join("bin", "arangoimp");
|
|
return executeAndWait(arangoimp, toArgv(args));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief runs arangodump or arangorestore
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function runArangoDumpRestore(options, instanceInfo, which, database) {
|
|
let args = {
|
|
"configuration": "none",
|
|
"server.username": options.username,
|
|
"server.password": options.password,
|
|
"server.endpoint": instanceInfo.endpoint,
|
|
"server.database": database
|
|
};
|
|
|
|
let exe;
|
|
|
|
if (which === "dump") {
|
|
args["output-directory"] = fs.join(instanceInfo.tmpDataDir, "dump");
|
|
exe = fs.join("bin", "arangodump");
|
|
} else {
|
|
args["create-database"] = "true";
|
|
args["input-directory"] = fs.join(instanceInfo.tmpDataDir, "dump");
|
|
exe = fs.join("bin", "arangorestore");
|
|
}
|
|
|
|
return executeAndWait(exe, toArgv(args));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief runs arangob
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function runArangoBenchmark(options, instanceInfo, cmds) {
|
|
let args = {
|
|
"configuration": "none",
|
|
"server.username": options.username,
|
|
"server.password": options.password,
|
|
"server.endpoint": instanceInfo.endpoint,
|
|
// "server.request-timeout": 1200 // default now.
|
|
"server.connect-timeout": 10 // 5s default
|
|
};
|
|
|
|
args = _.extend(args, cmds);
|
|
|
|
if (!args.hasOwnProperty('verbose')) {
|
|
args.quiet = true;
|
|
}
|
|
|
|
const exe = fs.join("bin", "arangob");
|
|
return executeAndWait(exe, toArgv(args));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief shuts down an instance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function shutdownInstance(instanceInfo, options) {
|
|
if (!checkInstanceAlive(instanceInfo, options)) {
|
|
print("Server already dead, doing nothing. This shouldn't happen?");
|
|
}
|
|
|
|
if (options.valgrind) {
|
|
waitOnServerForGC(instanceInfo, options, 60);
|
|
}
|
|
|
|
if (options.cluster) {
|
|
let rc = instanceInfo.kickstarter.shutdown();
|
|
|
|
if (!options.skipLogAnalysis) {
|
|
instanceInfo.importantLogLines = readImportantLogLines(instanceInfo.tmpDataDir);
|
|
}
|
|
|
|
if (options.cleanup) {
|
|
instanceInfo.kickstarter.cleanup();
|
|
}
|
|
|
|
if (rc.error && rc.results !== undefined) {
|
|
for (let i = 0; i < rc.results.length; ++i) {
|
|
if (rc.results[i].hasOwnProperty('isStartServers') &&
|
|
(rc.results[i].isStartServers === true)) {
|
|
for (let serverState in rc.results[i].serverStates) {
|
|
if (rc.results[i].serverStates.hasOwnProperty(serverState)) {
|
|
if ((rc.results[i].serverStates[serverState].status === "NOT-FOUND") ||
|
|
(rc.results[i].serverStates[serverState].hasOwnProperty('signal'))) {
|
|
print("Server " + serverState + " shut down with:\n" +
|
|
yaml.safeDump(rc.results[i].serverStates[serverState]));
|
|
|
|
if (!serverCrashed) {
|
|
print("marking run as crashy");
|
|
serverCrashed = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
killExternal(instanceInfo.dispatcherPid);
|
|
}
|
|
|
|
// single server
|
|
else {
|
|
if (typeof(instanceInfo.exitStatus) === 'undefined') {
|
|
download(instanceInfo.url + "/_admin/shutdown", "",
|
|
makeAuthorizationHeaders(options));
|
|
|
|
print("Waiting for server shut down");
|
|
|
|
let count = 0;
|
|
let bar = "[";
|
|
|
|
while (true) {
|
|
instanceInfo.exitStatus = statusExternal(instanceInfo.pid, false);
|
|
if (instanceInfo.exitStatus.status === "RUNNING") {
|
|
++count;
|
|
|
|
if (options.valgrind) {
|
|
wait(1);
|
|
continue;
|
|
}
|
|
|
|
if (count % 10 === 0) {
|
|
bar = bar + "#";
|
|
}
|
|
|
|
if (count > 600) {
|
|
print("forcefully terminating " + yaml.safeDump(instanceInfo.pid) +
|
|
" after 600 s grace period; marking crashy.");
|
|
serverCrashed = true;
|
|
killExternal(instanceInfo.pid);
|
|
break;
|
|
} else {
|
|
wait(1);
|
|
}
|
|
} else if (instanceInfo.exitStatus.status !== "TERMINATED") {
|
|
if (instanceInfo.exitStatus.hasOwnProperty('signal')) {
|
|
print("Server shut down with : " +
|
|
yaml.safeDump(instanceInfo.exitStatus) +
|
|
" marking build as crashy.");
|
|
|
|
serverCrashed = true;
|
|
break;
|
|
}
|
|
if (require("internal").platform.substr(0, 3) === 'win') {
|
|
// Windows: wait for procdump to do its job...
|
|
statusExternal(instanceInfo.monitor, true);
|
|
}
|
|
} else {
|
|
print("Server shutdown: Success.");
|
|
break; // Success.
|
|
}
|
|
}
|
|
|
|
if (count > 10) {
|
|
print("long Server shutdown: " + bar + ']');
|
|
}
|
|
} else {
|
|
print("Server already dead, doing nothing.");
|
|
}
|
|
|
|
if (!options.skipLogAnalysis) {
|
|
instanceInfo.importantLogLines =
|
|
readImportantLogLines(instanceInfo.tmpDataDir);
|
|
}
|
|
}
|
|
|
|
cleanupDirectories = cleanupDirectories.concat(
|
|
instanceInfo.tmpDataDir, instanceInfo.flatTmpDataDir);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief starts a dispatcher
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function startDispatcher(instanceInfo) {
|
|
const cmd = fs.join("bin", "arangod");
|
|
|
|
let args = {};
|
|
|
|
args["configuration"] = "none";
|
|
|
|
args["cluster.agent-path"] = fs.join("bin", "etcd-arango");
|
|
|
|
args["cluster.arangod-path"] = fs.join("bin", "arangod");
|
|
|
|
args["cluster.coordinator-config"] =
|
|
fs.join("etc", "relative", "arangod-coordinator.conf");
|
|
|
|
args["cluster.dbserver-config"] =
|
|
fs.join("etc", "relative", "arangod-dbserver.conf");
|
|
|
|
args["cluster.disable-dispatcher-frontend"] = "false";
|
|
|
|
args["cluster.disable-dispatcher-kickstarter"] = "false";
|
|
|
|
args["cluster.data-path"] = "cluster";
|
|
|
|
args["cluster.log-path"] = "cluster";
|
|
|
|
args["database.directory"] =
|
|
fs.join(instanceInfo.flatTmpDataDir, "dispatcher");
|
|
|
|
args["log.file"] =
|
|
fs.join(instanceInfo.flatTmpDataDir, "dispatcher.log");
|
|
|
|
args["server.endpoint"] = arango.getEndpoint();
|
|
|
|
args["javascript.startup-directory"] = "js";
|
|
|
|
args["javascript.app-path"] = fs.join("js", "apps");
|
|
|
|
instanceInfo.dispatcherPid = executeExternal(cmd, toArgv(args));
|
|
|
|
while (arango.GET("/_admin/version").error === true) {
|
|
print("Waiting for dispatcher to appear");
|
|
sleep(1);
|
|
}
|
|
|
|
print("Dispatcher is ready");
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief starts an instance
|
|
///
|
|
/// protocol must be one of ["tcp", "ssl", "unix"]
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function startInstanceCluster(instanceInfo, protocol, options, optionsExtraArgs,
|
|
addArgs, testname, appDir, tmpDataDir) {
|
|
startDispatcher(instanceInfo, options);
|
|
|
|
const clusterNodes = options.clusterNodes;
|
|
|
|
let extraArgs = makeArgsArangod(options, appDir);
|
|
extraArgs = _.extend(extraArgs, optionsExtraArgs);
|
|
|
|
if (addArgs !== undefined) {
|
|
extraArgs = _.extend(extraArgs, addArgs);
|
|
}
|
|
|
|
const dispatcher = {
|
|
"endpoint": "tcp://127.0.0.1:",
|
|
"arangodExtraArgs": toArgv(extraArgs),
|
|
"username": "root",
|
|
"password": ""
|
|
};
|
|
|
|
print("Temporary cluster data and logs are in", tmpDataDir);
|
|
|
|
let runInValgrind = "";
|
|
let testfn = "";
|
|
|
|
if (options.valgrind) {
|
|
runInValgrind = options.valgrind;
|
|
|
|
testfn = options.valgrindXmlFileBase;
|
|
|
|
if (testfn.length > 0) {
|
|
testfn += '_';
|
|
}
|
|
|
|
testfn += "cluster";
|
|
}
|
|
|
|
let valgrindHosts = '';
|
|
|
|
if (options.valgrindHosts) {
|
|
if (options.valgrindHosts.Coordinator === true) {
|
|
valgrindHosts += 'Coordinator';
|
|
}
|
|
|
|
if (options.valgrindHosts.DBServer === true) {
|
|
valgrindHosts += 'DBserver';
|
|
}
|
|
}
|
|
|
|
let valgrindOpts = {};
|
|
|
|
if (options.valgrindArgs) {
|
|
valgrindOpts = options.valgrindArgs;
|
|
}
|
|
|
|
let plan = new Planner({
|
|
"numberOfDBservers": clusterNodes,
|
|
"numberOfCoordinators": 1,
|
|
"dispatchers": {
|
|
"me": dispatcher
|
|
},
|
|
"dataPath": tmpDataDir,
|
|
"logPath": tmpDataDir,
|
|
"useSSLonCoordinators": protocol === "ssl",
|
|
"valgrind": runInValgrind,
|
|
"valgrindOpts": toArgv(valgrindOpts, true),
|
|
"valgrindXmlFileBase": testfn,
|
|
"valgrindTestname": testname,
|
|
"valgrindHosts": valgrindHosts,
|
|
"extremeVerbosity": options.extremeVerbosity
|
|
});
|
|
|
|
instanceInfo.kickstarter = new Kickstarter(plan.getPlan());
|
|
|
|
let rc = instanceInfo.kickstarter.launch();
|
|
|
|
if (rc.error) {
|
|
print("Cluster startup failed: " + rc.errorMessage);
|
|
return false;
|
|
}
|
|
|
|
let runInfo = instanceInfo.kickstarter.runInfo;
|
|
let j = runInfo.length - 1;
|
|
|
|
while (j > 0 && runInfo[j].isStartServers === undefined) {
|
|
--j;
|
|
}
|
|
|
|
if ((runInfo.length === 0) || (runInfo[0].error === true)) {
|
|
let error = new Error();
|
|
error.errorMessage = yaml.safeDump(runInfo);
|
|
throw error;
|
|
}
|
|
|
|
let roles = runInfo[j].roles;
|
|
let endpoints = runInfo[j].endpoints;
|
|
let pos = roles.indexOf("COORDINATOR");
|
|
|
|
instanceInfo.endpoint = endpoints[pos];
|
|
|
|
return true;
|
|
}
|
|
|
|
function valgrindArgsSingleServer(options, testname, run) {
|
|
let valgrindOpts = {};
|
|
|
|
if (options.valgrindArgs) {
|
|
valgrindOpts = options.valgrindArgs;
|
|
}
|
|
|
|
let testfn = options.valgrindXmlFileBase;
|
|
|
|
if (testfn.length > 0) {
|
|
testfn += '_';
|
|
}
|
|
|
|
testfn += testname;
|
|
|
|
valgrindOpts["xml-file"] = testfn + '.%p.xml';
|
|
valgrindOpts["log-file"] = testfn + '.%p.valgrind.log';
|
|
|
|
return toArgv(valgrindOpts, true).concat([run]);
|
|
}
|
|
|
|
function startInstanceSingleServer(instanceInfo, protocol, options, optionsExtraArgs,
|
|
addArgs, testname, appDir, tmpDataDir) {
|
|
const port = findFreePort();
|
|
instanceInfo.port = port;
|
|
|
|
const endpoint = protocol + "://127.0.0.1:" + port;
|
|
instanceInfo.endpoint = endpoint;
|
|
|
|
let td = fs.join(tmpDataDir, "data");
|
|
fs.makeDirectoryRecursive(td);
|
|
|
|
let args = makeArgsArangod(options, appDir);
|
|
args["server.endpoint"] = endpoint;
|
|
args["database.directory"] = td;
|
|
args["log.file"] = fs.join(tmpDataDir, "log");
|
|
|
|
if (protocol === "ssl") {
|
|
args["server.keyfile"] = fs.join("UnitTests", "server.pem");
|
|
}
|
|
|
|
args = _.extend(args, optionsExtraArgs);
|
|
|
|
if (addArgs !== undefined) {
|
|
args = _.extend(args, addArgs);
|
|
}
|
|
|
|
const run = fs.join("bin", "arangod");
|
|
|
|
if (options.valgrind) {
|
|
const valgrindArgs = valgrindArgsSingleServer(options, testname, run);
|
|
const newargs = valgrindArgs.concat(toArgv(args));
|
|
|
|
instanceInfo.pid = executeExternal(options.valgrind, newargs);
|
|
} else {
|
|
instanceInfo.pid = executeExternal(run, toArgv(args));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function startInstance(protocol, options, addArgs, testname, tmpDir) {
|
|
const startTime = time();
|
|
const topDir = findTopDir();
|
|
|
|
let instanceInfo = {};
|
|
instanceInfo.topDir = topDir;
|
|
|
|
// create temporary directories
|
|
instanceInfo.flatTmpDataDir = tmpDir || fs.getTempFile();
|
|
|
|
const tmpDataDir = fs.join(instanceInfo.flatTmpDataDir, testname);
|
|
const appDir = fs.join(tmpDataDir, "apps");
|
|
|
|
fs.makeDirectoryRecursive(tmpDataDir);
|
|
instanceInfo.tmpDataDir = tmpDataDir;
|
|
|
|
// build extra / valgrind arguments
|
|
let optionsExtraArgs = {};
|
|
|
|
if (typeof(options.extraArgs) === 'object') {
|
|
optionsExtraArgs = options.extraArgs;
|
|
}
|
|
|
|
// startup in cluster mode
|
|
let res = false;
|
|
|
|
if (options.cluster) {
|
|
res = startInstanceCluster(instanceInfo, protocol, options, optionsExtraArgs,
|
|
addArgs, testname, appDir, tmpDataDir);
|
|
}
|
|
|
|
// single instance mode
|
|
else {
|
|
res = startInstanceSingleServer(instanceInfo, protocol, options, optionsExtraArgs,
|
|
addArgs, testname, appDir, tmpDataDir);
|
|
}
|
|
|
|
if (!res) {
|
|
return false;
|
|
}
|
|
|
|
// wait until the server/coordinator is up:
|
|
let count = 0;
|
|
|
|
const url = endpointToURL(instanceInfo.endpoint);
|
|
instanceInfo.url = url;
|
|
|
|
while (true) {
|
|
wait(0.5, false);
|
|
|
|
const reply = download(url + "/_api/version", "", makeAuthorizationHeaders(options));
|
|
|
|
if (!reply.error && reply.code === 200) {
|
|
break;
|
|
}
|
|
|
|
++count;
|
|
|
|
if (count % 60 === 0) {
|
|
if (!checkInstanceAlive(instanceInfo, options)) {
|
|
print("startup failed! bailing out!");
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
print("up and running in " + (time() - startTime) + " seconds");
|
|
|
|
if (!options.cluster && (require("internal").platform.substr(0, 3) === 'win')) {
|
|
const procdumpArgs = [
|
|
'-accepteula',
|
|
'-e',
|
|
'-ma',
|
|
instanceInfo.pid.pid,
|
|
fs.join(tmpDataDir, 'core.dmp')
|
|
];
|
|
|
|
try {
|
|
instanceInfo.monitor = executeExternal('procdump', procdumpArgs);
|
|
} catch (x) {
|
|
print("failed to start procdump - is it installed?");
|
|
throw x;
|
|
}
|
|
}
|
|
|
|
return instanceInfo;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief runs ruby tests using RSPEC
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function camelize(str) {
|
|
return str.replace(/(?:^\w|[A-Z]|\b\w)/g, function(letter, index) {
|
|
return index === 0 ? letter.toLowerCase() : letter.toUpperCase();
|
|
}).replace(/\s+/g, '');
|
|
}
|
|
|
|
function rubyTests(options, ssl) {
|
|
let instanceInfo;
|
|
|
|
if (ssl) {
|
|
instanceInfo = startInstance("ssl", options, {}, "ssl_server");
|
|
} else {
|
|
instanceInfo = startInstance("tcp", options, {}, "http_server");
|
|
}
|
|
|
|
if (instanceInfo === false) {
|
|
return {
|
|
status: false,
|
|
message: "failed to start server!"
|
|
};
|
|
}
|
|
|
|
const 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');
|
|
|
|
const logsdir = fs.join(findTopDir(), "logs");
|
|
|
|
try {
|
|
fs.makeDirectory(logsdir);
|
|
} catch (err) {}
|
|
|
|
const files = fs.list(fs.join("UnitTests", "HttpInterface"));
|
|
|
|
let continueTesting = true;
|
|
let filtered = {};
|
|
let result = {};
|
|
|
|
let args;
|
|
let command;
|
|
|
|
if (require("internal").platform.substr(0, 3) === 'win') {
|
|
command = "rspec.bat";
|
|
} else {
|
|
command = "rspec";
|
|
}
|
|
|
|
const parseRspecJson = function(testCase, res, totalDuration) {
|
|
let tName = camelize(testCase.description);
|
|
let status = (testCase.status === "passed");
|
|
|
|
res[tName] = {
|
|
status: status,
|
|
message: testCase.full_description,
|
|
duration: totalDuration // RSpec doesn't offer per testcase time...
|
|
};
|
|
|
|
res.total++;
|
|
|
|
if (!status) {
|
|
const msg = yaml.safeDump(testCase)
|
|
.replace(/.*rspec\/core.*\n/gm, "")
|
|
.replace(/.*rspec\\core.*\n/gm, "");
|
|
print("RSpec test case falied: \n" + msg);
|
|
res[tName].message += "\n" + msg;
|
|
}
|
|
};
|
|
|
|
for (let i = 0; i < files.length; i++) {
|
|
const te = files[i];
|
|
|
|
if (te.substr(0, 4) === "api-" && te.substr(-3) === ".rb") {
|
|
if (filterTestcaseByOptions(te, options, filtered)) {
|
|
if (!continueTesting) {
|
|
print("Skipping " + te + " server is gone.");
|
|
|
|
result[te] = {
|
|
status: false,
|
|
message: instanceInfo.exitStatus
|
|
};
|
|
|
|
instanceInfo.exitStatus = "server is gone.";
|
|
break;
|
|
}
|
|
|
|
args = ["--color",
|
|
"-I", fs.join("UnitTests", "HttpInterface"),
|
|
"--format", "d",
|
|
"--format", "j",
|
|
"--out", fs.join("out", "UnitTests", te + ".json"),
|
|
"--require", tmpname,
|
|
fs.join("UnitTests", "HttpInterface", te)
|
|
];
|
|
|
|
print("\n" + Date() + " rspec trying", te, "...");
|
|
|
|
const res = executeAndWait(command, args);
|
|
|
|
result[te] = {
|
|
total: 0,
|
|
status: res.status
|
|
};
|
|
|
|
const resultfn = fs.join("out", "UnitTests", te + ".json");
|
|
|
|
try {
|
|
const jsonResult = JSON.parse(fs.read(resultfn));
|
|
|
|
if (options.extremeVerbosity) {
|
|
print(yaml.safeDump(jsonResult));
|
|
}
|
|
|
|
for (let j = 0; j < jsonResult.examples.length; ++j) {
|
|
parseRspecJson(jsonResult.examples[j], result[te],
|
|
jsonResult.summary.duration);
|
|
}
|
|
|
|
result[te].duration = jsonResult.summary.duration;
|
|
} catch (x) {
|
|
print("Failed to parse rspec result: " + x);
|
|
result[te]["complete_" + te] = res;
|
|
|
|
if (res.status === false) {
|
|
options.cleanup = false;
|
|
|
|
if (!options.force) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
continueTesting = checkInstanceAlive(instanceInfo, options);
|
|
} else {
|
|
if (options.extremeVerbosity) {
|
|
print("Skipped " + te + " because of " + filtered.filter);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
print("Shutting down...");
|
|
|
|
fs.remove(tmpname);
|
|
shutdownInstance(instanceInfo, options);
|
|
|
|
print("done.");
|
|
|
|
if ((!options.skipLogAnalysis) &&
|
|
instanceInfo.hasOwnProperty('importantLogLines') &&
|
|
Object.keys(instanceInfo.importantLogLines).length > 0) {
|
|
print("Found messages in the server logs: \n" +
|
|
yaml.safeDump(instanceInfo.importantLogLines));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief sort test-cases according to pathname
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
let testsCases = {
|
|
setup: false
|
|
};
|
|
|
|
function findTests() {
|
|
if (testsCases.setup) {
|
|
return;
|
|
}
|
|
|
|
testsCases.common = _.filter(fs.list(makePathUnix("js/common/tests/shell")),
|
|
function(p) {
|
|
return p.substr(-3) === ".js";
|
|
}).map(
|
|
function(x) {
|
|
return fs.join(makePathUnix("js/common/tests/shell"), x);
|
|
}).sort();
|
|
|
|
testsCases.server_only = _.filter(fs.list(makePathUnix("js/server/tests/shell")),
|
|
function(p) {
|
|
return p.substr(-3) === ".js";
|
|
}).map(
|
|
function(x) {
|
|
return fs.join(makePathUnix("js/server/tests/shell"), x);
|
|
}).sort();
|
|
|
|
testsCases.client_only = _.filter(fs.list(makePathUnix("js/client/tests/shell")),
|
|
function(p) {
|
|
return p.substr(-3) === ".js";
|
|
}).map(
|
|
function(x) {
|
|
return fs.join(makePathUnix("js/client/tests/shell"), x);
|
|
}).sort();
|
|
|
|
testsCases.server_aql = _.filter(fs.list(makePathUnix("js/server/tests/aql")),
|
|
function(p) {
|
|
return p.substr(-3) === ".js" && p.indexOf("ranges-combined") === -1;
|
|
}).map(
|
|
function(x) {
|
|
return fs.join(makePathUnix("js/server/tests/aql"), x);
|
|
}).sort();
|
|
|
|
testsCases.server_aql_extended =
|
|
_.filter(fs.list(makePathUnix("js/server/tests/aql")),
|
|
function(p) {
|
|
return p.substr(-3) === ".js" && p.indexOf("ranges-combined") !== -1;
|
|
}).map(
|
|
function(x) {
|
|
return fs.join(makePathUnix("js/server/tests/aql"), x);
|
|
}).sort();
|
|
|
|
testsCases.server_aql_performance =
|
|
_.filter(fs.list(makePathUnix("js/server/perftests")),
|
|
function(p) {
|
|
return p.substr(-3) === ".js";
|
|
}).map(
|
|
function(x) {
|
|
return fs.join(makePathUnix("js/server/perftests"), x);
|
|
}).sort();
|
|
|
|
testsCases.replication = _.filter(fs.list(makePathUnix("js/common/tests/replication")),
|
|
function(p) {
|
|
return p.substr(-3) === ".js";
|
|
}).map(
|
|
function(x) {
|
|
return fs.join(makePathUnix("js/common/tests/replication"), x);
|
|
}).sort();
|
|
|
|
testsCases.server = testsCases.common.concat(testsCases.server_only);
|
|
testsCases.client = testsCases.common.concat(testsCases.client_only);
|
|
|
|
testsCases.setup = true;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief filter test-cases according to options
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function filterTestcaseByOptions(testname, options, whichFilter) {
|
|
if (options.hasOwnProperty('test') && (typeof(options.test) !== 'undefined')) {
|
|
whichFilter.filter = 'testcase';
|
|
return testname === options.test;
|
|
}
|
|
|
|
if (options.replication) {
|
|
whichFilter.filter = 'replication';
|
|
return testname.indexOf('replication') !== -1;
|
|
} else if (testname.indexOf('replication') !== -1) {
|
|
whichFilter.filter = 'replication';
|
|
return false;
|
|
}
|
|
|
|
if ((testname.indexOf('-cluster') !== -1) && !options.cluster) {
|
|
whichFilter.filter = 'noncluster';
|
|
return false;
|
|
}
|
|
|
|
if (testname.indexOf('-noncluster') !== -1 && options.cluster) {
|
|
whichFilter.filter = 'cluster';
|
|
return false;
|
|
}
|
|
|
|
if (testname.indexOf('-timecritical') !== -1 && options.skipTimeCritical) {
|
|
whichFilter.filter = 'timecritical';
|
|
return false;
|
|
}
|
|
|
|
if (testname.indexOf('-nightly') !== -1 && options.skipNightly && !options.onlyNightly) {
|
|
whichFilter.filter = 'skip nightly';
|
|
return false;
|
|
}
|
|
|
|
if (testname.indexOf('-geo') !== -1 && options.skipGeo) {
|
|
whichFilter.filter = 'geo';
|
|
return false;
|
|
}
|
|
|
|
if (testname.indexOf('-nondeterministic') !== -1 && options.skipNondeterministic) {
|
|
whichFilter.filter = 'nondeterministic';
|
|
return false;
|
|
}
|
|
|
|
if (testname.indexOf('-graph') !== -1 && options.skipGraph) {
|
|
whichFilter.filter = 'graph';
|
|
return false;
|
|
}
|
|
|
|
if (testname.indexOf('-disabled') !== -1) {
|
|
whichFilter.filter = 'disabled';
|
|
return false;
|
|
}
|
|
|
|
if ((testname.indexOf('-memoryintense') !== -1) && options.skipMemoryIntense) {
|
|
whichFilter.filter = 'memoryintense';
|
|
return false;
|
|
}
|
|
|
|
if (testname.indexOf('-nightly') === -1 && options.onlyNightly) {
|
|
whichFilter.filter = 'only nightly';
|
|
return false;
|
|
}
|
|
|
|
if ((testname.indexOf('-novalgrind') !== -1) && options.valgrind) {
|
|
whichFilter.filter = 'skip in valgrind';
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test functions for all
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
let allTests = [
|
|
"arangosh",
|
|
"authentication",
|
|
"authentication_parameters",
|
|
"boost",
|
|
"config",
|
|
"dump",
|
|
"dump_authentication",
|
|
"dfdb",
|
|
"http_server",
|
|
"importing",
|
|
"shell_client",
|
|
"shell_server",
|
|
"shell_server_aql",
|
|
"ssl_server",
|
|
"upgrade",
|
|
"arangob"
|
|
];
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief internal members of the results
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
const internalMembers = [
|
|
"code",
|
|
"error",
|
|
"status",
|
|
"duration",
|
|
"failed",
|
|
"total",
|
|
"crashed",
|
|
"ok",
|
|
"message",
|
|
"suiteName"
|
|
];
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: all
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
let testFuncs = {
|
|
'all': function() {}
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: arangosh
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.arangosh = function(options) {
|
|
const arangosh = fs.join("bin", "arangosh");
|
|
|
|
let failed = 0;
|
|
let args = makeArgsArangosh(options);
|
|
|
|
let ret = {
|
|
"ArangoshExitCodeTest": {
|
|
"testArangoshExitCodeFail": {},
|
|
"testArangoshExitCodeSuccess": {},
|
|
"total": 2,
|
|
"duration": 0.0
|
|
}
|
|
};
|
|
|
|
// termination by throw
|
|
print("Starting arangosh with exception throwing script:");
|
|
args["javascript.execute-string"] = "throw('foo')";
|
|
|
|
const startTime = time();
|
|
let rc = executeExternalAndWait(arangosh, toArgv(args));
|
|
const deltaTime = time() - startTime;
|
|
const failSuccess = (rc.hasOwnProperty('exit') && rc.exit === 1);
|
|
|
|
if (!failSuccess) {
|
|
ret.ArangoshExitCodeTest.testArangoshExitCodeFail['message'] =
|
|
"didn't get expected return code (1): \n" +
|
|
yaml.safeDump(rc);
|
|
++failed;
|
|
}
|
|
|
|
ret.ArangoshExitCodeTest.testArangoshExitCodeFail['status'] = failSuccess;
|
|
ret.ArangoshExitCodeTest.testArangoshExitCodeFail['duration'] = deltaTime;
|
|
print("Status: " + ((failSuccess) ? "SUCCESS" : "FAIL") + "\n");
|
|
|
|
// regular termination
|
|
print("Starting arangosh with regular terminating script:");
|
|
args["javascript.execute-string"] = ";";
|
|
|
|
const startTime2 = time();
|
|
rc = executeExternalAndWait(arangosh, toArgv(args));
|
|
const deltaTime2 = time() - startTime2;
|
|
|
|
const successSuccess = (rc.hasOwnProperty('exit') && rc.exit === 0);
|
|
|
|
if (!successSuccess) {
|
|
ret.ArangoshExitCodeTest.testArangoshExitCodeFail['message'] =
|
|
"didn't get expected return code (0): \n" +
|
|
yaml.safeDump(rc);
|
|
|
|
++failed;
|
|
}
|
|
|
|
ret.ArangoshExitCodeTest.testArangoshExitCodeSuccess['status'] = failSuccess;
|
|
ret.ArangoshExitCodeTest.testArangoshExitCodeSuccess['duration'] = deltaTime2;
|
|
print("Status: " + ((successSuccess) ? "SUCCESS" : "FAIL") + "\n");
|
|
|
|
// return result
|
|
ret.ArangoshExitCodeTest.status = failSuccess && successSuccess;
|
|
ret.ArangoshExitCodeTest.duration = deltaTime + deltaTime2;
|
|
return ret;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: arangob
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
const benchTodos = [{
|
|
"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) {
|
|
if (options.skipArangoB === true) {
|
|
print("skipping Benchmark tests!");
|
|
return {
|
|
arangob: {
|
|
status: true,
|
|
skipped: true
|
|
}
|
|
};
|
|
}
|
|
|
|
print("arangob tests...");
|
|
|
|
let instanceInfo = startInstance("tcp", options, {}, "arangob");
|
|
|
|
if (instanceInfo === false) {
|
|
return {
|
|
arangob: {
|
|
status: false,
|
|
message: "failed to start server!"
|
|
}
|
|
};
|
|
}
|
|
|
|
let results = {
|
|
arangob: {
|
|
status: true,
|
|
total: 0
|
|
}
|
|
};
|
|
|
|
let continueTesting = true;
|
|
|
|
for (let i = 0; i < benchTodos.length; i++) {
|
|
const benchTodo = benchTodos[i];
|
|
|
|
if ((options.skipArangoBNonConnKeepAlive) &&
|
|
benchTodo.hasOwnProperty('keep-alive') &&
|
|
(benchTodo['keep-alive'] === "false")) {
|
|
benchTodo['keep-alive'] = true;
|
|
}
|
|
|
|
// On the cluster we do not yet have working transaction functionality:
|
|
if (!options.cluster ||
|
|
(benchTodo.test !== "counttrx" &&
|
|
benchTodo.test !== "multitrx")) {
|
|
|
|
if (!continueTesting) {
|
|
print("Skipping " + benchTodo + ", server is gone.");
|
|
|
|
results.arangob[i] = {
|
|
status: false,
|
|
message: instanceInfo.exitStatus
|
|
};
|
|
|
|
instanceInfo.exitStatus = "server is gone.";
|
|
|
|
break;
|
|
}
|
|
|
|
let args = benchTodo;
|
|
|
|
if (options.hasOwnProperty('benchargs')) {
|
|
args = _.extend(args, options.benchargs);
|
|
}
|
|
|
|
let oneResult = runArangoBenchmark(options, instanceInfo, args);
|
|
|
|
results.arangob[i] = oneResult;
|
|
results.arangob.total++;
|
|
|
|
if (!results.arangob[i].status) {
|
|
results.arangob.status = false;
|
|
}
|
|
|
|
continueTesting = checkInstanceAlive(instanceInfo, options);
|
|
|
|
if (oneResult.status !== true && !options.force) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo, options);
|
|
print("done.");
|
|
|
|
if ((!options.skipLogAnalysis) &&
|
|
instanceInfo.hasOwnProperty('importantLogLines') &&
|
|
Object.keys(instanceInfo.importantLogLines).length > 0) {
|
|
print("Found messages in the server logs: \n" +
|
|
yaml.safeDump(instanceInfo.importantLogLines));
|
|
}
|
|
|
|
return results;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: authentication
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.authentication = function(options) {
|
|
if (options.skipAuth === true) {
|
|
print("skipping Authentication tests!");
|
|
|
|
return {
|
|
authentication: {
|
|
status: true,
|
|
skipped: true
|
|
}
|
|
};
|
|
}
|
|
|
|
print("Authentication tests...");
|
|
|
|
let instanceInfo = startInstance("tcp", options, {
|
|
"server.disable-authentication": "false"
|
|
}, "authentication");
|
|
|
|
if (instanceInfo === false) {
|
|
return {
|
|
authentication: {
|
|
status: false,
|
|
message: "failed to start server!"
|
|
}
|
|
};
|
|
}
|
|
|
|
let results = {};
|
|
|
|
results.authentication = runInArangosh(options, instanceInfo,
|
|
fs.join("js", "client", "tests", "auth.js"));
|
|
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo, options);
|
|
print("done.");
|
|
|
|
if ((!options.skipLogAnalysis) &&
|
|
instanceInfo.hasOwnProperty('importantLogLines') &&
|
|
Object.keys(instanceInfo.importantLogLines).length > 0) {
|
|
print("Found messages in the server logs: \n" +
|
|
yaml.safeDump(instanceInfo.importantLogLines));
|
|
}
|
|
|
|
return results;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: authentication parameters
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
const authTestExpectRC = [
|
|
[401, 401, 401, 401, 401, 401, 401],
|
|
[401, 401, 401, 401, 401, 404, 404],
|
|
[404, 404, 200, 301, 301, 404, 404]
|
|
];
|
|
|
|
const authTestUrls = [
|
|
"/_api/",
|
|
"/_api",
|
|
"/_api/version",
|
|
"/_admin/html",
|
|
"/_admin/html/",
|
|
"/test",
|
|
"/the-big-fat-fox"
|
|
];
|
|
|
|
const authTestNames = [
|
|
"Full",
|
|
"SystemAuth",
|
|
"None"
|
|
];
|
|
|
|
const authTestServerParams = [{
|
|
"server.disable-authentication": "false",
|
|
"server.authenticate-system-only": "false"
|
|
}, {
|
|
"server.disable-authentication": "false",
|
|
"server.authenticate-system-only": "true"
|
|
}, {
|
|
"server.disable-authentication": "true",
|
|
"server.authenticate-system-only": "true"
|
|
}];
|
|
|
|
function checkBodyForJsonToParse(request) {
|
|
if (request.hasOwnProperty('body')) {
|
|
request.body = JSON.parse(request.hasOwnProperty('body'));
|
|
}
|
|
}
|
|
|
|
testFuncs.authentication_parameters = function(options) {
|
|
if (options.skipAuth === true) {
|
|
print("skipping Authentication with parameters tests!");
|
|
return {
|
|
authentication_parameters: {
|
|
status: true,
|
|
skipped: true
|
|
}
|
|
};
|
|
}
|
|
|
|
print("Authentication with parameters tests...");
|
|
|
|
let downloadOptions = {
|
|
followRedirects: false,
|
|
returnBodyOnError: true
|
|
};
|
|
|
|
if (options.valgrind) {
|
|
downloadOptions.timeout = 300;
|
|
}
|
|
|
|
let continueTesting = true;
|
|
let results = {};
|
|
|
|
for (let test = 0; test < 3; test++) {
|
|
let instanceInfo = startInstance("tcp", options,
|
|
authTestServerParams[test],
|
|
"authentication_parameters_" + authTestNames[test]);
|
|
|
|
if (instanceInfo === false) {
|
|
return {
|
|
authentication_parameters: {
|
|
status: false,
|
|
total: 1,
|
|
failed: 1,
|
|
message: authTestNames[test] + ": failed to start server!"
|
|
}
|
|
};
|
|
}
|
|
|
|
print(Date() + " Starting " + authTestNames[test] + " test");
|
|
|
|
const testName = 'auth_' + authTestNames[test];
|
|
results[testName] = {
|
|
failed: 0,
|
|
total: 0
|
|
};
|
|
|
|
for (let i = 0; i < authTestUrls.length; i++) {
|
|
const authTestUrl = authTestUrls[i];
|
|
|
|
++results[testName].total;
|
|
|
|
print(" URL: " + instanceInfo.url + authTestUrl);
|
|
|
|
if (!continueTesting) {
|
|
print("Skipping " + authTestUrl + ", server is gone.");
|
|
|
|
results[testName][authTestUrl] = {
|
|
status: false,
|
|
message: instanceInfo.exitStatus
|
|
};
|
|
|
|
results[testName].failed++;
|
|
instanceInfo.exitStatus = "server is gone.";
|
|
|
|
break;
|
|
}
|
|
|
|
let reply = download(instanceInfo.url + authTestUrl, "", downloadOptions);
|
|
|
|
if (reply.code === authTestExpectRC[test][i]) {
|
|
results[testName][authTestUrl] = {
|
|
status: true
|
|
};
|
|
} else {
|
|
checkBodyForJsonToParse(reply);
|
|
|
|
++results[testName].failed;
|
|
|
|
results[testName][authTestUrl] = {
|
|
status: false,
|
|
message: "we expected " +
|
|
authTestExpectRC[test][i] +
|
|
" and we got " + reply.code +
|
|
" Full Status: " + yaml.safeDump(reply)
|
|
};
|
|
}
|
|
|
|
continueTesting = checkInstanceAlive(instanceInfo, options);
|
|
}
|
|
|
|
results[testName].status = results[testName].failed === 0;
|
|
|
|
print("Shutting down " + authTestNames[test] + " test...");
|
|
shutdownInstance(instanceInfo, options);
|
|
|
|
if ((!options.skipLogAnalysis) &&
|
|
instanceInfo.hasOwnProperty('importantLogLines') &&
|
|
(instanceInfo.importantLogLines.length > 0)) {
|
|
print("Found messages in the server logs: \n" +
|
|
yaml.safeDump(instanceInfo.importantLogLines));
|
|
}
|
|
|
|
print("done with " + authTestNames[test] + " test.");
|
|
}
|
|
|
|
return results;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: boost
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.boost = function(options) {
|
|
const topDir = findTopDir();
|
|
const args = ["--show_progress"];
|
|
|
|
let results = {};
|
|
|
|
if (!options.skipBoost) {
|
|
const run = fs.join(topDir, "UnitTests", "basics_suite");
|
|
|
|
if (options.valgrind) {
|
|
const valgrindArgs = valgrindArgsSingleServer(options, "basics", run);
|
|
const newargs = valgrindArgs.concat(args);
|
|
|
|
results.basics = executeAndWait(options.valgrind, newargs);
|
|
} else {
|
|
results.basics = executeAndWait(run, args);
|
|
}
|
|
}
|
|
|
|
if (!options.skipGeo) {
|
|
const run = fs.join(topDir, "UnitTests", "geo_suite");
|
|
|
|
if (options.valgrind) {
|
|
const valgrindArgs = valgrindArgsSingleServer(options, "geo_suite", run);
|
|
const newargs = valgrindArgs.concat(args);
|
|
|
|
results.geo_suite = executeAndWait(options.valgrind, newargs);
|
|
} else {
|
|
results.geo_suite = executeAndWait(run, args);
|
|
}
|
|
}
|
|
|
|
return results;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: config
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.config = function(options) {
|
|
if (options.skipConfig) {
|
|
return {
|
|
config: {
|
|
status: true,
|
|
skipped: true
|
|
}
|
|
};
|
|
}
|
|
|
|
let results = {
|
|
absolut: {
|
|
status: true,
|
|
total: 0
|
|
},
|
|
relative: {
|
|
status: true,
|
|
total: 0
|
|
}
|
|
};
|
|
|
|
const topDir = findTopDir();
|
|
|
|
const ts = ["arangod",
|
|
"arangob",
|
|
"arangodump",
|
|
"arangoimp",
|
|
"arangorestore",
|
|
"arangosh"
|
|
];
|
|
|
|
print("--------------------------------------------------------------------------------");
|
|
print("absolute config tests");
|
|
print("--------------------------------------------------------------------------------");
|
|
|
|
for (let i = 0; i < ts.length; i++) {
|
|
const test = ts[i];
|
|
|
|
const args = {
|
|
"configuration": fs.join(topDir, "etc", "arangodb", test + ".conf"),
|
|
"flatCommands": ["--help"]
|
|
};
|
|
|
|
const run = fs.join(topDir, "bin", test);
|
|
|
|
if (options.valgrind) {
|
|
const valgrindArgs = valgrindArgsSingleServer(options, test, run);
|
|
const newargs = valgrindArgs.concat(toArgv(args));
|
|
|
|
results.absolut[test] = executeAndWait(options.valgrind, newargs);
|
|
} else {
|
|
results.absolut[test] = executeAndWait(run, toArgv(args));
|
|
}
|
|
|
|
if (!results.absolut[test].status) {
|
|
results.absolut.status = false;
|
|
}
|
|
|
|
results.absolut.total++;
|
|
|
|
print("Args for [" + test + "]:");
|
|
print(yaml.safeDump(args));
|
|
print("Result: " + results.absolut[test].status);
|
|
}
|
|
|
|
print("--------------------------------------------------------------------------------");
|
|
print("relative config tests");
|
|
print("--------------------------------------------------------------------------------");
|
|
|
|
for (let i = 0; i < ts.length; i++) {
|
|
const test = ts[i];
|
|
|
|
const args = {
|
|
"configuration": fs.join(topDir, "etc", "relative", test + ".conf"),
|
|
"flatCommands": ["--help"]
|
|
};
|
|
|
|
const run = fs.join(topDir, "bin", test);
|
|
|
|
if (options.valgrind) {
|
|
const valgrindArgs = valgrindArgsSingleServer(options, test, run);
|
|
const newargs = valgrindArgs.concat(toArgv(args));
|
|
|
|
results.relative[test] = executeAndWait(options.valgrind, newargs);
|
|
} else {
|
|
results.relative[test] = executeAndWait(run, toArgv(args));
|
|
}
|
|
|
|
results.relative[test] = executeAndWait(fs.join(topDir, "bin", test),
|
|
toArgv(args));
|
|
|
|
if (!results.relative[test].status) {
|
|
results.relative.status = false;
|
|
}
|
|
|
|
results.relative.total++;
|
|
|
|
print("Args for (relative) [" + test + "]:");
|
|
print(yaml.safeDump(args));
|
|
print("Result: " + results.relative[test].status);
|
|
}
|
|
|
|
return results;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: dfdb
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.dfdb = function(options) {
|
|
const topDir = findTopDir();
|
|
const dataDir = fs.getTempFile();
|
|
const args = ["-c", "etc/relative/arango-dfdb.conf", "--no-server", dataDir];
|
|
|
|
let results = {};
|
|
|
|
const run = fs.join(topDir, "bin", "arangod");
|
|
|
|
if (options.valgrind) {
|
|
const valgrindArgs = valgrindArgsSingleServer(options, "dfdb", run);
|
|
const newargs = valgrindArgs.concat(args);
|
|
|
|
results.dfdb = executeAndWait(options.valgrind, newargs);
|
|
} else {
|
|
results.dfdb = executeAndWait(run, args);
|
|
}
|
|
|
|
return results;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: dump
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.dump = function(options) {
|
|
let cluster;
|
|
|
|
if (options.cluster) {
|
|
cluster = "-cluster";
|
|
} else {
|
|
cluster = "";
|
|
}
|
|
|
|
print("dump tests...");
|
|
|
|
let instanceInfo = startInstance("tcp", options, {}, "dump");
|
|
|
|
if (instanceInfo === false) {
|
|
return {
|
|
dump: {
|
|
status: false,
|
|
message: "failed to start server!"
|
|
}
|
|
};
|
|
}
|
|
|
|
print(Date() + ": Setting up");
|
|
|
|
let results = {};
|
|
results.setup = runInArangosh(options, instanceInfo,
|
|
makePathUnix("js/server/tests/dump/dump-setup" + cluster + ".js"));
|
|
|
|
if (checkInstanceAlive(instanceInfo, options) &&
|
|
(results.setup.status === true)) {
|
|
print(Date() + ": Dump and Restore - dump");
|
|
|
|
results.dump = runArangoDumpRestore(options, instanceInfo, "dump",
|
|
"UnitTestsDumpSrc");
|
|
|
|
if (checkInstanceAlive(instanceInfo, options) &&
|
|
(results.dump.status === true)) {
|
|
print(Date() + ": Dump and Restore - restore");
|
|
|
|
results.restore = runArangoDumpRestore(options, instanceInfo, "restore",
|
|
"UnitTestsDumpDst");
|
|
|
|
if (checkInstanceAlive(instanceInfo, options) &&
|
|
(results.restore.status === true)) {
|
|
print(Date() + ": Dump and Restore - dump after restore");
|
|
|
|
results.test = runInArangosh(options, instanceInfo,
|
|
makePathUnix("js/server/tests/dump/dump" + cluster + ".js"), {
|
|
"server.database": "UnitTestsDumpDst"
|
|
});
|
|
|
|
if (checkInstanceAlive(instanceInfo, options) &&
|
|
(results.test.status === true)) {
|
|
print(Date() + ": Dump and Restore - teardown");
|
|
|
|
results.tearDown = runInArangosh(options, instanceInfo,
|
|
makePathUnix("js/server/tests/dump/dump-teardown" + cluster + ".js"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo, options);
|
|
print("done.");
|
|
|
|
if ((!options.skipLogAnalysis) &&
|
|
instanceInfo.hasOwnProperty('importantLogLines') &&
|
|
Object.keys(instanceInfo.importantLogLines).length > 0) {
|
|
print("Found messages in the server logs: \n" +
|
|
yaml.safeDump(instanceInfo.importantLogLines));
|
|
}
|
|
|
|
return results;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: dump_authentication
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.dump_authentication = function(options) {
|
|
if (options.cluster) {
|
|
if (options.extremeVerbosity) {
|
|
print("Skipped because of cluster.");
|
|
}
|
|
|
|
return {
|
|
"dump_authentication": {
|
|
"status": true,
|
|
"message": "skipped because of cluster",
|
|
"skipped": true
|
|
}
|
|
};
|
|
}
|
|
|
|
print("dump_authentication tests...");
|
|
|
|
const auth = {
|
|
"server.disable-authentication": "false"
|
|
};
|
|
|
|
print(JSON.stringify(auth));
|
|
|
|
let instanceInfo = startInstance("tcp", options, auth, "dump_authentication");
|
|
|
|
if (instanceInfo === false) {
|
|
return {
|
|
"dump_authentication": {
|
|
status: false,
|
|
message: "failed to start server!"
|
|
}
|
|
};
|
|
}
|
|
|
|
print(Date() + ": Setting up");
|
|
|
|
let results = {};
|
|
results.setup = runInArangosh(options, instanceInfo,
|
|
makePathUnix("js/server/tests/dump/dump-authentication-setup.js"),
|
|
auth);
|
|
|
|
if (checkInstanceAlive(instanceInfo, options) &&
|
|
(results.setup.status === true)) {
|
|
print(Date() + ": Dump and Restore - dump");
|
|
|
|
let authOpts = {
|
|
username: "foobaruser",
|
|
password: "foobarpasswd"
|
|
};
|
|
|
|
_.defaults(authOpts, options);
|
|
|
|
results.dump = runArangoDumpRestore(authOpts, instanceInfo, "dump",
|
|
"UnitTestsDumpSrc");
|
|
|
|
if (checkInstanceAlive(instanceInfo, options) &&
|
|
(results.dump.status === true)) {
|
|
print(Date() + ": Dump and Restore - restore");
|
|
|
|
results.restore = runArangoDumpRestore(authOpts, instanceInfo, "restore",
|
|
"UnitTestsDumpDst");
|
|
|
|
if (checkInstanceAlive(instanceInfo, options) &&
|
|
(results.restore.status === true)) {
|
|
print(Date() + ": Dump and Restore - dump after restore");
|
|
|
|
results.test = runInArangosh(authOpts, instanceInfo,
|
|
makePathUnix("js/server/tests/dump/dump-authentication.js"), {
|
|
"server.database": "UnitTestsDumpDst"
|
|
});
|
|
|
|
if (checkInstanceAlive(instanceInfo, options) &&
|
|
(results.test.status === true)) {
|
|
print(Date() + ": Dump and Restore - teardown");
|
|
|
|
results.tearDown = runInArangosh(options, instanceInfo,
|
|
makePathUnix("js/server/tests/dump/dump-teardown.js"), auth);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo, options);
|
|
print("done.");
|
|
|
|
if ((!options.skipLogAnalysis) &&
|
|
instanceInfo.hasOwnProperty('importantLogLines') &&
|
|
Object.keys(instanceInfo.importantLogLines).length > 0) {
|
|
print("Found messages in the server logs: \n" +
|
|
yaml.safeDump(instanceInfo.importantLogLines));
|
|
}
|
|
|
|
return results;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: foxx manager
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.foxx_manager = function(options) {
|
|
print("foxx_manager tests...");
|
|
|
|
let instanceInfo = startInstance("tcp", options, {}, "foxx_manager");
|
|
|
|
if (instanceInfo === false) {
|
|
return {
|
|
foxx_manager: {
|
|
status: false,
|
|
message: "failed to start server!"
|
|
}
|
|
};
|
|
}
|
|
|
|
let results = {};
|
|
|
|
results.update = runArangoshCmd(options, instanceInfo, {
|
|
"configuration": "etc/relative/foxx-manager.conf"
|
|
}, ["update"]);
|
|
|
|
if (results.update.status === true || options.force) {
|
|
results.search = runArangoshCmd(options, instanceInfo, {
|
|
"configuration": "etc/relative/foxx-manager.conf"
|
|
}, ["search", "itzpapalotl"]);
|
|
}
|
|
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo, options);
|
|
print("done.");
|
|
|
|
if ((!options.skipLogAnalysis) &&
|
|
instanceInfo.hasOwnProperty('importantLogLines') &&
|
|
Object.keys(instanceInfo.importantLogLines).length > 0) {
|
|
print("Found messages in the server logs: \n" +
|
|
yaml.safeDump(instanceInfo.importantLogLines));
|
|
}
|
|
|
|
return results;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: http replication
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.http_replication = function(options) {
|
|
var opts = {
|
|
"replication": true
|
|
};
|
|
_.defaults(opts, options);
|
|
|
|
return rubyTests(opts, false);
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: http server
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.http_server = function(options) {
|
|
return rubyTests(options, false);
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: importing
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
const impTodos = [{
|
|
id: "json1",
|
|
data: makePathUnix("js/common/test-data/import/import-1.json"),
|
|
coll: "UnitTestsImportJson1",
|
|
type: "json",
|
|
create: undefined
|
|
}, {
|
|
id: "json2",
|
|
data: makePathUnix("js/common/test-data/import/import-2.json"),
|
|
coll: "UnitTestsImportJson2",
|
|
type: "json",
|
|
create: undefined
|
|
}, {
|
|
id: "json3",
|
|
data: makePathUnix("js/common/test-data/import/import-3.json"),
|
|
coll: "UnitTestsImportJson3",
|
|
type: "json",
|
|
create: undefined
|
|
}, {
|
|
id: "json4",
|
|
data: makePathUnix("js/common/test-data/import/import-4.json"),
|
|
coll: "UnitTestsImportJson4",
|
|
type: "json",
|
|
create: undefined
|
|
}, {
|
|
id: "json5",
|
|
data: makePathUnix("js/common/test-data/import/import-5.json"),
|
|
coll: "UnitTestsImportJson5",
|
|
type: "json",
|
|
create: undefined
|
|
}, {
|
|
id: "csv1",
|
|
data: makePathUnix("js/common/test-data/import/import-1.csv"),
|
|
coll: "UnitTestsImportCsv1",
|
|
type: "csv",
|
|
create: "true"
|
|
}, {
|
|
id: "csv2",
|
|
data: makePathUnix("js/common/test-data/import/import-2.csv"),
|
|
coll: "UnitTestsImportCsv2",
|
|
type: "csv",
|
|
create: "true"
|
|
}, {
|
|
id: "csv3",
|
|
data: makePathUnix("js/common/test-data/import/import-3.csv"),
|
|
coll: "UnitTestsImportCsv3",
|
|
type: "csv",
|
|
create: "true"
|
|
}, {
|
|
id: "csv4",
|
|
data: makePathUnix("js/common/test-data/import/import-4.csv"),
|
|
coll: "UnitTestsImportCsv4",
|
|
type: "csv",
|
|
create: "true",
|
|
separator: ";",
|
|
backslash: true
|
|
}, {
|
|
id: "csv5",
|
|
data: makePathUnix("js/common/test-data/import/import-5.csv"),
|
|
coll: "UnitTestsImportCsv5",
|
|
type: "csv",
|
|
create: "true",
|
|
separator: ";",
|
|
backslash: true
|
|
}, {
|
|
id: "tsv1",
|
|
data: makePathUnix("js/common/test-data/import/import-1.tsv"),
|
|
coll: "UnitTestsImportTsv1",
|
|
type: "tsv",
|
|
create: "true"
|
|
}, {
|
|
id: "tsv2",
|
|
data: makePathUnix("js/common/test-data/import/import-2.tsv"),
|
|
coll: "UnitTestsImportTsv2",
|
|
type: "tsv",
|
|
create: "true"
|
|
}, {
|
|
id: "edge",
|
|
data: makePathUnix("js/common/test-data/import/import-edges.json"),
|
|
coll: "UnitTestsImportEdge",
|
|
type: "json",
|
|
create: "false"
|
|
}];
|
|
|
|
testFuncs.importing = function(options) {
|
|
if (options.cluster) {
|
|
if (options.extremeVerbosity) {
|
|
print("Skipped because of cluster.");
|
|
}
|
|
|
|
return {
|
|
"importing": {
|
|
"status": true,
|
|
"message": "skipped because of cluster",
|
|
"skipped": true
|
|
}
|
|
};
|
|
}
|
|
|
|
let instanceInfo = startInstance("tcp", options, {}, "importing");
|
|
|
|
if (instanceInfo === false) {
|
|
return {
|
|
"importing": {
|
|
status: false,
|
|
message: "failed to start server!"
|
|
}
|
|
};
|
|
}
|
|
|
|
let result = {};
|
|
|
|
try {
|
|
result.setup = runInArangosh(options, instanceInfo,
|
|
makePathUnix("js/server/tests/import/import-setup.js"));
|
|
|
|
if (result.setup.status !== true) {
|
|
throw new Error("cannot start import setup");
|
|
}
|
|
|
|
for (let i = 0; i < impTodos.length; i++) {
|
|
const impTodo = impTodos[i];
|
|
|
|
result[impTodo.id] = runArangoImp(options, instanceInfo, impTodo);
|
|
|
|
if (result[impTodo.id].status !== true && !options.force) {
|
|
throw new Error("cannot run import");
|
|
}
|
|
}
|
|
|
|
result.check = runInArangosh(options, instanceInfo,
|
|
makePathUnix("js/server/tests/import/import.js"));
|
|
|
|
result.teardown = runInArangosh(options, instanceInfo,
|
|
makePathUnix("js/server/tests/import/import-teardown.js"));
|
|
|
|
} catch (banana) {
|
|
print("An exceptions of the following form was caught:",
|
|
yaml.safeDump(banana));
|
|
}
|
|
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo, options);
|
|
print("done.");
|
|
|
|
if ((!options.skipLogAnalysis) &&
|
|
instanceInfo.hasOwnProperty('importantLogLines') &&
|
|
Object.keys(instanceInfo.importantLogLines).length > 0) {
|
|
|
|
print("Found messages in the server logs: \n" +
|
|
yaml.safeDump(instanceInfo.importantLogLines));
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: recovery
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function runArangodRecovery(instanceInfo, options, script, setup) {
|
|
if (!instanceInfo.tmpDataDir) {
|
|
let td = fs.join(fs.getTempFile(), "data");
|
|
fs.makeDirectoryRecursive(td);
|
|
|
|
instanceInfo.tmpDataDir = td;
|
|
}
|
|
|
|
if (!instanceInfo.recoveryArgs) {
|
|
let args = makeArgsArangod(options);
|
|
args["server.threads"] = 1;
|
|
args["wal.reserve-logfiles"] = 1;
|
|
args["database.directory"] = instanceInfo.tmpDataDir;
|
|
|
|
instanceInfo.recoveryArgv = toArgv(args).concat(["--no-server"]);
|
|
}
|
|
|
|
let argv = instanceInfo.recoveryArgv;
|
|
|
|
if (setup) {
|
|
argv = argv.concat([
|
|
"--log.level", "fatal",
|
|
"--javascript.script-parameter", "setup"
|
|
]);
|
|
} else {
|
|
argv = argv.concat([
|
|
"--log.level", "info",
|
|
"--wal.ignore-logfile-errors", "true",
|
|
"--javascript.script-parameter", "recovery"
|
|
]);
|
|
}
|
|
|
|
argv = argv.concat([
|
|
"--javascript.script",
|
|
fs.join(".", "js", "server", "tests", "recovery", script + ".js")
|
|
]);
|
|
|
|
instanceInfo.pid = executeAndWait(fs.join("bin", "arangod"), argv);
|
|
}
|
|
|
|
const recoveryTests = [
|
|
"disk-full-logfile",
|
|
"disk-full-logfile-data",
|
|
"disk-full-datafile",
|
|
"disk-full-datafile",
|
|
"collection-drop-recreate",
|
|
"create-with-temp",
|
|
"create-with-temp-old",
|
|
"create-collection-fail",
|
|
"create-database-fail",
|
|
"empty-datafiles",
|
|
"flush-drop-database-and-fail",
|
|
"drop-database-flush-and-fail",
|
|
"create-databases",
|
|
"recreate-databases",
|
|
"drop-databases",
|
|
"create-and-drop-databases",
|
|
"drop-database-and-fail",
|
|
"flush-drop-database-and-fail",
|
|
"collection-rename-recreate",
|
|
"collection-rename-recreate-flush",
|
|
"collection-unload",
|
|
"resume-recovery-multi-flush",
|
|
"resume-recovery-simple",
|
|
"resume-recovery-all",
|
|
"resume-recovery-other",
|
|
"resume-recovery",
|
|
"foxx-directories",
|
|
"collection-rename",
|
|
"collection-properties",
|
|
"empty-logfiles",
|
|
"many-logs",
|
|
"multiple-logs",
|
|
"collection-recreate",
|
|
"drop-indexes",
|
|
"create-indexes",
|
|
"create-collections",
|
|
"recreate-collection",
|
|
"drop-single-collection",
|
|
"drop-collections",
|
|
"collections-reuse",
|
|
"collections-different-attributes",
|
|
"indexes-hash",
|
|
"indexes-sparse-hash",
|
|
"indexes-skiplist",
|
|
"indexes-sparse-skiplist",
|
|
"indexes-geo",
|
|
"edges",
|
|
"cap-constraint",
|
|
"indexes",
|
|
"many-inserts",
|
|
"many-updates",
|
|
"wait-for-sync",
|
|
"attributes",
|
|
"no-journal",
|
|
"write-throttling",
|
|
"collector-oom",
|
|
"transaction-no-abort",
|
|
"transaction-no-commit",
|
|
"multi-database-durability",
|
|
"disk-full-no-collection-journal",
|
|
"no-shutdown-info-with-flush",
|
|
"no-shutdown-info-no-flush",
|
|
"no-shutdown-info-multiple-logs",
|
|
"insert-update-remove",
|
|
"insert-update-remove-distance",
|
|
"big-transaction-durability",
|
|
"transaction-durability",
|
|
"transaction-durability-multiple",
|
|
"corrupt-wal-marker-multiple",
|
|
"corrupt-wal-marker-single"
|
|
];
|
|
|
|
testFuncs.recovery = function(options) {
|
|
let results = {};
|
|
let status = true;
|
|
|
|
for (let i = 0; i < recoveryTests.length; ++i) {
|
|
let test = recoveryTests[i];
|
|
let instanceInfo = {};
|
|
|
|
runArangodRecovery(instanceInfo, options, test, true);
|
|
|
|
runArangodRecovery(instanceInfo, options, test, false);
|
|
|
|
if (instanceInfo.tmpDataDir) {
|
|
fs.removeDirectoryRecursive(instanceInfo.tmpDataDir, true);
|
|
}
|
|
|
|
results[test] = instanceInfo.pid;
|
|
|
|
if (!results[test].status) {
|
|
status = false;
|
|
}
|
|
}
|
|
|
|
results.status = status;
|
|
|
|
return {
|
|
recovery: results
|
|
};
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: replication_ongoing
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.replication_ongoing = function(options) {
|
|
const mr = makeResults('replication_ongoing');
|
|
|
|
let master = startInstance("tcp", options, {}, "master_ongoing");
|
|
|
|
if (master === false) {
|
|
return mr(false, "failed to start master!");
|
|
}
|
|
|
|
let slave = startInstance("tcp", options, {}, "slave_ongoing");
|
|
|
|
if (slave === false) {
|
|
shutdownInstance(master, options);
|
|
return mr(false, "failed to start slave!");
|
|
}
|
|
|
|
let res = runArangoshCmd(options, master, {}, [
|
|
"--javascript.unit-tests",
|
|
"./js/server/tests/replication/replication-ongoing.js",
|
|
slave.endpoint
|
|
]);
|
|
|
|
let results;
|
|
|
|
if (!res.status) {
|
|
results = mr(false, "replication-ongoing.js failed");
|
|
} else {
|
|
results = mr(true);
|
|
}
|
|
|
|
print("Shutting down...");
|
|
shutdownInstance(slave, options);
|
|
shutdownInstance(master, options);
|
|
print("done.");
|
|
|
|
return results;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: replication_static
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.replication_static = function(options) {
|
|
const mr = makeResults('replication_static');
|
|
|
|
let master = startInstance("tcp", options, {
|
|
"server.disable-authentication": "false"
|
|
}, "master_static");
|
|
|
|
if (master === false) {
|
|
return mr(false, "failed to start master!");
|
|
}
|
|
|
|
let slave = startInstance("tcp", options, {}, "slave_static");
|
|
|
|
if (slave === false) {
|
|
shutdownInstance(master, options);
|
|
return mr(false, "failed to start slave!");
|
|
}
|
|
|
|
let res = runArangoshCmd(options, master, {}, [
|
|
"--javascript.execute-string",
|
|
"var users = require('@arangodb/users'); " +
|
|
"users.save('replicator-user', 'replicator-password', true); " +
|
|
"users.reload();"
|
|
]);
|
|
|
|
let results;
|
|
|
|
if (res.status) {
|
|
res = runArangoshCmd(options, master, {}, [
|
|
"--javascript.unit-tests",
|
|
"./js/server/tests/replication/replication-static.js",
|
|
slave.endpoint
|
|
]);
|
|
|
|
if (res.status) {
|
|
results = mr(true);
|
|
} else {
|
|
results = mr(false, "replication-static.js failed");
|
|
}
|
|
} else {
|
|
results = mr(false, "cannot create users");
|
|
}
|
|
|
|
print("Shutting down...");
|
|
shutdownInstance(slave, options);
|
|
shutdownInstance(master, options);
|
|
print("done.");
|
|
|
|
return results;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: replication_sync
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.replication_sync = function(options) {
|
|
const mr = makeResults('replication');
|
|
let master = startInstance("tcp", options, {}, "master_sync");
|
|
|
|
if (master === false) {
|
|
return mr(false, "failed to start master!");
|
|
}
|
|
|
|
let slave = startInstance("tcp", options, {}, "slave_sync");
|
|
|
|
if (slave === false) {
|
|
shutdownInstance(master, options);
|
|
return mr(false, "failed to start slave!");
|
|
}
|
|
|
|
let res = runArangoshCmd(options, master, {}, [
|
|
"--javascript.execute-string",
|
|
"var users = require('@arangodb/users'); " +
|
|
"users.save('replicator-user', 'replicator-password', true); " +
|
|
"users.reload();"
|
|
]);
|
|
|
|
let results;
|
|
|
|
if (res.status) {
|
|
res = runArangoshCmd(options, master, {}, [
|
|
"--javascript.unit-tests",
|
|
"./js/server/tests/replication/replication-sync.js",
|
|
slave.endpoint
|
|
]);
|
|
|
|
if (res.status) {
|
|
results = mr(true);
|
|
} else {
|
|
results = mr(false, "replication-sync.js failed");
|
|
}
|
|
} else {
|
|
results = mr(false, "cannot create users");
|
|
}
|
|
|
|
print("Shutting down...");
|
|
shutdownInstance(slave, options);
|
|
shutdownInstance(master, options);
|
|
print("done.");
|
|
|
|
return results;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: shell_replication
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.shell_replication = function(options) {
|
|
findTests();
|
|
|
|
var opts = {
|
|
"replication": true
|
|
};
|
|
_.defaults(opts, options);
|
|
|
|
return performTests(opts, testsCases.replication, 'shell_replication');
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: shell client
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.shell_client = function(options) {
|
|
findTests();
|
|
|
|
let instanceInfo = startInstance("tcp", options, {}, "shell_client");
|
|
|
|
if (instanceInfo === false) {
|
|
return {
|
|
shell_client: {
|
|
status: false,
|
|
message: "failed to start server!"
|
|
}
|
|
};
|
|
}
|
|
|
|
let results = {};
|
|
let filtered = {};
|
|
let continueTesting = true;
|
|
|
|
for (let i = 0; i < testsCases.client.length; i++) {
|
|
const te = testsCases.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.";
|
|
|
|
break;
|
|
}
|
|
|
|
print("\narangosh: Trying", te, "...");
|
|
|
|
const reply = runInArangosh(options, instanceInfo, te);
|
|
results[te] = reply;
|
|
|
|
if (reply.status !== true) {
|
|
options.cleanup = false;
|
|
|
|
if (!options.force) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
continueTesting = checkInstanceAlive(instanceInfo, options);
|
|
} else {
|
|
if (options.extremeVerbosity) {
|
|
print("Skipped " + te + " because of " + filtered.filter);
|
|
}
|
|
}
|
|
}
|
|
|
|
print("Shutting down...");
|
|
shutdownInstance(instanceInfo, options);
|
|
print("done.");
|
|
|
|
if ((!options.skipLogAnalysis) &&
|
|
instanceInfo.hasOwnProperty('importantLogLines') &&
|
|
Object.keys(instanceInfo.importantLogLines).length > 0) {
|
|
print("Found messages in the server logs: \n" +
|
|
yaml.safeDump(instanceInfo.importantLogLines));
|
|
}
|
|
|
|
return results;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: shell server
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.shell_server = function(options) {
|
|
findTests();
|
|
|
|
return performTests(options, testsCases.server, 'shell_server');
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: shell server aql
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.shell_server_aql = function(options) {
|
|
findTests();
|
|
|
|
if (!options.skipAql) {
|
|
if (options.skipRanges) {
|
|
return performTests(options, testsCases.server_aql,
|
|
'shell_server_aql_skipranges');
|
|
} else {
|
|
return performTests(options,
|
|
testsCases.server_aql.concat(testsCases.server_aql_extended),
|
|
'shell_server_aql');
|
|
}
|
|
}
|
|
|
|
return {
|
|
shell_server_aql: {
|
|
status: true,
|
|
skipped: true
|
|
}
|
|
};
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: shell server only
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.shell_server_only = function(options) {
|
|
findTests();
|
|
|
|
return performTests(options, testsCases.server_only, 'shell_server_only');
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: shell server performance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.shell_server_perf = function(options) {
|
|
findTests();
|
|
|
|
return performTests(options, testsCases.server_aql_performance,
|
|
'shell_server_perf');
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: single client
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function single_usage(testsuite, list) {
|
|
print("single_" + testsuite + ": No test specified!\n Available tests:");
|
|
let filelist = "";
|
|
|
|
for (let 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 {
|
|
usage: {
|
|
status: false,
|
|
message: "No test specified!"
|
|
}
|
|
};
|
|
}
|
|
|
|
testFuncs.single_client = function(options) {
|
|
options.writeXmlReport = false;
|
|
|
|
if (options.test !== undefined) {
|
|
let instanceInfo = startInstance("tcp", options, {}, "single_client");
|
|
|
|
if (instanceInfo === false) {
|
|
return {
|
|
single_client: {
|
|
status: false,
|
|
message: "failed to start server!"
|
|
}
|
|
};
|
|
}
|
|
|
|
const te = options.test;
|
|
|
|
print("\n" + Date() + " arangosh: Trying ", te, "...");
|
|
|
|
let result = {};
|
|
result[te] = runInArangosh(options, instanceInfo, te);
|
|
|
|
print("Shutting down...");
|
|
|
|
if (result[te].status === false) {
|
|
options.cleanup = false;
|
|
}
|
|
|
|
shutdownInstance(instanceInfo, options);
|
|
|
|
print("done.");
|
|
|
|
if ((!options.skipLogAnalysis) &&
|
|
instanceInfo.hasOwnProperty('importantLogLines') &&
|
|
Object.keys(instanceInfo.importantLogLines).length > 0) {
|
|
print("Found messages in the server logs: \n" +
|
|
yaml.safeDump(instanceInfo.importantLogLines));
|
|
}
|
|
|
|
return result;
|
|
} else {
|
|
findTests();
|
|
return single_usage("client", testsCases.client);
|
|
}
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: single server
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.single_server = function(options) {
|
|
options.writeXmlReport = false;
|
|
|
|
if (options.test === undefined) {
|
|
findTests();
|
|
return single_usage("server", testsCases.server);
|
|
}
|
|
|
|
let instanceInfo = startInstance("tcp", options, {}, "single_server");
|
|
|
|
if (instanceInfo === false) {
|
|
return {
|
|
single_server: {
|
|
status: false,
|
|
message: "failed to start server!"
|
|
}
|
|
};
|
|
}
|
|
|
|
const te = options.test;
|
|
|
|
print("\n" + Date() + " arangod: Trying", te, "...");
|
|
|
|
let result = {};
|
|
let reply = runThere(options, instanceInfo, makePathGeneric(te));
|
|
|
|
if (reply.hasOwnProperty('status')) {
|
|
result[te] = reply;
|
|
|
|
if (result[te].status === false) {
|
|
options.cleanup = false;
|
|
}
|
|
}
|
|
|
|
print("Shutting down...");
|
|
|
|
if (result[te].status === false) {
|
|
options.cleanup = false;
|
|
}
|
|
|
|
shutdownInstance(instanceInfo, options);
|
|
|
|
print("done.");
|
|
|
|
if ((!options.skipLogAnalysis) &&
|
|
instanceInfo.hasOwnProperty('importantLogLines') &&
|
|
Object.keys(instanceInfo.importantLogLines).length > 0) {
|
|
print("Found messages in the server logs: \n" +
|
|
yaml.safeDump(instanceInfo.importantLogLines));
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: https server
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.ssl_server = function(options) {
|
|
if (options.skipSsl) {
|
|
return {
|
|
ssl_server: {
|
|
status: true,
|
|
skipped: true
|
|
}
|
|
};
|
|
}
|
|
|
|
return rubyTests(options, true);
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief TEST: upgrade
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.upgrade = function(options) {
|
|
if (options.cluster) {
|
|
return {
|
|
"upgrade": {
|
|
"status": true,
|
|
"message": "skipped because of cluster",
|
|
"skipped": true
|
|
}
|
|
};
|
|
}
|
|
|
|
let result = {
|
|
upgrade: {
|
|
status: true,
|
|
total: 1
|
|
}
|
|
};
|
|
|
|
const tmpDataDir = fs.getTempFile();
|
|
fs.makeDirectoryRecursive(tmpDataDir);
|
|
|
|
const appDir = fs.join(tmpDataDir, "app");
|
|
const port = findFreePort();
|
|
|
|
let args = makeArgsArangod(options, appDir);
|
|
args["server.endpoint"] = "tcp://127.0.0.1:" + port;
|
|
args["database.directory"] = fs.join(tmpDataDir, "data");
|
|
|
|
fs.makeDirectoryRecursive(fs.join(tmpDataDir, "data"));
|
|
|
|
const run = fs.join("bin", "arangod");
|
|
const argv = toArgv(args).concat(["--upgrade"]);
|
|
|
|
if (options.valgrind) {
|
|
const valgrindArgs = valgrindArgsSingleServer(options, "upgrade", run);
|
|
const newargs = valgrindArgs.concat(argv);
|
|
|
|
result.upgrade.first = executeAndWait(options.valgrind, newargs);
|
|
} else {
|
|
result.upgrade.first = executeAndWait(run, argv);
|
|
}
|
|
|
|
if (result.upgrade.first !== 0 && !options.force) {
|
|
print("not removing " + tmpDataDir);
|
|
return result;
|
|
}
|
|
|
|
++result.upgrade.total;
|
|
|
|
if (options.valgrind) {
|
|
const valgrindArgs = valgrindArgsSingleServer(options, "upgrade", run);
|
|
const newargs = valgrindArgs.concat(argv);
|
|
|
|
result.upgrade.second = executeAndWait(options.valgrind, newargs);
|
|
} else {
|
|
result.upgrade.second = executeAndWait(run, argv);
|
|
}
|
|
|
|
cleanupDirectories.push(tmpDataDir);
|
|
|
|
return result;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief STRESS TEST: stress_crud
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.stress_crud = function(options) {
|
|
const duration = options.duration;
|
|
const concurrency = options.concurrency;
|
|
|
|
const command = `
|
|
const stressCrud = require("./js/server/tests/stress/crud");
|
|
|
|
stressCrud.createDeleteUpdateParallel({
|
|
concurrency: ${concurrency},
|
|
duration: ${duration},
|
|
gnuplot: true,
|
|
pauseFor: 60
|
|
});
|
|
`;
|
|
|
|
return runStressTest(options, command, "stress_crud");
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief STRESS TEST: stress_killing
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFuncs.stress_killing = function(options) {
|
|
const duration = options.duration;
|
|
|
|
let opts = {
|
|
concurrency: 4
|
|
};
|
|
|
|
_.defaults(opts, options);
|
|
|
|
const command = `
|
|
const stressCrud = require("./js/server/tests/stress/killingQueries");
|
|
|
|
stressCrud.killingParallel({
|
|
duration: ${duration},
|
|
gnuplot: true
|
|
});
|
|
`;
|
|
|
|
return runStressTest(opts, command, "stress_killing");
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief STRESS TEST: stress_locks
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
testFuncs.stress_locks = function(options) {
|
|
const duration = options.duration;
|
|
const concurrency = options.concurrency;
|
|
|
|
const command = `
|
|
const deadlock = require("./js/server/tests/stress/deadlock");
|
|
|
|
deadlock.lockCycleParallel({
|
|
concurrency: ${concurrency},
|
|
duration: ${duration},
|
|
gnuplot: true
|
|
});
|
|
`;
|
|
|
|
return runStressTest(options, command, "stress_lock");
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief pretty prints the result
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function unitTestPrettyPrintResults(r) {
|
|
let testFail = 0;
|
|
let testSuiteFail = 0;
|
|
let success = "";
|
|
let fail = "";
|
|
|
|
try {
|
|
for (let testrun in r) {
|
|
if (r.hasOwnProperty(testrun) && (internalMembers.indexOf(testrun) === -1)) {
|
|
let isSuccess = true;
|
|
let successTests = {};
|
|
let oneOutput = "* Testrun: " + testrun + "\n";
|
|
|
|
for (let test in r[testrun]) {
|
|
if (r[testrun].hasOwnProperty(test) &&
|
|
(internalMembers.indexOf(test) === -1)) {
|
|
if (r[testrun][test].status) {
|
|
const where = test.lastIndexOf(fs.pathSeparator);
|
|
let which;
|
|
|
|
if (where < 0) {
|
|
which = 'Unittests';
|
|
} else {
|
|
which = test.substring(0, where);
|
|
test = test.substring(where + 1, test.length);
|
|
}
|
|
|
|
if (!successTests.hasOwnProperty(which)) {
|
|
successTests[which] = [];
|
|
}
|
|
|
|
successTests[which].push(test);
|
|
} else {
|
|
testSuiteFail++;
|
|
|
|
if (r[testrun][test].hasOwnProperty('message')) {
|
|
isSuccess = false;
|
|
oneOutput += " [ Fail ] " + test +
|
|
": Whole testsuite failed!\n";
|
|
|
|
if (typeof r[testrun][test].message === "object" &&
|
|
r[testrun][test].message.hasOwnProperty('body')) {
|
|
oneOutput += r[testrun][test].message.body + "\n";
|
|
} else {
|
|
oneOutput += r[testrun][test].message + "\n";
|
|
}
|
|
} else {
|
|
isSuccess = false;
|
|
oneOutput += " [ Fail ] " + test + "\n";
|
|
|
|
for (let oneTest in r[testrun][test]) {
|
|
if (r[testrun][test].hasOwnProperty(oneTest) &&
|
|
(internalMembers.indexOf(oneTest) === -1) &&
|
|
(!r[testrun][test][oneTest].status)) {
|
|
++testFail;
|
|
oneOutput += " -> " + oneTest +
|
|
" Failed; Verbose message:\n" +
|
|
r[testrun][test][oneTest].message + "\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (successTests !== "") {
|
|
for (let key in successTests) {
|
|
if (successTests.hasOwnProperty(key)) {
|
|
oneOutput = " [Success] " + key +
|
|
" / [" + successTests[key].join(', ') + ']\n' + oneOutput;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isSuccess) {
|
|
success += oneOutput;
|
|
} else {
|
|
fail += oneOutput;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (success !== "") {
|
|
print(success);
|
|
}
|
|
|
|
if (fail !== "") {
|
|
print(fail);
|
|
}
|
|
|
|
print("Overall state: " + ((r.status === true) ? "Success" : "Fail"));
|
|
|
|
if (r.status !== true) {
|
|
print(" Suites failed: " + testSuiteFail + " Tests Failed: " + testFail);
|
|
}
|
|
|
|
if (r.crashed === true) {
|
|
print(" We had at least one unclean shutdown of an arangod during the testrun.");
|
|
}
|
|
} catch (x) {
|
|
print("exception caught while pretty printing result: ");
|
|
print(x.message);
|
|
print(JSON.stringify(r));
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief print usage information
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function printUsage() {
|
|
print();
|
|
print("Usage: UnitTest([which, ...], options)");
|
|
print();
|
|
print(' where "which" is one of:\n');
|
|
|
|
for (let i in testFuncs) {
|
|
if (testFuncs.hasOwnProperty(i)) {
|
|
let oneFunctionDocumentation;
|
|
|
|
if (functionsDocumentation.hasOwnProperty(i)) {
|
|
oneFunctionDocumentation = ' - ' + functionsDocumentation[i];
|
|
} else {
|
|
oneFunctionDocumentation = '';
|
|
}
|
|
|
|
let checkAll;
|
|
|
|
if (allTests.indexOf(i) !== -1) {
|
|
checkAll = '[x]';
|
|
} else {
|
|
checkAll = ' ';
|
|
}
|
|
|
|
print(' ' + checkAll + ' ' + i + ' ' + oneFunctionDocumentation);
|
|
}
|
|
}
|
|
|
|
for (let i in optionsDocumentation) {
|
|
if (optionsDocumentation.hasOwnProperty(i)) {
|
|
print(optionsDocumentation[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @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.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function unitTest(cases, options) {
|
|
if (typeof options !== "object") {
|
|
options = {};
|
|
}
|
|
|
|
_.defaults(options, optionsDefaults);
|
|
|
|
if (cases === undefined) {
|
|
printUsage();
|
|
|
|
print('FATAL: "which" is undefined\n');
|
|
|
|
return {
|
|
status: false
|
|
};
|
|
}
|
|
|
|
const jsonReply = options.jsonReply;
|
|
delete options.jsonReply;
|
|
|
|
// tests to run
|
|
let caselist = [];
|
|
|
|
for (let n = 0; n < cases.length; ++n) {
|
|
let which = cases[n];
|
|
|
|
if (which === "all") {
|
|
caselist = caselist.conact(allTests);
|
|
} else if (testFuncs.hasOwnProperty(which)) {
|
|
caselist.push(which);
|
|
} else {
|
|
let line = "Unknown test '" + which + "'\nKnown tests are: ";
|
|
let sep = "";
|
|
|
|
Object.keys(testFuncs).map(function(key) {
|
|
line += sep + key;
|
|
sep = ", ";
|
|
});
|
|
|
|
print(line);
|
|
|
|
return {
|
|
status: false
|
|
};
|
|
}
|
|
}
|
|
|
|
let globalStatus = true;
|
|
let results = {};
|
|
|
|
// running all tests
|
|
for (let n = 0; n < caselist.length; ++n) {
|
|
const currentTest = caselist[n];
|
|
|
|
print("Executing test", currentTest, "with options", options);
|
|
|
|
let result = testFuncs[currentTest](options);
|
|
results[currentTest] = result;
|
|
|
|
let status = true;
|
|
|
|
for (let i in result) {
|
|
if (result.hasOwnProperty(i)) {
|
|
if (result[i].status !== true) {
|
|
status = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
result.status = status;
|
|
|
|
if (!status) {
|
|
globalStatus = false;
|
|
}
|
|
}
|
|
|
|
results.status = globalStatus;
|
|
results.crashed = serverCrashed;
|
|
|
|
if (globalStatus) {
|
|
cleanupDBDirectories(options);
|
|
} else {
|
|
print("since some tests weren't successfully, not cleaning up: \n" +
|
|
yaml.safeDump(cleanupDirectories));
|
|
}
|
|
|
|
yaml.safeDump(results);
|
|
|
|
if (jsonReply === true) {
|
|
return results;
|
|
} else {
|
|
return globalStatus;
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief exports
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
exports.unitTest = unitTest;
|
|
|
|
exports.internalMembers = internalMembers;
|
|
exports.testFuncs = testFuncs;
|
|
exports.unitTestPrettyPrintResults = unitTestPrettyPrintResults;
|
|
|
|
// TODO write test for 2.6-style queues
|
|
// testFuncs.queue_legacy = function (options) {
|
|
// if (options.skipFoxxQueues) {
|
|
// print("skipping test of legacy queue job types");
|
|
// return {};
|
|
// }
|
|
// var startTime;
|
|
// var queueAppMountPath = '/test-queue-legacy';
|
|
// print("Testing legacy queue job types");
|
|
// var instanceInfo = startInstance("tcp", options, [], "queue_legacy");
|
|
// if (instanceInfo === false) {
|
|
// return {status: false, message: "failed to start server!"};
|
|
// }
|
|
// var data = {
|
|
// naive: {_key: 'potato', hello: 'world'},
|
|
// forced: {_key: 'tomato', hello: 'world'},
|
|
// plain: {_key: 'banana', hello: 'world'}
|
|
// };
|
|
// var results = {};
|
|
// results.install = runArangoshCmd(options, instanceInfo, {
|
|
// "configuration": "etc/relative/foxx-manager.conf"
|
|
// }, [
|
|
// "install",
|
|
// "js/common/test-data/apps/queue-legacy-test",
|
|
// queueAppMountPath
|
|
// ]);
|
|
|
|
// print("Restarting without foxx-queues-warmup-exports...");
|
|
// shutdownInstance(instanceInfo, options);
|
|
// instanceInfo = startInstance("tcp", options, {
|
|
// "server.foxx-queues-warmup-exports": "false"
|
|
// }, "queue_legacy", instanceInfo.flatTmpDataDir);
|
|
// if (instanceInfo === false) {
|
|
// return {status: false, message: "failed to restart server!"};
|
|
// }
|
|
// print("done.");
|
|
|
|
// var res, body;
|
|
// startTime = time();
|
|
// try {
|
|
// res = download(
|
|
// instanceInfo.url + queueAppMountPath + '/',
|
|
// JSON.stringify(data.naive),
|
|
// {method: 'POST'}
|
|
// );
|
|
// body = JSON.parse(res.body);
|
|
// results.naive = {status: body.success === false, message: JSON.stringify({body: res.body, code: res.code})};
|
|
// } catch (e) {
|
|
// results.naive = {status: true, message: JSON.stringify({body: res.body, code: res.code})};
|
|
// }
|
|
// results.naive.duration = time() - startTime;
|
|
|
|
// startTime = time();
|
|
// try {
|
|
// res = download(
|
|
// instanceInfo.url + queueAppMountPath + '/?allowUnknown=true',
|
|
// JSON.stringify(data.forced),
|
|
// {method: 'POST'}
|
|
// );
|
|
// body = JSON.parse(res.body);
|
|
// results.forced = (
|
|
// body.success
|
|
// ? {status: true}
|
|
// : {status: false, message: body.error, stacktrace: body.stacktrace}
|
|
// );
|
|
// } catch (e) {
|
|
// results.forced = {status: false, message: JSON.stringify({body: res.body, code: res.code})};
|
|
// }
|
|
// results.forced.duration = time() - startTime;
|
|
|
|
// print("Restarting with foxx-queues-warmup-exports...");
|
|
// shutdownInstance(instanceInfo, options);
|
|
// instanceInfo = startInstance("tcp", options, {
|
|
// "server.foxx-queues-warmup-exports": "true"
|
|
// }, "queue_legacy", instanceInfo.flatTmpDataDir);
|
|
// if (instanceInfo === false) {
|
|
// return {status: false, message: "failed to restart server!"};
|
|
// }
|
|
// print("done.");
|
|
|
|
// startTime = time();
|
|
// try {
|
|
// res = download(instanceInfo.url + queueAppMountPath + '/', JSON.stringify(data.plain), {method: 'POST'});
|
|
// body = JSON.parse(res.body);
|
|
// results.plain = (
|
|
// body.success
|
|
// ? {status: true}
|
|
// : {status: false, message: JSON.stringify({body: res.body, code: res.code})}
|
|
// );
|
|
// } catch (e) {
|
|
// results.plain = {status: false, message: JSON.stringify({body: res.body, code: res.code})};
|
|
// }
|
|
// results.plain.duration = time() - startTime;
|
|
|
|
// startTime = time();
|
|
// try {
|
|
// for (var i = 0; i < 60; i++) {
|
|
// wait(1);
|
|
// res = download(instanceInfo.url + queueAppMountPath + '/');
|
|
// body = JSON.parse(res.body);
|
|
// if (body.length === 2) {
|
|
// break;
|
|
// }
|
|
// }
|
|
// results.final = (
|
|
// body.length === 2 && body[0]._key === data.forced._key && body[1]._key === data.plain._key
|
|
// ? {status: true}
|
|
// : {status: false, message: JSON.stringify({body: res.body, code: res.code})}
|
|
// );
|
|
// } catch (e) {
|
|
// results.final = {status: false, message: JSON.stringify({body: res.body, code: res.code})};
|
|
// }
|
|
// results.final.duration = time() - startTime;
|
|
|
|
// results.uninstall = runArangoshCmd(options, instanceInfo, {
|
|
// "configuration": "etc/relative/foxx-manager.conf"
|
|
// }, [
|
|
// "uninstall",
|
|
// queueAppMountPath
|
|
// ]);
|
|
// print("Shutting down...");
|
|
// shutdownInstance(instanceInfo, options);
|
|
// print("done.");
|
|
// if ((!options.skipLogAnalysis) &&
|
|
// instanceInfo.hasOwnProperty('importantLogLines') &&
|
|
// Object.keys(instanceInfo.importantLogLines).length > 0) {
|
|
// print("Found messages in the server logs: \n" + yaml.safeDump(instanceInfo.importantLogLines));
|
|
// }
|
|
// return results;
|
|
// };
|