sharedb 6.0.4 → 7.0.0

package/test/agent.js

@@ -1,4 +1,5 @@
 var Backend = require('../lib/backend');
+var MemoryDb = require('../lib/db/memory');
 var logger = require('../lib/logger');
 var sinon = require('sinon');
 var StreamSocket = require('../lib/stream-socket');
@@ -19,6 +20,141 @@ describe('Agent', function() {
     backend.close(done);
   });
 
+  describe('request validation', function() {
+    var socket;
+    var connection;
+
+    beforeEach(function(done) {
+      socket = new StreamSocket();
+      backend.listen(socket.stream);
+      connection = new Connection(socket);
+      socket._open();
+      connection.once('connected', function() {
+        done();
+      });
+    });
+
+    function expectRejected(message, expectedError, done) {
+      var dbReads = ['getSnapshot', 'getSnapshotBulk', 'getOps', 'getOpsBulk', 'query'].map(function(method) {
+        return sinon.spy(MemoryDb.prototype, method);
+      });
+      connection.on('receive', function(request) {
+        var reply = request.data;
+        if (!reply || !reply.error) return;
+        request.data = null;
+        expect(reply.error).to.include({code: 'ERR_MESSAGE_BADLY_FORMED', message: expectedError});
+        dbReads.forEach(function(dbRead) {
+          expect(dbRead).not.to.have.been.called;
+        });
+        done();
+      });
+      socket.send(JSON.stringify(message));
+    }
+
+    var unconvertible = {toString: 1};
+    var badIds = [unconvertible, 42, null, '__proto__'];
+    var badVersions = [unconvertible, '1', -1];
+
+    [ACTIONS.fetch, ACTIONS.subscribe, ACTIONS.snapshotFetch].forEach(function(action) {
+      badVersions.forEach(function(badVersion) {
+        it('rejects a ' + action + ' with version ' + JSON.stringify(badVersion), function(done) {
+          expectRejected({a: action, c: 'dogs', d: 'fido', v: badVersion}, 'Invalid version', done);
+        });
+      });
+    });
+
+    [unconvertible, '1'].forEach(function(badTimestamp) {
+      it('rejects a snapshot fetch with timestamp ' + JSON.stringify(badTimestamp), function(done) {
+        var message = {a: ACTIONS.snapshotFetchByTimestamp, c: 'dogs', d: 'fido', ts: badTimestamp};
+        expectRejected(message, 'Invalid timestamp', done);
+      });
+    });
+
+    [ACTIONS.bulkFetch, ACTIONS.bulkSubscribe, ACTIONS.bulkUnsubscribe].forEach(function(action) {
+      it('rejects a ' + action + ' without bulk data', function(done) {
+        expectRejected({a: action, c: 'dogs', b: null}, 'Invalid bulk subscribe data', done);
+      });
+
+      badIds.forEach(function(badId) {
+        it('rejects a ' + action + ' with id ' + JSON.stringify(badId), function(done) {
+          expectRejected({a: action, c: 'dogs', b: ['fido', badId]}, 'Invalid id', done);
+        });
+      });
+
+      badVersions.forEach(function(badVersion) {
+        it('rejects a ' + action + ' with version ' + JSON.stringify(badVersion), function(done) {
+          expectRejected({a: action, c: 'dogs', b: {fido: badVersion}}, 'Invalid version', done);
+        });
+      });
+
+      it('rejects a ' + action + ' with a __proto__ key in its version map', function(done) {
+        expectRejected({a: action, c: 'dogs', b: JSON.parse('{"__proto__": 0}')}, 'Invalid id', done);
+      });
+    });
+
+    [ACTIONS.queryFetch, ACTIONS.querySubscribe].forEach(function(action) {
+      [unconvertible, ['dogs'], '__proto__'].forEach(function(badCollection) {
+        it('rejects a ' + action + ' with collection ' + JSON.stringify(badCollection), function(done) {
+          expectRejected({a: action, id: 1, c: badCollection, q: {}}, 'Invalid collection', done);
+        });
+      });
+
+      badIds.forEach(function(badId) {
+        it('rejects a ' + action + ' with result id ' + JSON.stringify(badId), function(done) {
+          expectRejected({a: action, id: 1, c: 'dogs', q: {}, r: [[badId]]}, 'Invalid id', done);
+        });
+      });
+
+      badVersions.forEach(function(badVersion) {
+        it('rejects a ' + action + ' with result version ' + JSON.stringify(badVersion), function(done) {
+          expectRejected({a: action, id: 1, c: 'dogs', q: {}, r: [['fido', badVersion]]}, 'Invalid version', done);
+        });
+      });
+
+      [{fido: 0}, ['fido']].forEach(function(badResults) {
+        it('rejects a ' + action + ' with results ' + JSON.stringify(badResults), function(done) {
+          expectRejected({a: action, id: 1, c: 'dogs', q: {}, r: badResults}, 'Invalid query results', done);
+        });
+      });
+    });
+
+    it('accepts a query unsubscribe without a collection', function(done) {
+      connection.on('receive', function(request) {
+        var reply = request.data;
+        if (!reply || reply.a !== ACTIONS.queryUnsubscribe) return;
+        request.data = null;
+        expect(reply).not.to.have.property('error');
+        done();
+      });
+      socket.send(JSON.stringify({a: ACTIONS.queryUnsubscribe, id: 1}));
+    });
+
+    [ACTIONS.presenceSubscribe, ACTIONS.presenceUnsubscribe].forEach(function(action) {
+      [unconvertible, '1'].forEach(function(badSeq) {
+        it('rejects a ' + action + ' with seq ' + JSON.stringify(badSeq), function(done) {
+          expectRejected({a: action, ch: 'dogs.fido', seq: badSeq}, 'Invalid seq', done);
+        });
+      });
+    });
+
+    badVersions.forEach(function(badVersion) {
+      it('rejects presence with presence version ' + JSON.stringify(badVersion), function(done) {
+        var message = {a: ACTIONS.presence, ch: 'dogs.fido', id: 'rex', p: null, pv: badVersion};
+        expectRejected(message, 'Invalid presence version', done);
+      });
+    });
+
+    [unconvertible, true].forEach(function(badProtocol) {
+      it('rejects a handshake with protocol ' + JSON.stringify(badProtocol), function(done) {
+        expectRejected({a: ACTIONS.handshake, protocol: badProtocol, protocolMinor: 2}, 'Invalid protocol', done);
+      });
+
+      it('rejects a handshake with minor protocol ' + JSON.stringify(badProtocol), function(done) {
+        expectRejected({a: ACTIONS.handshake, protocol: 1, protocolMinor: badProtocol}, 'Invalid protocol', done);
+      });
+    });
+  });
+
   describe('handshake', function() {
     it('warns when messages are sent before the handshake', function(done) {
       var socket = new StreamSocket();
@@ -83,4 +219,108 @@ describe('Agent', function() {
       });
     });
   });
