Started on node.js+socket.io+mongoDB on the backend for more responsivnes

server/node_modules/mongojs/test/crash.js

@@ -0,0 +1,10 @@
+var mongojs = require('../index');
+var db = mongojs('localhost', ['test']);
+
+db.test.findOne(function() {
+  throw new Error('I should crash the program');
+});
+
+setTimeout(function() {
+  throw new Error('timeout');
+}, 5000);

server/node_modules/mongojs/test/insert.js

@@ -0,0 +1,22 @@
+var test = require('./tape');
+var mongojs = require('../index');
+var db = mongojs('test', ['a']);
+
+module.exports = function(testName, docs, testFn) {
+  test(testName, function(t) {
+    db.a.remove(function(err) {
+      t.ok(!err);
+
+      db.a.insert(docs, function(err) {
+        t.ok(!err);
+        testFn(db, t, function() {
+          db.a.remove(function(err) {
+            t.ok(!err);
+            t.end();
+          });
+        });
+      });
+
+    });
+  });
+};

server/node_modules/mongojs/test/tape.js

@@ -0,0 +1,11 @@
+var test = require('tape');
+
+if (typeof setImmediate === 'undefined') setImmediate = process.nextTick;
+setImmediate(function() {
+  test('end', function(t) {
+    t.end();
+    process.exit();
+  });
+});
+
+module.exports = test;

server/node_modules/mongojs/test/test-aggregate.js

@@ -0,0 +1,28 @@
+var insert = require('./insert');
+var concat = require('concat-stream');
+
+insert('aggregate', [{
+  name:'Squirtle', type:'water'
+}, {
+  name:'Starmie' , type:'water'
+}, {
+  name:'Charmander' , type:'fire'
+}, {
+  name:'Lapras'  , type:'water'
+}], function(db, t, done) {
+  db.a.aggregate({$group: {_id: '$type'}}, function(err, types) {
+    var arr = types.map(function(x) {return x._id});
+    t.equal(types.length, 2);
+    t.notEqual(arr.indexOf('fire'), -1);
+    t.notEqual(arr.indexOf('water'), -1);
+
+    // test as a stream
+    db.a.aggregate({$group: {_id: '$type'}}).pipe(concat(function(types) {
+      var arr = types.map(function(x) {return x._id});
+      t.equal(types.length, 2);
+      t.notEqual(arr.indexOf('fire'), -1);
+      t.notEqual(arr.indexOf('water'), -1);
+      t.end();
+    }));
+  });
+});

server/node_modules/mongojs/test/test-bulk-updates.js

@@ -0,0 +1,43 @@
+var insert = require('./insert');
+
+insert('bulk', [{
+  name:'Squirtle', type:'water'
+}, {
+  name:'Starmie' , type:'water'
+}, {
+  name:'Lapras'  , type:'water'
+}, {
+  name: 'Charmander', type: 'fire'
+}], function(db, t, done) {
+  db.runCommand('serverStatus', function(err, resp) {
+    if (err) return t.fail();
+    if (parseFloat(resp.version) < 2.6) return t.end();
+
+    var bulk = db.a.initializeOrderedBulkOp();
+    bulk.find({type: 'water'}).update({$set: {level: 1}});
+    bulk.find({type: 'water'}).update({$inc: {level: 2}});
+    bulk.insert({name: 'Spearow', type: 'flying'});
+    bulk.insert({name: 'Pidgeotto', type: 'flying'});
+    bulk.insert({name: 'Charmeleon', type: 'fire'});
+    bulk.find({type: 'flying'}).removeOne();
+    bulk.find({type: 'fire'}).remove();
+    bulk.find({type: 'water'}).updateOne({$set: {hp: 100}});
+
+    bulk.execute(function(err, res) {
+      t.ok(res.ok);
+      db.a.find(function(err, res) {
+        t.equal(res[0].name, 'Squirtle');
+        t.equal(res[1].name, 'Starmie');
+        t.equal(res[2].name, 'Lapras');
+        t.equal(res[3].name, 'Pidgeotto');
+
+        t.equal(res[0].level, 3);
+        t.equal(res[1].level, 3);
+        t.equal(res[2].level, 3);
+
+        t.equal(res[0].hp, 100);
+        t.end();
+      });
+    });
+  });
+});

