247 lines
7.7 KiB
JavaScript
247 lines
7.7 KiB
JavaScript
import * as t from 'lib0/testing'
|
|
import { init, compare } from './testHelper.js' // eslint-disable-line
|
|
import * as Y from '../src/index.js'
|
|
import { readClientsStructRefs, readDeleteSet, UpdateDecoderV2, UpdateEncoderV2, writeDeleteSet } from '../src/internals.js'
|
|
import * as encoding from 'lib0/encoding'
|
|
import * as decoding from 'lib0/decoding'
|
|
|
|
/**
|
|
* @typedef {Object} Enc
|
|
* @property {function(Array<Uint8Array>):Uint8Array} Enc.mergeUpdates
|
|
* @property {function(Y.Doc):Uint8Array} Enc.encodeStateAsUpdate
|
|
* @property {function(Y.Doc, Uint8Array):void} Enc.applyUpdate
|
|
* @property {function(Uint8Array):void} Enc.logUpdate
|
|
* @property {function(Uint8Array):{from:Map<number,number>,to:Map<number,number>}} Enc.parseUpdateMeta
|
|
* @property {function(Y.Doc):Uint8Array} Enc.encodeStateVector
|
|
* @property {function(Uint8Array):Uint8Array} Enc.encodeStateVectorFromUpdate
|
|
* @property {string} Enc.updateEventName
|
|
* @property {string} Enc.description
|
|
* @property {function(Uint8Array, Uint8Array):Uint8Array} Enc.diffUpdate
|
|
*/
|
|
|
|
/**
|
|
* @type {Enc}
|
|
*/
|
|
const encV1 = {
|
|
mergeUpdates: Y.mergeUpdates,
|
|
encodeStateAsUpdate: Y.encodeStateAsUpdate,
|
|
applyUpdate: Y.applyUpdate,
|
|
logUpdate: Y.logUpdate,
|
|
parseUpdateMeta: Y.parseUpdateMeta,
|
|
encodeStateVectorFromUpdate: Y.encodeStateVectorFromUpdate,
|
|
encodeStateVector: Y.encodeStateVector,
|
|
updateEventName: 'update',
|
|
description: 'V1',
|
|
diffUpdate: Y.diffUpdate
|
|
}
|
|
|
|
/**
|
|
* @type {Enc}
|
|
*/
|
|
const encV2 = {
|
|
mergeUpdates: Y.mergeUpdatesV2,
|
|
encodeStateAsUpdate: Y.encodeStateAsUpdateV2,
|
|
applyUpdate: Y.applyUpdateV2,
|
|
logUpdate: Y.logUpdateV2,
|
|
parseUpdateMeta: Y.parseUpdateMetaV2,
|
|
encodeStateVectorFromUpdate: Y.encodeStateVectorFromUpdateV2,
|
|
encodeStateVector: Y.encodeStateVector,
|
|
updateEventName: 'updateV2',
|
|
description: 'V2',
|
|
diffUpdate: Y.diffUpdateV2
|
|
}
|
|
|
|
/**
|
|
* @type {Enc}
|
|
*/
|
|
const encDoc = {
|
|
mergeUpdates: (updates) => {
|
|
const ydoc = new Y.Doc({ gc: false })
|
|
updates.forEach(update => {
|
|
Y.applyUpdateV2(ydoc, update)
|
|
})
|
|
return Y.encodeStateAsUpdateV2(ydoc)
|
|
},
|
|
encodeStateAsUpdate: Y.encodeStateAsUpdateV2,
|
|
applyUpdate: Y.applyUpdateV2,
|
|
logUpdate: Y.logUpdateV2,
|
|
parseUpdateMeta: Y.parseUpdateMetaV2,
|
|
encodeStateVectorFromUpdate: Y.encodeStateVectorFromUpdateV2,
|
|
encodeStateVector: Y.encodeStateVector,
|
|
updateEventName: 'updateV2',
|
|
description: 'Merge via Y.Doc',
|
|
/**
|
|
* @param {Uint8Array} update
|
|
* @param {Uint8Array} sv
|
|
*/
|
|
diffUpdate: (update, sv) => {
|
|
const ydoc = new Y.Doc({ gc: false })
|
|
Y.applyUpdateV2(ydoc, update)
|
|
return Y.encodeStateAsUpdateV2(ydoc, sv)
|
|
}
|
|
}
|
|
|
|
const encoders = [encV1, encV2, encDoc]
|
|
|
|
/**
|
|
* @param {Array<Y.Doc>} users
|
|
* @param {Enc} enc
|
|
*/
|
|
const fromUpdates = (users, enc) => {
|
|
const updates = users.map(user =>
|
|
enc.encodeStateAsUpdate(user)
|
|
)
|
|
const ydoc = new Y.Doc()
|
|
enc.applyUpdate(ydoc, enc.mergeUpdates(updates))
|
|
return ydoc
|
|
}
|
|
|
|
/**
|
|
* @param {t.TestCase} tc
|
|
*/
|
|
export const testMergeUpdates = tc => {
|
|
const { users, array0, array1 } = init(tc, { users: 3 })
|
|
|
|
array0.insert(0, [1])
|
|
array1.insert(0, [2])
|
|
|
|
compare(users)
|
|
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 {Enc} enc
|
|
* @param {boolean} hasDeletes
|
|
*/
|
|
const checkUpdateCases = (ydoc, updates, enc, hasDeletes) => {
|
|
const cases = []
|
|
|
|
// Case 1: Simple case, simply merge everything
|
|
cases.push(enc.mergeUpdates(updates))
|
|
|
|
// Case 2: Overlapping updates
|
|
cases.push(enc.mergeUpdates([
|
|
enc.mergeUpdates(updates.slice(2)),
|
|
enc.mergeUpdates(updates.slice(0, 2))
|
|
]))
|
|
|
|
// Case 3: Overlapping updates
|
|
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(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(enc.mergeUpdates(cases))
|
|
|
|
// const targetState = enc.encodeStateAsUpdate(ydoc)
|
|
// t.info('Target State: ')
|
|
// enc.logUpdate(targetState)
|
|
|
|
cases.forEach((mergedUpdates, i) => {
|
|
// t.info('State Case $' + i + ':')
|
|
// enc.logUpdate(updates)
|
|
const merged = new Y.Doc({ gc: false })
|
|
enc.applyUpdate(merged, mergedUpdates)
|
|
t.compareArrays(merged.getArray().toArray(), ydoc.getArray().toArray())
|
|
t.compare(enc.encodeStateVector(merged), enc.encodeStateVectorFromUpdate(mergedUpdates))
|
|
|
|
if (enc.updateEventName !== 'update') { // @todo should this also work on legacy updates?
|
|
for (let j = 1; j < updates.length; j++) {
|
|
const partMerged = enc.mergeUpdates(updates.slice(j))
|
|
const partMeta = enc.parseUpdateMeta(partMerged)
|
|
const targetSV = Y.encodeStateVectorFromUpdateV2(Y.mergeUpdatesV2(updates.slice(0, j)))
|
|
const diffed = enc.diffUpdate(mergedUpdates, targetSV)
|
|
const diffedMeta = enc.parseUpdateMeta(diffed)
|
|
const decDiffedSV = Y.decodeStateVector(enc.encodeStateVectorFromUpdate(diffed))
|
|
t.compare(partMeta, diffedMeta)
|
|
t.compare(decDiffedSV, partMeta.to)
|
|
{
|
|
// We can'd do the following
|
|
// - t.compare(diffed, mergedDeletes)
|
|
// because diffed contains the set of all deletes.
|
|
// So we add all deletes from `diffed` to `partDeletes` and compare then
|
|
const decoder = decoding.createDecoder(diffed)
|
|
const updateDecoder = new UpdateDecoderV2(decoder)
|
|
readClientsStructRefs(updateDecoder, new Y.Doc())
|
|
const ds = readDeleteSet(updateDecoder)
|
|
const updateEncoder = new UpdateEncoderV2()
|
|
encoding.writeVarUint(updateEncoder.restEncoder, 0) // 0 structs
|
|
writeDeleteSet(updateEncoder, ds)
|
|
const deletesUpdate = updateEncoder.toUint8Array()
|
|
const mergedDeletes = Y.mergeUpdatesV2([deletesUpdate, partMerged])
|
|
if (!hasDeletes || enc !== encDoc) {
|
|
// deletes will almost definitely lead to different encoders because of the mergeStruct feature that is present in encDoc
|
|
t.compare(diffed, mergedDeletes)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const meta = enc.parseUpdateMeta(mergedUpdates)
|
|
meta.from.forEach((clock, client) => t.assert(clock === 0))
|
|
meta.to.forEach((clock, client) => {
|
|
const structs = /** @type {Array<Y.Item>} */ (merged.store.clients.get(client))
|
|
const lastStruct = structs[structs.length - 1]
|
|
t.assert(lastStruct.id.clock + lastStruct.length === clock)
|
|
})
|
|
})
|
|
}
|
|
|
|
/**
|
|
* @param {t.TestCase} tc
|
|
*/
|
|
export const testMergeUpdates1 = tc => {
|
|
encoders.forEach((enc, i) => {
|
|
t.info(`Using encoder: ${enc.description}`)
|
|
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])
|
|
|
|
checkUpdateCases(ydoc, updates, enc, false)
|
|
})
|
|
}
|
|
|
|
/**
|
|
* @param {t.TestCase} tc
|
|
*/
|
|
export const testMergeUpdates2 = tc => {
|
|
encoders.forEach((enc, i) => {
|
|
t.info(`Using encoder: ${enc.description}`)
|
|
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)
|
|
|
|
checkUpdateCases(ydoc, updates, enc, true)
|
|
})
|
|
}
|
|
|
|
/**
|
|
* @todo be able to apply Skip structs to Yjs docs
|
|
*/
|