types.array.test.js

/**
 * Module dependencies.
 */

var start = require('./common')
  , should = require('should')
  , mongoose = require('./common').mongoose
  , Schema = mongoose.Schema
  , random = require('../lib/utils').random
  , MongooseArray = mongoose.Types.Array;

var User = new Schema({
    name: String
  , pets: [Schema.ObjectId]
});

mongoose.model('User', User);

var Pet = new Schema({
  name: String
});

mongoose.model('Pet', Pet);

/**
 * Test.
 */

module.exports = {

  'test that a mongoose array behaves and quacks like an array': function(){
    var a = new MongooseArray;

    a.should.be.an.instanceof(Array);
    a.should.be.an.instanceof(MongooseArray);
    Array.isArray(a).should.be.true;
    (a._atomics.constructor).should.eql(Object);
  },

  'test indexOf()': function(){
    var db = start()
      , User = db.model('User', 'users_' + random())
      , Pet = db.model('Pet', 'pets' + random());

    var tj = new User({ name: 'tj' })
      , tobi = new Pet({ name: 'tobi' })
      , loki = new Pet({ name: 'loki' })
      , jane = new Pet({ name: 'jane' })
      , pets = [];

    tj.pets.push(tobi);
    tj.pets.push(loki);
    tj.pets.push(jane);

    var pending = 3;

    ;[tobi, loki, jane].forEach(function(pet){
      pet.save(function(){
        --pending || done();
      });
    });

    function done() {
      Pet.find({}, function(err, pets){
        tj.save(function(err){
          User.findOne({ name: 'tj' }, function(err, user){
            db.close();
            should.equal(null, err, 'error in callback');
            user.pets.should.have.length(3);
            user.pets.indexOf(tobi.id).should.equal(0);
            user.pets.indexOf(loki.id).should.equal(1);
            user.pets.indexOf(jane.id).should.equal(2);
            user.pets.indexOf(tobi._id).should.equal(0);
            user.pets.indexOf(loki._id).should.equal(1);
            user.pets.indexOf(jane._id).should.equal(2);
          });
        });
      });
    }
  },
  'test #splice() with numbers': function () {
    var collection = 'splicetest-number' + random();
    var db = start()
      , schema = new Schema({ numbers: Array })
      , A = db.model('splicetestNumber', schema, collection);

    var a = new A({ numbers: [4,5,6,7] });
    a.save(function (err) {
      should.equal(null, err, 'could not save splice test');
      A.findById(a._id, function (err, doc) {
        should.equal(null, err, 'error finding splice doc');
        doc.numbers.splice(1, 1);
        doc.numbers.toObject().should.eql([4,6,7]);
        doc.save(function (err) {
          should.equal(null, err, 'could not save splice test');
          A.findById(a._id, function (err, doc) {
            should.equal(null, err, 'error finding splice doc');
            doc.numbers.toObject().should.eql([4,6,7]);

            A.collection.drop(function (err) {
              db.close();
              should.strictEqual(err, null);
            });
          });
        });
      });
    });
  },

  'test #splice() on embedded docs': function () {
    var collection = 'splicetest-embeddeddocs' + random();
    var db = start()
      , schema = new Schema({ types: [new Schema({ type: String }) ]})
      , A = db.model('splicetestEmbeddedDoc', schema, collection);

    var a = new A({ types: [{type:'bird'},{type:'boy'},{type:'frog'},{type:'cloud'}] });
    a.save(function (err) {
      should.equal(null, err, 'could not save splice test');
      A.findById(a._id, function (err, doc) {
        should.equal(null, err, 'error finding splice doc');

        doc.types.splice(1, 1);

        var obj = doc.types.toObject();
        obj[0].type.should.eql('bird');
        obj[1].type.should.eql('frog');
        obj[2].type.should.eql('cloud');

        doc.save(function (err) {
          should.equal(null, err, 'could not save splice test');
          A.findById(a._id, function (err, doc) {
            should.equal(null, err, 'error finding splice doc');

            var obj = doc.types.toObject();
            obj[0].type.should.eql('bird');
            obj[1].type.should.eql('frog');
            obj[2].type.should.eql('cloud');

            A.collection.drop(function (err) {
              db.close();
              should.strictEqual(err, null);
            });
          });
        });
      });
    });
  }
};