test with all encoders

tests/updates.tests.js

@@ -2,23 +2,34 @@ import * as t from 'lib0/testing.js'
 import { init, compare } from './testHelper.js' // eslint-disable-line
 import * as Y from '../src/index.js'
 
-const useV2 = true
+const encV1 = {
+  mergeUpdates: Y.mergeUpdates,
+  encodeStateAsUpdate: Y.encodeStateAsUpdate,
+  applyUpdate: Y.applyUpdate,
+  logUpdate: Y.logUpdate,
+  updateEventName: 'update'
+}
 
-const encodeStateAsUpdate = useV2 ? Y.encodeStateAsUpdateV2 : Y.encodeStateAsUpdate
-const mergeUpdates = useV2 ? Y.mergeUpdatesV2 : Y.mergeUpdates
-const applyUpdate = useV2 ? Y.applyUpdateV2 : Y.applyUpdate
-const logUpdate = useV2 ? Y.logUpdateV2 : Y.logUpdate
-const updateEventName = useV2 ? 'updateV2' : 'update'
+const encV2 = {
+  mergeUpdates: Y.mergeUpdatesV2,
+  encodeStateAsUpdate: Y.encodeStateAsUpdateV2,
+  applyUpdate: Y.applyUpdateV2,
+  logUpdate: Y.logUpdateV2,
+  updateEventName: 'updateV2'
+}
+
+const encoders = [encV1, encV2]
 
 /**
  * @param {Array<Y.Doc>} users
+ * @param {encV1 | encV2} enc
  */
-const fromUpdates = users => {
+const fromUpdates = (users, enc) => {
   const updates = users.map(user =>
-    encodeStateAsUpdate(user)
+    enc.encodeStateAsUpdate(user)
   )
   const ydoc = new Y.Doc()
-  applyUpdate(ydoc, mergeUpdates(updates))
+  enc.applyUpdate(ydoc, enc.mergeUpdates(updates))
   return ydoc
 }
 
@@ -31,53 +42,56 @@ export const testMergeUpdates = tc => {
   array0.insert(0, [1])
   array1.insert(0, [2])
 
-  const merged = fromUpdates(users)
   compare(users)
-  t.compareArrays(array0.toArray(), merged.getArray('array').toArray())
+  encoders.forEach(enc => {
+    const merged = fromUpdates(users, enc)
+    t.compareArrays(array0.toArray(), merged.getArray('array').toArray())
+  })
 }
 
 /**
  * @param {Y.Doc} ydoc
  * @param {Array<Uint8Array>} updates - expecting at least 4 updates
+ * @param {encV1 | encV2} enc
  */
-const checkUpdateCases = (ydoc, updates) => {
+const checkUpdateCases = (ydoc, updates, enc) => {
   const cases = []
 
   // Case 1: Simple case, simply merge everything
-  cases.push(mergeUpdates(updates))
+  cases.push(enc.mergeUpdates(updates))
 
   // Case 2: Overlapping updates
-  cases.push(mergeUpdates([
-    mergeUpdates(updates.slice(2)),
-    mergeUpdates(updates.slice(0, 2))
+  cases.push(enc.mergeUpdates([
+    enc.mergeUpdates(updates.slice(2)),
+    enc.mergeUpdates(updates.slice(0, 2))
   ]))
 
   // Case 3: Overlapping updates
-  cases.push(mergeUpdates([
-    mergeUpdates(updates.slice(2)),
-    mergeUpdates(updates.slice(1, 3)),
+  cases.push(enc.mergeUpdates([
+    enc.mergeUpdates(updates.slice(2)),
+    enc.mergeUpdates(updates.slice(1, 3)),
     updates[0]
   ]))
 
   // Case 4: Separated updates (containing skips)
-  cases.push(mergeUpdates([
-    mergeUpdates([updates[0], updates[2]]),
-    mergeUpdates([updates[1], updates[3]]),
-    mergeUpdates(updates.slice(4))
+  cases.push(enc.mergeUpdates([
+    enc.mergeUpdates([updates[0], updates[2]]),
+    enc.mergeUpdates([updates[1], updates[3]]),
+    enc.mergeUpdates(updates.slice(4))
   ]))
 
   // Case 5: overlapping with many duplicates
-  cases.push(mergeUpdates(cases))
+  cases.push(enc.mergeUpdates(cases))
 
-  const targetState = encodeStateAsUpdate(ydoc)
+  const targetState = enc.encodeStateAsUpdate(ydoc)
   t.info('Target State: ')
-  logUpdate(targetState)
+  enc.logUpdate(targetState)
 
   cases.forEach((updates, i) => {
     t.info('State Case $' + i + ':')
-    logUpdate(updates)
+    enc.logUpdate(updates)
     const merged = new Y.Doc()
-    applyUpdate(merged, updates)
+    enc.applyUpdate(merged, updates)
     t.compareArrays(merged.getArray().toArray(), ydoc.getArray().toArray())
   })
 }
@@ -86,34 +100,40 @@ const checkUpdateCases = (ydoc, updates) => {
  * @param {t.TestCase} tc
  */
 export const testMergeUpdates1 = tc => {
-  const ydoc = new Y.Doc({ gc: false })
-  const updates = /** @type {Array<Uint8Array>} */ ([])
-  ydoc.on(updateEventName, update => { updates.push(update) })
+  encoders.forEach((enc, i) => {
+    t.info(`Using V${i + 1} encoder.`)
+    const ydoc = new Y.Doc({ gc: false })
+    const updates = /** @type {Array<Uint8Array>} */ ([])
+    ydoc.on(enc.updateEventName, update => { updates.push(update) })
 
-  const array = ydoc.getArray()
-  array.insert(0, [1])
-  array.insert(0, [2])
-  array.insert(0, [3])
-  array.insert(0, [4])
+    const array = ydoc.getArray()
+    array.insert(0, [1])
+    array.insert(0, [2])
+    array.insert(0, [3])
+    array.insert(0, [4])
 
-  checkUpdateCases(ydoc, updates)
+    checkUpdateCases(ydoc, updates, enc)
+  })
 }
 
 /**
  * @param {t.TestCase} tc
  */
 export const testMergeUpdates2 = tc => {
-  const ydoc = new Y.Doc({ gc: false })
-  const updates = /** @type {Array<Uint8Array>} */ ([])
-  ydoc.on(updateEventName, update => { updates.push(update) })
+  encoders.forEach((enc, i) => {
+    t.info(`Using V${i + 1} encoder.`)
+    const ydoc = new Y.Doc({ gc: false })
+    const updates = /** @type {Array<Uint8Array>} */ ([])
+    ydoc.on(enc.updateEventName, update => { updates.push(update) })
 
-  const array = ydoc.getArray()
-  array.insert(0, [1, 2])
-  array.delete(1, 1)
-  array.insert(0, [3, 4])
-  array.delete(1, 2)
+    const array = ydoc.getArray()
+    array.insert(0, [1, 2])
+    array.delete(1, 1)
+    array.insert(0, [3, 4])
+    array.delete(1, 2)
 
-  checkUpdateCases(ydoc, updates)
+    checkUpdateCases(ydoc, updates, enc)
+  })
 }
 
 /**