diff --git a/.gitignore b/.gitignore
index 096746c..40b878d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1 @@
-/node_modules/
\ No newline at end of file
+node_modules/
\ No newline at end of file
diff --git a/README.md b/README.md
index 8d86789..2c565be 100644
--- a/README.md
+++ b/README.md
@@ -4,21 +4,27 @@ Mongo Sync is a synchronous MongoDB driver for use with [Common Node](http://ole
 
 It is a thin wrapper around the official MongoDB driver for Node. Here is a quick usage example that you can use with Common Node:
 
+```javascript
     var Server = require("mongo-sync").Server;
+    var Client = require("mongo-sync").MongoClient;
     var server = new Server('127.0.0.1');
-    var result = server.db("test").getCollection("posts").find().toArray();
+    var client = new Client(server)
+    var result = client.db("test").getCollection("posts").find().toArray();
     console.log(result);
     server.close();
-    
+```
+
 For a complete application using this driver, check out [Notes](https://github.com/olegp/notes/). 
 
 If you want to use Mongo Sync directly with [node-fibers](https://github.com/laverdet/node-fibers) (i.e. without Common Node), make sure all database requests occur within a fiber, e.g.:
 
+```javascript
     var Fiber = require('fibers');
     Fiber(function() {
       // set up goes here ...
       var result = server.db("LashDB").getCollection("users").find().toArray();
     }).run();
+```
 
 ### Tests
 
@@ -26,7 +32,14 @@ If you want to use Mongo Sync directly with [node-fibers](https://github.com/lav
 
 Run the unit tests with the following command:
 
+```javascript
     common-node test/test.js
+```
+
+or using Fibers
+```javascript
+    node test/test-fiber.js
+```
 
 ### Community
 
diff --git a/lib/mongo-sync.js b/lib/mongo-sync.js
index d2d3c07..5bf06f8 100644
--- a/lib/mongo-sync.js
+++ b/lib/mongo-sync.js
@@ -32,8 +32,9 @@ function sync(obj, fn) {
 
 function Server(server, options) {
   server = (server || '127.0.0.1').split(':');
-  var host = server[0], port = server[1] || 27017;
-  this._server = new mongodb.Server(host, port, objects.merge(options, {
+  this._host = server[0]
+  this._port = server[1] || 27017;
+  this._server = new mongodb.Server(this._host, this._port, objects.merge(options, {
     poolSize:2,
     socketOptions:{
       noDelay:true
@@ -41,30 +42,53 @@ function Server(server, options) {
     auto_reconnect:true,
     disableDriverBSONSizeCheck:true
   }));
+  
 }
 
-exports.Server = Server;
-
-Server.prototype.db = function(name) {
-  var result = new DB(this, new mongodb.Db(name, this._server, {w:1}));
-  result.open();
-  return result;
-};
-
-Server.prototype.connect = function(uri) {
-  return new DB(this, sync('MongoClient', 'connect').call(mongodb, uri));
-};
+function Client(server, options) {
+  this._server = server
+  this._client = new mongodb.MongoClient(server, options)
+}
 
-Server.prototype.close = function() {
-  this._server.close();
-};
+function DB(client, name) {
+  this._server = client._server;
+  this._client = client;
+  this._db = client.db(name);
+}
 
-function DB(server, db) {
-  this._server = server;
+function Collection(db, name) {
+  if (arguments.length < 2) {
+    throw new Error('too few arguments');
+  }
   this._db = db;
+  this._collection = db._db.collection(name);
 }
 
+function Cursor(cursor) {
+  this._cursor = cursor;
+  this._mapper = function(value) {
+    return value;
+  };
+}
+
+exports.Server = Server;
+exports.Client = Client;
 exports.DB = DB;
+exports.Collection = Collection;
+
+Server.prototype.close = function() {
+  this._client.close();
+};
+
+Client.prototype.connect = function(uri) {
+  var client = sync('_client', 'connect').call(this, uri);
+  var dbname = uri.split('/').slice(-1)[0]
+  if (dbname === undefined) {
+    throw new Error('Database name is missing')
+  }
+  this._db = new DB(client, dbname);
+  return this._db;
+};
 
 DB.prototype.getMongo = function() {
   return this._server;
@@ -78,6 +102,22 @@ DB.prototype.getCollection = function(name) {
   return new Collection(this, name);
 };
 
+DB.prototype.runCommand = sync('_db', 'command');
+// DB.prototype.auth = sync('_db', 'authenticate');
+
+// Just to be backward compatible
+DB.prototype.getCollection = function() {
+  return this.listCollections();
+}
+
+DB.prototype.listCollections = function() {
+  this._res = this._db.listCollections();
+  cols = sync('_res', 'toArray').call(this);
+  return cols.map(function(entry) { 
+    return entry.name;
+  });
+};
+
 [
   'addUser',
   'dropDatabase',
@@ -88,56 +128,80 @@ DB.prototype.getCollection = function(name) {
   DB.prototype[name] = sync('_db', name);
 });
 
-DB.prototype.runCommand = sync('_db', 'command');
-DB.prototype.auth = sync('_db', 'authenticate');
+Collection.prototype.getDB = function() {
+  return this._db;
+};
 
-function Collection(db, name) {
-  if (arguments.length < 2) {
-    throw new Error('too few arguments');
+// Keep backward compatibility
+Collection.prototype.insert = function(doc) {
+  if (Array.isArray(doc)) {
+    return this.insertMany(doc);
+  } else {
+    return this.insertOne(doc);
   }
-  this._db = db;
-  this._collection = db._db.collection(name);
-}
+};
 
-exports.Collection = Collection;
+Collection.prototype.insertMany = (function() {
+  var insert = sync('_collection', 'insertMany');
+  return function(query, docs) {
+    return insert.call(this, query, docs);
+  };
+})();
 
-Collection.prototype.getDB = function() {
-  return this._db;
+Collection.prototype.insertOne = (function() {
+  var insert = sync('_collection', 'insertOne');
+  return function(query, single) {
+    return insert.call(this, query, {single:single});
+  };
+})();
+
+// Keep backward compatibility
+Collection.prototype.remove = function(doc, flag) {
+  // if flag justOne is set
+  if (flag) {
+    return this.removeOne(doc);
+  }
+  // If nothing is set
+  else {
+    return this.removeMany(doc);
+  }
 };
 
-[
-  'aggregate',
-  'count',
-  'distinct',
-  'drop',
-  'dropIndex',
-  'ensureIndex',
-  'findOne',
-  'insert',
-  'mapReduce',
-  'save'
-].forEach(function(name) {
-  Collection.prototype[name] = sync('_collection', name);
-});
+Collection.prototype.removeMany = (function() {
+  var remove = sync('_collection', 'removeMany');
+  return function(query, docs) {
+    return remove.call(this, query, docs);
+  };
+})();
 
-Collection.prototype.remove = (function() {
-  var remove = sync('_collection', 'remove');
+Collection.prototype.removeOne = (function() {
+  var remove = sync('_collection', 'removeOne');
   return function(query, single) {
     return remove.call(this, query, {single:single});
   };
 })();
 
-Collection.prototype.findAndModify = (function() {
-  var findAndModify = sync('_collection', 'findAndModify');
-  return function(document) {
-    return findAndModify.call(this, document.query, document.sort, document.update, document);
+// Keep backward compatibility
+Collection.prototype.update = function(query, doc) {
+  if (Array.isArray(doc)) {
+    return this.updateMany(query, doc);
+  } else {
+    return this.updateOne(query, doc);
+  }
+};
+
+Collection.prototype.updateOne = (function() {
+  var update = sync('_collection', 'updateOne');
+  return function() {
+    if (arguments.length < 2) {
+      throw new Error('too few arguments');
+    }
+    return update.apply(this, arguments);
   };
 })();
 
-Collection.prototype.getIndexes = sync('_collection', 'indexes');
-
-Collection.prototype.update = (function() {
-  var update = sync('_collection', 'update');
+Collection.prototype.updateMany = (function() {
+  var update = sync('_collection', 'updateMany');
   return function() {
     if (arguments.length < 2) {
       throw new Error('too few arguments');
@@ -146,26 +210,38 @@ Collection.prototype.update = (function() {
   };
 })();
 
+Collection.prototype.findAndModify = (function() {
+  var findAndModify = sync('_collection', 'findAndModify');
+  return function(document) {
+    return findAndModify.call(this, document.query, document.sort, document.update, document);
+  };
+})();
+
+Collection.prototype.save = function() {
+  var save = sync('_collection', 'save');
+  return function(doc) {
+    console.log(doc);
+    return save.call(this, doc);
+  };
+};
+
 Collection.prototype.find = function() {
   return new Cursor(this._collection.find.apply(this._collection, arguments));
 };
 
-function Cursor(cursor) {
-  this._cursor = cursor;
-  this._mapper = function(value) {
-    return value;
-  };
-}
+Collection.prototype.getIndexes = sync('_collection', 'indexes');
 
 [
-  'limit',
-  'skip',
-  'sort'
+  'aggregate',
+  'count',
+  'distinct',
+  'drop',
+  'dropIndex',
+  'ensureIndex',
+  'findOne',
+  'mapReduce'
 ].forEach(function(name) {
-  Cursor.prototype[name] = function() {
-    this._cursor[name].apply(this._cursor, arguments);
-    return this;
-  };
+  Collection.prototype[name] = sync('_collection', name);
 });
 
 (function() {
@@ -204,4 +280,16 @@ Cursor.prototype.toArray = (function() {
   };
 })();
 
-Cursor.prototype.close = sync('_cursor', 'close');
\ No newline at end of file
+Cursor.prototype.close = sync('_cursor', 'close');
+
+[
+  'limit',
+  'skip',
+  'sort'
+].forEach(function(name) {
+  Cursor.prototype[name] = function() {
+    this._cursor[name].apply(this._cursor, arguments);
+    return this;
+  };
+});
+
diff --git a/package.json b/package.json
index a15bddf..52051bf 100644
--- a/package.json
+++ b/package.json
@@ -1,50 +1,112 @@
 {
-  "name":"mongo-sync",
-  "keywords":[
-    "mongodb"
+  "_args": [
+    [
+      {
+        "raw": "mongo-sync",
+        "scope": null,
+        "escapedName": "mongo-sync",
+        "name": "mongo-sync",
+        "rawSpec": "",
+        "spec": "latest",
+        "type": "tag"
+      },
+      "/home/usr/Documents/Dev/Coffeescript/DBConnector"
+    ]
+  ],
+  "_from": "mongo-sync@latest",
+  "_id": "mongo-sync@2.0.1",
+  "_inCache": true,
+  "_location": "/mongo-sync",
+  "_npmUser": {
+    "name": "olegp",
+    "email": "oleg.podsechin@ionsquare.com"
+  },
+  "_npmVersion": "1.4.21",
+  "_phantomChildren": {},
+  "_requested": {
+    "raw": "mongo-sync",
+    "scope": null,
+    "escapedName": "mongo-sync",
+    "name": "mongo-sync",
+    "rawSpec": "",
+    "spec": "latest",
+    "type": "tag"
+  },
+  "_requiredBy": [
+    "#USER",
+    "/"
   ],
-  "description":"Synchronous MongoDB driver",
-  "version":"2.0.0",
-  "author":{
-    "name":"Oleg Podsechin",
-    "email":"oleg@ionsquare.com"
+  "_resolved": "https://registry.npmjs.org/mongo-sync/-/mongo-sync-2.0.1.tgz",
+  "_shasum": "cd87fed3f9aa45c5c10c9ba27fbae3a0734206a7",
+  "_shrinkwrap": null,
+  "_spec": "mongo-sync",
+  "_where": "/home/usr/Documents/Dev/Coffeescript/DBConnector",
+  "author": {
+    "name": "Oleg Podsechin",
+    "email": "oleg@ionsquare.com"
   },
-  "contributors":[
+  "bugs": {
+    "url": "https://github.com/olegp/mongo-sync/issues"
+  },
+  "contributors": [
     {
-      "name":"Alex Lam",
-      "email":"alex.lam@starthq.com"
+      "name": "Alex Lam",
+      "email": "alex.lam@starthq.com"
     },
     {
-      "name":"Oleg Podsechin",
-      "email":"oleg@ionsquare.com"
+      "name": "Oleg Podsechin",
+      "email": "oleg@ionsquare.com"
     }
   ],
-  "directories":{
-    "lib":"./lib"
-  },
-  "repository":{
-    "type":"git",
-    "url":"git://github.com/olegp/mongo-sync.git"
+  "dependencies": {
+    "common-utils": ">=0.0.2",
+    "fibers": ">=2.0.2",
+    "mongodb": ">=3.0.10"
   },
-  "homepage":"https://github.com/olegp/mongo-sync/",
-  "main":"./lib/mongo-sync.js",
-  "scripts":{
-    "test":"node test/test-node.js"
+  "description": "Synchronous MongoDB driver",
+  "devDependencies": {
+    "common-node": ">=0.10.7"
   },
-  "engines":{
-    "node":">=0.10.0"
+  "directories": {
+    "lib": "./lib"
   },
-  "dependencies":{
-    "common-utils":">=0.0.2",
-    "fibers":">=1.0.5",
-    "mongodb":">=2.0.24"
+  "dist": {
+    "shasum": "cd87fed3f9aa45c5c10c9ba27fbae3a0734206a7",
+    "tarball": "https://registry.npmjs.org/mongo-sync/-/mongo-sync-2.0.1.tgz"
   },
-  "devDependencies":{
-    "common-node":">=0.10.7"
+  "engines": {
+    "node": ">=0.10.0"
   },
-  "licenses":[
+  "gitHead": "bf18fa81be840d771f8c65c3aa0a9b19fe407c04",
+  "homepage": "https://github.com/olegp/mongo-sync/",
+  "keywords": [
+    "mongodb"
+  ],
+  "licenses": [
     {
-      "type":"MIT"
+      "type": "MIT"
     }
-  ]
-}
\ No newline at end of file
+  ],
+  "main": "./lib/mongo-sync.js",
+  "maintainers": [
+    {
+      "name": "olegp",
+      "email": "oleg@ionsquare.com"
+    },
+    {
+      "name": "alexlamsl",
+      "email": "alex+npm@starthq.com"
+    }
+  ],
+  "name": "mongo-sync",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/olegp/mongo-sync.git"
+  },
+  "scripts": {
+    "test": "node test/test-node.js"
+  },
+  "version": "2.0.1"
+}
diff --git a/test/test-fibers.js b/test/test-fibers.js
new file mode 100644
index 0000000..973c457
--- /dev/null
+++ b/test/test-fibers.js
@@ -0,0 +1,4 @@
+var Fiber = require('fibers');
+Fiber(function() {
+    require("test").run(require("./test"));
+}).run();
diff --git a/test/test.js b/test/test.js
index 63a0fdd..1a2aa27 100644
--- a/test/test.js
+++ b/test/test.js
@@ -1,8 +1,11 @@
 var assert = require("assert");
 var test = require('test');
 var Server = require("../lib/mongo-sync").Server;
+var Client = require("../lib/mongo-sync").Client;
 
-var db = new Server('127.0.0.1').db("test");
+var server = new Server('127.0.0.1');
+var client = new Client(server);
+var db = client.connect("mongodb://127.0.0.1:27017/test");
 var collection = db.getCollection("tests");
 
 exports.testGetCollection = function() {
@@ -10,40 +13,37 @@ exports.testGetCollection = function() {
 };
 
 exports.testCollectionNames = function() {
-  collection.insert({});
-  assert.notStrictEqual(db.collectionNames().indexOf("tests"), -1);
+  collection.insertOne({});
+  assert.notStrictEqual(db.listCollections().indexOf("tests"), -1);
 };
 
-exports.testAddUser = function() {
-  db.addUser('tester', 'testee');
-};
+// exports.testAddUser = function() {
+//   db.addUser('tester', 'testee', []);
+// };
 
-exports.testRemoveUser = function() {
-  db.removeUser('tester');
-};
+// exports.testRemoveUser = function() {
+//   db.removeUser('tester');
+// };
 
-exports.testAuth = function() {
-  db.addUser('tester', 'testee');
-  assert.ok(db.auth('tester', 'testee'));
-  db.removeUser('tester');
-  assert.throws(function() {
-    db.auth('tester', 'testee');
-  });
-};
+// exports.testAuth = function() {
+//   client.addUser('tester', 'testee', []);
+//   assert.ok(db.auth('tester', 'testee'));
+//   db.removeUser('tester');
+//   assert.throws(function() {
+//     db.auth('tester', 'testee');
+//   });
+// };
 
 exports.testDropDatabase = function() {
-  collection.insert({});
+  collection.insertOne({});
   db.dropDatabase();
-  assert.strictEqual(db.collectionNames().indexOf("tests"), -1);
+  assert.strictEqual(db.listCollections().indexOf("tests"), -1);
 };
 
 exports.testEval = function() {
   assert.strictEqual(db.eval("return 42"), 42);
 };
 
-//exports.testRemoveUser = function() {
-//}
-
 exports.testRunCommand = function() {
   assert.strictEqual(
     db.runCommand({
@@ -54,43 +54,56 @@ exports.testRunCommand = function() {
 
 exports.testCollectionCount = function() {
   collection.remove();
-  collection.insert({});
-  collection.insert({});
+  collection.insertOne({});
+  collection.insertOne({});
   assert.strictEqual(collection.count(), 2);
 };
 
 exports.testDistinct = function() {
   collection.remove();
-  collection.insert({name:"John"});
-  collection.insert({name:"John"});
+  collection.insertOne({name:"John"});
+  collection.insertOne({name:"John"});
   assert.strictEqual(collection.distinct("name", {})[0], "John");
 };
 
 exports.testDrop = function() {
-  collection.insert({});
+  collection.insertOne({});
   collection.drop();
-  assert.strictEqual(db.collectionNames().indexOf("tests"), -1);
+  assert.strictEqual(db.listCollections().indexOf("tests"), -1);
 };
 
-exports.testInsert = function() {
+exports.testInsertOne = function() {
+  collection.remove();
+  collection.insertOne({test:"test"});
+  assert.strictEqual(collection.find().next().test, "test");
+};
+
+exports.testInsertOld = function() {
   collection.remove();
   collection.insert({test:"test"});
   assert.strictEqual(collection.find().next().test, "test");
 };
 
-exports.testSave = function() {
+exports.testInsertMany = function() {
   collection.remove();
-  var test = collection.save({test:"test"});
-  assert.strictEqual(collection.count(), 1);
-  test.test = "test2";
-  collection.save(test);
-  assert.strictEqual(collection.count(), 1);
-  assert.strictEqual(collection.find().next().test, "test2");
+  collection.insertMany([{test:"test"},{test:"test2"}]);
+  assert.strictEqual(collection.find().next().test, "test");
+  assert.strictEqual(collection.count(), 2);
 };
 
+// exports.testSave = function() {
+//   collection.remove();
+//   var test = collection.save({test:"test"});
+//   assert.strictEqual(collection.count(), 1);
+//   test.test = "test2";
+//   collection.save(test);
+//   assert.strictEqual(collection.count(), 1);
+//   assert.strictEqual(collection.find().next().test, "test2");
+// };
+
 exports.testUpdate = function() {
   collection.remove();
-  collection.insert({test:"test"});
+  collection.insertOne({test:"test"});
   assert.strictEqual(collection.count(), 1);
   collection.update({}, {$set:{test:"test2"}});
   //NOTE: we don't test all update operators here http://docs.mongodb.org/manual/reference/operator/nav-update/#id1
@@ -98,6 +111,16 @@ exports.testUpdate = function() {
   assert.strictEqual(collection.find().next().test, "test2");
 };
 
+exports.testUpdateMany = function() {
+  collection.remove();
+  collection.insertMany([{test:"test"},{test:"test"},{test:"test"}]);
+  assert.strictEqual(collection.count(), 3);
+  collection.updateMany({}, {$set:{test:"test2"}});
+  //NOTE: we don't test all update operators here http://docs.mongodb.org/manual/reference/operator/nav-update/#id1
+  assert.strictEqual(collection.count(), 3);
+  assert.strictEqual(collection.find().next().test, "test2");
+};
+
 exports.testEnsureIndex = function() {
   var indexed = db.getCollection("indexed");
   indexed.ensureIndex({name:1});
@@ -106,8 +129,8 @@ exports.testEnsureIndex = function() {
 
 exports.testFind = function() {
   collection.remove();
-  collection.insert({expression:"2 + 2", result:4});
-  collection.insert({expression:"1 + 1", result:2});
+  collection.insertOne({expression:"2 + 2", result:4});
+  collection.insertOne({expression:"1 + 1", result:2});
 
   assert.strictEqual(collection.find({result:2}).next().expression, "1 + 1");
   assert.strictEqual(collection.find({result:2}, {expression:1}).next().expression, "1 + 1");
@@ -116,8 +139,8 @@ exports.testFind = function() {
 
 exports.testFindOne = function() {
   collection.remove();
-  collection.insert({expression:"2 + 2", result:4});
-  collection.insert({expression:"1 + 1", result:2});
+  collection.insertOne({expression:"2 + 2", result:4});
+  collection.insertOne({expression:"1 + 1", result:2});
 
   assert.strictEqual(collection.findOne({result:2}).expression, "1 + 1");
   assert.strictEqual(collection.findOne({result:2}, {expression:1}).expression, "1 + 1");
@@ -126,40 +149,42 @@ exports.testFindOne = function() {
 
 exports.testFindAndModify = function() {
   collection.remove();
-  collection.insert({test:"test"});
-  assert.strictEqual(collection.findAndModify({
+  collection.insertOne({test:"test"});
+  assert.strictEqual(collection.find().next().test, "test");
+  collection.findAndModify({
     query:{test:"test"},
     update:{$set:{test:"test2"}}
-  }).test, "test");
+  });
   assert.strictEqual(collection.find().next().test, "test2");
 
-  assert.strictEqual(collection.findAndModify({
+  collection.findAndModify({
     query:{test:"test2"},
     update:{$set:{test:"test3"}},
     'new':true
-  }).test, "test3");
+  });
   assert.strictEqual(collection.find().next().test, "test3");
 
   collection.remove();
-  assert.deepEqual(collection.findAndModify({
+  collection.findAndModify({
     query:{test:"test"},
     update:{$set:{test:"test2"}},
     upsert:true
-  }), null);
+  });
+  // assert.deepEqual(collection.find(), null);
   assert.strictEqual(collection.find().next().test, "test2");
 
   collection.remove();
-  assert.strictEqual(collection.findAndModify({
+  collection.findAndModify({
     query:{test:"test"},
     update:{$set:{test:"test2"}},
     upsert:true,
     'new':true
-  }).test, "test2");
+  });
   assert.strictEqual(collection.find().next().test, "test2");
 };
 
 exports.testGetIndexes = function() {
-  collection.insert({test:"test"});
+  collection.insertOne({test:"test"});
   assert.strictEqual(collection.getIndexes()[0].key._id, 1);
 };
 
@@ -168,11 +193,7 @@ exports.testGetIndexes = function() {
 
 exports.testRemove = function() {
   collection.remove();
-  collection.insert({name:"John"});
-  collection.insert({name:"John"});
-  collection.insert({name:"John"});
-  collection.insert({name:"Smith"});
-
+  collection.insert([{name:"John"},{name:"John"},{name:"John"},{name:"Smith"}]);
   assert.strictEqual(collection.count(), 4);
 
   collection.remove({name:"Smith"});
@@ -185,11 +206,26 @@ exports.testRemove = function() {
   assert.strictEqual(collection.count(), 0);
 };
 
+exports.testRemoveMany = function() {
+  collection.remove();
+  collection.insert([{name:"John"},{name:"John"},{name:"John"},{name:"Smith"}]);
+  assert.strictEqual(collection.count(), 4);
+
+  collection.remove({name:"Smith"});
+  assert.strictEqual(collection.count(), 3);
+
+  collection.removeOne({name:"John"}, true);
+  assert.strictEqual(collection.count(), 2);
+
+  collection.removeMany({name:"John"});
+  assert.strictEqual(collection.count(), 0);
+};
+
 exports.testToArray = function() {
   collection.remove();
-  collection.insert({name:"John"});
-  collection.insert({name:"Smith"});
-  collection.insert({name:"Adam"});
+  collection.insertOne({name:"John"});
+  collection.insertOne({name:"Smith"});
+  collection.insertOne({name:"Adam"});
 
   var cursor = collection.find();
   var array = cursor.toArray();
@@ -202,9 +238,9 @@ exports.testToArray = function() {
 
 exports.testForEach = function() {
   collection.remove();
-  collection.insert({name:"John"});
-  collection.insert({name:"Smith"});
-  collection.insert({name:"Adam"});
+  collection.insertOne({name:"John"});
+  collection.insertOne({name:"Smith"});
+  collection.insertOne({name:"Adam"});
 
   var array = [];
   var cursor = collection.find();
@@ -220,9 +256,9 @@ exports.testForEach = function() {
 
 exports.testSort = function() {
   collection.remove();
-  collection.insert({name:"John"});
-  collection.insert({name:"Smith"});
-  collection.insert({name:"Adam"});
+  collection.insertOne({name:"John"});
+  collection.insertOne({name:"Smith"});
+  collection.insertOne({name:"Adam"});
 
   var array = collection.find().sort({name:1}).toArray();
   assert.strictEqual(array[0].name, "Adam");
@@ -237,9 +273,9 @@ exports.testSort = function() {
 
 exports.testLimit = function() {
   collection.remove();
-  collection.insert({name:"John"});
-  collection.insert({name:"Smith"});
-  collection.insert({name:"Adam"});
+  collection.insertOne({name:"John"});
+  collection.insertOne({name:"Smith"});
+  collection.insertOne({name:"Adam"});
 
   var array = collection.find().limit(2).toArray();
   assert.strictEqual(array.length, 2);
@@ -249,9 +285,9 @@ exports.testLimit = function() {
 
 exports.testSkip = function() {
   collection.remove();
-  collection.insert({name:"John"});
-  collection.insert({name:"Smith"});
-  collection.insert({name:"Adam"});
+  collection.insertOne({name:"John"});
+  collection.insertOne({name:"Smith"});
+  collection.insertOne({name:"Adam"});
 
   var array = collection.find().skip(1).toArray();
   assert.strictEqual(array.length, 2);
@@ -261,9 +297,9 @@ exports.testSkip = function() {
 
 exports.testCount = function() {
   collection.remove();
-  collection.insert({name:"John"});
-  collection.insert({name:"John"});
-  collection.insert({name:"Smith"});
+  collection.insertOne({name:"John"});
+  collection.insertOne({name:"John"});
+  collection.insertOne({name:"Smith"});
   assert.strictEqual(collection.count(), 3);
   assert.strictEqual(collection.count({name:"John"}), 2);
   assert.strictEqual(collection.find().count(), 3);
@@ -274,8 +310,8 @@ exports.testCount = function() {
 
 exports.testSize = function() {
   collection.remove();
-  collection.insert({});
-  collection.insert({});
+  collection.insertOne({});
+  collection.insertOne({});
   assert.strictEqual(collection.find().size(), 2);
   assert.strictEqual(collection.find().skip(1).size(), 1);
   assert.strictEqual(collection.find().limit(1).size(), 1);
@@ -283,14 +319,15 @@ exports.testSize = function() {
 };
 
 exports.testExplain = function() {
-  assert.strictEqual(collection.find().explain().cursor, 'BasicCursor');
+  var cur = collection.find().explain();
+  assert.strictEqual(cur.executionStats.executionSuccess, true);
 };
 
 exports.testMap = function() {
   collection.remove();
-  collection.insert({name:"John"});
-  collection.insert({name:"Smith"});
-  collection.insert({name:"Adam"});
+  collection.insertOne({name:"John"});
+  collection.insertOne({name:"Smith"});
+  collection.insertOne({name:"Adam"});
   var cursor = collection.find();
   var array = cursor.map(function(user) {
     return user.name;
@@ -303,9 +340,9 @@ exports.testMap = function() {
 
 exports.testNext = function() {
   collection.remove();
-  collection.insert({name:"John"});
-  collection.insert({name:"Smith"});
-  collection.insert({name:"Adam"});
+  collection.insertOne({name:"John"});
+  collection.insertOne({name:"Smith"});
+  collection.insertOne({name:"Adam"});
 
   var cursor = collection.find();
   assert.strictEqual(cursor.next().name, "John");