sharedb 6.0.4 → 7.0.0

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

@@ -6,6 +6,7 @@ var presenceTestType = require('./presence-test-type');
 var errorHandler = require('../../util').errorHandler;
 var PresencePauser = require('./presence-pauser');
 var sinon = require('sinon');
+var ACTIONS = require('../../../lib/message-actions').ACTIONS;
 types.register(presenceTestType.type);
 
 describe('DocPresence', function() {
@@ -971,6 +972,59 @@ describe('DocPresence', function() {
     ], done);
   });
 
+  it('emits an error and drops stale remote presence that cannot be transformed', function(done) {
+    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);
+    }
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        connection2.on('send', function(message) {
+          if (message.a !== ACTIONS.presenceRequest) return;
+          catchUpCount++;
+          if (catchUpCount === 1) next();
+        });
+        sendUntypedPresenceAtVersion(0);
+      },
+      function(next) {
+        doc2.once('op', function() {
+          next();
+        });
+        doc1.submitOp({index: 5, value: 'ern'}, errorHandler(done));
+      },
+      function(next) {
+        presence2.once('error', function(error) {
+          expect(error).to.be.an.instanceOf(Error);
+          expect(error.code).to.equal('ERR_DOC_TYPE_NOT_RECOGNIZED');
+          next();
+        });
+        sendUntypedPresenceAtVersion(1);
+      },
+      function(next) {
+        doc2.once('op', function() {
+          next();
+        });
+        doc1.submitOp({index: 0, value: 'The'}, errorHandler(done));
+      },
+      function(next) {
+        presence2.once('receive', function(id, presence) {
+          expect(presence).to.eql({index: 1});
+          expect(catchUpCount).to.equal(1);
+          next();
+        });
+        localPresence1.submit({index: 1}, errorHandler(done));
+      }
+    ], done);
+  });
+
   it('sends null presence when the doc is destroyed', function(done) {
     var localPresence1 = presence1.create('presence-1');
 

package/test/client/presence/presence.js

@@ -486,6 +486,54 @@ describe('Presence', function() {
     ], done);
   });
 
