sharedb 2.2.1 → 2.2.5

package/README.md

@@ -1,5 +1,3 @@
-_This README is for `sharedb@1.x`. For `sharedb@1.x-beta`, see [the 1.x-beta branch](https://github.com/share/sharedb/tree/1.x-beta). To upgrade, see [the upgrade guide](https://github.com/share/sharedb/wiki/Upgrading-to-sharedb@1.0.0-from-1.0.0-beta)._
-
 # ShareDB
 
   [![NPM Version](https://img.shields.io/npm/v/sharedb.svg)](https://npmjs.org/package/sharedb)
@@ -11,8 +9,9 @@ ShareDB is a realtime database backend based on [Operational Transformation
 documents. It is the realtime backend for the [DerbyJS web application
 framework](http://derbyjs.com/).
 
-For questions, discussion and announcements, join the [ShareJS mailing
-list](https://groups.google.com/forum/?fromgroups#!forum/sharejs) or [check the FAQ](./docs/faq.md).
+For help, questions, discussion and announcements, join the [ShareJS mailing
+list](https://groups.google.com/forum/?fromgroups#!forum/sharejs) or [read the documentation](https://share.github.io/sharedb/
+).
 
 Please report any bugs you find to the [issue
 tracker](https://github.com/share/sharedb/issues).

package/lib/backend.js

@@ -772,6 +772,16 @@ Backend.prototype._fetchSnapshot = function(collection, id, version, callback) {
   var db = this.db;
   var backend = this;
 
+  var shouldGetLatestSnapshot = version === null;
+  if (shouldGetLatestSnapshot) {
+    return backend.db.getSnapshot(collection, id, null, null, function(error, snapshot) {
+      if (error) return callback(error);
+
+      callback(null, snapshot);
+    });
+  }
+
+
   this.milestoneDb.getMilestoneSnapshot(collection, id, version, function(error, milestoneSnapshot) {
     if (error) return callback(error);
 
@@ -833,6 +843,15 @@ Backend.prototype._fetchSnapshotByTimestamp = function(collection, id, timestamp
   var from = 0;
   var to = null;
 
+  var shouldGetLatestSnapshot = timestamp === null;
+  if (shouldGetLatestSnapshot) {
+    return backend.db.getSnapshot(collection, id, null, null, function(error, snapshot) {
+      if (error) return callback(error);
+
+      callback(null, snapshot);
+    });
+  }
+
   milestoneDb.getMilestoneSnapshotAtOrBeforeTime(collection, id, timestamp, function(error, snapshot) {
     if (error) return callback(error);
     milestoneSnapshot = snapshot;
@@ -883,10 +902,6 @@ function pluckIds(snapshots) {
 }
 
 function filterOpsInPlaceBeforeTimestamp(ops, timestamp) {
-  if (timestamp === null) {
-    return;
-  }
-
   for (var i = 0; i < ops.length; i++) {
     var op = ops[i];
     var opTimestamp = op.m && op.m.ts;

package/lib/client/doc.js

@@ -114,6 +114,10 @@ function Doc(connection, collection, id) {
   // ops are still received. Should be toggled through the pause() and
   // resume() methods to correctly flush on resume.
   this.paused = false;
+
+  // Internal counter that gets incremented every time doc.data is updated.
+  // Used as a cheap way to check if doc.data has changed.
+  this._dataStateVersion = 0;
 }
 emitter.mixin(Doc);
 
@@ -156,13 +160,18 @@ Doc.prototype._setType = function(newType) {
   } else if (newType === null) {
     this.type = newType;
     // If we removed the type from the object, also remove its data
-    this.data = undefined;
+    this._setData(undefined);
   } else {
     var err = new ShareDBError(ERROR_CODE.ERR_DOC_TYPE_NOT_RECOGNIZED, 'Missing type ' + newType);
     return this.emit('error', err);
   }
 };
 
+Doc.prototype._setData = function(data) {
+  this.data = data;
+  this._dataStateVersion++;
+};
+
 // Ingest snapshot data. This data must include a version, snapshot and type.
 // This is used both to ingest data that was exported with a webpage and data
 // that was received from the server during a fetch.
@@ -218,9 +227,11 @@ Doc.prototype.ingestSnapshot = function(snapshot, callback) {
   this.version = snapshot.v;
   var type = (snapshot.type === undefined) ? types.defaultType : snapshot.type;
   this._setType(type);
-  this.data = (this.type && this.type.deserialize) ?
-    this.type.deserialize(snapshot.data) :
-    snapshot.data;
+  this._setData(
+    (this.type && this.type.deserialize) ?
+      this.type.deserialize(snapshot.data) :
+      snapshot.data
+  );
   this.emit('load');
   callback && callback();
 };
@@ -613,6 +624,8 @@ Doc.prototype._otApply = function(op, source) {
       for (var i = 0; i < op.op.length; i++) {
         var component = op.op[i];
         var componentOp = {op: [component]};
+        // Apply the individual op component
+        this.emit('before op', componentOp.op, source, op.src);
         // Transform componentOp against any ops that have been submitted
         // sychronously inside of an op event handler since we began apply of
         // our operation
@@ -620,9 +633,7 @@ Doc.prototype._otApply = function(op, source) {
           var transformErr = transformX(this.applyStack[j], componentOp);
           if (transformErr) return this._hardRollback(transformErr);
         }
-        // Apply the individual op component
-        this.emit('before op', componentOp.op, source, op.src);
-        this.data = this.type.apply(this.data, componentOp.op);
+        this._setData(this.type.apply(this.data, componentOp.op));
         this.emit('op', componentOp.op, source, op.src);
       }
       this.emit('op batch', op.op, source);
@@ -635,7 +646,7 @@ Doc.prototype._otApply = function(op, source) {
     // the snapshot before it gets changed
     this.emit('before op', op.op, source, op.src);
     // Apply the operation to the local data, mutating it in place
-    this.data = this.type.apply(this.data, op.op);
+    this._setData(this.type.apply(this.data, op.op));
     // Emit an 'op' event once the local data includes the changes from the
     // op. For locally submitted ops, this will be synchronously with
     // submission and before the server or other clients have received the op.
@@ -648,11 +659,15 @@ Doc.prototype._otApply = function(op, source) {
 
   if (op.create) {
     this._setType(op.create.type);
-    this.data = (this.type.deserialize) ?
-      (this.type.createDeserialized) ?
-        this.type.createDeserialized(op.create.data) :
-        this.type.deserialize(this.type.create(op.create.data)) :
-      this.type.create(op.create.data);
+    if (this.type.deserialize) {
+      if (this.type.createDeserialized) {
+        this._setData(this.type.createDeserialized(op.create.data));
+      } else {
+        this._setData(this.type.deserialize(this.type.create(op.create.data)));
+      }
+    } else {
+      this._setData(this.type.create(op.create.data));
+    }
     this.emit('create', source);
     return;
   }

package/lib/client/presence/local-doc-presence.js

@@ -12,6 +12,7 @@ function LocalDocPresence(presence, presenceId) {
 
   this._doc = this.connection.get(this.collection, this.id);
   this._isSending = false;
+  this._docDataVersionByPresenceVersion = {};
 
   this._opHandler = this._transformAgainstOp.bind(this);
   this._createOrDelHandler = this._handleCreateOrDel.bind(this);
@@ -35,6 +36,9 @@ LocalDocPresence.prototype.submit = function(value, callback) {
     return this._callbackOrEmit(error, callback);
   };
 
+  // Record the current data state version to check if we need to transform
+  // the presence later
+  this._docDataVersionByPresenceVersion[this.presenceVersion] = this._doc._dataStateVersion;
   LocalPresence.prototype.submit.call(this, value, callback);
 };
 
@@ -63,6 +67,7 @@ LocalDocPresence.prototype._sendPending = function() {
     });
 
     presence._pendingMessages = [];
+    presence._docDataVersionByPresenceVersion = {};
   });
 };
 
@@ -76,9 +81,18 @@ LocalDocPresence.prototype._registerWithDoc = function() {
 
 LocalDocPresence.prototype._transformAgainstOp = function(op, source) {
   var presence = this;
+  var docDataVersion = this._doc._dataStateVersion;
+
   this._pendingMessages.forEach(function(message) {
+    // Check if the presence needs transforming against the op - this is to check against
+    // edge cases where presence is submitted from an 'op' event
+    var messageDocDataVersion = presence._docDataVersionByPresenceVersion[message.pv];
+    if (messageDocDataVersion >= docDataVersion) return;
     try {
       message.p = presence._transformPresence(message.p, op, source);
+      // Ensure the presence's data version is kept consistent to deal with "deep" op
+      // submissions
+      presence._docDataVersionByPresenceVersion[message.pv] = docDataVersion;
     } catch (error) {
       var callback = presence._getCallback(message.pv);
       presence._callbackOrEmit(error, callback);
@@ -103,6 +117,7 @@ LocalDocPresence.prototype._handleCreateOrDel = function() {
 LocalDocPresence.prototype._handleLoad = function() {
   this.value = null;
   this._pendingMessages = [];
+  this._docDataVersionByPresenceVersion = {};
 };
 
 LocalDocPresence.prototype._message = function() {

package/lib/ot.js

@@ -221,11 +221,18 @@ function normalizeLegacyJson0Ops(snapshot, json0Op) {
   if (snapshot.type !== types.defaultType.uri) return;
   var components = json0Op.op;
   if (!components) return;
+  var data = snapshot.data;
+
+  // type.apply() makes no guarantees about mutating the original data, so
+  // we need to clone. However, we only need to apply() if we have multiple
+  // components, so avoid cloning if we don't have to.
+  if (components.length > 1) data = util.clone(data);
+
   for (var i = 0; i < components.length; i++) {
     var component = components[i];
     if (typeof component.lm === 'string') component.lm = +component.lm;
     var path = component.p;
-    var element = snapshot.data;
+    var element = data;
     for (var j = 0; j < path.length; j++) {
       var key = path[j];
       // https://github.com/ottypes/json0/blob/73db17e86adc5d801951d1a69453b01382e66c7d/lib/json0.js#L21
@@ -234,5 +241,10 @@ function normalizeLegacyJson0Ops(snapshot, json0Op) {
       else if (element.constructor === Object) path[j] = key.toString();
       element = element[key];
     }
+
+    // Apply to update the snapshot, so we can correctly check the path for
+    // the next component. We don't need to do this on the final iteration,
+    // since there's no more ops.
+    if (i < components.length - 1) data = types.defaultType.apply(data, [component]);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sharedb",
-  "version": "2.2.1",
+  "version": "2.2.5",
   "description": "JSON OT database backend",
   "main": "lib/index.js",
   "dependencies": {

package/test/client/doc.js

@@ -214,6 +214,36 @@ describe('Doc', function() {
       });
     });
 
+    it('remote ops are transformed by ops submitted in `before op` event handlers', function(done) {
+      var doc = this.doc;
+      var doc2 = this.doc2;
+      var doc3 = this.doc3;
+      function beforeOpHandler(op, source) {
+        if (source) {
+          return;
+        }
+        doc.off('before op', beforeOpHandler);
+        doc.submitOp({p: ['list', 0], li: 2}, {source: true});
+      }
+      function opHandler(op, source) {
+        if (source) {
+          return;
+        }
+        doc.off('op', opHandler);
+        doc.submitOp({p: ['list', 0], li: 3}, {source: true});
+      }
+      doc2.submitOp({p: ['list'], oi: []}, function() {
+        doc.fetch(function() {
+          doc.on('before op', beforeOpHandler);
+          doc.on('op', opHandler);
+          doc2.submitOp([{p: ['list', 0], li: 1}, {p: ['list', 1], li: 42}], function() {
+            doc.fetch();
+            verifyConsistency(doc, doc2, doc3, [], done);
+          });
+        });
+      });
+    });
+
     it('remote multi component ops are transformed by ops submitted in `op` event handlers', function(done) {
       var doc = this.doc;
       var doc2 = this.doc2;

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

@@ -979,4 +979,50 @@ describe('DocPresence', function() {
       }
     ], done);
   });
+
+  it('does not transform presence submitted in an op event when the presence was created late', function(done) {
+    var localPresence1;
+
+    doc1.on('op', function() {
+      localPresence1.submit({index: 7});
+    });
+
+    localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        doc1.submitOp({index: 5, value: 'ern'});
+        presence2.on('receive', function(id, value) {
+          expect(value).to.eql({index: 7});
+          next();
+        });
+      }
+    ], done);
+  });
+
+  it('does transform late-created presence submitted in an op event by a deep second op', function(done) {
+    var localPresence1;
+
+    var submitted = false;
+    doc1.on('op', function() {
+      if (submitted) return;
+      submitted = true;
+      localPresence1.submit({index: 7});
+      doc1.submitOp({index: 5, value: 'akg'});
+    });
+
+    localPresence1 = presence1.create('presence-1');
+
+    async.series([
+      presence2.subscribe.bind(presence2),
+      function(next) {
+        doc1.submitOp({index: 5, value: 'ern'});
+        presence2.on('receive', function(id, value) {
+          expect(value).to.eql({index: 10});
+          next();
+        });
+      }
+    ], done);
+  });
 });

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

@@ -490,6 +490,54 @@ describe('SnapshotTimestampRequest', function() {
             done();
           });
       });
+
+      describe('when timestamp is null', function() {
+        it('fetches latest snapshot', function(done) {
+          sinon.spy(milestoneDb, 'getMilestoneSnapshotAtOrBeforeTime');
+          sinon.spy(milestoneDb, 'getMilestoneSnapshotAtOrAfterTime');
+          sinon.spy(db, 'getOps');
+
+          backendWithMilestones.connect()
+            .fetchSnapshotByTimestamp('books', 'mocking-bird', null, function(error, snapshot) {
+              if (error) return done(error);
+
+              expect(milestoneDb.getMilestoneSnapshotAtOrBeforeTime.called).to.be.false;
+              expect(milestoneDb.getMilestoneSnapshotAtOrAfterTime.called).to.be.false;
+              expect(db.getOps.called).to.be.false;
+
+              expect(snapshot.v).to.equal(5);
+              expect(snapshot.data).to.eql({
+                title: 'To Kill a Mocking Bird',
+                author: 'Harper Lee',
+                year: 1960
+              });
+
+              done();
+            });
+        });
+
+        it('returns error if getSnapshot fails', function(done) {
+          sinon.spy(milestoneDb, 'getMilestoneSnapshotAtOrBeforeTime');
+          sinon.spy(milestoneDb, 'getMilestoneSnapshotAtOrAfterTime');
+          sinon.spy(db, 'getOps');
+
+          sinon.stub(db, 'getSnapshot').callsFake(function(_collection, _id, _fields, _options, callback) {
+            callback(new Error('TEST_ERROR'));
+          });
+
+          backendWithMilestones.connect()
+            .fetchSnapshotByTimestamp('books', 'mocking-bird', null, function(error) {
+              expect(error.message).to.be.equal('TEST_ERROR');
+
+              expect(milestoneDb.getMilestoneSnapshotAtOrBeforeTime.called).to.be.false;
+              expect(milestoneDb.getMilestoneSnapshotAtOrAfterTime.called).to.be.false;
+              expect(db.getOps.called).to.be.false;
+              expect(db.getSnapshot.called).to.be.true;
+
+              done();
+            });
+        });
+      });
     });
   });
 });

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

@@ -439,6 +439,60 @@ describe('SnapshotVersionRequest', function() {
         }
       ], done);
     });
+
+    describe('with version null', function() {
+      it('fetches a latest version', function(done) {
+        var doc = backendWithMilestones.connect().get('books', 'mocking-bird');
+
+        async.waterfall([
+          doc.create.bind(doc, {title: 'To Kill a Mocking Bird'}),
+          doc.submitOp.bind(doc, {p: ['author'], oi: 'Harper Lea'}),
+          doc.submitOp.bind(doc, {p: ['author'], od: 'Harper Lea', oi: 'Harper Lee'}),
+          function(next) {
+            sinon.spy(milestoneDb, 'getMilestoneSnapshot');
+            sinon.spy(db, 'getOps');
+            backendWithMilestones.connect().fetchSnapshot('books', 'mocking-bird', null, next);
+          },
+          function(snapshot, next) {
+            expect(milestoneDb.getMilestoneSnapshot.called).to.be.false;
+            expect(db.getOps.called).to.be.false;
+            expect(snapshot.v).to.equal(3);
+            expect(snapshot.data).to.eql({
+              title: 'To Kill a Mocking Bird',
+              author: 'Harper Lee'
+            });
+            next();
+          }
+        ], done);
+      });
+
+      it('return error if getSnapshot fails', function(done) {
+        var doc = backendWithMilestones.connect().get('books', 'mocking-bird');
+
+        async.waterfall([
+          doc.create.bind(doc, {title: 'To Kill a Mocking Bird'}),
+          doc.submitOp.bind(doc, {p: ['author'], oi: 'Harper Lea'}),
+          doc.submitOp.bind(doc, {p: ['author'], od: 'Harper Lea', oi: 'Harper Lee'}),
+          function(next) {
+            sinon.spy(milestoneDb, 'getMilestoneSnapshot');
+            sinon.spy(db, 'getOps');
+            sinon.stub(db, 'getSnapshot').callsFake(function(_collection, _id, _fields, _options, callback) {
+              callback(new Error('TEST_ERROR'));
+            });
+            backendWithMilestones.connect().fetchSnapshot('books', 'mocking-bird', null, function(error) {
+              expect(error.message).to.be.equal('TEST_ERROR');
+              next(null, null);
+            });
+          },
+          function(snapshot, next) {
+            expect(milestoneDb.getMilestoneSnapshot.called).to.be.false;
+            expect(db.getOps.called).to.be.false;
+            expect(db.getSnapshot.called).to.be.true;
+            next();
+          }
+        ], done);
+      });
+    });
   });
 
   describe('invalid json0v2 path', function() {
@@ -496,4 +550,50 @@ describe('SnapshotVersionRequest', function() {
       });
     });
   });
+
+  describe('invalid json0v2 path with multiple components', function() {
+    beforeEach(function(done) {
+      var doc = backend.connect().get('series', 'his-dark-materials');
+      async.series([
+        doc.create.bind(doc, [{}]),
+        doc.submitOp.bind(doc, [
+          {p: ['0', 'title'], oi: ''},
+          {p: ['0', 'title', 0], si: 'Northern Lights'}
+        ])
+      ], done);
+    });
+
+    describe('json0v1', function() {
+      it('fetches v2 with json0v1', function(done) {
+        backend.connect().fetchSnapshot('series', 'his-dark-materials', 2, function(error, snapshot) {
+          if (error) return done(error);
+          expect(snapshot.data).to.eql([{title: 'Northern Lights'}]);
+          done();
+        });
+      });
+    });
+
+    describe('json0v2', function() {
+      var defaultType;
+
+      beforeEach(function() {
+        defaultType = types.defaultType;
+        types.defaultType = json0v2;
+        types.register(json0v2);
+      });
+
+      afterEach(function() {
+        types.defaultType = defaultType;
+        types.register(defaultType);
+      });
+
+      it('fetches v2 with json0v2', function(done) {
+        backend.connect().fetchSnapshot('series', 'his-dark-materials', 2, function(error, snapshot) {
+          if (error) return done(error);
+          expect(snapshot.data).to.eql([{title: 'Northern Lights'}]);
+          done();
+        });
+      });
+    });
+  });
 });

