raw_test.js

var mongodb = process.env['TEST_NATIVE'] != null ? require('../lib/mongodb').native() : require('../lib/mongodb').pure();
var useSSL = process.env['USE_SSL'] != null ? true : false;

var testCase = require('nodeunit').testCase,
  debug = require('util').debug,
  inspect = require('util').inspect,
  nodeunit = require('nodeunit'),
  gleak = require('../dev/tools/gleak'),
  ObjectID = mongodb.ObjectID,
  Db = mongodb.Db,
  Cursor = mongodb.Cursor,
  Collection = mongodb.Collection,
  Server = mongodb.Server;

var MONGODB = 'integration_tests';
var client = null;

/**
 * Retrieve the server information for the current
 * instance of the db client
 * 
 * @ignore
 */
exports.setUp = function(callback) {
  var self = exports;  
  client = new Db(MONGODB, new Server("127.0.0.1", 27017, {auto_reconnect: true, poolSize: 4, ssl:useSSL}), {native_parser: (process.env['TEST_NATIVE'] != null)});
  client.open(function(err, db_p) {
    if(numberOfTestsRun == (Object.keys(self).length)) {
      // If first test drop the db
      client.dropDatabase(function(err, done) {
        callback();
      });
    } else {
      return callback();
    }
  });
}

/**
 * Retrieve the server information for the current
 * instance of the db client
 * 
 * @ignore
 */
exports.tearDown = function(callback) {
  var self = this;
  numberOfTestsRun = numberOfTestsRun - 1;
  // Close connection
  client.close();
  callback();
}

exports.shouldCorrectlySaveDocumentsAndReturnAsRaw = function(test) {
  client.createCollection('shouldCorrectlySaveDocumentsAndReturnAsRaw', function(err, collection) {
    // Insert some documents
    collection.insert([{a:1}, {b:2000}, {c:2.3}], {safe:true}, function(err, result) {
      // You have to pass at least query + fields before passing options
      collection.find({}, null, {raw:true}).toArray(function(err, items) {
        var objects = [];
        for(var i = 0; i < items.length; i++) {
          test.ok(Buffer.isBuffer(items[i]));
          objects.push(client.bson.deserialize(items[i]));
        }
        
        test.equal(1, objects[0].a);
        test.equal(2000, objects[1].b);
        test.equal(2.3, objects[2].c);
        
        // Execute findOne
        collection.findOne({a:1}, {raw:true}, function(err, item) {
          test.ok(Buffer.isBuffer(item));
          var object = client.bson.deserialize(item);
          test.equal(1, object.a)            
          test.done();
        })          
      })        
    })
  });
}

exports.shouldCorrectlyRemoveDocumentAndReturnRaw = function(test) {
  client.createCollection('shouldCorrectlyRemoveDocumentAndReturnRaw', function(err, collection) {
    // Insert some documents
    collection.insert([{a:1}, {b:2000}, {c:2.3}], {safe:true}, function(err, result) {
      // Let's create a raw delete command
      var queryObject = {b:2000};
      // Create raw bson buffer
      var rawQueryObject = new Buffer(client.bson.calculateObjectSize(queryObject));
      client.bson.serializeWithBufferAndIndex(queryObject, false, rawQueryObject, 0);    

      // Update the document and return the raw new document
      collection.remove(rawQueryObject, {safe:true}, function(err, numberOfDeleted) {
        test.equal(1, numberOfDeleted);
        
        collection.findOne({b:2000}, function(err, item) {
          test.equal(null, item)
          test.done();
        });          
      });        
    });
  });
}

exports.shouldCorrectlyUpdateDocumentAndReturnRaw = function(test) {
  client.createCollection('shouldCorrectlyUpdateDocumentAndReturnRaw', function(err, collection) {
    // Insert some documents
    collection.insert([{a:1}, {b:2000}, {c:2.3}], {safe:true}, function(err, result) {
      // Let's create a raw delete command
      var selectorObject = {b:2000};
      // Create raw bson buffer
      var rawSelectorObject = new Buffer(client.bson.calculateObjectSize(selectorObject));
      client.bson.serializeWithBufferAndIndex(selectorObject, false, rawSelectorObject, 0);    
      // Let's create a raw delete command
      var updateObject = {"$set":{c:2}};
      // Create raw bson buffer
      var rawUpdateObject = new Buffer(client.bson.calculateObjectSize(updateObject));
      client.bson.serializeWithBufferAndIndex(updateObject, false, rawUpdateObject, 0);    
      // Update the document and return the raw new document
      collection.update(rawSelectorObject, rawUpdateObject, {safe:true}, function(err, numberOfUpdated) {
        test.equal(1, numberOfUpdated);
        
        // Query the document
        collection.find({}, {}, {raw:true}).toArray(function(err, items) {
          var objects = [];
          for(var i = 0; i < items.length; i++) {
            test.ok(Buffer.isBuffer(items[i]));
            objects.push(client.bson.deserialize(items[i]));
          }
          
          test.equal(1, objects[0].a);
          test.equal(2.3, objects[1].c);
          test.equal(2000, objects[2].b);
          test.equal(2, objects[2].c);
          test.done();
        })
      });        
    });
  });
}