+  it('does not leak Streams when subscribing the same presence multiple times in parallel', function(done) {
+    var streamsCount = backend.pubsub.streamsCount;
+    async.series([
+      function(next) {
+        presence1.subscribe();
+        // Trick it into sending a duplicate request
+        presence1.wantSubscribe = false;
+        presence1.subscribe(next);
+      },
+      function(next) {
+        expect(backend.pubsub.streamsCount).to.equal(streamsCount + 1);
+        next();
+      },
+      presence1.unsubscribe.bind(presence1),
+      function(next) {
+        expect(backend.pubsub.streamsCount).to.equal(streamsCount);
+        next();
+      }
+    ], done);
+  });
+
+  it('does not broadcast a disconnect when subscribing the same presence multiple times in parallel', 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) {
+        presence1.subscribe();
+        // Trick it into sending a duplicate request
+        presence1.wantSubscribe = false;
+        presence1.subscribe(next);
+      },
+      function(next) {
+        localPresence1.submit({index: 2}, errorHandler(done));
+        presence2.once('receive', function(id, presence) {
+          expect(presence).to.eql({index: 2});
+          next();
+        });
+      }
+    ], done);
+  });
+
   it('throws an error when trying to create a presence with a non-string ID', function() {
     expect(function() {
       presence1.create(123);

package/test/client/query-subscribe.js

@@ -127,11 +127,13 @@ module.exports = function(options) {
 
         it('does not duplicate messages', function(done) {
           var connection = this.backend.connect();
+          this.backend.db.pollInterval = 0;
+          this.backend.db.pollDebounce = 0;
           var count = 0;
           var query = connection.createSubscribeQuery(
             'dogs',
             this.matchAllDbQuery,
-            {pollInterval: 0, pollDebounce: 0},
+            null,
             function(err) {
               if (err) return done(err);
               connection.get('dogs', '1').on('error', done).create({});
@@ -519,13 +521,17 @@ function commonTests(options) {
     });
   });
 
-  it('pollDebounce option reduces subsequent poll interval', function(done) {
+  it('query middleware pollDebounce option reduces subsequent poll interval', function(done) {
     var clock = util.useFakeTimers();
     var connection = this.backend.connect();
     this.backend.db.canPollDoc = function() {
       return false;
     };
-    var query = connection.createSubscribeQuery('items', this.matchAllDbQuery, {pollDebounce: 2000});
+    this.backend.use('query', function(context, next) {
+      context.options.pollDebounce = 2000;
+      next();
+    });
+    var query = connection.createSubscribeQuery('items', this.matchAllDbQuery);
     query.on('error', done);
     var batchSizes = [];
     var total = 0;
@@ -618,21 +624,21 @@ function commonTests(options) {
     });
   });
 
-  it('pollInterval updates a subscribed query after an unpublished create', function(done) {
+  it('query middleware pollInterval updates a subscribed query after an unpublished create', function(done) {
     var clock = util.useFakeTimers();
     var connection = this.backend.connect();
     this.backend.suppressPublish = true;
-    var query = connection.createSubscribeQuery(
-      'dogs',
-      this.matchAllDbQuery,
-      {pollDebounce: 0, pollInterval: 50},
-      function(err) {
-        if (err) return done(err);
-        connection.get('dogs', 'fido').on('error', done).create({}, function() {
-          clock.tick(51);
-        });
-      }
-    );
+    this.backend.use('query', function(context, next) {
+      context.options.pollDebounce = 0;
+      context.options.pollInterval = 50;
+      next();
+    });
+    var query = connection.createSubscribeQuery('dogs', this.matchAllDbQuery, null, function(err) {
+      if (err) return done(err);
+      connection.get('dogs', 'fido').on('error', done).create({}, function() {
+        clock.tick(51);
+      });
+    });
     query.on('error', done);
     query.on('insert', function(docs) {
       expect(util.pluck(docs, 'id')).eql(['fido']);
@@ -659,13 +665,17 @@ function commonTests(options) {
     });
   });
 
-  it('pollInterval captures additional unpublished creates', function(done) {
+  it('query middleware pollInterval captures additional unpublished creates', function(done) {
     var clock = util.useFakeTimers();
     var connection = this.backend.connect();
     this.backend.suppressPublish = true;
+    this.backend.use('query', function(context, next) {
+      context.options.pollInterval = 1000;
+      next();
+    });
     var count = 0;
 
-    var query = connection.createSubscribeQuery('dogs', this.matchAllDbQuery, {pollInterval: 1000}, function(err) {
+    var query = connection.createSubscribeQuery('dogs', this.matchAllDbQuery, null, function(err) {
       if (err) return done(err);
       var doc = connection.get('dogs', count.toString()).on('error', done);
       doc.create({}, function(e) {
@@ -686,6 +696,34 @@ function commonTests(options) {
     clock.tick(1);
   });
 
+  it('does not pass client pollInterval or pollDebounce to query middleware', function(done) {
+    var connection = this.backend.connect();
+    var queryOptions;
+    this.backend.use('query', function(context, next) {
+      queryOptions = context.options;
+      next();
+    });
+    connection.createSubscribeQuery('dogs', this.matchAllDbQuery, {pollInterval: 1, pollDebounce: 0}, function(err) {
+      if (err) return done(err);
+      expect(queryOptions).not.to.have.any.keys('pollInterval', 'pollDebounce');
+      done();
+    });
+  });
+
+  it('ignores pollInterval from client query options', function(done) {
+    var clock = util.useFakeTimers();
+    var connection = this.backend.connect();
+    var db = this.backend.db;
+    db.pollInterval = 0;
+    sinon.spy(db, 'queryPoll');
+    connection.createSubscribeQuery('dogs', this.matchAllDbQuery, {pollInterval: 50}, function(err) {
+      if (err) return done(err);
+      clock.tick(1000);
+      expect(db.queryPoll.called).to.be.false;
+      done();
+    });
+  });
+
   it('query extra is returned to client', function(done) {
     var connection = this.backend.connect();
     this.backend.db.query = function(collection, query, fields, options, callback) {
@@ -906,7 +944,7 @@ function commonTests(options) {
     connection.createSubscribeQuery(
       'dogs',
       this.matchAllDbQuery,
-      {pollInterval: 0, pollDebounce: 0},
+      null,
       function(err) {
         if (err) {
           expect(err.message).to.be.equal('TEST_ERROR');

package/test/client/snapshot-timestamp-request.js

@@ -128,6 +128,17 @@ describe('SnapshotTimestampRequest', function() {
       ], done);
     });
 
+    it('fetches ops up to the current version when there are no milestones', function(done) {
+      sinon.spy(backend.db, 'getOps');
+      var halfwayBetweenDays2and3 = (day2 + day3) * 0.5;
+
+      backend.connect().fetchSnapshotByTimestamp('books', 'time-machine', halfwayBetweenDays2and3, function(error) {
+        if (error) return done(error);
+        expect(backend.db.getOps.calledWith('books', 'time-machine', 0, 3)).to.equal(true);
+        done();
+      });
+    });
+
     it('fetches the day 3 version when asking for a time after day 3', function(done) {
       var connection = backend.connect();
       async.waterfall([
@@ -229,8 +240,11 @@ describe('SnapshotTimestampRequest', function() {
     });
 
     it('returns an empty snapshot if trying to fetch a non-existent document', function(done) {
+      sinon.spy(backend.db, 'getOps');
+
       backend.connect().fetchSnapshotByTimestamp('books', 'does-not-exist', day1, function(error, snapshot) {
         if (error) return done(error);
+        expect(backend.db.getOps.called).to.be.false;
         expect(snapshot).to.eql({
           id: 'does-not-exist',
           v: 0,
@@ -469,6 +483,7 @@ describe('SnapshotTimestampRequest', function() {
       it('fetches a snapshot that matches a milestone snapshot', function(done) {
         sinon.spy(milestoneDb, 'getMilestoneSnapshotAtOrBeforeTime');
         sinon.spy(milestoneDb, 'getMilestoneSnapshotAtOrAfterTime');
+        sinon.spy(db, 'getOps');
 
         backendWithMilestones.connect()
           .fetchSnapshotByTimestamp('books', 'mocking-bird', day2, function(error, snapshot) {
@@ -476,6 +491,7 @@ describe('SnapshotTimestampRequest', function() {
 
             expect(milestoneDb.getMilestoneSnapshotAtOrBeforeTime.calledOnce).to.equal(true);
             expect(milestoneDb.getMilestoneSnapshotAtOrAfterTime.calledOnce).to.equal(true);
+            expect(db.getOps.called).to.be.false;
 
             expect(snapshot.v).to.equal(2);
             expect(snapshot.data).to.eql({title: 'To Kill a Mocking Bird', author: 'Harper Lea'});
@@ -483,6 +499,27 @@ describe('SnapshotTimestampRequest', function() {
           });
       });
 
+      it('skips fetching ops when milestone times are out of version order', function(done) {
+        var milestoneAtVersion = function(version) {
+          return function(collection, id, _timestamp, callback) {
+            milestoneDb.getMilestoneSnapshot(collection, id, version, callback);
+          };
+        };
+        sinon.stub(milestoneDb, 'getMilestoneSnapshotAtOrBeforeTime').callsFake(milestoneAtVersion(4));
+        sinon.stub(milestoneDb, 'getMilestoneSnapshotAtOrAfterTime').callsFake(milestoneAtVersion(2));
+        sinon.spy(db, 'getOps');
+        var halfwayBetweenDays3and4 = (day3 + day4) * 0.5;
+
+        backendWithMilestones.connect()
+          .fetchSnapshotByTimestamp('books', 'mocking-bird', halfwayBetweenDays3and4, function(error, snapshot) {
+            if (error) return done(error);
+            expect(db.getOps.called).to.be.false;
+            expect(snapshot.v).to.equal(4);
+            expect(snapshot.data).to.eql({title: 'To Kill a Mocking Bird', author: 'Harper Lee', year: 1959});
+            done();
+          });
+      });
+
       it('fetches a snapshot before any milestones', function(done) {
         sinon.spy(milestoneDb, 'getMilestoneSnapshotAtOrBeforeTime');
         sinon.spy(milestoneDb, 'getMilestoneSnapshotAtOrAfterTime');
@@ -513,7 +550,7 @@ describe('SnapshotTimestampRequest', function() {
 
             expect(milestoneDb.getMilestoneSnapshotAtOrBeforeTime.calledOnce).to.equal(true);
             expect(milestoneDb.getMilestoneSnapshotAtOrAfterTime.calledOnce).to.equal(true);
-            expect(db.getOps.calledWith('books', 'mocking-bird', 4, null)).to.equal(true);
+            expect(db.getOps.calledWith('books', 'mocking-bird', 4, 5)).to.equal(true);
 
             expect(snapshot.v).to.equal(5);
             expect(snapshot.data).to.eql({

package/test/middleware.js

@@ -5,6 +5,7 @@ var types = require('../lib/types');
 var errorHandler = util.errorHandler;
 var ShareDBError = require('../lib/error');
 var sinon = require('sinon');
+var crypto = require('crypto');
 var ACTIONS = require('../lib/message-actions').ACTIONS;
 
 var ERROR_CODE = ShareDBError.CODES;
@@ -63,6 +64,101 @@ describe('middleware', function() {
         done();
       });
     });
+
+    it('uses a clientId set on connect as the connection id and op src', function(done) {
+      var backend = this.backend;
+      backend.use('connect', function(request, next) {
+        request.agent.clientId = 'alice:1';
+        next();
+      });
+
+      var srcs = [];
+      backend.use('submit', function(request, next) {
+        srcs.push(request.op.src);
+        next();
+      });
+
+      backend.connect(null, null, function(connection) {
+        expect(connection.id).to.equal('alice:1');
+        connection.get('dogs', 'fido').create({age: 3}, function(error) {
+          if (error) return done(error);
+          expect(srcs).to.eql(['alice:1']);
+          done();
+        });
+      });
+    });
+  });
+
+  describe('restricting op sources', function() {
+    beforeEach(function() {
+      function srcFor(userId) {
+        return userId + ':' + crypto.randomUUID();
+      }
+
+      function isSrcOf(userId, src) {
+        if (typeof src !== 'string') return false;
+        var separator = src.lastIndexOf(':');
+        return separator !== -1 && src.slice(0, separator) === String(userId);
+      }
+
+      this.backend.use('connect', function(context, next) {
+        var userId = context.req.userId;
+        context.agent.custom.userId = userId;
+        context.agent.clientId = srcFor(userId);
+        next();
+      });
+
+      this.backend.use('receive', function(context, next) {
+        var message = context.data;
+        var userId = context.agent.custom.userId;
+        if (message.a === ACTIONS.handshake && message.id != null && !isSrcOf(userId, message.id)) {
+          delete message.id;
+        }
+        if (message.a === ACTIONS.op && message.src != null && !isSrcOf(userId, message.src)) {
+          return next(new Error('Op src belongs to another user'));
+        }
+        next();
+      });
+    });
+
+    it('keeps a reclaimed id that names the same user', function(done) {
+      var backend = this.backend;
+      backend.connect(null, {userId: 42}, function(connection) {
+        var id = connection.id;
+        expect(id).to.match(/^42:/);
+        connection.close();
+        backend.connect(connection, {userId: 42}, function() {
+          expect(connection.id).to.equal(id);
+          done();
+        });
+      });
+    });
+
+    it('replaces a reclaimed id that names another user', function(done) {
+      var backend = this.backend;
+      backend.connect(null, {userId: 42}, function(connection) {
+        connection.close();
+        connection.id = '7:stale';
+        backend.connect(connection, {userId: 42}, function() {
+          expect(connection.id).to.match(/^42:/);
+          expect(connection.id).to.equal(connection.agent.clientId);
+          done();
+        });
+      });
+    });
+
+    it('rejects an op whose src names another user', function(done) {
+      this.backend.connect(null, {userId: 42}, function(connection) {
+        connection.get('dogs', 'fido').on('error', function(error) {
+          expect(error.message).to.equal('Op src belongs to another user');
+          done();
+        });
+        connection.send({
+          a: ACTIONS.op, c: 'dogs', d: 'fido', v: 0, src: '7:1', seq: 1,
+          create: {type: 'json0', data: {}}
+        });
+      });
+    });
   });
 
   describe('readSnapshots', function() {

package/test/ot.js

@@ -159,6 +159,22 @@ describe('ot', function() {
       expect({}.polluted).to.equal(undefined);
     });
 
+    it('returns an error for a path segment that cannot be converted to a key', function() {
+      var error;
+      expect(function() {
+        error = ot.apply(snapshot, {v: 6, op: [{p: ['colour', {toString: 'x'}], oi: 'yes'}]});
+      }).to.not.throw();
+      expect(error.code).to.equal(ERROR_CODE.ERR_OT_OP_NOT_APPLIED);
+    });
+
+    it('returns an error for an op whose length cannot be converted to a number', function() {
+      var error;
+      expect(function() {
+        error = ot.apply(snapshot, {v: 6, op: {length: {toString: 'x'}}});
+      }).to.not.throw();
+      expect(error.code).to.equal(ERROR_CODE.ERR_OT_OP_NOT_APPLIED);
+    });
+
     ['__proto__', 'constructor'].forEach(function(badProp) {
       it('rejects ' + badProp + ' as a path segment', function() {
         var error = ot.apply(snapshot, {v: 6, op: [{p: [badProp, 'polluted'], oi: 'yes'}]});
@@ -187,6 +203,52 @@ describe('ot', function() {
     });
   });
 
+  describe('checkSubmittedOpForType', function() {
+    it('rejects an array-like json0 op', function() {
+      var op = {op: {0: {p: ['colour'], oi: 'red'}, length: 1}};
+      var error = ot.checkSubmittedOpForType(type.uri, op);
+      expect(error.code).to.equal(ERROR_CODE.ERR_OT_OP_BADLY_FORMED);
+    });
+
+    it('rejects a json0 op that is not an array', function() {
+      var error = ot.checkSubmittedOpForType(type.uri, {op: {p: ['colour'], oi: 'red'}});
+      expect(error.code).to.equal(ERROR_CODE.ERR_OT_OP_BADLY_FORMED);
+    });
+
+    it('rejects a json0 op component that is not an object', function() {
+      var error = ot.checkSubmittedOpForType(type.uri, {op: [null]});
+      expect(error.code).to.equal(ERROR_CODE.ERR_OT_OP_BADLY_FORMED);
+      expect(error.message).to.equal('Missing path');
+    });
+
+    it('rejects a dangerous path segment', function() {
+      var error = ot.checkSubmittedOpForType(type.uri, {op: [{p: ['__proto__', 'x'], oi: 'yes'}]});
+      expect(error.code).to.equal(ERROR_CODE.ERR_OT_OP_NOT_APPLIED);
+      expect(error.message).to.equal('Invalid path segment');
+    });
+
+    it('returns an error for a path segment that cannot be converted to a key', function() {
+      var error;
+      expect(function() {
+        error = ot.checkSubmittedOpForType(type.uri, {op: [{p: ['colour', {toString: 'x'}], oi: 'yes'}]});
+      }).to.not.throw();
+      expect(error.code).to.equal(ERROR_CODE.ERR_OT_OP_NOT_APPLIED);
+    });
+
+    it('accepts a valid json0 op', function() {
+      expect(ot.checkSubmittedOpForType(type.uri, {op: [{p: ['colour'], oi: 'red'}]})).equal();
+    });
+
+    it('leaves ops for other types alone', function() {
+      expect(ot.checkSubmittedOpForType(presenceType.uri, {op: {index: 0, value: 'hi'}})).equal();
+    });
+
+    it('leaves creates and deletes alone', function() {
+      expect(ot.checkSubmittedOpForType(type.uri, {create: {type: type.uri}})).equal();
+      expect(ot.checkSubmittedOpForType(type.uri, {del: true})).equal();
+    });
+  });
+
   describe('no-op', function() {
     it('works on existing docs', function() {
       var doc = {v: 6, type: type.uri, data: 'Hi'};

package/test/projections.js

@@ -383,6 +383,24 @@ describe('projection utility methods', function() {
         {x: true},
         {op: [{p: [], oi: {y: 1}}]}
       );
+      test(
+        {0: true},
+        {op: [{p: [0], na: 1}]}
+      );
+    });
+
+    [
+      null,
+      {},
+      [null],
+      [{}],
+      [{p: null}],
+      [{p: 'x'}],
+      [{p: [{toString: 'x'}]}]
+    ].forEach(function(edit) {
+      it('does not allow the malformed op ' + JSON.stringify(edit), function() {
+        expect(projections.isOpAllowed(null, {x: true}, {op: edit})).equal(false);
+      });
     });
   });
 

package/test/pubsub-memory.js

@@ -1,6 +1,7 @@
 var MemoryPubSub = require('../lib/pubsub/memory');
 var PubSub = require('../lib/pubsub');
 var expect = require('chai').expect;
+var sinon = require('sinon');
 
 require('./pubsub')(function(callback) {
   callback(null, new MemoryPubSub());
@@ -29,6 +30,50 @@ describe('PubSub base class', function() {
     pubsub.subscribe('x');
   });
 
+  it('returns the _subscribe error to every concurrent subscriber', function(done) {
+    var pubsub = new PubSub();
+    sinon.spy(pubsub, '_subscribe');
+    var errors = 0;
+    function onSubscribe(err) {
+      expect(err.code).to.equal('ERR_DATABASE_METHOD_NOT_IMPLEMENTED');
+      if (++errors < 2) return;
+      expect(pubsub._subscribe).to.have.been.calledOnce;
+      done();
+    }
+    pubsub.subscribe('x', onSubscribe);
+    pubsub.subscribe('x', onSubscribe);
+  });
+
+  it('calls _subscribe again after a failed subscribe', function(done) {
+    var pubsub = new PubSub();
+    pubsub.subscribe('x', function(err) {
+      expect(err.code).to.equal('ERR_DATABASE_METHOD_NOT_IMPLEMENTED');
+      pubsub._subscribe = function(channel, callback) {
+        callback();
+      };
+      pubsub.subscribe('x', function(err) {
+        if (err) return done(err);
+        expect(pubsub.streamsCount).to.equal(1);
+        done();
+      });
+    });
+  });
+
+  it('can resubscribe from a callback that destroyed the last stream', function(done) {
+    var pubsub = new PubSub();
+    pubsub._subscribe = function(channel, callback) {
+      callback();
+    };
+    pubsub._unsubscribe = function(channel, callback) {
+      callback();
+    };
+    pubsub.subscribe('x', function(err, stream) {
+      if (err) return done(err);
+      stream.destroy();
+      pubsub.subscribe('x', done);
+    });
+  });
+
   it('emits an error if _unsubscribe is unimplemented', function(done) {
     var pubsub = new PubSub();
     pubsub._subscribe = function(channel, callback) {

package/test/pubsub.js

@@ -60,6 +60,51 @@ module.exports = function(create) {
       });
     });
 
+    it('calls _subscribe once for concurrent subscribes to a channel', function(done) {
+      var pubsub = this.pubsub;
+      var _subscribe = pubsub._subscribe;
+      var subscribeCalls = 0;
+      pubsub._subscribe = function() {
+        subscribeCalls++;
+        return _subscribe.apply(this, arguments);
+      };
+      var received = [];
+      var finished = 0;
+      function onSubscribe(err, stream) {
+        if (err) return done(err);
+        var messages = [];
+        received.push(messages);
+        stream.on('data', function(data) {
+          messages.push(data.n);
+          if (data.n !== 2 || ++finished < 2) return;
+          expect(received).eql([[1, 2], [1, 2]]);
+          done();
+        });
+        if (received.length < 2) return;
+        expect(subscribeCalls).equal(1);
+        pubsub.publish(['x'], {n: 1});
+        pubsub.publish(['x'], {n: 2});
+      }
+      pubsub.subscribe('x', onSubscribe);
+      pubsub.subscribe('x', onSubscribe);
+    });
+
+    it('keeps a channel subscribed when a concurrent subscriber destroys its 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('stream.destroy() unsubscribes from a channel', function(done) {
       var pubsub = this.pubsub;
       pubsub.subscribe('x', function(err, stream) {