deno.land / x / mongoose@6.7.5 / test / model.findOneAndReplace.test.js
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437'use strict';
/** * Test dependencies. */
const start = require('./common');
const assert = require('assert');
const mongoose = start.mongoose;const Schema = mongoose.Schema;const ObjectId = Schema.Types.ObjectId;const DocumentObjectId = mongoose.Types.ObjectId;
describe('model: findOneAndReplace:', function() { let Comments; let BlogPost; let db;
before(function() { db = start(); });
after(async function() { await db.close(); });
beforeEach(() => db.deleteModel(/.*/)); afterEach(() => require('./util').clearTestData(db)); afterEach(() => require('./util').stopRemainingOps(db));
beforeEach(function() { Comments = new Schema();
Comments.add({ title: String, date: Date, body: String, comments: [Comments] });
BlogPost = new Schema({ title: String, author: String, slug: String, date: Date, meta: { date: Date, visitors: Number }, published: Boolean, mixed: {}, numbers: [Number], owners: [ObjectId], comments: [Comments] });
BlogPost.virtual('titleWithAuthor') .get(function() { return this.get('title') + ' by ' + this.get('author'); }) .set(function(val) { const split = val.split(' by '); this.set('title', split[0]); this.set('author', split[1]); });
BlogPost.method('cool', function() { return this; });
BlogPost.static('woot', function() { return this; });
BlogPost = db.model('BlogPost', BlogPost); });
it('returns the original document', async function() { const M = BlogPost; const title = 'remove muah';
const post = new M({ title: title });
await post.save();
const doc = await M.findOneAndReplace({ title: title });
assert.equal(post.id, doc.id); });
it('options/conditions/doc are merged when no callback is passed', function() { const M = BlogPost;
const now = new Date(); let query;
// Model.findOneAndReplace query = M.findOneAndReplace({ author: 'aaron' }, {}, { select: 'author' }); assert.equal(query._fields.author, 1); assert.equal(query._conditions.author, 'aaron');
query = M.findOneAndReplace({ author: 'aaron' }); assert.equal(query._fields, undefined); assert.equal(query._conditions.author, 'aaron');
query = M.findOneAndReplace(); assert.equal(query.options.new, undefined); assert.equal(query._fields, undefined); assert.equal(query._conditions.author, undefined);
// Query.findOneAndReplace query = M.where('author', 'aaron').findOneAndReplace({ date: now }); assert.equal(query._fields, undefined); assert.equal(query._conditions.date, now); assert.equal(query._conditions.author, 'aaron');
query = M.find().findOneAndReplace({ author: 'aaron' }, {}, { select: 'author' }); assert.equal(query._fields.author, 1); assert.equal(query._conditions.author, 'aaron');
query = M.find().findOneAndReplace(); assert.equal(query._fields, undefined); assert.equal(query._conditions.author, undefined); });
it('executes when a callback is passed', function(done) { const M = BlogPost; let pending = 5;
M.findOneAndReplace({ name: 'aaron1' }, { select: 'name' }, cb); M.findOneAndReplace({ name: 'aaron1' }, cb); M.where().findOneAndReplace({ name: 'aaron1' }, { select: 'name' }, cb); M.where().findOneAndReplace({ name: 'aaron1' }, cb); M.where('name', 'aaron1').findOneAndReplace(cb);
function cb(err, doc) { assert.ifError(err); assert.equal(doc, null); // no previously existing doc if (--pending) { return; } done(); } });
it('executed with only a callback throws', function() { const M = BlogPost; let err;
try { M.findOneAndReplace(function() {}); } catch (e) { err = e; }
assert.ok(/First argument must not be a function/.test(err)); });
it('executed with only a callback throws', function() { const M = BlogPost; let err;
try { M.findByIdAndDelete(function() {}); } catch (e) { err = e; }
assert.ok(/First argument must not be a function/.test(err)); });
it('executes when a callback is passed', function(done) { const M = BlogPost; const _id = new DocumentObjectId(); let pending = 2;
M.findByIdAndDelete(_id, { select: 'name' }, cb); M.findByIdAndDelete(_id, cb);
function cb(err, doc) { assert.ifError(err); assert.equal(doc, null); // no previously existing doc if (--pending) return; done(); } });
it('returns the original document', async function() { const M = BlogPost; const title = 'remove muah pleez';
const post = await M.create({ title: title }); await post.save();
const doc = await M.findByIdAndDelete(post.id); assert.equal(post.id, doc.id);
const gone = await M.findById(post.id); assert.equal(gone, null); });
it('options/conditions/doc are merged when no callback is passed', function() { const M = BlogPost; const _id = new DocumentObjectId();
let query;
// Model.findByIdAndDelete query = M.findByIdAndDelete(_id, { select: 'author' }); assert.equal(query._fields.author, 1); assert.equal(query._conditions._id.toString(), _id.toString());
query = M.findByIdAndDelete(_id.toString()); assert.equal(query._fields, undefined); assert.equal(query._conditions._id, _id.toString());
query = M.findByIdAndDelete(); assert.equal(query.options.new, undefined); assert.equal(query._fields, undefined); assert.equal(query._conditions._id, undefined); });
it('supports v3 select string syntax', function() { const M = BlogPost;
const query = M.findOneAndReplace({}, {}, { select: 'author -title' }); assert.strictEqual(1, query._fields.author); assert.strictEqual(0, query._fields.title); });
it('supports v3 select object syntax', function() { const M = BlogPost;
const query = M.findOneAndReplace({}, {}, { select: { author: 1, title: 0 } }); assert.strictEqual(1, query._fields.author); assert.strictEqual(0, query._fields.title); });
it('supports v3 sort string syntax', function() { const M = BlogPost;
const query = M.findOneAndReplace({}, {}, { sort: 'author -title' }); assert.equal(Object.keys(query.options.sort).length, 2); assert.equal(query.options.sort.author, 1); assert.equal(query.options.sort.title, -1); });
it('supports v3 sort object syntax', function() { const M = BlogPost;
const query = M.findOneAndReplace({}, {}, { sort: { author: 1, title: -1 } }); assert.equal(Object.keys(query.options.sort).length, 2); assert.equal(query.options.sort.author, 1); assert.equal(query.options.sort.title, -1); });
it('supports population (gh-1395)', async function() { const M = db.model('Test1', { name: String }); const N = db.model('Test2', { a: { type: Schema.ObjectId, ref: 'Test1' }, i: Number });
const a = await M.create({ name: 'i am an A' });
const b = await N.create({ a: a._id, i: 10 });
const doc = await N.findOneAndReplace({ _id: b._id }, { a: a._id }) .populate('a') .exec();
assert.ok(doc); assert.ok(doc.a); assert.equal(doc.a.name, 'i am an A'); });
it('only calls setters once (gh-6203)', async function() {
const calls = []; const userSchema = new mongoose.Schema({ name: String, foo: { type: String, set: function(val) { calls.push(val); return val + val; } } }); const Model = db.model('Test', userSchema);
await Model.findOneAndReplace({ foo: '123' }, { name: 'bar' });
assert.deepEqual(calls, ['123']); });
describe('middleware', function() { it('works', async function() { const s = new Schema({ topping: { type: String, default: 'bacon' }, base: String });
let preCount = 0; s.pre('findOneAndReplace', function() { ++preCount; });
let postCount = 0; s.post('findOneAndReplace', function() { ++postCount; });
const Breakfast = db.model('Test', s); await Breakfast.create({ base: 'eggs' });
const breakfast = await Breakfast.findOneAndReplace({ base: 'eggs' }, {}); assert.equal(breakfast.base, 'eggs'); assert.equal(preCount, 1); assert.equal(postCount, 1); });
it('works with exec() (gh-439)', async function() { const s = new Schema({ topping: { type: String, default: 'bacon' }, base: String });
let preCount = 0; s.pre('findOneAndReplace', function() { ++preCount; });
let postCount = 0; s.post('findOneAndReplace', function() { ++postCount; });
const Breakfast = db.model('Test', s); const breakfast = new Breakfast({ base: 'eggs' });
await breakfast.save();
const updatedBreakfast = await Breakfast.findOneAndReplace({ base: 'eggs' }, {}).exec();
assert.equal(updatedBreakfast.base, 'eggs'); assert.equal(preCount, 1); assert.equal(postCount, 1); }); });
it('works (gh-7654)', async function() { const schema = new Schema({ name: String, age: Number }); const Model = db.model('Test', schema);
await Model.findOneAndReplace({}, { name: 'Jean-Luc Picard', age: 59 }, { upsert: true });
const doc = await Model.findOne(); assert.equal(doc.name, 'Jean-Luc Picard');
const err = await Model.findOneAndReplace({}, { age: 'not a number' }, {}). then(() => null, err => err); assert.ok(err); assert.ok(err.errors['age'].message.indexOf('not a number') !== -1, err.errors['age'].message); });
it('schema-level projection (gh-7654)', async function() { const schema = new Schema({ name: String, age: { type: Number, select: false } }); const Model = db.model('Test', schema);
const doc = await Model.findOneAndReplace({}, { name: 'Jean-Luc Picard', age: 59 }, { upsert: true, returnOriginal: false });
assert.ok(!doc.age); });
it('supports `new` in addition to `returnOriginal` (gh-7846)', async function() { const schema = new Schema({ name: String, age: Number }); const Model = db.model('Test', schema);
const doc = await Model.findOneAndReplace({}, { name: 'Jean-Luc Picard', age: 59 }, { upsert: true, new: true });
assert.equal(doc.age, 59); });
it('orFail() (gh-8030)', async function() { const schema = Schema({ name: String, age: Number }); const Model = db.model('Test', schema);
let err = await Model.findOneAndReplace({}, { name: 'test' }).orFail(). then(() => assert.ok(false), err => err);
assert.ok(err); assert.equal(err.name, 'DocumentNotFoundError');
await Model.create({ name: 'test' }); err = await Model.findOneAndReplace({ name: 'test' }, { name: 'test2' }). orFail(). then(() => null, err => err);
assert.ifError(err); });
it('skips validation if `runValidators` === false (gh-11559)', async function() { const testSchema = new Schema({ name: { type: String, required: true // you had a typo here } }); const Test = db.model('Test', testSchema); const entry = await Test.create({ name: 'Test' });
await Test.findOneAndReplace( { name: 'Test' }, {}, // this part is key, I am trying to replace without required fields { runValidators: false } );
const doc = await Test.findById(entry); assert.strictEqual(doc.name, undefined); });});
Version Info