exports.shouldCorreclyInsertRawDocumentAndRetrieveThem = function(test) {
  client.createCollection('shouldCorreclyInsertRawDocumentAndRetrieveThem', function(err, collection) {
    // Create serialized insert objects
    var id = new ObjectID();
    var inputObjects = [{_id:id}, {a:1}, {b:2}, {c:4}]
    var serializedObjects = [];
    
    // Serialize all object
    for(var i = 0; i < inputObjects.length; i++) {
      // Create raw bson buffer
      var rawObject = new Buffer(client.bson.calculateObjectSize(inputObjects[i]));
      client.bson.serializeWithBufferAndIndex(inputObjects[i], false, rawObject, 0);
      serializedObjects.push(rawObject);
    }
    
    // Insert all raw objects
    collection.insert(serializedObjects, {safe:true}, function(err, result) {
      test.equal(null, err);
      
      // Query the document
      collection.find({}, {}, {raw:true}).toArray(function(err, items) {
        var objects = [];
        for(var i = 0; i < items.length; i++) {
          test.ok(Buffer.isBuffer(items[i]));
          objects.push(client.bson.deserialize(items[i]));
        }

        test.equal(id.toHexString(), objects[0]._id.toHexString());
        test.equal(1, objects[1].a);
        test.equal(2, objects[2].b);
        test.equal(4, objects[3].c);
        test.done();
      })
    });      
  });
}

exports.shouldCorrectlyPeformQueryUsingRaw = function(test) {
  client.createCollection('shouldCorrectlyPeformQueryUsingRaw', function(err, collection) {
    collection.insert([{a:1}, {b:2}, {b:3}], {safe:true}, function(err, result) {
      test.equal(null, err);

      // Let's create a raw query object
      var queryObject = {b:3};
      // Create raw bson buffer
      var rawQueryObject = new Buffer(client.bson.calculateObjectSize(queryObject));
      client.bson.serializeWithBufferAndIndex(queryObject, false, rawQueryObject, 0);    

      // Let's create a raw fields object
      var fieldsObject = {};
      // Create raw bson buffer
      var rawFieldsObject = new Buffer(client.bson.calculateObjectSize(fieldsObject));
      client.bson.serializeWithBufferAndIndex(fieldsObject, false, rawFieldsObject, 0);    

      collection.find(rawQueryObject, rawFieldsObject, {raw:true}).toArray(function(err, items) {
        test.equal(1, items.length);
        test.ok(items[0] instanceof Buffer);
        if(items[0] == null) console.dir(items)
        var object = client.bson.deserialize(items[0]);
        test.equal(3, object.b)            

        collection.findOne(rawQueryObject, rawFieldsObject, {raw:true}, function(err, item) {
          test.equal(null, err);
          test.ok(item != null);
          var object = client.bson.deserialize(item);
          test.equal(3, object.b)                        
          test.done();
        });
      });
    })
  });
}

exports.shouldCorrectlyThrowErrorsWhenIllegalySizedMessages = function(test) {
  client.createCollection('shouldCorrectlyThrowErrorsWhenIllegalySizedMessages', function(err, collection) {
    var illegalBuffer = new Buffer(20);
    try {
      collection.insert(illegalBuffer, {safe:true}, function(err, result) {});        
    } catch (err) {
      test.ok(err.toString().indexOf("insert") != -1);        
    }
    
    try {
      collection.update(illegalBuffer, {}, function(){})          
    } catch(err) {
      test.ok(err.toString().indexOf("update spec") != -1);
    }        

    try {
      collection.update({}, illegalBuffer, function(){})          
    } catch(err) {
      test.ok(err.toString().indexOf("update document") != -1);
    }              

    try {
      collection.remove(illegalBuffer, function(){})          
    } catch(err) {
      test.ok(err.toString().indexOf("delete") != -1);
    }              

    try {
      collection.find(illegalBuffer).toArray(function() {})
    } catch(err) {
      test.ok(err.toString().indexOf("query selector") != -1);
    }              

    try {
      collection.find({}, illegalBuffer).toArray(function() {})
    } catch(err) {
      test.ok(err.toString().indexOf("query fields") != -1);
    }              

    try {
      collection.findOne(illegalBuffer, function() {})
    } catch(err) {      
      test.ok(err.toString().indexOf("query selector") != -1);
    }              

    try {
      collection.findOne({}, illegalBuffer, function() {})
    } catch(err) {
      test.ok(err.toString().indexOf("query fields") != -1);
      test.done();
    }              
  });
}

