sharedb-mongo 1.0.0-beta.6 → 1.0.0

package/test/test_mongo_middleware.js

@@ -0,0 +1,469 @@
+var async = require('async');
+var sinon = require('sinon');
+var chai = require('chai');
+chai.use(require('sinon-chai'));
+var expect = chai.expect;
+var ShareDbMongo = require('..');
+var mongodb = require('./../mongodb');
+var Collection = mongodb.Collection;
+
+var mongoUrl = process.env.TEST_MONGO_URL || 'mongodb://localhost:27017/test';
+var BEFORE_EDIT = ShareDbMongo.MiddlewareActions.beforeOverwrite;
+var BEFORE_CREATE = ShareDbMongo.MiddlewareActions.beforeCreate;
+var BEFORE_SNAPSHOT_LOOKUP = ShareDbMongo.MiddlewareActions.beforeSnapshotLookup;
+
+function create(callback) {
+  var db = new ShareDbMongo(mongoUrl);
+  db.getDbs(function(err, mongo) {
+    if (err) return callback(err);
+    mongo.dropDatabase(function(err) {
+      if (err) return callback(err);
+      callback(null, db, mongo);
+    });
+  });
+}
+
+describe('mongo db middleware', function() {
+  var sandbox = sinon.createSandbox();
+  var db;
+
+  beforeEach(function(done) {
+    sandbox.spy(Collection.prototype, 'find');
+    create(function(err, createdDb) {
+      if (err) return done(err);
+      db = createdDb;
+      done();
+    });
+  });
+
+  afterEach(function(done) {
+    sandbox.restore();
+    db.close(done);
+  });
+
+  describe('error handling', function() {
+    it('throws error when no action is given', function() {
+      function invalidAction() {
+        db.use(null, function(_request, next) {
+          next();
+        });
+      }
+      expect(invalidAction).to.throw();
+    });
+
+    it('throws error when no handler is given', function() {
+      function invalidAction() {
+        db.use('someAction');
+      }
+      expect(invalidAction).to.throw();
+    });
+
+    it('throws error on unrecognized action name', function() {
+      function invalidAction() {
+        db.use('someAction', function(_request, next) {
+          next();
+        });
+      }
+      expect(invalidAction).to.throw();
+    });
+  });
+
+  describe(BEFORE_EDIT, function() {
+    it('has the expected properties on the request object', function(done) {
+      db.use(BEFORE_EDIT, function(request, next) {
+        expect(request).to.have.all.keys([
+          'action',
+          'collectionName',
+          'documentToWrite',
+          'op',
+          'options',
+          'query'
+        ]);
+        expect(request.action).to.equal(BEFORE_EDIT);
+        expect(request.collectionName).to.equal('testcollection');
+        expect(request.documentToWrite.foo).to.equal('fuzz');
+        expect(request.op.op).to.exist;
+        expect(request.options.testOptions).to.equal('yes');
+        expect(request.query._id).to.equal('test1');
+        next();
+        done();
+      });
+
+      var snapshot = {type: 'json0', id: 'test1', v: 1, data: {foo: 'bar'}};
+      var editOp = {v: 2, op: [{p: ['foo'], oi: 'bar', oi: 'baz'}], m: {ts: Date.now()}};
+      var newSnapshot = {type: 'json0', id: 'test1', v: 2, data: {foo: 'fuzz'}};
+
+      db.commit('testcollection', snapshot.id, {v: 0, create: {}}, snapshot, null, function(err) {
+        if (err) return done(err);
+        db.commit('testcollection', snapshot.id, editOp, newSnapshot, {testOptions: 'yes'}, function(err) {
+          if (err) return done(err);
+        });
+      });
+    });
+
+    it('should augment query filter and write to the document when commit is called', function(done) {
+      // Augment the query. The original query looks up the document by id, wheras this middleware
+      // changes it to use the `foo` property. The end result still returns the same document. The next
+      // middleware ensures we attached it to the request.
+      // We can't truly change which document is returned from the query because MongoDB will not allow
+      // the immutable fields such as `_id` to be changed.
+      db.use(BEFORE_EDIT, function(request, next) {
+        request.query.foo = 'bar';
+        next();
+      });
+      // Attach this middleware to check that the original one is passing the context
+      // correctly. Commit will be called after this.
+      db.use(BEFORE_EDIT, function(request, next) {
+        expect(request.query).to.deep.equal({
+          _id: 'test1',
+          _v: 1,
+          foo: 'bar'
+        });
+        next();
+      });
+
+      var snapshot = {type: 'json0', id: 'test1', v: 1, data: {foo: 'bar'}};
+      var editOp = {v: 2, op: [{p: ['foo'], oi: 'bar', oi: 'baz'}], m: {ts: Date.now()}};
+      var newSnapshot = {type: 'json0', id: 'test1', v: 2, data: {foo: 'baz'}};
+
+      db.commit('testcollection', snapshot.id, {v: 0, create: {}}, snapshot, null, function(err) {
+        if (err) return done(err);
+        expectDocumentToContainFoo('bar', function() {
+          db.commit('testcollection', snapshot.id, editOp, newSnapshot, null, function(err) {
+            if (err) return done(err);
+            // Ensure the value is updated as expected
+            expectDocumentToContainFoo('baz', done);
+          });
+        });
+      });
+    });
+  });
+
+  it('should augment the written document when commit is called', function(done) {
+    // Change the written value of foo to be `fuzz`
+    db.use(BEFORE_EDIT, function(request, next) {
+      request.documentToWrite.foo = 'fuzz';
+      next();
+    });
+
+    var snapshot = {type: 'json0', id: 'test1', v: 1, data: {foo: 'bar'}};
+
+    // Issue a commit to change `bar` to `baz`
+    var editOp = {v: 2, op: [{p: ['foo'], oi: 'bar', oi: 'baz'}], m: {ts: Date.now()}};
+    var newSnapshot = {type: 'json0', id: 'test1', v: 2, data: {foo: 'baz'}};
+
+    db.commit('testcollection', snapshot.id, {v: 0, create: {}}, snapshot, null, function(err) {
+      if (err) return done(err);
+      expectDocumentToContainFoo('bar', function() {
+        db.commit('testcollection', snapshot.id, editOp, newSnapshot, null, function(err) {
+          if (err) return done(err);
+          // Ensure the value is updated as expected
+          expectDocumentToContainFoo('fuzz', done);
+        });
+      });
+    });
+  });
+
+  describe(BEFORE_CREATE, function() {
+    it('has the expected properties on the request object', function(done) {
+      db.use(BEFORE_CREATE, function(request, next) {
+        expect(request).to.have.all.keys([
+          'action',
+          'collectionName',
+          'documentToWrite',
+          'op',
+          'options'
+        ]);
+        expect(request.action).to.equal(BEFORE_CREATE);
+        expect(request.collectionName).to.equal('testcollection');
+        expect(request.documentToWrite.foo).to.equal('bar');
+        expect(request.op).to.exist;
+        expect(request.options.testOptions).to.equal('baz');
+        next();
+      });
+
+      var snapshot = {type: 'json0', id: 'test1', v: 1, data: {foo: 'bar'}};
+
+      db.commit('testcollection', snapshot.id, {v: 0, create: {}}, snapshot, {testOptions: 'baz'}, done);
+    });
+
+    it('should augment the written document when commit is called', function(done) {
+      // Change the written value of foo to be `fuzz`
+      db.use(BEFORE_CREATE, function(request, next) {
+        request.documentToWrite.foo = 'fuzz';
+        next();
+      });
+
+      var snapshot = {type: 'json0', id: 'test1', v: 1, data: {foo: 'bar'}};
+
+      db.commit('testcollection', snapshot.id, {v: 0, create: {}}, snapshot, null, function(err) {
+        if (err) return done(err);
+        expectDocumentToContainFoo('fuzz', done);
+      });
+    });
+
+    it('returns without writing when there was a middleware error', function(done) {
+      db.use(BEFORE_CREATE, function(_, next) {
+        next(new Error('Oh no!'));
+      });
+
+      var snapshot = {type: 'json0', id: 'test1', v: 1, data: {foo: 'bar'}};
+
+      db.commit('testcollection', snapshot.id, {v: 0, create: {}}, snapshot, null, function(err) {
+        expectDocumentNotToExist(function() {
+          if (err) return done();
+          done('Expected an error, did not get one');
+        });
+      });
+    });
+  });
+
+  describe(BEFORE_SNAPSHOT_LOOKUP, function() {
+    it('has the expected properties on the request object before getting a single snapshot', function(done) {
+      db.use(BEFORE_SNAPSHOT_LOOKUP, function(request, next) {
+        expect(request).to.have.all.keys([
+          'action',
+          'collectionName',
+          'options',
+          'query'
+        ]);
+        expect(request.action).to.equal(BEFORE_SNAPSHOT_LOOKUP);
+        expect(request.collectionName).to.equal('testcollection');
+        expect(request.options.testOptions).to.equal('yes');
+        expect(request.query._id).to.equal('test1');
+        next();
+        done();
+      });
+
+      var snapshot = {type: 'json0', id: 'test1', v: 1, data: {foo: 'bar'}};
+      db.commit('testcollection', snapshot.id, {v: 0, create: {}}, snapshot, null, function(err) {
+        if (err) return done(err);
+        db.getSnapshot('testcollection', 'test1', null, {testOptions: 'yes'}, function(err, doc) {
+          if (err) return done(err);
+          expect(doc).to.exist;
+        });
+      });
+    });
+
+    it('passes triggeredBy = submitRequest when fields has $submit = true', function(done) {
+      var middlewareSpy = sinon.spy(function(request, next) {
+        expect(request).to.have.all.keys([
+          'action',
+          'collectionName',
+          'options',
+          'query',
+          'triggeredBy'
+        ]);
+        expect(request.action).to.equal(BEFORE_SNAPSHOT_LOOKUP);
+        expect(request.collectionName).to.equal('testcollection');
+        expect(request.options.testOptions).to.equal('yes');
+        expect(request.triggeredBy).to.equal('submitRequest');
+        expect(request.query._id).to.equal('test1');
+        // test that when we set findOptions in the middleware, they get passed to the Mongo driver.
+        request.findOptions = {
+          maxTimeMS: 999
+        };
+        next();
+      });
+      db.use(BEFORE_SNAPSHOT_LOOKUP, middlewareSpy);
+
+      var snapshot = {type: 'json0', id: 'test1', v: 1, data: {foo: 'bar'}};
+      db.commit('testcollection', snapshot.id, {v: 0, create: {}}, snapshot, null, function(err) {
+        if (err) return done(err);
+        db.getSnapshot('testcollection', 'test1', {
+          $submit: true
+        }, {testOptions: 'yes'}, function(err, doc) {
+          if (err) return done(err);
+          expect(doc).to.exist;
+          expect(middlewareSpy).to.have.been.calledOnceWith(sinon.match.object, sinon.match.func);
+          expect(Collection.prototype.find).to.have.been.calledOnceWith({
+            _id: snapshot.id
+          }, {
+            maxTimeMS: 999
+          });
+          done();
+        });
+      });
+    });
+
+    it('has the expected properties on the request object before getting ops', function(done) {
+      var middlewareSpy = sinon.spy(function(request, next) {
+        expect(request).to.have.all.keys([
+          'action',
+          'collectionName',
+          'options',
+          'query'
+        ]);
+        expect(request.action).to.equal(BEFORE_SNAPSHOT_LOOKUP);
+        expect(request.collectionName).to.equal('testcollection');
+        expect(request.options.testOptions).to.equal('yes');
+        expect(request.query._id).to.deep.equal('test2');
+        next();
+      });
+      db.use(BEFORE_SNAPSHOT_LOOKUP, middlewareSpy);
+
+      var snapshot = {type: 'json0', id: 'test2', v: 1, data: {foo: 'bar'}};
+      db.commit('testcollection', snapshot.id, {v: 0, create: {}}, snapshot, null, function(err) {
+        if (err) return done(err);
+        db.getOps('testcollection', 'test2', 0, 1, {testOptions: 'yes'}, function(err) {
+          if (err) return done(err);
+          /*
+            Don't finalize the test in the middleware - since getOps will make queries *after* the middleware is fired.
+            If we call done() in the middleware, we'll close the db connection, and then getOps will call _getOps()
+            which will throw a "db connection closed" error.
+           */
+          expect(middlewareSpy).to.have.been.calledOnceWith(sinon.match.object, sinon.match.func);
+          done();
+        });
+      });
+    });
+
+    it('has the expected properties on the request object before getting ops bulk', function(done) {
+      var middlewareSpy = sinon.spy(function(request, next) {
+        expect(request).to.have.all.keys([
+          'action',
+          'collectionName',
+          'options',
+          'query'
+        ]);
+        expect(request.action).to.equal(BEFORE_SNAPSHOT_LOOKUP);
+        expect(request.collectionName).to.equal('testcollection');
+        expect(request.options.testOptions).to.equal('yes');
+        expect(request.query._id).to.deep.equal({$in: ['test2']});
+        next();
+      });
+      db.use(BEFORE_SNAPSHOT_LOOKUP, middlewareSpy);
+
+      var snapshot = {type: 'json0', id: 'test2', v: 1, data: {foo: 'bar'}};
+      db.commit('testcollection', snapshot.id, {v: 0, create: {}}, snapshot, null, function(err) {
+        if (err) return done(err);
+        db.getOpsBulk('testcollection', {
+          test2: 0
+        }, {
+          test2: 1
+        }, {testOptions: 'yes'}, function(err) {
+          if (err) return done(err);
+          /*
+            Don't finalize the test in the middleware - since getOps will make queries *after* the middleware is fired.
+            If we call done() in the middleware, we'll close the db connection, and then getOps will call _getOps()
+            which will throw a "db connection closed" error.
+           */
+          expect(middlewareSpy).to.have.been.calledOnceWith(sinon.match.object, sinon.match.func);
+          done();
+        });
+      });
+    });
+
+    it('has the expected properties on the request object before getting bulk snapshots', function(done) {
+      db.use(BEFORE_SNAPSHOT_LOOKUP, function(request, next) {
+        expect(request).to.have.all.keys([
+          'action',
+          'collectionName',
+          'options',
+          'query'
+        ]);
+        expect(request.action).to.equal(BEFORE_SNAPSHOT_LOOKUP);
+        expect(request.collectionName).to.equal('testcollection');
+        expect(request.options.testOptions).to.equal('yes');
+        expect(request.query._id).to.deep.equal({$in: ['test1']});
+        next();
+        done();
+      });
+
+      var snapshot = {type: 'json0', id: 'test1', v: 1, data: {foo: 'bar'}};
+      db.commit('testcollection', snapshot.id, {v: 0, create: {}}, snapshot, null, function(err) {
+        if (err) return done(err);
+        db.getSnapshotBulk('testcollection', ['test1'], null, {testOptions: 'yes'}, function(err, doc) {
+          if (err) return done(err);
+          expect(doc).to.exist;
+        });
+      });
+    });
+
+    it('should augment the query when getSnapshot is called', function(done) {
+      var snapshots = [
+        {type: 'json0', id: 'test1', v: 1, data: {foo: 'bar'}},
+        {type: 'json0', id: 'test2', v: 1, data: {foo: 'baz'}}
+      ];
+
+      async.each(snapshots, function(snapshot, cb) {
+        db.commit('testcollection', snapshot.id, {v: 0, create: {}}, snapshot, null, cb);
+      }, function(err) {
+        if (err) return done(err);
+        db.getSnapshot('testcollection', 'test1', null, null, function(err, doc) {
+          if (err) return done(err);
+          expect(doc.data).eql({
+            foo: 'bar'
+          });
+
+          // Change the query to look for baz and not bar
+          db.use(BEFORE_SNAPSHOT_LOOKUP, function(request, next) {
+            request.query = {_id: 'test2'};
+            next();
+          });
+
+          db.getSnapshot('testcollection', 'test1', null, null, function(err, doc) {
+            if (err) return done(err);
+            expect(doc.data).eql({
+              foo: 'baz'
+            });
+            done();
+          });
+        });
+      });
+    });
+
+    it('should augment the query when getSnapshotBulk is called', function(done) {
+      var snapshots = [
+        {type: 'json0', id: 'test1', v: 1, data: {foo: 'bar'}},
+        {type: 'json0', id: 'test2', v: 1, data: {foo: 'baz'}}
+      ];
+
+      async.each(snapshots, function(snapshot, cb) {
+        db.commit('testcollection', snapshot.id, {v: 0, create: {}}, snapshot, null, cb);
+      }, function(err) {
+        if (err) return done(err);
+        db.getSnapshotBulk('testcollection', ['test1', 'test2'], null, null, function(err, docs) {
+          if (err) return done(err);
+          expect(docs.test1.data.foo).to.equal('bar');
+          expect(docs.test2.data.foo).to.equal('baz');
+
+          // Change the query to look for baz and not bar
+          db.use(BEFORE_SNAPSHOT_LOOKUP, function(request, next) {
+            request.query = {_id: {$in: ['test2']}};
+            next();
+          });
+
+          db.getSnapshotBulk('testcollection', ['test1', 'test2'], null, null, function(err, docs) {
+            if (err) return done(err);
+            expect(docs.test1.data).not.to.exist;
+            expect(docs.test2.data.foo).to.equal('baz');
+            done();
+          });
+        });
+      });
+    });
+  });
+
+  function expectDocumentToContainFoo(valueOfFoo, cb) {
+    var query = {_id: 'test1'};
+
+    db.query('testcollection', query, null, null, function(err, results) {
+      if (err) return done(err);
+      expect(results[0].data).eql({
+        foo: valueOfFoo
+      });
+      cb();
+    });
+  };
+
+  function expectDocumentNotToExist(cb) {
+    var query = {_id: 'test1'};
+
+    db.query('testcollection', query, null, null, function(err, results) {
+      if (err) return cb(err);
+      expect(results).to.be.empty;
+      cb();
+    });
+  };
+});

