123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398
'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: findOneAndDelete:', 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.findOneAndDelete({ title: title });
    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 now = new Date();    let query;
    // Model.findOneAndDelete    query = M.findOneAndDelete({ author: 'aaron' }, { select: 'author' });    assert.equal(query._fields.author, 1);    assert.equal(query._conditions.author, 'aaron');
    query = M.findOneAndDelete({ author: 'aaron' });    assert.equal(query._fields, undefined);    assert.equal(query._conditions.author, 'aaron');
    query = M.findOneAndDelete();    assert.equal(query.options.new, undefined);    assert.equal(query._fields, undefined);    assert.equal(query._conditions.author, undefined);
    // Query.findOneAndDelete    query = M.where('author', 'aaron').findOneAndDelete({ date: now });    assert.equal(query._fields, undefined);    assert.equal(query._conditions.date, now);    assert.equal(query._conditions.author, 'aaron');
    query = M.find().findOneAndDelete({ author: 'aaron' }, { select: 'author' });    assert.equal(query._fields.author, 1);    assert.equal(query._conditions.author, 'aaron');
    query = M.find().findOneAndDelete();    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.findOneAndDelete({ name: 'aaron1' }, { select: 'name' }, cb);    M.findOneAndDelete({ name: 'aaron1' }, cb);    M.where().findOneAndDelete({ name: 'aaron1' }, { select: 'name' }, cb);    M.where().findOneAndDelete({ name: 'aaron1' }, cb);    M.where('name', 'aaron1').findOneAndDelete(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.findOneAndDelete(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 = new M({ 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 _id = new DocumentObjectId();
    let query;
    query = M.findByIdAndDelete(_id, { select: 'author -title' });    assert.strictEqual(1, query._fields.author);    assert.strictEqual(0, query._fields.title);
    query = M.findOneAndDelete({}, { 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 _id = new DocumentObjectId();
    let query;
    query = M.findByIdAndDelete(_id, { select: { author: 1, title: 0 } });    assert.strictEqual(1, query._fields.author);    assert.strictEqual(0, query._fields.title);
    query = M.findOneAndDelete({}, { 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 _id = new DocumentObjectId();
    let query;
    query = M.findByIdAndDelete(_id, { 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);
    query = M.findOneAndDelete({}, { 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 _id = new DocumentObjectId();
    let query;
    query = M.findByIdAndDelete(_id, { 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);
    query = M.findOneAndDelete(_id, { 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.findOneAndDelete({ _id: b._id }, { select: 'a -_id' })      .populate('a')      .exec();
    assert.ok(doc);    assert.equal(doc._id, undefined);    assert.ok(doc.a);    assert.equal('i am an A', doc.a.name);  });
  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.findOneAndDelete({ 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('findOneAndDelete', function() {        ++preCount;      });
      let postCount = 0;      s.post('findOneAndDelete', function() {        ++postCount;      });
      const Breakfast = db.model('Test', s);      const breakfast = new Breakfast({        base: 'eggs'      });
      await breakfast.save();

      const deletedBreakfast = await Breakfast.findOneAndDelete(        { base: 'eggs' },        {}      );
      assert.equal(deletedBreakfast.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('findOneAndDelete', function() {        ++preCount;      });
      let postCount = 0;      s.post('findOneAndDelete', function() {        ++postCount;      });
      const Breakfast = db.model('Test', s);      const breakfast = new Breakfast({        base: 'eggs'      });
      await breakfast.save();

      const updatedBreakfast = await Breakfast.        findOneAndDelete({ base: 'eggs' }, {}).        exec();
      assert.equal(updatedBreakfast.base, 'eggs');      assert.equal(preCount, 1);      assert.equal(postCount, 1);    });  });});