sharedb 7.0.0 → 7.0.2

package/test/client/presence/presence.js

@@ -1,4 +1,5 @@
 var Backend = require('../../../lib/backend');
+var logger = require('../../../lib/logger');
 var PresencePauser = require('./presence-pauser');
 var expect = require('chai').expect;
 var async = require('async');
@@ -685,6 +686,32 @@ describe('Presence', function() {
     ], done);
   });
 
+  it('ignores presence from another client with the same ID as its local presence', function(done) {
+    var connection3 = backend.connect();
+    var localPresence3 = connection3.getPresence('test-channel').create('presence-1');
+    var localPresence1 = presence1.create('presence-1');
+    var hasReceivedOwnPresence = false;
+    presence1.on('receive', function(id) {
+      done(new Error('Unexpected presence received: ' + id));
+    });
+
+    async.series([
+      presence1.subscribe.bind(presence1),
+      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();
+          });
+        });
+        localPresence3.submit({index: 9}, errorHandler(done));
+      }
+    ], done);
+  });
+
   it('adds itself back onto the connection after a destroy and a resubscribe', function(done) {
     async.series([
       presence1.destroy.bind(presence1),
@@ -718,6 +745,513 @@ describe('Presence', function() {
     ], done);
   });
 
+  it('broadcasts a null presence when a connection that never subscribed is disconnected', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 3}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.be.null;
+          next();
+        });
+        connection1.close();
+      }
+    ], done);
+  });
+
+  it('broadcasts a null presence for presence in flight when the connection is disconnected', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    backend.use(backend.MIDDLEWARE_ACTIONS.receivePresence, function(context, next) {
+      if (context.presence.p === null) return next();
+      connection1.agent.stream.once('end', function() {
+        next();
+      });
+      connection1.close();
+    });
+
+    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;
+          next();
+        });
+        localPresence1.submit({index: 3}, errorHandler(done));
+      }
+    ], done);
+  });
+
+  it('broadcasts a null presence for presence in flight when unsubscribing', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    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([
+      presence1.subscribe.bind(presence1),
+      presence2.subscribe.bind(presence2),
+      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: 3}, cb);
+          }
+        ], next);
+      }
+    ], done);
+  });
+
+  it('broadcasts presence submitted after unsubscribing while earlier presence was in flight', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    var localPresence2 = presence1.create('presence-2');
+    var received = {};
+
+    backend.use(backend.MIDDLEWARE_ACTIONS.receivePresence, function(context, next) {
+      if (context.presence.id !== 'presence-1' || context.presence.p === null) return next();
+      presence1.unsubscribe(function(error) {
+        if (error) return done(error);
+        localPresence2.submit({index: 2}, function(error) {
+          if (error) return done(error);
+          next();
+        });
+      });
+    });
+
+    async.series([
+      presence1.subscribe.bind(presence1),
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        presence2.on('receive', function(id, presence) {
+          received[id] = presence;
+          if (Object.keys(received).length === 2) next();
+        });
+        localPresence1.submit({index: 1}, errorHandler(done));
+      },
+      function(next) {
+        expect(received).to.eql({'presence-1': null, 'presence-2': {index: 2}});
+        next();
+      }
+    ], done);
+  });
+
+  it('broadcasts a null presence for presence held in receive middleware when disconnected', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+
+    backend.use(backend.MIDDLEWARE_ACTIONS.receive, function(context, next) {
+      if (context.agent !== connection1.agent || context.data.a !== 'p') return next();
+      connection1.agent.stream.once('end', function() {
+        next();
+      });
+      connection1.close();
+    });
+
+    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;
+          next();
+        });
+        localPresence1.submit({index: 3}, errorHandler(done));
+      }
+    ], done);
+  });
+
+  it('does not rewrite a null presence again when middleware fills it in on disconnect', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    var nullPresenceCount = 0;
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 3}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        backend.use(backend.MIDDLEWARE_ACTIONS.receivePresence, function(context, callback) {
+          if (context.presence.p !== null) return callback();
+          if (++nullPresenceCount > 1) return done(new Error('Rewrote a null presence more than once'));
+          context.presence.p = {index: 0};
+          callback();
+        });
+        presence2.once('receive', function(id) {
+          expect(id).to.equal('presence-1');
+          expect(nullPresenceCount).to.equal(1);
+          next();
+        });
+        connection1.close();
+      }
+    ], done);
+  });
+
+  it('logs an error when the leave for presence in flight fails', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    var agent1 = connection1.agent;
+
+    sinon.stub(logger, 'error').callsFake(function(message, channel, id, src, error) {
+      expect(message).to.equal('Error broadcasting disconnect presence');
+      expect([channel, id, src]).to.eql(['test-channel', 'presence-1', agent1._src()]);
+      expect(error.message).to.equal('bad!');
+      done();
+    });
+
+    backend.use(backend.MIDDLEWARE_ACTIONS.receivePresence, function(context, next) {
+      if (context.presence.p === null) return next(new Error('bad!'));
+      agent1.stream.once('end', function() {
+        next();
+      });
+      connection1.close();
+    });
+
+    localPresence1.submit({index: 3}, errorHandler(done));
+  });
+
+  it('does not broadcast presence that gets through middleware after its own leave', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    var localPresence2 = presence1.create('presence-2');
+    var releasePresence;
+
+    backend.use(backend.MIDDLEWARE_ACTIONS.receivePresence, function(context, next) {
+      var isFirstPresence = context.presence.id === 'presence-1' && context.presence.pv === 0;
+      if (!isFirstPresence || releasePresence) return next();
+      releasePresence = next;
+    });
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 1}, errorHandler(done));
+        localPresence1.submit({index: 2}, errorHandler(done));
+        presence2.once('receive', function(id, presence) {
+          expect(presence).to.eql({index: 2});
+          next();
+        });
+      },
+      function(next) {
+        localPresence1.submit(null, errorHandler(done));
+        presence2.once('receive', function(id, presence) {
+          expect(presence).to.be.null;
+          next();
+        });
+      },
+      function(next) {
+        releasePresence();
+        localPresence2.submit({index: 3}, errorHandler(done));
+        presence2.once('receive', function(id) {
+          expect(id).to.equal('presence-2');
+          next();
+        });
+      },
+      function(next) {
+        expect(presence2.remotePresences).to.eql({'presence-2': {index: 3}});
+        next();
+      }
+    ], done);
+  });
+
+  it('broadcasts presence in flight when its leave is rejected', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    var releasePresence;
+
+    backend.use(backend.MIDDLEWARE_ACTIONS.receivePresence, function(context, next) {
+      if (context.presence.p === null) return next(new Error('bad!'));
+      releasePresence = next;
+    });
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 1}, errorHandler(done));
+        localPresence1.submit(null, function(error) {
+          expect(error.message).to.contain('bad!');
+          next();
+        });
+      },
+      function(next) {
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.eql({index: 1});
+          next();
+        });
+        releasePresence();
+      }
+    ], done);
+  });
+
+  it('broadcasts presence that overtakes its older leave in receive middleware', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    var releaseLeave;
+    var releasePresence;
+
+    backend.use(backend.MIDDLEWARE_ACTIONS.receive, function(context, next) {
+      var isLeave = context.agent === connection1.agent && context.data.a === 'p' && context.data.p === null;
+      if (!isLeave) return next();
+      releaseLeave = next;
+    });
+
+    backend.use(backend.MIDDLEWARE_ACTIONS.receivePresence, function(context, next) {
+      if (context.presence.p === null) return next();
+      releasePresence = next;
+      releaseLeave();
+    });
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        presence2.once('receive', function(id, presence) {
+          expect(presence).to.be.null;
+          next();
+        });
+        localPresence1.submit(null, errorHandler(done));
+        localPresence1.submit({index: 1}, errorHandler(done));
+      },
+      function(next) {
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.eql({index: 1});
+          next();
+        });
+        releasePresence();
+      }
+    ], done);
+  });
+
+  it('broadcasts presence re-created with the same id while its old leave is in middleware', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    var releaseLeave;
+    var releasePresence;
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 1}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        backend.use(backend.MIDDLEWARE_ACTIONS.receivePresence, function(context, callback) {
+          if (releaseLeave && releasePresence) return callback();
+          if (context.presence.p === null) releaseLeave = callback;
+          else releasePresence = callback;
+          if (releaseLeave && releasePresence) next();
+        });
+        localPresence1.submit(null);
+        presence1.create('presence-1').submit({index: 2}, errorHandler(done));
+      },
+      function(next) {
+        presence2.once('receive', function(id, presence) {
+          expect(presence).to.be.null;
+          next();
+        });
+        releaseLeave();
+      },
+      function(next) {
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.eql({index: 2});
+          next();
+        });
+        releasePresence();
+      }
+    ], done);
+  });
+
+  it('broadcasts presence submitted after unsubscribing while an older one is still in middleware', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    var heldPresences = [];
+    var onHeld;
+
+    backend.use(backend.MIDDLEWARE_ACTIONS.receivePresence, function(context, next) {
+      if (context.presence.p === null) return next();
+      heldPresences.push(next);
+      onHeld();
+    });
+
+    async.series([
+      presence1.subscribe.bind(presence1),
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        onHeld = next;
+        localPresence1.submit({index: 1}, errorHandler(done));
+      },
+      presence1.unsubscribe.bind(presence1),
+      function(next) {
+        onHeld = next;
+        localPresence1.submit({index: 2}, errorHandler(done));
+      },
+      function(next) {
+        heldPresences[0]();
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.be.null;
+          next();
+        });
+      },
+      function(next) {
+        heldPresences[1]();
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.eql({index: 2});
+          next();
+        });
+      }
+    ], done);
+  });
+
+  it('broadcasts presence re-created with the same id, and its leave on disconnect', 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) {
+        localPresence1.destroy(errorHandler(done));
+        presence2.once('receive', function(id, presence) {
+          expect(presence).to.be.null;
+          next();
+        });
+      },
+      function(next) {
+        presence1.create('presence-1').submit({index: 2}, errorHandler(done));
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.eql({index: 2});
+          next();
+        });
+      },
+      function(next) {
+        connection1.close();
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.be.null;
+          next();
+        });
+      }
+    ], done);
+  });
+
+  it('broadcasts presence re-created with the same id after destroying the channel presence', function(done) {
+    async.series([
+      presence1.subscribe.bind(presence1),
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        presence1.create('presence-1').submit({index: 1}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        var leaveCount = 0;
+        presence1.destroy(errorHandler(done));
+        presence2.on('receive', function receiveLeave(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.be.null;
+          leaveCount++;
+          if (leaveCount < 2) return;
+          presence2.off('receive', receiveLeave);
+          next();
+        });
+      },
+      function(next) {
+        connection1.getPresence('test-channel').create('presence-1').submit({index: 2}, errorHandler(done));
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.eql({index: 2});
+          next();
+        });
+      },
+      function(next) {
+        connection1.close();
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.be.null;
+          next();
+        });
+      }
+    ], done);
+  });
+
+  it('broadcasts a null presence when unsubscribing', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    async.series([
+      presence1.subscribe.bind(presence1),
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 3}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        presence2.once('receive', function(id, presence) {
+          expect(id).to.equal('presence-1');
+          expect(presence).to.be.null;
+          next();
+        });
+        presence1.unsubscribe(errorHandler(done));
+      }
+    ], done);
+  });
+
+  it('does not broadcast a null presence again when disconnecting after unsubscribing', function(done) {
+    var localPresence1 = presence1.create('presence-1');
+    var agent1 = connection1.agent;
+    async.series([
+      presence1.subscribe.bind(presence1),
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        localPresence1.submit({index: 3}, errorHandler(done));
+        presence2.once('receive', function() {
+          next();
+        });
+      },
+      function(next) {
+        presence2.once('receive', function() {
+          next();
+        });
+        presence1.unsubscribe(errorHandler(done));
+      },
+      function(next) {
+        sinon.spy(agent1, '_broadcastPresence');
+        agent1.stream.once('end', next);
+        connection1.close();
+      },
+      function(next) {
+        expect(agent1._broadcastPresence).not.to.have.been.called;
+        next();
+      }
+    ], done);
+  });
+
   describe('middleware', function() {
     describe('receivePresence', function() {
       it('provides the presence in the middleware', function(done) {
@@ -732,7 +1266,7 @@ describe('Presence', function() {
 
       it('can mutate the presence in the middleware', function(done) {
         backend.use(backend.MIDDLEWARE_ACTIONS.receivePresence, function(context, next) {
-          context.presence.p.index++;
+          if (context.presence.p) context.presence.p.index++;
           next();
         });
 
@@ -767,8 +1301,34 @@ describe('Presence', function() {
             localPresence1.submit({index: 5}, function(error) {
               expect(error.message).to.contain('bad!');
               expect(connection1.agent.presenceRequests['test-channel']).not.to.be.ok;
+              expect(connection1.agent._pendingPresenceBroadcasts).to.be.empty;
+              next();
+            });
+          }
+        ], done);
+      });
+
+      it('still broadcasts presence in flight when another presence on the channel is rejected', function(done) {
+        var localPresence1 = presence1.create('presence-1');
+        var localPresence2 = presence1.create('presence-2');
+
+        backend.use(backend.MIDDLEWARE_ACTIONS.receivePresence, function(context, next) {
+          if (context.presence.id === 'presence-2') return next(new Error('bad!'));
+          localPresence2.submit({index: 2}, function(error) {
+            expect(error.message).to.contain('bad!');
+            next();
+          });
+        });
+
+        async.series([
+          presence2.subscribe.bind(presence2),
+          function(next) {
+            presence2.once('receive', function(id, presence) {
+              expect(id).to.equal('presence-1');
+              expect(presence).to.eql({index: 1});
               next();
             });
+            localPresence1.submit({index: 1}, errorHandler(done));
           }
         ], done);
       });
@@ -795,6 +1355,27 @@ describe('Presence', function() {
         ], done);
       });
 
+      it('emits an error for a presence with the same ID on the presence, not its local presence', function(done) {
+        var localPresence1 = presence1.create('presence-1');
+        var localPresence2 = presence2.create('presence-1');
+        localPresence2.on('error', done);
+
+        backend.use(backend.MIDDLEWARE_ACTIONS.sendPresence, function(context, next) {
+          next(new Error('uh-oh!'));
+        });
+
+        async.series([
+          presence2.subscribe.bind(presence2),
+          function(next) {
+            localPresence1.submit({index: 3}, errorHandler(done));
+            presence2.once('error', function(error) {
+              expect(error.message).to.equal('uh-oh!');
+              next();
+            });
+          }
+        ], done);
+      });
+
       it('emits errors on the server instead of sending to the client', function(done) {
         var localPresence1 = presence1.create('presence-1');
 

package/test/client/query-subscribe.js

@@ -430,6 +430,31 @@ function commonTests(options) {
     });
   });
 
+  it('subscribed query results catch up on ops missed while disconnected', function(done) {
+    var backend = this.backend;
+    var connection = backend.connect();
+    var doc2 = backend.connect().get('dogs', 'fido').on('error', done);
+    var matchAllDbQuery = this.matchAllDbQuery;
+    doc2.create({age: 3}, function(err) {
+      if (err) return done(err);
+      var query = connection.createSubscribeQuery('dogs', matchAllDbQuery, null, function(err, results) {
+        if (err) return done(err);
+        var doc = results[0];
+        connection.close();
+        doc2.submitOp({p: ['age'], na: 1}, function(err) {
+          if (err) return done(err);
+          backend.connect(connection);
+          query.once('ready', function() {
+            expect(doc.version).to.equal(2);
+            expect(doc.data).to.eql({age: 4});
+            done();
+          });
+        });
+      });
+      query.on('error', done);
+    });
+  });
+
   it('subscribed query gets simultaneous insert and remove after reconnecting', function(done) {
     var backend = this.backend;
     var connection = backend.connect();