mirror of https://gitee.com/bigwinds/arangodb
2377 lines
78 KiB
JavaScript
2377 lines
78 KiB
JavaScript
/*jshint globalstrict:false, strict:false */
|
|
/*global assertEqual, assertNotNull, assertNull, assertTrue, assertMatch,
|
|
assertFalse */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test the graph class
|
|
///
|
|
/// @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 Dr. Frank Celler, Lucas Dohmen
|
|
/// @author Copyright 2012, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var jsunity = require("jsunity");
|
|
|
|
var db = require("@arangodb").db;
|
|
var SimpleQueryArray = require("@arangodb/simple-query").SimpleQueryArray;
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test lookup-by-key API
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function SimpleQueryLookupByKeysSuite () {
|
|
'use strict';
|
|
|
|
var cn = "example";
|
|
var c = null;
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
db._drop(cn);
|
|
c = null;
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief lookup in empty collection
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testEmptyCollection : function () {
|
|
var result = c.documents([ "foo", "bar", "baz" ]);
|
|
|
|
assertEqual({ documents: [ ] }, result);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief lookup in empty collection and empty lookup list
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testEmptyCollectionAndArray : function () {
|
|
var result = c.documents([ ]);
|
|
|
|
assertEqual({ documents: [ ] }, result);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief lookup in collection with empty lookup list
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testEmptyArray : function () {
|
|
for (var i = 0; i < 100; ++i) {
|
|
c.insert({ _key: "test" + i });
|
|
}
|
|
|
|
var result = c.documents([ ]);
|
|
|
|
assertEqual({ documents: [ ] }, result);
|
|
|
|
// try with alias method
|
|
result = c.lookupByKeys([ ]);
|
|
assertEqual({ documents: [ ] }, result);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief lookup in collection with document ids
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testDocumentIds : function () {
|
|
var keys = [ ];
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
c.insert({ _key: "test" + i });
|
|
keys.push(c.name() + "/test" + i);
|
|
}
|
|
|
|
// should have matches
|
|
var result = c.documents(keys);
|
|
assertEqual(100, result.documents.length);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief lookup in collection with document ids
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testDocumentIdDuplicates : function () {
|
|
var keys = [ ];
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
c.insert({ _key: "test" + i });
|
|
// each document is here exactly twice
|
|
keys.push(c.name() + "/test" + i);
|
|
keys.push(c.name() + "/test" + i);
|
|
}
|
|
|
|
// should have matches
|
|
var result = c.documents(keys);
|
|
assertEqual(100, result.documents.length);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief lookup in collection with document ids
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testDocumentIdNonExisting : function () {
|
|
var keys = [ ];
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
c.insert({ _key: "test" + i });
|
|
keys.push(c.name() + "/foo" + i);
|
|
}
|
|
|
|
// should not have matches
|
|
var result = c.documents(keys);
|
|
assertEqual(0, result.documents.length);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief lookup in collection with document ids
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testDocumentIdsInvalid : function () {
|
|
var keys = [ ];
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
c.insert({ _key: "test" + i });
|
|
keys.push(c.name() + "/");
|
|
}
|
|
|
|
// should not have matches
|
|
var result = c.documents(keys);
|
|
assertEqual(0, result.documents.length);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief lookup in collection with document ids
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testDocumentIdsOtherCollection : function () {
|
|
var keys = [ ];
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
c.insert({ _key: "test" + i });
|
|
keys.push("Another" + c.name() + "/test" + i);
|
|
}
|
|
|
|
// should not have matches
|
|
var result = c.documents(keys);
|
|
assertEqual(0, result.documents.length);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief lookup in collection with numeric keys
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNumericKeys : function () {
|
|
for (var i = 0; i < 100; ++i) {
|
|
c.insert({ _key: String(i) });
|
|
}
|
|
|
|
// should have matches
|
|
var result = c.documents([ "1", "2", "3", "0" ]);
|
|
assertEqual(4, result.documents.length);
|
|
|
|
// try with alias method
|
|
result = c.lookupByKeys([ "1", "2", "3", "0" ]);
|
|
assertEqual(4, result.documents.length);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief lookup using invalid keys
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testInvalidKeys : function () {
|
|
var result = c.documents([ " ", "* ", " bfffff/\\&, ", "////.,;::" ]);
|
|
|
|
assertEqual({ documents: [ ] }, result);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief lookup in collection
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testLookup : function () {
|
|
var keys = [ ];
|
|
for (var i = 0; i < 1000; ++i) {
|
|
c.insert({ _key: "test" + i, value: i });
|
|
keys.push("test" + i);
|
|
}
|
|
|
|
var result = c.documents(keys);
|
|
assertEqual(1000, result.documents.length);
|
|
|
|
result.documents.forEach(function(doc) {
|
|
assertTrue(doc.hasOwnProperty("_id"));
|
|
assertTrue(doc.hasOwnProperty("_key"));
|
|
assertTrue(doc.hasOwnProperty("_rev"));
|
|
assertTrue(doc.hasOwnProperty("value"));
|
|
assertMatch(/^test\d+$/, doc._key);
|
|
assertEqual(cn + "/" + doc._key, doc._id);
|
|
assertEqual(doc._key, "test" + doc.value);
|
|
});
|
|
|
|
// try with alias method
|
|
result = c.lookupByKeys(keys);
|
|
assertEqual(1000, result.documents.length);
|
|
|
|
result.documents.forEach(function(doc) {
|
|
assertTrue(doc.hasOwnProperty("_id"));
|
|
assertTrue(doc.hasOwnProperty("_key"));
|
|
assertTrue(doc.hasOwnProperty("_rev"));
|
|
assertTrue(doc.hasOwnProperty("value"));
|
|
assertMatch(/^test\d+$/, doc._key);
|
|
assertEqual(cn + "/" + doc._key, doc._id);
|
|
assertEqual(doc._key, "test" + doc.value);
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief lookup in collection
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testLookupDuplicate : function () {
|
|
var keys = [ ];
|
|
for (var i = 0; i < 100; ++i) {
|
|
c.insert({ _key: "test" + i, value: i });
|
|
// add same key twice
|
|
keys.push("test" + i);
|
|
keys.push("test" + i);
|
|
}
|
|
|
|
var result = c.documents(keys);
|
|
assertEqual(100, result.documents.length);
|
|
|
|
result.documents.forEach(function(doc) {
|
|
assertTrue(doc.hasOwnProperty("_id"));
|
|
assertTrue(doc.hasOwnProperty("_key"));
|
|
assertTrue(doc.hasOwnProperty("_rev"));
|
|
assertTrue(doc.hasOwnProperty("value"));
|
|
assertMatch(/^test\d+$/, doc._key);
|
|
assertEqual(cn + "/" + doc._key, doc._id);
|
|
assertEqual(doc._key, "test" + doc.value);
|
|
});
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test remove-by-keys API
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function SimpleQueryRemoveByKeysSuite () {
|
|
'use strict';
|
|
|
|
var cn = "example";
|
|
var c = null;
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._drop(cn);
|
|
c = db._create(cn);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
db._drop(cn);
|
|
c = null;
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief remove in empty collection
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testEmptyCollection : function () {
|
|
var result = c.removeByKeys([ "foo", "bar", "baz" ]);
|
|
|
|
assertEqual({ removed: 0, ignored: 3 }, result);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief remove in empty collection and empty lookup list
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testEmptyCollectionAndArray : function () {
|
|
var result = c.removeByKeys([ ]);
|
|
|
|
assertEqual({ removed: 0, ignored: 0 }, result);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief remove in collection with empty lookup list
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testEmptyArray : function () {
|
|
for (var i = 0; i < 100; ++i) {
|
|
c.insert({ _key: "test" + i });
|
|
}
|
|
|
|
var result = c.removeByKeys([ ]);
|
|
|
|
assertEqual({ removed: 0, ignored: 0 }, result);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief remove in collection with existing and nonexisting keys
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMixed : function () {
|
|
var keys = [ ];
|
|
for (var i = 0; i < 500; ++i) {
|
|
c.insert({ _key: "test" + i });
|
|
|
|
if (i % 2 === 0) {
|
|
keys.push("test" + i);
|
|
}
|
|
else {
|
|
keys.push("foobar" + i);
|
|
}
|
|
}
|
|
|
|
var result = c.removeByKeys(keys);
|
|
|
|
assertEqual({ removed: 250, ignored: 250 }, result);
|
|
|
|
assertEqual(250, c.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief remove in collection with nonexisting keys
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNonExisting : function () {
|
|
var keys = [ ];
|
|
for (var i = 0; i < 100; ++i) {
|
|
keys.push("test" + i);
|
|
}
|
|
|
|
var result = c.removeByKeys(keys);
|
|
|
|
assertEqual({ removed: 0, ignored: 100 }, result);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief remove in collection with numeric keys
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNumericKeys : function () {
|
|
for (var i = 0; i < 100; ++i) {
|
|
c.insert({ _key: String(i) });
|
|
}
|
|
|
|
// should have matches
|
|
var result = c.removeByKeys([ "1", "2", "3", "0" ]);
|
|
assertEqual({ removed: 4, ignored: 0 }, result);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief remove using invalid keys
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testInvalidKeys : function () {
|
|
var result = c.removeByKeys([ " ", "* ", " bfffff/\\&, ", "////.,;::" ]);
|
|
|
|
assertEqual({ removed: 0, ignored: 4 }, result);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief remove in collection
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemove : function () {
|
|
var keys = [ ];
|
|
for (var i = 0; i < 1000; ++i) {
|
|
c.insert({ _key: "test" + i, value: i });
|
|
keys.push("test" + i);
|
|
}
|
|
|
|
var result = c.removeByKeys(keys);
|
|
assertEqual({ removed: 1000, ignored: 0 }, result);
|
|
|
|
assertEqual(0, c.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief remove in collection
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemoveTwice : function () {
|
|
var keys = [ ];
|
|
for (var i = 0; i < 1000; ++i) {
|
|
c.insert({ _key: "test" + i, value: i });
|
|
keys.push("test" + i);
|
|
}
|
|
|
|
var result = c.removeByKeys(keys);
|
|
assertEqual({ removed: 1000, ignored: 0 }, result);
|
|
|
|
assertEqual(0, c.count());
|
|
c.insert({ _key: "test3" });
|
|
c.insert({ _key: "test1000" });
|
|
|
|
result = c.removeByKeys(keys);
|
|
assertEqual({ removed: 1, ignored: 999 }, result);
|
|
|
|
assertEqual(1, c.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief remove in collection
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemoveDuplicate : function () {
|
|
var keys = [ ];
|
|
for (var i = 0; i < 100; ++i) {
|
|
c.insert({ _key: "test" + i, value: i });
|
|
// add same key twice
|
|
keys.push("test" + i);
|
|
keys.push("test" + i);
|
|
}
|
|
|
|
var result = c.removeByKeys(keys);
|
|
assertEqual({ removed: 100, ignored: 100 }, result);
|
|
|
|
assertEqual(0, c.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief remove in collection
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemovePartial : function () {
|
|
var keys = [ ];
|
|
for (var i = 0; i < 2000; ++i) {
|
|
c.insert({ _key: "test" + i, value: i });
|
|
|
|
if (i % 2 === 0) {
|
|
keys.push("test" + i);
|
|
}
|
|
}
|
|
|
|
// result should have been de-duplicated?
|
|
var result = c.removeByKeys(keys);
|
|
assertEqual({ removed: 1000, ignored: 0 }, result);
|
|
|
|
assertEqual(1000, c.count());
|
|
assertFalse(c.exists("test0"));
|
|
assertTrue(c.exists("test1"));
|
|
assertFalse(c.exists("test2"));
|
|
assertTrue(c.exists("test3"));
|
|
// ...
|
|
assertFalse(c.exists("test1998"));
|
|
assertTrue(c.exists("test1999"));
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite: skip and limit with a collection
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function SimpleQueryArraySkipLimitSuite () {
|
|
'use strict';
|
|
var numbers = null;
|
|
var query = null;
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
numbers = [0,1,2,3,4,5,6,7,8,9];
|
|
query = new SimpleQueryArray(numbers);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: skip
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testSkip : function () {
|
|
var n = query.clone().skip(0).toArray();
|
|
|
|
assertEqual(n, numbers);
|
|
|
|
n = query.clone().skip(1).toArray();
|
|
|
|
assertEqual(n, numbers.slice(1,10));
|
|
|
|
n = query.clone().skip(2).toArray();
|
|
|
|
assertEqual(n, numbers.slice(2,10));
|
|
|
|
n = query.clone().skip(1).skip(1).toArray();
|
|
|
|
assertEqual(n, numbers.slice(2,10));
|
|
|
|
n = query.clone().skip(10).toArray();
|
|
|
|
assertEqual(n, []);
|
|
|
|
n = query.clone().skip(11).toArray();
|
|
|
|
assertEqual(n, []);
|
|
|
|
n = query.clone().skip(9).toArray();
|
|
|
|
assertEqual(n, [numbers[9]]);
|
|
|
|
n = query.clone().skip(9).skip(1).toArray();
|
|
|
|
assertEqual(n, []);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: limit
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testLimit : function () {
|
|
var n = query.clone().limit(10).toArray();
|
|
|
|
assertEqual(n, numbers);
|
|
|
|
n = query.clone().limit(9).toArray();
|
|
|
|
assertEqual(n, numbers.slice(0,9));
|
|
|
|
n = query.clone().limit(9).limit(8).limit(7).toArray();
|
|
|
|
assertEqual(n, numbers.slice(0,7));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: skip and limit
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testSkipLimit : function () {
|
|
var n = query.clone().skip(0).limit(10).toArray();
|
|
|
|
assertEqual(n, numbers);
|
|
|
|
n = query.clone().limit(10).skip(0).toArray();
|
|
|
|
assertEqual(n, numbers);
|
|
|
|
n = query.clone().limit(9).skip(1).toArray();
|
|
|
|
assertEqual(n, numbers.slice(1,9));
|
|
|
|
n = query.clone().limit(9).skip(1).limit(7).toArray();
|
|
|
|
assertEqual(n, numbers.slice(1,8));
|
|
|
|
n = query.clone().skip(-5).limit(3).toArray();
|
|
|
|
assertEqual(n, numbers.slice(5,8));
|
|
|
|
n = query.clone().skip(-8).limit(7).skip(1).limit(4).toArray();
|
|
|
|
assertEqual(n, numbers.slice(3,7));
|
|
|
|
n = query.clone().skip(-10).limit(9).skip(1).limit(7).toArray();
|
|
|
|
assertEqual(n, numbers.slice(1,8));
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite: skip and limit with a collection
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function SimpleQueryAllSkipLimitSuite () {
|
|
'use strict';
|
|
var cn = "UnitTestsCollectionSkipLimit";
|
|
var collection = null;
|
|
var numbers = null;
|
|
var num = function(d) { return d.n; };
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._drop(cn);
|
|
collection = db._create(cn, { waitForSync : false });
|
|
|
|
for (var i = 0; i < 10; ++i) {
|
|
collection.save({ n : i });
|
|
}
|
|
|
|
numbers = collection.all().toArray().map(num);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
collection.drop();
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: skip
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAllSkip : function () {
|
|
var n = collection.all().skip(0).toArray().map(num);
|
|
assertEqual(n, numbers);
|
|
|
|
n = collection.all().skip(1).toArray().map(num);
|
|
assertEqual(n, numbers.slice(1,10));
|
|
|
|
n = collection.all().skip(2).toArray().map(num);
|
|
assertEqual(n, numbers.slice(2,10));
|
|
|
|
n = collection.all().skip(1).skip(1).toArray().map(num);
|
|
assertEqual(n, numbers.slice(2,10));
|
|
|
|
n = collection.all().skip(10).toArray().map(num);
|
|
assertEqual(n, []);
|
|
|
|
n = collection.all().skip(11).toArray().map(num);
|
|
assertEqual(n, []);
|
|
|
|
n = collection.all().skip(9).toArray().map(num);
|
|
assertEqual(n, [numbers[9]]);
|
|
|
|
n = collection.all().skip(9).skip(1).toArray().map(num);
|
|
assertEqual(n, []);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: limit
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAllLimit : function () {
|
|
var n = collection.all().limit(10).toArray().map(num);
|
|
assertEqual(n, numbers);
|
|
|
|
n = collection.all().limit(9).toArray().map(num);
|
|
assertEqual(n, numbers.slice(0,9));
|
|
|
|
n = collection.all().limit(9).limit(8).limit(7).toArray().map(num);
|
|
assertEqual(n, numbers.slice(0,7));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: skip and limit
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAllSkipLimit : function () {
|
|
var n = collection.all().skip(0).limit(10).toArray().map(num);
|
|
assertEqual(n, numbers);
|
|
|
|
n = collection.all().limit(10).skip(0).toArray().map(num);
|
|
assertEqual(n, numbers);
|
|
|
|
n = collection.all().limit(9).skip(1).toArray().map(num);
|
|
assertEqual(n, numbers.slice(1, 9));
|
|
|
|
n = collection.all().limit(9).skip(1).limit(7).toArray().map(num);
|
|
assertEqual(n, numbers.slice(1, 8));
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite: query-by-example
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function SimpleQueryByExampleSuite () {
|
|
'use strict';
|
|
var cn = "UnitTestsCollectionByExample";
|
|
var collection = null;
|
|
var id = function(d) { return d._id; };
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._drop(cn);
|
|
collection = db._create(cn);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
collection.drop();
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using indexes
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleHash1 : function () {
|
|
var d, s;
|
|
var example = { "a" : { "b" : true, "c" : "foo" }, "d" : true };
|
|
|
|
collection.ensureHashIndex("d");
|
|
|
|
d = collection.save(example);
|
|
s = collection.firstExample({ "d" : true });
|
|
assertEqual(d._id, s._id);
|
|
|
|
s = collection.firstExample({ "d" : false });
|
|
assertNull(s);
|
|
|
|
s = collection.firstExample({ "a.b" : true });
|
|
assertEqual(d._id, s._id);
|
|
|
|
s = collection.firstExample({ "a.c" : "foo" });
|
|
assertEqual(d._id, s._id);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using indexes
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleHash2 : function () {
|
|
var d1, d2, d3, d4, s;
|
|
var example1 = { "a" : { "b" : true } };
|
|
var example2 = { "a" : { "b" : "foo" } };
|
|
var example3 = { "a" : { "b" : null } };
|
|
var example4 = { "c" : 1 };
|
|
|
|
collection.ensureHashIndex("a.b");
|
|
|
|
d1 = collection.save(example1);
|
|
d2 = collection.save(example2);
|
|
d3 = collection.save(example3);
|
|
d4 = collection.save(example4);
|
|
|
|
s = collection.firstExample({ "a.b" : true });
|
|
assertEqual(d1._id, s._id);
|
|
s = collection.firstExample({ "a.b" : "foo" });
|
|
assertEqual(d2._id, s._id);
|
|
s = collection.firstExample({ "a.b" : false });
|
|
assertNull(s);
|
|
s = collection.firstExample({ "a.b" : null });
|
|
assertNotNull(s);
|
|
s = collection.firstExample({ "c" : 1 });
|
|
assertEqual(d4._id, s._id);
|
|
|
|
s = collection.firstExample(example1);
|
|
assertEqual(d1._id, s._id);
|
|
s = collection.firstExample(example2);
|
|
assertEqual(d2._id, s._id);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using indexes
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleSparseHash : function () {
|
|
var d1, d2, d3, d4, s;
|
|
var example1 = { "a" : { "b" : true } };
|
|
var example2 = { "a" : { "b" : "foo" } };
|
|
var example3 = { "a" : { "b" : null } };
|
|
var example4 = { "c" : 1 };
|
|
|
|
collection.ensureHashIndex("a.b", { sparse: true });
|
|
|
|
d1 = collection.save(example1);
|
|
d2 = collection.save(example2);
|
|
d3 = collection.save(example3);
|
|
d4 = collection.save(example4);
|
|
|
|
s = collection.firstExample({ "a.b" : true });
|
|
assertEqual(d1._id, s._id);
|
|
s = collection.firstExample({ "a.b" : "foo" });
|
|
assertEqual(d2._id, s._id);
|
|
s = collection.firstExample({ "a.b" : false });
|
|
assertNull(s);
|
|
s = collection.firstExample({ "a.b" : null });
|
|
assertNotNull(s);
|
|
s = collection.firstExample({ "c" : 1 });
|
|
assertEqual(d4._id, s._id);
|
|
|
|
s = collection.firstExample(example1);
|
|
assertEqual(d1._id, s._id);
|
|
s = collection.firstExample(example2);
|
|
assertEqual(d2._id, s._id);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using indexes
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleSkiplist1 : function () {
|
|
var d, s;
|
|
var example = { "a" : { "b" : true, "c" : "foo" }, "d" : true };
|
|
|
|
collection.ensureSkiplist("d");
|
|
|
|
d = collection.save(example);
|
|
s = collection.firstExample({ "d" : true });
|
|
assertEqual(d._id, s._id);
|
|
|
|
s = collection.firstExample({ "d" : false });
|
|
assertNull(s);
|
|
|
|
s = collection.firstExample({ "a.b" : true });
|
|
assertEqual(d._id, s._id);
|
|
|
|
s = collection.firstExample({ "a.c" : "foo" });
|
|
assertEqual(d._id, s._id);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using indexes
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleSkiplist2 : function () {
|
|
var d1, d2, d3, d4, s;
|
|
var example1 = { "a" : { "b" : true } };
|
|
var example2 = { "a" : { "b" : "foo" } };
|
|
var example3 = { "a" : { "b" : null } };
|
|
var example4 = { "c" : 1 };
|
|
|
|
collection.ensureSkiplist("a.b");
|
|
|
|
d1 = collection.save(example1);
|
|
d2 = collection.save(example2);
|
|
d3 = collection.save(example3);
|
|
d4 = collection.save(example4);
|
|
|
|
s = collection.firstExample({ "a.b" : true });
|
|
assertEqual(d1._id, s._id);
|
|
s = collection.firstExample({ "a.b" : "foo" });
|
|
assertEqual(d2._id, s._id);
|
|
s = collection.firstExample({ "a.b" : false });
|
|
assertNull(s);
|
|
s = collection.firstExample({ "a.b" : null });
|
|
assertNotNull(s);
|
|
s = collection.firstExample({ "c" : 1 });
|
|
assertEqual(d4._id, s._id);
|
|
|
|
s = collection.firstExample(example1);
|
|
assertEqual(d1._id, s._id);
|
|
s = collection.firstExample(example2);
|
|
assertEqual(d2._id, s._id);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using indexes
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleSparseSkiplist : function () {
|
|
var d1, d2, d3, d4, s;
|
|
var example1 = { "a" : { "b" : true } };
|
|
var example2 = { "a" : { "b" : "foo" } };
|
|
var example3 = { "a" : { "b" : null } };
|
|
var example4 = { "c" : 1 };
|
|
|
|
collection.ensureSkiplist("a.b", { sparse: true });
|
|
|
|
d1 = collection.save(example1);
|
|
d2 = collection.save(example2);
|
|
d3 = collection.save(example3);
|
|
d4 = collection.save(example4);
|
|
|
|
s = collection.firstExample({ "a.b" : true });
|
|
assertEqual(d1._id, s._id);
|
|
s = collection.firstExample({ "a.b" : "foo" });
|
|
assertEqual(d2._id, s._id);
|
|
s = collection.firstExample({ "a.b" : false });
|
|
assertNull(s);
|
|
s = collection.firstExample({ "a.b" : null });
|
|
assertNotNull(s);
|
|
s = collection.firstExample({ "c" : 1 });
|
|
assertEqual(d4._id, s._id);
|
|
|
|
s = collection.firstExample(example1);
|
|
assertEqual(d1._id, s._id);
|
|
s = collection.firstExample(example2);
|
|
assertEqual(d2._id, s._id);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleMultipleValues : function () {
|
|
[ null, 1, 2, true, false, "1", "2", "foo", "barbazbark", [ ] ].forEach(function(v) {
|
|
for (var i = 0; i < 5; ++i) {
|
|
collection.save({ value: v });
|
|
}
|
|
|
|
var result = collection.byExample({ value: v }).toArray();
|
|
assertEqual(5, result.length);
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleMultipleValuesHashIndex : function () {
|
|
collection.ensureHashIndex("value");
|
|
|
|
[ null, 1, 2, true, false, "1", "2", "foo", "barbazbark", [ ] ].forEach(function(v) {
|
|
for (var i = 0; i < 5; ++i) {
|
|
collection.save({ value: v });
|
|
}
|
|
|
|
var result = collection.byExample({ value: v }).toArray();
|
|
assertEqual(5, result.length);
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleMultipleValuesSparseHashIndex : function () {
|
|
collection.ensureHashIndex("value", { sparse: true });
|
|
|
|
[ null, 1, 2, true, false, "1", "2", "foo", "barbazbark", [ ] ].forEach(function(v) {
|
|
for (var i = 0; i < 5; ++i) {
|
|
collection.save({ value: v });
|
|
}
|
|
|
|
var result = collection.byExample({ value: v }).toArray();
|
|
assertEqual(5, result.length);
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleMultipleValuesSkiplist : function () {
|
|
collection.ensureSkiplist("value");
|
|
|
|
[ null, 1, 2, true, false, "1", "2", "foo", "barbazbark", [ ] ].forEach(function(v) {
|
|
for (var i = 0; i < 5; ++i) {
|
|
collection.save({ value: v });
|
|
}
|
|
|
|
var result = collection.byExample({ value: v }).toArray();
|
|
assertEqual(5, result.length);
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleMultipleValuesSparseSkiplist : function () {
|
|
collection.ensureSkiplist("value", { sparse: true });
|
|
|
|
[ null, 1, 2, true, false, "1", "2", "foo", "barbazbark", [ ] ].forEach(function(v) {
|
|
for (var i = 0; i < 5; ++i) {
|
|
collection.save({ value: v });
|
|
}
|
|
|
|
var result = collection.byExample({ value: v }).toArray();
|
|
assertEqual(5, result.length);
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using _key
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleKey : function () {
|
|
var d, s;
|
|
|
|
d = collection.save({ _key: "meow" });
|
|
s = collection.firstExample({ _key: "foo" });
|
|
assertNull(s);
|
|
|
|
s = collection.firstExample({ _key: "meow" });
|
|
assertEqual(d._id, s._id);
|
|
assertEqual(d._key, s._key);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using _key & others
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleKeyMore : function () {
|
|
var d, s;
|
|
|
|
d = collection.save({ _key: "meow" });
|
|
s = collection.firstExample({ _key: "meow", a: 1 });
|
|
assertNull(s);
|
|
|
|
d = collection.save({ _key: "foo", a: 2 });
|
|
s = collection.firstExample({ _key: "foo", a: 2 });
|
|
assertEqual(d._id, s._id);
|
|
assertEqual(d._key, s._key);
|
|
assertEqual(2, s.a);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using _rev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleRev : function () {
|
|
var d, s;
|
|
|
|
d = collection.save({ _key: "meow" });
|
|
s = collection.firstExample({ _rev: d._rev });
|
|
assertEqual(d._rev, s._rev);
|
|
|
|
s = collection.firstExample({ _rev: "foo" });
|
|
assertNull(s);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using _rev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleRevId : function () {
|
|
var d, s;
|
|
|
|
d = collection.save({ _key: "meow" });
|
|
s = collection.firstExample({ _rev: d._rev, _id: cn + "/meow" });
|
|
assertEqual(d._rev, s._rev);
|
|
|
|
s = collection.firstExample({ _rev: d._rev, _id: cn + "/foo" });
|
|
assertNull(s);
|
|
|
|
s = collection.firstExample({ _rev: "foo", _id: cn + "/meow" });
|
|
assertNull(s);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using _rev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleRevMore : function () {
|
|
var d, s;
|
|
|
|
d = collection.save({ _key: "meow", a: 1, b: 2 });
|
|
s = collection.firstExample({ _rev: d._rev, b: 2, a: 1 });
|
|
assertEqual(d._rev, s._rev);
|
|
assertEqual("meow", s._key);
|
|
|
|
s = collection.firstExample({ _rev: d._rev, a: 1 });
|
|
assertEqual(d._rev, s._rev);
|
|
assertEqual("meow", s._key);
|
|
|
|
s = collection.firstExample({ _rev: d._rev, b: 2 });
|
|
assertEqual(d._rev, s._rev);
|
|
assertEqual("meow", s._key);
|
|
|
|
s = collection.firstExample({ _rev: d._rev, a: 2 });
|
|
assertNull(s);
|
|
|
|
s = collection.firstExample({ _rev: d._rev, b: 1 });
|
|
assertNull(s);
|
|
|
|
s = collection.firstExample({ _rev: d._rev, a: 1, b: 3 });
|
|
assertNull(s);
|
|
|
|
s = collection.firstExample({ _rev: "foo", a: 1 });
|
|
assertNull(s);
|
|
|
|
s = collection.firstExample({ _rev: "foo", b: 2 });
|
|
assertNull(s);
|
|
|
|
s = collection.firstExample({ _rev: "foo", a: 1, b: 2 });
|
|
assertNull(s);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using _id
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleId : function () {
|
|
var d, s;
|
|
|
|
d = collection.save({ _key: "meow" });
|
|
s = collection.firstExample({ _id: cn + "/foo" });
|
|
assertNull(s);
|
|
|
|
s = collection.firstExample({ _id: cn + "/meow" });
|
|
assertEqual(d._id, s._id);
|
|
assertEqual(d._key, s._key);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using _id & others
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleIdMore : function () {
|
|
var d, s;
|
|
|
|
d = collection.save({ _key: "meow" });
|
|
s = collection.firstExample({ _id: cn + "/meow", a: 1 });
|
|
assertEqual(null, s);
|
|
|
|
d = collection.save({ _key: "foo", a: 2 });
|
|
s = collection.firstExample({ _id: cn + "/foo", a: 2 });
|
|
assertEqual(d._id, s._id);
|
|
assertEqual(d._key, s._key);
|
|
assertEqual(2, s.a);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using _id & sub-attributes
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleIdSubAttributes : function () {
|
|
var d, s;
|
|
|
|
d = collection.save({ _key: "meow", foo: { bar: "baz" } });
|
|
s = collection.firstExample({ _id: cn + "/meow", foo: { bar: "baz" } });
|
|
assertEqual(d._id, s._id);
|
|
assertEqual(d._key, s._key);
|
|
assertEqual({ bar: "baz" }, s.foo);
|
|
|
|
d = collection.save({ _key: "foo", values: [ { foo: "bar", baz: "bam" } ] });
|
|
s = collection.firstExample({ _id: cn + "/foo", values: [ { foo: "bar", baz: "bam" } ] });
|
|
assertEqual(d._id, s._id);
|
|
assertEqual(d._key, s._key);
|
|
assertEqual([ { foo: "bar", baz: "bam" } ], s.values);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using non existing system attribute
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleNonExisting : function () {
|
|
var d, s;
|
|
|
|
d = collection.save({ _key: "meow" });
|
|
s = collection.firstExample({ _foo: "foo" });
|
|
assertEqual(null, s);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleObject : function () {
|
|
var d1 = collection.save({ i : 1 });
|
|
var d2 = collection.save({ i : 1, a : { j : 1 } });
|
|
var d3 = collection.save({ i : 1, a : { j : 1, k : 1 } });
|
|
var d4 = collection.save({ i : 1, a : { j : 2, k : 2 } });
|
|
var d5 = collection.save({ i : 2 });
|
|
var d6 = collection.save({ i : 2, a : 2 });
|
|
var d7 = collection.save({ i : 2, a : { j : 2, k : 2 } });
|
|
var s;
|
|
|
|
s = collection.byExample({ i : 1 }).toArray().map(id).sort();
|
|
assertEqual([d1._id, d2._id, d3._id, d4._id].sort(), s);
|
|
|
|
s = collection.byExample({ i : 2 }).toArray().map(id).sort();
|
|
assertEqual([d5._id, d6._id, d7._id].sort(), s);
|
|
|
|
s = collection.byExample({ a : { j : 1 } }).toArray().map(id).sort();
|
|
assertEqual([d2._id], s);
|
|
|
|
s = collection.byExample({ "a.j" : 1 }).toArray().map(id).sort();
|
|
assertEqual([d2._id, d3._id].sort(), s);
|
|
|
|
s = collection.byExample({ i : 2, "a.k" : 2 }).toArray().map(id).sort();
|
|
assertEqual([d7._id], s);
|
|
|
|
s = collection.firstExample({ "i" : 2, "a.k" : 2 });
|
|
assertEqual(d7._id, s._id);
|
|
|
|
s = collection.firstExample({ "i" : 2, "a.k" : 27 });
|
|
assertEqual(null, s);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleList : function () {
|
|
var d1 = collection.save({ i : 1 });
|
|
var d2 = collection.save({ i : 1, a : { j : 1 } });
|
|
var d3 = collection.save({ i : 1, a : { j : 1, k : 1 } });
|
|
var d4 = collection.save({ i : 1, a : { j : 2, k : 2 } });
|
|
var d5 = collection.save({ i : 2 });
|
|
var d6 = collection.save({ i : 2, a : 2 });
|
|
var d7 = collection.save({ i : 2, a : { j : 2, k : 2 } });
|
|
var s;
|
|
|
|
s = collection.byExample("i", 1).toArray().map(id).sort();
|
|
assertEqual([d1._id, d2._id, d3._id, d4._id].sort(), s);
|
|
|
|
s = collection.byExample("i", 2).toArray().map(id).sort();
|
|
assertEqual([d5._id, d6._id, d7._id].sort(), s);
|
|
|
|
s = collection.byExample("a", { j : 1 }).toArray().map(id).sort();
|
|
assertEqual([d2._id], s);
|
|
|
|
s = collection.byExample("a.j", 1).toArray().map(id).sort();
|
|
assertEqual([d2._id, d3._id].sort(), s);
|
|
|
|
s = collection.byExample("i", 2, "a.k", 2).toArray().map(id).sort();
|
|
assertEqual([d7._id], s);
|
|
|
|
s = collection.firstExample("i", 2, "a.k", 2);
|
|
assertEqual(d7._id, s._id);
|
|
|
|
s = collection.firstExample("i", 2, "a.k", 27);
|
|
assertEqual(null, s);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: removeByExample
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemoveByExample : function () {
|
|
var deleted;
|
|
|
|
for (var i = 0; i < 50; ++i) {
|
|
collection.save({ value : i });
|
|
}
|
|
|
|
deleted = collection.removeByExample({ value : 2 });
|
|
assertEqual(1, deleted);
|
|
|
|
deleted = collection.removeByExample({ value : 2 });
|
|
assertEqual(0, deleted);
|
|
|
|
deleted = collection.removeByExample({ value : 20 });
|
|
assertEqual(1, deleted);
|
|
|
|
deleted = collection.removeByExample({ value : 20 });
|
|
assertEqual(0, deleted);
|
|
|
|
deleted = collection.removeByExample({ value : 1 });
|
|
assertEqual(1, deleted);
|
|
|
|
// not existing documents
|
|
deleted = collection.removeByExample({ value : 50 });
|
|
assertEqual(0, deleted);
|
|
|
|
deleted = collection.removeByExample({ value : null });
|
|
assertEqual(0, deleted);
|
|
|
|
deleted = collection.removeByExample({ value : "5" });
|
|
assertEqual(0, deleted);
|
|
|
|
deleted = collection.removeByExample({ peter : "meow" });
|
|
assertEqual(0, deleted);
|
|
|
|
collection.truncate();
|
|
deleted = collection.removeByExample({ value : 4 });
|
|
assertEqual(0, deleted);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: removeByExample with new signature
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemoveByExampleWithNewSignature : function () {
|
|
var deleted;
|
|
|
|
collection.save({ b: 1, value : 2222 });
|
|
|
|
for (var i = 0; i < 50; ++i) {
|
|
collection.save({ a: 1, value : i });
|
|
}
|
|
// test default parameter
|
|
deleted = collection.removeByExample({ b : 1 });
|
|
assertEqual(1, deleted);
|
|
|
|
deleted = collection.removeByExample({ a : 1 }, {limit : 10});
|
|
assertEqual(10, deleted);
|
|
|
|
deleted = collection.removeByExample({ a : 1 }, {waitForSync: true, limit : 15});
|
|
assertEqual(15, deleted);
|
|
|
|
// not existing documents
|
|
deleted = collection.removeByExample({ value : 500 });
|
|
assertEqual(0, deleted);
|
|
|
|
deleted = collection.removeByExample({ value : null });
|
|
assertEqual(0, deleted);
|
|
|
|
deleted = collection.removeByExample({ value : "5" });
|
|
assertEqual(0, deleted);
|
|
|
|
deleted = collection.removeByExample({ peter : "meow" });
|
|
assertEqual(0, deleted);
|
|
|
|
collection.truncate();
|
|
deleted = collection.removeByExample({ value : 4 });
|
|
assertEqual(0, deleted);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: removeByExample
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemoveByExampleMult : function () {
|
|
var deleted;
|
|
|
|
for (var i = 0; i < 5; ++i) {
|
|
for (var j = 0; j < 5; ++j) {
|
|
collection.save({ value1 : i, value2: j });
|
|
}
|
|
}
|
|
|
|
deleted = collection.removeByExample({ value2 : 2 });
|
|
assertEqual(5, deleted);
|
|
|
|
deleted = collection.removeByExample({ value2 : 2 });
|
|
assertEqual(0, deleted);
|
|
|
|
deleted = collection.removeByExample({ value1 : 4 });
|
|
assertEqual(4, deleted);
|
|
|
|
deleted = collection.removeByExample({ value1 : 4 });
|
|
assertEqual(0, deleted);
|
|
|
|
// not existing documents
|
|
deleted = collection.removeByExample({ value1 : 99 });
|
|
assertEqual(0, deleted);
|
|
|
|
deleted = collection.removeByExample({ value1 : "0" });
|
|
assertEqual(0, deleted);
|
|
|
|
deleted = collection.removeByExample({ meow : 1 });
|
|
assertEqual(0, deleted);
|
|
|
|
deleted = collection.removeByExample({ meow : "peter" });
|
|
assertEqual(0, deleted);
|
|
|
|
collection.truncate();
|
|
deleted = collection.removeByExample({ value1: 3 });
|
|
assertEqual(0, deleted);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: removeByExample
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRemoveByExampleLimit : function () {
|
|
var deleted;
|
|
|
|
for (var i = 0; i < 50; ++i) {
|
|
collection.save({ value : 1 });
|
|
}
|
|
|
|
deleted = collection.removeByExample({ value : 1 }, false, 10);
|
|
assertEqual(10, deleted);
|
|
|
|
assertEqual(40, collection.count());
|
|
|
|
deleted = collection.removeByExample({ value : 1 }, false, 20);
|
|
assertEqual(20, deleted);
|
|
|
|
assertEqual(20, collection.count());
|
|
|
|
deleted = collection.removeByExample({ value : 1 }, false, 20);
|
|
assertEqual(20, deleted);
|
|
|
|
assertEqual(0, collection.count());
|
|
|
|
deleted = collection.removeByExample({ value : 1 }, false, 20);
|
|
assertEqual(0, deleted);
|
|
|
|
assertEqual(0, collection.count());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: replaceByExample
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReplaceByExample : function () {
|
|
var replaced;
|
|
|
|
for (var i = 0; i < 50; ++i) {
|
|
collection.save({ value : i });
|
|
}
|
|
|
|
replaced = collection.replaceByExample({ value : 2 }, { foo : "bar", bar : "baz" });
|
|
assertEqual(1, replaced);
|
|
|
|
assertEqual(50, collection.count());
|
|
|
|
var doc = collection.firstExample({ foo : "bar", bar : "baz" });
|
|
assertEqual("bar", doc.foo);
|
|
assertEqual("baz", doc.bar);
|
|
assertEqual(undefined, doc.value);
|
|
|
|
// not existing documents
|
|
replaced = collection.replaceByExample({ meow : true }, { });
|
|
|
|
assertEqual(0, replaced);
|
|
|
|
replaced = collection.replaceByExample({ value : 142 }, { });
|
|
assertEqual(0, replaced);
|
|
|
|
replaced = collection.replaceByExample({ value : "peng!" }, { });
|
|
assertEqual(0, replaced);
|
|
|
|
collection.truncate();
|
|
replaced = collection.replaceByExample({ value : 6 }, { });
|
|
assertEqual(0, replaced);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: replaceByExampleWithNewSignature
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReplaceByExampleWithNewSignature : function () {
|
|
var replaced;
|
|
|
|
for (var i = 0; i < 50; ++i) {
|
|
collection.save({ value: 2, a: i, b: i + 1 });
|
|
}
|
|
|
|
replaced = collection.replaceByExample({ value : 2 },
|
|
{ foo : "bar", bar : "baz" },
|
|
{limit : 20, waitForSync: true});
|
|
assertEqual(20, replaced);
|
|
|
|
assertEqual(50, collection.count());
|
|
|
|
var doc = collection.firstExample({ foo : "bar", bar : "baz" });
|
|
assertEqual("bar", doc.foo);
|
|
assertEqual("baz", doc.bar);
|
|
assertEqual(undefined, doc.value);
|
|
assertEqual(undefined, doc.a);
|
|
assertEqual(undefined, doc.b);
|
|
|
|
// not existing documents
|
|
replaced = collection.replaceByExample({ meow : true }, { });
|
|
assertEqual(0, replaced);
|
|
|
|
replaced = collection.replaceByExample({ value : 142 }, { });
|
|
assertEqual(0, replaced);
|
|
|
|
replaced = collection.replaceByExample({ value : "peng!" }, { });
|
|
assertEqual(0, replaced);
|
|
|
|
collection.truncate();
|
|
replaced = collection.replaceByExample({ value : 6 }, { });
|
|
assertEqual(0, replaced);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: replaceByExample
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReplaceByExampleLimit : function () {
|
|
var replaced, docs;
|
|
|
|
for (var i = 0; i < 50; ++i) {
|
|
collection.save({ value : 1 });
|
|
}
|
|
|
|
replaced = collection.replaceByExample({ value : 1 }, { foo : "bar", bar : "baz" }, false, 10);
|
|
assertEqual(10, replaced);
|
|
|
|
assertEqual(50, collection.count());
|
|
|
|
docs = collection.byExample({ foo : "bar", bar : "baz" }).toArray();
|
|
assertEqual(10, docs.length);
|
|
docs = collection.byExample({ value : 1 }).toArray();
|
|
assertEqual(40, docs.length);
|
|
|
|
replaced = collection.replaceByExample({ value : 1 }, { meow : false }, false, 15);
|
|
assertEqual(15, replaced);
|
|
|
|
assertEqual(50, collection.count());
|
|
|
|
docs = collection.byExample({ foo : "bar", bar : "baz" }).toArray();
|
|
assertEqual(10, docs.length);
|
|
docs = collection.byExample({ meow : false }).toArray();
|
|
assertEqual(15, docs.length);
|
|
docs = collection.byExample({ value : 1 }).toArray();
|
|
assertEqual(25, docs.length);
|
|
|
|
// not existing documents
|
|
replaced = collection.replaceByExample({ meow : true }, { }, false, 99);
|
|
assertEqual(0, replaced);
|
|
|
|
replaced = collection.replaceByExample({ value : 42 }, { }, false, 99);
|
|
assertEqual(0, replaced);
|
|
|
|
replaced = collection.replaceByExample({ value : "peng!" }, { }, false, 99);
|
|
assertEqual(0, replaced);
|
|
|
|
// check counts
|
|
docs = collection.byExample({ foo : "bar", bar : "baz" }).toArray();
|
|
assertEqual(10, docs.length);
|
|
docs = collection.byExample({ meow : false }).toArray();
|
|
assertEqual(15, docs.length);
|
|
docs = collection.byExample({ value : 1 }).toArray();
|
|
assertEqual(25, docs.length);
|
|
|
|
collection.truncate();
|
|
replaced = collection.replaceByExample({ value : 1 }, { }, false);
|
|
assertEqual(0, replaced);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: updateByExample
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUpdateByExample : function () {
|
|
var updated;
|
|
|
|
for (var i = 0; i < 50; ++i) {
|
|
collection.save({ value : i });
|
|
}
|
|
|
|
// update and keep old values
|
|
updated = collection.updateByExample({ value : 2 }, { foo : "bar", bar : "baz" });
|
|
assertEqual(1, updated);
|
|
|
|
assertEqual(50, collection.count());
|
|
|
|
var doc = collection.firstExample({ foo : "bar", bar : "baz" });
|
|
assertEqual("bar", doc.foo);
|
|
assertEqual("baz", doc.bar);
|
|
assertEqual(2, doc.value);
|
|
|
|
// update and remove old values
|
|
updated = collection.updateByExample({ value : 5 }, { foo : "bart", bar : "baz", value : null }, false);
|
|
assertEqual(1, updated);
|
|
|
|
doc = collection.firstExample({ foo : "bart", bar : "baz" });
|
|
assertEqual("bart", doc.foo);
|
|
assertEqual("baz", doc.bar);
|
|
assertEqual(undefined, doc.value);
|
|
|
|
// update and overwrite old values
|
|
updated = collection.updateByExample({ value : 17 }, { foo : "barw", bar : "baz", value : 9 }, false);
|
|
assertEqual(1, updated);
|
|
|
|
doc = collection.firstExample({ foo : "barw", bar : "baz" });
|
|
assertEqual("barw", doc.foo);
|
|
assertEqual("baz", doc.bar);
|
|
assertEqual(9, doc.value);
|
|
|
|
// not existing documents
|
|
updated = collection.updateByExample({ meow : true }, { });
|
|
assertEqual(0, updated);
|
|
|
|
updated = collection.updateByExample({ value : 142 }, { });
|
|
assertEqual(0, updated);
|
|
|
|
updated = collection.updateByExample({ value : "peng!" }, { });
|
|
assertEqual(0, updated);
|
|
|
|
collection.truncate();
|
|
updated = collection.updateByExample({ value : 6 }, { });
|
|
assertEqual(0, updated);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: updateByExample with new Signature
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUpdateByExampleWithNewSignature : function () {
|
|
var updated;
|
|
|
|
for (var i = 0; i < 50; ++i) {
|
|
collection.save({ value : i , a : 1});
|
|
}
|
|
|
|
// update and keep old values
|
|
updated = collection.updateByExample({ value : 2 }, { foo : "bar", bar : "baz" });
|
|
assertEqual(1, updated);
|
|
|
|
assertEqual(50, collection.count());
|
|
|
|
var doc = collection.firstExample({ foo : "bar", bar : "baz" });
|
|
assertEqual("bar", doc.foo);
|
|
assertEqual("baz", doc.bar);
|
|
assertEqual(2, doc.value);
|
|
|
|
// update and remove old values
|
|
updated = collection.updateByExample({ value : 5 },
|
|
{ foo : "bart", bar : "baz", value : null },
|
|
{keepNull: false});
|
|
assertEqual(1, updated);
|
|
|
|
doc = collection.firstExample({ foo : "bart", bar : "baz" });
|
|
assertEqual("bart", doc.foo);
|
|
assertEqual("baz", doc.bar);
|
|
assertEqual(undefined, doc.value);
|
|
|
|
// update and overwrite old values
|
|
updated = collection.updateByExample({ value : 17 }, { foo : "barw", bar : "baz", value : 9 }, {keepNull: false});
|
|
assertEqual(1, updated);
|
|
|
|
doc = collection.firstExample({ foo : "barw", bar : "baz" });
|
|
assertEqual("barw", doc.foo);
|
|
assertEqual("baz", doc.bar);
|
|
assertEqual(9, doc.value);
|
|
|
|
// update and remove old values keep null values
|
|
updated = collection.updateByExample({ value : 6 },
|
|
{ foo : "bart6", bar : "baz6", value : null },
|
|
{keepNull: true});
|
|
assertEqual(1, updated);
|
|
|
|
doc = collection.firstExample({ foo : "bart6", bar : "baz6" });
|
|
assertEqual("bart6", doc.foo);
|
|
assertEqual("baz6", doc.bar);
|
|
assertEqual(null, doc.value);
|
|
|
|
// not existing documents
|
|
updated = collection.updateByExample({ meow : true }, { });
|
|
assertEqual(0, updated);
|
|
|
|
updated = collection.updateByExample({ nonExistentValue : "foo" }, { });
|
|
assertEqual(0, updated);
|
|
|
|
collection.truncate();
|
|
updated = collection.updateByExample({ value : 6 }, { });
|
|
assertEqual(0, updated);
|
|
|
|
for (i = 0; i < 50; ++i) {
|
|
collection.save({ test : i , limitTest : 1});
|
|
}
|
|
// update and remove old values keep null values
|
|
updated = collection.updateByExample(
|
|
{ limitTest : 1 },
|
|
{ foo : "bart", bar : "baz", value : null },
|
|
{keepNull: true, limit : 30});
|
|
assertEqual(30, updated);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: updateByExample
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUpdateByExampleLimit : function () {
|
|
var updated, docs;
|
|
|
|
for (var i = 0; i < 50; ++i) {
|
|
collection.save({ value : 1 });
|
|
}
|
|
|
|
// update some, keep old values
|
|
updated = collection.updateByExample({ value : 1 }, { foo : "bar", bar : "baz" }, false, false, 10);
|
|
assertEqual(10, updated);
|
|
|
|
assertEqual(50, collection.count());
|
|
|
|
docs = collection.byExample({ foo : "bar", bar : "baz" }).toArray();
|
|
assertEqual(10, docs.length);
|
|
docs = collection.byExample({ value : 1 }).toArray();
|
|
assertEqual(50, docs.length);
|
|
|
|
// update some others
|
|
updated = collection.updateByExample({ value : 1 }, { meow : false }, false, false, 15);
|
|
assertEqual(15, updated);
|
|
|
|
assertEqual(50, collection.count());
|
|
|
|
docs = collection.byExample({ foo : "bar", bar : "baz" }).toArray();
|
|
assertEqual(10, docs.length);
|
|
docs = collection.byExample({ meow : false }).toArray();
|
|
assertEqual(15, docs.length);
|
|
docs = collection.byExample({ value : 1 }).toArray();
|
|
assertEqual(50, docs.length);
|
|
|
|
// update some, remove old values
|
|
updated = collection.updateByExample({ value : 1 }, { value : null, fox : true }, false, false, 5);
|
|
assertEqual(5, updated);
|
|
|
|
assertEqual(50, collection.count());
|
|
|
|
docs = collection.byExample({ fox : true }).toArray();
|
|
assertEqual(5, docs.length);
|
|
docs = collection.byExample({ value : 1 }).toArray();
|
|
assertEqual(45, docs.length);
|
|
|
|
// update some, overwrite old values
|
|
updated = collection.updateByExample({ value : 1 }, { value : 16 }, false, false, 10);
|
|
assertEqual(10, updated);
|
|
|
|
assertEqual(50, collection.count());
|
|
|
|
docs = collection.byExample({ value : 16 }).toArray();
|
|
assertEqual(10, docs.length);
|
|
docs = collection.byExample({ fox : true }).toArray();
|
|
assertEqual(5, docs.length);
|
|
docs = collection.byExample({ value : 1 }).toArray();
|
|
assertEqual(35, docs.length);
|
|
|
|
// not existing documents
|
|
updated = collection.updateByExample({ meow : true }, { }, false, false, 99);
|
|
assertEqual(0, updated);
|
|
|
|
updated = collection.updateByExample({ value : 42 }, { }, false, false, 99);
|
|
assertEqual(0, updated);
|
|
|
|
updated = collection.updateByExample({ value : "peng!" }, { }, false, false, 99);
|
|
assertEqual(0, updated);
|
|
|
|
collection.truncate();
|
|
updated = collection.updateByExample({ value : 1 }, { });
|
|
assertEqual(0, updated);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: updateByExample, mergeObjects
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUpdateByExampleMergeObjectsSameUnspecified : function () {
|
|
var updated;
|
|
|
|
collection.save({ _key: "one", value : { foo: "test" } });
|
|
|
|
// update don't specify mergeObjects behavior
|
|
updated = collection.updateByExample({ value: { foo : "test" } }, { value: { foo : "baz" } });
|
|
assertEqual(1, updated);
|
|
|
|
var doc = collection.document("one");
|
|
assertEqual({ foo: "baz" }, doc.value);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: updateByExample, mergeObjects
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUpdateByExampleMergeObjectsUnspecified : function () {
|
|
var updated;
|
|
|
|
collection.save({ _key: "one", value : { foo: "test" } });
|
|
|
|
// update don't specify mergeObjects behavior
|
|
updated = collection.updateByExample({ value: { foo : "test" } },
|
|
{ value: { bar : "baz" } });
|
|
assertEqual(1, updated);
|
|
|
|
var doc = collection.document("one");
|
|
assertEqual({ foo: "test", bar: "baz" }, doc.value);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: updateByExample, mergeObjects
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUpdateByExampleMergeObjectsTrue : function () {
|
|
var updated;
|
|
|
|
collection.save({ _key: "one", value : { foo: "test" } });
|
|
|
|
// update don't specify mergeObjects behavior
|
|
updated = collection.updateByExample({ value: { foo : "test" } },
|
|
{ value: { bar : "baz" } },
|
|
{ mergeObjects: true });
|
|
assertEqual(1, updated);
|
|
|
|
var doc = collection.document("one");
|
|
assertEqual({ foo: "test", bar: "baz" }, doc.value);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: updateByExample, mergeObjects
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUpdateByExampleMergeObjectsFalse : function () {
|
|
var updated;
|
|
|
|
collection.save({ _key: "one", value : { foo: "test" } });
|
|
|
|
// update don't specify mergeObjects behavior
|
|
updated = collection.updateByExample({ value: { foo : "test" } },
|
|
{ value: { bar : "baz" } },
|
|
{ mergeObjects: false });
|
|
assertEqual(1, updated);
|
|
|
|
var doc = collection.document("one");
|
|
assertEqual({ bar: "baz" }, doc.value);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: updateByExample, mergeObjects
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUpdateByExampleMergeObjectsEmptyObject : function () {
|
|
var updated;
|
|
|
|
collection.save({ _key: "one", value : { foo: "test" } });
|
|
|
|
// update don't specify mergeObjects behavior
|
|
updated = collection.updateByExample({ value: { foo : "test" } }, { value: { } });
|
|
assertEqual(1, updated);
|
|
|
|
var doc = collection.document("one");
|
|
assertEqual({ foo: "test" }, doc.value);
|
|
}
|
|
};
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite: query-by-example
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function SimpleQueryByExampleEdgeSuite () {
|
|
'use strict';
|
|
var cn = "UnitTestsCollectionByExample";
|
|
var c1 = "UnitTestsCollectionByExampleEdge";
|
|
var collection = null;
|
|
var edge = null;
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._drop(cn);
|
|
db._drop(c1);
|
|
collection = db._create(cn);
|
|
edge = db._createEdgeCollection(c1);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
collection.drop();
|
|
edge.drop();
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using edge index
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleEdgeFrom : function () {
|
|
edge.save(cn + "/foo", cn + "/bar", { _key: "e1", foo: "bar" });
|
|
edge.save(cn + "/bar", cn + "/foo", { _key: "e2", bar: "foo" });
|
|
|
|
var doc;
|
|
doc = edge.firstExample({ _from: cn + "/foo" });
|
|
assertEqual(c1 + "/e1", doc._id);
|
|
assertEqual("e1", doc._key);
|
|
assertEqual("bar", doc.foo);
|
|
assertEqual(cn + "/foo", doc._from);
|
|
assertEqual(cn + "/bar", doc._to);
|
|
|
|
doc = edge.firstExample({ _from: cn + "/barbaz" });
|
|
assertNull(doc);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using edge index
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleEdgeFromMore : function () {
|
|
edge.save(cn + "/foo", cn + "/bar", { _key: "e1", foo: "bar" });
|
|
edge.save(cn + "/bar", cn + "/foo", { _key: "e2", bar: "foo" });
|
|
|
|
var doc;
|
|
doc = edge.firstExample({ _from: cn + "/foo", foo: "bar" });
|
|
assertEqual(c1 + "/e1", doc._id);
|
|
assertEqual("e1", doc._key);
|
|
assertEqual("bar", doc.foo);
|
|
assertEqual(cn + "/foo", doc._from);
|
|
assertEqual(cn + "/bar", doc._to);
|
|
|
|
doc = edge.firstExample({ _from: cn + "/foo", foo: "baz" });
|
|
assertNull(doc);
|
|
|
|
doc = edge.firstExample({ _from: cn + "/foo", bar: "foo" });
|
|
assertNull(doc);
|
|
|
|
doc = edge.firstExample({ _from: cn + "/foo", boo: "far" });
|
|
assertNull(doc);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using edge index
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleEdgeTo : function () {
|
|
edge.save(cn + "/foo", cn + "/bar", { _key: "e1", foo: "bar" });
|
|
edge.save(cn + "/bar", cn + "/foo", { _key: "e2", bar: "foo" });
|
|
|
|
var doc;
|
|
doc = edge.firstExample({ _to: cn + "/foo" });
|
|
assertEqual(c1 + "/e2", doc._id);
|
|
assertEqual("e2", doc._key);
|
|
assertEqual("foo", doc.bar);
|
|
assertEqual(cn + "/bar", doc._from);
|
|
assertEqual(cn + "/foo", doc._to);
|
|
|
|
doc = edge.firstExample({ _to: cn + "/bart" });
|
|
assertNull(doc);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using edge index
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleEdgeToMore : function () {
|
|
edge.save(cn + "/foo", cn + "/bar", { _key: "e1", foo: "bar" });
|
|
edge.save(cn + "/bar", cn + "/foo", { _key: "e2", bar: "foo" });
|
|
|
|
var doc;
|
|
doc = edge.firstExample({ _to: cn + "/foo", bar: "foo" });
|
|
assertEqual(c1 + "/e2", doc._id);
|
|
assertEqual("e2", doc._key);
|
|
assertEqual("foo", doc.bar);
|
|
assertEqual(cn + "/bar", doc._from);
|
|
assertEqual(cn + "/foo", doc._to);
|
|
|
|
doc = edge.firstExample({ _to: cn + "/foo", bar: "baz" });
|
|
assertNull(doc);
|
|
|
|
doc = edge.firstExample({ _to: cn + "/foo", foo: "bar" });
|
|
assertNull(doc);
|
|
|
|
doc = edge.firstExample({ _to: cn + "/foo", boo: "far" });
|
|
assertNull(doc);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using edge index
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleEdgeFromTo : function () {
|
|
edge.save(cn + "/foo", cn + "/bar", { _key: "e1", foo: "bar" });
|
|
edge.save(cn + "/bar", cn + "/foo", { _key: "e2", bar: "foo" });
|
|
|
|
var doc;
|
|
doc = edge.firstExample({ _to: cn + "/foo", _from: cn + "/bar" });
|
|
assertEqual(c1 + "/e2", doc._id);
|
|
assertEqual("e2", doc._key);
|
|
assertEqual("foo", doc.bar);
|
|
assertEqual(cn + "/bar", doc._from);
|
|
assertEqual(cn + "/foo", doc._to);
|
|
|
|
doc = edge.firstExample({ _to: cn + "/foo", _from: cn + "/baz" });
|
|
assertNull(doc);
|
|
|
|
doc = edge.firstExample({ _to: cn + "/bar", _from: cn + "/bar" });
|
|
assertNull(doc);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: byExample, using edge index
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testByExampleEdgeFromToMore : function () {
|
|
edge.save(cn + "/foo", cn + "/bar", { _key: "e1", foo: "bar" });
|
|
edge.save(cn + "/bar", cn + "/foo", { _key: "e2", bar: "foo" });
|
|
|
|
var doc;
|
|
doc = edge.firstExample({ _to: cn + "/foo", _from: cn + "/bar", bar: "foo" });
|
|
assertEqual(c1 + "/e2", doc._id);
|
|
assertEqual("e2", doc._key);
|
|
assertEqual("foo", doc.bar);
|
|
assertEqual(cn + "/bar", doc._from);
|
|
assertEqual(cn + "/foo", doc._to);
|
|
|
|
doc = edge.firstExample({ _to: cn + "/foo", _from: cn + "/baz", bar: "baz" });
|
|
assertNull(doc);
|
|
|
|
doc = edge.firstExample({ _to: cn + "/foo", _from: cn + "/baz", foo: "bar" });
|
|
assertNull(doc);
|
|
|
|
doc = edge.firstExample({ _to: cn + "/bar", _from: cn + "/bar", boo: "far" });
|
|
assertNull(doc);
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite: range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function SimpleQueryRangeSuite () {
|
|
'use strict';
|
|
var cn = "UnitTestsCollectionRange";
|
|
var collection = null;
|
|
var age = function(d) { return d.age; };
|
|
var ageSort = function(l, r) { if (l !== r) { if (l < r) { return -1; } return 1; } return 0; };
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._drop(cn);
|
|
collection = db._create(cn);
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
collection.save({ age : i });
|
|
}
|
|
|
|
collection.ensureSkiplist("age");
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
collection.drop();
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRange : function () {
|
|
var l = collection.range("age", 10, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 10, 11, 12 ], l);
|
|
|
|
l = collection.closedRange("age", 10, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 10, 11, 12, 13 ], l);
|
|
|
|
l = collection.range("age", null, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ], l);
|
|
|
|
l = collection.closedRange("age", null, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ], l);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite: range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function SimpleQuerySparseRangeSuite () {
|
|
'use strict';
|
|
var cn = "UnitTestsCollectionRange";
|
|
var collection = null;
|
|
var age = function(d) { return d.age; };
|
|
var ageSort = function(l, r) { if (l !== r) { if (l < r) { return -1; } return 1; } return 0; };
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._drop(cn);
|
|
collection = db._create(cn);
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
collection.save({ age : i });
|
|
}
|
|
|
|
collection.ensureSkiplist("age", { sparse: true });
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
collection.drop();
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRange : function () {
|
|
var l = collection.range("age", 10, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 10, 11, 12 ], l);
|
|
|
|
l = collection.closedRange("age", 10, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 10, 11, 12, 13 ], l);
|
|
|
|
l = collection.range("age", null, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ], l);
|
|
|
|
l = collection.closedRange("age", null, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ], l);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRangeMultipleIndexes : function () {
|
|
// now we have a sparse and a non-sparse index
|
|
collection.ensureSkiplist("age", { sparse: false });
|
|
|
|
var l = collection.range("age", 10, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 10, 11, 12 ], l);
|
|
|
|
l = collection.closedRange("age", 10, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 10, 11, 12, 13 ], l);
|
|
|
|
l = collection.range("age", null, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ], l);
|
|
|
|
l = collection.closedRange("age", null, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ], l);
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite: range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function SimpleQueryUniqueRangeSuite () {
|
|
'use strict';
|
|
var cn = "UnitTestsCollectionRange";
|
|
var collection = null;
|
|
var age = function(d) { return d.age; };
|
|
var ageSort = function(l, r) { if (l !== r) { if (l < r) { return -1; } return 1; } return 0; };
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._drop(cn);
|
|
collection = db._create(cn);
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
collection.save({ age : i });
|
|
}
|
|
|
|
collection.ensureUniqueSkiplist("age");
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
collection.drop();
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRange : function () {
|
|
var l = collection.range("age", 10, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 10, 11, 12 ], l);
|
|
|
|
l = collection.closedRange("age", 10, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 10, 11, 12, 13 ], l);
|
|
|
|
l = collection.range("age", null, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ], l);
|
|
|
|
l = collection.closedRange("age", null, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ], l);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite: range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function SimpleQueryUniqueSparseRangeSuite () {
|
|
'use strict';
|
|
var cn = "UnitTestsCollectionRange";
|
|
var collection = null;
|
|
var age = function(d) { return d.age; };
|
|
var ageSort = function(l, r) { if (l !== r) { if (l < r) { return -1; } return 1; } return 0; };
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._drop(cn);
|
|
collection = db._create(cn);
|
|
|
|
for (var i = 0; i < 100; ++i) {
|
|
collection.save({ age : i });
|
|
}
|
|
|
|
collection.ensureUniqueSkiplist("age", { sparse: true });
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
collection.drop();
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRange : function () {
|
|
var l = collection.range("age", 10, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 10, 11, 12 ], l);
|
|
|
|
l = collection.closedRange("age", 10, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 10, 11, 12, 13 ], l);
|
|
|
|
l = collection.range("age", null, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ], l);
|
|
|
|
l = collection.closedRange("age", null, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ], l);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRangeMultipleIndexes : function () {
|
|
// now we have a sparse and a non-sparse index
|
|
collection.ensureUniqueSkiplist("age", { sparse: false });
|
|
|
|
var l = collection.range("age", 10, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 10, 11, 12 ], l);
|
|
|
|
l = collection.closedRange("age", 10, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 10, 11, 12, 13 ], l);
|
|
|
|
l = collection.range("age", null, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ], l);
|
|
|
|
l = collection.closedRange("age", null, 13).toArray().map(age).sort(ageSort);
|
|
assertEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ], l);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite: range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function SimpleQueryAnySuite () {
|
|
'use strict';
|
|
var cn = "UnitTestsCollectionAny";
|
|
var collectionEmpty = null;
|
|
var collectionOne = null;
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
var name;
|
|
|
|
name = cn + "Empty";
|
|
db._drop(name);
|
|
collectionEmpty = db._create(name);
|
|
|
|
name = cn + "One";
|
|
db._drop(name);
|
|
collectionOne = db._create(name, { waitForSync : false });
|
|
collectionOne.save({ age : 1 });
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
collectionEmpty.drop();
|
|
collectionOne.drop();
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test: any
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAny : function () {
|
|
var d = collectionEmpty.any();
|
|
assertEqual(null, d);
|
|
|
|
d = collectionOne.any();
|
|
assertNotNull(d);
|
|
assertEqual(1, d.age);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief executes the test suites
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
jsunity.run(SimpleQueryLookupByKeysSuite);
|
|
jsunity.run(SimpleQueryRemoveByKeysSuite);
|
|
jsunity.run(SimpleQueryArraySkipLimitSuite);
|
|
jsunity.run(SimpleQueryAllSkipLimitSuite);
|
|
jsunity.run(SimpleQueryByExampleSuite);
|
|
jsunity.run(SimpleQueryByExampleEdgeSuite);
|
|
jsunity.run(SimpleQueryRangeSuite);
|
|
jsunity.run(SimpleQuerySparseRangeSuite);
|
|
jsunity.run(SimpleQueryUniqueRangeSuite);
|
|
jsunity.run(SimpleQueryUniqueSparseRangeSuite);
|
|
jsunity.run(SimpleQueryAnySuite);
|
|
|
|
return jsunity.done();
|
|
|