server/node_modules/mongojs/test/test-chained-collection-names.js

@@ -0,0 +1,16 @@
+var test = require('./tape');
+var mongojs = require('../index');
+var db = mongojs('test', ['b.c']);
+
+test('chained-collection-names', function(t) {
+  db.b.c.remove(function() {
+    db.b.c.save({hello: "world"}, function(err, rs) {
+      db.b.c.find(function(err, docs) {
+        t.equal(docs[0].hello, "world");
+        db.b.c.remove(function() {
+          t.end();
+        });
+      });
+    });
+  });
+});

server/node_modules/mongojs/test/test-crash.js

@@ -0,0 +1,10 @@
+var test = require('./tape');
+var cp = require('child_process');
+
+test('crash', function(t) {
+  var proc = cp.spawn('node', ['./crash.js']);
+  proc.on('exit', function(code) {
+    t.notEqual(code, 0);
+    t.end();
+  });
+});

server/node_modules/mongojs/test/test-create-collection.js

@@ -0,0 +1,15 @@
+var test = require('./tape');
+var mongojs = require('../index');
+var db = mongojs('test', ['test123']);
+
+test('createCollection', function(t) {
+  db.test123.drop(function() {
+    db.createCollection('test123', function(err) {
+      t.ok(!err);
+      db.createCollection('test123', function(err) {
+        t.ok(err);
+        t.end();
+      });
+    });
+  });
+});

server/node_modules/mongojs/test/test-cursor-count.js

@@ -0,0 +1,19 @@
+var insert = require('./insert');
+
+insert('remove', [{
+  name:'Squirtle', type:'water'
+}, {
+  name:'Charmander' , type:'fire'
+}, {
+  name:'Starmie' , type:'water'
+}, {
+  name:'Lapras'  , type:'water'
+}], function(db, t, done) {
+  db.a.find().count(function(err, cnt) {
+    t.equal(cnt, 4);
+    db.a.find({type: 'water'}).count(function(err, cnt2) {
+      t.equal(cnt2, 3);
+      done();
+    });
+  });
+});

server/node_modules/mongojs/test/test-cursor-explain.js

@@ -0,0 +1,14 @@
+var test = require('./tape');
+var insert = require('./insert');
+
+insert('cursor.explain', [{
+  hello:'world1'
+},{
+  hello:'world2'
+}], function(db, t, done) {
+  var cursor = db.a.find();
+  cursor.explain(function(err, result) {
+    t.equal(result.nscannedObjects, 2);
+    done();
+  });
+});

server/node_modules/mongojs/test/test-cursor-foreach.js

@@ -0,0 +1,17 @@
+var insert = require('./insert');
+
+var pokemons = [{
+  name:'Squirtle', type:'water'
+}, {
+  name:'Starmie' , type:'water'
+}, {
+  name:'Lapras'  , type:'water'
+}];
+
+insert('remove', pokemons, function(db, t, done) {
+  var i = 0;
+  db.a.find().forEach(function(err, pkm) {
+    if (++i === 4) return t.end();
+    t.equal(pkm.name, pokemons[i - 1].name);
+  });
+});

server/node_modules/mongojs/test/test-cursor-map.js

@@ -0,0 +1,17 @@
+var insert = require('./insert');
+
+insert('cursor.map', [{
+  hello:'world1'
+},{
+  hello:'world2'
+}], function(db, t, done) {
+  var cursor = db.a.find();
+  cursor.map(function(x) { 
+    return x.hello 
+  }, function(err, res) {
+    t.equal(res[0], 'world1');
+    t.equal(res[1], 'world2');
+    done();
+  });
+});
+

server/node_modules/mongojs/test/test-cursor-rewind.js

@@ -0,0 +1,22 @@
+var insert = require('./insert');
+
+insert('remove', [{
+  name:'Squirtle', type:'water'
+}, {
+  name:'Starmie' , type:'water'
+}, {
+  name:'Lapras'  , type:'water'
+}], function(db, t, done) {
+  var cursor = db.a.find().sort({name: 1});
+  cursor.next(function(err, obj1) {
+    t.equal(obj1.name, 'Lapras')
+    cursor.next(function(err, obj2) {
+      t.equal(obj2.name, 'Squirtle')
+      cursor.rewind();
+      cursor.next(function(err) {
+        t.equal(obj1.name, 'Lapras')
+        t.end();
+      });
+    })
+  });
+});

