sharedb 7.0.0 → 7.0.2

package/test/client/presence/doc-presence.js

@@ -585,20 +585,595 @@ describe('DocPresence', function() {
     connection1.send(message);
   });
 
+  it('rejects a presence message with a non-integer version', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    localPresence1.on('error', function(error) {
+      expect(error.code).to.eql('ERR_MESSAGE_BADLY_FORMED');
+      done();
+    });
+
+    var message = localPresence1._message();
+    message.v = 1.5;
+    message.t = presenceTestType.type.uri;
+    connection1.send(message);
+  });
+
+  it('rejects a presence message without a version', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    localPresence1.on('error', function(error) {
+      expect(error.code).to.eql('ERR_MESSAGE_BADLY_FORMED');
+      done();
+    });
+
+    var message = localPresence1._message();
+    message.t = presenceTestType.type.uri;
+    connection1.send(message);
+  });
+
+  [
+    {description: 'without doc coordinates', c: undefined, d: undefined},
+    {description: 'for another doc', c: 'books', d: 'subtle-knife'}
+  ].forEach(function(test) {
+    it('ignores remote presence on its channel ' + test.description, function(done) {
+      sinon.spy(doc2, 'fetch');
+
+      [doc2.version, doc2.version + 1].forEach(function(version, index) {
+        var message = presence1.create('presence-' + index)._message();
+        message.c = test.c;
+        message.d = test.d;
+        message.p = {index: 1};
+        message.v = version;
+        message.t = presenceTestType.type.uri;
+        connection2.handleMessage(message);
+      });
+
+      doc2.whenNothingPending(function() {
+        expect(presence2.remotePresences).to.be.empty;
+        expect(presence2._remotePresenceInstances).to.be.empty;
+        expect(doc2.fetch).not.to.have.been.called;
+        done();
+      });
+    });
+  });
+
+  it('rejects presence whose version is ahead of the doc', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    presence2.on('receive', function() {
+      done(new Error('Should not broadcast presence from the future'));
+    });
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.on('error', function(error) {
+          expect(error.code).to.equal('ERR_OP_VERSION_NEWER_THAN_CURRENT_SNAPSHOT');
+          expect(connection1.agent.presenceRequests[presence1.channel]['presence-1'].p).to.be.null;
+          next();
+        });
+
+        var message = localPresence1._message();
+        message.p = {index: 1};
+        message.v = doc1.version + 1;
+        message.t = presenceTestType.type.uri;
+        connection1.send(message);
+      }
+    ], done);
+  });
+
+  it('rejects presence ahead of a tracked doc', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      localPresence1.submit.bind(localPresence1, {index: 1}),
+      function(next) {
+        localPresence1.on('error', function(error) {
+          expect(error.code).to.equal('ERR_OP_VERSION_NEWER_THAN_CURRENT_SNAPSHOT');
+          next();
+        });
+
+        var message = localPresence1._message();
+        message.p = {index: 1};
+        message.v = doc1.version + 1;
+        message.t = presenceTestType.type.uri;
+        connection1.send(message);
+      }
+    ], done);
+  });
+
+  it('rejects presence ahead of a tracked doc after ops to a doc on the same channel', function(done) {
+    var notesDoc1 = connection1.get('notes', 'private.alice');
+    var diaryDoc1 = connection1.get('notes.private', 'alice');
+    var diaryDoc2 = connection2.get('notes.private', 'alice');
+    var localNotesPresence1 = connection1.getDocPresence('notes', 'private.alice').create('notes-presence');
+
+    async.series([
+      notesDoc1.create.bind(notesDoc1, 'Hello', presenceTestType.type.name),
+      localNotesPresence1.submit.bind(localNotesPresence1, {index: 1}),
+      diaryDoc2.create.bind(diaryDoc2, 'Dear diary', presenceTestType.type.name),
+      diaryDoc1.subscribe.bind(diaryDoc1),
+      function(next) {
+        diaryDoc1.once('op', function() {
+          next();
+        });
+        diaryDoc2.submitOp({index: 0, value: 'Oh, '}, errorHandler(done));
+      },
+      function(next) {
+        localNotesPresence1.on('error', function(error) {
+          expect(error.code).to.equal('ERR_OP_VERSION_NEWER_THAN_CURRENT_SNAPSHOT');
+          next();
+        });
+
+        expect(diaryDoc2.version).to.be.above(notesDoc1.version);
+        var message = localNotesPresence1._message();
+        message.p = {index: 1};
+        message.v = diaryDoc2.version;
+        message.t = presenceTestType.type.uri;
+        connection1.send(message);
+      }
+    ], done);
+  });
+
+  it('does not read the snapshot for presence after its own client\'s op', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 1}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        doc2.once('op', function() {
+          next();
+        });
+        doc1.submitOp({index: 0, value: 'The '}, errorHandler(done));
+      },
+      function(next) {
+        sinon.spy(backend.db, 'getSnapshot');
+        localPresence1.submit({index: 6}, errorHandler(done));
+        presence2.once('receive', function(id, presence) {
+          expect(presence).to.eql({index: 6});
+          expect(backend.db.getSnapshot).not.to.have.been.called;
+          next();
+        });
+      }
+    ], done);
+  });
+
+  it('does not read the snapshot for presence at the tracked doc version', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 1}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        sinon.spy(backend.db, 'getSnapshot');
+        localPresence1.submit({index: 2}, errorHandler(done));
+        presence2.once('receive', function(id, presence) {
+          expect(presence).to.eql({index: 2});
+          expect(backend.db.getSnapshot).not.to.have.been.called;
+          next();
+        });
+      }
+    ], done);
+  });
+
+  it('clamps a leave ahead of the doc to the doc version', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    localPresence1.on('error', done);
+    sinon.spy(doc2, 'fetch');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.be.null;
+          expect(connection1.agent.presenceRequests[presence1.channel]['presence-1'].v).to.equal(doc1.version);
+          expect(doc2.fetch).not.to.have.been.called;
+          next();
+        });
+
+        var leave = localPresence1._message();
+        leave.p = null;
+        leave.v = doc1.version + 1;
+        leave.t = presenceTestType.type.uri;
+        connection1.send(leave);
+      }
+    ], done);
+  });
+
+  it('broadcasts null presence on disconnect after rejecting presence ahead of the doc', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence1.subscribe.bind(presence1),
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 1}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        localPresence1.once('error', function(error) {
+          expect(error.code).to.equal('ERR_OP_VERSION_NEWER_THAN_CURRENT_SNAPSHOT');
+          next();
+        });
+
+        var message = localPresence1._message();
+        message.v = doc1.version + 1;
+        message.t = presenceTestType.type.uri;
+        connection1.send(message);
+      },
+      function(next) {
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.be.null;
+          next();
+        });
+        connection1.close();
+      }
+    ], done);
+  });
+
+  it('accepts up-to-date presence when the agent\'s tracked doc version lags behind', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 1}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        doc1.submitOp({index: 5, value: 'ern'}, errorHandler(done));
+        doc2.once('op', function() {
+          next();
+        });
+      },
+      function(next) {
+        connection1.agent.latestDocVersions.books['northern-lights'] = 1;
+        localPresence1.submit({index: 12}, errorHandler(done));
+        presence2.once('receive', function(id, presence) {
+          expect(doc2.version).to.eql(2);
+          expect(presence).to.eql({index: 12});
+          next();
+        });
+      }
+    ], done);
+  });
+
+  it('transforms presence ahead of the agent\'s lagging tracked doc version by later ops', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 1}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        doc1.submitOp({index: 5, value: 'ern'}, errorHandler(done));
+        doc2.once('op', function() {
+          next();
+        });
+      },
+      function(next) {
+        doc2.submitOp({index: 0, value: 'The '}, errorHandler(done));
+        doc1.once('op', function() {
+          next();
+        });
+      },
+      function(next) {
+        connection1.agent.latestDocVersions.books['northern-lights'] = 1;
+        presence2.once('receive', function(id, presence) {
+          expect(presence).to.eql({index: 16});
+          next();
+        });
+
+        var message = localPresence1._message();
+        message.p = {index: 12};
+        message.v = 2;
+        message.t = presenceTestType.type.uri;
+        connection1.send(message);
+      }
+    ], done);
+  });
+
+  it('rejects presence ahead of the doc when transformed without a tracked version', function(done) {
+    var presence = {
+      c: 'books',
+      d: 'northern-lights',
+      p: {index: 1},
+      v: doc1.version + 1,
+      t: presenceTestType.type.uri
+    };
+    backend.transformPresenceToLatestVersion(connection1.agent, presence, function(error) {
+      expect(error.code).to.equal('ERR_OP_VERSION_NEWER_THAN_CURRENT_SNAPSHOT');
+      done();
+    });
+  });
+
   it('rejects a presence message without an ID', function(done) {
     var localPresence1 = presence1.create('presence-1');
-    // Have to catch the error on the Presence instance, because obviously
-    // we won't find the LocalPresence without the ID
-    presence1.on('error', function(error) {
-      expect(error.code).to.eql('ERR_MESSAGE_BADLY_FORMED');
-      done();
+    // Have to catch the error on the Presence instance, because obviously
+    // we won't find the LocalPresence without the ID
+    presence1.on('error', function(error) {
+      expect(error.code).to.eql('ERR_MESSAGE_BADLY_FORMED');
+      done();
+    });
+
+    var message = localPresence1._message();
+    message.id = null;
+    message.v = 1;
+    message.t = presenceTestType.type.uri;
+    connection1.send(message);
+  });
+
+  it('rejects a presence message for a different doc than its channel', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    localPresence1.on('error', function(error) {
+      expect(error.code).to.eql('ERR_MESSAGE_BADLY_FORMED');
+      expect(error.message).to.equal('Presence collection and doc ID do not match channel');
+      done();
+    });
+
+    var message = localPresence1._message();
+    message.d = 'subtle-knife';
+    message.v = 1;
+    message.t = presenceTestType.type.uri;
+    connection1.send(message);
+  });
+
+  it('rejects a presence message with a doc ID but no collection', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    localPresence1.on('error', function(error) {
+      expect(error.code).to.eql('ERR_MESSAGE_BADLY_FORMED');
+      done();
+    });
+
+    var message = localPresence1._message();
+    message.c = null;
+    message.v = 1;
+    message.t = presenceTestType.type.uri;
+    connection1.send(message);
+  });
+
+  it('rejects a presence message with a collection but no doc ID', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    localPresence1.on('error', function(error) {
+      expect(error.code).to.eql('ERR_MESSAGE_BADLY_FORMED');
+      done();
+    });
+
+    var message = localPresence1._message();
+    message.d = null;
+    message.v = 1;
+    message.t = presenceTestType.type.uri;
+    connection1.send(message);
+  });
+
+  it('rejects a presence message with an empty collection', function(done) {
+    var localPresence1 = connection1.getDocPresence('', 'northern-lights').create('presence-1');
+    localPresence1.on('error', function(error) {
+      expect(error.code).to.eql('ERR_MESSAGE_BADLY_FORMED');
+      done();
+    });
+
+    var message = localPresence1._message();
+    message.v = 1;
+    message.t = presenceTestType.type.uri;
+    connection1.send(message);
+  });
+
+  it('rejects a presence message with an empty doc ID', function(done) {
+    var localPresence1 = connection1.getDocPresence('books', '').create('presence-1');
+    localPresence1.on('error', function(error) {
+      expect(error.code).to.eql('ERR_MESSAGE_BADLY_FORMED');
+      done();
+    });
+
+    var message = localPresence1._message();
+    message.v = 1;
+    message.t = presenceTestType.type.uri;
+    connection1.send(message);
+  });
+
+  it('rejects presence on a doc the client cannot read', function(done) {
+    backend.use(backend.MIDDLEWARE_ACTIONS.readSnapshots, function(context, next) {
+      next(new Error('Forbidden'));
+    });
+
+    var localPresence1 = presence1.create('presence-1');
+    localPresence1.submit({index: 1}, function(error) {
+      expect(error.message).to.equal('Forbidden');
+      done();
+    });
+  });
+
+  it('clears presence when a client that has lost read access disconnects', function(done) {
+    var agent1 = connection1.agent;
+    var canRead = true;
+    [backend.MIDDLEWARE_ACTIONS.readSnapshots, backend.MIDDLEWARE_ACTIONS.op].forEach(function(action) {
+      backend.use(action, function(context, next) {
+        if (canRead || context.agent !== agent1) return next();
+        next(new Error('Forbidden'));
+      });
+    });
+    var localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 1}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        doc2.submitOp({index: 5, value: 'ern'}, errorHandler(done));
+        doc1.once('op', function() {
+          next();
+        });
+      },
+      function(next) {
+        canRead = false;
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.be.null;
+          next();
+        });
+        connection1.close();
+      }
+    ], done);
+  });
+
+  it('ignores untyped presence on its channel', function(done) {
+    var connection3 = backend.connect();
+    var untypedPresence3 = connection3.getPresence('books.northern-lights');
+    var localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      untypedPresence3.subscribe.bind(untypedPresence3),
+      function(next) {
+        connection2.on('receive', function(request) {
+          if (request.data.src !== connection3.id) return;
+          localPresence1.submit({index: 1}, errorHandler(done));
+        });
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.eql({index: 1});
+          next();
+        });
+        connection3.send({
+          a: 'p', ch: 'books.northern-lights', id: 'presence-1', p: {index: 9}, pv: 0, v: doc1.version
+        });
+      }
+    ], done);
+  });
+
+  it('does not let untyped presence with the same ID ack its local presence', function(done) {
+    var connection3 = backend.connect();
+    var untypedPresence3 = connection3.getPresence('books.northern-lights');
+    var localPresence1 = presence1.create('presence-1');
+    var hasReceivedOwnPresence = false;
+
+    async.series([
+      presence1.subscribe.bind(presence1),
+      untypedPresence3.subscribe.bind(untypedPresence3),
+      function(next) {
+        connection1.on('receive', function(request) {
+          if (request.data.src === connection1.id) hasReceivedOwnPresence = true;
+          if (request.data.src !== connection3.id) return;
+          localPresence1.submit({index: 1}, function(error) {
+            if (error) return done(error);
+            expect(hasReceivedOwnPresence).to.be.true;
+            next();
+          });
+        });
+        connection3.send({
+          a: 'p', ch: 'books.northern-lights', id: 'presence-1', p: {index: 9}, pv: 0, v: doc1.version
+        });
+      }
+    ], done);
+  });
+
+  it('does not let typed presence from another client with the same ID ack its local presence', function(done) {
+    var connection3 = backend.connect();
+    var presence3 = connection3.getDocPresence('books', 'northern-lights');
+    var localPresence1 = presence1.create('presence-1');
+    var hasReceivedOwnPresence = false;
+
+    async.series([
+      presence1.subscribe.bind(presence1),
+      presence3.subscribe.bind(presence3),
+      function(next) {
+        connection1.on('receive', function(request) {
+          if (request.data.src === connection1.id) hasReceivedOwnPresence = true;
+          if (request.data.src !== connection3.id) return;
+          localPresence1.submit({index: 1}, function(error) {
+            if (error) return done(error);
+            expect(hasReceivedOwnPresence).to.be.true;
+            next();
+          });
+        });
+        connection3.send({
+          a: 'p',
+          ch: 'books.northern-lights',
+          c: 'books',
+          d: 'northern-lights',
+          t: presenceTestType.type.uri,
+          id: 'presence-1',
+          p: {index: 9},
+          pv: 0,
+          v: doc1.version
+        });
+      }
+    ], done);
+  });
+
+  it('emits a forwarded error for a presence with the same ID on the presence, not its local presence', function(done) {
+    backend.use(backend.MIDDLEWARE_ACTIONS.sendPresence, function(context, next) {
+      next(new Error('uh-oh!'));
     });
 
-    var message = localPresence1._message();
-    message.id = null;
-    message.v = 1;
-    message.t = presenceTestType.type.uri;
-    connection1.send(message);
+    var connection3 = backend.connect();
+    var doc3 = connection3.get('books', 'northern-lights');
+    var localPresence3 = connection3.getDocPresence('books', 'northern-lights').create('presence-1');
+    var localPresence1 = presence1.create('presence-1');
+    localPresence1.on('error', done);
+
+    async.series([
+      doc3.subscribe.bind(doc3),
+      presence1.subscribe.bind(presence1),
+      function(next) {
+        presence1.once('error', function(error) {
+          expect(error.message).to.equal('uh-oh!');
+          next();
+        });
+        localPresence3.submit({index: 1}, errorHandler(done));
+      }
+    ], done);
+  });
+
+  it('ignores presence for a doc whose collection and id join to the same channel', function(done) {
+    var connection3 = backend.connect();
+    var notesDoc1 = connection1.get('notes', 'private.alice');
+    var notesDoc3 = connection3.get('notes', 'private.alice');
+    var diaryDoc2 = connection2.get('notes.private', 'alice');
+    var localNotesPresence1 = connection1.getDocPresence('notes', 'private.alice').create('notes-presence');
+    var localDiaryPresence2 = connection2.getDocPresence('notes.private', 'alice').create('diary-presence');
+    var notesPresence3 = connection3.getDocPresence('notes', 'private.alice');
+
+    async.series([
+      notesDoc1.create.bind(notesDoc1, 'Hello', presenceTestType.type.name),
+      diaryDoc2.create.bind(diaryDoc2, 'Dear diary', presenceTestType.type.name),
+      notesDoc3.subscribe.bind(notesDoc3),
+      notesPresence3.subscribe.bind(notesPresence3),
+      function(next) {
+        notesPresence3.once('receive', function(id) {
+          expect(id).to.equal('notes-presence');
+          next();
+        });
+        localDiaryPresence2.submit({index: 1}, function(error) {
+          if (error) return done(error);
+          localNotesPresence1.submit({index: 1}, errorHandler(done));
+        });
+      }
+    ], done);
   });
 
   it('only sends presence responses for the associated doc', function(done) {
@@ -793,6 +1368,21 @@ describe('DocPresence', function() {
     ], done);
   });
 