package/test/test_op_link_validator.js

@@ -0,0 +1,159 @@
+var OpLinkValidator = require('../op-link-validator');
+var expect = require('chai').expect;
+
+describe('OpLinkValidator', function() {
+  it('starts with no unique op', function() {
+    var validator = new OpLinkValidator();
+    var opWithUniqueVersion = validator.opWithUniqueVersion();
+    expect(opWithUniqueVersion).to.equal(null);
+  });
+
+  it('starts not at the end of the list', function() {
+    var validator = new OpLinkValidator();
+    expect(validator.isAtEndOfList()).to.equal(false);
+  });
+
+  it('has no unique op with just one op', function() {
+    var op = {v: 1};
+    var validator = new OpLinkValidator();
+
+    validator.push(op);
+    var opWithUniqueVersion = validator.opWithUniqueVersion();
+
+    expect(opWithUniqueVersion).to.equal(null);
+  });
+
+  it('has a unique op with just two different ops', function() {
+    var op1 = {v: 1};
+    var op2 = {v: 2};
+    var validator = new OpLinkValidator();
+
+    validator.push(op1);
+    validator.push(op2);
+    var opWithUniqueVersion = validator.opWithUniqueVersion();
+
+    expect(opWithUniqueVersion).to.equal(op1);
+  });
+
+  it('does not have a uniquye op with just two identical ops', function() {
+    var op1 = {v: 1};
+    var op2 = {v: 1};
+    var validator = new OpLinkValidator();
+
+    validator.push(op1);
+    validator.push(op2);
+    var opWithUniqueVersion = validator.opWithUniqueVersion();
+
+    expect(opWithUniqueVersion).to.equal(null);
+  });
+
+  it('has a unique op with three ops with different versions', function() {
+    var op1 = {v: 1};
+    var op2 = {v: 2};
+    var op3 = {v: 3};
+    var validator = new OpLinkValidator();
+
+    validator.push(op1);
+    validator.push(op2);
+    validator.push(op3);
+    var opWithUniqueVersion = validator.opWithUniqueVersion();
+
+    expect(opWithUniqueVersion).to.equal(op2);
+  });
+
+  it('is not at the end of the list with three ops', function() {
+    var op1 = {v: 1};
+    var op2 = {v: 2};
+    var op3 = {v: 3};
+    var validator = new OpLinkValidator();
+
+    validator.push(op1);
+    validator.push(op2);
+    validator.push(op3);
+
+    expect(validator.isAtEndOfList()).to.equal(false);
+  });
+
+  it('does not have a unique op with three ops with the same version', function() {
+    var op = {v: 1};
+    var validator = new OpLinkValidator();
+
+    validator.push(op);
+    validator.push(op);
+    validator.push(op);
+    var opWithUniqueVersion = validator.opWithUniqueVersion();
+
+    expect(opWithUniqueVersion).to.equal(null);
+  });
+
+  it('does not have a unique op if the first two ops are the same', function() {
+    var op1 = {v: 1};
+    var op2 = {v: 1};
+    var op3 = {v: 2};
+    var validator = new OpLinkValidator();
+
+    validator.push(op1);
+    validator.push(op2);
+    validator.push(op3);
+    var opWithUniqueVersion = validator.opWithUniqueVersion();
+
+    expect(opWithUniqueVersion).to.equal(null);
+  });
+
+  it('does not have a unique op if the last two ops are the same', function() {
+    var op1 = {v: 1};
+    var op2 = {v: 2};
+    var op3 = {v: 2};
+    var validator = new OpLinkValidator();
+
+    validator.push(op1);
+    validator.push(op2);
+    validator.push(op3);
+    var opWithUniqueVersion = validator.opWithUniqueVersion();
+
+    expect(opWithUniqueVersion).to.equal(null);
+  });
+
+  it('has a unique op in a long chain', function() {
+    var op1 = {v: 1};
+    var op2 = {v: 1};
+    var op3 = {v: 1};
+    var op4 = {v: 2};
+    var op5 = {v: 2};
+    var op6 = {v: 3};
+    var op7 = {v: 4};
+    var validator = new OpLinkValidator();
+
+    validator.push(op1);
+    validator.push(op2);
+    validator.push(op3);
+    validator.push(op4);
+    validator.push(op5);
+    validator.push(op6);
+    validator.push(op7);
+    var opWithUniqueVersion = validator.opWithUniqueVersion();
+
+    expect(opWithUniqueVersion).to.equal(op6);
+  });
+
+  it('has a unique op with two ops and a current op of null', function() {
+    var op1 = {v: 1};
+    var op2 = {v: 2};
+    var op3 = null;
+    var validator = new OpLinkValidator();
+
+    validator.push(op1);
+    validator.push(op2);
+    validator.push(op3);
+    var opWithUniqueVersion = validator.opWithUniqueVersion();
+
+    expect(opWithUniqueVersion).to.equal(op2);
+  });
+
+  it('is at the end of the list with a current op of null', function() {
+    var op = null;
+    var validator = new OpLinkValidator();
+    validator.push(op);
+    expect(validator.isAtEndOfList()).to.equal(true);
+  });
+});

