sharedb 3.2.4 → 3.3.1

package/test/client/submit.js

@@ -4,6 +4,7 @@ var sinon = require('sinon');
 var types = require('../../lib/types');
 var deserializedType = require('./deserialized-type');
 var numberType = require('./number-type');
+var errorHandler = require('../util').errorHandler;
 types.register(deserializedType.type);
 types.register(deserializedType.type2);
 types.register(numberType.type);
@@ -1210,5 +1211,52 @@ module.exports = function() {
         });
       });
     });
+
+    describe('submitting when behind the server', function() {
+      var doc;
+      var remoteDoc;
+
+      beforeEach(function(done) {
+        var connection = this.backend.connect();
+        doc = connection.get('dogs', 'fido');
+        var remoteConnection = this.backend.connect();
+        remoteDoc = remoteConnection.get('dogs', 'fido');
+
+        async.series([
+          doc.create.bind(doc, {name: 'fido'}),
+          remoteDoc.fetch.bind(remoteDoc),
+          remoteDoc.submitOp.bind(remoteDoc, [{p: ['tricks'], oi: ['fetch']}]),
+          function(next) {
+            expect(doc.data).to.eql({name: 'fido'});
+            expect(remoteDoc.data).to.eql({name: 'fido', tricks: ['fetch']});
+            next();
+          }
+        ], done);
+      });
+
+      it('is sent ops it has missed when submitting, without calling fetch', function(done) {
+        sinon.spy(doc, 'fetch');
+
+        doc.submitOp([{p: ['age'], oi: 2}], errorHandler(done));
+
+        doc.once('op', function() {
+          expect(doc.data).to.eql({name: 'fido', tricks: ['fetch'], age: 2});
+          expect(doc.fetch.called).to.be.false;
+          done();
+        });
+      });
+
+      it('does not expose op metadata in the middleware when sending missing ops', function(done) {
+        this.backend.use('apply', function(request) {
+          expect(request.ops).to.have.length(1);
+          var op = request.ops[0];
+          expect(op.op).to.eql([{p: ['tricks'], oi: ['fetch']}]);
+          expect(op.m).to.be.undefined;
+          done();
+        });
+
+        doc.submitOp([{p: ['age'], oi: 2}], errorHandler(done));
+      });
+    });
   });
 };

package/test/logger.js

@@ -8,10 +8,6 @@ describe('Logger', function() {
       sinon.stub(console, 'warn');
     });
 