server/node_modules/mongojs/test/test-cursor-size.js

@@ -0,0 +1,20 @@
+var insert = require('./insert');
+
+insert('cursor.size', [{
+  hello:'world1'
+},{
+  hello:'world2'
+},{
+  hello:'world3'
+},{
+  hello:'world4'
+}], function(db, t, done) {
+  db.a.find().skip(1).size(function(err, thesize) {
+    t.equal(thesize, 3);
+    db.a.find().limit(2).size(function(err, theothersize) {
+      t.equal(theothersize, 2);
+      done();
+    });
+  });
+});
+

server/node_modules/mongojs/test/test-disinct.js

@@ -0,0 +1,23 @@
+var test = require('./tape');
+var insert = require('./insert');
+
+insert('distinct', [{
+  goodbye:'world',
+  hello:'space'
+}, {
+  goodbye:'world',
+  hello:'space'
+}, {
+  goodbye:'earth',
+  hello:'space'
+}, {
+  goodbye:'world',
+  hello:'space'
+}], function(db, t, done) {
+  db.a.distinct('goodbye',{hello:'space'},function(err, docs) {
+    t.ok(!err);
+    t.equal(docs.length, 2);
+    t.equal(docs[0], 'world');
+    done();
+  });
+});

server/node_modules/mongojs/test/test-drop-indexes.js

@@ -0,0 +1,28 @@
+var insert = require('./insert');
+var concat = require('concat-stream');
+
+insert('aggregate', [{
+  name:'Squirtle', type:'water'
+}, {
+  name:'Starmie' , type:'water'
+}, {
+  name:'Charmander' , type:'fire'
+}, {
+  name:'Lapras'  , type:'water'
+}], function(db, t, done) {
+  db.a.ensureIndex({type: 1}, function(err) {
+    t.ok(!err);
+    db.a.getIndexes(function(err, indexes) {
+      t.ok(!err);
+      t.equal(indexes.length, 2);
+      db.a.dropIndexes(function(err) {
+        t.ok(!err);
+
+        db.a.getIndexes(function(err, indexes) {
+          t.equal(indexes.length, 1);
+          t.end();
+        });
+      });
+    });
+  });
+});

server/node_modules/mongojs/test/test-find-and-modify.js

@@ -0,0 +1,71 @@
+var insert = require('./insert');
+
+insert('findAndModify', [{
+  id: 1,
+  hello: 'you'
+}, {
+  id: 2,
+  hello: 'other'
+}], function(db, t, done) {
+  // Update and find the old document
+  db.a.findAndModify({
+    query: { id: 1 },
+    update: { $set: { hello: 'world' } },
+  },
+  function(err, doc, lastErrorObject) {
+    t.ok(!err);
+    t.equal(doc.id, 1);
+    t.equal(doc.hello, 'you');
+    t.equal(lastErrorObject.updatedExisting, true);
+    t.equal(lastErrorObject.n, 1);
+
+    // Update and find the new document
+    db.a.findAndModify({
+      query: { id: 2 },
+      'new': true,
+      update: { $set: { hello: 'me' } }
+    }, function(err, doc, lastErrorObject) {
+      t.ok(!err);
+      t.equal(doc.id, 2);
+      t.equal(doc.hello, 'me');
+      t.equal(lastErrorObject.updatedExisting, true);
+      t.equal(lastErrorObject.n, 1);
+
+      // Remove and find document
+      db.a.findAndModify({
+        query: { id: 1 },
+        remove: true
+      }, function(err, doc, lastErrorObject) {
+        t.ok(!err);
+        t.equal(doc.id, 1);
+        t.equal(lastErrorObject.n, 1);
+
+        // Insert document using upsert
+        db.a.findAndModify({
+          query: { id: 3 },
+          update: { id: 3, hello: 'girl' },
+          'new': true,
+          upsert: true
+        }, function(err, doc, lastErrorObject) {
+          t.ok(!err);
+          t.equal(doc.id, 3);
+          t.equal(doc.hello, 'girl');
+          t.equal(lastErrorObject.updatedExisting, false);
+          t.equal(lastErrorObject.n, 1);
+          t.equal(String(lastErrorObject.upserted), String(doc._id));
+
+          // Find non existing document
+          db.a.findAndModify({
+            query: { id: 0 },
+            update: { $set: { hello: 'boy' } }
+          }, function(err, doc, lastErrorObject) {
+            t.ok(!err);
+            t.equal(lastErrorObject.n, 0);
+
+            done();
+          });
+        });
+      });
+    });
+  });
+});