+  it('does not keep presence when fetching its doc version fails', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    backend.use(backend.MIDDLEWARE_ACTIONS.readSnapshots, function(context, next) {
+      next(new Error('denied'));
+    });
+
+    localPresence1.submit({index: 1}, function(error) {
+      expect(error.message).to.contain('denied');
+      expect(connection1.agent.presenceRequests).to.be.empty;
+      expect(connection1.agent._pendingPresenceBroadcasts).to.be.empty;
+      done();
+    });
+  });
+
   it('errors when trying to submit presence on a type that does not support it', function(done) {
     var jsonDoc = connection1.get('books', 'snuff');
     var jsonPresence = connection1.getDocPresence('books', 'snuff');
@@ -976,12 +1566,19 @@ describe('DocPresence', function() {
     var localPresence1 = presence1.create('presence-1');
     var catchUpCount = 0;
 
-    function sendUntypedPresenceAtVersion(version) {
-      var message = localPresence1._message();
-      message.d = null;
-      message.p = {index: 0};
-      message.v = version;
-      connection1.send(message);
+    function receiveUntransformablePresenceAtVersion(version) {
+      connection2.handleMessage({
+        a: ACTIONS.presence,
+        ch: 'books.northern-lights',
+        src: connection1.id,
+        id: 'presence-1',
+        p: {index: 0},
+        pv: version,
+        c: 'books',
+        d: 'northern-lights',
+        v: version,
+        t: null
+      });
     }
 
     async.series([
@@ -992,7 +1589,7 @@ describe('DocPresence', function() {
           catchUpCount++;
           if (catchUpCount === 1) next();
         });
-        sendUntypedPresenceAtVersion(0);
+        receiveUntransformablePresenceAtVersion(0);
       },
       function(next) {
         doc2.once('op', function() {
@@ -1006,7 +1603,7 @@ describe('DocPresence', function() {
           expect(error.code).to.equal('ERR_DOC_TYPE_NOT_RECOGNIZED');
           next();
         });
-        sendUntypedPresenceAtVersion(1);
+        receiveUntransformablePresenceAtVersion(1);
       },
       function(next) {
         doc2.once('op', function() {
@@ -1047,6 +1644,252 @@ describe('DocPresence', function() {
     ], done);
   });
 
+  it('releases the doc version stream of presence in flight when unsubscribing', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    var streamsCount;
+
+    backend.use(backend.MIDDLEWARE_ACTIONS.receivePresence, function(context, next) {
+      if (context.presence.p === null) return next();
+      presence1.unsubscribe(function(error) {
+        if (error) return done(error);
+        next();
+      });
+    });
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        streamsCount = backend.pubsub.streamsCount;
+        next();
+      },
+      presence1.subscribe.bind(presence1),
+      function(next) {
+        async.parallel([
+          function(cb) {
+            presence2.once('receive', function(id, presence) {
+              expect(id).to.equal('presence-1');
+              expect(presence).to.be.null;
+              cb();
+            });
+          },
+          function(cb) {
+            localPresence1.submit({index: 1}, cb);
+          }
+        ], next);
+      },
+      function(next) {
+        expect(backend.pubsub.streamsCount).to.equal(streamsCount);
+        next();
+      }
+    ], done);
+  });
+
+  it('releases the doc version stream of presence transformed across a delete when unsubscribing', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence1.subscribe.bind(presence1),
+      doc1.unsubscribe.bind(doc1),
+      doc2.del.bind(doc2),
+      localPresence1.submit.bind(localPresence1, {index: 1}),
+      function(next) {
+        expect(connection1.agent.presenceRequests['books.northern-lights']['presence-1'].p).to.be.null;
+        expect(connection1.agent.latestDocVersionStreams).not.to.be.empty;
+        presence1.unsubscribe(next);
+      },
+      function(next) {
+        expect(connection1.agent.latestDocVersions).to.be.empty;
+        expect(connection1.agent.latestDocVersionStreams).to.be.empty;
+        next();
+      }
+    ], done);
+  });
+
+  it('releases the doc version stream of presence that failed to transform when unsubscribing', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    var localPresence2 = presence1.create('presence-2');
+
+    async.series([
+      presence1.subscribe.bind(presence1),
+      presence2.subscribe.bind(presence2),
+      doc1.unsubscribe.bind(doc1),
+      doc2.submitOp.bind(doc2, {index: 5, value: 'ern'}),
+      function(next) {
+        localPresence1.submit({badProp: 'foo'}, function(error) {
+          expect(error.code).to.equal('ERR_PRESENCE_TRANSFORM_FAILED');
+          expect(connection1.agent.latestDocVersionStreams).not.to.be.empty;
+          presence1.unsubscribe(next);
+        });
+      },
+      function(next) {
+        expect(connection1.agent.latestDocVersions).to.be.empty;
+        expect(connection1.agent.latestDocVersionStreams).to.be.empty;
+        localPresence2.submit({index: 2}, errorHandler(done));
+        presence2.once('receive', function(id) {
+          expect(id).to.equal('presence-2');
+          next();
+        });
+      }
+    ], done);
+  });
+
+  it('does not broadcast an older presence that finishes transforming after its client unsubscribes', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    var localPresence2 = presence1.create('presence-2');
+    var releaseFirstTransform;
+
+    async.series([
+      presence1.subscribe.bind(presence1),
+      presence2.subscribe.bind(presence2),
+      doc1.unsubscribe.bind(doc1),
+      doc2.submitOp.bind(doc2, {index: 5, value: 'ern'}),
+      function(next) {
+        backend.use(backend.MIDDLEWARE_ACTIONS.op, function(context, callback) {
+          if (releaseFirstTransform || context.agent !== connection1.agent) return callback();
+          releaseFirstTransform = callback;
+          next();
+        });
+        localPresence1.submit({index: 1}, errorHandler(done));
+      },
+      function(next) {
+        localPresence1.submit({index: 2}, errorHandler(done));
+        presence2.once('receive', function(id, presence) {
+          expect(presence).to.eql({index: 2});
+          next();
+        });
+      },
+      function(next) {
+        presence1.unsubscribe(errorHandler(done));
+        presence2.once('receive', function(id, presence) {
+          expect(presence).to.be.null;
+          next();
+        });
+      },
+      function(next) {
+        releaseFirstTransform();
+        localPresence2.submit({index: 3}, errorHandler(done));
+        presence2.once('receive', function(id) {
+          expect(id).to.equal('presence-2');
+          next();
+        });
+      },
+      function(next) {
+        expect(presence2.remotePresences).to.have.all.keys('presence-2');
+        next();
+      }
+    ], done);
+  });
+
+  it('broadcasts an older presence still transforming when a newer one fails to transform', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    var releaseFirstTransform;
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      doc1.unsubscribe.bind(doc1),
+      doc2.submitOp.bind(doc2, {index: 5, value: 'ern'}),
+      function(next) {
+        backend.use(backend.MIDDLEWARE_ACTIONS.op, function(context, callback) {
+          if (releaseFirstTransform || context.agent !== connection1.agent) return callback();
+          releaseFirstTransform = callback;
+          next();
+        });
+        localPresence1.submit({index: 1}, errorHandler(done));
+      },
+      function(next) {
+        localPresence1.submit({badProp: 'foo'}, function(error) {
+          expect(error.code).to.equal('ERR_PRESENCE_TRANSFORM_FAILED');
+          next();
+        });
+      },
+      function(next) {
+        releaseFirstTransform();
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.eql({index: 1});
+          next();
+        });
+      }
+    ], done);
+  });
+
+  it('broadcasts a null presence still being transformed when the connection closes', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      doc1.unsubscribe.bind(doc1),
+      doc2.submitOp.bind(doc2, {index: 5, value: 'ern'}),
+      function(next) {
+        localPresence1.submit({index: 1}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        backend.use(backend.MIDDLEWARE_ACTIONS.op, function(context, callback) {
+          if (context.agent !== connection1.agent) return callback();
+          connection1.agent.stream.once('end', function() {
+            callback();
+          });
+          connection1.close();
+        });
+        localPresence1.submit(null, errorHandler(done));
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.be.null;
+          next();
+        });
+      }
+    ], done);
+  });
+
+  it('does not broadcast presence still looking up its doc version when it is destroyed', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    var localPresence2 = presence1.create('presence-2');
+    var releaseDocVersion;
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        backend.use(backend.MIDDLEWARE_ACTIONS.readSnapshots, function(context, callback) {
+          if (releaseDocVersion || context.agent !== connection1.agent) return callback();
+          releaseDocVersion = callback;
+          next();
+        });
+        localPresence1.submit({index: 1}, errorHandler(done));
+      },
+      function(next) {
+        localPresence1.destroy(errorHandler(done));
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.be.null;
+          next();
+        });
+      },
+      function(next) {
+        connection1.once('receive', function(request) {
+          expect(request.data).to.include({id: 'presence-1', pv: 0});
+          expect(connection1.agent.latestDocVersions).to.be.empty;
+          expect(connection1.agent.latestDocVersionStreams).to.be.empty;
+          next();
+        });
+        releaseDocVersion();
+      },
+      function(next) {
+        localPresence2.submit({index: 2}, errorHandler(done));
+        presence2.once('receive', function(id) {
+          expect(id).to.equal('presence-2');
+          next();
+        });
+      },
+      function(next) {
+        expect(presence2.remotePresences).to.have.all.keys('presence-2');
+        next();
+      }
+    ], done);
+  });
+
   it('does not error when destroying presence for a deleted doc', function(done) {
     var localPresence1 = presence1.create('presence-1');