-    afterEach(function() {
-      sinon.restore();
-    });
-
     it('logs to console by default', function() {
       var logger = new Logger();
       logger.warn('warning');

package/test/middleware.js

@@ -3,6 +3,11 @@ var expect = require('chai').expect;
 var util = require('./util');
 var types = require('../lib/types');
 var errorHandler = util.errorHandler;
+var ShareDBError = require('../lib/error');
+var sinon = require('sinon');
+var ACTIONS = require('../lib/message-actions').ACTIONS;
+
+var ERROR_CODE = ShareDBError.CODES;
 
 describe('middleware', function() {
   beforeEach(function() {
@@ -417,4 +422,355 @@ describe('middleware', function() {
       doc.submitOp([{p: ['tricks', 1], li: 'stay'}], {source: 'c'}, errorHandler(done));
     });
   });
+
+  describe('$fixup', function() {
+    var connection;
+    var backend;
+    var doc;
+
+    beforeEach(function(done) {
+      backend = this.backend;
+      connection = backend.connect();
+      doc = connection.get('dogs', 'fido');
+
+      doc.create({name: 'fido'}, done);
+    });
+
+    it('applies a fixup op to the client that submitted it', function(done) {
+      backend.use('apply', function(request, next) {
+        request.$fixup([{p: ['tricks', 1], li: 'stay'}]);
+        next();
+      });
+
+      doc.submitOp([{p: ['tricks'], oi: ['fetch']}], function(error) {
+        if (error) return done(error);
+        expect(doc.data.tricks).to.eql(['fetch', 'stay']);
+        expect(doc.version).to.equal(2);
+        done();
+      });
+    });
+
+    it('emits an op event for the fixup', function(done) {
+      backend.use('apply', function(request, next) {
+        request.$fixup([{p: ['tricks', 1], li: 'stay'}]);
+        next();
+      });
+
+      doc.submitOp([{p: ['tricks'], oi: ['fetch']}], errorHandler(done));
+
+      doc.on('op', function() {
+        expect(doc.data.tricks).to.eql(['fetch', 'stay']);
+        done();
+      });
+    });
+
+    it('passes the fixed up op to future middleware', function(done) {
+      backend.use('apply', function(request, next) {
+        request.$fixup([{p: ['tricks', 1], li: 'stay'}]);
+        next();
+      });
+
+      backend.use('apply', function(request, next) {
+        expect(request.op.op).to.eql([
+          {p: ['tricks'], oi: ['fetch']},
+          {p: ['tricks', 1], li: 'stay'}
+        ]);
+        next();
+      });
+
+      doc.submitOp([{p: ['tricks'], oi: ['fetch']}], done);
+    });
+
+    it('applies the composed op to a remote client', function(done) {
+      backend.use('apply', function(request, next) {
+        request.$fixup([{p: ['tricks', 1], li: 'stay'}]);
+        next();
+      });
+
+      var remoteConnection = backend.connect();
+      var remoteDoc = remoteConnection.get('dogs', 'fido');
+
+      remoteDoc.subscribe(function(error) {
+        if (error) return done(error);
+
+        expect(remoteDoc.data).to.eql({name: 'fido'});
+
+        remoteDoc.on('op batch', function() {
+          expect(remoteDoc.data.tricks).to.eql(['fetch', 'stay']);
+          expect(doc.version).to.equal(remoteDoc.version);
+          done();
+        });
+
+        doc.submitOp([{p: ['tricks'], oi: ['fetch']}], errorHandler(done));
+      });
+    });
+
+    it('transforms pending ops by the fixup for remote clients', function(done) {
+      var applied = false;
+      backend.use('apply', function(request, next) {
+        if (applied) return next();
+        applied = true;
+        request.$fixup([{p: ['tricks', 0], li: 'stay'}]);
+        next();
+      });
+
+      var remoteConnection = backend.connect();
+      var remoteDoc = remoteConnection.get('dogs', 'fido');
+
+      remoteDoc.subscribe(function(error) {
+        if (error) return done(error);
+
+        expect(remoteDoc.data).to.eql({name: 'fido'});
+
+        remoteDoc.on('op batch', function() {
+          if (remoteDoc.version !== 3) return;
+          expect(remoteDoc.data.tricks).to.eql(['stay', 'fetch', 'sit']);
+          expect(remoteDoc.data).to.eql(doc.data);
+          done();
+        });
+
+        doc.preventCompose = true;
+        doc.submitOp([{p: ['tricks'], oi: ['fetch']}], errorHandler(done));
+        doc.submitOp([{p: ['tricks', 1], li: 'sit'}], errorHandler(done));
+      });
+    });
+
+    it('transforms pending ops by the fixup for the local doc', function(done) {
+      var applied = false;
+      backend.use('apply', function(request, next) {
+        if (applied) return next();
+        applied = true;
+        request.$fixup([{p: ['tricks', 0, 0], si: 'go '}]);
+        next();
+      });
+
+      var remoteConnection = backend.connect();
+      var remoteDoc = remoteConnection.get('dogs', 'fido');
+
+      remoteDoc.subscribe(function(error) {
+        if (error) return done(error);
+
+        expect(remoteDoc.data).to.eql({name: 'fido'});
+
+        remoteDoc.on('op batch', function() {
+          if (remoteDoc.version !== 3) return;
+          expect(remoteDoc.data.tricks).to.eql(['stay', 'go fetch']);
+          expect(remoteDoc.data).to.eql(doc.data);
+          done();
+        });
+
+        doc.preventCompose = true;
+        doc.submitOp([{p: ['tricks'], oi: ['fetch', 'stay']}], errorHandler(done));
+        doc.submitOp([{p: ['tricks', 0], lm: 1}], errorHandler(done));
+      });
+    });
+
+    it('applies a fixup to a creation op', function(done) {
+      backend.use('apply', function(request, next) {
+        request.$fixup([{p: ['goodBoy'], oi: true}]);
+        next();
+      });
+
+      doc = connection.get('dogs', 'rover');
+      doc.create({name: 'rover'}, function(error) {
+        if (error) return done(error);
+        expect(doc.data.goodBoy).to.be.true;
+        done();
+      });
+    });
+
+    it('throws an error if trying to fixup a deletion', function(done) {
+      backend.use('apply', function(request, next) {
+        var error;
+        try {
+          request.$fixup([{p: ['tricks', 0], oi: ['stay']}]);
+        } catch (e) {
+          error = e;
+        }
+        next(error);
+      });
+
+      doc.del(function(error) {
+        expect(error.code).to.equal(ERROR_CODE.ERR_CANNOT_FIXUP_DELETION);
+        done();
+      });
+    });
+
+    it('throws an error if trying to fixup in commit middleware', function(done) {
+      backend.use('commit', function(request, next) {
+        var error;
+        try {
+          request.$fixup([{p: ['tricks', 0], oi: ['stay']}]);
+        } catch (e) {
+          error = e;
+        }
+        next(error);
+      });
+
+      doc.submitOp([{p: ['goodBoy'], oi: true}], function(error) {
+        expect(error.code).to.equal(ERROR_CODE.ERR_FIXUP_IS_ONLY_VALID_ON_APPLY);
+        done();
+      });
+    });
+
+    it('retry fixup', function(done) {
+      var flush;
+      backend.use('apply', function(request, next) {
+        expect(request.op.m.fixup).to.be.undefined;
+        if (flush) return next();
+        flush = function() {
+          request.$fixup([{p: ['name', 0], si: 'fixup'}]);
+          next();
+        };
+      });
+
+      doc.subscribe(function(error) {
+        if (error) return done(error);
+
+        var remoteConnection = backend.connect();
+        var remoteDoc = remoteConnection.get('dogs', 'fido');
+
+        doc.submitOp([{p: ['name', 0], si: 'foo'}], function(error) {
+          if (error) return done(error);
+          expect(doc.data).to.eql({});
+          done();
+        });
+
+        remoteDoc.subscribe(function(error) {
+          if (error) return done(error);
+          remoteDoc.submitOp([{p: ['name'], od: 'fido'}], errorHandler(done));
+        });
+
+        doc.once('op', function(op, source) {
+          if (source) return;
+          expect(doc.data).to.eql({});
+          flush();
+        });
+      });
+    });
+
+    it('fixup that ignores no-op', function(done) {
+      var flush;
+      backend.use('apply', function(request, next) {
+        if (request.op.src !== connection.id) return next();
+        if (flush) {
+          request.$fixup([{p: ['name'], oi: 'fixup'}]);
+          return next();
+        }
+        flush = function() {
+          request.$fixup([{p: ['name', 0], si: 'fixup'}]);
+          next();
+        };
+      });
+
+      doc.subscribe(function(error) {
+        if (error) return done(error);
+
+        var remoteConnection = backend.connect();
+        var remoteDoc = remoteConnection.get('dogs', 'fido');
+
+        var count = 0;
+        var callback = function() {
+          count++;
+          if (count !== 2) return;
+          expect(doc.data).to.eql({name: 'fixup'});
+          expect(remoteDoc.data).to.eql(doc.data);
+          expect(doc.version).to.equal(remoteDoc.version);
+          done();
+        };
+
+        doc.submitOp([{p: ['name', 0], si: 'foo'}], function(error) {
+          if (error) return done(error);
+          callback();
+        });
+
+        remoteDoc.on('op', function(op, source) {
+          if (source) return;
+          callback();
+        });
+
+        remoteDoc.subscribe(function(error) {
+          if (error) return done(error);
+          remoteDoc.submitOp([{p: ['name'], od: 'fido'}], errorHandler(done));
+        });
+
+        doc.once('op', function(op, source) {
+          if (source) return;
+          expect(doc.data).to.eql({});
+          flush();
+        });
+      });
+    });
+
+    it('applies two fixups', function(done) {
+      backend.use('apply', function(request, next) {
+        request.$fixup([{p: ['tricks', 0], li: 'sit'}]);
+        next();
+      });
+
+      backend.use('apply', function(request, next) {
+        request.$fixup([{p: ['tricks', 0], li: 'stay'}]);
+        next();
+      });
+
+      doc.submitOp([{p: ['tricks'], oi: ['fetch']}], function(error) {
+        if (error) return done(error);
+        expect(doc.data.tricks).to.eql(['stay', 'sit', 'fetch']);
+        done();
+      });
+    });
+
+    it('rolls the doc back if the fixup cannot be applied', function(done) {
+      backend.use('apply', function(request, next) {
+        request.$fixup([{p: ['stay'], oi: true}]);
+        next();
+      });
+
+      backend.use('reply', function(request, next) {
+        if (request.reply[ACTIONS.fixup]) {
+          // Deliberately overwrite our fixup op to trigger a client rollback
+          request.reply[ACTIONS.fixup][0].op = [{p: ['fetch'], ld: 'bad'}];
+        }
+        next();
+      });
+
+      sinon.spy(doc, 'fetch');
+
+      doc.submitOp([{p: ['fetch'], oi: true}], function(error) {
+        expect(error).to.be.ok;
+        expect(doc.fetch.calledOnce).to.be.true;
+        done();
+      });
+    });
+
+    describe('no compose', function() {
+      var originalCompose;
+
+      beforeEach(function() {
+        originalCompose = types.defaultType.compose;
+        delete types.defaultType.compose;
+      });
+
+      afterEach(function() {
+        types.defaultType.compose = originalCompose.bind(types.defaultType);
+      });
+
+      it('throws an error if trying to compose on a type that does not support it', function(done) {
+        backend.use('apply', function(request, next) {
+          var error;
+          try {
+            request.$fixup([{p: ['tricks', 0], oi: ['stay']}]);
+          } catch (e) {
+            error = e;
+          }
+          next(error);
+        });
+
+        doc.submitOp([{p: ['goodBoy'], oi: true}], function(error) {
+          expect(error.code).to.equal(ERROR_CODE.ERR_TYPE_DOES_NOT_SUPPORT_COMPOSE);
+          done();
+        });
+      });
+    });
+  });
 });

package/test/milestone-db.js

@@ -576,8 +576,10 @@ module.exports = function(options) {
       });
 
       it('only stores even-numbered versions', function(done) {
-        db.on('save', function(collection, snapshot) {
-          if (snapshot.v !== 4) return;
+        var snapshotCount = 0;
+        db.on('save', function() {
+          snapshotCount++;
+          if (snapshotCount < 2) return;
 
           async.waterfall([
             db.getMilestoneSnapshot.bind(db, 'books', 'catcher-in-the-rye', 1),
@@ -619,8 +621,10 @@ module.exports = function(options) {
           callback();
         });
 
-        db.on('save', function(collection, snapshot) {
-          if (snapshot.v !== 4) return;
+        var snapshotCount = 0;
+        db.on('save', function() {
+          snapshotCount++;
+          if (snapshotCount < 2) return;
 
           async.waterfall([
             db.getMilestoneSnapshot.bind(db, 'books', 'catcher-in-the-rye', 1),

package/test/setup.js

@@ -1,4 +1,5 @@
 var logger = require('../lib/logger');
+var sinon = require('sinon');
 
 if (process.env.LOGGING !== 'true') {
   // Silence the logger for tests by setting all its methods to no-ops
@@ -8,3 +9,7 @@ if (process.env.LOGGING !== 'true') {
     error: function() {}
   });
 }
+
+afterEach(function() {
+  sinon.restore();
+});