ok

1 files changed, 526 insertions, 0 deletions

diff --git a/node_modules/mongoose/test/model.update.test.js b/node_modules/mongoose/test/model.update.test.js
new file mode 100644
index 0000000..8e795d5
--- /dev/null
+++ b/node_modules/mongoose/test/model.update.test.js
@@ -0,0 +1,526 @@
+
+/**
+ * Test dependencies.
+ */
+
+var start = require('./common')
+  , should = require('should')
+  , mongoose = start.mongoose
+  , random = require('../lib/utils').random
+  , Query = require('../lib/query')
+  , Schema = mongoose.Schema
+  , SchemaType = mongoose.SchemaType
+  , CastError = SchemaType.CastError
+  , ValidatorError = SchemaType.ValidatorError
+  , ValidationError = mongoose.Document.ValidationError
+  , ObjectId = Schema.ObjectId
+  , DocumentObjectId = mongoose.Types.ObjectId
+  , DocumentArray = mongoose.Types.DocumentArray
+  , EmbeddedDocument = mongoose.Types.Embedded
+  , MongooseNumber = mongoose.Types.Number
+  , MongooseArray = mongoose.Types.Array
+  , MongooseError = mongoose.Error;
+
+/**
+ * Setup.
+ */
+
+var Comments = new Schema();
+
+Comments.add({
+    title     : String
+  , date      : Date
+  , body      : String
+  , comments  : [Comments]
+});
+
+var 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) {
+    var 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;
+});
+
+mongoose.model('BlogPost', BlogPost);
+
+var collection = 'blogposts_' + random();
+
+var strictSchema = new Schema({ name: String }, { strict: true });
+mongoose.model('UpdateStrictSchema', strictSchema);
+
+module.exports = {
+
+  'test updating documents': function () {
+    var db = start()
+      , BlogPost = db.model('BlogPost', collection)
+      , title = 'Tobi ' + random()
+      , author = 'Brian ' + random()
+      , newTitle = 'Woot ' + random()
+      , id0 = new DocumentObjectId
+      , id1 = new DocumentObjectId
+
+    var post = new BlogPost();
+    post.set('title', title);
+    post.author = author;
+    post.meta.visitors = 0;
+    post.date = new Date;
+    post.published = true;
+    post.mixed = { x: 'ex' };
+    post.numbers = [4,5,6,7];
+    post.owners = [id0, id1];
+    post.comments = [{ body: 'been there' }, { body: 'done that' }];
+
+    post.save(function (err) {
+      should.strictEqual(err, null);
+      BlogPost.findById(post._id, function (err, cf) {
+        should.strictEqual(err, null);
+        cf.title.should.equal(title);
+        cf.author.should.equal(author);
+        cf.meta.visitors.valueOf().should.eql(0);
+        cf.date.should.eql(post.date);
+        cf.published.should.be.true;
+        cf.mixed.x.should.equal('ex');
+        cf.numbers.toObject().should.eql([4,5,6,7]);
+        cf.owners.length.should.equal(2);
+        cf.owners[0].toString().should.equal(id0.toString());
+        cf.owners[1].toString().should.equal(id1.toString());
+        cf.comments.length.should.equal(2);
+        cf.comments[0].body.should.eql('been there');
+        cf.comments[1].body.should.eql('done that');
+        should.exist(cf.comments[0]._id);
+        should.exist(cf.comments[1]._id);
+        cf.comments[0]._id.should.be.an.instanceof(DocumentObjectId)
+        cf.comments[1]._id.should.be.an.instanceof(DocumentObjectId);
+
+        var update = {
+            title: newTitle // becomes $set
+          , $inc: { 'meta.visitors': 2 }
+          , $set: { date: new Date }
+          , published: false // becomes $set
+          , 'mixed': { x: 'ECKS', y: 'why' } // $set
+          , $pullAll: { 'numbers': [4, 6] }
+          , $pull: { 'owners': id0 }
+          , 'comments.1.body': 8 // $set
+        }
+
+        BlogPost.update({ title: title }, update, function (err) {
+          should.strictEqual(err, null);
+
+          BlogPost.findById(post._id, function (err, up) {
+            should.strictEqual(err, null);
+            up.title.should.equal(newTitle);
+            up.author.should.equal(author);
+            up.meta.visitors.valueOf().should.equal(2);
+            up.date.toString().should.equal(update.$set.date.toString());
+            up.published.should.eql(false);
+            up.mixed.x.should.equal('ECKS');
+            up.mixed.y.should.equal('why');
+            up.numbers.toObject().should.eql([5,7]);
+            up.owners.length.should.equal(1);
+            up.owners[0].toString().should.eql(id1.toString());
+            up.comments[0].body.should.equal('been there');
+            up.comments[1].body.should.equal('8');
+            should.exist(up.comments[0]._id);
+            should.exist(up.comments[1]._id);
+            up.comments[0]._id.should.be.an.instanceof(DocumentObjectId)
+            up.comments[1]._id.should.be.an.instanceof(DocumentObjectId);
+
+            var update2 = {
+                'comments.body': 'fail'
+            }
+
+            BlogPost.update({ _id: post._id }, update2, function (err) {
+              should.strictEqual(!!err, true);
+              ;/^can't append to array using string field name \[body\]/.test(err.message).should.be.true;
+              BlogPost.findById(post, function (err, p) {
+                should.strictEqual(null, err);
+
+                var update3 = {
+                    $pull: 'fail'
+                }
+
+                BlogPost.update({ _id: post._id }, update3, function (err) {
+                  should.strictEqual(!!err, true);
+                  ;/Invalid atomic update value/.test(err.message).should.be.true;
+
+                  var update4 = {
+                      $inc: { idontexist: 1 }
+                  }
+
+                  // should not overwrite doc when no valid paths are submitted
+                  BlogPost.update({ _id: post._id }, update4, function (err) {
+                    should.strictEqual(err, null);
+
+                    BlogPost.findById(post._id, function (err, up) {
+                      should.strictEqual(err, null);
+
+                      up.title.should.equal(newTitle);
+                      up.author.should.equal(author);
+                      up.meta.visitors.valueOf().should.equal(2);
+                      up.date.toString().should.equal(update.$set.date.toString());
+                      up.published.should.eql(false);
+                      up.mixed.x.should.equal('ECKS');
+                      up.mixed.y.should.equal('why');
+                      up.numbers.toObject().should.eql([5,7]);
+                      up.owners.length.should.equal(1);
+                      up.owners[0].toString().should.eql(id1.toString());
+                      up.comments[0].body.should.equal('been there');
+                      up.comments[1].body.should.equal('8');
+                      // non-schema data was still stored in mongodb
+                      should.strictEqual(1, up._doc.idontexist);
+
+                      update5(post);
+                    });
+                  });
+                });
+              });
+            });
+          });
+        });
+      });
+    });
+
+    function update5 (post) {
+      var update = {
+          comments: [{ body: 'worked great' }]
+        , $set: {'numbers.1': 100}
+        , $inc: { idontexist: 1 }
+      }
+
+      BlogPost.update({ _id: post._id }, update, function (err) {
+        should.strictEqual(err, null);
+
+        // get the underlying doc
+        BlogPost.collection.findOne({ _id: post._id }, function (err, doc) {
+          should.strictEqual(err, null);
+
+          var up = new BlogPost;
+          up.init(doc);
+          up.comments.length.should.equal(1);
+          up.comments[0].body.should.equal('worked great');
+          should.strictEqual(true, !! doc.comments[0]._id);
+          up.meta.visitors.valueOf().should.equal(2);
+          up.mixed.x.should.equal('ECKS');
+          up.numbers.toObject().should.eql([5,100]);
+          up.numbers[1].valueOf().should.eql(100);
+
+          doc.idontexist.should.equal(2);
+          doc.numbers[1].should.eql(100);
+
+          update6(post);
+        });
+      });
+    }
+
+    function update6 (post) {
+      var update = {
+          $pushAll: { comments: [{ body: 'i am number 2' }, { body: 'i am number 3' }] }
+      }
+
+      BlogPost.update({ _id: post._id }, update, function (err) {
+        should.strictEqual(null, err);
+        BlogPost.findById(post, function (err, ret) {
+          should.strictEqual(null, err);
+          ret.comments.length.should.equal(3);
+          ret.comments[1].body.should.equal('i am number 2');
+          should.strictEqual(true, !! ret.comments[1]._id);
+          ret.comments[1]._id.should.be.an.instanceof(DocumentObjectId)
+          ret.comments[2].body.should.equal('i am number 3');
+          should.strictEqual(true, !! ret.comments[2]._id);
+          ret.comments[2]._id.should.be.an.instanceof(DocumentObjectId)
+
+          update7(post);
+        })
+      });
+    }
+
+    // gh-542
+    function update7 (post) {
+      var update = {
+          $pull: { comments: { body: 'i am number 2' } }
+      }
+
+      BlogPost.update({ _id: post._id }, update, function (err) {
+        should.strictEqual(null, err);
+        BlogPost.findById(post, function (err, ret) {
+          should.strictEqual(null, err);
+          ret.comments.length.should.equal(2);
+          ret.comments[0].body.should.equal('worked great');
+          ret.comments[0]._id.should.be.an.instanceof(DocumentObjectId)
+          ret.comments[1].body.should.equal('i am number 3');
+          ret.comments[1]._id.should.be.an.instanceof(DocumentObjectId)
+
+          update8(post);
+        })
+      });
+    }
+
+    // gh-479
+    function update8 (post) {
+      function a () {};
+      a.prototype.toString = function () { return 'MongoDB++' }
+      var crazy = new a;
+
+      var update = {
+          $addToSet: { 'comments.$.comments': { body: 'The Ring Of Power' } }
+        , $set: { 'comments.$.title': crazy }
+      }
+
+      BlogPost.update({ _id: post._id, 'comments.body': 'worked great' }, update, function (err) {
+        should.strictEqual(null, err);
+        BlogPost.findById(post, function (err, ret) {
+          should.strictEqual(null, err);
+          ret.comments.length.should.equal(2);
+          ret.comments[0].body.should.equal('worked great');
+          ret.comments[0].title.should.equal('MongoDB++');
+          should.strictEqual(true, !! ret.comments[0].comments);
+          ret.comments[0].comments.length.should.equal(1);
+          should.strictEqual(ret.comments[0].comments[0].body, 'The Ring Of Power');
+          ret.comments[0]._id.should.be.an.instanceof(DocumentObjectId)
+          ret.comments[0].comments[0]._id.should.be.an.instanceof(DocumentObjectId)
+          ret.comments[1].body.should.equal('i am number 3');
+          should.strictEqual(undefined, ret.comments[1].title);
+          ret.comments[1]._id.should.be.an.instanceof(DocumentObjectId)
+
+          update9(post);
+        })
+      });
+    }
+
+    // gh-479
+    function update9 (post) {
+      var update = {
+          $inc: { 'comments.$.newprop': '1' }
+        , $set: { date: (new Date).getTime() } // check for single val casting
+      }
+
+      BlogPost.update({ _id: post._id, 'comments.body': 'worked great' }, update, function (err) {
+        should.strictEqual(null, err);
+        BlogPost.findById(post, function (err, ret) {
+          should.strictEqual(null, err);
+          ret._doc.comments[0]._doc.newprop.should.equal(1);
+          should.strictEqual(undefined, ret._doc.comments[1]._doc.newprop);
+          ret.date.should.be.an.instanceof(Date);
+          ret.date.toString().should.equal(update.$set.date.toString());
+
+          update10(post, ret);
+        })
+      });
+    }
+
+    // gh-545
+    function update10 (post, last) {
+      var owner = last.owners[0];
+
+      var update = {
+          $addToSet: { 'owners': owner }
+      }
+
+      BlogPost.update({ _id: post._id }, update, function (err) {
+        should.strictEqual(null, err);
+        BlogPost.findById(post, function (err, ret) {
+          should.strictEqual(null, err);
+          ret.owners.length.should.equal(1);
+          ret.owners[0].toString().should.eql(owner.toString());
+
+          update11(post, ret);
+        })
+      });
+    }
+
+    // gh-545
+    function update11 (post, last) {
+      var owner = last.owners[0]
+        , newowner = new DocumentObjectId
+
+      var update = {
+          $addToSet: { 'owners': { $each: [owner, newowner] }}
+      }
+
+      BlogPost.update({ _id: post._id }, update, function (err) {
+        should.strictEqual(null, err);
+        BlogPost.findById(post, function (err, ret) {
+          should.strictEqual(null, err);
+          ret.owners.length.should.equal(2);
+          ret.owners[0].toString().should.eql(owner.toString());
+          ret.owners[1].toString().should.eql(newowner.toString());
+
+          update12(post, newowner);
+        })
+      });
+    }
+
+    // gh-574
+    function update12 (post, newowner) {
+      var update = {
+          $pop: { 'owners': -1 }
+        , $unset: { title: 1 }
+      }
+
+      BlogPost.update({ _id: post._id }, update, function (err) {
+        should.strictEqual(null, err);
+        BlogPost.findById(post, function (err, ret) {
+          should.strictEqual(null, err);
+          ret.owners.length.should.equal(1);
+          ret.owners[0].toString().should.eql(newowner.toString());
+          should.strictEqual(undefined, ret.title);
+
+          update13(post, ret);
+        })
+      });
+    }
+
+    function update13 (post, ret) {
+      var update = {
+          $set: {
+              'comments.0.comments.0.date': '11/5/2011'
+            , 'comments.1.body': 9000
+          }
+      }
+
+      BlogPost.update({ _id: post._id }, update, function (err) {
+        should.strictEqual(null, err);
+        BlogPost.findById(post, function (err, ret) {
+          should.strictEqual(null, err);
+          ret.comments.length.should.equal(2);
+          ret.comments[0].body.should.equal('worked great');
+          ret.comments[1].body.should.equal('9000');
+          ret.comments[0].comments[0].date.toString().should.equal(new Date('11/5/2011').toString())
+          ret.comments[1].comments.length.should.equal(0);
+
+          update14(post, ret);
+        })
+      });
+    }
+
+    // gh-542
+    function update14 (post, ret) {
+      var update = {
+          $pull: { comments: { _id: ret.comments[0].id } }
+      }
+
+      BlogPost.update({ _id: post._id }, update, function (err) {
+        should.strictEqual(null, err);
+        BlogPost.findById(post, function (err, ret) {
+          should.strictEqual(null, err);
+          ret.comments.length.should.equal(1);
+          ret.comments[0].body.should.equal('9000');
+          update15(post, ret);
+        })
+      });
+    }
+
+    function update15 (post, ret) {
+      var update = {
+          $pull: { comments: { body: { $in: [ret.comments[0].body] }} }
+      }
+
+      BlogPost.update({ _id: post._id }, update, function (err) {
+        should.strictEqual(null, err);
+        BlogPost.findById(post, function (err, ret) {
+          should.strictEqual(null, err);
+          ret.comments.length.should.equal(0);
+          update16(post, ret);
+        })
+      });
+    }
+
+    function update16 (post, ret) {
+      ret.comments.$pushAll([{body: 'hi'}, {body:'there'}]);
+      ret.save(function (err) {
+        should.strictEqual(null, err);
+        BlogPost.findById(post, function (err, ret) {
+          should.strictEqual(null, err);
+          ret.comments.length.should.equal(2);
+
+          var update = {
+              $pull: { comments: { body: { $nin: ['there'] }} }
+          }
+
+          BlogPost.update({ _id: ret._id }, update, function (err) {
+            should.strictEqual(null, err);
+            BlogPost.findById(post, function (err, ret) {
+              db.close();
+              should.strictEqual(null, err);
+              ret.comments.length.should.equal(1);
+            })
+          });
+        })
+      });
+    }
+  },
+
+  // gh-699
+  'Model._castUpdate should honor strict schemas': function () {
+    var db = start();
+    var S = db.model('UpdateStrictSchema');
+    db.close();
+
+    var doc = S.find()._castUpdate({ ignore: true });
+    Object.keys(doc.$set).length.should.equal(0);
+  },
+
+  'Model.update should honor strict schemas': function () {
+    var db = start();
+    var S = db.model('UpdateStrictSchema');
+    var s = new S({ name: 'orange crush' });
+
+    s.save(function (err) {
+      should.strictEqual(null, err);
+
+      S.update({ _id: s._id }, { ignore: true }, function (err, affected) {
+        should.strictEqual(null, err);
+        affected.should.equal(1);
+
+        S.findById(s._id, function (err, doc) {
+          db.close();
+          should.strictEqual(null, err);
+          should.not.exist(doc.ignore);
+          should.not.exist(doc._doc.ignore);
+        });
+      });
+    });
+  },
+
+  'model.update passes number of affected documents': function () {
+    var db = start()
+      , B = db.model('BlogPost', 'wwwwowowo'+random())
+
+    B.create({ title: 'one'},{title:'two'},{title:'three'}, function (err) {
+      should.strictEqual(null, err);
+      B.update({}, { title: 'newtitle' }, { multi: true }, function (err, affected) {
+        db.close();
+        should.strictEqual(null, err);
+        affected.should.equal(3);
+      });
+    });
+  }
+
+}