implement test type that better demos the intent of deserialization

Author: nateps

test/client/deserialized-type.js

@@ -0,0 +1,139 @@
+
+// A basic type that uses a custom linked list object type as its snapshot
+// data and therefore requires custom serialization into JSON
+exports.type = {
+  name: 'test-deserialized-type',
+  uri: 'http://sharejs.org/types/test-deserialized-type',
+  create: create,
+  deserialize: deserialize,
+  apply: apply,
+  transform: transform
+};
+
+// Type that additionally defines createDeserialized and supports passing
+// deserialized data to doc.create()
+exports.type2 = {
+  name: 'test-deserialized-type2',
+  uri: 'http://sharejs.org/types/test-deserialized-type2',
+  create: create,
+  createDeserialized: createDeserialized,
+  deserialize: deserialize,
+  apply: apply,
+  transform: transform
+};
+
+// A node of a singly linked list to demonstrate use of a non-JSON type as
+// snapshot data
+exports.Node = Node;
+
+// When type.createDeserialized is defined, it will be called on the client
+// instead of type.create, and type.create will be called on the server. Only
+// serialized data should be passed to type.create
+function create(array) {
+  return array || [];
+}
+
+// If type.deserialize is defined and type.createDeserialized is not,
+// type.create + type.deserialize will be called in the client Doc class when
+// a create operation is created locally or received from the server. The type
+// may implement this method to support creating doc data in the deserialized
+// format directly in addition to creating from the serialized form
+function createDeserialized(data) {
+  if (data instanceof Node) {
+    return data;
+  }
+  if (data == null) {
+    return null;
+  }
+  return deserialize(data);
+}
+
+// Method called when a snapshot is ingested to cast it into deserialized type
+// before setting on doc.data
+function deserialize(array) {
+  var node = null;
+  for (var i = array.length; i--;) {
+    var value = array[i];
+    node = new Node(value, node);
+  }
+  return node;
+}
+
+// When deserialized is defined, apply must do type checking on the input and
+// return deserialized data when passed deserialized data or serialized data
+// when passed serialized data
+function apply(data, op) {
+  return (data instanceof Node) ?
+    deserializedApply(data, op) :
+    serializedApply(data, op);
+}
+
+// Deserialized apply is used in the client for all client submitted and
+// incoming ops. It should apply with the snapshot in the deserialized format
+function deserializedApply(node, op) {
+  if (typeof op.insert === 'number') {
+    return node.insert(op.insert, op.value);
+  }
+  throw new Error('Op not recognized');
+}
+
+// Serialized apply is needed for applying ops on the server to the snapshot
+// data stored in the database. For maximum efficiency, the serialized apply
+// can implement the equivalent apply method on JSON data directly, though for
+// a simpler implementation, it can also call deserialize its input, use the
+// same deserialized apply, and serialize again before returning
+function serializedApply(array, op) {
+  if (typeof op.insert === 'number') {
+    array.splice(array.insert, 0, op.value);
+    return array;
+  }
+  throw new Error('Op not recognized');
+}
+
+function transform(op1, op2, side) {
+  if (
+    typeof op1.insert === 'number' &&
+    typeof op2.insert === 'number'
+  ) {
+    var index = op1.insert;
+    if (op2.insert < index || (op2.insert === index && side === 'left')) {
+      index++;
+    }
+    return {
+      insert: index,
+      value: op1.value
+    };
+  }
+  throw new Error('Op not recognized');
+}
+
+// A custom linked list object type to demonstrate custom deserialization
+function Node(value, next) {
+  this.value = value;
+  this.next = next || null;
+}
+Node.prototype.at = function(index) {
+  var node = this;
+  while (index--) {
+    node = node.next;
+  }
+  return node;
+};
+Node.prototype.insert = function(index, value) {
+  if (index === 0) {
+    return new Node(value, this);
+  }
+  var previous = this.at(index - 1);
+  var node = new Node(value, previous.next);
+  previous.next = node;
+  return this;
+};
+// Implementing a toJSON serialization method for the doc.data object is
+// needed if doc.create() is called with deserialized data
+Node.prototype.toJSON = function() {
+  var out = [];
+  for (var node = this; node; node = node.next) {
+    out.push(node.value);
+  }
+  return out;
+};

