sharedb 7.0.0 → 7.0.2

package/test/middleware.js

@@ -519,6 +519,156 @@ describe('middleware', function() {
     });
   });
 
+  describe('retry', function() {
+    var backend;
+    var doc;
+    var remoteDoc;
+
+    beforeEach(function(done) {
+      backend = this.backend;
+      doc = backend.connect().get('dogs', 'fido');
+      remoteDoc = backend.connect().get('dogs', 'fido');
+      doc.create({age: 3}, function(error) {
+        if (error) return done(error);
+        remoteDoc.fetch(done);
+      });
+    });
+
+    // Holds both ops in 'commit' until they've been applied to the same snapshot,
+    // then commits the remote op first, so the local op loses the race and retries
+    function forceRetry(callback) {
+      var commitDoc;
+      var commitRemoteDoc;
+      backend.use('commit', function(request, next) {
+        if (commitDoc && commitRemoteDoc) return next();
+        if (request.op.src === doc.connection.id) commitDoc = next;
+        else commitRemoteDoc = next;
+        if (commitDoc && commitRemoteDoc) commitRemoteDoc();
+      });
+
+      remoteDoc.submitOp([{p: ['age'], na: 7}], function(error) {
+        if (error) return callback(error);
+        commitDoc();
+      });
+      doc.submitOp([{p: ['age'], na: 2}], callback);
+    }
+
+    it('is triggered between a lost commit and the next attempt', function(done) {
+      var actions = [];
+      ['submit', 'apply', 'commit', 'retry', 'afterWrite'].forEach(function(action) {
+        backend.use(action, function(request, next) {
+          if (request.op.src === doc.connection.id) actions.push(action);
+          next();
+        });
+      });
+
+      forceRetry(function(error) {
+        if (error) return done(error);
+        expect(actions).to.eql(['submit', 'apply', 'commit', 'retry', 'apply', 'commit', 'afterWrite']);
+        expect(doc.data).to.eql({age: 12});
+        done();
+      });
+    });
+
+    it('has the number of retries so far', function(done) {
+      var retries = [];
+      backend.use('retry', function(request, next) {
+        retries.push(request.retries);
+        next();
+      });
+
+      forceRetry(function(error) {
+        if (error) return done(error);
+        expect(retries).to.eql([1]);
+        done();
+      });
+    });
+
+    it('is triggered after the failed attempt is reset', function(done) {
+      backend.use('apply', function(request, next) {
+        if (request.op.src === doc.connection.id && !request.retries) {
+          request.$fixup([{p: ['age'], na: 1}]);
+        }
+        next();
+      });
+      var retryRequest;
+      backend.use('retry', function(request, next) {
+        retryRequest = {
+          op: request.op.op,
+          fixup: request.op.m.fixup,
+          snapshot: request.snapshot,
+          channels: request.channels
+        };
+        next();
+      });
+
+      forceRetry(function(error) {
+        if (error) return done(error);
+        expect(retryRequest).to.eql({
+          op: [{p: ['age'], na: 2}],
+          fixup: undefined,
+          snapshot: null,
+          channels: null
+        });
+        done();
+      });
+    });
+
+    it('lets middleware reset state before the next attempt', function(done) {
+      var snapshotsBeforeApply = [];
+      backend.use('apply', function(request, next) {
+        if (request.op.src !== doc.connection.id) return next();
+        if (!request.snapshotBeforeApply) {
+          request.snapshotBeforeApply = JSON.parse(JSON.stringify(request.snapshot.data));
+        }
+        snapshotsBeforeApply.push(request.snapshotBeforeApply);
+        next();
+      });
+      backend.use('retry', function(request, next) {
+        delete request.snapshotBeforeApply;
+        next();
+      });
+
+      forceRetry(function(error) {
+        if (error) return done(error);
+        expect(snapshotsBeforeApply).to.eql([{age: 3}, {age: 10}]);
+        done();
+      });
+    });
+
+    it('is not triggered if the op commits first time', function(done) {
+      var retry = sinon.spy(function(_request, next) {
+        next();
+      });
+      backend.use('retry', retry);
+
+      doc.submitOp([{p: ['age'], na: 2}], function(error) {
+        if (error) return done(error);
+        expect(retry).not.to.have.been.called;
+        done();
+      });
+    });
+
+    it('is not triggered once the op has used up its retries', function(done) {
+      backend.maxSubmitRetries = 0;
+      var retry = sinon.spy(function(_request, next) {
+        next();
+      });
+      backend.use('retry', retry);
+
+      forceRetry(function(error) {
+        expect(error.code).to.equal(ERROR_CODE.ERR_MAX_SUBMIT_RETRIES_EXCEEDED);
+        expect(retry).not.to.have.been.called;
+        done();
+      });
+    });
+
+    it('rejects the op with an error passed to next', function(done) {
+      backend.use('retry', passError);
+      forceRetry(getErrorTest(done));
+    });
+  });
+
   describe('$fixup', function() {
     var connection;
     var backend;

package/test/pubsub-memory.js

@@ -74,6 +74,81 @@ describe('PubSub base class', function() {
     });
   });
 