exports.shouldCorrectlyPeformQueryUsingRawSettingRawAtCollectionLevel = function(test) {
  client.createCollection('shouldCorrectlyPeformQueryUsingRawSettingRawAtCollectionLevel', function(err, collection) {
    collection.insert([{a:1}, {b:2}, {b:3}], {safe:true}, function(err, result) {
      test.equal(null, err);

      // Let's create a raw query object
      var queryObject = {b:3};
      // Create raw bson buffer
      var rawQueryObject = new Buffer(client.bson.calculateObjectSize(queryObject));
      client.bson.serializeWithBufferAndIndex(queryObject, false, rawQueryObject, 0);    

      // Let's create a raw fields object
      var fieldsObject = {};
      // Create raw bson buffer
      var rawFieldsObject = new Buffer(client.bson.calculateObjectSize(fieldsObject));
      client.bson.serializeWithBufferAndIndex(fieldsObject, false, rawFieldsObject, 0);    

      client.collection('shouldCorrectlyPeformQueryUsingRaw', {raw:true}, function(err, collection) {
        collection.find(rawQueryObject, rawFieldsObject).toArray(function(err, items) {
          test.equal(1, items.length);
          test.ok(items[0] instanceof Buffer);
          var object = client.bson.deserialize(items[0]);
          test.equal(3, object.b)            

          collection.findOne(rawQueryObject, rawFieldsObject, {raw:true}, function(err, item) {
            test.equal(null, err);
            test.ok(item != null);
            var object = client.bson.deserialize(item);
            test.equal(3, object.b)                        
            test.done();
          });
        });          
      });  
    })
  });
}

exports.shouldCorreclyInsertRawDocumentAndRetrieveThemSettingRawAtCollectionLevel = function(test) {
  client.createCollection('shouldCorreclyInsertRawDocumentAndRetrieveThemSettingRawAtCollectionLevel', {raw:true}, function(err, collection) {
    // Create serialized insert objects
    var id = new ObjectID();
    var inputObjects = [{_id:id}, {a:1}, {b:2}, {c:4}]
    var serializedObjects = [];
    
    // Serialize all object
    for(var i = 0; i < inputObjects.length; i++) {
      // Create raw bson buffer
      var rawObject = new Buffer(client.bson.calculateObjectSize(inputObjects[i]));
      client.bson.serializeWithBufferAndIndex(inputObjects[i], false, rawObject, 0);
      serializedObjects.push(rawObject);
    }
    
    // Insert all raw objects
    collection.insert(serializedObjects, {safe:true}, function(err, result) {
      test.equal(null, err);
      
      // Query the document
      collection.find({}, {}).toArray(function(err, items) {
        var objects = [];
        for(var i = 0; i < items.length; i++) {
          test.ok(Buffer.isBuffer(items[i]));
          objects.push(client.bson.deserialize(items[i]));
        }

        test.equal(id.toHexString(), objects[0]._id.toHexString());
        test.equal(1, objects[1].a);
        test.equal(2, objects[2].b);
        test.equal(4, objects[3].c);
        test.done();
      })
    });      
  });
}

exports.shouldCorrectlyUpdateDocumentAndReturnRawSettingRawAtCollectionLevel = function(test) {
  client.createCollection('shouldCorrectlyUpdateDocumentAndReturnRawSettingRawAtCollectionLevel', {raw:true}, function(err, collection) {
    // Insert some documents
    collection.insert([{a:1}, {b:2000}, {c:2.3}], {safe:true}, function(err, result) {
      // Let's create a raw delete command
      var selectorObject = {b:2000};
      // Create raw bson buffer
      var rawSelectorObject = new Buffer(client.bson.calculateObjectSize(selectorObject));
      client.bson.serializeWithBufferAndIndex(selectorObject, false, rawSelectorObject, 0);    
      // Let's create a raw delete command
      var updateObject = {"$set":{c:2}};
      // Create raw bson buffer
      var rawUpdateObject = new Buffer(client.bson.calculateObjectSize(updateObject));
      client.bson.serializeWithBufferAndIndex(updateObject, false, rawUpdateObject, 0);    
      // Update the document and return the raw new document
      collection.update(rawSelectorObject, rawUpdateObject, {safe:true}, function(err, numberOfUpdated) {
        test.equal(1, numberOfUpdated);
        
        // Query the document
        collection.find({}, {}).toArray(function(err, items) {
          var objects = [];
          for(var i = 0; i < items.length; i++) {
            test.ok(Buffer.isBuffer(items[i]));
            objects.push(client.bson.deserialize(items[i]));
          }
          
          test.equal(1, objects[0].a);
          test.equal(2.3, objects[1].c);
          test.equal(2000, objects[2].b);
          test.equal(2, objects[2].c);
          test.done();
        })
      });        
    });
  });
}

/**
 * Retrieve the server information for the current
 * instance of the db client
 * 
 * @ignore
 */
exports.noGlobalsLeaked = function(test) {
  var leaks = gleak.detectNew();
  test.equal(0, leaks.length, "global var leak detected: " + leaks.join(', '));
  test.done();
}

/**
 * Retrieve the server information for the current
 * instance of the db client
 * 
 * @ignore
 */
var numberOfTestsRun = Object.keys(this).length - 2;