server/node_modules/mongojs/test/test-find-and-select.js

@@ -0,0 +1,14 @@
+var insert = require('./insert');
+
+insert('find and select', [{
+  hello:'world',
+  another:'value'
+}], function(db, t, done) {
+  db.a.find({}, {another:1}, function(err, docs) {
+    t.ok(!err);
+    t.equal(docs.length, 1);
+    t.equal(docs[0].hello, undefined);
+    t.equal(docs[0].another, 'value');
+    done();
+  });
+});

server/node_modules/mongojs/test/test-find-by-objectid.js

@@ -0,0 +1,18 @@
+var insert = require('./insert');
+
+insert('find by ObjectId', [{
+  hello:'world'
+}], function(db, t, done) {
+  db.a.find({_id:db.ObjectId('abeabeabeabeabeabeabeabe')}, {hello:1}, function(err, docs) {
+    t.ok(!err);
+    t.equal(docs.length, 0);
+
+    db.a.save({_id:db.ObjectId('abeabeabeabeabeabeabeabe')}, function() {
+      db.a.find({_id:db.ObjectId('abeabeabeabeabeabeabeabe')}, {hello:1}, function(err, docs) {
+        t.ok(!err);
+        t.equal(docs.length, 1);
+        done();
+      });
+    });
+  });
+});

server/node_modules/mongojs/test/test-find-cursor-options.js

@@ -0,0 +1,23 @@
+var insert = require('./insert');
+
+insert('find cursor options', [{
+  hello:'world1'
+},{
+  hello:'world2'
+}], function(db, t, done) {
+  var cursor = db.a.find().limit(1).skip(1);
+  var runs = 0;
+
+  cursor.next(function loop(err, doc) {
+    if (!doc) {
+      t.equal(runs, 1);
+      done();
+      return;
+    }
+    t.ok(!err);
+    t.equal(doc.hello, 'world2');
+    t.equal(typeof doc, 'object');
+    runs++;
+    cursor.next(loop);
+  });
+});

server/node_modules/mongojs/test/test-find-cursor.js

@@ -0,0 +1,23 @@
+var insert = require('./insert');
+
+insert('find cursor', [{
+  hello:'world1'
+},{
+  hello:'world2'
+}], function(db, t, done) {
+  var cursor = db.a.find();
+  var runs = 0;
+
+  cursor.next(function loop(err, doc) {
+    if (!doc) {
+      t.equal(runs, 2);
+      done();
+      return;
+    }
+    t.ok(!err);
+    t.ok(doc.hello === 'world1' || doc.hello === 'world2');
+    t.equal(typeof doc, 'object');
+    runs++;
+    cursor.next(loop);
+  });
+});

server/node_modules/mongojs/test/test-find-limit.js

@@ -0,0 +1,12 @@
+var insert = require('./insert');
+
+insert('find().limit', [{
+  hello:'world'
+}], function(db, t, done) {
+  db.a.find().limit(1, function(err, docs) {
+    t.ok(!err);
+    t.equal(docs.length, 1);
+    t.equal(docs[0].hello, 'world');
+    done();
+  });
+});

server/node_modules/mongojs/test/test-find-one.js

@@ -0,0 +1,14 @@
+var insert = require('./insert');
+
+insert('findOne', [{
+  hello:'world1'
+},{
+  hello:'world2'
+}], function(db, t, done) {
+  db.a.findOne(function(err, doc) {
+    t.ok(!err);
+    t.equal(typeof doc, 'object');
+    t.ok(doc.hello === 'world1' || doc.hello === 'world2');
+    done();
+  });
+});

server/node_modules/mongojs/test/test-find-query.js

@@ -0,0 +1,14 @@
+var insert = require('./insert');
+
+insert('find query', [{
+  hello:'world1'
+}, {
+  hello:'world2'
+}], function(db, t, done) {
+  db.a.find({hello:'world2'}, function(err, docs) {
+    t.ok(!err);
+    t.equal(docs.length, 1);
+    t.equal(docs[0].hello, 'world2');
+    done();
+  });
+});

