1387 lines
62 KiB
TypeScript
1387 lines
62 KiB
TypeScript
import * as assert from 'assert'
|
|
import * as Automerge from '../src'
|
|
import { assertEqualsOneOf } from './helpers'
|
|
import { decodeChange } from './legacy/columnar'
|
|
|
|
const UUID_PATTERN = /^[0-9a-f]{32}$/
|
|
const OPID_PATTERN = /^[0-9]+@[0-9a-f]{32}$/
|
|
|
|
// CORE FEATURES
|
|
//
|
|
// TODO - Cursors
|
|
// TODO - Tables
|
|
// TODO - on-pass load() & reconstruct change from opset
|
|
// TODO - micro-patches (needed for fully hydrated object in js)
|
|
// TODO - valueAt(heads) / GC
|
|
//
|
|
// AUTOMERGE UNSUPPORTED
|
|
//
|
|
// TODO - patchCallback
|
|
|
|
|
|
describe('Automerge', () => {
|
|
describe('initialization ', () => {
|
|
it('should initially be an empty map', () => {
|
|
const doc = Automerge.init()
|
|
assert.deepStrictEqual(doc, {})
|
|
})
|
|
|
|
it('should allow instantiating from an existing object', () => {
|
|
const initialState = { birds: { wrens: 3, magpies: 4 } }
|
|
const doc = Automerge.from(initialState)
|
|
assert.deepStrictEqual(doc, initialState)
|
|
})
|
|
|
|
it('should allow merging of an object initialized with `from`', () => {
|
|
let doc1 = Automerge.from({ cards: [] })
|
|
let doc2 = Automerge.merge(Automerge.init(), doc1)
|
|
assert.deepStrictEqual(doc2, { cards: [] })
|
|
})
|
|
|
|
it('should allow passing an actorId when instantiating from an existing object', () => {
|
|
const actorId = '1234'
|
|
let doc = Automerge.from({ foo: 1 }, actorId)
|
|
assert.strictEqual(Automerge.getActorId(doc), '1234')
|
|
})
|
|
|
|
it('accepts an empty object as initial state', () => {
|
|
const doc = Automerge.from({})
|
|
assert.deepStrictEqual(doc, {})
|
|
})
|
|
|
|
it('accepts an array as initial state, but converts it to an object', () => {
|
|
const doc = Automerge.from(['a', 'b', 'c'])
|
|
assert.deepStrictEqual(doc, { '0': 'a', '1': 'b', '2': 'c' })
|
|
})
|
|
|
|
it('accepts strings as initial values, but treats them as an array of characters', () => {
|
|
const doc = Automerge.from('abc')
|
|
assert.deepStrictEqual(doc, { '0': 'a', '1': 'b', '2': 'c' })
|
|
})
|
|
|
|
it('ignores numbers provided as initial values', () => {
|
|
const doc = Automerge.from(123)
|
|
assert.deepStrictEqual(doc, {})
|
|
})
|
|
|
|
it('ignores booleans provided as initial values', () => {
|
|
const doc1 = Automerge.from(false)
|
|
assert.deepStrictEqual(doc1, {})
|
|
const doc2 = Automerge.from(true)
|
|
assert.deepStrictEqual(doc2, {})
|
|
})
|
|
})
|
|
|
|
describe('sequential use', () => {
|
|
let s1, s2
|
|
beforeEach(() => {
|
|
s1 = Automerge.init()
|
|
})
|
|
|
|
it('should not mutate objects', () => {
|
|
s2 = Automerge.change(s1, doc => doc.foo = 'bar')
|
|
assert.strictEqual(s1.foo, undefined)
|
|
assert.strictEqual(s2.foo, 'bar')
|
|
})
|
|
|
|
it('changes should be retrievable', () => {
|
|
const change1 = Automerge.getLastLocalChange(s1)
|
|
s2 = Automerge.change(s1, doc => doc.foo = 'bar')
|
|
const change2 = Automerge.getLastLocalChange(s2)
|
|
assert.strictEqual(change1, undefined)
|
|
const change = decodeChange(change2)
|
|
assert.deepStrictEqual(change, {
|
|
actor: change.actor, deps: [], seq: 1, startOp: 1,
|
|
hash: change.hash, message: '', time: change.time,
|
|
ops: [{obj: '_root', key: 'foo', action: 'set', insert: false, value: 'bar', pred: []}]
|
|
})
|
|
})
|
|
|
|
it('should not register any conflicts on repeated assignment', () => {
|
|
assert.strictEqual(Automerge.getConflicts(s1, 'foo'), undefined)
|
|
s1 = Automerge.change(s1, 'change', doc => doc.foo = 'one')
|
|
assert.strictEqual(Automerge.getConflicts(s1, 'foo'), undefined)
|
|
s1 = Automerge.change(s1, 'change', doc => doc.foo = 'two')
|
|
assert.strictEqual(Automerge.getConflicts(s1, 'foo'), undefined)
|
|
})
|
|
|
|
describe('changes', () => {
|
|
it('should group several changes', () => {
|
|
s2 = Automerge.change(s1, 'change message', doc => {
|
|
doc.first = 'one'
|
|
assert.strictEqual(doc.first, 'one')
|
|
doc.second = 'two'
|
|
assert.deepStrictEqual(doc, {
|
|
first: 'one', second: 'two'
|
|
})
|
|
})
|
|
assert.deepStrictEqual(s1, {})
|
|
assert.deepStrictEqual(s2, {first: 'one', second: 'two'})
|
|
})
|
|
|
|
it('should freeze objects if desired', () => {
|
|
s1 = Automerge.init({freeze: true})
|
|
s2 = Automerge.change(s1, doc => doc.foo = 'bar')
|
|
try {
|
|
s2.foo = 'lemon'
|
|
} catch (e) { }
|
|
assert.strictEqual(s2.foo, 'bar')
|
|
|
|
let deleted = false
|
|
try {
|
|
deleted = delete s2.foo
|
|
} catch (e) { }
|
|
assert.strictEqual(s2.foo, 'bar')
|
|
assert.strictEqual(deleted, false)
|
|
|
|
Automerge.change(s2, () => {
|
|
try {
|
|
s2.foo = 'lemon'
|
|
} catch (e) { }
|
|
assert.strictEqual(s2.foo, 'bar')
|
|
})
|
|
|
|
assert.throws(() => { Object.assign(s2, {x: 4}) })
|
|
assert.strictEqual(s2.x, undefined)
|
|
})
|
|
|
|
it('should allow repeated reading and writing of values', () => {
|
|
s2 = Automerge.change(s1, 'change message', doc => {
|
|
doc.value = 'a'
|
|
assert.strictEqual(doc.value, 'a')
|
|
doc.value = 'b'
|
|
doc.value = 'c'
|
|
assert.strictEqual(doc.value, 'c')
|
|
})
|
|
assert.deepStrictEqual(s1, {})
|
|
assert.deepStrictEqual(s2, {value: 'c'})
|
|
})
|
|
|
|
it('should not record conflicts when writing the same field several times within one change', () => {
|
|
s1 = Automerge.change(s1, 'change message', doc => {
|
|
doc.value = 'a'
|
|
doc.value = 'b'
|
|
doc.value = 'c'
|
|
})
|
|
assert.strictEqual(s1.value, 'c')
|
|
assert.strictEqual(Automerge.getConflicts(s1, 'value'), undefined)
|
|
})
|
|
|
|
it('should return the unchanged state object if nothing changed', () => {
|
|
s2 = Automerge.change(s1, () => {})
|
|
assert.strictEqual(s2, s1)
|
|
})
|
|
|
|
it('should ignore field updates that write the existing value', () => {
|
|
s1 = Automerge.change(s1, doc => doc.field = 123)
|
|
s2 = Automerge.change(s1, doc => doc.field = 123)
|
|
assert.strictEqual(s2, s1)
|
|
})
|
|
|
|
it('should not ignore field updates that resolve a conflict', () => {
|
|
s2 = Automerge.merge(Automerge.init(), s1)
|
|
s1 = Automerge.change(s1, doc => doc.field = 123)
|
|
s2 = Automerge.change(s2, doc => doc.field = 321)
|
|
s1 = Automerge.merge(s1, s2)
|
|
assert.strictEqual(Object.keys(Automerge.getConflicts(s1, 'field')).length, 2)
|
|
const resolved = Automerge.change(s1, doc => doc.field = s1.field)
|
|
assert.notStrictEqual(resolved, s1)
|
|
assert.deepStrictEqual(resolved, {field: s1.field})
|
|
assert.strictEqual(Automerge.getConflicts(resolved, 'field'), undefined)
|
|
})
|
|
|
|
it('should ignore list element updates that write the existing value', () => {
|
|
s1 = Automerge.change(s1, doc => doc.list = [123])
|
|
s2 = Automerge.change(s1, doc => doc.list[0] = 123)
|
|
assert.strictEqual(s2, s1)
|
|
})
|
|
|
|
it('should not ignore list element updates that resolve a conflict', () => {
|
|
s1 = Automerge.change(s1, doc => doc.list = [1])
|
|
s2 = Automerge.merge(Automerge.init(), s1)
|
|
s1 = Automerge.change(s1, doc => doc.list[0] = 123)
|
|
s2 = Automerge.change(s2, doc => doc.list[0] = 321)
|
|
s1 = Automerge.merge(s1, s2)
|
|
assert.deepStrictEqual(Automerge.getConflicts(s1.list, 0), {
|
|
[`3@${Automerge.getActorId(s1)}`]: 123,
|
|
[`3@${Automerge.getActorId(s2)}`]: 321
|
|
})
|
|
const resolved = Automerge.change(s1, doc => doc.list[0] = s1.list[0])
|
|
assert.deepStrictEqual(resolved, s1)
|
|
assert.notStrictEqual(resolved, s1)
|
|
assert.strictEqual(Automerge.getConflicts(resolved.list, 0), undefined)
|
|
})
|
|
|
|
it('should sanity-check arguments', () => {
|
|
s1 = Automerge.change(s1, doc => doc.nested = {})
|
|
assert.throws(() => { Automerge.change({}, doc => doc.foo = 'bar') }, /must be the document root/)
|
|
assert.throws(() => { Automerge.change(s1.nested, doc => doc.foo = 'bar') }, /must be the document root/)
|
|
})
|
|
|
|
it('should not allow nested change blocks', () => {
|
|
assert.throws(() => {
|
|
Automerge.change(s1, doc1 => {
|
|
Automerge.change(doc1, doc2 => {
|
|
doc2.foo = 'bar'
|
|
})
|
|
})
|
|
}, /Calls to Automerge.change cannot be nested/)
|
|
assert.throws(() => {
|
|
s1 = Automerge.change(s1, doc1 => {
|
|
s2 = Automerge.change(s1, doc2 => doc2.two = 2)
|
|
doc1.one = 1
|
|
})
|
|
}, /Attempting to use an outdated Automerge document/)
|
|
})
|
|
|
|
it('should not allow the same base document to be used for multiple changes', () => {
|
|
assert.throws(() => {
|
|
Automerge.change(s1, doc => doc.one = 1)
|
|
Automerge.change(s1, doc => doc.two = 2)
|
|
}, /Attempting to use an outdated Automerge document/)
|
|
})
|
|
|
|
it('should allow a document to be cloned', () => {
|
|
s1 = Automerge.change(s1, doc => doc.zero = 0)
|
|
s2 = Automerge.clone(s1)
|
|
s1 = Automerge.change(s1, doc => doc.one = 1)
|
|
s2 = Automerge.change(s2, doc => doc.two = 2)
|
|
assert.deepStrictEqual(s1, {zero: 0, one: 1})
|
|
assert.deepStrictEqual(s2, {zero: 0, two: 2})
|
|
Automerge.free(s1)
|
|
Automerge.free(s2)
|
|
})
|
|
|
|
it('should work with Object.assign merges', () => {
|
|
s1 = Automerge.change(s1, doc1 => {
|
|
doc1.stuff = {foo: 'bar', baz: 'blur'}
|
|
})
|
|
s1 = Automerge.change(s1, doc1 => {
|
|
doc1.stuff = Object.assign({}, doc1.stuff, {baz: 'updated!'})
|
|
})
|
|
assert.deepStrictEqual(s1, {stuff: {foo: 'bar', baz: 'updated!'}})
|
|
})
|
|
|
|
it('should support Date objects in maps', () => {
|
|
const now = new Date()
|
|
s1 = Automerge.change(s1, doc => doc.now = now)
|
|
let changes = Automerge.getAllChanges(s1)
|
|
;[s2] = Automerge.applyChanges(Automerge.init(), changes)
|
|
assert.strictEqual(s2.now instanceof Date, true)
|
|
assert.strictEqual(s2.now.getTime(), now.getTime())
|
|
})
|
|
|
|
it('should support Date objects in lists', () => {
|
|
const now = new Date()
|
|
s1 = Automerge.change(s1, doc => doc.list = [now])
|
|
let changes = Automerge.getAllChanges(s1)
|
|
;[s2] = Automerge.applyChanges(Automerge.init(), changes)
|
|
assert.strictEqual(s2.list[0] instanceof Date, true)
|
|
assert.strictEqual(s2.list[0].getTime(), now.getTime())
|
|
})
|
|
|
|
it('should call patchCallback if supplied', () => {
|
|
const callbacks = [], actor = Automerge.getActorId(s1)
|
|
const s2 = Automerge.change(s1, {
|
|
patchCallback: (patch, before, after) => callbacks.push({patch, before, after})
|
|
}, doc => {
|
|
doc.birds = ['Goldfinch']
|
|
})
|
|
assert.strictEqual(callbacks.length, 2)
|
|
assert.deepStrictEqual(callbacks[0].patch, { action: "put", path: ["birds"], value: [], conflict: false})
|
|
assert.deepStrictEqual(callbacks[1].patch, { action: "splice", path: ["birds",0], values: ["Goldfinch"] })
|
|
assert.strictEqual(callbacks[0].before, s1)
|
|
assert.strictEqual(callbacks[1].after, s2)
|
|
})
|
|
|
|
it('should call a patchCallback set up on document initialisation', () => {
|
|
const callbacks = []
|
|
s1 = Automerge.init({
|
|
patchCallback: (patch, before, after) => callbacks.push({patch, before, after })
|
|
})
|
|
const s2 = Automerge.change(s1, doc => doc.bird = 'Goldfinch')
|
|
const actor = Automerge.getActorId(s1)
|
|
assert.strictEqual(callbacks.length, 1)
|
|
assert.deepStrictEqual(callbacks[0].patch, {
|
|
action: "put", path: ["bird"], value: "Goldfinch", conflict: false
|
|
})
|
|
assert.strictEqual(callbacks[0].before, s1)
|
|
assert.strictEqual(callbacks[0].after, s2)
|
|
})
|
|
})
|
|
|
|
describe('emptyChange()', () => {
|
|
it('should append an empty change to the history', () => {
|
|
s1 = Automerge.change(s1, 'first change', doc => doc.field = 123)
|
|
s2 = Automerge.emptyChange(s1, 'empty change')
|
|
assert.notStrictEqual(s2, s1)
|
|
assert.deepStrictEqual(s2, s1)
|
|
assert.deepStrictEqual(Automerge.getHistory(s2).map(state => state.change.message), ['first change', 'empty change'])
|
|
})
|
|
|
|
it('should reference dependencies', () => {
|
|
s1 = Automerge.change(s1, doc => doc.field = 123)
|
|
s2 = Automerge.merge(Automerge.init(), s1)
|
|
s2 = Automerge.change(s2, doc => doc.other = 'hello')
|
|
s1 = Automerge.emptyChange(Automerge.merge(s1, s2))
|
|
const history = Automerge.getHistory(s1)
|
|
const emptyChange = history[2].change
|
|
assert.deepStrictEqual(emptyChange.deps, [history[0].change.hash, history[1].change.hash].sort())
|
|
assert.deepStrictEqual(emptyChange.ops, [])
|
|
})
|
|
})
|
|
|
|
describe('root object', () => {
|
|
it('should handle single-property assignment', () => {
|
|
s1 = Automerge.change(s1, 'set bar', doc => doc.foo = 'bar')
|
|
s1 = Automerge.change(s1, 'set zap', doc => doc.zip = 'zap')
|
|
assert.strictEqual(s1.foo, 'bar')
|
|
assert.strictEqual(s1.zip, 'zap')
|
|
assert.deepStrictEqual(s1, {foo: 'bar', zip: 'zap'})
|
|
})
|
|
|
|
it('should allow floating-point values', () => {
|
|
s1 = Automerge.change(s1, doc => doc.number = 1589032171.1)
|
|
assert.strictEqual(s1.number, 1589032171.1)
|
|
})
|
|
|
|
it('should handle multi-property assignment', () => {
|
|
s1 = Automerge.change(s1, 'multi-assign', doc => {
|
|
Object.assign(doc, {foo: 'bar', answer: 42})
|
|
})
|
|
assert.strictEqual(s1.foo, 'bar')
|
|
assert.strictEqual(s1.answer, 42)
|
|
assert.deepStrictEqual(s1, {foo: 'bar', answer: 42})
|
|
})
|
|
|
|
it('should handle root property deletion', () => {
|
|
s1 = Automerge.change(s1, 'set foo', doc => { doc.foo = 'bar'; doc.something = null })
|
|
s1 = Automerge.change(s1, 'del foo', doc => { delete doc.foo })
|
|
assert.strictEqual(s1.foo, undefined)
|
|
assert.strictEqual(s1.something, null)
|
|
assert.deepStrictEqual(s1, {something: null})
|
|
})
|
|
|
|
it('should follow JS delete behavior', () => {
|
|
s1 = Automerge.change(s1, 'set foo', doc => { doc.foo = 'bar' })
|
|
let deleted
|
|
s1 = Automerge.change(s1, 'del foo', doc => {
|
|
deleted = delete doc.foo
|
|
})
|
|
assert.strictEqual(deleted, true)
|
|
let deleted2
|
|
assert.doesNotThrow(() => {
|
|
s1 = Automerge.change(s1, 'del baz', doc => {
|
|
deleted2 = delete doc.baz
|
|
})
|
|
})
|
|
assert.strictEqual(deleted2, true)
|
|
})
|
|
|
|
it('should allow the type of a property to be changed', () => {
|
|
s1 = Automerge.change(s1, 'set number', doc => doc.prop = 123)
|
|
assert.strictEqual(s1.prop, 123)
|
|
s1 = Automerge.change(s1, 'set string', doc => doc.prop = '123')
|
|
assert.strictEqual(s1.prop, '123')
|
|
s1 = Automerge.change(s1, 'set null', doc => doc.prop = null)
|
|
assert.strictEqual(s1.prop, null)
|
|
s1 = Automerge.change(s1, 'set bool', doc => doc.prop = true)
|
|
assert.strictEqual(s1.prop, true)
|
|
})
|
|
|
|
it('should require property names to be valid', () => {
|
|
assert.throws(() => {
|
|
Automerge.change(s1, 'foo', doc => doc[''] = 'x')
|
|
}, /must not be an empty string/)
|
|
})
|
|
|
|
it('should not allow assignment of unsupported datatypes', () => {
|
|
Automerge.change(s1, doc => {
|
|
assert.throws(() => { doc.foo = undefined }, /Unsupported type of value: undefined/)
|
|
assert.throws(() => { doc.foo = {prop: undefined} }, /Unsupported type of value: undefined/)
|
|
assert.throws(() => { doc.foo = () => {} }, /Unsupported type of value: function/)
|
|
assert.throws(() => { doc.foo = Symbol('foo') }, /Unsupported type of value: symbol/)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('nested maps', () => {
|
|
it('should assign an objectId to nested maps', () => {
|
|
s1 = Automerge.change(s1, doc => { doc.nested = {} })
|
|
let id = Automerge.getObjectId(s1.nested)
|
|
assert.strictEqual(OPID_PATTERN.test(Automerge.getObjectId(s1.nested)), true)
|
|
assert.notEqual(Automerge.getObjectId(s1.nested), '_root')
|
|
})
|
|
|
|
it('should handle assignment of a nested property', () => {
|
|
s1 = Automerge.change(s1, 'first change', doc => {
|
|
doc.nested = {}
|
|
doc.nested.foo = 'bar'
|
|
})
|
|
s1 = Automerge.change(s1, 'second change', doc => {
|
|
doc.nested.one = 1
|
|
})
|
|
assert.deepStrictEqual(s1, {nested: {foo: 'bar', one: 1}})
|
|
assert.deepStrictEqual(s1.nested, {foo: 'bar', one: 1})
|
|
assert.strictEqual(s1.nested.foo, 'bar')
|
|
assert.strictEqual(s1.nested.one, 1)
|
|
})
|
|
|
|
it('should handle assignment of an object literal', () => {
|
|
s1 = Automerge.change(s1, doc => {
|
|
doc.textStyle = {bold: false, fontSize: 12}
|
|
})
|
|
assert.deepStrictEqual(s1, {textStyle: {bold: false, fontSize: 12}})
|
|
assert.deepStrictEqual(s1.textStyle, {bold: false, fontSize: 12})
|
|
assert.strictEqual(s1.textStyle.bold, false)
|
|
assert.strictEqual(s1.textStyle.fontSize, 12)
|
|
})
|
|
|
|
it('should handle assignment of multiple nested properties', () => {
|
|
s1 = Automerge.change(s1, doc => {
|
|
doc.textStyle = {bold: false, fontSize: 12}
|
|
Object.assign(doc.textStyle, {typeface: 'Optima', fontSize: 14})
|
|
})
|
|
assert.strictEqual(s1.textStyle.typeface, 'Optima')
|
|
assert.strictEqual(s1.textStyle.bold, false)
|
|
assert.strictEqual(s1.textStyle.fontSize, 14)
|
|
assert.deepStrictEqual(s1.textStyle, {typeface: 'Optima', bold: false, fontSize: 14})
|
|
})
|
|
|
|
it('should handle arbitrary-depth nesting', () => {
|
|
s1 = Automerge.change(s1, doc => {
|
|
doc.a = {b: {c: {d: {e: {f: {g: 'h'}}}}}}
|
|
})
|
|
s1 = Automerge.change(s1, doc => {
|
|
doc.a.b.c.d.e.f.i = 'j'
|
|
})
|
|
assert.deepStrictEqual(s1, {a: { b: { c: { d: { e: { f: { g: 'h', i: 'j'}}}}}}})
|
|
assert.strictEqual(s1.a.b.c.d.e.f.g, 'h')
|
|
assert.strictEqual(s1.a.b.c.d.e.f.i, 'j')
|
|
})
|
|
|
|
it('should allow an old object to be replaced with a new one', () => {
|
|
s1 = Automerge.change(s1, 'change 1', doc => {
|
|
doc.myPet = {species: 'dog', legs: 4, breed: 'dachshund'}
|
|
})
|
|
s2 = Automerge.change(s1, 'change 2', doc => {
|
|
doc.myPet = {species: 'koi', variety: '紅白', colors: {red: true, white: true, black: false}}
|
|
})
|
|
assert.deepStrictEqual(s1.myPet, {
|
|
species: 'dog', legs: 4, breed: 'dachshund'
|
|
})
|
|
assert.strictEqual(s1.myPet.breed, 'dachshund')
|
|
assert.deepStrictEqual(s2.myPet, {
|
|
species: 'koi', variety: '紅白',
|
|
colors: {red: true, white: true, black: false}
|
|
})
|
|
assert.strictEqual(s2.myPet.breed, undefined)
|
|
assert.strictEqual(s2.myPet.variety, '紅白')
|
|
})
|
|
|
|
it('should allow fields to be changed between primitive and nested map', () => {
|
|
s1 = Automerge.change(s1, doc => doc.color = '#ff7f00')
|
|
assert.strictEqual(s1.color, '#ff7f00')
|
|
s1 = Automerge.change(s1, doc => doc.color = {red: 255, green: 127, blue: 0})
|
|
assert.deepStrictEqual(s1.color, {red: 255, green: 127, blue: 0})
|
|
s1 = Automerge.change(s1, doc => doc.color = '#ff7f00')
|
|
assert.strictEqual(s1.color, '#ff7f00')
|
|
})
|
|
|
|
it('should not allow several references to the same map object', () => {
|
|
s1 = Automerge.change(s1, doc => doc.object = {})
|
|
assert.throws(() => {
|
|
Automerge.change(s1, doc => { doc.x = doc.object })
|
|
}, /Cannot create a reference to an existing document object/)
|
|
assert.throws(() => {
|
|
Automerge.change(s1, doc => { doc.x = s1.object })
|
|
}, /Cannot create a reference to an existing document object/)
|
|
assert.throws(() => {
|
|
Automerge.change(s1, doc => { doc.x = {}; doc.y = doc.x })
|
|
}, /Cannot create a reference to an existing document object/)
|
|
})
|
|
|
|
it('should not allow object-copying idioms', () => {
|
|
s1 = Automerge.change(s1, doc => {
|
|
doc.items = [{id: 'id1', name: 'one'}, {id: 'id2', name: 'two'}]
|
|
})
|
|
// People who have previously worked with immutable state in JavaScript may be tempted
|
|
// to use idioms like this, which don't work well with Automerge -- see e.g.
|
|
// https://github.com/automerge/automerge/issues/260
|
|
assert.throws(() => {
|
|
Automerge.change(s1, doc => {
|
|
doc.items = [...doc.items, {id: 'id3', name: 'three'}]
|
|
})
|
|
}, /Cannot create a reference to an existing document object/)
|
|
})
|
|
|
|
it('should handle deletion of properties within a map', () => {
|
|
s1 = Automerge.change(s1, 'set style', doc => {
|
|
doc.textStyle = {typeface: 'Optima', bold: false, fontSize: 12}
|
|
})
|
|
s1 = Automerge.change(s1, 'non-bold', doc => delete doc.textStyle.bold)
|
|
assert.strictEqual(s1.textStyle.bold, undefined)
|
|
assert.deepStrictEqual(s1.textStyle, {typeface: 'Optima', fontSize: 12})
|
|
})
|
|
|
|
it('should handle deletion of references to a map', () => {
|
|
s1 = Automerge.change(s1, 'make rich text doc', doc => {
|
|
Object.assign(doc, {title: 'Hello', textStyle: {typeface: 'Optima', fontSize: 12}})
|
|
})
|
|
s1 = Automerge.change(s1, doc => delete doc.textStyle)
|
|
assert.strictEqual(s1.textStyle, undefined)
|
|
assert.deepStrictEqual(s1, {title: 'Hello'})
|
|
})
|
|
|
|
it('should validate field names', () => {
|
|
s1 = Automerge.change(s1, doc => doc.nested = {})
|
|
assert.throws(() => { Automerge.change(s1, doc => doc.nested[''] = 'x') }, /must not be an empty string/)
|
|
assert.throws(() => { Automerge.change(s1, doc => doc.nested = {'': 'x'}) }, /must not be an empty string/)
|
|
})
|
|
})
|
|
|
|
describe('lists', () => {
|
|
it('should allow elements to be inserted', () => {
|
|
s1 = Automerge.change(s1, doc => doc.noodles = [])
|
|
s1 = Automerge.change(s1, doc => doc.noodles.insertAt(0, 'udon', 'soba'))
|
|
s1 = Automerge.change(s1, doc => doc.noodles.insertAt(1, 'ramen'))
|
|
assert.deepStrictEqual(s1, {noodles: ['udon', 'ramen', 'soba']})
|
|
assert.deepStrictEqual(s1.noodles, ['udon', 'ramen', 'soba'])
|
|
assert.strictEqual(s1.noodles[0], 'udon')
|
|
assert.strictEqual(s1.noodles[1], 'ramen')
|
|
assert.strictEqual(s1.noodles[2], 'soba')
|
|
assert.strictEqual(s1.noodles.length, 3)
|
|
})
|
|
|
|
it('should handle assignment of a list literal', () => {
|
|
s1 = Automerge.change(s1, doc => doc.noodles = ['udon', 'ramen', 'soba'])
|
|
assert.deepStrictEqual(s1, {noodles: ['udon', 'ramen', 'soba']})
|
|
assert.deepStrictEqual(s1.noodles, ['udon', 'ramen', 'soba'])
|
|
assert.strictEqual(s1.noodles[0], 'udon')
|
|
assert.strictEqual(s1.noodles[1], 'ramen')
|
|
assert.strictEqual(s1.noodles[2], 'soba')
|
|
assert.strictEqual(s1.noodles[3], undefined)
|
|
assert.strictEqual(s1.noodles.length, 3)
|
|
})
|
|
|
|
it('should only allow numeric indexes', () => {
|
|
s1 = Automerge.change(s1, doc => doc.noodles = ['udon', 'ramen', 'soba'])
|
|
s1 = Automerge.change(s1, doc => doc.noodles[1] = 'Ramen!')
|
|
assert.strictEqual(s1.noodles[1], 'Ramen!')
|
|
s1 = Automerge.change(s1, doc => doc.noodles['1'] = 'RAMEN!!!')
|
|
assert.strictEqual(s1.noodles[1], 'RAMEN!!!')
|
|
assert.throws(() => { Automerge.change(s1, doc => doc.noodles.favourite = 'udon') }, /list index must be a number/)
|
|
assert.throws(() => { Automerge.change(s1, doc => doc.noodles[''] = 'udon') }, /list index must be a number/)
|
|
assert.throws(() => { Automerge.change(s1, doc => doc.noodles['1e6'] = 'udon') }, /list index must be a number/)
|
|
})
|
|
|
|
it('should handle deletion of list elements', () => {
|
|
s1 = Automerge.change(s1, doc => doc.noodles = ['udon', 'ramen', 'soba'])
|
|
s1 = Automerge.change(s1, doc => delete doc.noodles[1])
|
|
assert.deepStrictEqual(s1.noodles, ['udon', 'soba'])
|
|
s1 = Automerge.change(s1, doc => doc.noodles.deleteAt(1))
|
|
assert.deepStrictEqual(s1.noodles, ['udon'])
|
|
assert.strictEqual(s1.noodles[0], 'udon')
|
|
assert.strictEqual(s1.noodles[1], undefined)
|
|
assert.strictEqual(s1.noodles[2], undefined)
|
|
assert.strictEqual(s1.noodles.length, 1)
|
|
})
|
|
|
|
it('should handle assignment of individual list indexes', () => {
|
|
s1 = Automerge.change(s1, doc => doc.japaneseFood = ['udon', 'ramen', 'soba'])
|
|
s1 = Automerge.change(s1, doc => doc.japaneseFood[1] = 'sushi')
|
|
assert.deepStrictEqual(s1.japaneseFood, ['udon', 'sushi', 'soba'])
|
|
assert.strictEqual(s1.japaneseFood[0], 'udon')
|
|
assert.strictEqual(s1.japaneseFood[1], 'sushi')
|
|
assert.strictEqual(s1.japaneseFood[2], 'soba')
|
|
assert.strictEqual(s1.japaneseFood[3], undefined)
|
|
assert.strictEqual(s1.japaneseFood.length, 3)
|
|
})
|
|
|
|
it('concurrent edits insert in reverse actorid order if counters equal', () => {
|
|
s1 = Automerge.init('aaaa')
|
|
s2 = Automerge.init('bbbb')
|
|
s1 = Automerge.change(s1, doc => doc.list = [])
|
|
s2 = Automerge.merge(s2, s1)
|
|
s1 = Automerge.change(s1, doc => doc.list.splice(0, 0, "2@aaaa"))
|
|
s2 = Automerge.change(s2, doc => doc.list.splice(0, 0, "2@bbbb"))
|
|
s2 = Automerge.merge(s2, s1)
|
|
assert.deepStrictEqual(Automerge.toJS(s2).list, ["2@bbbb", "2@aaaa"])
|
|
})
|
|
|
|
it('concurrent edits insert in reverse counter order if different', () => {
|
|
s1 = Automerge.init('aaaa')
|
|
s2 = Automerge.init('bbbb')
|
|
s1 = Automerge.change(s1, doc => doc.list = [])
|
|
s2 = Automerge.merge(s2, s1)
|
|
s1 = Automerge.change(s1, doc => doc.list.splice(0, 0, "2@aaaa"))
|
|
s2 = Automerge.change(s2, doc => doc.foo = "2@bbbb")
|
|
s2 = Automerge.change(s2, doc => doc.list.splice(0, 0, "3@bbbb"))
|
|
s2 = Automerge.merge(s2, s1)
|
|
assert.deepStrictEqual(s2.list, ["3@bbbb", "2@aaaa"])
|
|
})
|
|
|
|
it('should treat out-by-one assignment as insertion', () => {
|
|
s1 = Automerge.change(s1, doc => doc.japaneseFood = ['udon'])
|
|
s1 = Automerge.change(s1, doc => doc.japaneseFood[1] = 'sushi')
|
|
assert.deepStrictEqual(s1.japaneseFood, ['udon', 'sushi'])
|
|
assert.strictEqual(s1.japaneseFood[0], 'udon')
|
|
assert.strictEqual(s1.japaneseFood[1], 'sushi')
|
|
assert.strictEqual(s1.japaneseFood[2], undefined)
|
|
assert.strictEqual(s1.japaneseFood.length, 2)
|
|
})
|
|
|
|
it('should not allow out-of-range assignment', () => {
|
|
s1 = Automerge.change(s1, doc => doc.japaneseFood = ['udon'])
|
|
assert.throws(() => { Automerge.change(s1, doc => doc.japaneseFood[4] = 'ramen') }, /is out of bounds/)
|
|
})
|
|
|
|
it('should allow bulk assignment of multiple list indexes', () => {
|
|
s1 = Automerge.change(s1, doc => doc.noodles = ['udon', 'ramen', 'soba'])
|
|
s1 = Automerge.change(s1, doc => Object.assign(doc.noodles, {0: 'うどん', 2: 'そば'}))
|
|
assert.deepStrictEqual(s1.noodles, ['うどん', 'ramen', 'そば'])
|
|
assert.strictEqual(s1.noodles[0], 'うどん')
|
|
assert.strictEqual(s1.noodles[1], 'ramen')
|
|
assert.strictEqual(s1.noodles[2], 'そば')
|
|
assert.strictEqual(s1.noodles.length, 3)
|
|
})
|
|
|
|
it('should handle nested objects', () => {
|
|
s1 = Automerge.change(s1, doc => doc.noodles = [{type: 'ramen', dishes: ['tonkotsu', 'shoyu']}])
|
|
s1 = Automerge.change(s1, doc => doc.noodles.push({type: 'udon', dishes: ['tempura udon']}))
|
|
s1 = Automerge.change(s1, doc => doc.noodles[0].dishes.push('miso'))
|
|
assert.deepStrictEqual(s1, {noodles: [
|
|
{type: 'ramen', dishes: ['tonkotsu', 'shoyu', 'miso']},
|
|
{type: 'udon', dishes: ['tempura udon']}
|
|
]})
|
|
assert.deepStrictEqual(s1.noodles[0], {
|
|
type: 'ramen', dishes: ['tonkotsu', 'shoyu', 'miso']
|
|
})
|
|
assert.deepStrictEqual(s1.noodles[1], {
|
|
type: 'udon', dishes: ['tempura udon']
|
|
})
|
|
})
|
|
|
|
it('should handle nested lists', () => {
|
|
s1 = Automerge.change(s1, doc => doc.noodleMatrix = [['ramen', 'tonkotsu', 'shoyu']])
|
|
s1 = Automerge.change(s1, doc => doc.noodleMatrix.push(['udon', 'tempura udon']))
|
|
s1 = Automerge.change(s1, doc => doc.noodleMatrix[0].push('miso'))
|
|
assert.deepStrictEqual(s1.noodleMatrix, [['ramen', 'tonkotsu', 'shoyu', 'miso'], ['udon', 'tempura udon']])
|
|
assert.deepStrictEqual(s1.noodleMatrix[0], ['ramen', 'tonkotsu', 'shoyu', 'miso'])
|
|
assert.deepStrictEqual(s1.noodleMatrix[1], ['udon', 'tempura udon'])
|
|
})
|
|
|
|
it('should handle deep nesting', () => {
|
|
s1 = Automerge.change(s1, doc => doc.nesting = {
|
|
maps: { m1: { m2: { foo: "bar", baz: {} }, m2a: { } } },
|
|
lists: [ [ 1, 2, 3 ], [ [ 3, 4, 5, [6]], 7 ] ],
|
|
mapsinlists: [ { foo: "bar" }, [ { bar: "baz" } ] ],
|
|
listsinmaps: { foo: [1, 2, 3], bar: [ [ { baz: "123" } ] ] }
|
|
})
|
|
s1 = Automerge.change(s1, doc => {
|
|
doc.nesting.maps.m1a = "123"
|
|
doc.nesting.maps.m1.m2.baz.xxx = "123"
|
|
delete doc.nesting.maps.m1.m2a
|
|
doc.nesting.lists.shift()
|
|
doc.nesting.lists[0][0].pop()
|
|
doc.nesting.lists[0][0].push(100)
|
|
doc.nesting.mapsinlists[0].foo = "baz"
|
|
doc.nesting.mapsinlists[1][0].foo = "bar"
|
|
delete doc.nesting.mapsinlists[1]
|
|
doc.nesting.listsinmaps.foo.push(4)
|
|
doc.nesting.listsinmaps.bar[0][0].baz = "456"
|
|
delete doc.nesting.listsinmaps.bar
|
|
})
|
|
assert.deepStrictEqual(s1, { nesting: {
|
|
maps: { m1: { m2: { foo: "bar", baz: { xxx: "123" } } }, m1a: "123" },
|
|
lists: [ [ [ 3, 4, 5, 100 ], 7 ] ],
|
|
mapsinlists: [ { foo: "baz" } ],
|
|
listsinmaps: { foo: [1, 2, 3, 4] }
|
|
}})
|
|
})
|
|
|
|
it('should handle replacement of the entire list', () => {
|
|
s1 = Automerge.change(s1, doc => doc.noodles = ['udon', 'soba', 'ramen'])
|
|
s1 = Automerge.change(s1, doc => doc.japaneseNoodles = doc.noodles.slice())
|
|
s1 = Automerge.change(s1, doc => doc.noodles = ['wonton', 'pho'])
|
|
assert.deepStrictEqual(s1, {
|
|
noodles: ['wonton', 'pho'],
|
|
japaneseNoodles: ['udon', 'soba', 'ramen']
|
|
})
|
|
assert.deepStrictEqual(s1.noodles, ['wonton', 'pho'])
|
|
assert.strictEqual(s1.noodles[0], 'wonton')
|
|
assert.strictEqual(s1.noodles[1], 'pho')
|
|
assert.strictEqual(s1.noodles[2], undefined)
|
|
assert.strictEqual(s1.noodles.length, 2)
|
|
})
|
|
|
|
it('should allow assignment to change the type of a list element', () => {
|
|
s1 = Automerge.change(s1, doc => doc.noodles = ['udon', 'soba', 'ramen'])
|
|
assert.deepStrictEqual(s1.noodles, ['udon', 'soba', 'ramen'])
|
|
s1 = Automerge.change(s1, doc => doc.noodles[1] = {type: 'soba', options: ['hot', 'cold']})
|
|
assert.deepStrictEqual(s1.noodles, ['udon', {type: 'soba', options: ['hot', 'cold']}, 'ramen'])
|
|
s1 = Automerge.change(s1, doc => doc.noodles[1] = ['hot soba', 'cold soba'])
|
|
assert.deepStrictEqual(s1.noodles, ['udon', ['hot soba', 'cold soba'], 'ramen'])
|
|
s1 = Automerge.change(s1, doc => doc.noodles[1] = 'soba is the best')
|
|
assert.deepStrictEqual(s1.noodles, ['udon', 'soba is the best', 'ramen'])
|
|
})
|
|
|
|
it('should allow list creation and assignment in the same change callback', () => {
|
|
s1 = Automerge.change(Automerge.init(), doc => {
|
|
doc.letters = ['a', 'b', 'c']
|
|
doc.letters[1] = 'd'
|
|
})
|
|
assert.strictEqual(s1.letters[1], 'd')
|
|
})
|
|
|
|
it('should allow adding and removing list elements in the same change callback', () => {
|
|
s1 = Automerge.change(Automerge.init(), doc => doc.noodles = [])
|
|
s1 = Automerge.change(s1, doc => {
|
|
doc.noodles.push('udon')
|
|
doc.noodles.deleteAt(0)
|
|
})
|
|
assert.deepStrictEqual(s1, {noodles: []})
|
|
// do the add-remove cycle twice, test for #151 (https://github.com/automerge/automerge/issues/151)
|
|
s1 = Automerge.change(s1, doc => {
|
|
doc.noodles.push('soba')
|
|
doc.noodles.deleteAt(0)
|
|
})
|
|
assert.deepStrictEqual(s1, {noodles: []})
|
|
})
|
|
|
|
it('should handle arbitrary-depth nesting', () => {
|
|
s1 = Automerge.change(s1, doc => doc.maze = [[[[[[[['noodles', ['here']]]]]]]]])
|
|
s1 = Automerge.change(s1, doc => doc.maze[0][0][0][0][0][0][0][1].unshift('found'))
|
|
assert.deepStrictEqual(s1.maze, [[[[[[[['noodles', ['found', 'here']]]]]]]]])
|
|
assert.deepStrictEqual(s1.maze[0][0][0][0][0][0][0][1][1], 'here')
|
|
s2 = Automerge.load(Automerge.save(s1))
|
|
assert.deepStrictEqual(s1,s2)
|
|
})
|
|
|
|
it('should not allow several references to the same list object', () => {
|
|
s1 = Automerge.change(s1, doc => doc.list = [])
|
|
assert.throws(() => {
|
|
Automerge.change(s1, doc => { doc.x = doc.list })
|
|
}, /Cannot create a reference to an existing document object/)
|
|
assert.throws(() => {
|
|
Automerge.change(s1, doc => { doc.x = s1.list })
|
|
}, /Cannot create a reference to an existing document object/)
|
|
assert.throws(() => {
|
|
Automerge.change(s1, doc => { doc.x = []; doc.y = doc.x })
|
|
}, /Cannot create a reference to an existing document object/)
|
|
})
|
|
})
|
|
|
|
describe('counters', () => {
|
|
// counter
|
|
it('should allow deleting counters from maps', () => {
|
|
const s1 = Automerge.change(Automerge.init(), doc => doc.birds = {wrens: new Automerge.Counter(1)})
|
|
const s2 = Automerge.change(s1, doc => doc.birds.wrens.increment(2))
|
|
const s3 = Automerge.change(s2, doc => delete doc.birds.wrens)
|
|
assert.deepStrictEqual(s2, {birds: {wrens: new Automerge.Counter(3)}})
|
|
assert.deepStrictEqual(s3, {birds: {}})
|
|
})
|
|
|
|
// counter
|
|
/*
|
|
it('should not allow deleting counters from lists', () => {
|
|
const s1 = Automerge.change(Automerge.init(), doc => doc.recordings = [new Automerge.Counter(1)])
|
|
const s2 = Automerge.change(s1, doc => doc.recordings[0].increment(2))
|
|
assert.deepStrictEqual(s2, {recordings: [new Automerge.Counter(3)]})
|
|
assert.throws(() => { Automerge.change(s2, doc => doc.recordings.deleteAt(0)) }, /Unsupported operation/)
|
|
})
|
|
*/
|
|
})
|
|
})
|
|
|
|
describe('concurrent use', () => {
|
|
let s1, s2, s3, s4
|
|
beforeEach(() => {
|
|
s1 = Automerge.init()
|
|
s2 = Automerge.init()
|
|
s3 = Automerge.init()
|
|
s4 = Automerge.init()
|
|
})
|
|
|
|
it('should merge concurrent updates of different properties', () => {
|
|
s1 = Automerge.change(s1, doc => doc.foo = 'bar')
|
|
s2 = Automerge.change(s2, doc => doc.hello = 'world')
|
|
s3 = Automerge.merge(s1, s2)
|
|
assert.strictEqual(s3.foo, 'bar')
|
|
assert.strictEqual(s3.hello, 'world')
|
|
assert.deepStrictEqual(s3, {foo: 'bar', hello: 'world'})
|
|
assert.strictEqual(Automerge.getConflicts(s3, 'foo'), undefined)
|
|
assert.strictEqual(Automerge.getConflicts(s3, 'hello'), undefined)
|
|
s4 = Automerge.load(Automerge.save(s3))
|
|
assert.deepEqual(s3,s4)
|
|
})
|
|
|
|
it('should add concurrent increments of the same property', () => {
|
|
s1 = Automerge.change(s1, doc => doc.counter = new Automerge.Counter())
|
|
s2 = Automerge.merge(s2, s1)
|
|
s1 = Automerge.change(s1, doc => doc.counter.increment())
|
|
s2 = Automerge.change(s2, doc => doc.counter.increment(2))
|
|
s3 = Automerge.merge(s1, s2)
|
|
assert.strictEqual(s1.counter.value, 1)
|
|
assert.strictEqual(s2.counter.value, 2)
|
|
assert.strictEqual(s3.counter.value, 3)
|
|
assert.strictEqual(Automerge.getConflicts(s3, 'counter'), undefined)
|
|
s4 = Automerge.load(Automerge.save(s3))
|
|
assert.deepEqual(s3,s4)
|
|
})
|
|
|
|
it('should add increments only to the values they precede', () => {
|
|
s1 = Automerge.change(s1, doc => doc.counter = new Automerge.Counter(0))
|
|
s1 = Automerge.change(s1, doc => doc.counter.increment())
|
|
s2 = Automerge.change(s2, doc => doc.counter = new Automerge.Counter(100))
|
|
s2 = Automerge.change(s2, doc => doc.counter.increment(3))
|
|
s3 = Automerge.merge(s1, s2)
|
|
if (Automerge.getActorId(s1) > Automerge.getActorId(s2)) {
|
|
assert.deepStrictEqual(s3, {counter: new Automerge.Counter(1)})
|
|
} else {
|
|
assert.deepStrictEqual(s3, {counter: new Automerge.Counter(103)})
|
|
}
|
|
assert.deepStrictEqual(Automerge.getConflicts(s3, 'counter'), {
|
|
[`1@${Automerge.getActorId(s1)}`]: new Automerge.Counter(1),
|
|
[`1@${Automerge.getActorId(s2)}`]: new Automerge.Counter(103)
|
|
})
|
|
s4 = Automerge.load(Automerge.save(s3))
|
|
assert.deepEqual(s3,s4)
|
|
})
|
|
|
|
it('should detect concurrent updates of the same field', () => {
|
|
s1 = Automerge.change(s1, doc => doc.field = 'one')
|
|
s2 = Automerge.change(s2, doc => doc.field = 'two')
|
|
s3 = Automerge.merge(s1, s2)
|
|
if (Automerge.getActorId(s1) > Automerge.getActorId(s2)) {
|
|
assert.deepStrictEqual(s3, {field: 'one'})
|
|
} else {
|
|
assert.deepStrictEqual(s3, {field: 'two'})
|
|
}
|
|
assert.deepStrictEqual(Automerge.getConflicts(s3, 'field'), {
|
|
[`1@${Automerge.getActorId(s1)}`]: 'one',
|
|
[`1@${Automerge.getActorId(s2)}`]: 'two'
|
|
})
|
|
})
|
|
|
|
it('should detect concurrent updates of the same list element', () => {
|
|
s1 = Automerge.change(s1, doc => doc.birds = ['finch'])
|
|
s2 = Automerge.merge(s2, s1)
|
|
s1 = Automerge.change(s1, doc => doc.birds[0] = 'greenfinch')
|
|
s2 = Automerge.change(s2, doc => doc.birds[0] = 'goldfinch')
|
|
s3 = Automerge.merge(s1, s2)
|
|
if (Automerge.getActorId(s1) > Automerge.getActorId(s2)) {
|
|
assert.deepStrictEqual(s3.birds, ['greenfinch'])
|
|
} else {
|
|
assert.deepStrictEqual(s3.birds, ['goldfinch'])
|
|
}
|
|
assert.deepStrictEqual(Automerge.getConflicts(s3.birds, 0), {
|
|
[`3@${Automerge.getActorId(s1)}`]: 'greenfinch',
|
|
[`3@${Automerge.getActorId(s2)}`]: 'goldfinch'
|
|
})
|
|
})
|
|
|
|
it.skip('should handle assignment conflicts of different types', () => {
|
|
s1 = Automerge.change(s1, doc => doc.field = 'string')
|
|
s2 = Automerge.change(s2, doc => doc.field = ['list'])
|
|
s3 = Automerge.change(s3, doc => doc.field = {thing: 'map'})
|
|
s1 = Automerge.merge(Automerge.merge(s1, s2), s3)
|
|
assertEqualsOneOf(s1.field, 'string', ['list'], {thing: 'map'})
|
|
assert.deepStrictEqual(Automerge.getConflicts(s1, 'field'), {
|
|
[`1@${Automerge.getActorId(s1)}`]: 'string',
|
|
[`1@${Automerge.getActorId(s2)}`]: ['list'],
|
|
[`1@${Automerge.getActorId(s3)}`]: {thing: 'map'}
|
|
})
|
|
})
|
|
|
|
it('should handle changes within a conflicting map field', () => {
|
|
s1 = Automerge.change(s1, doc => doc.field = 'string')
|
|
s2 = Automerge.change(s2, doc => doc.field = {})
|
|
s2 = Automerge.change(s2, doc => doc.field.innerKey = 42)
|
|
s3 = Automerge.merge(s1, s2)
|
|
assertEqualsOneOf(s3.field, 'string', {innerKey: 42})
|
|
assert.deepStrictEqual(Automerge.getConflicts(s3, 'field'), {
|
|
[`1@${Automerge.getActorId(s1)}`]: 'string',
|
|
[`1@${Automerge.getActorId(s2)}`]: {innerKey: 42}
|
|
})
|
|
})
|
|
|
|
// FIXME - difficult bug here - patches arrive for conflicted subobject
|
|
it.skip('should handle changes within a conflicting list element', () => {
|
|
s1 = Automerge.change(s1, doc => doc.list = ['hello'])
|
|
s2 = Automerge.merge(s2, s1)
|
|
s1 = Automerge.change(s1, doc => doc.list[0] = {map1: true})
|
|
s1 = Automerge.change(s1, doc => doc.list[0].key = 1)
|
|
s2 = Automerge.change(s2, doc => doc.list[0] = {map2: true})
|
|
s2 = Automerge.change(s2, doc => doc.list[0].key = 2)
|
|
s3 = Automerge.merge(s1, s2)
|
|
if (Automerge.getActorId(s1) > Automerge.getActorId(s2)) {
|
|
assert.deepStrictEqual(s3.list, [{map1: true, key: 1}])
|
|
} else {
|
|
assert.deepStrictEqual(s3.list, [{map2: true, key: 2}])
|
|
}
|
|
assert.deepStrictEqual(Automerge.getConflicts(s3.list, 0), {
|
|
[`3@${Automerge.getActorId(s1)}`]: {map1: true, key: 1},
|
|
[`3@${Automerge.getActorId(s2)}`]: {map2: true, key: 2}
|
|
})
|
|
})
|
|
|
|
it('should not merge concurrently assigned nested maps', () => {
|
|
s1 = Automerge.change(s1, doc => doc.config = {background: 'blue'})
|
|
s2 = Automerge.change(s2, doc => doc.config = {logo_url: 'logo.png'})
|
|
s3 = Automerge.merge(s1, s2)
|
|
assertEqualsOneOf(s3.config, {background: 'blue'}, {logo_url: 'logo.png'})
|
|
assert.deepStrictEqual(Automerge.getConflicts(s3, 'config'), {
|
|
[`1@${Automerge.getActorId(s1)}`]: {background: 'blue'},
|
|
[`1@${Automerge.getActorId(s2)}`]: {logo_url: 'logo.png'}
|
|
})
|
|
})
|
|
|
|
it('should clear conflicts after assigning a new value', () => {
|
|
s1 = Automerge.change(s1, doc => doc.field = 'one')
|
|
s2 = Automerge.change(s2, doc => doc.field = 'two')
|
|
s3 = Automerge.merge(s1, s2)
|
|
s3 = Automerge.change(s3, doc => doc.field = 'three')
|
|
assert.deepStrictEqual(s3, {field: 'three'})
|
|
assert.strictEqual(Automerge.getConflicts(s3, 'field'), undefined)
|
|
s2 = Automerge.merge(s2, s3)
|
|
assert.deepStrictEqual(s2, {field: 'three'})
|
|
assert.strictEqual(Automerge.getConflicts(s2, 'field'), undefined)
|
|
})
|
|
|
|
it('should handle concurrent insertions at different list positions', () => {
|
|
s1 = Automerge.change(s1, doc => doc.list = ['one', 'three'])
|
|
s2 = Automerge.merge(s2, s1)
|
|
s1 = Automerge.change(s1, doc => doc.list.splice(1, 0, 'two'))
|
|
s2 = Automerge.change(s2, doc => doc.list.push('four'))
|
|
s3 = Automerge.merge(s1, s2)
|
|
assert.deepStrictEqual(s3, {list: ['one', 'two', 'three', 'four']})
|
|
assert.strictEqual(Automerge.getConflicts(s3, 'list'), undefined)
|
|
})
|
|
|
|
it('should handle concurrent insertions at the same list position', () => {
|
|
s1 = Automerge.change(s1, doc => doc.birds = ['parakeet'])
|
|
s2 = Automerge.merge(s2, s1)
|
|
s1 = Automerge.change(s1, doc => doc.birds.push('starling'))
|
|
s2 = Automerge.change(s2, doc => doc.birds.push('chaffinch'))
|
|
s3 = Automerge.merge(s1, s2)
|
|
assertEqualsOneOf(s3.birds, ['parakeet', 'starling', 'chaffinch'], ['parakeet', 'chaffinch', 'starling'])
|
|
s2 = Automerge.merge(s2, s3)
|
|
assert.deepStrictEqual(s2, s3)
|
|
})
|
|
|
|
it('should handle concurrent assignment and deletion of a map entry', () => {
|
|
// Add-wins semantics
|
|
s1 = Automerge.change(s1, doc => doc.bestBird = 'robin')
|
|
s2 = Automerge.merge(s2, s1)
|
|
s1 = Automerge.change(s1, doc => delete doc.bestBird)
|
|
s2 = Automerge.change(s2, doc => doc.bestBird = 'magpie')
|
|
s3 = Automerge.merge(s1, s2)
|
|
assert.deepStrictEqual(s1, {})
|
|
assert.deepStrictEqual(s2, {bestBird: 'magpie'})
|
|
assert.deepStrictEqual(s3, {bestBird: 'magpie'})
|
|
assert.strictEqual(Automerge.getConflicts(s3, 'bestBird'), undefined)
|
|
})
|
|
|
|
it('should handle concurrent assignment and deletion of a list element', () => {
|
|
// Concurrent assignment ressurects a deleted list element. Perhaps a little
|
|
// surprising, but consistent with add-wins semantics of maps (see test above)
|
|
s1 = Automerge.change(s1, doc => doc.birds = ['blackbird', 'thrush', 'goldfinch'])
|
|
s2 = Automerge.merge(s2, s1)
|
|
s1 = Automerge.change(s1, doc => doc.birds[1] = 'starling')
|
|
s2 = Automerge.change(s2, doc => doc.birds.splice(1, 1))
|
|
s3 = Automerge.merge(s1, s2)
|
|
assert.deepStrictEqual(s1.birds, ['blackbird', 'starling', 'goldfinch'])
|
|
assert.deepStrictEqual(s2.birds, ['blackbird', 'goldfinch'])
|
|
assert.deepStrictEqual(s3.birds, ['blackbird', 'starling', 'goldfinch'])
|
|
s4 = Automerge.load(Automerge.save(s3))
|
|
assert.deepStrictEqual(s3, s4);
|
|
})
|
|
|
|
it('should handle insertion after a deleted list element', () => {
|
|
s1 = Automerge.change(s1, doc => doc.birds = ['blackbird', 'thrush', 'goldfinch'])
|
|
s2 = Automerge.merge(s2, s1)
|
|
s1 = Automerge.change(s1, doc => doc.birds.splice(1, 2))
|
|
s2 = Automerge.change(s2, doc => doc.birds.splice(2, 0, 'starling'))
|
|
s3 = Automerge.merge(s1, s2)
|
|
assert.deepStrictEqual(s3, {birds: ['blackbird', 'starling']})
|
|
assert.deepStrictEqual(Automerge.merge(s2, s3), {birds: ['blackbird', 'starling']})
|
|
})
|
|
|
|
it('should handle concurrent deletion of the same element', () => {
|
|
s1 = Automerge.change(s1, doc => doc.birds = ['albatross', 'buzzard', 'cormorant'])
|
|
s2 = Automerge.merge(s2, s1)
|
|
s1 = Automerge.change(s1, doc => doc.birds.deleteAt(1)) // buzzard
|
|
s2 = Automerge.change(s2, doc => doc.birds.deleteAt(1)) // buzzard
|
|
s3 = Automerge.merge(s1, s2)
|
|
assert.deepStrictEqual(s3.birds, ['albatross', 'cormorant'])
|
|
})
|
|
|
|
it('should handle concurrent deletion of different elements', () => {
|
|
s1 = Automerge.change(s1, doc => doc.birds = ['albatross', 'buzzard', 'cormorant'])
|
|
s2 = Automerge.merge(s2, s1)
|
|
s1 = Automerge.change(s1, doc => doc.birds.deleteAt(0)) // albatross
|
|
s2 = Automerge.change(s2, doc => doc.birds.deleteAt(1)) // buzzard
|
|
s3 = Automerge.merge(s1, s2)
|
|
assert.deepStrictEqual(s3.birds, ['cormorant'])
|
|
})
|
|
|
|
it('should handle concurrent updates at different levels of the tree', () => {
|
|
// A delete higher up in the tree overrides an update in a subtree
|
|
s1 = Automerge.change(s1, doc => doc.animals = {birds: {pink: 'flamingo', black: 'starling'}, mammals: ['badger']})
|
|
s2 = Automerge.merge(s2, s1)
|
|
s1 = Automerge.change(s1, doc => doc.animals.birds.brown = 'sparrow')
|
|
s2 = Automerge.change(s2, doc => delete doc.animals.birds)
|
|
s3 = Automerge.merge(s1, s2)
|
|
assert.deepStrictEqual(s1.animals, {
|
|
birds: {
|
|
pink: 'flamingo', brown: 'sparrow', black: 'starling'
|
|
},
|
|
mammals: ['badger']
|
|
})
|
|
assert.deepStrictEqual(s2.animals, {mammals: ['badger']})
|
|
assert.deepStrictEqual(s3.animals, {mammals: ['badger']})
|
|
})
|
|
|
|
it('should handle updates of concurrently deleted objects', () => {
|
|
s1 = Automerge.change(s1, doc => doc.birds = {blackbird: {feathers: 'black'}})
|
|
s2 = Automerge.merge(s2, s1)
|
|
s1 = Automerge.change(s1, doc => delete doc.birds.blackbird)
|
|
s2 = Automerge.change(s2, doc => doc.birds.blackbird.beak = 'orange')
|
|
s3 = Automerge.merge(s1, s2)
|
|
assert.deepStrictEqual(s1, {birds: {}})
|
|
})
|
|
|
|
it('should not interleave sequence insertions at the same position', () => {
|
|
s1 = Automerge.change(s1, doc => doc.wisdom = [])
|
|
s2 = Automerge.merge(s2, s1)
|
|
s1 = Automerge.change(s1, doc => doc.wisdom.push('to', 'be', 'is', 'to', 'do'))
|
|
s2 = Automerge.change(s2, doc => doc.wisdom.push('to', 'do', 'is', 'to', 'be'))
|
|
s3 = Automerge.merge(s1, s2)
|
|
assertEqualsOneOf(s3.wisdom,
|
|
['to', 'be', 'is', 'to', 'do', 'to', 'do', 'is', 'to', 'be'],
|
|
['to', 'do', 'is', 'to', 'be', 'to', 'be', 'is', 'to', 'do'])
|
|
// In case you're wondering: http://quoteinvestigator.com/2013/09/16/do-be-do/
|
|
})
|
|
|
|
describe('multiple insertions at the same list position', () => {
|
|
it('should handle insertion by greater actor ID', () => {
|
|
s1 = Automerge.init('aaaa')
|
|
s2 = Automerge.init('bbbb')
|
|
s1 = Automerge.change(s1, doc => doc.list = ['two'])
|
|
s2 = Automerge.merge(s2, s1)
|
|
s2 = Automerge.change(s2, doc => doc.list.splice(0, 0, 'one'))
|
|
assert.deepStrictEqual(s2.list, ['one', 'two'])
|
|
})
|
|
|
|
it('should handle insertion by lesser actor ID', () => {
|
|
s1 = Automerge.init('bbbb')
|
|
s2 = Automerge.init('aaaa')
|
|
s1 = Automerge.change(s1, doc => doc.list = ['two'])
|
|
s2 = Automerge.merge(s2, s1)
|
|
s2 = Automerge.change(s2, doc => doc.list.splice(0, 0, 'one'))
|
|
assert.deepStrictEqual(s2.list, ['one', 'two'])
|
|
})
|
|
|
|
it('should handle insertion regardless of actor ID', () => {
|
|
s1 = Automerge.change(s1, doc => doc.list = ['two'])
|
|
s2 = Automerge.merge(s2, s1)
|
|
s2 = Automerge.change(s2, doc => doc.list.splice(0, 0, 'one'))
|
|
assert.deepStrictEqual(s2.list, ['one', 'two'])
|
|
})
|
|
|
|
it('should make insertion order consistent with causality', () => {
|
|
s1 = Automerge.change(s1, doc => doc.list = ['four'])
|
|
s2 = Automerge.merge(s2, s1)
|
|
s2 = Automerge.change(s2, doc => doc.list.unshift('three'))
|
|
s1 = Automerge.merge(s1, s2)
|
|
s1 = Automerge.change(s1, doc => doc.list.unshift('two'))
|
|
s2 = Automerge.merge(s2, s1)
|
|
s2 = Automerge.change(s2, doc => doc.list.unshift('one'))
|
|
assert.deepStrictEqual(s2.list, ['one', 'two', 'three', 'four'])
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('saving and loading', () => {
|
|
it('should save and restore an empty document', () => {
|
|
let s = Automerge.load(Automerge.save(Automerge.init()))
|
|
assert.deepStrictEqual(s, {})
|
|
})
|
|
|
|
it('should generate a new random actor ID', () => {
|
|
let s1 = Automerge.init()
|
|
let s2 = Automerge.load(Automerge.save(s1))
|
|
assert.strictEqual(UUID_PATTERN.test(Automerge.getActorId(s1).toString()), true)
|
|
assert.strictEqual(UUID_PATTERN.test(Automerge.getActorId(s2).toString()), true)
|
|
assert.notEqual(Automerge.getActorId(s1), Automerge.getActorId(s2))
|
|
})
|
|
|
|
it('should allow a custom actor ID to be set', () => {
|
|
let s = Automerge.load(Automerge.save(Automerge.init()), '333333')
|
|
assert.strictEqual(Automerge.getActorId(s), '333333')
|
|
})
|
|
|
|
it('should reconstitute complex datatypes', () => {
|
|
let s1 = Automerge.change(Automerge.init(), doc => doc.todos = [{title: 'water plants', done: false}])
|
|
let s2 = Automerge.load(Automerge.save(s1))
|
|
assert.deepStrictEqual(s2, {todos: [{title: 'water plants', done: false}]})
|
|
})
|
|
|
|
it('should save and load maps with @ symbols in the keys', () => {
|
|
let s1 = Automerge.change(Automerge.init(), doc => doc["123@4567"] = "hello")
|
|
let s2 = Automerge.load(Automerge.save(s1))
|
|
assert.deepStrictEqual(s2, { "123@4567": "hello" })
|
|
})
|
|
|
|
it('should reconstitute conflicts', () => {
|
|
let s1 = Automerge.change(Automerge.init('111111'), doc => doc.x = 3)
|
|
let s2 = Automerge.change(Automerge.init('222222'), doc => doc.x = 5)
|
|
s1 = Automerge.merge(s1, s2)
|
|
let s3 = Automerge.load(Automerge.save(s1))
|
|
assert.strictEqual(s1.x, 5)
|
|
assert.strictEqual(s3.x, 5)
|
|
assert.deepStrictEqual(Automerge.getConflicts(s1, 'x'), {'1@111111': 3, '1@222222': 5})
|
|
assert.deepStrictEqual(Automerge.getConflicts(s3, 'x'), {'1@111111': 3, '1@222222': 5})
|
|
})
|
|
|
|
it('should reconstitute element ID counters', () => {
|
|
const s1 = Automerge.init('01234567')
|
|
const s2 = Automerge.change(s1, doc => doc.list = ['a'])
|
|
const listId = Automerge.getObjectId(s2.list)
|
|
const changes12 = Automerge.getAllChanges(s2).map(decodeChange)
|
|
assert.deepStrictEqual(changes12, [{
|
|
hash: changes12[0].hash, actor: '01234567', seq: 1, startOp: 1,
|
|
time: changes12[0].time, message: '', deps: [], ops: [
|
|
{obj: '_root', action: 'makeList', key: 'list', insert: false, pred: []},
|
|
{obj: listId, action: 'set', elemId: '_head', insert: true, value: 'a', pred: []}
|
|
]
|
|
}])
|
|
const s3 = Automerge.change(s2, doc => doc.list.deleteAt(0))
|
|
const s4 = Automerge.load(Automerge.save(s3), '01234567')
|
|
const s5 = Automerge.change(s4, doc => doc.list.push('b'))
|
|
const changes45 = Automerge.getAllChanges(s5).map(decodeChange)
|
|
assert.deepStrictEqual(s5, {list: ['b']})
|
|
assert.deepStrictEqual(changes45[2], {
|
|
hash: changes45[2].hash, actor: '01234567', seq: 3, startOp: 4,
|
|
time: changes45[2].time, message: '', deps: [changes45[1].hash], ops: [
|
|
{obj: listId, action: 'set', elemId: '_head', insert: true, value: 'b', pred: []}
|
|
]
|
|
})
|
|
})
|
|
|
|
it('should allow a reloaded list to be mutated', () => {
|
|
let doc = Automerge.change(Automerge.init(), doc => doc.foo = [])
|
|
doc = Automerge.load(Automerge.save(doc))
|
|
doc = Automerge.change(doc, 'add', doc => doc.foo.push(1))
|
|
doc = Automerge.load(Automerge.save(doc))
|
|
assert.deepStrictEqual(doc.foo, [1])
|
|
})
|
|
|
|
it('should reload a document containing deflated columns', () => {
|
|
// In this test, the keyCtr column is long enough for deflate compression to kick in, but the
|
|
// keyStr column is short. Thus, the deflate bit gets set for keyCtr but not for keyStr.
|
|
// When checking whether the columns appear in ascending order, we must ignore the deflate bit.
|
|
let doc = Automerge.change(Automerge.init(), doc => {
|
|
doc.list = []
|
|
for (let i = 0; i < 200; i++) doc.list.insertAt(Math.floor(Math.random() * i), 'a')
|
|
})
|
|
Automerge.load(Automerge.save(doc))
|
|
let expected = []
|
|
for (let i = 0; i < 200; i++) expected.push('a')
|
|
assert.deepStrictEqual(doc, {list: expected})
|
|
})
|
|
|
|
it.skip('should call patchCallback if supplied to load', () => {
|
|
const s1 = Automerge.change(Automerge.init(), doc => doc.birds = ['Goldfinch'])
|
|
const s2 = Automerge.change(s1, doc => doc.birds.push('Chaffinch'))
|
|
const callbacks = [], actor = Automerge.getActorId(s1)
|
|
const reloaded = Automerge.load(Automerge.save(s2), {
|
|
patchCallback(patch, before, after, local) {
|
|
callbacks.push({patch, before, after, local})
|
|
}
|
|
})
|
|
assert.strictEqual(callbacks.length, 1)
|
|
assert.deepStrictEqual(callbacks[0].patch, {
|
|
maxOp: 3, deps: [decodeChange(Automerge.getAllChanges(s2)[1]).hash], clock: {[actor]: 2}, pendingChanges: 0,
|
|
diffs: {objectId: '_root', type: 'map', props: {birds: {[`1@${actor}`]: {
|
|
objectId: `1@${actor}`, type: 'list', edits: [
|
|
{action: 'multi-insert', index: 0, elemId: `2@${actor}`, values: ['Goldfinch', 'Chaffinch']}
|
|
]
|
|
}}}}
|
|
})
|
|
assert.deepStrictEqual(callbacks[0].before, {})
|
|
assert.strictEqual(callbacks[0].after, reloaded)
|
|
assert.strictEqual(callbacks[0].local, false)
|
|
})
|
|
})
|
|
|
|
describe('history API', () => {
|
|
it('should return an empty history for an empty document', () => {
|
|
assert.deepStrictEqual(Automerge.getHistory(Automerge.init()), [])
|
|
})
|
|
|
|
it('should make past document states accessible', () => {
|
|
let s = Automerge.init()
|
|
s = Automerge.change(s, doc => doc.config = {background: 'blue'})
|
|
s = Automerge.change(s, doc => doc.birds = ['mallard'])
|
|
s = Automerge.change(s, doc => doc.birds.unshift('oystercatcher'))
|
|
assert.deepStrictEqual(Automerge.getHistory(s).map(state => state.snapshot), [
|
|
{config: {background: 'blue'}},
|
|
{config: {background: 'blue'}, birds: ['mallard']},
|
|
{config: {background: 'blue'}, birds: ['oystercatcher', 'mallard']}
|
|
])
|
|
})
|
|
|
|
it('should make change messages accessible', () => {
|
|
let s = Automerge.init()
|
|
s = Automerge.change(s, 'Empty Bookshelf', doc => doc.books = [])
|
|
s = Automerge.change(s, 'Add Orwell', doc => doc.books.push('Nineteen Eighty-Four'))
|
|
s = Automerge.change(s, 'Add Huxley', doc => doc.books.push('Brave New World'))
|
|
assert.deepStrictEqual(s.books, ['Nineteen Eighty-Four', 'Brave New World'])
|
|
assert.deepStrictEqual(Automerge.getHistory(s).map(state => state.change.message),
|
|
['Empty Bookshelf', 'Add Orwell', 'Add Huxley'])
|
|
})
|
|
})
|
|
|
|
describe('changes API', () => {
|
|
it('should return an empty list on an empty document', () => {
|
|
let changes = Automerge.getAllChanges(Automerge.init())
|
|
assert.deepStrictEqual(changes, [])
|
|
})
|
|
|
|
it('should return an empty list when nothing changed', () => {
|
|
let s1 = Automerge.change(Automerge.init(), doc => doc.birds = ['Chaffinch'])
|
|
assert.deepStrictEqual(Automerge.getChanges(s1, s1), [])
|
|
})
|
|
|
|
it('should do nothing when applying an empty list of changes', () => {
|
|
let s1 = Automerge.change(Automerge.init(), doc => doc.birds = ['Chaffinch'])
|
|
assert.deepStrictEqual(Automerge.applyChanges(s1, [])[0], s1)
|
|
})
|
|
|
|
it('should return all changes when compared to an empty document', () => {
|
|
let s1 = Automerge.change(Automerge.init(), 'Add Chaffinch', doc => doc.birds = ['Chaffinch'])
|
|
let s2 = Automerge.change(s1, 'Add Bullfinch', doc => doc.birds.push('Bullfinch'))
|
|
let changes = Automerge.getChanges(Automerge.init(), s2)
|
|
assert.strictEqual(changes.length, 2)
|
|
})
|
|
|
|
it('should allow a document copy to be reconstructed from scratch', () => {
|
|
let s1 = Automerge.change(Automerge.init(), 'Add Chaffinch', doc => doc.birds = ['Chaffinch'])
|
|
let s2 = Automerge.change(s1, 'Add Bullfinch', doc => doc.birds.push('Bullfinch'))
|
|
let changes = Automerge.getAllChanges(s2)
|
|
let [s3] = Automerge.applyChanges(Automerge.init(), changes)
|
|
assert.deepStrictEqual(s3.birds, ['Chaffinch', 'Bullfinch'])
|
|
})
|
|
|
|
it('should return changes since the last given version', () => {
|
|
let s1 = Automerge.change(Automerge.init(), 'Add Chaffinch', doc => doc.birds = ['Chaffinch'])
|
|
let changes1 = Automerge.getAllChanges(s1)
|
|
let s2 = Automerge.change(s1, 'Add Bullfinch', doc => doc.birds.push('Bullfinch'))
|
|
let changes2 = Automerge.getChanges(s1, s2)
|
|
assert.strictEqual(changes1.length, 1) // Add Chaffinch
|
|
assert.strictEqual(changes2.length, 1) // Add Bullfinch
|
|
})
|
|
|
|
it('should incrementally apply changes since the last given version', () => {
|
|
let s1 = Automerge.change(Automerge.init(), 'Add Chaffinch', doc => doc.birds = ['Chaffinch'])
|
|
let changes1 = Automerge.getAllChanges(s1)
|
|
let s2 = Automerge.change(s1, 'Add Bullfinch', doc => doc.birds.push('Bullfinch'))
|
|
let changes2 = Automerge.getChanges(s1, s2)
|
|
let [s3] = Automerge.applyChanges(Automerge.init(), changes1)
|
|
let [s4] = Automerge.applyChanges(s3, changes2)
|
|
assert.deepStrictEqual(s3.birds, ['Chaffinch'])
|
|
assert.deepStrictEqual(s4.birds, ['Chaffinch', 'Bullfinch'])
|
|
})
|
|
|
|
it('should handle updates to a list element', () => {
|
|
let s1 = Automerge.change(Automerge.init(), doc => doc.birds = ['Chaffinch', 'Bullfinch'])
|
|
let s2 = Automerge.change(s1, doc => doc.birds[0] = 'Goldfinch')
|
|
let [s3] = Automerge.applyChanges(Automerge.init(), Automerge.getAllChanges(s2))
|
|
assert.deepStrictEqual(s3.birds, ['Goldfinch', 'Bullfinch'])
|
|
assert.strictEqual(Automerge.getConflicts(s3.birds, 0), undefined)
|
|
})
|
|
|
|
// TEXT
|
|
it('should handle updates to a text object', () => {
|
|
let s1 = Automerge.change(Automerge.init(), doc => doc.text = new Automerge.Text('ab'))
|
|
let s2 = Automerge.change(s1, doc => doc.text.set(0, 'A'))
|
|
let [s3] = Automerge.applyChanges(Automerge.init(), Automerge.getAllChanges(s2))
|
|
assert.deepStrictEqual([...s3.text], ['A', 'b'])
|
|
})
|
|
|
|
/*
|
|
it.skip('should report missing dependencies', () => {
|
|
let s1 = Automerge.change(Automerge.init(), doc => doc.birds = ['Chaffinch'])
|
|
let s2 = Automerge.merge(Automerge.init(), s1)
|
|
s2 = Automerge.change(s2, doc => doc.birds.push('Bullfinch'))
|
|
let changes = Automerge.getAllChanges(s2)
|
|
let [s3, patch] = Automerge.applyChanges(Automerge.init(), [changes[1]])
|
|
assert.deepStrictEqual(s3, {})
|
|
assert.deepStrictEqual(Automerge.Backend.getMissingDeps(Automerge.Frontend.getBackendState(s3)),
|
|
decodeChange(changes[1]).deps)
|
|
assert.strictEqual(patch.pendingChanges, 1)
|
|
;[s3, patch] = Automerge.applyChanges(s3, [changes[0]])
|
|
assert.deepStrictEqual(s3.birds, ['Chaffinch', 'Bullfinch'])
|
|
assert.deepStrictEqual(Automerge.Backend.getMissingDeps(Automerge.Frontend.getBackendState(s3)), [])
|
|
assert.strictEqual(patch.pendingChanges, 0)
|
|
})
|
|
*/
|
|
|
|
it('should report missing dependencies with out-of-order applyChanges', () => {
|
|
let s0 = Automerge.init()
|
|
let s1 = Automerge.change(s0, doc => doc.test = ['a'])
|
|
let changes01 = Automerge.getAllChanges(s1)
|
|
let s2 = Automerge.change(s1, doc => doc.test = ['b'])
|
|
let changes12 = Automerge.getChanges(s1, s2)
|
|
let s3 = Automerge.change(s2, doc => doc.test = ['c'])
|
|
let changes23 = Automerge.getChanges(s2, s3)
|
|
let s4 = Automerge.init()
|
|
let [s5] = Automerge.applyChanges(s4, changes23)
|
|
let [s6] = Automerge.applyChanges(s5, changes12)
|
|
assert.deepStrictEqual(Automerge.getMissingDeps(s6), [decodeChange(changes01[0]).hash])
|
|
})
|
|
|
|
it('should call patchCallback if supplied when applying changes', () => {
|
|
const s1 = Automerge.change(Automerge.init(), doc => doc.birds = ['Goldfinch'])
|
|
const callbacks = [], actor = Automerge.getActorId(s1)
|
|
const before = Automerge.init()
|
|
const [after, patch] = Automerge.applyChanges(before, Automerge.getAllChanges(s1), {
|
|
patchCallback(patch, before, after) {
|
|
callbacks.push({patch, before, after})
|
|
}
|
|
})
|
|
assert.strictEqual(callbacks.length, 2)
|
|
assert.deepStrictEqual(callbacks[0].patch, { action: 'put', path: ["birds"], value: [], conflict: false })
|
|
assert.deepStrictEqual(callbacks[1].patch, { action: 'splice', path: ["birds",0], values: ["Goldfinch"] })
|
|
assert.strictEqual(callbacks[0].before, before)
|
|
assert.strictEqual(callbacks[1].after, after)
|
|
})
|
|
|
|
it('should merge multiple applied changes into one patch', () => {
|
|
const s1 = Automerge.change(Automerge.init(), doc => doc.birds = ['Goldfinch'])
|
|
const s2 = Automerge.change(s1, doc => doc.birds.push('Chaffinch'))
|
|
const patches = [], actor = Automerge.getActorId(s2)
|
|
Automerge.applyChanges(Automerge.init(), Automerge.getAllChanges(s2),
|
|
{patchCallback: p => patches.push(p)})
|
|
assert.deepStrictEqual(patches, [
|
|
{ action: 'put', conflict: false, path: [ 'birds' ], value: [] },
|
|
{ action: "splice", path: [ "birds", 0 ], values: [ "Goldfinch", "Chaffinch" ] }
|
|
])
|
|
})
|
|
|
|
it('should call a patchCallback registered on doc initialisation', () => {
|
|
const s1 = Automerge.change(Automerge.init(), doc => doc.bird = 'Goldfinch')
|
|
const patches = [], actor = Automerge.getActorId(s1)
|
|
const before = Automerge.init({patchCallback: p => patches.push(p)})
|
|
Automerge.applyChanges(before, Automerge.getAllChanges(s1))
|
|
assert.deepStrictEqual(patches, [{
|
|
action: "put",
|
|
conflict: false,
|
|
path: [ "bird" ],
|
|
value: "Goldfinch" }
|
|
])
|
|
})
|
|
})
|
|
})
|