package/test/test_skip_poll.js

@@ -1,6 +1,5 @@
-var expect = require('expect.js');
+var expect = require('chai').expect;
 var ShareDbMongo = require('../index');
-var checkOp = require('sharedb/lib/ot').checkOp;
 
 describe('skipPoll', function() {
   // Run a test function against a small sample set of queries
@@ -8,7 +7,7 @@ describe('skipPoll', function() {
     function testInNewCase(query) {
       it(JSON.stringify(query), function() {
         test(query);
-      })
+      });
     };
 
     testInNewCase({a: 1});
@@ -129,8 +128,12 @@ function assertIfSkips(rawOp, query, expectedSkips) {
   expect(actualSkips).eql(expectedSkips);
 }
 
-function assertSkips(rawOp, query) { assertIfSkips(rawOp, query, true); };
-function assertNotSkips(rawOp, query) { assertIfSkips(rawOp, query, false); };
+function assertSkips(rawOp, query) {
+  assertIfSkips(rawOp, query, true);
+};
+function assertNotSkips(rawOp, query) {
+  assertIfSkips(rawOp, query, false);
+};
 
 function has(haystack, needle) {
   return haystack.indexOf(needle) !== -1;

package/.npmignore

@@ -1,4 +0,0 @@
-*.swp
-*.DS_Store
-node_modules
-coverage

package/.travis.yml

@@ -1,27 +0,0 @@
-language: node_js
-
-node_js:
-  - "6"
-  - "8"
-  - "10"
-
-services:
-  - docker
-
-env:
-  - MONGODB_VERSION="2.6"
-  - MONGODB_VERSION="3.6"
-  - MONGODB_VERSION="4.0"
-
-before_install:
-  - docker run -d -p 127.0.0.1:27017:27017 mongo:$MONGODB_VERSION
-
-before_script:
-  - until nc -z localhost 27017; do echo Waiting for MongoDB; sleep 1; done
-
-script:
-  - npm run test-cover
-
-# Send coverage data to Coveralls
-after_script:
-  - cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js