server/node_modules/mongojs/test/test-find-sort.js

@@ -0,0 +1,21 @@
+var insert = require('./insert');
+var concat = require('concat-stream');
+
+insert('aggregate', [{
+  name:'Squirtle', type:'water'
+}, {
+  name:'Starmie' , type:'water'
+}, {
+  name:'Charmander' , type:'fire'
+}, {
+  name:'Lapras'  , type:'water'
+}], function(db, t, done) {
+  db.a.find().sort({name: 1}, function(err, docs) {
+    t.ok(!err);
+    t.equal(docs[0].name, 'Charmander');
+    t.equal(docs[1].name, 'Lapras');
+    t.equal(docs[2].name, 'Squirtle');
+    t.equal(docs[3].name, 'Starmie');
+    t.end();
+  });
+});

server/node_modules/mongojs/test/test-find.js

@@ -0,0 +1,13 @@
+var test = require('./tape');
+var insert = require('./insert');
+
+insert('find', [{
+  hello:'world'
+}], function(db, t, done) {
+  db.a.find(function(err, docs) {
+    t.ok(!err);
+    t.equal(docs.length, 1);
+    t.equal(docs[0].hello, 'world');
+    done();
+  });
+});

server/node_modules/mongojs/test/test-get-collection-names.js

@@ -0,0 +1,13 @@
+var insert = require('./insert');
+
+insert('getCollectionNames', [{
+  hello:'world'
+}], function(db, t, done) {
+  db.collection('b').save({hello: "world"}, function(err, b) {
+    db.getCollectionNames(function(err, colNames) {
+      t.notEqual(colNames.indexOf('a'), -1);
+      t.notEqual(colNames.indexOf('b'), -1);
+      done();
+    });
+  });
+});

server/node_modules/mongojs/test/test-group.js

@@ -0,0 +1,28 @@
+var insert = require('./insert');
+
+insert('group', [{
+  t: 242424,
+  online: 1
+}, {
+  t: 4244,
+  online: 0
+}], function(db, t, done) {
+  db.a.group({
+    key: {},
+    cond: {t: {$gte: 86400}},
+    initial: {count: 0, online: 0},
+    reduce: function(doc, out) {
+      out.count++;
+      out.online += doc.online;
+    },
+    finalize: function(out) {
+      out.avgOnline = out.online / out.count;
+    }
+  }, function(err, curOnline) {
+    t.ok(!err);
+    t.equal(curOnline[0].count, 1);
+    t.equal(curOnline[0].online, 1);
+    done();
+  });
+})
+

server/node_modules/mongojs/test/test-insert.js

@@ -0,0 +1,27 @@
+var test = require('./tape');
+var mongojs = require('../index');
+var db = mongojs('test', ['a','b']);
+
+test('insert', function(t) {
+  db.a.insert([{name: "Squirtle"}, {name: "Charmander"}, {name: "Bulbasaur"}], function(err, docs) {
+    t.ok(docs[0]._id);
+    t.ok(docs[1]._id);
+    t.ok(docs[2]._id);
+
+    // It should only return one document in the 
+    // callback when one document is passed instead of an array
+    db.a.insert({name: "Lapras"}, function(err, doc) {
+      t.equal(doc.name, "Lapras");
+
+      // If you pass a one element array the callback should
+      // have a one element array
+      db.a.insert([{name: "Pidgeotto"}], function (err, docs) {
+        t.equal(docs[0].name, "Pidgeotto");
+        t.equal(docs.length, 1);
+        db.a.remove(function() {
+          db.close(t.end.bind(t));
+        });
+      });
+    });
+  });
+});

server/node_modules/mongojs/test/test-map-reduce.js

@@ -0,0 +1,28 @@
+var test = require('./tape');
+var insert = require('./insert');
+
+insert('remove', [{
+  name:'Squirtle', type:'water', level: 10
+}, {
+  name:'Starmie' , type:'water', level: 8
+}, {
+  name:'Charmander' , type:'fire', level: 8
+}, {
+  name:'Lapras'  , type:'water', level: 12
+}], function(db, t, done) {
+  db.a.mapReduce(function() {
+    emit(this.type, this.level);
+  }, function(key, values) {
+    return Array.sum(values);
+  }, {
+    query: {type: 'water'},
+    out: 'levelSum'
+  }, function(err) {
+    t.notOk(err);
+    db.collection('levelSum').findOne(function(err, res) {
+      t.equal(res._id, 'water');
+      t.equal(res.value, 30);
+      db.collection('levelSum').drop(done);
+    });
+  });
+});

