mirror of https://gitee.com/bigwinds/arangodb
4946 lines
134 KiB
JavaScript
4946 lines
134 KiB
JavaScript
/*jshint globalstrict:false, strict:false, maxlen : 200 */
|
|
/*global fail, assertTrue, assertEqual, TRANSACTION */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tests for transactions
|
|
///
|
|
/// @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 2013, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var jsunity = require("jsunity");
|
|
var internal = require("internal");
|
|
var arangodb = require("@arangodb");
|
|
var helper = require("@arangodb/aql-helper");
|
|
var db = arangodb.db;
|
|
var testHelper = require("@arangodb/test-helper").Helper;
|
|
|
|
var compareStringIds = function (l, r) {
|
|
'use strict';
|
|
var i;
|
|
if (l.length !== r.length) {
|
|
return l.length - r.length < 0 ? -1 : 1;
|
|
}
|
|
|
|
// length is equal
|
|
for (i = 0; i < l.length; ++i) {
|
|
if (l[i] !== r[i]) {
|
|
return l[i] < r[i] ? -1 : 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
};
|
|
|
|
var sortedKeys = function (col) {
|
|
'use strict';
|
|
var keys = [ ];
|
|
|
|
col.toArray().forEach(function (d) {
|
|
keys.push(d._key);
|
|
});
|
|
|
|
keys.sort();
|
|
return keys;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function transactionInvocationSuite () {
|
|
'use strict';
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: invalid invocations of TRANSACTION() function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testInvalidInvocations : function () {
|
|
var tests = [
|
|
undefined,
|
|
null,
|
|
true,
|
|
false,
|
|
0,
|
|
1,
|
|
"foo",
|
|
{ }, { },
|
|
{ }, { }, { },
|
|
false, true,
|
|
[ ],
|
|
[ "action" ],
|
|
[ "collections" ],
|
|
[ "collections", "action" ],
|
|
{ },
|
|
{ collections: true },
|
|
{ action: true },
|
|
{ action: function () { } },
|
|
{ collections: true, action: true },
|
|
{ collections: { }, action: true },
|
|
{ collections: { } },
|
|
{ collections: true, action: function () { } },
|
|
{ collections: { read: true }, action: function () { } },
|
|
{ collections: { }, lockTimeout: -1, action: function () { } },
|
|
{ collections: { }, lockTimeout: -30.0, action: function () { } },
|
|
{ collections: { }, lockTimeout: null, action: function () { } },
|
|
{ collections: { }, lockTimeout: true, action: function () { } },
|
|
{ collections: { }, lockTimeout: "foo", action: function () { } },
|
|
{ collections: { }, lockTimeout: [ ], action: function () { } },
|
|
{ collections: { }, lockTimeout: { }, action: function () { } },
|
|
{ collections: { }, waitForSync: null, action: function () { } },
|
|
{ collections: { }, waitForSync: 0, action: function () { } },
|
|
{ collections: { }, waitForSync: "foo", action: function () { } },
|
|
{ collections: { }, waitForSync: [ ], action: function () { } },
|
|
{ collections: { }, waitForSync: { }, action: function () { } }
|
|
];
|
|
|
|
tests.forEach(function (test) {
|
|
try {
|
|
TRANSACTION(test);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_BAD_PARAMETER.code, err.errorNum);
|
|
}
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: valid invocations of TRANSACTION() function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testValidEmptyInvocations : function () {
|
|
var result;
|
|
|
|
var tests = [
|
|
{ collections: { }, action: function () { result = 1; return true; } },
|
|
{ collections: { read: [ ] }, action: function () { result = 1; return true; } },
|
|
{ collections: { write: [ ] }, action: function () { result = 1; return true; } },
|
|
{ collections: { read: [ ], write: [ ] }, action: function () { result = 1; return true; } },
|
|
{ collections: { read: [ ], write: [ ] }, lockTimeout: 5.0, action: function () { result = 1; return true; } },
|
|
{ collections: { read: [ ], write: [ ] }, lockTimeout: 0.0, action: function () { result = 1; return true; } },
|
|
{ collections: { read: [ ], write: [ ] }, waitForSync: true, action: function () { result = 1; return true; } },
|
|
{ collections: { read: [ ], write: [ ] }, waitForSync: false, action: function () { result = 1; return true; } }
|
|
];
|
|
|
|
tests.forEach(function (test) {
|
|
result = 0;
|
|
|
|
TRANSACTION(test);
|
|
assertEqual(1, result);
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: return values
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnValues : function () {
|
|
var tests = [
|
|
{ expected: 1, trx: { collections: { }, action: function () { return 1; } } },
|
|
{ expected: undefined, trx: { collections: { }, action: function () { } } },
|
|
{ expected: [ ], trx: { collections: { read: [ ] }, action: function () { return [ ]; } } },
|
|
{ expected: [ null, true, false ], trx: { collections: { write: [ ] }, action: function () { return [ null, true, false ]; } } },
|
|
{ expected: "foo", trx: { collections: { read: [ ], write: [ ] }, action: function () { return "foo"; } } },
|
|
{ expected: { "a" : 1, "b" : 2 }, trx: { collections: { read: [ ], write: [ ] }, action: function () { return { "a" : 1, "b" : 2 }; } } }
|
|
];
|
|
|
|
tests.forEach(function (test) {
|
|
assertEqual(test.expected, TRANSACTION(test.trx));
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: action
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testActionFunction : function () {
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function () {
|
|
return 42;
|
|
}
|
|
};
|
|
|
|
assertEqual(42, TRANSACTION(obj));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: action
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testActionInvalidString : function () {
|
|
try {
|
|
TRANSACTION({
|
|
collections : {
|
|
},
|
|
action : "return 42;"
|
|
});
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_BAD_PARAMETER.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: action
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testActionString : function () {
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : "function () { return 42; }"
|
|
};
|
|
|
|
assertEqual(42, TRANSACTION(obj));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: nesting
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNesting : function () {
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function () {
|
|
TRANSACTION({
|
|
collections: {
|
|
},
|
|
action: "function () { return 1; }"
|
|
});
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_TRANSACTION_NESTED.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: nesting
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNestingEmbedFlag : function () {
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function () {
|
|
return 19 + TRANSACTION({
|
|
collections: {
|
|
},
|
|
embed: true,
|
|
action: "function () { return 23; }"
|
|
});
|
|
}
|
|
};
|
|
|
|
assertEqual(42, TRANSACTION(obj));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: params
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testParamsFunction : function () {
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function (params) {
|
|
return [ params[1], params[4] ];
|
|
},
|
|
params: [ 1, 2, 3, 4, 5 ]
|
|
};
|
|
|
|
assertEqual([ 2, 5 ], TRANSACTION(obj));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: params
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testParamsString : function () {
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : "function (params) { return [ params[1], params[4] ]; }",
|
|
params: [ 1, 2, 3, 4, 5 ]
|
|
};
|
|
|
|
assertEqual([ 2, 5 ], TRANSACTION(obj));
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function transactionCollectionsSuite () {
|
|
'use strict';
|
|
var cn1 = "UnitTestsTransaction1";
|
|
var cn2 = "UnitTestsTransaction2";
|
|
|
|
var c1 = null;
|
|
var c2 = null;
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._drop(cn1);
|
|
c1 = db._create(cn1);
|
|
|
|
db._drop(cn2);
|
|
c2 = db._create(cn2);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
if (c1 !== null) {
|
|
c1.drop();
|
|
}
|
|
|
|
c1 = null;
|
|
|
|
if (c2 !== null) {
|
|
c2.drop();
|
|
}
|
|
|
|
c2 = null;
|
|
internal.wait(0);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx using non-existing collections
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNonExistingCollectionsArray : function () {
|
|
var obj = {
|
|
collections : {
|
|
read : [ "UnitTestsTransactionNonExisting" ]
|
|
},
|
|
action : function () {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_ARANGO_COLLECTION_NOT_FOUND.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx using non-existing collections
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNonExistingCollectionsString : function () {
|
|
var obj = {
|
|
collections : {
|
|
read : "UnitTestsTransactionNonExisting"
|
|
},
|
|
action : function () {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_ARANGO_COLLECTION_NOT_FOUND.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx using non-declared collections
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNonDeclaredCollections1 : function () {
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function () {
|
|
c1.save({ _key : "foo" });
|
|
return true;
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_TRANSACTION_UNREGISTERED_COLLECTION.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx using non-declared collections
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNonDeclaredCollections2 : function () {
|
|
var obj = {
|
|
collections : {
|
|
write : [ cn2 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ _key : "foo" });
|
|
return true;
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_TRANSACTION_UNREGISTERED_COLLECTION.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx using wrong mode
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNonDeclaredCollections3 : function () {
|
|
var obj = {
|
|
collections : {
|
|
read : [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ _key : "foo" });
|
|
return true;
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_TRANSACTION_UNREGISTERED_COLLECTION.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx using no collections
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNoCollections : function () {
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function () {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx using no collections
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNoCollectionsAql : function () {
|
|
var result;
|
|
var getQueryResults = helper.getQueryResults;
|
|
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function () {
|
|
result = getQueryResults("FOR i IN [ 1, 2, 3 ] RETURN i");
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
assertEqual([ 1, 2, 3 ], result);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx using valid collections
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testValidCollectionsArray : function () {
|
|
var obj = {
|
|
collections : {
|
|
write : [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ _key : "foo" });
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
},
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx using valid collections
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testValidCollectionsString : function () {
|
|
var obj = {
|
|
collections : {
|
|
write : cn1
|
|
},
|
|
action : function () {
|
|
c1.save({ _key : "foo" });
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx using valid collections
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testValidMultipleCollectionsArray : function () {
|
|
var obj = {
|
|
collections : {
|
|
write : [ cn1, cn2 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ _key : "foo" });
|
|
c2.save({ _key : "foo" });
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx using valid collections
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testValidMultipleCollectionsString : function () {
|
|
c2.save({ _key : "foo" });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write : cn1,
|
|
read: cn2
|
|
},
|
|
action : function () {
|
|
c1.save({ _key : "foo" });
|
|
c2.document("foo");
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx using valid collections
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRedeclareCollectionArray : function () {
|
|
var obj = {
|
|
collections : {
|
|
read : [ cn1 ],
|
|
write : [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ _key : "foo" });
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx using valid collections
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRedeclareCollectionString : function () {
|
|
var obj = {
|
|
collections : {
|
|
read : cn1,
|
|
write : cn1
|
|
},
|
|
action : function () {
|
|
c1.save({ _key : "foo" });
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx using valid collections
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReadWriteCollections : function () {
|
|
var obj = {
|
|
collections : {
|
|
read : [ cn1 ],
|
|
write : [ cn2 ]
|
|
},
|
|
action : function () {
|
|
c2.save({ _key : "foo" });
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx using waitForSync
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testWaitForSyncTrue : function () {
|
|
var obj = {
|
|
collections : {
|
|
write : [ cn1 ]
|
|
},
|
|
waitForSync: true,
|
|
action : function () {
|
|
c1.save({ _key : "foo" });
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx using waitForSync
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testWaitForSyncFalse : function () {
|
|
var obj = {
|
|
collections : {
|
|
write : [ cn1 ]
|
|
},
|
|
waitForSync: false,
|
|
action : function () {
|
|
c1.save({ _key : "foo" });
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with embedded AQL
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAqlRead : function () {
|
|
var i = 0;
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.save({ _key : "test" + i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
read : [ cn1 ]
|
|
},
|
|
action : function () {
|
|
var docs = db._query("FOR i IN @@cn1 RETURN i", { "@cn1" : cn1 }).toArray();
|
|
assertEqual(10, docs.length);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with embedded AQL
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAqlReadMulti : function () {
|
|
var i = 0;
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.save({ _key : "test" + i });
|
|
c2.save({ _key : "test" + i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
read : [ cn1, cn2 ]
|
|
},
|
|
action : function () {
|
|
var docs = db._query("FOR i IN @@cn1 FOR j IN @@cn2 RETURN i", { "@cn1" : cn1, "@cn2" : cn2 }).toArray();
|
|
assertEqual(100, docs.length);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with embedded AQL
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAqlReadMultiUndeclared : function () {
|
|
var i = 0;
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.save({ _key : "test" + i });
|
|
c2.save({ _key : "test" + i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
// intentionally empty
|
|
},
|
|
action : function () {
|
|
var docs = db._query("FOR i IN @@cn1 FOR j IN @@cn2 RETURN i", { "@cn1" : cn1, "@cn2" : cn2 }).toArray();
|
|
assertEqual(100, docs.length);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with embedded AQL
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAqlWrite : function () {
|
|
var i = 0;
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.save({ _key : "test" + i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
var ops = db._query("FOR i IN @@cn1 REMOVE i._key IN @@cn1", { "@cn1" : cn1 }).getExtra().stats;
|
|
assertEqual(10, ops.writesExecuted);
|
|
assertEqual(0, c1.count());
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
assertEqual(0, c1.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with embedded AQL
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAqlReadWrite : function () {
|
|
var i = 0;
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.save({ _key : "test" + i });
|
|
c2.save({ _key : "test" + i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
read: [ cn1 ],
|
|
write: [ cn2 ]
|
|
},
|
|
action : function () {
|
|
var ops = db._query("FOR i IN @@cn1 REMOVE i._key IN @@cn2", { "@cn1" : cn1, "@cn2" : cn2 }).getExtra().stats;
|
|
assertEqual(10, ops.writesExecuted);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
|
|
assertEqual(10, c1.count());
|
|
assertEqual(0, c2.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with embedded AQL
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAqlWriteUndeclared : function () {
|
|
var i = 0;
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.save({ _key : "test" + i });
|
|
c2.save({ _key : "test" + i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
read: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
try{
|
|
db._query("FOR i IN @@cn1 REMOVE i._key IN @@cn2", { "@cn1" : cn1, "@cn2" : cn2 });
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_TRANSACTION_UNREGISTERED_COLLECTION.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(10, c1.count());
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
|
|
assertEqual(10, c1.count());
|
|
assertEqual(10, c2.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with embedded AQL
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAqlMultiWrite : function () {
|
|
var i = 0;
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.save({ _key : "test" + i });
|
|
c2.save({ _key : "test" + i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1, cn2 ]
|
|
},
|
|
action : function () {
|
|
var ops;
|
|
ops = db._query("FOR i IN @@cn1 REMOVE i._key IN @@cn1", { "@cn1" : cn1 }).getExtra().stats;
|
|
assertEqual(10, ops.writesExecuted);
|
|
assertEqual(0, c1.count());
|
|
|
|
ops = db._query("FOR i IN @@cn2 REMOVE i._key IN @@cn2", { "@cn2" : cn2 }).getExtra().stats;
|
|
assertEqual(10, ops.writesExecuted);
|
|
assertEqual(0, c2.count());
|
|
return true;
|
|
}
|
|
};
|
|
|
|
assertTrue(TRANSACTION(obj));
|
|
|
|
assertEqual(0, c1.count());
|
|
assertEqual(0, c2.count());
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function transactionOperationsSuite () {
|
|
'use strict';
|
|
var cn1 = "UnitTestsTransaction1";
|
|
var cn2 = "UnitTestsTransaction2";
|
|
|
|
var c1 = null;
|
|
var c2 = null;
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._drop(cn1);
|
|
db._drop(cn2);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
if (c1 !== null) {
|
|
c1.drop();
|
|
}
|
|
|
|
c1 = null;
|
|
|
|
if (c2 !== null) {
|
|
c2.drop();
|
|
}
|
|
|
|
c2 = null;
|
|
internal.wait(0);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with create operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCreate : function () {
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function () {
|
|
db._create(cn1);
|
|
fail();
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_TRANSACTION_DISALLOWED_OPERATION.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with drop operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testDrop : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function () {
|
|
c1.drop();
|
|
fail();
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_TRANSACTION_DISALLOWED_OPERATION.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with rename operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRename : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function () {
|
|
c1.rename(cn2);
|
|
fail();
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_TRANSACTION_DISALLOWED_OPERATION.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with create index operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCreateHashConstraint : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function () {
|
|
c1.ensureUniqueConstraint("foo");
|
|
fail();
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_TRANSACTION_DISALLOWED_OPERATION.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with create index operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCreateHashIndex : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function () {
|
|
c1.ensureHashIndex("foo");
|
|
fail();
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_TRANSACTION_DISALLOWED_OPERATION.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with create index operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCreateSkiplistIndex : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function () {
|
|
c1.ensureSkiplist("foo");
|
|
fail();
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_TRANSACTION_DISALLOWED_OPERATION.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with create index operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCreateSkiplistConstraint : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function () {
|
|
c1.ensureUniqueSkiplist("foo");
|
|
fail();
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_TRANSACTION_DISALLOWED_OPERATION.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with create index operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCreateFulltextIndex : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function () {
|
|
c1.ensureFulltextIndex("foo");
|
|
fail();
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_TRANSACTION_DISALLOWED_OPERATION.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with create index operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCreateGeoIndex : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function () {
|
|
c1.ensureGeoIndex("foo", "bar");
|
|
fail();
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_TRANSACTION_DISALLOWED_OPERATION.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with create index operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCreateGeoConstraint : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function () {
|
|
c1.ensureGeoConstraint("foo", "bar", true);
|
|
fail();
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_TRANSACTION_DISALLOWED_OPERATION.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with drop index operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testDropIndex : function () {
|
|
c1 = db._create(cn1);
|
|
var idx = c1.ensureUniqueConstraint("foo");
|
|
|
|
var obj = {
|
|
collections : {
|
|
},
|
|
action : function () {
|
|
c1.dropIndex(idx.id);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(arangodb.errors.ERROR_TRANSACTION_DISALLOWED_OPERATION.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with read operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testSingleRead1 : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo", a: 1 });
|
|
|
|
var obj = {
|
|
collections : {
|
|
read: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
assertEqual(1, c1.document("foo").a);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(1, c1.count());
|
|
assertEqual([ "foo" ], sortedKeys(c1));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with read operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testSingleRead2 : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo", a: 1 });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
assertEqual(1, c1.document("foo").a);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(1, c1.count());
|
|
assertEqual([ "foo" ], sortedKeys(c1));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with read operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testScan1 : function () {
|
|
c1 = db._create(cn1);
|
|
for (var i = 0; i < 100; ++i) {
|
|
c1.save({ _key: "foo" + i, a: i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
read: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
assertEqual(100, c1.toArray().length);
|
|
assertEqual(100, c1.count());
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
assertEqual(i, c1.document("foo" + i).a);
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(100, c1.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with read operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testScan2 : function () {
|
|
c1 = db._create(cn1);
|
|
for (var i = 0; i < 100; ++i) {
|
|
c1.save({ _key: "foo" + i, a: i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
assertEqual(100, c1.toArray().length);
|
|
assertEqual(100, c1.count());
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
assertEqual(i, c1.document("foo" + i).a);
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(100, c1.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with insert operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testSingleInsert : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ _key: "foo" });
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(1, c1.count());
|
|
assertEqual([ "foo" ], sortedKeys(c1));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with insert operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMultiInsert : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ _key: "foo" });
|
|
c1.save({ _key: "bar" });
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(2, c1.count());
|
|
assertEqual([ "bar", "foo" ], sortedKeys(c1));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with insert operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testInsertWithExisting : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo" });
|
|
c1.save({ _key: "bar" });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ _key: "baz" });
|
|
c1.save({ _key: "bam" });
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(4, c1.count());
|
|
assertEqual([ "bam", "bar", "baz", "foo" ], sortedKeys(c1));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with replace operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReplace : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo", a: 1 });
|
|
c1.save({ _key: "bar", b: 2, c: 3 });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
assertEqual(1, c1.document("foo").a);
|
|
c1.replace("foo", { a: 3 });
|
|
|
|
assertEqual(2, c1.document("bar").b);
|
|
assertEqual(3, c1.document("bar").c);
|
|
c1.replace("bar", { b: 9 });
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(2, c1.count());
|
|
assertEqual([ "bar", "foo" ], sortedKeys(c1));
|
|
assertEqual(3, c1.document("foo").a);
|
|
assertEqual(9, c1.document("bar").b);
|
|
assertEqual(undefined, c1.document("bar").c);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with replace operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReplaceReplace : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo", a: 1 });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
assertEqual(1, c1.document("foo").a);
|
|
c1.replace("foo", { a: 3 });
|
|
assertEqual(3, c1.document("foo").a);
|
|
c1.replace("foo", { a: 4 });
|
|
assertEqual(4, c1.document("foo").a);
|
|
c1.replace("foo", { a: 5 });
|
|
assertEqual(5, c1.document("foo").a);
|
|
c1.replace("foo", { a: 6, b: 99 });
|
|
assertEqual(6, c1.document("foo").a);
|
|
assertEqual(99, c1.document("foo").b);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(1, c1.count());
|
|
assertEqual(6, c1.document("foo").a);
|
|
assertEqual(99, c1.document("foo").b);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with update operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUpdate : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo", a: 1 });
|
|
c1.save({ _key: "bar", b: 2 });
|
|
c1.save({ _key: "baz", c: 3 });
|
|
c1.save({ _key: "bam", d: 4 });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
assertEqual(1, c1.document("foo").a);
|
|
c1.update("foo", { a: 3 });
|
|
|
|
assertEqual(2, c1.document("bar").b);
|
|
c1.update("bar", { b: 9 });
|
|
|
|
assertEqual(3, c1.document("baz").c);
|
|
c1.update("baz", { b: 9, c: 12 });
|
|
|
|
assertEqual(4, c1.document("bam").d);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(4, c1.count());
|
|
assertEqual([ "bam", "bar", "baz", "foo" ], sortedKeys(c1));
|
|
assertEqual(3, c1.document("foo").a);
|
|
assertEqual(9, c1.document("bar").b);
|
|
assertEqual(9, c1.document("baz").b);
|
|
assertEqual(12, c1.document("baz").c);
|
|
assertEqual(4, c1.document("bam").d);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with remove operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemove : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo", a: 1 });
|
|
c1.save({ _key: "bar", b: 2 });
|
|
c1.save({ _key: "baz", c: 3 });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.remove("foo");
|
|
c1.remove("baz");
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(1, c1.count());
|
|
assertEqual([ "bar" ], sortedKeys(c1));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with truncate operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testTruncateEmpty : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.truncate();
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(0, c1.count());
|
|
assertEqual([ ], sortedKeys(c1));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with truncate operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testTruncateNonEmpty : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
c1.save({ a: i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.truncate();
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(0, c1.count());
|
|
assertEqual([ ], sortedKeys(c1));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with truncate operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testTruncateAndAdd : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
c1.save({ a: i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.truncate();
|
|
c1.save({ _key: "foo" });
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(1, c1.count());
|
|
assertEqual([ "foo" ], sortedKeys(c1));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with byExample operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExample : function () {
|
|
c1 = db._create(cn1);
|
|
c1.ensureUniqueConstraint("name");
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
c1.save({ name: "test" + i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
var r = c1.byExample({ name: "test99" }).toArray();
|
|
assertEqual(r.length, 1);
|
|
assertEqual("test99", r[0].name);
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with firstExample operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFirstExample1 : function () {
|
|
c1 = db._create(cn1);
|
|
c1.ensureUniqueConstraint("name");
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
c1.save({ name: "test" + i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
var r = c1.firstExample({ name: "test99" });
|
|
assertEqual("test99", r.name);
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with firstExample operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFirstExample2 : function () {
|
|
c1 = db._create(cn1);
|
|
c1.ensureHashIndex("name");
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
c1.save({ name: "test" + i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
var r = c1.firstExample({ name: "test99" });
|
|
assertEqual("test99", r.name);
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with firstExample operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFirstExample3 : function () {
|
|
c1 = db._create(cn1);
|
|
c1.ensureUniqueSkiplist("name");
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
c1.save({ name: "test" + i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
var r = c1.firstExample({ name: "test99" });
|
|
assertEqual("test99", r.name);
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with firstExample operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFirstExample4 : function () {
|
|
c1 = db._create(cn1);
|
|
c1.ensureSkiplist("name");
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
c1.save({ name: "test" + i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
var r = c1.firstExample({ name: "test99" });
|
|
assertEqual("test99", r.name);
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx with fulltext operation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testFulltext : function () {
|
|
c1 = db._create(cn1);
|
|
var idx = c1.ensureFulltextIndex("text");
|
|
|
|
c1.save({ text: "steam", other: 1 });
|
|
c1.save({ text: "steamboot", other: 2 });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
var r = c1.FULLTEXT(idx, "prefix:steam");
|
|
assertEqual(2, r.documents.length);
|
|
|
|
r = c1.FULLTEXT(idx, "steam");
|
|
assertEqual(1, r.documents.length);
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function transactionBarriersSuite () {
|
|
'use strict';
|
|
var cn1 = "UnitTestsTransaction1";
|
|
var cn2 = "UnitTestsTransaction2";
|
|
|
|
var c1 = null;
|
|
var c2 = null;
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._drop(cn1);
|
|
db._drop(cn2);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
if (c1 !== null) {
|
|
c1.drop();
|
|
}
|
|
|
|
c1 = null;
|
|
|
|
if (c2 !== null) {
|
|
c2.drop();
|
|
}
|
|
|
|
c2 = null;
|
|
internal.wait(0);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: usage of barriers outside of transaction
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testBarriersOutsideCommit : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var docs = [ ];
|
|
var i;
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
for (i = 0; i < 100; ++i) {
|
|
c1.save({ _key: "foo" + i, value1: i, value2: "foo" + i + "x" });
|
|
}
|
|
|
|
for (i = 0; i < 100; ++i) {
|
|
docs.push(c1.document("foo" + i));
|
|
}
|
|
|
|
return c1.document("foo0");
|
|
}
|
|
};
|
|
|
|
var result = TRANSACTION(obj);
|
|
|
|
assertEqual(100, docs.length);
|
|
assertEqual(100, c1.count());
|
|
|
|
assertEqual("foo0", result._key);
|
|
assertEqual(0, result.value1);
|
|
assertEqual("foo0x", result.value2);
|
|
|
|
for (i = 0; i < 100; ++i) {
|
|
assertEqual("foo" + i, docs[i]._key);
|
|
assertEqual(i, docs[i].value1);
|
|
assertEqual("foo" + i + "x", docs[i].value2);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: usage of barriers outside of transaction
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testBarriersOutsideRollback : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var docs = [ ];
|
|
var i;
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
for (i = 0; i < 100; ++i) {
|
|
c1.save({ _key: "foo" + i, value1: i, value2: "foo" + i + "x" });
|
|
}
|
|
|
|
for (i = 0; i < 100; ++i) {
|
|
docs.push(c1.document("foo" + i));
|
|
}
|
|
|
|
throw "doh!";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(100, docs.length);
|
|
|
|
for (i = 0; i < 100; ++i) {
|
|
assertEqual("foo" + i, docs[i]._key);
|
|
assertEqual(i, docs[i].value1);
|
|
assertEqual("foo" + i + "x", docs[i].value2);
|
|
}
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function transactionGraphSuite () {
|
|
'use strict';
|
|
var cn1 = "UnitTestsVertices";
|
|
var cn2 = "UnitTestsEdges";
|
|
|
|
var G = require('@arangodb/graph').Graph;
|
|
|
|
var c1 = null;
|
|
var c2 = null;
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._drop(cn1);
|
|
db._drop(cn2);
|
|
|
|
c1 = db._create(cn1);
|
|
c2 = db._createEdgeCollection(cn2);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
if (c1 !== null) {
|
|
c1.drop();
|
|
}
|
|
|
|
c1 = null;
|
|
|
|
if (c2 !== null) {
|
|
c2.drop();
|
|
}
|
|
|
|
c2 = null;
|
|
internal.wait(0);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback updates in a graph transaction
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackGraphUpdates : function () {
|
|
var graph;
|
|
|
|
try {
|
|
graph = new G('UnitTestsGraph');
|
|
graph.drop();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
graph = new G('UnitTestsGraph', cn1, cn2);
|
|
var gotHere = 0;
|
|
|
|
assertEqual(0, db[cn1].count());
|
|
|
|
var obj = {
|
|
collections: {
|
|
write: [ cn1, cn2 ]
|
|
},
|
|
action : function () {
|
|
var result = { };
|
|
result.enxirvp = graph.addVertex(null, { _rev : null })._properties;
|
|
result.biitqtk = graph.addVertex(null, { _rev : null })._properties;
|
|
result.oboyuhh = graph.addEdge(graph.getVertex(result.enxirvp._id), graph.getVertex(result.biitqtk._id), null, { name: "john smith" })._properties;
|
|
result.cvwmkym = db[cn1].replace(result.enxirvp._id, { _rev : null });
|
|
result.gsalfxu = db[cn1].replace(result.biitqtk._id, { _rev : null });
|
|
result.xsjzbst = (function (){
|
|
graph.removeEdge(graph.getEdge(result.oboyuhh._id));
|
|
return true;
|
|
}());
|
|
|
|
result.thizhdd = graph.addEdge(graph.getVertex(result.cvwmkym._id), graph.getVertex(result.gsalfxu._id), result.oboyuhh._key, { name: "david smith" });
|
|
gotHere = 1;
|
|
|
|
result.rldfnre = graph.addEdge(graph.getVertex(result.cvwmkym._id), graph.getVertex(result.gsalfxu._id), result.oboyuhh._key, { name : "david smith" })._properties;
|
|
gotHere = 2;
|
|
|
|
return result;
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(0, db[cn1].count());
|
|
assertEqual(0, db[cn2].count());
|
|
assertEqual(1, gotHere);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: usage of barriers outside of graph transaction
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUseBarriersOutsideGraphTransaction : function () {
|
|
var graph;
|
|
|
|
try {
|
|
graph = new G('UnitTestsGraph');
|
|
graph.drop();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
graph = new G('UnitTestsGraph', cn1, cn2);
|
|
|
|
var obj = {
|
|
collections: {
|
|
write: [ cn1, cn2 ]
|
|
},
|
|
action : function () {
|
|
var result = { };
|
|
|
|
result.enxirvp = graph.addVertex(null, { _rev : null })._properties;
|
|
result.biitqtk = graph.addVertex(null, { _rev : null })._properties;
|
|
result.oboyuhh = graph.addEdge(graph.getVertex(result.enxirvp._id), graph.getVertex(result.biitqtk._id), null, { name : "john smith" })._properties;
|
|
result.cvwmkym = db[cn1].replace(result.enxirvp._id, { _rev : null });
|
|
result.gsalfxu = db[cn1].replace(result.biitqtk._id, { _rev : null });
|
|
result.xsjzbst = (function (){
|
|
graph.removeEdge(graph.getEdge(result.oboyuhh._id));
|
|
return true;
|
|
}());
|
|
|
|
result.rldfnre = graph.addEdge(graph.getVertex(result.cvwmkym._id), graph.getVertex(result.gsalfxu._id), result.oboyuhh._key, { name : "david smith" })._properties;
|
|
|
|
return result;
|
|
}
|
|
};
|
|
|
|
var result = TRANSACTION(obj);
|
|
assertTrue(result.enxirvp._key.length > 0);
|
|
assertEqual(undefined, result.enxirvp.name);
|
|
|
|
assertTrue(result.biitqtk._key.length > 0);
|
|
assertEqual(undefined, result.biitqtk.name);
|
|
|
|
assertTrue(result.oboyuhh._key.length > 0);
|
|
assertEqual("john smith", result.oboyuhh.name);
|
|
assertEqual(null, result.oboyuhh.$label);
|
|
assertTrue(result.oboyuhh._from.length > 0);
|
|
assertTrue(result.oboyuhh._to.length > 0);
|
|
|
|
assertTrue(result.cvwmkym._key.length > 0);
|
|
assertEqual(undefined, result.cvwmkym.name);
|
|
assertEqual(result.enxirvp._rev, result.cvwmkym._oldRev);
|
|
|
|
assertTrue(result.gsalfxu._key.length > 0);
|
|
assertEqual(undefined, result.gsalfxu.name);
|
|
assertEqual(result.biitqtk._rev, result.gsalfxu._oldRev);
|
|
|
|
assertEqual(true, result.xsjzbst);
|
|
|
|
assertTrue(result.rldfnre._key.length > 0);
|
|
assertEqual(result.oboyuhh._key, result.rldfnre._key);
|
|
assertEqual("david smith", result.rldfnre.name);
|
|
assertEqual(null, result.rldfnre.$label);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: usage of read-copied documents inside write-transaction
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReadWriteDocumentsList : function () {
|
|
c1.save({ _key: "bar" });
|
|
c1.save({ _key: "baz" });
|
|
c2.save(cn1 + "/bar", cn1 + "/baz", { type: "one" });
|
|
c2.save(cn1 + "/baz", cn1 + "/bar", { type: "two" });
|
|
|
|
var obj = {
|
|
collections: {
|
|
write: [ cn2 ]
|
|
},
|
|
action : function () {
|
|
var result = [ ];
|
|
|
|
result.push(c2.inEdges(cn1 + "/baz"));
|
|
result.push(c2.inEdges(cn1 + "/bar"));
|
|
|
|
c2.save(cn1 + "/foo", cn1 + "/baz", { type: "three" });
|
|
c2.save(cn1 + "/foo", cn1 + "/bar", { type: "four" });
|
|
|
|
result.push(c2.inEdges(cn1 + "/baz"));
|
|
result.push(c2.inEdges(cn1 + "/bar"));
|
|
|
|
return result;
|
|
}
|
|
};
|
|
|
|
var sorter = function (l, r) {
|
|
if (l.type !== r.type) {
|
|
if (l.type < r.type) {
|
|
return -1;
|
|
}
|
|
return 1;
|
|
}
|
|
return 0;
|
|
};
|
|
|
|
var result = TRANSACTION(obj);
|
|
|
|
assertEqual(4, result.length);
|
|
var r = result[0];
|
|
assertEqual(1, r.length);
|
|
assertEqual(cn1 + "/bar", r[0]._from);
|
|
assertEqual(cn1 + "/baz", r[0]._to);
|
|
assertEqual("one", r[0].type);
|
|
|
|
r = result[1];
|
|
assertEqual(1, r.length);
|
|
assertEqual(cn1 + "/baz", r[0]._from);
|
|
assertEqual(cn1 + "/bar", r[0]._to);
|
|
assertEqual("two", r[0].type);
|
|
|
|
r = result[2];
|
|
r.sort(sorter);
|
|
|
|
assertEqual(2, r.length);
|
|
assertEqual(cn1 + "/bar", r[0]._from);
|
|
assertEqual(cn1 + "/baz", r[0]._to);
|
|
assertEqual("one", r[0].type);
|
|
|
|
assertEqual(cn1 + "/foo", r[1]._from);
|
|
assertEqual(cn1 + "/baz", r[1]._to);
|
|
assertEqual("three", r[1].type);
|
|
|
|
r = result[3];
|
|
r.sort(sorter);
|
|
|
|
assertEqual(cn1 + "/foo", r[0]._from);
|
|
assertEqual(cn1 + "/bar", r[0]._to);
|
|
assertEqual("four", r[0].type);
|
|
|
|
assertEqual(2, r.length);
|
|
assertEqual(cn1 + "/baz", r[1]._from);
|
|
assertEqual(cn1 + "/bar", r[1]._to);
|
|
assertEqual("two", r[1].type);
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function transactionRollbackSuite () {
|
|
'use strict';
|
|
var cn1 = "UnitTestsTransaction1";
|
|
|
|
var c1 = null;
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._drop(cn1);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
if (c1 !== null) {
|
|
c1.drop();
|
|
}
|
|
|
|
c1 = null;
|
|
internal.wait(0);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback after flush
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackAfterFlush : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ _key: "tom" });
|
|
c1.save({ _key: "tim" });
|
|
c1.save({ _key: "tam" });
|
|
|
|
internal.wal.flush(true);
|
|
assertEqual(3, c1.count());
|
|
throw "rollback";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(0, c1.count());
|
|
|
|
testHelper.waitUnload(c1);
|
|
|
|
assertEqual(0, c1.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: the collection revision id
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackRevision : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo" });
|
|
|
|
var r = c1.revision();
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
var _r = r;
|
|
|
|
c1.save({ _key: "tom" });
|
|
assertEqual(1, compareStringIds(c1.revision(), _r));
|
|
_r = c1.revision();
|
|
|
|
c1.save({ _key: "tim" });
|
|
assertEqual(1, compareStringIds(c1.revision(), _r));
|
|
_r = c1.revision();
|
|
|
|
c1.save({ _key: "tam" });
|
|
assertEqual(1, compareStringIds(c1.revision(), _r));
|
|
_r = c1.revision();
|
|
|
|
c1.remove("tam");
|
|
assertEqual(1, compareStringIds(c1.revision(), _r));
|
|
_r = c1.revision();
|
|
|
|
c1.update("tom", { "bom" : true });
|
|
assertEqual(1, compareStringIds(c1.revision(), _r));
|
|
_r = c1.revision();
|
|
|
|
c1.remove("tom");
|
|
assertEqual(1, compareStringIds(c1.revision(), _r));
|
|
//_r = c1.revision();
|
|
|
|
throw "rollback";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(1, c1.count());
|
|
assertEqual(r, c1.revision());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback inserts
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackInsert : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo" });
|
|
c1.save({ _key: "bar" });
|
|
c1.save({ _key: "meow" });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ _key: "tom" });
|
|
c1.save({ _key: "tim" });
|
|
c1.save({ _key: "tam" });
|
|
|
|
assertEqual(6, c1.count());
|
|
throw "rollback";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(3, c1.count());
|
|
assertEqual([ "bar", "foo", "meow" ], sortedKeys(c1));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback inserts w/ secondary indexes
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackInsertSecondaryIndexes : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo", value: "foo", a: 1 });
|
|
c1.save({ _key: "bar", value: "bar", a: 1 });
|
|
c1.save({ _key: "meow", value: "meow" });
|
|
|
|
c1.ensureHashIndex("value");
|
|
c1.ensureSkiplist("value");
|
|
var good = false;
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ _key: "tom", value: "tom" });
|
|
c1.save({ _key: "tim", value: "tim" });
|
|
c1.save({ _key: "tam", value: "tam" });
|
|
c1.save({ _key: "troet", value: "foo", a: 2 });
|
|
c1.save({ _key: "floxx", value: "bar", a: 2 });
|
|
|
|
assertEqual(8, c1.count());
|
|
|
|
good = true;
|
|
throw "rollback";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
assertEqual(true, good);
|
|
|
|
assertEqual(3, c1.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback inserts
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackInsertUpdate : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo" });
|
|
c1.save({ _key: "bar" });
|
|
c1.save({ _key: "meow" });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ _key: "tom" });
|
|
c1.save({ _key: "tim" });
|
|
c1.save({ _key: "tam" });
|
|
|
|
c1.update("tom", { });
|
|
c1.update("tim", { });
|
|
c1.update("tam", { });
|
|
c1.update("bar", { });
|
|
c1.remove("foo");
|
|
c1.remove("bar");
|
|
c1.remove("meow");
|
|
c1.remove("tom");
|
|
|
|
assertEqual(2, c1.count());
|
|
throw "rollback";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(3, c1.count());
|
|
assertEqual([ "bar", "foo", "meow" ], sortedKeys(c1));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback update
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackUpdate : function () {
|
|
var d1, d2, d3;
|
|
|
|
c1 = db._create(cn1);
|
|
d1 = c1.save({ _key: "foo", a: 1 });
|
|
d2 = c1.save({ _key: "bar", a: 2 });
|
|
d3 = c1.save({ _key: "meow", a: 3 });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.update(d1, { a: 4 });
|
|
c1.update(d2, { a: 5 });
|
|
c1.update(d3, { a: 6 });
|
|
|
|
assertEqual(3, c1.count());
|
|
throw "rollback";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(3, c1.count());
|
|
assertEqual([ "bar", "foo", "meow" ], sortedKeys(c1));
|
|
assertEqual(d1._rev, c1.document("foo")._rev);
|
|
assertEqual(d2._rev, c1.document("bar")._rev);
|
|
assertEqual(d3._rev, c1.document("meow")._rev);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback update
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackUpdateUpdate : function () {
|
|
var d1, d2, d3;
|
|
|
|
c1 = db._create(cn1);
|
|
d1 = c1.save({ _key: "foo", a: 1 });
|
|
d2 = c1.save({ _key: "bar", a: 2 });
|
|
d3 = c1.save({ _key: "meow", a: 3 });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
for (var i = 0; i < 100; ++i) {
|
|
c1.replace("foo", { a: i });
|
|
c1.replace("bar", { a: i + 42 });
|
|
c1.replace("meow", { a: i + 23 });
|
|
|
|
assertEqual(i, c1.document("foo").a);
|
|
assertEqual(i + 42, c1.document("bar").a);
|
|
assertEqual(i + 23, c1.document("meow").a);
|
|
}
|
|
|
|
assertEqual(3, c1.count());
|
|
|
|
throw "rollback";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(3, c1.count());
|
|
assertEqual([ "bar", "foo", "meow" ], sortedKeys(c1));
|
|
assertEqual(1, c1.document("foo").a);
|
|
assertEqual(2, c1.document("bar").a);
|
|
assertEqual(3, c1.document("meow").a);
|
|
assertEqual(d1._rev, c1.document("foo")._rev);
|
|
assertEqual(d2._rev, c1.document("bar")._rev);
|
|
assertEqual(d3._rev, c1.document("meow")._rev);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback remove w/ secondary indexes
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackUpdateSecondaryIndexes : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo", value: "foo", a: 1 });
|
|
c1.save({ _key: "bar", value: "bar", a: 1 });
|
|
c1.save({ _key: "meow", value: "meow" });
|
|
|
|
c1.ensureHashIndex("value");
|
|
c1.ensureSkiplist("value");
|
|
var good = false;
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.update("foo", { value: "foo", a: 2 });
|
|
c1.update("bar", { value: "bar", a: 2 });
|
|
c1.update("meow", { value: "troet" });
|
|
|
|
assertEqual(3, c1.count());
|
|
|
|
good = true;
|
|
throw "rollback";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(true, good);
|
|
assertEqual(3, c1.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback remove
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackRemove : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo" });
|
|
c1.save({ _key: "bar" });
|
|
c1.save({ _key: "meow" });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.remove("meow");
|
|
c1.remove("foo");
|
|
|
|
assertEqual(1, c1.count());
|
|
assertEqual([ "bar" ], sortedKeys(c1));
|
|
|
|
throw "rollback";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(3, c1.count());
|
|
assertEqual([ "bar", "foo", "meow" ], sortedKeys(c1));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback remove
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackRemoveMulti : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo" });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
for (var i = 0; i < 100; ++i) {
|
|
c1.save({ _key: "foo" + i });
|
|
}
|
|
|
|
assertEqual(101, c1.count());
|
|
|
|
throw "rollback";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(1, c1.count());
|
|
assertEqual([ "foo" ], sortedKeys(c1));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback remove w/ secondary indexes
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackRemoveSecondaryIndexes : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo", value: "foo", a: 1 });
|
|
c1.save({ _key: "bar", value: "bar", a: 1 });
|
|
c1.save({ _key: "meow", value: "meow" });
|
|
|
|
c1.ensureHashIndex("value");
|
|
c1.ensureSkiplist("value");
|
|
var good = false;
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.remove("meow");
|
|
c1.remove("bar");
|
|
c1.remove("foo");
|
|
|
|
assertEqual(0, c1.count());
|
|
|
|
good = true;
|
|
|
|
throw "rollback";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(true, good);
|
|
assertEqual(3, c1.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback insert/remove w/ secondary indexes
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackRemoveInsertSecondaryIndexes : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo", value: "foo", a: 1 });
|
|
c1.save({ _key: "bar", value: "bar", a: 1 });
|
|
c1.save({ _key: "meow", value: "meow" });
|
|
|
|
c1.ensureHashIndex("value");
|
|
c1.ensureSkiplist("value");
|
|
var good = false;
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.remove("meow");
|
|
c1.remove("bar");
|
|
c1.remove("foo");
|
|
assertEqual(0, c1.count());
|
|
|
|
c1.save({ _key: "foo2", value: "foo", a: 2 });
|
|
c1.save({ _key: "bar2", value: "bar", a: 2 });
|
|
assertEqual(2, c1.count());
|
|
|
|
good = true;
|
|
|
|
throw "rollback";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(true, good);
|
|
assertEqual(3, c1.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback truncate
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackTruncateEmpty : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
// truncate often...
|
|
for (var i = 0; i < 100; ++i) {
|
|
c1.truncate();
|
|
}
|
|
|
|
throw "rollback";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(0, c1.count());
|
|
assertEqual([ ], sortedKeys(c1));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback truncate
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackTruncateNonEmpty : function () {
|
|
c1 = db._create(cn1);
|
|
for (var i = 0; i < 100; ++i) {
|
|
c1.save({ _key: "foo" + i });
|
|
}
|
|
assertEqual(100, c1.count());
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
// truncate often...
|
|
for (var i = 0; i < 100; ++i) {
|
|
c1.truncate();
|
|
}
|
|
c1.save({ _key: "bar" });
|
|
|
|
throw "rollback";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(100, c1.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx rollback with unique constraint violation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackUniquePrimary : function () {
|
|
c1 = db._create(cn1);
|
|
var d1 = c1.save({ _key: "foo" });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ _key: "bar" });
|
|
c1.save({ _key: "foo" });
|
|
fail();
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(1, c1.count());
|
|
assertEqual("foo", c1.toArray()[0]._key);
|
|
assertEqual(d1._rev, c1.toArray()[0]._rev);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: trx rollback with unique constraint violation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackUniqueSecondary : function () {
|
|
c1 = db._create(cn1);
|
|
c1.ensureUniqueConstraint("name");
|
|
var d1 = c1.save({ name: "foo" });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ name: "bar" });
|
|
c1.save({ name: "baz" });
|
|
c1.save({ name: "foo" });
|
|
fail();
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
assertEqual(1, c1.count());
|
|
assertEqual("foo", c1.toArray()[0].name);
|
|
assertEqual(d1._rev, c1.toArray()[0]._rev);
|
|
},
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback a mixed workload
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackMixed1 : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var i;
|
|
|
|
for (i = 0; i < 100; ++i) {
|
|
c1.save({ _key: "key" + i, value: i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
|
|
for (i = 0; i < 50; ++i) {
|
|
c1.remove("key" + i);
|
|
}
|
|
|
|
for (i = 50; i < 100; ++i) {
|
|
c1.update("key" + i, { value: i - 50 });
|
|
}
|
|
|
|
c1.remove("key50");
|
|
throw "doh!";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(100, c1.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback a mixed workload
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackMixed2 : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
c1.save({ _key: "foo" });
|
|
c1.save({ _key: "bar" });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
var i;
|
|
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.save({ _key: "key" + i, value: i });
|
|
}
|
|
|
|
for (i = 0; i < 5; ++i) {
|
|
c1.remove("key" + i);
|
|
}
|
|
|
|
for (i = 5; i < 10; ++i) {
|
|
c1.update("key" + i, { value: i - 5 });
|
|
}
|
|
|
|
c1.remove("key5");
|
|
throw "doh!";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(2, c1.count());
|
|
assertEqual("foo", c1.document("foo")._key);
|
|
assertEqual("bar", c1.document("bar")._key);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback a mixed workload
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackMixed3 : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
c1.save({ _key: "foo" });
|
|
c1.save({ _key: "bar" });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
var i;
|
|
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.save({ _key: "key" + i, value: i });
|
|
}
|
|
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.remove("key" + i);
|
|
}
|
|
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.save({ _key: "key" + i, value: i });
|
|
}
|
|
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.update("key" + i, { value: i - 5 });
|
|
}
|
|
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.update("key" + i, { value: i + 5 });
|
|
}
|
|
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.remove("key" + i);
|
|
}
|
|
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.save({ _key: "key" + i, value: i });
|
|
}
|
|
|
|
throw "doh!";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(2, c1.count());
|
|
assertEqual("foo", c1.document("foo")._key);
|
|
assertEqual("bar", c1.document("bar")._key);
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function transactionCountSuite () {
|
|
'use strict';
|
|
var cn1 = "UnitTestsTransaction1";
|
|
|
|
var c1 = null;
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._drop(cn1);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
if (c1 !== null) {
|
|
c1.drop();
|
|
}
|
|
|
|
c1 = null;
|
|
internal.wait(0);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: test counts during trx
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCountDuring : function () {
|
|
c1 = db._create(cn1);
|
|
assertEqual(0, c1.count());
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
var d1, d2;
|
|
|
|
c1.save({ a : 1 });
|
|
assertEqual(1, c1.count());
|
|
|
|
d1 = c1.save({ a : 2 });
|
|
assertEqual(2, c1.count());
|
|
|
|
d2 = c1.update(d1, { a : 3 });
|
|
assertEqual(2, c1.count());
|
|
|
|
assertEqual(3, c1.document(d2).a);
|
|
|
|
c1.remove(d2);
|
|
assertEqual(1, c1.count());
|
|
|
|
c1.truncate();
|
|
assertEqual(0, c1.count());
|
|
|
|
c1.truncate();
|
|
assertEqual(0, c1.count());
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(0, c1.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: test counts during and after trx
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCountCommitAfterFlush : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo" });
|
|
c1.save({ _key: "bar" });
|
|
assertEqual(2, c1.count());
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ _key: "baz" });
|
|
assertEqual(3, c1.count());
|
|
|
|
internal.wal.flush(true, false);
|
|
|
|
c1.save({ _key: "meow" });
|
|
assertEqual(4, c1.count());
|
|
|
|
internal.wal.flush(true, false);
|
|
|
|
c1.remove("foo");
|
|
assertEqual(3, c1.count());
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(3, c1.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: test counts during and after trx
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCountCommit : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo" });
|
|
c1.save({ _key: "bar" });
|
|
assertEqual(2, c1.count());
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ _key: "baz" });
|
|
assertEqual(3, c1.count());
|
|
|
|
c1.save({ _key: "meow" });
|
|
assertEqual(4, c1.count());
|
|
|
|
c1.remove("foo");
|
|
assertEqual(3, c1.count());
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(3, c1.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: test counts during and after trx
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCountRollback : function () {
|
|
c1 = db._create(cn1);
|
|
c1.save({ _key: "foo" });
|
|
c1.save({ _key: "bar" });
|
|
assertEqual(2, c1.count());
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ _key: "baz" });
|
|
assertEqual(3, c1.count());
|
|
|
|
c1.save({ _key: "meow" });
|
|
assertEqual(4, c1.count());
|
|
|
|
c1.remove("foo");
|
|
assertEqual(3, c1.count());
|
|
|
|
throw "rollback";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
assertEqual(2, c1.count());
|
|
|
|
var keys = [ ];
|
|
c1.toArray().forEach(function (d) {
|
|
keys.push(d._key);
|
|
});
|
|
keys.sort();
|
|
assertEqual([ "bar", "foo" ], keys);
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function transactionCrossCollectionSuite () {
|
|
'use strict';
|
|
var cn1 = "UnitTestsTransaction1";
|
|
var cn2 = "UnitTestsTransaction2";
|
|
|
|
var c1 = null;
|
|
var c2 = null;
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._drop(cn1);
|
|
db._drop(cn2);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
if (c1 !== null) {
|
|
c1.drop();
|
|
}
|
|
|
|
c1 = null;
|
|
|
|
if (c2 !== null) {
|
|
c2.drop();
|
|
}
|
|
|
|
c2 = null;
|
|
internal.wait(0);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: test cross collection commit
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testInserts : function () {
|
|
c1 = db._create(cn1);
|
|
c2 = db._create(cn2);
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1, cn2 ]
|
|
},
|
|
action : function () {
|
|
var i;
|
|
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.save({ _key: "a" + i });
|
|
c2.save({ _key: "b" + i });
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(10, c1.count());
|
|
assertEqual(10, c2.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: test cross collection commit
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUpdates : function () {
|
|
c1 = db._create(cn1);
|
|
c2 = db._create(cn2);
|
|
|
|
var i;
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.save({ _key: "a" + i, a: i });
|
|
c2.save({ _key: "b" + i, b: i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1, cn2 ]
|
|
},
|
|
action : function () {
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.update("a" + i, { a: i + 20 });
|
|
|
|
c2.update("b" + i, { b: i + 20 });
|
|
c2.remove("b" + i);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(10, c1.count());
|
|
assertEqual(0, c2.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: test cross collection commit
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testDeletes : function () {
|
|
c1 = db._create(cn1);
|
|
c2 = db._create(cn2);
|
|
|
|
var i;
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.save({ _key: "a" + i, a: i });
|
|
c2.save({ _key: "b" + i, b: i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1, cn2 ]
|
|
},
|
|
action : function () {
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.remove("a" + i);
|
|
c2.remove("b" + i);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(0, c1.count());
|
|
assertEqual(0, c2.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: test cross collection commit
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testDeleteReload : function () {
|
|
c1 = db._create(cn1);
|
|
c2 = db._create(cn2);
|
|
|
|
var i;
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.save({ _key: "a" + i, a: i });
|
|
c2.save({ _key: "b" + i, b: i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1, cn2 ]
|
|
},
|
|
action : function () {
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.remove("a" + i);
|
|
c2.remove("b" + i);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(0, c1.count());
|
|
assertEqual(0, c2.count());
|
|
|
|
testHelper.waitUnload(c1);
|
|
testHelper.waitUnload(c2);
|
|
|
|
assertEqual(0, c1.count());
|
|
assertEqual(0, c2.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: test cross collection commit
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCommitReload : function () {
|
|
c1 = db._create(cn1);
|
|
c2 = db._create(cn2);
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1, cn2 ]
|
|
},
|
|
action : function () {
|
|
var i;
|
|
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.save({ _key: "a" + i });
|
|
}
|
|
|
|
for (i = 0; i < 10; ++i) {
|
|
c2.save({ _key: "b" + i });
|
|
}
|
|
|
|
assertEqual(10, c1.count());
|
|
assertEqual(10, c2.count());
|
|
|
|
c1.remove("a4");
|
|
c2.remove("b6");
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TRANSACTION(obj);
|
|
assertEqual(9, c1.count());
|
|
assertEqual(9, c2.count());
|
|
|
|
testHelper.waitUnload(c1);
|
|
testHelper.waitUnload(c2);
|
|
|
|
assertEqual(9, c1.count());
|
|
assertEqual(9, c2.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: test cross collection rollback
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRollbackReload : function () {
|
|
c1 = db._create(cn1);
|
|
c2 = db._create(cn2);
|
|
|
|
c1.save({ _key: "a1" });
|
|
c2.save({ _key: "b1", a: 1 });
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1, cn2 ]
|
|
},
|
|
action : function () {
|
|
c1.save({ _key: "a2" });
|
|
c1.save({ _key: "a3" });
|
|
|
|
c2.save({ _key: "b2" });
|
|
c2.update("b1", { a: 2 });
|
|
assertEqual(2, c2.document("b1").a);
|
|
|
|
throw "rollback";
|
|
}
|
|
};
|
|
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
assertEqual(1, c1.count());
|
|
assertEqual(1, c2.count());
|
|
|
|
assertEqual([ "a1" ], sortedKeys(c1));
|
|
assertEqual([ "b1" ], sortedKeys(c2));
|
|
assertEqual(1, c2.document("b1").a);
|
|
|
|
c1.unload();
|
|
c2.unload();
|
|
testHelper.waitUnload(c1);
|
|
testHelper.waitUnload(c2);
|
|
|
|
assertEqual(1, c1.count());
|
|
assertEqual(1, c2.count());
|
|
|
|
assertEqual([ "a1" ], sortedKeys(c1));
|
|
assertEqual([ "b1" ], sortedKeys(c2));
|
|
assertEqual(1, c2.document("b1").a);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: unload / reload after failed transactions
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUnloadReloadFailedTrx : function () {
|
|
c1 = db._create(cn1);
|
|
|
|
var i;
|
|
for (i = 0; i < 10; ++i) {
|
|
c1.save({ _key: "a" + i, a: i });
|
|
}
|
|
|
|
var obj = {
|
|
collections : {
|
|
write: [ cn1 ],
|
|
},
|
|
action : function () {
|
|
var i;
|
|
for (i = 0; i < 100; ++i) {
|
|
c1.save({ _key: "test" + i });
|
|
}
|
|
|
|
throw "rollback";
|
|
}
|
|
};
|
|
|
|
for (i = 0; i < 50; ++i) {
|
|
try {
|
|
TRANSACTION(obj);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
}
|
|
}
|
|
|
|
assertEqual(10, c1.count());
|
|
|
|
testHelper.waitUnload(c1);
|
|
|
|
assertEqual(10, c1.count());
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function transactionConstraintsSuite () {
|
|
'use strict';
|
|
var cn = "UnitTestsTransaction";
|
|
|
|
var c = null;
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._drop(cn);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
if (c !== null) {
|
|
c.drop();
|
|
}
|
|
|
|
c = null;
|
|
internal.wait(0);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMultiHashConstraintInsert1 : function () {
|
|
c = db._create(cn);
|
|
c.ensureUniqueConstraint("value1");
|
|
c.ensureUniqueConstraint("value2");
|
|
|
|
var i;
|
|
for (i = 0; i < 10; ++i) {
|
|
c.save({ _key: "test" + i, value1: i, value2: i });
|
|
}
|
|
assertEqual(10, c.count());
|
|
|
|
try {
|
|
c.save({ value1: 9, value2: 17 });
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_ARANGO_UNIQUE_CONSTRAINT_VIOLATED.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(10, c.count());
|
|
assertEqual(9, c.document("test9").value1);
|
|
assertEqual(9, c.document("test9").value2);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMultiHashConstraintInsert2 : function () {
|
|
c = db._create(cn);
|
|
c.ensureUniqueConstraint("value1");
|
|
c.ensureUniqueConstraint("value2");
|
|
|
|
var i;
|
|
for (i = 0; i < 10; ++i) {
|
|
c.save({ _key: "test" + i, value1: i, value2: i });
|
|
}
|
|
assertEqual(10, c.count());
|
|
|
|
try {
|
|
c.save({ value1: 17, value2: 9 });
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_ARANGO_UNIQUE_CONSTRAINT_VIOLATED.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(10, c.count());
|
|
assertEqual(9, c.document("test9").value1);
|
|
assertEqual(9, c.document("test9").value2);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMultiSkipConstraintInsert1 : function () {
|
|
c = db._create(cn);
|
|
c.ensureUniqueSkiplist("value1");
|
|
c.ensureUniqueSkiplist("value2");
|
|
|
|
var i;
|
|
for (i = 0; i < 10; ++i) {
|
|
c.save({ _key: "test" + i, value1: i, value2: i });
|
|
}
|
|
assertEqual(10, c.count());
|
|
|
|
try {
|
|
c.save({ value1: 9, value2: 17 });
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_ARANGO_UNIQUE_CONSTRAINT_VIOLATED.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(10, c.count());
|
|
assertEqual(9, c.document("test9").value1);
|
|
assertEqual(9, c.document("test9").value2);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMultiSkipConstraintInsert2 : function () {
|
|
c = db._create(cn);
|
|
c.ensureUniqueSkiplist("value1");
|
|
c.ensureUniqueSkiplist("value2");
|
|
|
|
var i;
|
|
for (i = 0; i < 10; ++i) {
|
|
c.save({ _key: "test" + i, value1: i, value2: i });
|
|
}
|
|
assertEqual(10, c.count());
|
|
|
|
try {
|
|
c.save({ value1: 17, value2: 9 });
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_ARANGO_UNIQUE_CONSTRAINT_VIOLATED.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(10, c.count());
|
|
assertEqual(9, c.document("test9").value1);
|
|
assertEqual(9, c.document("test9").value2);
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function transactionServerFailuresSuite () {
|
|
'use strict';
|
|
var cn = "UnitTestsTransaction";
|
|
|
|
var c = null;
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
internal.debugClearFailAt();
|
|
|
|
if (c !== null) {
|
|
c.drop();
|
|
}
|
|
|
|
c = null;
|
|
internal.wait(0);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of starting a transaction fails
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testBeginTransactionFailure : function () {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
internal.debugSetFailAt("LogfileManagerRegisterTransactionOom");
|
|
|
|
try {
|
|
db._executeTransaction({
|
|
collections: {
|
|
write: cn
|
|
},
|
|
action: function () {
|
|
c.save({ value: 1 });
|
|
fail();
|
|
}
|
|
});
|
|
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_OUT_OF_MEMORY.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testInsertUniqueHashIndexServerFailures : function () {
|
|
var failures = [ "InsertPrimaryIndex", "InsertSecondaryIndexes", "InsertHashIndex" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
c.ensureUniqueConstraint("value");
|
|
|
|
internal.debugSetFailAt(f);
|
|
|
|
try {
|
|
c.save({ value: 1 });
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(0, c.count());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testInsertUniqueHashIndexServerFailuresTrx : function () {
|
|
var failures = [ "InsertPrimaryIndex", "InsertSecondaryIndexes", "InsertHashIndex" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
c.ensureUniqueConstraint("value");
|
|
|
|
db._executeTransaction({
|
|
collections: {
|
|
write: cn
|
|
},
|
|
action: function () {
|
|
c.save({ value: 1 });
|
|
|
|
internal.debugSetFailAt(f);
|
|
try {
|
|
c.save({ value: 2 });
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(1, c.count());
|
|
internal.debugClearFailAt();
|
|
}
|
|
});
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testInsertUniqueHashIndexServerFailuresRollback : function () {
|
|
var failures = [ "InsertPrimaryIndex", "InsertSecondaryIndexes", "InsertHashIndex" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
c.ensureUniqueConstraint("value");
|
|
|
|
try {
|
|
db._executeTransaction({
|
|
collections: {
|
|
write: cn
|
|
},
|
|
action: function () {
|
|
c.save({ value: 1 });
|
|
|
|
internal.debugSetFailAt(f);
|
|
c.save({ value: 2 });
|
|
}
|
|
});
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(0, c.count());
|
|
internal.debugClearFailAt();
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testInsertNonUniqueHashIndexServerFailures : function () {
|
|
var failures = [ "InsertPrimaryIndex", "InsertSecondaryIndexes", "InsertHashIndex" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
c.ensureHashIndex("value");
|
|
|
|
internal.debugSetFailAt(f);
|
|
|
|
try {
|
|
c.save({ value: 1 });
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(0, c.count());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testInsertNonUniqueHashIndexServerFailuresTrx : function () {
|
|
var failures = [ "InsertPrimaryIndex", "InsertSecondaryIndexes", "InsertHashIndex" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
c.ensureHashIndex("value");
|
|
|
|
db._executeTransaction({
|
|
collections: {
|
|
write: cn
|
|
},
|
|
action: function () {
|
|
c.save({ value: 1 });
|
|
|
|
internal.debugSetFailAt(f);
|
|
try {
|
|
c.save({ value: 2 });
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(1, c.count());
|
|
internal.debugClearFailAt();
|
|
}
|
|
});
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testInsertNonUniqueHashIndexServerFailuresRollback : function () {
|
|
var failures = [ "InsertPrimaryIndex", "InsertSecondaryIndexes", "InsertHashIndex" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
c.ensureHashIndex("value");
|
|
|
|
try {
|
|
db._executeTransaction({
|
|
collections: {
|
|
write: cn
|
|
},
|
|
action: function () {
|
|
c.save({ value: 1 });
|
|
|
|
internal.debugSetFailAt(f);
|
|
c.save({ value: 2 });
|
|
}
|
|
});
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(0, c.count());
|
|
internal.debugClearFailAt();
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemoveUniqueHashIndexServerFailures : function () {
|
|
var failures = [ "DeletePrimaryIndex", "DeleteSecondaryIndexes", "RemoveHashIndex" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
for (var i = 0; i < 1000; ++i) {
|
|
c.save({ value: i });
|
|
}
|
|
c.ensureUniqueConstraint("value");
|
|
|
|
internal.debugSetFailAt(f);
|
|
|
|
try {
|
|
c.truncate();
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(1000, c.count());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemoveNonUniqueHashIndexServerFailures : function () {
|
|
var failures = [ "DeletePrimaryIndex", "DeleteSecondaryIndexes", "RemoveHashIndex" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
for (var i = 0; i < 1000; ++i) {
|
|
c.save({ value: i % 10 });
|
|
}
|
|
c.ensureHashIndex("value");
|
|
|
|
internal.debugSetFailAt(f);
|
|
|
|
try {
|
|
c.truncate();
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(1000, c.count());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemoveNonUniqueHashIndexServerFailuresTrx : function () {
|
|
var failures = [ "DeletePrimaryIndex", "DeleteSecondaryIndexes", "RemoveHashIndex" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
c.ensureHashIndex("value");
|
|
for (var i = 0; i < 1000; ++i) {
|
|
c.save({ _key: "test" + i, value: i % 10 });
|
|
}
|
|
|
|
db._executeTransaction({
|
|
collections: {
|
|
write: cn
|
|
},
|
|
action: function () {
|
|
for (var j = 0; j < 10; ++j) {
|
|
c.remove("test" + j);
|
|
}
|
|
|
|
internal.debugSetFailAt(f);
|
|
|
|
try {
|
|
c.remove("test10");
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
}
|
|
});
|
|
|
|
assertEqual(990, c.count());
|
|
internal.debugClearFailAt();
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemoveNonUniqueHashIndexServerFailuresRollback : function () {
|
|
var failures = [ "DeletePrimaryIndex", "DeleteSecondaryIndexes", "RemoveHashIndex" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
for (var i = 0; i < 1000; ++i) {
|
|
c.save({ _key: "test" + i, value: i % 10 });
|
|
}
|
|
|
|
c.ensureHashIndex("value");
|
|
|
|
try {
|
|
db._executeTransaction({
|
|
collections: {
|
|
write: cn
|
|
},
|
|
action: function () {
|
|
for (var j = 0; j < 10; ++j) {
|
|
c.remove("test" + j);
|
|
}
|
|
|
|
internal.debugSetFailAt(f);
|
|
c.remove("test10");
|
|
}
|
|
});
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(1000, c.count());
|
|
internal.debugClearFailAt();
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemoveUniqueSkiplistServerFailures : function () {
|
|
var failures = [ "DeletePrimaryIndex", "DeleteSecondaryIndexes" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
for (var i = 0; i < 1000; ++i) {
|
|
c.save({ value: i });
|
|
}
|
|
c.ensureUniqueSkiplist("value");
|
|
|
|
internal.debugSetFailAt(f);
|
|
|
|
try {
|
|
c.truncate();
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(1000, c.count());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemoveNonUniqueSkiplistServerFailures : function () {
|
|
var failures = [ "DeletePrimaryIndex", "DeleteSecondaryIndexes" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
for (var i = 0; i < 1000; ++i) {
|
|
c.save({ value: i % 10 });
|
|
}
|
|
c.ensureSkiplist("value");
|
|
|
|
internal.debugSetFailAt(f);
|
|
|
|
try {
|
|
c.truncate();
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(1000, c.count());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemoveMultipleIndexesServerFailures : function () {
|
|
var failures = [ "DeletePrimaryIndex", "DeleteSecondaryIndexes", "RemoveHashIndex" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
for (var i = 0; i < 1000; ++i) {
|
|
c.save({ value: i % 10 });
|
|
}
|
|
c.ensureSkiplist("value");
|
|
c.ensureHashIndex("value");
|
|
|
|
internal.debugSetFailAt(f);
|
|
|
|
try {
|
|
c.truncate();
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(1000, c.count());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReadServerFailures : function () {
|
|
var failures = [ "ReadDocumentNoLock", "ReadDocumentNoLockExcept" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
internal.debugSetFailAt(f);
|
|
|
|
try {
|
|
c.document("foo");
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testInsertServerFailuresEmpty : function () {
|
|
var failures = [
|
|
"InsertDocumentNoHeader",
|
|
"InsertDocumentNoHeaderExcept",
|
|
"InsertDocumentNoLock",
|
|
"InsertDocumentNoOperation",
|
|
"InsertDocumentNoOperationExcept",
|
|
"TransactionOperationNoSlot",
|
|
"TransactionOperationNoSlotExcept",
|
|
"TransactionOperationAfterAdjust",
|
|
"TransactionOperationAtEnd" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
internal.debugSetFailAt(f);
|
|
|
|
try {
|
|
c.save({ _key: "foo", a: 1 });
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum, f);
|
|
}
|
|
|
|
assertEqual(0, c.count());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testInsertServerFailuresNonEmpty : function () {
|
|
var failures = [
|
|
"InsertDocumentNoHeader",
|
|
"InsertDocumentNoHeaderExcept",
|
|
"InsertDocumentNoLock",
|
|
"InsertDocumentNoOperation",
|
|
"InsertDocumentNoOperationExcept",
|
|
"TransactionOperationNoSlot",
|
|
"TransactionOperationNoSlotExcept",
|
|
"TransactionOperationAfterAdjust",
|
|
"TransactionOperationAtEnd" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
c.save({ _key: "bar", foo: "bar" });
|
|
assertEqual(1, c.count());
|
|
assertEqual("bar", c.document("bar").foo);
|
|
|
|
internal.debugSetFailAt(f);
|
|
|
|
try {
|
|
c.save({ _key: "foo", a: 1 });
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum, f);
|
|
}
|
|
|
|
assertEqual(1, c.count());
|
|
assertEqual("bar", c.document("bar").foo);
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testInsertServerFailuresConstraint : function () {
|
|
var failures = [
|
|
"InsertDocumentNoHeader",
|
|
"InsertDocumentNoHeaderExcept",
|
|
"InsertDocumentNoLock" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
c.save({ _key: "foo", foo: "bar" });
|
|
assertEqual(1, c.count());
|
|
assertEqual("bar", c.document("foo").foo);
|
|
|
|
internal.debugSetFailAt(f);
|
|
|
|
try {
|
|
c.save({ _key: "foo", foo: "baz" });
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum, f);
|
|
}
|
|
|
|
assertEqual(1, c.count());
|
|
assertEqual("bar", c.document("foo").foo);
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testInsertServerFailuresMulti : function () {
|
|
var failures = [
|
|
"InsertDocumentNoHeader",
|
|
"InsertDocumentNoHeaderExcept",
|
|
"InsertDocumentNoLock",
|
|
"InsertDocumentNoOperation",
|
|
"InsertDocumentNoOperationExcept",
|
|
"TransactionOperationNoSlot",
|
|
"TransactionOperationNoSlotExcept",
|
|
"TransactionOperationAfterAdjust",
|
|
"TransactionOperationAtEnd" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
try {
|
|
TRANSACTION({
|
|
collections: {
|
|
write: [ cn ],
|
|
},
|
|
action: function () {
|
|
for (var i = 0; i < 10; ++i) {
|
|
if (i === 9) {
|
|
internal.debugSetFailAt(f);
|
|
}
|
|
c.save({ _key: "test" + i, a: 1 });
|
|
}
|
|
}
|
|
});
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum, f);
|
|
}
|
|
|
|
assertEqual(0, c.count(), f);
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemoveServerFailuresEmpty : function () {
|
|
var failures = [ "RemoveDocumentNoMarker", "RemoveDocumentNoMarkerExcept", "RemoveDocumentNoLock" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
internal.debugSetFailAt(f);
|
|
|
|
try {
|
|
c.remove("foo");
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(0, c.count());
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemoveServerFailuresNonEmpty : function () {
|
|
var failures = [ "RemoveDocumentNoMarker",
|
|
"RemoveDocumentNoMarkerExcept",
|
|
"RemoveDocumentNoLock",
|
|
"RemoveDocumentNoOperation",
|
|
"RemoveDocumentNoOperationExcept",
|
|
"TransactionOperationNoSlot",
|
|
"TransactionOperationNoSlotExcept",
|
|
"TransactionOperationAfterAdjust",
|
|
"TransactionOperationAtEnd" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
c.save({ _key: "foo", foo: "bar" });
|
|
assertEqual(1, c.count());
|
|
assertEqual("bar", c.document("foo").foo);
|
|
|
|
internal.debugSetFailAt(f);
|
|
|
|
try {
|
|
c.remove("foo");
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(1, c.count());
|
|
assertEqual("bar", c.document("foo").foo);
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemoveServerFailuresMulti : function () {
|
|
var failures = [ "RemoveDocumentNoMarker",
|
|
"RemoveDocumentNoMarkerExcept",
|
|
"RemoveDocumentNoLock",
|
|
"RemoveDocumentNoOperation",
|
|
"RemoveDocumentNoOperationExcept",
|
|
"TransactionOperationNoSlot",
|
|
"TransactionOperationNoSlotExcept",
|
|
"TransactionOperationAfterAdjust",
|
|
"TransactionOperationAtEnd" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
var i;
|
|
for (i = 0; i < 10; ++i) {
|
|
c.save({ _key: "test" + i, a: i });
|
|
}
|
|
|
|
try {
|
|
TRANSACTION({
|
|
collections: {
|
|
write: [ cn ],
|
|
},
|
|
action: function () {
|
|
for (var i = 0; i < 10; ++i) {
|
|
if (i === 9) {
|
|
internal.debugSetFailAt(f);
|
|
}
|
|
c.remove("test" + i);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(10, c.count());
|
|
for (i = 0; i < 10; ++i) {
|
|
assertEqual(i, c.document("test" + i).a);
|
|
}
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUpdateServerFailuresNonEmpty : function () {
|
|
var failures = [
|
|
"UpdateDocumentNoMarker",
|
|
"UpdateDocumentNoMarkerExcept",
|
|
"UpdateDocumentNoLock",
|
|
"UpdateDocumentNoOperation",
|
|
"UpdateDocumentNoOperationExcept",
|
|
"TransactionOperationNoSlot",
|
|
"TransactionOperationNoSlotExcept",
|
|
"TransactionOperationAfterAdjust",
|
|
"TransactionOperationAtEnd" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
c.save({ _key: "foo", foo: "bar" });
|
|
assertEqual(1, c.count());
|
|
assertEqual("bar", c.document("foo").foo);
|
|
|
|
internal.debugSetFailAt(f);
|
|
|
|
try {
|
|
c.update("foo", { bar: "baz" });
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum, f);
|
|
}
|
|
|
|
assertEqual(1, c.count());
|
|
assertEqual("bar", c.document("foo").foo);
|
|
assertEqual(undefined, c.document("foo").bar);
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUpdateServerFailuresMulti : function () {
|
|
var failures = [
|
|
"UpdateDocumentNoMarker",
|
|
"UpdateDocumentNoMarkerExcept",
|
|
"UpdateDocumentNoLock",
|
|
"UpdateDocumentNoOperation",
|
|
"UpdateDocumentNoOperationExcept",
|
|
"TransactionOperationNoSlot",
|
|
"TransactionOperationNoSlotExcept",
|
|
"TransactionOperationAfterAdjust",
|
|
"TransactionOperationAtEnd" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
var i;
|
|
for (i = 0; i < 10; ++i) {
|
|
c.save({ _key: "test" + i, a: i });
|
|
}
|
|
assertEqual(10, c.count());
|
|
|
|
try {
|
|
TRANSACTION({
|
|
collections: {
|
|
write: [ cn ],
|
|
},
|
|
action: function () {
|
|
for (var i = 0; i < 10; ++i) {
|
|
if (i === 9) {
|
|
internal.debugSetFailAt(f);
|
|
}
|
|
c.update("test" + i, { a: i + 1 });
|
|
}
|
|
}
|
|
});
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum, f);
|
|
}
|
|
|
|
assertEqual(10, c.count());
|
|
for (i = 0; i < 10; ++i) {
|
|
assertEqual(i, c.document("test" + i).a, f);
|
|
}
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUpdateServerFailuresMultiUpdate : function () {
|
|
var failures = [
|
|
"UpdateDocumentNoMarker",
|
|
"UpdateDocumentNoMarkerExcept",
|
|
"UpdateDocumentNoLock",
|
|
"UpdateDocumentNoOperation",
|
|
"UpdateDocumentNoOperationExcept",
|
|
"TransactionOperationNoSlot",
|
|
"TransactionOperationNoSlotExcept",
|
|
"TransactionOperationAfterAdjust",
|
|
"TransactionOperationAtEnd" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
var i;
|
|
for (i = 0; i < 10; ++i) {
|
|
c.save({ _key: "test" + i, a: i });
|
|
}
|
|
assertEqual(10, c.count());
|
|
|
|
try {
|
|
TRANSACTION({
|
|
collections: {
|
|
write: [ cn ],
|
|
},
|
|
action: function () {
|
|
for (var i = 0; i < 10; ++i) {
|
|
if (i === 9) {
|
|
internal.debugSetFailAt(f);
|
|
}
|
|
// double update
|
|
c.update("test" + i, { a: i + 1 });
|
|
c.update("test" + i, { a: i + 2, b: 2 });
|
|
}
|
|
}
|
|
});
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(10, c.count(), f);
|
|
for (i = 0; i < 10; ++i) {
|
|
assertEqual(i, c.document("test" + i).a, f);
|
|
assertEqual(undefined, c.document("test" + i).b, f);
|
|
}
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testTruncateServerFailures : function () {
|
|
var failures = [ "RemoveDocumentNoMarker",
|
|
"RemoveDocumentNoMarkerExcept",
|
|
"RemoveDocumentNoLock",
|
|
"RemoveDocumentNoOperation",
|
|
"RemoveDocumentNoOperationExcept",
|
|
"TransactionOperationNoSlot",
|
|
"TransactionOperationNoSlotExcept" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
var i;
|
|
for (i = 0; i < 10; ++i) {
|
|
c.save({ _key: "test" + i, a: i });
|
|
}
|
|
|
|
internal.debugSetFailAt(f);
|
|
|
|
try {
|
|
c.truncate();
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(10, c.count());
|
|
for (i = 0; i < 10; ++i) {
|
|
assertEqual(i, c.document("test" + i).a);
|
|
}
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: rollback in case of a server-side fail
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMixedServerFailures : function () {
|
|
var failures = [
|
|
"UpdateDocumentNoMarker",
|
|
"UpdateDocumentNoMarkerExcept",
|
|
"UpdateDocumentNoLock",
|
|
"UpdateDocumentNoOperation",
|
|
"UpdateDocumentNoOperationExcept",
|
|
"RemoveDocumentNoMarker",
|
|
"RemoveDocumentNoMarkerExcept",
|
|
"RemoveDocumentNoLock",
|
|
"RemoveDocumentNoOperation",
|
|
"RemoveDocumentNoOperationExcept",
|
|
"InsertDocumentNoHeader",
|
|
"InsertDocumentNoHeaderExcept",
|
|
"InsertDocumentNoLock",
|
|
"InsertDocumentNoOperation",
|
|
"InsertDocumentNoOperationExcept",
|
|
"TransactionOperationNoSlot",
|
|
"TransactionOperationNoSlotExcept",
|
|
"TransactionOperationAfterAdjust",
|
|
"TransactionOperationAtEnd" ];
|
|
|
|
failures.forEach (function (f) {
|
|
internal.debugClearFailAt();
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
var i;
|
|
for (i = 0; i < 100; ++i) {
|
|
c.save({ _key: "test" + i, a: i });
|
|
}
|
|
assertEqual(100, c.count());
|
|
|
|
internal.debugSetFailAt(f);
|
|
|
|
try {
|
|
TRANSACTION({
|
|
collections: {
|
|
write: [ cn ],
|
|
},
|
|
action: function () {
|
|
var i;
|
|
for (i = 100; i < 150; ++i) {
|
|
c.save({ _key: "test" + i, a: i });
|
|
}
|
|
assertEqual(150, c.count());
|
|
|
|
for (i = 0; i < 50; ++i) {
|
|
c.remove("test" + i);
|
|
}
|
|
assertEqual(100, c.count());
|
|
|
|
for (i = 50; i < 100; ++i) {
|
|
c.update("test" + i, { a: i - 50, b: "foo" });
|
|
}
|
|
assertEqual(100, c.count());
|
|
}
|
|
});
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum, f);
|
|
}
|
|
|
|
assertEqual(100, c.count());
|
|
for (i = 0; i < 100; ++i) {
|
|
assertEqual(i, c.document("test" + i).a, f);
|
|
assertEqual(undefined, c.document("test" + i).b, f);
|
|
}
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test disk full during collection
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testDiskFullWhenCollectingTransaction : function () {
|
|
internal.debugClearFailAt();
|
|
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
// should not cause any problems yet, but later
|
|
internal.debugSetFailAt("CreateJournalDocumentCollection");
|
|
|
|
// adjust the configuration and make sure we flush all reserve logfiles
|
|
internal.wal.properties({ reserveLogfiles: 1 });
|
|
|
|
var i;
|
|
for (i = 0; i < 100; ++i) {
|
|
c.save({ _key: "test" + i, a: i });
|
|
}
|
|
assertEqual(100, c.count());
|
|
|
|
for (i = 0; i < 4; ++i) {
|
|
// write something into the logs so we can flush 'em
|
|
c.save({ _key: "foo" });
|
|
c.remove("foo");
|
|
internal.wal.flush(true, false);
|
|
}
|
|
|
|
// one more to populate a new logfile
|
|
c.save({ _key: "foo" });
|
|
c.remove("foo");
|
|
|
|
TRANSACTION({
|
|
collections: {
|
|
write: [ cn ],
|
|
},
|
|
action: function () {
|
|
var i;
|
|
for (i = 100; i < 150; ++i) {
|
|
c.save({ _key: "test" + i, a: i });
|
|
}
|
|
assertEqual(150, c.count());
|
|
|
|
// make sure we fill up the logfile
|
|
for (i = 0; i < 100000; ++i) {
|
|
c.save({ _key: "foo" + i, value: "the quick brown foxx jumped over the lazy dog" });
|
|
}
|
|
}
|
|
});
|
|
|
|
assertEqual(100150, c.count());
|
|
var fig = c.figures();
|
|
assertEqual(100160, fig.uncollectedLogfileEntries);
|
|
|
|
internal.debugClearFailAt();
|
|
while (true) {
|
|
try {
|
|
internal.wal.flush(true, true);
|
|
break;
|
|
}
|
|
catch (err) {
|
|
internal.wait(0.5, false);
|
|
}
|
|
}
|
|
|
|
assertEqual(100150, c.count());
|
|
|
|
testHelper.waitUnload(c);
|
|
|
|
// data should be there after unload
|
|
assertEqual(100150, c.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: disk full during transaction
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testDiskFullDuringTransaction : function () {
|
|
internal.debugClearFailAt();
|
|
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
var i;
|
|
for (i = 0; i < 100; ++i) {
|
|
c.save({ _key: "test" + i, a: i });
|
|
}
|
|
assertEqual(100, c.count());
|
|
|
|
internal.wal.flush(true, true);
|
|
|
|
try {
|
|
TRANSACTION({
|
|
collections: {
|
|
write: [ cn ],
|
|
},
|
|
action: function () {
|
|
var i;
|
|
for (i = 100; i < 150; ++i) {
|
|
c.save({ _key: "test" + i, a: i });
|
|
}
|
|
assertEqual(150, c.count());
|
|
|
|
// should not cause any problems
|
|
internal.debugSetFailAt("LogfileManagerGetWriteableLogfile");
|
|
|
|
for (i = 0; i < 500000; ++i) {
|
|
c.save({ _key: "foo" + i, value: "the quick brown foxx jumped over the lazy dog" });
|
|
}
|
|
|
|
fail();
|
|
}
|
|
});
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_ARANGO_NO_JOURNAL.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(100, c.count());
|
|
internal.debugClearFailAt();
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: cannot write begin marker for trx
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNoBeginMarker : function () {
|
|
internal.debugClearFailAt();
|
|
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
var i;
|
|
for (i = 0; i < 100; ++i) {
|
|
c.save({ _key: "test" + i, a: i });
|
|
}
|
|
assertEqual(100, c.count());
|
|
|
|
internal.wal.flush(true, true);
|
|
internal.debugSetFailAt("TransactionWriteBeginMarker");
|
|
|
|
try {
|
|
TRANSACTION({
|
|
collections: {
|
|
write: [ cn ],
|
|
},
|
|
action: function () {
|
|
c.save({ _key: "test100" });
|
|
fail();
|
|
}
|
|
});
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(100, c.count());
|
|
internal.debugClearFailAt();
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: cannot write commit marker for trx
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNoCommitMarker : function () {
|
|
internal.debugClearFailAt();
|
|
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
var i;
|
|
for (i = 0; i < 100; ++i) {
|
|
c.save({ _key: "test" + i, a: i });
|
|
}
|
|
assertEqual(100, c.count());
|
|
|
|
internal.wal.flush(true, true);
|
|
internal.debugSetFailAt("TransactionWriteCommitMarker");
|
|
|
|
try {
|
|
TRANSACTION({
|
|
collections: {
|
|
write: [ cn ],
|
|
},
|
|
action: function () {
|
|
var i;
|
|
for (i = 100; i < 1000; ++i) {
|
|
c.save({ _key: "test" + i, a: i });
|
|
}
|
|
|
|
assertEqual(1000, c.count());
|
|
}
|
|
});
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(internal.errors.ERROR_DEBUG.code, err.errorNum);
|
|
}
|
|
|
|
assertEqual(100, c.count());
|
|
internal.debugClearFailAt();
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: cannot write abort marker for trx
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNoAbortMarker : function () {
|
|
internal.debugClearFailAt();
|
|
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
|
|
var i;
|
|
for (i = 0; i < 100; ++i) {
|
|
c.save({ _key: "test" + i, a: i });
|
|
}
|
|
assertEqual(100, c.count());
|
|
|
|
internal.wal.flush(true, true);
|
|
internal.debugSetFailAt("TransactionWriteAbortMarker");
|
|
|
|
try {
|
|
TRANSACTION({
|
|
collections: {
|
|
write: [ cn ],
|
|
},
|
|
action: function () {
|
|
var i;
|
|
for (i = 100; i < 1000; ++i) {
|
|
c.save({ _key: "test" + i, a: i });
|
|
}
|
|
|
|
assertEqual(1000, c.count());
|
|
|
|
throw "rollback!";
|
|
}
|
|
});
|
|
}
|
|
catch (err) {
|
|
// ignore the intentional error
|
|
}
|
|
|
|
internal.debugClearFailAt();
|
|
|
|
testHelper.waitUnload(c);
|
|
|
|
assertEqual(100, c.count());
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief executes the test suites
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// only run this test suite if server-side failures are enabled
|
|
if (internal.debugCanUseFailAt()) {
|
|
jsunity.run(transactionServerFailuresSuite);
|
|
}
|
|
|
|
jsunity.run(transactionInvocationSuite);
|
|
jsunity.run(transactionCollectionsSuite);
|
|
jsunity.run(transactionOperationsSuite);
|
|
jsunity.run(transactionBarriersSuite);
|
|
jsunity.run(transactionGraphSuite);
|
|
jsunity.run(transactionRollbackSuite);
|
|
jsunity.run(transactionCountSuite);
|
|
jsunity.run(transactionCrossCollectionSuite);
|
|
jsunity.run(transactionConstraintsSuite);
|
|
|
|
return jsunity.done();
|
|
|