test/client/submit.js

@@ -1,9 +1,9 @@
 var async = require('async');
 var expect = require('expect.js');
 var types = require('../../lib/types');
-var serializable_type = require('../ot-mock-serializable-json0').type;
-
-types.register(serializable_type);
+var deserializedType = require('./deserialized-type');
+types.register(deserializedType.type);
+types.register(deserializedType.type2);
 
 module.exports = function() {
 describe('client submit', function() {
@@ -43,16 +43,6 @@ describe('client submit', function() {
     });
   });
 
-  it('can create a new doc with a serializable type', function(done) {
-    var doc = this.backend.connect().get('dogs', 'fido');
-    doc.create(serializable_type.serialize({age: 3}), serializable_type.uri, function(err) {
-      if (err) return done(err);
-      expect(doc.data).eql({age: 3});
-      expect(doc.version).eql(1);
-      done();
-    });
-  });
-
   it('can create then delete then create a doc', function(done) {
     var doc = this.backend.connect().get('dogs', 'fido');
     doc.create({age: 3}, function(err) {
@@ -88,19 +78,6 @@ describe('client submit', function() {
     });
   });
 
-  it('can create then submit an op on a serializable type', function(done) {
-    var doc = this.backend.connect().get('dogs', 'fido');
-    doc.create(serializable_type.serialize({age: 3}), serializable_type.uri, function(err) {
-      if (err) return done(err);
-      doc.submitOp({p: ['age'], na: 2}, function(err) {
-        if (err) return done(err);
-        expect(doc.data).eql({age: 5});
-        expect(doc.version).eql(2);
-        done();
-      });
-    });
-  });
-
   it('can create then submit an op sync', function(done) {
     var doc = this.backend.connect().get('dogs', 'fido');
     doc.create({age: 3});
@@ -167,33 +144,6 @@ describe('client submit', function() {
     });
   });
 
-  it('ops submitted sync get composed with a serializable type', function(done) {
-    var doc = this.backend.connect().get('dogs', 'fido');
-    doc.create(serializable_type.serialize({age: 3}), serializable_type.uri);
-    doc.submitOp({p: ['age'], na: 2});
-    doc.submitOp({p: ['age'], na: 2}, function(err) {
-      if (err) return done(err);
-      expect(doc.data).eql({age: 7});
-      // Version is 1 instead of 3, because the create and ops got composed
-      expect(doc.version).eql(1);
-      doc.submitOp({p: ['age'], na: 2});
-      doc.submitOp({p: ['age'], na: 2}, function(err) {
-        if (err) return done(err);
-        expect(doc.data).eql({age: 11});
-        // Ops get composed
-        expect(doc.version).eql(2);
-        doc.submitOp({p: ['age'], na: 2});
-        doc.del(function(err) {
-          if (err) return done(err);
-          expect(doc.data).eql(undefined);
-          // del DOES NOT get composed
-          expect(doc.version).eql(4);
-          done();
-        });
-      });
-    });
-  });
-
   it('does not compose ops when doc.preventCompose is true', function(done) {
     var doc = this.backend.connect().get('dogs', 'fido');
     doc.preventCompose = true;
@@ -434,23 +384,6 @@ describe('client submit', function() {
     });
   });
 
-  it('can commit then fetch in a new connection to get the same data with a serializable type', function(done) {
-    var doc = this.backend.connect().get('dogs', 'fido');
-    var doc2 = this.backend.connect().get('dogs', 'fido');
-    doc.create(serializable_type.serialize({age: 3}), serializable_type.uri, function(err) {
-      if (err) return done(err);
-      doc2.fetch(function(err) {
-        if (err) return done(err);
-        expect(doc.data).eql({age: 3});
-        expect(doc2.data).eql({age: 3});
-        expect(doc.version).eql(1);
-        expect(doc2.version).eql(1);
-        expect(doc.data).not.equal(doc2.data);
-        done();
-      });
-    });
-  });
-
   it('an op submitted concurrently is transformed by the first', function(done) {
     var doc = this.backend.connect().get('dogs', 'fido');
     var doc2 = this.backend.connect().get('dogs', 'fido');
@@ -1111,5 +1044,99 @@ describe('client submit', function() {
     });
   });
 
+  describe('type.deserialize', function() {
+    it('can create a new doc', function(done) {
+      var doc = this.backend.connect().get('dogs', 'fido');
+      doc.create([3], deserializedType.type.uri, function(err) {
+        if (err) return done(err);
+        expect(doc.data).a(deserializedType.Node);
+        expect(doc.data).eql({value: 3, next: null});
+        done();
+      });
+    });
+
+    it('is stored serialized in backend', function() {
+      var db = this.backend.db;
+      var doc = this.backend.connect().get('dogs', 'fido');
+      doc.create([3], deserializedType.type.uri, function(err) {
+        if (err) return done(err);
+        db.getSnapshot('dogs', fido, null, null, function(err, snapshot) {
+          if (err) return done(err);
+          expect(snapshot.data).eql([3]);
+          done();
+        });
+      });
+    });
+
+    it('deserializes on fetch', function(done) {
+      var doc = this.backend.connect().get('dogs', 'fido');
+      var doc2 = this.backend.connect().get('dogs', 'fido');
+      var backend = this.backend;
+      doc.create([3], deserializedType.type.uri, function(err) {
+        if (err) return done(err);
+        doc2.fetch(function(err) {
+          if (err) return done(err);
+          expect(doc2.data).a(deserializedType.Node);
+          expect(doc2.data).eql({value: 3, next: null});
+          done();
+        });
+      });
+    });
+
+    it('can create then submit an op', function(done) {
+      var doc = this.backend.connect().get('dogs', 'fido');
+      doc.create([3], deserializedType.type.uri, function(err) {
+        if (err) return done(err);
+        doc.submitOp({insert: 0, value: 2}, function(err) {
+          if (err) return done(err);
+          expect(doc.data).eql({value: 2, next: {value: 3, next: null}});
+          done();
+        });
+      });
+    });
+
+    it('server fetches and transforms by already committed op', function(done) {
+      var doc = this.backend.connect().get('dogs', 'fido');
+      var doc2 = this.backend.connect().get('dogs', 'fido');
+      var backend = this.backend;
+      doc.create([3], deserializedType.type.uri, function(err) {
+        if (err) return done(err);
+        doc2.fetch(function(err) {
+          if (err) return done(err);
+          doc.submitOp({insert: 0, value: 2}, function(err) {
+            if (err) return done(err);
+            doc2.submitOp({insert: 1, value: 4}, function(err) {
+              if (err) return done(err);
+              expect(doc2.data).eql({value: 2, next: {value: 3, next: {value: 4, next: null}}});
+              done();
+            });
+          });
+        });
+      });
+    });
+  });
+
+  describe('type.createDeserialized', function() {
+    it('can create a new doc', function(done) {
+      var doc = this.backend.connect().get('dogs', 'fido');
+      doc.create([3], deserializedType.type2.uri, function(err) {
+        if (err) return done(err);
+        expect(doc.data).a(deserializedType.Node);
+        expect(doc.data).eql({value: 3, next: null});
+        done();
+      });
+    });
+
+    it('can create a new doc from deserialized form', function(done) {
+      var doc = this.backend.connect().get('dogs', 'fido');
+      doc.create(new deserializedType.Node(3), deserializedType.type2.uri, function(err) {
+        if (err) return done(err);
+        expect(doc.data).a(deserializedType.Node);
+        expect(doc.data).eql({value: 3, next: null});
+        done();
+      });
+    });
+  });
+
 });
 };