772 lines
30 KiB
JavaScript
772 lines
30 KiB
JavaScript
(function() {
|
|
"use strict";
|
|
|
|
var crudAPISpecTests = function crudAPISpecTests() {
|
|
"use strict";
|
|
|
|
// Get the colllection
|
|
var coll = db.crud_tests;
|
|
|
|
// Setup
|
|
function createTestExecutor(coll, method, verifyResult) {
|
|
return function(args) {
|
|
// Drop collection
|
|
coll.drop();
|
|
// Insert test data
|
|
var r = coll.insertMany(args.insert);
|
|
assert.eq(args.insert.length, r.insertedIds.length);
|
|
|
|
// Execute the method with arguments
|
|
r = coll[method].apply(coll, args.params);
|
|
verifyResult(args.result, r);
|
|
|
|
// Get all the results
|
|
var results = coll.find({}).sort({_id: 1}).toArray();
|
|
|
|
assert.docEq(args.expected, results);
|
|
}
|
|
}
|
|
|
|
function checkResultObject(first, second) {
|
|
// Only assert on the "modifiedCount" property when write commands are enabled
|
|
if (db.getMongo().writeMode() === 'commands') {
|
|
assert.docEq(first, second);
|
|
} else {
|
|
var overrideModifiedCount = {modifiedCount: undefined};
|
|
assert.docEq(Object.merge(first, overrideModifiedCount),
|
|
Object.merge(second, overrideModifiedCount));
|
|
}
|
|
}
|
|
|
|
// Setup executors
|
|
var deleteManyExecutor = createTestExecutor(coll, 'deleteMany', checkResultObject);
|
|
var deleteOneExecutor = createTestExecutor(coll, 'deleteOne', checkResultObject);
|
|
var bulkWriteExecutor = createTestExecutor(coll, 'bulkWrite', checkResultObject);
|
|
var findOneAndDeleteExecutor = createTestExecutor(coll, 'findOneAndDelete',
|
|
checkResultObject);
|
|
var findOneAndReplaceExecutor = createTestExecutor(coll, 'findOneAndReplace',
|
|
checkResultObject);
|
|
var findOneAndUpdateExecutor = createTestExecutor(coll, 'findOneAndUpdate',
|
|
checkResultObject);
|
|
var insertManyExecutor = createTestExecutor(coll, 'insertMany', checkResultObject);
|
|
var insertOneExecutor = createTestExecutor(coll, 'insertOne', checkResultObject);
|
|
var replaceOneExecutor = createTestExecutor(coll, 'replaceOne', checkResultObject);
|
|
var updateManyExecutor = createTestExecutor(coll, 'updateMany', checkResultObject);
|
|
var updateOneExecutor = createTestExecutor(coll, 'updateOne', checkResultObject);
|
|
var countExecutor = createTestExecutor(coll, 'count', assert.eq);
|
|
var distinctExecutor = createTestExecutor(coll, 'distinct', assert.eq);
|
|
|
|
//
|
|
// BulkWrite
|
|
//
|
|
|
|
bulkWriteExecutor({
|
|
insert: [{ _id: 1, c: 1 }, { _id: 2, c: 2 }, { _id: 3, c: 3 }],
|
|
params: [[
|
|
{ insertOne: { document: {_id: 4, a: 1 } } }
|
|
, { updateOne: { filter: {_id: 5, a:2}, update: {$set: {a:2}}, upsert:true } }
|
|
, { updateMany: { filter: {_id: 6,a:3}, update: {$set: {a:3}}, upsert:true } }
|
|
, { deleteOne: { filter: {c:1} } }
|
|
, { insertOne: { document: {_id: 7, c: 2 } } }
|
|
, { deleteMany: { filter: {c:2} } }
|
|
, { replaceOne: { filter: {c:3}, replacement: {c:4}, upsert:true } }]],
|
|
result: {
|
|
acknowledged: true, insertedCount:2,
|
|
matchedCount:1, deletedCount: 3,
|
|
upsertedCount:2, insertedIds : {'0' : 4, '4' : 7 }, upsertedIds : { '1' : 5, '2' : 6 }
|
|
},
|
|
expected: [{ "_id" : 3, "c" : 4 }, { "_id" : 4, "a" : 1 }, { "_id" : 5, "a" : 2 }, { "_id" : 6, "a" : 3 }]
|
|
});
|
|
|
|
bulkWriteExecutor({
|
|
insert: [{ _id: 1, c: 1 }, { _id: 2, c: 2 }, { _id: 3, c: 3 }],
|
|
params: [[
|
|
{ insertOne: { document: { _id: 4, a: 1 } } }
|
|
, { updateOne: { filter: {_id: 5, a:2}, update: {$set: {a:2}}, upsert:true } }
|
|
, { updateMany: { filter: {_id: 6, a:3}, update: {$set: {a:3}}, upsert:true } }
|
|
, { deleteOne: { filter: {c:1} } }
|
|
, { deleteMany: { filter: {c:2} } }
|
|
, { replaceOne: { filter: {c:3}, replacement: {c:4}, upsert:true } }], { ordered: false }],
|
|
result: {
|
|
acknowledged: true, insertedCount:1, matchedCount:1, deletedCount:2, upsertedCount:2, insertedIds : {'0' : 4 }, upsertedIds : { '1' : 5, '2' : 6 }
|
|
},
|
|
expected: [{ "_id" : 3, "c" : 4 }, { "_id" : 4, "a" : 1 }, { "_id" : 5, "a" : 2 }, { "_id" : 6, "a" : 3 }]
|
|
});
|
|
|
|
// DeleteMany
|
|
//
|
|
|
|
// DeleteMany when many documents match
|
|
deleteManyExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: { $gt: 1 } }
|
|
],
|
|
result: {acknowledged: true, deletedCount:2},
|
|
expected: [{_id:1, x: 11}]
|
|
});
|
|
// DeleteMany when no document matches
|
|
deleteManyExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: 4 }
|
|
],
|
|
result: {acknowledged: true, deletedCount:0},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}]
|
|
});
|
|
// DeleteMany when many documents match, no write concern
|
|
deleteManyExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: { $gt: 1 } }, { w : 0 }
|
|
],
|
|
result: {acknowledged: false},
|
|
expected: [{_id:1, x: 11}]
|
|
});
|
|
|
|
//
|
|
// DeleteOne
|
|
//
|
|
|
|
// DeleteOne when many documents match
|
|
deleteOneExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: { $gt: 1 } }
|
|
],
|
|
result: {acknowledged: true, deletedCount:1},
|
|
expected: [{_id:1, x: 11}, {_id:3, x: 33}]
|
|
});
|
|
// DeleteOne when one document matches
|
|
deleteOneExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: 2 }
|
|
],
|
|
result: {acknowledged: true, deletedCount:1},
|
|
expected: [{_id:1, x: 11}, {_id:3, x: 33}]
|
|
});
|
|
// DeleteOne when no documents match
|
|
deleteOneExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: 4 }
|
|
],
|
|
result: {acknowledged: true, deletedCount:0},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}]
|
|
});
|
|
// DeleteOne when many documents match, no write concern
|
|
deleteOneExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: { $gt: 1 } }, {w:0}
|
|
],
|
|
result: {acknowledged: false},
|
|
expected: [{_id:1, x: 11}, {_id:3, x: 33}]
|
|
});
|
|
|
|
//
|
|
// FindOneAndDelete
|
|
//
|
|
|
|
// FindOneAndDelete when one document matches
|
|
findOneAndDeleteExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: { $gt: 2 } }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 } }
|
|
],
|
|
result: {x:33},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}]
|
|
});
|
|
// FindOneAndDelete when one document matches
|
|
findOneAndDeleteExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: 2 }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 } }
|
|
],
|
|
result: {x:22},
|
|
expected: [{_id:1, x: 11}, {_id:3, x: 33}]
|
|
});
|
|
// FindOneAndDelete when no documents match
|
|
findOneAndDeleteExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: 4 }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 } }
|
|
],
|
|
result: null,
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}]
|
|
});
|
|
|
|
//
|
|
// FindOneAndReplace
|
|
//
|
|
|
|
// FindOneAndReplace when many documents match returning the document before modification
|
|
findOneAndReplaceExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: { $gt: 1 } }
|
|
, { x: 32 }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 } }
|
|
],
|
|
result: {x:22},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 32}, {_id:3, x: 33}]
|
|
});
|
|
// FindOneAndReplace when many documents match returning the document after modification
|
|
findOneAndReplaceExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: { $gt: 1 } }
|
|
, { x: 32 }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 }, returnNewDocument:true }
|
|
],
|
|
result: {x:32},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 32}, {_id:3, x: 33}]
|
|
});
|
|
// FindOneAndReplace when one document matches returning the document before modification
|
|
findOneAndReplaceExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: 2 }
|
|
, { x: 32 }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 } }
|
|
],
|
|
result: {x:22},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 32}, {_id:3, x: 33}]
|
|
});
|
|
// FindOneAndReplace when one document matches returning the document after modification
|
|
findOneAndReplaceExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: 2 }
|
|
, { x: 32 }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 }, returnNewDocument:true }
|
|
],
|
|
result: {x:32},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 32}, {_id:3, x: 33}]
|
|
});
|
|
// FindOneAndReplace when no documents match returning the document before modification
|
|
findOneAndReplaceExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: 4 }
|
|
, { x: 44 }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 } }
|
|
],
|
|
result: null,
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}]
|
|
});
|
|
// FindOneAndReplace when no documents match with upsert returning the document before modification
|
|
findOneAndReplaceExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: 4 }
|
|
, { x: 44 }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 }, upsert:true }
|
|
],
|
|
result: null,
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}, {_id:4, x:44}]
|
|
});
|
|
// FindOneAndReplace when no documents match returning the document after modification
|
|
findOneAndReplaceExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: 4 }
|
|
, { x: 44 }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 }, returnNewDocument:true }
|
|
],
|
|
result: null,
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}]
|
|
});
|
|
// FindOneAndReplace when no documents match with upsert returning the document after modification
|
|
findOneAndReplaceExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: 4 }
|
|
, { x: 44 }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 }, returnNewDocument:true, upsert:true }
|
|
],
|
|
result: {x:44},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}, {_id:4, x: 44}]
|
|
});
|
|
|
|
assert.throws(function() {
|
|
coll.findOneAndReplace({a:1}, {$set:{b:1}});
|
|
});
|
|
|
|
//
|
|
// FindOneAndUpdate
|
|
//
|
|
|
|
// FindOneAndUpdate when many documents match returning the document before modification
|
|
findOneAndUpdateExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: { $gt: 1 } }
|
|
, { $inc: { x: 1 } }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 } }
|
|
],
|
|
result: {x:22},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 23}, {_id:3, x: 33}]
|
|
});
|
|
// FindOneAndUpdate when many documents match returning the document after modification
|
|
findOneAndUpdateExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: { $gt: 1 } }
|
|
, { $inc: { x: 1 } }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 }, returnNewDocument: true }
|
|
],
|
|
result: {x:23},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 23}, {_id:3, x: 33}]
|
|
});
|
|
// FindOneAndUpdate when one document matches returning the document before modification
|
|
findOneAndUpdateExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: 2 }
|
|
, { $inc: { x: 1 } }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 } }
|
|
],
|
|
result: {x:22},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 23}, {_id:3, x: 33}]
|
|
});
|
|
// FindOneAndUpdate when one document matches returning the document after modification
|
|
findOneAndUpdateExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: 2 }
|
|
, { $inc: { x: 1 } }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 }, returnNewDocument: true }
|
|
],
|
|
result: {x:23},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 23}, {_id:3, x: 33}]
|
|
});
|
|
// FindOneAndUpdate when no documents match returning the document before modification
|
|
findOneAndUpdateExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: 4 }
|
|
, { $inc: { x: 1 } }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 } }
|
|
],
|
|
result: null,
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}]
|
|
});
|
|
// FindOneAndUpdate when no documents match with upsert returning the document before modification
|
|
findOneAndUpdateExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: 4 }
|
|
, { $inc: { x: 1 } }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 }, upsert:true }
|
|
],
|
|
result: null,
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}, {_id:4, x: 1}]
|
|
});
|
|
// FindOneAndUpdate when no documents match returning the document after modification
|
|
findOneAndUpdateExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: 4 }
|
|
, { $inc: { x: 1 } }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 }, returnNewDocument:true }
|
|
],
|
|
result: null,
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}]
|
|
});
|
|
// FindOneAndUpdate when no documents match with upsert returning the document after modification
|
|
findOneAndUpdateExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [
|
|
{ _id: 4 }
|
|
, { $inc: { x: 1 } }
|
|
, { projection: { x: 1, _id: 0 }, sort: { x: 1 }, returnNewDocument:true, upsert:true }
|
|
],
|
|
result: {x:1},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}, {_id:4, x: 1}]
|
|
});
|
|
|
|
assert.throws(function() {
|
|
coll.findOneAndUpdate({a:1}, {});
|
|
});
|
|
|
|
assert.throws(function() {
|
|
coll.findOneAndUpdate({a:1}, {b:1});
|
|
});
|
|
|
|
//
|
|
// InsertMany
|
|
//
|
|
|
|
// InsertMany with non-existing documents
|
|
insertManyExecutor({
|
|
insert: [{ _id:1, x:11 }],
|
|
params: [
|
|
[{_id: 2, x: 22}, {_id:3, x:33}]
|
|
],
|
|
result: {acknowledged: true, insertedIds: [2, 3]},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}]
|
|
});
|
|
// InsertMany with non-existing documents, no write concern
|
|
insertManyExecutor({
|
|
insert: [{ _id:1, x:11 }],
|
|
params: [
|
|
[{_id: 2, x: 22}, {_id:3, x:33}]
|
|
, {w:0}
|
|
],
|
|
result: {acknowledged: false},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}]
|
|
});
|
|
|
|
//
|
|
// InsertOne
|
|
//
|
|
|
|
// InsertOne with non-existing documents
|
|
insertOneExecutor({
|
|
insert: [{ _id:1, x:11 }],
|
|
params: [
|
|
{_id: 2, x: 22}
|
|
],
|
|
result: {acknowledged: true, insertedId: 2},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}]
|
|
});
|
|
// InsertOne with non-existing documents, no write concern
|
|
insertOneExecutor({
|
|
insert: [{ _id:1, x:11 }],
|
|
params: [
|
|
{_id: 2, x: 22}, {w:0}
|
|
],
|
|
result: {acknowledged: false},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}]
|
|
});
|
|
|
|
//
|
|
// ReplaceOne
|
|
//
|
|
|
|
// ReplaceOne when many documents match
|
|
replaceOneExecutor({
|
|
insert: [{ _id: 1, x: 11 }, { _id: 2, x: 22 }, { _id:3, x:33 }],
|
|
params: [{ _id: { $gt: 1 } }, { x: 111 }],
|
|
result: {acknowledged:true, matchedCount:1, modifiedCount:1},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 111}, {_id:3, x: 33}]
|
|
});
|
|
// ReplaceOne when one document matches
|
|
replaceOneExecutor({
|
|
insert: [{ _id: 1, x: 11 }, { _id: 2, x: 22 }, { _id:3, x:33 }],
|
|
params: [{ _id: 1 }, { _id: 1, x: 111 }],
|
|
result: {acknowledged:true, matchedCount:1, modifiedCount:1},
|
|
expected: [{_id:1, x: 111}, {_id:2, x: 22}, {_id:3, x: 33}]
|
|
});
|
|
// ReplaceOne when no documents match
|
|
replaceOneExecutor({
|
|
insert: [{ _id: 1, x: 11 }, { _id: 2, x: 22 }, { _id:3, x:33 }],
|
|
params: [{ _id: 4 }, { _id: 4, x: 1 }],
|
|
result: {acknowledged:true, matchedCount:0, modifiedCount:0},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}]
|
|
});
|
|
// ReplaceOne with upsert when no documents match without an id specified
|
|
replaceOneExecutor({
|
|
insert: [{ _id: 1, x: 11 }, { _id: 2, x: 22 }, { _id:3, x:33 }],
|
|
params: [{ _id: 4 }, { x: 1 }, {upsert:true}],
|
|
result: {acknowledged:true, matchedCount:0, modifiedCount:0, upsertedId: 4},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}, {_id:4, x: 1}]
|
|
});
|
|
// ReplaceOne with upsert when no documents match with an id specified
|
|
replaceOneExecutor({
|
|
insert: [{ _id: 1, x: 11 }, { _id: 2, x: 22 }, { _id:3, x:33 }],
|
|
params: [{ _id: 4 }, { _id: 4, x: 1 }, {upsert:true}],
|
|
result: {acknowledged:true, matchedCount:0, modifiedCount:0, upsertedId: 4},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}, {_id:4, x: 1}]
|
|
});
|
|
// ReplaceOne with upsert when no documents match with an id specified, no write concern
|
|
replaceOneExecutor({
|
|
insert: [{ _id: 1, x: 11 }, { _id: 2, x: 22 }, { _id:3, x:33 }],
|
|
params: [{ _id: 4 }, { _id: 4, x: 1 }, {upsert:true, w:0}],
|
|
result: {acknowledged:false},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}, {_id:4, x: 1}]
|
|
});
|
|
// ReplaceOne with upsert when no documents match with an id specified, no write concern
|
|
replaceOneExecutor({
|
|
insert: [{ _id: 1, x: 11 }, { _id: 2, x: 22 }, { _id:3, x:33 }],
|
|
params: [{ _id: 4 }, { _id: 4, x: 1 }, {upsert:true, writeConcern:{w:0}}],
|
|
result: {acknowledged:false},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}, {_id:4, x: 1}]
|
|
});
|
|
|
|
assert.throws(function() {
|
|
coll.replaceOne({a:1}, {$set:{b:1}});
|
|
});
|
|
|
|
//
|
|
// UpdateMany
|
|
//
|
|
|
|
// UpdateMany when many documents match
|
|
updateManyExecutor({
|
|
insert: [{ _id: 1, x: 11 }, { _id: 2, x: 22 }, { _id:3, x:33 }],
|
|
params: [{ _id: { $gt: 1 } }, { $inc: { x: 1 } }],
|
|
result: {acknowledged:true, matchedCount:2, modifiedCount:2},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 23}, {_id:3, x: 34}]
|
|
});
|
|
// UpdateMany when one document matches
|
|
updateManyExecutor({
|
|
insert: [{ _id: 1, x: 11 }, { _id: 2, x: 22 }, { _id:3, x:33 }],
|
|
params: [{ _id: 1 }, { $inc: { x: 1 } }],
|
|
result: {acknowledged:true, matchedCount:1, modifiedCount:1},
|
|
expected: [{_id:1, x: 12}, {_id:2, x: 22}, {_id:3, x: 33}]
|
|
});
|
|
// UpdateMany when no documents match
|
|
updateManyExecutor({
|
|
insert: [{ _id: 1, x: 11 }, { _id: 2, x: 22 }, { _id:3, x:33 }],
|
|
params: [{ _id: 4 }, { $inc: { x: 1 } }],
|
|
result: {acknowledged:true, matchedCount:0, modifiedCount:0},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}]
|
|
});
|
|
// UpdateMany with upsert when no documents match
|
|
updateManyExecutor({
|
|
insert: [{ _id: 1, x: 11 }, { _id: 2, x: 22 }, { _id:3, x:33 }],
|
|
params: [{ _id: 4 }, { $inc: { x: 1 } }, { upsert: true }],
|
|
result: {acknowledged:true, matchedCount:0, modifiedCount:0, upsertedId: 4},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}, {_id:4, x: 1}]
|
|
});
|
|
// UpdateMany with upsert when no documents match, no write concern
|
|
updateManyExecutor({
|
|
insert: [{ _id: 1, x: 11 }, { _id: 2, x: 22 }, { _id:3, x:33 }],
|
|
params: [{ _id: 4 }, { $inc: { x: 1 } }, { upsert: true, w: 0 }],
|
|
result: {acknowledged:false},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}, {_id:4, x: 1}]
|
|
});
|
|
|
|
assert.throws(function() {
|
|
coll.updateMany({a:1}, {});
|
|
});
|
|
|
|
assert.throws(function() {
|
|
coll.updateMany({a:1}, {b:1});
|
|
});
|
|
|
|
//
|
|
// UpdateOne
|
|
//
|
|
|
|
// UpdateOne when many documents match
|
|
updateOneExecutor({
|
|
insert: [{ _id: 1, x: 11 }, { _id: 2, x: 22 }, { _id:3, x:33 }],
|
|
params: [{ _id: { $gt: 1 } }, { $inc: { x: 1 } }],
|
|
result: {acknowledged:true, matchedCount:1, modifiedCount:1},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 23}, {_id:3, x: 33}]
|
|
});
|
|
// UpdateOne when one document matches
|
|
updateOneExecutor({
|
|
insert: [{ _id: 1, x: 11 }, { _id: 2, x: 22 }, { _id:3, x:33 }],
|
|
params: [{ _id: 1 }, { $inc: { x: 1 } }],
|
|
result: {acknowledged:true, matchedCount:1, modifiedCount:1},
|
|
expected: [{_id:1, x: 12}, {_id:2, x: 22}, {_id:3, x: 33}]
|
|
});
|
|
// UpdateOne when no documents match
|
|
updateOneExecutor({
|
|
insert: [{ _id: 1, x: 11 }, { _id: 2, x: 22 }, { _id:3, x:33 }],
|
|
params: [{ _id: 4 }, { $inc: { x: 1 } }],
|
|
result: {acknowledged:true, matchedCount:0, modifiedCount:0},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}]
|
|
});
|
|
|
|
// UpdateOne with upsert when no documents match
|
|
updateOneExecutor({
|
|
insert: [{ _id: 1, x: 11 }, { _id: 2, x: 22 }, { _id:3, x:33 }],
|
|
params: [{ _id: 4 }, { $inc: { x: 1 } }, {upsert:true}],
|
|
result: {acknowledged:true, matchedCount:0, modifiedCount:0, upsertedId: 4},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 22}, {_id:3, x: 33}, {_id: 4, x: 1}]
|
|
});
|
|
// UpdateOne when many documents match, no write concern
|
|
updateOneExecutor({
|
|
insert: [{ _id: 1, x: 11 }, { _id: 2, x: 22 }, { _id:3, x:33 }],
|
|
params: [{ _id: { $gt: 1 } }, { $inc: { x: 1 } }, {w:0}],
|
|
result: {acknowledged:false},
|
|
expected: [{_id:1, x: 11}, {_id:2, x: 23}, {_id:3, x: 33}]
|
|
});
|
|
|
|
assert.throws(function() {
|
|
coll.updateOne({a:1}, {});
|
|
});
|
|
|
|
assert.throws(function() {
|
|
coll.updateOne({a:1}, {b:1});
|
|
});
|
|
|
|
//
|
|
// Count
|
|
//
|
|
|
|
// Simple count of all elements
|
|
countExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [{}],
|
|
result: 3,
|
|
expected: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }]
|
|
});
|
|
// Simple count no arguments
|
|
countExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [],
|
|
result: 3,
|
|
expected: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }]
|
|
});
|
|
// Simple count filtered
|
|
countExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [{_id: {$gt: 1}}],
|
|
result: 2,
|
|
expected: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }]
|
|
});
|
|
// Simple count of all elements, applying limit
|
|
countExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [{}, {limit:1}],
|
|
result: 1,
|
|
expected: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }]
|
|
});
|
|
// Simple count of all elements, applying skip
|
|
countExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [{}, {skip:1}],
|
|
result: 2,
|
|
expected: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }]
|
|
});
|
|
// Simple count no arguments, applying hint
|
|
countExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: [{}, {hint: { "_id": 1}}],
|
|
result: 3,
|
|
expected: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }]
|
|
});
|
|
|
|
//
|
|
// Distinct
|
|
//
|
|
|
|
// Simple distinct of field x no filter
|
|
distinctExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: ['x'],
|
|
result: [11, 22, 33],
|
|
expected: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }]
|
|
});
|
|
// Simple distinct of field x
|
|
distinctExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: ['x', {}],
|
|
result: [11, 22, 33],
|
|
expected: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }]
|
|
});
|
|
// Simple distinct of field x filtered
|
|
distinctExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: ['x', {x: { $gt: 11 }}],
|
|
result: [22, 33],
|
|
expected: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }]
|
|
});
|
|
// Simple distinct of field x filtered with maxTimeMS
|
|
distinctExecutor({
|
|
insert: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }],
|
|
params: ['x', {x: { $gt: 11 }}, {maxTimeMS:100000}],
|
|
result: [22, 33],
|
|
expected: [{ _id: 1, x:11 }, { _id: 2, x:22 }, { _id: 3, x:33 }]
|
|
});
|
|
|
|
//
|
|
// Find
|
|
//
|
|
|
|
coll.deleteMany({});
|
|
// Insert all of them
|
|
coll.insertMany([{a:0, b:0}, {a:1, b:1}]);
|
|
|
|
// Simple projection
|
|
var result = coll.find({}).sort({a:1}).limit(1).skip(1).projection({_id:0, a:1}).toArray();
|
|
assert.docEq(result, [{a:1}]);
|
|
|
|
// Simple tailable cursor
|
|
var cursor = coll.find({}).sort({a:1}).tailable();
|
|
assert.eq(34, (cursor._options & ~DBQuery.Option.slaveOk));
|
|
var cursor = coll.find({}).sort({a:1}).tailable(false);
|
|
assert.eq(2, (cursor._options & ~DBQuery.Option.slaveOk));
|
|
|
|
// Check modifiers
|
|
var cursor = coll.find({}).modifiers({$hint:'a_1'});
|
|
assert.eq('a_1', cursor._query['$hint']);
|
|
|
|
// allowPartialResults
|
|
var cursor = coll.find({}).allowPartialResults();
|
|
assert.eq(128, (cursor._options & ~DBQuery.Option.slaveOk));
|
|
|
|
// noCursorTimeout
|
|
var cursor = coll.find({}).noCursorTimeout();
|
|
assert.eq(16, (cursor._options & ~DBQuery.Option.slaveOk));
|
|
|
|
// oplogReplay
|
|
var cursor = coll.find({}).oplogReplay();
|
|
assert.eq(8, (cursor._options & ~DBQuery.Option.slaveOk));
|
|
|
|
//
|
|
// Aggregation
|
|
//
|
|
|
|
coll.deleteMany({});
|
|
// Insert all of them
|
|
coll.insertMany([{a:0, b:0}, {a:1, b:1}]);
|
|
|
|
// Simple aggregation with useCursor
|
|
var result = coll.aggregate([{$match: {}}], {useCursor:true}).toArray();
|
|
assert.eq(2, result.length);
|
|
|
|
// Simple aggregation with batchSize
|
|
var result = coll.aggregate([{$match: {}}], {batchSize:2}).toArray();
|
|
assert.eq(2, result.length);
|
|
|
|
// Drop collection
|
|
coll.drop();
|
|
coll.ensureIndex({a:1}, {unique:true})
|
|
|
|
// Should throw duplicate key error
|
|
assert.throws(function() {
|
|
coll.insertMany([{a:0, b:0}, {a:0, b:1}])
|
|
});
|
|
|
|
assert(coll.findOne({a:0, b:0}) != null);
|
|
assert.throws(function() {
|
|
coll.insertOne({a:0, b:0})
|
|
});
|
|
|
|
assert.throws(function() {
|
|
coll.updateOne({b:2}, {$set: {a:0}}, {upsert:true});
|
|
});
|
|
|
|
assert.throws(function() {
|
|
coll.updateMany({b:2}, {$set: {a:0}}, {upsert:true});
|
|
});
|
|
|
|
assert.throws(function() {
|
|
coll.deleteOne({$invalidFieldName:{a:1}});
|
|
});
|
|
|
|
assert.throws(function() {
|
|
coll.deleteMany({$set:{a:1}});
|
|
});
|
|
|
|
assert.throws(function() {
|
|
coll.bulkWrite([
|
|
{ insertOne: { document: { _id: 4, a: 0 } } }
|
|
]);
|
|
});
|
|
}
|
|
|
|
crudAPISpecTests();
|
|
})();
|