+  it('stays subscribed when the last stream is destroyed just after a subscribe', function(done) {
+    var pubsub = new PubSub();
+    pubsub._subscribe = sinon.spy(function(channel, callback) {
+      callback();
+    });
+    pubsub._unsubscribe = sinon.spy(function(channel, callback) {
+      callback();
+    });
+    pubsub.subscribe('x', function(err, lastStream) {
+      if (err) return done(err);
+      pubsub.subscribe('x', function(err) {
+        if (err) return done(err);
+        expect(pubsub._unsubscribe).not.to.have.been.called;
+        expect(pubsub._subscribe).to.have.been.calledOnce;
+        expect(pubsub.subscribed.x).to.equal(true);
+        expect(pubsub.streamsCount).to.equal(1);
+        done();
+      });
+      lastStream.destroy();
+    });
+  });
+
+  it('waits for an in-flight _unsubscribe before calling _subscribe', function(done) {
+    var pubsub = new PubSub();
+    var finishUnsubscribe;
+    pubsub._subscribe = sinon.spy(function(channel, callback) {
+      callback();
+    });
+    pubsub._unsubscribe = function(channel, callback) {
+      finishUnsubscribe = callback;
+    };
+    pubsub.subscribe('x', function(err, stream) {
+      if (err) return done(err);
+      stream.destroy();
+      var resubscribed = 0;
+      function onResubscribe(err) {
+        if (err) return done(err);
+        if (++resubscribed < 2) return;
+        expect(pubsub._subscribe).to.have.been.calledTwice;
+        expect(pubsub.streamsCount).to.equal(2);
+        done();
+      }
+      pubsub.subscribe('x', onResubscribe);
+      pubsub.subscribe('x', onResubscribe);
+      expect(pubsub._subscribe).to.have.been.calledOnce;
+      finishUnsubscribe();
+    });
+  });
+
+  it('subscribes before throwing an unhandled in-flight _unsubscribe error', function(done) {
+    var pubsub = new PubSub();
+    var finishUnsubscribe;
+    pubsub._subscribe = function(channel, callback) {
+      callback();
+    };
+    pubsub._unsubscribe = function(channel, callback) {
+      finishUnsubscribe = callback;
+    };
+    pubsub.subscribe('x', function(err, stream) {
+      if (err) return done(err);
+      stream.destroy();
+      var resubscribed = false;
+      pubsub.subscribe('x', function(err) {
+        if (err) return done(err);
+        resubscribed = true;
+      });
+      expect(function() {
+        finishUnsubscribe(new Error('unsubscribe failed'));
+      }).to.throw('unsubscribe failed');
+      expect(resubscribed).to.equal(true);
+      expect(pubsub.subscribed.x).to.equal(true);
+      done();
+    });
+  });
+
   it('emits an error if _unsubscribe is unimplemented', function(done) {
     var pubsub = new PubSub();
     pubsub._subscribe = function(channel, callback) {

package/test/pubsub.js

@@ -105,6 +105,38 @@ module.exports = function(create) {
       });
     });
 
+    it('can resubscribe to a channel straight after destroying its last stream', function(done) {
+      var pubsub = this.pubsub;
+      pubsub.subscribe('x', function(err, stream) {
+        if (err) return done(err);
+        stream.destroy();
+        pubsub.subscribe('x', function(err, stream) {
+          if (err) return done(err);
+          stream.on('data', function(data) {
+            expect(data).eql({test: true});
+            done();
+          });
+          pubsub.publish(['x'], {test: true});
+        });
+      });
+    });
+
+    it('can subscribe to a channel just before its last stream is destroyed', function(done) {
+      var pubsub = this.pubsub;
+      pubsub.subscribe('x', function(err, lastStream) {
+        if (err) return done(err);
+        pubsub.subscribe('x', function(err, stream) {
+          if (err) return done(err);
+          stream.on('data', function(data) {
+            expect(data).eql({test: true});
+            done();
+          });
+          pubsub.publish(['x'], {test: true});
+        });
+        lastStream.destroy();
+      });
+    });
+
     it('stream.destroy() unsubscribes from a channel', function(done) {
       var pubsub = this.pubsub;
       pubsub.subscribe('x', function(err, stream) {