package/test/ot.js

@@ -373,118 +373,250 @@ describe('ot', function() {
   });
 
   describe('applyOps', function() {
-    it('applies an op to a snapshot', function() {
-      var snapshot = {
-        type: 'json0',
-        data: {title: 'Wee Free Men'}
-      };
+    describe('with normalization turned on', function() {
+      it('applies an op to a snapshot', function() {
+        var snapshot = {
+          type: 'http://sharejs.org/types/JSONv0',
+          data: {title: 'Wee Free Men'}
+        };
+
+        var ops = [
+          {
+            v: 1,
+            op: [{p: ['title', 0], si: 'The '}]
+          }
+        ];
+
+        var error = ot.applyOps(snapshot, ops, {
+          _normalizeLegacyJson0Ops: true
+        });
+        expect(error).to.be.undefined;
+        expect(snapshot.data).to.eql({title: 'The Wee Free Men'});
+        expect(snapshot.v).to.equal(2);
+      });
 
-      var ops = [
-        {
-          v: 1,
-          op: [{p: ['title', 0], si: 'The '}]
-        }
-      ];
+      it('applies multiple ops', function() {
+        var snapshot = {
+          type: 'http://sharejs.org/types/JSONv0',
+          data: {title: 'Wee Free Men'}
+        };
+
+        var ops = [
+          {
+            v: 1,
+            op: [{p: ['title', 0], si: 'The '}]
+          },
+          {
+            v: 2,
+            op: [{p: ['author'], oi: 'Terry Pratchett'}]
+          }
+        ];
+
+        ot.applyOps(snapshot, ops, {
+          _normalizeLegacyJson0Ops: true
+        });
+        expect(snapshot.data).to.eql({
+          author: 'Terry Pratchett',
+          title: 'The Wee Free Men'
+        });
+        expect(snapshot.v).to.equal(3);
+      });
 
-      var error = ot.applyOps(snapshot, ops);
-      expect(error).to.be.undefined;
-      expect(snapshot.data).to.eql({title: 'The Wee Free Men'});
-      expect(snapshot.v).to.equal(2);
-    });
+      it('applies a del to a snapshot', function() {
+        var snapshot = {
+          type: 'http://sharejs.org/types/JSONv0',
+          data: {title: 'Wee Free Men'}
+        };
 
-    it('applies multiple ops', function() {
-      var snapshot = {
-        type: 'json0',
-        data: {title: 'Wee Free Men'}
-      };
+        var ops = [{v: 1, del: true}];
 
-      var ops = [
-        {
-          v: 1,
-          op: [{p: ['title', 0], si: 'The '}]
-        },
-        {
-          v: 2,
-          op: [{p: ['author'], oi: 'Terry Pratchett'}]
-        }
-      ];
-
-      ot.applyOps(snapshot, ops);
-      expect(snapshot.data).to.eql({
-        author: 'Terry Pratchett',
-        title: 'The Wee Free Men'
+        ot.applyOps(snapshot, ops, {
+          _normalizeLegacyJson0Ops: true
+        });
+        expect(snapshot.data).to.be.undefined;
       });
-      expect(snapshot.v).to.equal(3);
-    });
 
-    it('applies a del to a snapshot', function() {
-      var snapshot = {
-        type: 'json0',
-        data: {title: 'Wee Free Men'}
-      };
+      it('applies a create to a snapshot', function() {
+        var snapshot = {};
+        var ops = [
+          {
+            v: 1,
+            create: {
+              type: 'http://sharejs.org/types/JSONv0',
+              data: {title: 'Wee Free Men'}
+            }
+          }
+        ];
 
-      var ops = [{v: 1, del: true}];
+        ot.applyOps(snapshot, ops, {
+          _normalizeLegacyJson0Ops: true
+        });
+        expect(snapshot.data).to.eql({title: 'Wee Free Men'});
+      });
 
-      ot.applyOps(snapshot, ops);
-      expect(snapshot.data).to.be.undefined;
-    });
+      it('returns an error if the snapshot has an unknown type', function() {
+        var snapshot = {type: 'unknown-type', data: {}};
+        var ops = [
+          {
+            v: 1,
+            op: [{p: ['title'], oi: 'Title'}]
+          }
+        ];
+        var error = ot.applyOps(snapshot, ops, {
+          _normalizeLegacyJson0Ops: true
+        });
+        expect(error.code).to.equal(ERROR_CODE.ERR_DOC_TYPE_NOT_RECOGNIZED);
+      });
 
-    it('applies a create to a snapshot', function() {
-      var snapshot = {};
-      var ops = [
-        {
-          v: 1,
-          create: {
-            type: 'json0',
-            data: {title: 'Wee Free Men'}
+      it('returns an error if a create op has an unknown type', function() {
+        var snapshot = {};
+        var ops = [
+          {
+            v: 1,
+            create: {
+              type: 'unknown-type',
+              data: {}
+            }
           }
-        }
-      ];
+        ];
+        var error = ot.applyOps(snapshot, ops, {
+          _normalizeLegacyJson0Ops: true
+        });
+        expect(error.code).to.equal(ERROR_CODE.ERR_DOC_TYPE_NOT_RECOGNIZED);
+      });
 
-      ot.applyOps(snapshot, ops);
-      expect(snapshot.data).to.eql({title: 'Wee Free Men'});
-    });
+      it('catches and returns an error thrown by type.apply', function() {
+        var snapshot = {
+          type: 'http://sharejs.org/types/JSONv0',
+          data: {title: 'Wee Free Men'}
+        };
 
-    it('returns an error if the snapshot has an unknown type', function() {
-      var snapshot = {type: 'unknown-type', data: {}};
-      var ops = [
-        {
+        var ops = [{
           v: 1,
-          op: [{p: ['title'], oi: 'Title'}]
-        }
-      ];
-      var error = ot.applyOps(snapshot, ops);
-      expect(error.code).to.equal(ERROR_CODE.ERR_DOC_TYPE_NOT_RECOGNIZED);
+          op: [{p: ['title'], li: 'not a list'}]
+        }];
+
+        var error = ot.applyOps(snapshot, ops, {
+          _normalizeLegacyJson0Ops: true
+        });
+        expect(error.code).to.equal(ERROR_CODE.ERR_OT_OP_NOT_APPLIED);
+      });
     });
 
-    it('returns an error if a create op has an unknown type', function() {
-      var snapshot = {};
-      var ops = [
-        {
-          v: 1,
-          create: {
-            type: 'unknown-type',
-            data: {}
+    describe('with normalization turned off', function() {
+      it('applies an op to a snapshot', function() {
+        var snapshot = {
+          type: 'json0',
+          data: {title: 'Wee Free Men'}
+        };
+
+        var ops = [
+          {
+            v: 1,
+            op: [{p: ['title', 0], si: 'The '}]
           }
-        }
-      ];
-      var error = ot.applyOps(snapshot, ops);
-      expect(error.code).to.equal(ERROR_CODE.ERR_DOC_TYPE_NOT_RECOGNIZED);
-    });
+        ];
 
-    it('catches and returns an error thrown by type.apply', function() {
-      var snapshot = {
-        type: 'json0',
-        data: {title: 'Wee Free Men'}
-      };
+        var error = ot.applyOps(snapshot, ops);
+        expect(error).to.be.undefined;
+        expect(snapshot.data).to.eql({title: 'The Wee Free Men'});
+        expect(snapshot.v).to.equal(2);
+      });
+
+      it('applies multiple ops', function() {
+        var snapshot = {
+          type: 'json0',
+          data: {title: 'Wee Free Men'}
+        };
+
+        var ops = [
+          {
+            v: 1,
+            op: [{p: ['title', 0], si: 'The '}]
+          },
+          {
+            v: 2,
+            op: [{p: ['author'], oi: 'Terry Pratchett'}]
+          }
+        ];
+
+        ot.applyOps(snapshot, ops);
+        expect(snapshot.data).to.eql({
+          author: 'Terry Pratchett',
+          title: 'The Wee Free Men'
+        });
+        expect(snapshot.v).to.equal(3);
+      });
 
-      var ops = [{
-        v: 1,
-        op: [{p: ['title'], li: 'not a list'}]
-      }];
+      it('applies a del to a snapshot', function() {
+        var snapshot = {
+          type: 'json0',
+          data: {title: 'Wee Free Men'}
+        };
 
-      var error = ot.applyOps(snapshot, ops);
-      expect(error.code).to.equal(ERROR_CODE.ERR_OT_OP_NOT_APPLIED);
+        var ops = [{v: 1, del: true}];
+
+        ot.applyOps(snapshot, ops);
+        expect(snapshot.data).to.be.undefined;
+      });
+
+      it('applies a create to a snapshot', function() {
+        var snapshot = {};
+        var ops = [
+          {
+            v: 1,
+            create: {
+              type: 'json0',
+              data: {title: 'Wee Free Men'}
+            }
+          }
+        ];
+
+        ot.applyOps(snapshot, ops);
+        expect(snapshot.data).to.eql({title: 'Wee Free Men'});
+      });
+
+      it('returns an error if the snapshot has an unknown type', function() {
+        var snapshot = {type: 'unknown-type', data: {}};
+        var ops = [
+          {
+            v: 1,
+            op: [{p: ['title'], oi: 'Title'}]
+          }
+        ];
+        var error = ot.applyOps(snapshot, ops);
+        expect(error.code).to.equal(ERROR_CODE.ERR_DOC_TYPE_NOT_RECOGNIZED);
+      });
+
+      it('returns an error if a create op has an unknown type', function() {
+        var snapshot = {};
+        var ops = [
+          {
+            v: 1,
+            create: {
+              type: 'unknown-type',
+              data: {}
+            }
+          }
+        ];
+        var error = ot.applyOps(snapshot, ops);
+        expect(error.code).to.equal(ERROR_CODE.ERR_DOC_TYPE_NOT_RECOGNIZED);
+      });
+
+      it('catches and returns an error thrown by type.apply', function() {
+        var snapshot = {
+          type: 'json0',
+          data: {title: 'Wee Free Men'}
+        };
+
+        var ops = [{
+          v: 1,
+          op: [{p: ['title'], li: 'not a list'}]
+        }];
+
+        var error = ot.applyOps(snapshot, ops);
+        expect(error.code).to.equal(ERROR_CODE.ERR_OT_OP_NOT_APPLIED);
+      });
     });
   });
 });