+
+  describe('pub/sub channel collisions', function() {
+    var writer;
+    var subscriber;
+
+    beforeEach(function() {
+      writer = backend.connect();
+      subscriber = backend.connect();
+    });
+
+    it('does not deliver ops for a doc whose collection and id join to the same channel', function(done) {
+      var doc = subscriber.get('notes', 'private.alice');
+      doc.subscribe(function(error) {
+        if (error) return done(error);
+        doc.once('create', function() {
+          expect(doc.data).to.eql({text: 'Hello'});
+          done();
+        });
+        writer.get('notes.private', 'alice').create({diary: 'Dear diary'}, function(error) {
+          if (error) return done(error);
+          writer.get('notes', 'private.alice').create({text: 'Hello'}, function(error) {
+            if (error) done(error);
+          });
+        });
+      });
+    });
+
+    it('does not deliver ops from a collection whose channel matches the doc channel', function(done) {
+      var doc = subscriber.get('notes', 'private');
+      doc.subscribe(function(error) {
+        if (error) return done(error);
+        doc.once('create', function() {
+          expect(doc.data).to.eql({text: 'Hello'});
+          done();
+        });
+        writer.get('notes.private', 'alice').create({diary: 'Dear diary'}, function(error) {
+          if (error) return done(error);
+          writer.get('notes', 'private').create({text: 'Hello'}, function(error) {
+            if (error) done(error);
+          });
+        });
+      });
+    });
+
+    it('does not deliver ops to a query on a collection whose channel matches the doc channel', function(done) {
+      var opMessages = [];
+      var diaryEdit = {p: ['diary'], od: 'Dear diary', oi: 'Dear diary, again'};
+      subscriber.on('receive', function(request) {
+        if (request.data.a === ACTIONS.op) opMessages.push(request.data);
+      });
+      var privateDoc = writer.get('notes.private', 'private');
+      privateDoc.create({diary: 'Dear diary'}, function(error) {
+        if (error) return done(error);
+        subscriber.createSubscribeQuery('notes.private', {}, null, function(error, results) {
+          if (error) return done(error);
+          results[0].once('op', function() {
+            expect(opMessages).to.have.length(1);
+            expect(opMessages[0].op).to.eql([diaryEdit]);
+            done();
+          });
+          writer.get('notes', 'private').create({text: 'Hello'}, function(error) {
+            if (error) return done(error);
+            privateDoc.submitOp(diaryEdit, function(error) {
+              if (error) done(error);
+            });
+          });
+        });
+      });
+    });
+
+    it('does not deliver ops to a query from another collection sharing its custom channel', function(done) {
+      backend.use('commit', function(context, next) {
+        context.channels.push('shared');
+        next();
+      });
+      backend.use('query', function(context, next) {
+        context.channels = ['shared'];
+        next();
+      });
+      var opMessages = [];
+      var rename = {p: ['name'], od: 'Fido', oi: 'Rex'};
+      subscriber.on('receive', function(request) {
+        if (request.data.a === ACTIONS.op) opMessages.push(request.data);
+      });
+      var dog = writer.get('dogs', 'fido');
+      dog.create({name: 'Fido'}, function(error) {
+        if (error) return done(error);
+        subscriber.createSubscribeQuery('dogs', {}, null, function(error, results) {
+          if (error) return done(error);
+          results[0].once('op', function() {
+            expect(opMessages).to.have.length(1);
+            expect(opMessages[0].op).to.eql([rename]);
+            done();
+          });
+          writer.get('cats', 'fido').create({name: 'Tom'}, function(error) {
+            if (error) return done(error);
+            dog.submitOp(rename, function(error) {
+              if (error) done(error);
+            });
+          });
+        });
+      });
+    });
+  });
 });

