Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
arangodb/js/common/tests/shell-database.js

654 lines
20 KiB
JavaScript
Raw Blame History

/*jshint strict: true */
/*global require, assertEqual, assertTrue, assertFalse, assertNotEqual, assertMatch, assertEqual, fail */
////////////////////////////////////////////////////////////////////////////////
/// @brief test the common database interface
///
/// @file
///
/// DISCLAIMER
///
/// Copyright 2010-2012 triagens GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
/// http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an "AS IS" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.
///
/// Copyright holder is triAGENS GmbH, Cologne, Germany
///
/// @author Jan Steemann
/// @author Copyright 2012, triAGENS GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
var jsunity = require("jsunity");
var internal = require("internal");
var arangodb = require("org/arangodb");
var ERRORS = arangodb.errors;
// -----------------------------------------------------------------------------
// --SECTION-- database methods
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief test suite: database methods
////////////////////////////////////////////////////////////////////////////////
function DatabaseSuite () {
"use strict";
return {
setUp : function () {
internal.db._useDatabase("_system");
},
tearDown : function () {
// always go back to system database
internal.db._useDatabase("_system");
try {
// drop this database if it exists
internal.db._dropDatabase("UnitTestsDatabase0");
}
catch (err) {
// ignore
}
// trigger GC to remove databases physically
internal.wait(0);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test the version information
////////////////////////////////////////////////////////////////////////////////
testVersion : function () {
assertMatch(/(^2\.5)|(-devel$)/, internal.db._version());
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test _name function
////////////////////////////////////////////////////////////////////////////////
testName : function () {
assertEqual("_system", internal.db._name());
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test _path function
////////////////////////////////////////////////////////////////////////////////
testPath : function () {
assertTrue(typeof internal.db._path() === "string");
assertTrue(internal.db._path() !== "");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test _isSystem function
////////////////////////////////////////////////////////////////////////////////
testIsSystem : function () {
assertTrue(typeof internal.db._isSystem() === "boolean");
assertTrue(internal.db._isSystem());
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test _query function
////////////////////////////////////////////////////////////////////////////////
testQuery : function () {
assertEqual([ 1 ], internal.db._query("return 1").toArray());
assertEqual([ [ 1, 2, 9, "foo" ] ], internal.db._query("return [ 1, 2, 9, \"foo\" ]").toArray());
assertEqual([ [ 1, 454 ] ], internal.db._query("return [ @low, @high ]", { low : 1, high : 454 }).toArray());
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test _executeTransaction
////////////////////////////////////////////////////////////////////////////////
testExecuteTransaction1 : function () {
var result = internal.db._executeTransaction({
collections: { },
action: function (params) {
return params.v1 + params.v2;
},
params: {
"v1": 1,
"v2": 2
}
});
assertEqual(3, result);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test _executeTransaction
////////////////////////////////////////////////////////////////////////////////
testExecuteTransaction2 : function () {
var result = internal.db._executeTransaction({
collections: { },
action: "function () { return params.v1[0] - params.v1[1]; }",
params: {
"v1": [ 10, 4 ],
}
});
assertEqual(6, result);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test _listDatabases function
////////////////////////////////////////////////////////////////////////////////
testListDatabases : function () {
var actual, n;
assertEqual("_system", internal.db._name());
actual = internal.db._listDatabases();
assertTrue(Array.isArray(actual));
n = actual.length;
assertTrue(n > 0);
assertTrue( ( function () {
for (var i = 0; i < actual.length; ++i) {
if (actual[i] === "_system") {
return true;
}
}
return false;
}() ) );
try {
internal.db._dropDatabase("UnitTestsDatabase0");
}
catch (err) {
}
internal.db._createDatabase("UnitTestsDatabase0");
actual = internal.db._listDatabases();
assertTrue(Array.isArray(actual));
assertEqual(n + 1, actual.length);
assertTrue( ( function () {
for (var i = 0; i < actual.length; ++i) {
if (actual[i] === "UnitTestsDatabase0") {
return true;
}
}
return false;
}() ) );
internal.db._dropDatabase("UnitTestsDatabase0");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test _createDatabase function
////////////////////////////////////////////////////////////////////////////////
testCreateDatabase : function () {
assertEqual("_system", internal.db._name());
try {
internal.db._dropDatabase("UnitTestsDatabase0");
}
catch (err1) {
}
try {
internal.db._dropDatabase("UnitTestsDatabase1");
}
catch (err2) {
}
assertTrue(internal.db._createDatabase("UnitTestsDatabase0"));
assertTrue(internal.db._createDatabase("UnitTestsDatabase1"));
assertTrue(internal.db._dropDatabase("UnitTestsDatabase0"));
assertTrue(internal.db._dropDatabase("UnitTestsDatabase1"));
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test _createDatabase function
////////////////////////////////////////////////////////////////////////////////
testCreateDatabaseWithUsers1 : function () {
assertEqual("_system", internal.db._name());
try {
internal.db._dropDatabase("UnitTestsDatabase0");
}
catch (err1) {
}
// empty users
assertTrue(internal.db._createDatabase("UnitTestsDatabase0", { }, [ ]));
assertTrue(internal.db._dropDatabase("UnitTestsDatabase0"));
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test _createDatabase function
////////////////////////////////////////////////////////////////////////////////
testCreateDatabaseWithUsers2 : function () {
assertEqual("_system", internal.db._name());
try {
internal.db._dropDatabase("UnitTestsDatabase0");
}
catch (err1) {
}
var users = [
{ username: "admin", passwd: "secret", extra: { gender: "m" } },
{ username: "foo", active: false, extra: { gender: "f" } }
];
assertTrue(internal.db._createDatabase("UnitTestsDatabase0", { }, users));
internal.db._useDatabase("UnitTestsDatabase0");
var userManager = require("org/arangodb/users");
var user = userManager.document("admin");
assertEqual("admin", user.user);
assertTrue(user.active);
assertEqual("m", user.extra.gender);
user = userManager.document("foo");
assertEqual("foo", user.user);
assertFalse(user.active);
assertEqual("f", user.extra.gender);
internal.db._useDatabase("_system");
assertTrue(internal.db._dropDatabase("UnitTestsDatabase0"));
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test _createDatabase function
////////////////////////////////////////////////////////////////////////////////
testCreateDatabaseWithUsers3 : function () {
assertEqual("_system", internal.db._name());
try {
internal.db._dropDatabase("UnitTestsDatabase0");
}
catch (err1) {
}
var users = [
{ username: "admin", passwd: "secret", active: true, extra: { gender: "m" } },
{ username: "admin", passwd: "", active: false, extra: { gender: "m" } },
];
assertTrue(internal.db._createDatabase("UnitTestsDatabase0", { }, users));
internal.db._useDatabase("UnitTestsDatabase0");
var userManager = require("org/arangodb/users");
var user = userManager.document("admin");
assertEqual("admin", user.user);
assertTrue(user.active);
assertEqual("m", user.extra.gender);
internal.db._useDatabase("_system");
assertTrue(internal.db._dropDatabase("UnitTestsDatabase0"));
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test _createDatabase function
////////////////////////////////////////////////////////////////////////////////
testCreateDatabaseInvalidName : function () {
assertEqual("_system", internal.db._name());
[ "", " ", "-", "0", "99999", ":::", "fox::", "test!" ].forEach (function (d) {
try {
internal.db._createDatabase(d);
fail();
}
catch (err) {
assertEqual(ERRORS.ERROR_ARANGO_DATABASE_NAME_INVALID.code, err.errorNum);
}
});
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test _createDatabase function
////////////////////////////////////////////////////////////////////////////////
testCreateDatabaseNonSystem : function () {
assertEqual("_system", internal.db._name());
try {
internal.db._dropDatabase("UnitTestsDatabase0");
}
catch (err1) {
}
internal.db._createDatabase("UnitTestsDatabase0");
internal.db._useDatabase("UnitTestsDatabase0");
assertEqual("UnitTestsDatabase0", internal.db._name());
// creation of new databases should fail here
try {
internal.db._createDatabase("UnitTestsDatabase1");
fail();
}
catch (err2) {
assertEqual(ERRORS.ERROR_ARANGO_USE_SYSTEM_DATABASE.code, err2.errorNum);
}
// removing a database should fail here
try {
internal.db._dropDatabase("UnitTestsDatabase1");
fail();
}
catch (err3) {
assertEqual(ERRORS.ERROR_ARANGO_USE_SYSTEM_DATABASE.code, err3.errorNum);
}
internal.db._useDatabase("_system");
internal.db._dropDatabase("UnitTestsDatabase0");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test _createDatabase function
////////////////////////////////////////////////////////////////////////////////
testCreateDatabaseDuplicate : function () {
assertEqual("_system", internal.db._name());
try {
internal.db._dropDatabase("UnitTestsDatabase0");
}
catch (err1) {
}
internal.db._createDatabase("UnitTestsDatabase0");
try {
internal.db._createDatabase("UnitTestsDatabase0");
fail();
}
catch (err2) {
assertEqual(ERRORS.ERROR_ARANGO_DUPLICATE_NAME.code, err2.errorNum);
}
internal.db._dropDatabase("UnitTestsDatabase0");
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test _createDatabase function
////////////////////////////////////////////////////////////////////////////////
testCreateDatabaseCaseSensitivity : function () {
assertEqual("_system", internal.db._name());
var getCollections = function () {
var result = [ ];
internal.db._collections().forEach(function (c) {
if (c.name()[0] !== "_") {
result.push(c.name());
}
});
result.sort();
return result;
};
try {
internal.db._dropDatabase("UnitTestsDatabase0");
}
catch (err1) {
}
try {
internal.db._dropDatabase("UNITTESTSDATABASE0");
}
catch (err2) {
}
assertTrue(internal.db._createDatabase("UnitTestsDatabase0"));
assertTrue(internal.db._createDatabase("UNITTESTSDATABASE0"));
internal.db._useDatabase("UnitTestsDatabase0");
assertEqual("UnitTestsDatabase0", internal.db._name());
var c1 = internal.db._create("test1");
assertNotEqual(-1, getCollections().indexOf("test1"));
c1.save({ "_key": "foo" });
assertEqual(1, internal.db._collection("test1").count());
assertEqual(1, c1.count());
internal.db._useDatabase("UNITTESTSDATABASE0");
assertEqual("UNITTESTSDATABASE0", internal.db._name());
var c2 = internal.db._create("test1");
assertNotEqual(-1, getCollections().indexOf("test1"));
c2.save({ "_key": "foo" });
c2.save({ "_key": "bar" });
c2.save({ "_key": "baz" });
assertEqual(3, internal.db._collection("test1").count());
assertEqual(3, c2.count());
c1.remove("foo");
assertEqual(0, c1.count());
assertEqual(3, c2.count());
assertEqual(3, internal.db._collection("test1").count());
internal.db._useDatabase("UnitTestsDatabase0");
assertEqual(0, c1.count());
assertEqual(3, c2.count());
assertEqual(0, internal.db._collection("test1").count());
c1.drop();
c1 = null;
internal.db._useDatabase("UNITTESTSDATABASE0");
assertEqual(3, internal.db._collection("test1").count());
assertEqual(3, c2.count());
c2.remove("foo");
assertEqual(2, internal.db._collection("test1").count());
assertEqual(2, c2.count());
internal.db._useDatabase("_system");
assertTrue(internal.db._dropDatabase("UnitTestsDatabase0"));
assertTrue(internal.db._dropDatabase("UNITTESTSDATABASE0"));
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test _useDatabase function
////////////////////////////////////////////////////////////////////////////////
testUseDatabase : function () {
assertEqual("_system", internal.db._name());
try {
internal.db._dropDatabase("UnitTestsDatabase0");
}
catch (err1) {
}
internal.db._createDatabase("UnitTestsDatabase0");
internal.db._useDatabase("UnitTestsDatabase0");
assertEqual("UnitTestsDatabase0", internal.db._name());
internal.db._useDatabase("UnitTestsDatabase0");
assertEqual("UnitTestsDatabase0", internal.db._name());
internal.db._useDatabase("_system");
assertEqual("_system", internal.db._name());
assertTrue(internal.db._dropDatabase("UnitTestsDatabase0"));
try {
internal.db._useDatabase("UnitTestsDatabase0");
fail();
}
catch (err2) {
assertTrue(err2.errorNum === ERRORS.ERROR_ARANGO_DATABASE_NOT_FOUND.code ||
err2.errorNum === ERRORS.ERROR_HTTP_NOT_FOUND.code);
}
assertEqual("_system", internal.db._name());
try {
internal.db._useDatabase("THISDATABASEDOESNOTEXIST");
fail();
}
catch (err3) {
assertTrue(err3.errorNum === ERRORS.ERROR_ARANGO_DATABASE_NOT_FOUND.code ||
err3.errorNum === ERRORS.ERROR_HTTP_NOT_FOUND.code);
}
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test _dropDatabase function
////////////////////////////////////////////////////////////////////////////////
testDropDatabase : function () {
assertEqual("_system", internal.db._name());
try {
internal.db._dropDatabase("UnitTestsDatabase0");
}
catch (err1) {
}
var isContained = function (name) {
var l = internal.db._listDatabases();
for (var i = 0; i < l.length; ++i) {
if (l[i] === name) {
return true;
}
}
return false;
};
internal.db._createDatabase("UnitTestsDatabase0");
assertTrue(isContained("UnitTestsDatabase0"));
assertTrue(isContained("_system"));
assertTrue(internal.db._dropDatabase("UnitTestsDatabase0"));
assertFalse(isContained("UnitTestsDatabase0"));
assertTrue(isContained("_system"));
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test collection cache in the face of collection deletion
////////////////////////////////////////////////////////////////////////////////
testCollectionsCache1 : function () {
var db = internal.db;
var name = "UnitTestsCollectionCache";
db._drop(name);
db._create(name);
db[name].save({ _key: "test", value: 1 });
var cid = db[name]._id;
assertEqual(name, db[name].name());
assertEqual(1, db[name].count());
assertEqual(1, db[name].document("test").value);
// remove the collection and re-create a new one with the same name
db._drop(name);
db._create(name);
db[name].save({ _key: "foo", value: 1 });
db[name].save({ _key: "test", value: 2 });
assertNotEqual(cid, db[name]._id);
assertEqual(name, db[name].name());
assertEqual(2, db[name].count());
assertEqual(1, db[name].document("foo").value);
assertEqual(2, db[name].document("test").value);
db._drop(name);
try {
db[name].save({ _key: "foo", value: 1 });
fail();
}
catch (err) {
// cannot call method ... of undefined
assertMatch(/^Cannot read property 'save' of undefined/, err.message);
}
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test collection cache in the face of database changes
////////////////////////////////////////////////////////////////////////////////
testCollectionsCache2 : function () {
var db = internal.db;
var name = "UnitTestsCollectionCache";
assertTrue("_system", db._name());
db._drop(name);
db._create(name);
db[name].save({ _key: "foo", value: 1 });
var cid = db[name]._id;
assertEqual(name, db[name].name());
assertEqual(1, db[name].count());
// switch the database
db._createDatabase("UnitTestsDatabase0");
db._useDatabase("UnitTestsDatabase0");
// collection should not yet exist in other database
try {
db[name].save({ _key: "foo", value: 1 });
fail();
}
catch (err) {
// cannot call method ... of undefined
assertMatch(/^Cannot read property 'save' of undefined/, err.message);
}
db._create(name);
assertNotEqual(cid, db[name]._id);
assertEqual(name, db[name].name());
assertEqual(0, db[name].count());
db[name].save({ _key: "foo", value: 1 });
db[name].save({ _key: "bar", value: 1 });
assertEqual(2, db[name].count());
db._useDatabase("_system");
assertEqual(1, db[name].count());
db._dropDatabase("UnitTestsDatabase0");
}
};
}
// -----------------------------------------------------------------------------
// --SECTION-- main
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief executes the test suite
////////////////////////////////////////////////////////////////////////////////
jsunity.run(DatabaseSuite);
return jsunity.done();
// Local Variables:
// mode: outline-minor
// outline-regexp: "^\\(/// @brief\\|/// @addtogroup\\|// --SECTION--\\|/// @page\\|/// @}\\)"
// End:
Reference in New Issue View Git Blame Copy Permalink