server/node_modules/mongojs/test/test-optional-callback.js

@@ -0,0 +1,12 @@
+var test = require('./tape');
+var mongojs = require('../index');
+var db = mongojs('test', ['a','b']);
+
+test('optional callback', function(t) {
+  db.a.ensureIndex({hello:'world'})
+  setTimeout(function() {
+    db.a.count(function() {
+      db.close(t.end.bind(t));
+    })
+  }, 100);
+});

server/node_modules/mongojs/test/test-pass-driver-db.js

@@ -0,0 +1,36 @@
+var test = require('./tape');
+var mongodb = require('mongodb');
+var mongojs = require('../');
+var each = require('each-series');
+
+test('receive a driver db or mongojs instance', function(t) {
+  mongodb.Db.connect('mongodb://localhost/test', function(err, thedb) {
+
+    var doTests = function(db, i, callback) {
+      var afterFind = function() {
+        db.a.remove(function(err) {
+          t.ok(!err);
+          t.equal(db.toString(), 'test');
+          callback();
+        });
+      };
+
+      var afterInsert = function(err) {
+        t.ok(!err);
+
+        db.a.findOne(function(err, data) {
+          t.equal(data.name, 'Pidgey');
+          afterFind();
+        });
+      };
+
+      var afterRemove = function(err) {
+        t.ok(!err);
+        db.a.insert({name: 'Pidgey'}, afterInsert);
+      };
+      db.a.remove(afterRemove);
+    };
+
+    each([mongojs(thedb, ['a']), mongojs(mongojs('test', []), ['a'])], doTests, t.end.bind(t));
+  });
+});

server/node_modules/mongojs/test/test-proxy.js

@@ -0,0 +1,16 @@
+var test = require('./tape');
+var mongojs = require('../index');
+var db = mongojs('test');
+
+test('proxy', function(t) {
+  if (typeof Proxy === 'undefined') return t.end();
+
+  db.a.remove(function() {
+    db.a.insert({hello: 'world'}, function() {
+      db.a.findOne(function(err, doc) {
+        t.equal(doc.hello, 'world');
+        t.end();
+      });
+    });
+  });
+});

server/node_modules/mongojs/test/test-remove.js

@@ -0,0 +1,30 @@
+var insert = require('./insert');
+
+// Delete just one
+insert('remove', [{
+  name:'Squirtle', type:'water'
+}, {
+  name:'Starmie' , type:'water'
+}, {
+  name:'Lapras'  , type:'water'
+}], function(db, t, done) {
+  // Remove just one
+  db.a.remove({type:'water'}, true, function(err, lastErrorObject) {
+    t.equal(lastErrorObject.n, 1);
+
+    db.a.find({type:'water'}, function(err, docs) {
+      t.equal(docs.length, 2);
+      t.equal(docs[0].name, 'Starmie')
+
+      // Normal remove
+      db.a.remove({type:'water'}, function(err, lastErrorObject) {
+        t.equal(lastErrorObject.n, 2);
+
+        db.a.find({type:'water'}, function(err, docs) {
+          t.equal(docs.length, 0);
+          done();
+        });
+      });
+    });
+  });
+});

server/node_modules/mongojs/test/test-runcommand.js

@@ -0,0 +1,31 @@
+var insert = require('./insert');
+
+insert('runCommand', [{
+  hello: "world"
+},{
+  hello: "world2"
+},{
+  hello: "world3"
+},{
+  hello: "world"
+}], function(db, t, done) {
+  db.runCommand({count: "a", query:{}}, function(err, res) {
+    t.equal(res.n, 4);
+    db.a.runCommand('count', {query: {hello: "world"}}, function(err, res) {
+      t.equal(res.n, 2);
+      db.a.runCommand('distinct', {key: "hello", query:{}}, function(err, docs) {
+        t.equal(docs.values.length, 3);
+        db.runCommand({distinct:'a', key:"hello", query:{hello:"world"}}, function(err, docs) {
+          t.equal(docs.values.length, 1);
+          db.runCommand("ping", function(err, res) {
+            t.equal(res.ok,1);
+            db.a.runCommand("count", function(err, res) {
+              t.equal(res.n, 4);
+              done();
+            });
+          });
+        });
+      });
+    });
+  });
+});