package/test/backend.js

@@ -1,4 +1,5 @@
 var Backend = require('../lib/backend');
+var MemoryDB = require('../lib/db/memory');
 var expect = require('chai').expect;
 var sinon = require('sinon');
 var logger = require('../lib/logger');
@@ -28,6 +29,46 @@ describe('Backend', function() {
         expect(handler.callCount).to.equal(1);
       });
     });
+
+    describe('extraDbs', function() {
+      var archive;
+
+      beforeEach(function() {
+        archive = new MemoryDB();
+        backend = new Backend({extraDbs: {archive: archive}});
+      });
+
+      ['createFetchQuery', 'createSubscribeQuery'].forEach(function(method) {
+        it(method + ' queries the extra DB named by the db option', function(done) {
+          var query = sinon.spy(archive, 'query');
+          backend.connect()[method]('books', {}, {db: 'archive'}, function(error) {
+            if (error) return done(error);
+            expect(query).to.have.been.calledWith('books');
+            done();
+          });
+        });
+
+        ['constructor', '__proto__', {toString: 1}].forEach(function(badValue) {
+          it(method + ' errors if the db option is ' + JSON.stringify(badValue), function(done) {
+            backend.connect()[method]('books', {}, {db: badValue}, function(error) {
+              expect(error).to.include({code: 'ERR_DATABASE_ADAPTER_NOT_FOUND'});
+              done();
+            });
+          });
+
+          it(method + ' errors if middleware sets the db option to ' + JSON.stringify(badValue), function(done) {
+            backend.use('query', function(request, next) {
+              request.options.db = badValue;
+              process.nextTick(next);
+            });
+            backend.connect()[method]('books', {}, null, function(error) {
+              expect(error).to.include({code: 'ERR_DATABASE_ADAPTER_NOT_FOUND'});
+              done();
+            });
+          });
+        });
+      });
+    });
   });
 
   describe('a simple document', function() {
@@ -207,7 +248,7 @@ describe('Backend', function() {
             title: '1984',
             author: 'George Orwell'
           });
-          var op = {op: {p: ['publication'], oi: 1949}};
+          var op = {op: [{p: ['publication'], oi: 1949}]};
           stream.on('data', function(data) {
             expect(data.op).to.eql(op.op);
             done();
@@ -229,6 +270,48 @@ describe('Backend', function() {
       });
     });
 
+    describe('subscribeBulk', function() {
+      it('only subscribes once to a duplicated id', function(done) {
+        backend.subscribeBulk(agent, 'books', ['1984', '1984'], function(error, streams) {
+          if (error) return done(error);
+          expect(Object.keys(streams)).to.eql(['1984']);
+          expect(backend.pubsub.streamsCount).to.equal(1);
+          done();
+        });
+      });
+
+      describe('when one subscribe fails', function() {
+        var finishSubscribe;
+
+        beforeEach(function() {
+          finishSubscribe = {};
+          backend.pubsub._subscribe = function(channel, callback) {
+            finishSubscribe[channel] = callback;
+          };
+        });
+
+        it('destroys streams that subscribed before the failure', function(done) {
+          backend.subscribeBulk(agent, 'books', ['1984', 'bad'], function(error) {
+            expect(error.message).to.equal('subscribe failed');
+            expect(backend.pubsub.streamsCount).to.equal(0);
+            done();
+          });
+          finishSubscribe['books.1984']();
+          finishSubscribe['books.bad'](new Error('subscribe failed'));
+        });
+
+        it('destroys streams that subscribe after the failure', function(done) {
+          backend.subscribeBulk(agent, 'books', ['1984', 'bad'], function(error) {
+            expect(error.message).to.equal('subscribe failed');
+            finishSubscribe['books.1984']();
+            expect(backend.pubsub.streamsCount).to.equal(0);
+            done();
+          });
+          finishSubscribe['books.bad'](new Error('subscribe failed'));
+        });
+      });
+    });
+
     describe('submitRequestEnd', function() {
       it('emits after write', function(done) {
         var afterWriteCalled = false;
@@ -245,7 +328,7 @@ describe('Backend', function() {
           done();
         });
 
-        var op = {op: {p: ['publicationYear'], oi: 1949}};
+        var op = {op: [{p: ['publicationYear'], oi: 1949}]};
         backend.submit(agent, 'books', '1984', op, null, function(error) {
           if (error) done(error);
         });
@@ -262,7 +345,7 @@ describe('Backend', function() {
           done();
         });
 
-        var op = {op: {p: ['publicationYear'], oi: 1949}};
+        var op = {op: [{p: ['publicationYear'], oi: 1949}]};
         backend.submit(agent, 'books', '1984', op, null, function() {
           // Swallow the error
         });

package/test/client/doc.js

@@ -657,31 +657,31 @@ describe('Doc', function() {
     });
   });
 
-  describe('errors on ops that could cause prototype corruption', function() {
-    function expectReceiveError(
-      connection,
-      collectionName,
-      docId,
-      expectedError,
-      done
-    ) {
-      connection.on('receive', function(request) {
-        var message = request.data;
-        if (message.c === collectionName && message.d === docId) {
-          if ('error' in message) {
-            request.data = null; // Stop further processing of the message
-            if (message.error.message === expectedError) {
-              return done();
-            } else {
-              return done('Unexpected ShareDB error: ' + message.error.message);
-            }
+  function expectReceiveError(
+    connection,
+    collectionName,
+    docId,
+    expectedError,
+    done
+  ) {
+    connection.on('receive', function(request) {
+      var message = request.data;
+      if (message.c === collectionName && message.d === docId) {
+        if ('error' in message) {
+          request.data = null; // Stop further processing of the message
+          if (message.error.message === expectedError) {
+            return done();
           } else {
-            return done('Expected error on ' + collectionName + '.' + docId + ' but got no error');
+            return done('Unexpected ShareDB error: ' + message.error.message);
           }
+        } else {
+          return done('Expected error on ' + collectionName + '.' + docId + ' but got no error');
         }
-      });
-    }
+      }
+    });
+  }
 
+  describe('errors on ops that could cause prototype corruption', function() {
     afterEach(function() {
       delete Object.prototype.polluted;
     });
@@ -760,16 +760,21 @@ describe('Doc', function() {
       });
     });
 
-    // ot-json0 walks ops with .length and numeric indexing, so it applies an
-    // array-like object as if it were an op
     [
       {
         name: 'an array-like op',
-        op: {0: {p: ['__proto__', 'polluted'], oi: 'oops'}, length: 1}
+        op: {0: {p: ['__proto__', 'polluted'], oi: 'oops'}, length: 1},
+        error: 'json0 op must be an array'
       },
       {
         name: 'ops with a path segment that is not a string',
-        op: [{p: [['__proto__'], 'polluted'], oi: 'oops'}]
+        op: [{p: [['__proto__'], 'polluted'], oi: 'oops'}],
+        error: 'Invalid path segment'
+      },
+      {
+        name: 'ops with a component that is not an object',
+        op: [null],
+        error: 'Missing path'
       }
     ].forEach(function(test) {
       it('Rejects ' + test.name, function(done) {
@@ -780,7 +785,7 @@ describe('Doc', function() {
           if (err) {
             return done(err);
           }
-          expectReceiveError(connection, collectionName, docId, 'Invalid path segment', function(error) {
+          expectReceiveError(connection, collectionName, docId, test.error, function(error) {
             if (error) {
               return done(error);
             }
@@ -911,6 +916,31 @@ describe('Doc', function() {
         });
       });
 
+      // normalize() runs before the paths are checked, and it takes a bare
+      // component as well as an op, fills in a missing path, and branches on
+      // Array.isArray() — so these all reach the check as a real op
+      [
+        {name: 'a bare op component', op: {p: ['__proto__', 'polluted'], oi: 'oops'}},
+        {name: 'an op that is also shaped like a component', op: (function() {
+          var op = [{p: ['__proto__', 'polluted'], oi: 'oops'}];
+          op.p = [];
+          return op;
+        })()},
+        {name: 'an op with a pathless component before a bad one', op: [
+          {p: [], od: {foo: 'bar'}, oi: {foo: 'bar'}},
+          {p: ['__proto__', 'polluted'], oi: 'oops'}
+        ]}
+      ].forEach(function(test) {
+        it('rejects ' + test.name + ' composed into a pending create', function(done) {
+          var doc = this.connection.get('test-collection', 'test-doc');
+          doc.create({foo: 'bar'});
+          doc.submitOp(test.op, function(error) {
+            expectInvalidPathSegment(error);
+            done();
+          });
+        });
+      });
+
       it('leaves the doc usable after rejecting an op', function(done) {
         var doc = this.connection.get('test-collection', 'test-doc');
         async.series([
@@ -932,6 +962,165 @@ describe('Doc', function() {
     });
   });
 
+  // ot-json0's apply() quietly ignores an op that isn't an array, but its
+  // compose() and invert() throw on one. $fixup() composes, and it is called
+  // from middleware, so the throw is uncaught and takes the process down
+  describe('errors on badly formed json0 ops', function() {
+    [
+      {
+        name: 'an array-like op',
+        op: {0: {p: ['colour'], oi: 'red'}, length: 1},
+        error: 'json0 op must be an array'
+      },
+      {
+        name: 'a bare op component',
+        op: {p: ['colour'], oi: 'red'},
+        error: 'json0 op must be an array'
+      },
+      {
+        name: 'an op component that is not an object',
+        op: [null],
+        error: 'Missing path'
+      }
+    ].forEach(function(test) {
+      it('Rejects ' + test.name + ' before the apply middleware can fix it up', function(done) {
+        var connection = this.connection;
+        var collectionName = 'test-collection';
+        var docId = 'test-doc';
+        this.backend.use('apply', function(request, next) {
+          if ('op' in request.op) request.$fixup([{p: ['fixed'], oi: true}]);
+          next();
+        });
+        connection.get(collectionName, docId).create({id: docId}, function(err) {
+          if (err) {
+            return done(err);
+          }
+          expectReceiveError(connection, collectionName, docId, test.error, done);
+          connection.send({
+            a: 'op',
+            c: collectionName,
+            d: docId,
+            v: 1,
+            seq: connection.seq++,
+            x: {},
+            op: test.op
+          });
+        });
+      });
+    });
+
+    describe('locally submitted ops', function() {
+      // json0's normalize() throws on a component that isn't an object, and it
+      // runs before the op is checked, so this used to come straight out of
+      // submitOp() rather than through the callback
+      it('rejects an op component that is not an object without sending it to the server', function(done) {
+        var doc = this.connection.get('test-collection', 'test-doc');
+        doc.create({foo: 'bar'}, function(error) {
+          if (error) return done(error);
+          var calledBack = false;
+          doc.submitOp([null], function(error) {
+            calledBack = true;
+            expect(error.code).to.equal(ShareDBError.CODES.ERR_OT_OP_BADLY_FORMED);
+          });
+          // The server would only reject asynchronously, so calling back
+          // synchronously is how we know the op never left the client
+          expect(calledBack).to.equal(true);
+          done();
+        });
+      });
+
+      it('emits an error for an op component that is not an object with no callback', function(done) {
+        var doc = this.connection.get('test-collection', 'test-doc');
+        doc.create({foo: 'bar'}, function(error) {
+          if (error) return done(error);
+          doc.on('error', function(error) {
+            expect(error.code).to.equal(ShareDBError.CODES.ERR_OT_OP_BADLY_FORMED);
+            done();
+          });
+          doc.submitOp([null]);
+        });
+      });
+
+      // A type can throw anything at all, and reading .message off a thrown
+      // null would throw out of the catch, which is what the catch is for
+      [
+        {
+          name: 'a string',
+          thrown: 'not an op',
+          code: ShareDBError.CODES.ERR_OT_OP_BADLY_FORMED,
+          message: 'not an op'
+        },
+        {
+          name: 'null',
+          thrown: null,
+          code: ShareDBError.CODES.ERR_OT_OP_BADLY_FORMED,
+          message: 'null'
+        },
+        {
+          name: 'a ShareDBError',
+          thrown: new ShareDBError('ERR_CUSTOM_TYPE_ERROR', 'Custom type error'),
+          code: 'ERR_CUSTOM_TYPE_ERROR',
+          message: 'Custom type error'
+        }
+      ].forEach(function(test) {
+        it('reports ' + test.name + ' thrown by normalize()', function(done) {
+          var doc = this.connection.get('test-collection', 'test-doc');
+          doc.create({foo: 'bar'}, function(error) {
+            if (error) return done(error);
+            sinon.stub(json0, 'normalize').callsFake(function() {
+              throw test.thrown;
+            });
+            doc.submitOp([{p: ['foo'], od: 'bar'}], function(error) {
+              expect(error.code).to.equal(test.code);
+              expect(error.message).to.equal(test.message);
+              done();
+            });
+          });
+        });
+      });
+
+      // normalize() accepts more than the server does, and everything it
+      // accepts has to stay submittable
+      [
+        {name: 'a bare op component', op: {p: ['baz'], oi: true}},
+        {name: 'an op whose component has no path', op: [{od: {foo: 'bar'}, oi: {foo: 'bar', baz: true}}]},
+        {name: 'a bare component with no path', op: {od: {foo: 'bar'}, oi: {foo: 'bar', baz: true}}}
+      ].forEach(function(test) {
+        it('accepts ' + test.name + ', which json0 normalizes into an op', function(done) {
+          var doc = this.connection.get('test-collection', 'test-doc');
+          async.series([
+            doc.create.bind(doc, {foo: 'bar'}),
+            doc.submitOp.bind(doc, test.op),
+            doc.whenNothingPending.bind(doc),
+            function(next) {
+              expect(doc.data).to.eql({foo: 'bar', baz: true});
+              next();
+            }
+          ], done);
+        });
+      });
+
+      it('leaves the doc usable after rejecting an op', function(done) {
+        var doc = this.connection.get('test-collection', 'test-doc');
+        async.series([
+          doc.create.bind(doc, {foo: 'bar'}),
+          function(next) {
+            doc.submitOp([null], function(error) {
+              expect(error).to.be.instanceOf(Error);
+              next();
+            });
+          },
+          doc.submitOp.bind(doc, [{p: ['baz'], oi: true}]),
+          doc.whenNothingPending.bind(doc),
+          function(next) {
+            expect(doc.data).to.eql({foo: 'bar', baz: true});
+            next();
+          }
+        ], done);
+      });
+    });
+  });
+
   describe('toSnapshot', function() {
     var doc;
     beforeEach(function(done) {