server/node_modules/mongojs/test/test-save.js

@@ -0,0 +1,19 @@
+var test = require('./tape');
+var mongojs = require('../index');
+var db = mongojs('test', ['a','b']);
+
+test('save', function(t) {
+  db.a.save({hello: "world"}, function(err, doc) {
+    t.equal(doc.hello, "world");
+    t.ok(doc._id);
+
+    doc.hello = "verden";
+    db.a.save(doc, function(err, doc) {
+      t.ok(doc._id);
+      t.equal(doc.hello, "verden")
+      db.a.remove(function() {
+        db.close(t.end.bind(t));
+      });
+    });
+  });
+});

server/node_modules/mongojs/test/test-simple.js

@@ -0,0 +1,11 @@
+var test = require('./tape');
+var mongojs = require('../index');
+var db = mongojs('test', ['a','b']);
+
+test('simple', function(t) {
+  db.a.find(function(err, docs) {
+    t.ok(!err);
+    t.equal(docs.length, 0);
+    db.close(t.end.bind(t));
+  });
+});

server/node_modules/mongojs/test/test-streaming-cursor.js

@@ -0,0 +1,29 @@
+var insert = require('./insert');
+
+insert('streaming cursor', [{
+  hello:'world1'
+},{
+  hello:'world2'
+}], function(db, t, done) {
+  var cursor = db.a.find();
+  var runs = 0;
+
+  var loop = function() {
+    var doc;
+
+    while (doc = cursor.read()) {
+      t.ok(doc.hello === 'world1' || doc.hello === 'world2');
+      t.equal(typeof doc, 'object');
+      runs++;
+    }
+
+    cursor.once('readable', loop);
+  };
+
+  cursor.on('end', function() {
+    t.equal(runs, 2);
+    done();
+  });
+
+  loop();
+});

server/node_modules/mongojs/test/test-update-and-callback.js

@@ -0,0 +1,16 @@
+var insert = require('./insert');
+
+insert('update and callback', [{
+  hello:'world'
+}], function(db, t, done) {
+  var sync = true;
+  db.a.update({hello:'world'}, {$set:{hello:'verden'}}, function(err, lastErrorObject) {
+    t.ok(!sync);
+    t.ok(!err);
+    t.equal(lastErrorObject.updatedExisting, true);
+    t.equal(lastErrorObject.n, 1);
+
+    done();
+  });
+  sync = false;
+});

server/node_modules/mongojs/test/test-update-multi.js

@@ -0,0 +1,23 @@
+var insert = require('./insert');
+
+insert('update multi', [{
+  hello:'world1'
+},{
+  hello:'world2'
+}], function(db, t, done) {
+  db.a.update({}, {$set:{updated:true}}, {multi:true}, function(err, lastErrorObject) {
+    t.ok(!err);
+    t.equal(lastErrorObject.updatedExisting, true);
+    t.equal(lastErrorObject.n, 2);
+
+    db.a.find(function(err, docs) {
+      t.ok(!err);
+      t.equal(docs.length, 2);
+      t.ok(docs[0].updated);
+      t.equal(docs[0].hello, 'world1');
+      t.ok(docs[1].updated);
+      t.equal(docs[1].hello, 'world2');
+      done();
+    });
+  });
+});

server/node_modules/mongojs/test/test-update.js

@@ -0,0 +1,17 @@
+var insert = require('./insert');
+
+insert('update', [{
+  hello:'world'
+}], function(db, t, done) {
+  db.a.update({hello:'world'}, {$set:{hello:'verden'}}, function(err, lastErrorObject) {
+    t.ok(!err);
+    t.equal(lastErrorObject.updatedExisting, true);
+    t.equal(lastErrorObject.n, 1);
+
+    db.a.findOne(function(err, doc) {
+      t.ok(!err);
+      t.equal(doc.hello, 'verden');
+      done();
+    });
+  });
+});