9271b20cf5
A few tests were failing which exposed the fact that if skip is `B` (the out factor of the OpTree) then we set `skip = None` and this causes us to attempt to return `Skip` in a non root node. I ported the failing test from JS to Rust and fixed the problem. I also fixed the formatting issues.
488 lines
15 KiB
TypeScript
488 lines
15 KiB
TypeScript
import * as assert from "assert"
|
|
import { unstable as Automerge } from "../src"
|
|
import * as WASM from "@automerge/automerge-wasm"
|
|
|
|
describe("Automerge", () => {
|
|
describe("basics", () => {
|
|
it("should init clone and free", () => {
|
|
let doc1 = Automerge.init()
|
|
let doc2 = Automerge.clone(doc1)
|
|
|
|
// this is only needed if weakrefs are not supported
|
|
Automerge.free(doc1)
|
|
Automerge.free(doc2)
|
|
})
|
|
|
|
it("should be able to make a view with specifc heads", () => {
|
|
let doc1 = Automerge.init<any>()
|
|
let doc2 = Automerge.change(doc1, d => (d.value = 1))
|
|
let heads2 = Automerge.getHeads(doc2)
|
|
let doc3 = Automerge.change(doc2, d => (d.value = 2))
|
|
let doc2_v2 = Automerge.view(doc3, heads2)
|
|
assert.deepEqual(doc2, doc2_v2)
|
|
let doc2_v2_clone = Automerge.clone(doc2, "aabbcc")
|
|
assert.deepEqual(doc2, doc2_v2_clone)
|
|
assert.equal(Automerge.getActorId(doc2_v2_clone), "aabbcc")
|
|
})
|
|
|
|
it("should allow you to change a clone of a view", () => {
|
|
let doc1 = Automerge.init<any>()
|
|
doc1 = Automerge.change(doc1, d => (d.key = "value"))
|
|
let heads = Automerge.getHeads(doc1)
|
|
doc1 = Automerge.change(doc1, d => (d.key = "value2"))
|
|
let fork = Automerge.clone(Automerge.view(doc1, heads))
|
|
assert.deepEqual(fork, { key: "value" })
|
|
fork = Automerge.change(fork, d => (d.key = "value3"))
|
|
assert.deepEqual(fork, { key: "value3" })
|
|
})
|
|
|
|
it("handle basic set and read on root object", () => {
|
|
let doc1 = Automerge.init<any>()
|
|
let doc2 = Automerge.change(doc1, d => {
|
|
d.hello = "world"
|
|
d.big = "little"
|
|
d.zip = "zop"
|
|
d.app = "dap"
|
|
assert.deepEqual(d, {
|
|
hello: "world",
|
|
big: "little",
|
|
zip: "zop",
|
|
app: "dap",
|
|
})
|
|
})
|
|
assert.deepEqual(doc2, {
|
|
hello: "world",
|
|
big: "little",
|
|
zip: "zop",
|
|
app: "dap",
|
|
})
|
|
})
|
|
|
|
it("should be able to insert and delete a large number of properties", () => {
|
|
let doc = Automerge.init<any>()
|
|
|
|
doc = Automerge.change(doc, doc => {
|
|
doc["k1"] = true
|
|
})
|
|
|
|
for (let idx = 1; idx <= 200; idx++) {
|
|
doc = Automerge.change(doc, doc => {
|
|
delete doc["k" + idx]
|
|
doc["k" + (idx + 1)] = true
|
|
assert(Object.keys(doc).length == 1)
|
|
})
|
|
}
|
|
})
|
|
|
|
it("can detect an automerge doc with isAutomerge()", () => {
|
|
const doc1 = Automerge.from({ sub: { object: true } })
|
|
assert(Automerge.isAutomerge(doc1))
|
|
assert(!Automerge.isAutomerge(doc1.sub))
|
|
assert(!Automerge.isAutomerge("String"))
|
|
assert(!Automerge.isAutomerge({ sub: { object: true } }))
|
|
assert(!Automerge.isAutomerge(undefined))
|
|
const jsObj = Automerge.toJS(doc1)
|
|
assert(!Automerge.isAutomerge(jsObj))
|
|
assert.deepEqual(jsObj, doc1)
|
|
})
|
|
|
|
it("it should recursively freeze the document if requested", () => {
|
|
let doc1 = Automerge.init<any>({ freeze: true })
|
|
let doc2 = Automerge.init<any>()
|
|
|
|
assert(Object.isFrozen(doc1))
|
|
assert(!Object.isFrozen(doc2))
|
|
|
|
// will also freeze sub objects
|
|
doc1 = Automerge.change(
|
|
doc1,
|
|
doc => (doc.book = { title: "how to win friends" })
|
|
)
|
|
doc2 = Automerge.merge(doc2, doc1)
|
|
assert(Object.isFrozen(doc1))
|
|
assert(Object.isFrozen(doc1.book))
|
|
assert(!Object.isFrozen(doc2))
|
|
assert(!Object.isFrozen(doc2.book))
|
|
|
|
// works on from
|
|
let doc3 = Automerge.from({ sub: { obj: "inner" } }, { freeze: true })
|
|
assert(Object.isFrozen(doc3))
|
|
assert(Object.isFrozen(doc3.sub))
|
|
|
|
// works on load
|
|
let doc4 = Automerge.load<any>(Automerge.save(doc3), { freeze: true })
|
|
assert(Object.isFrozen(doc4))
|
|
assert(Object.isFrozen(doc4.sub))
|
|
|
|
// follows clone
|
|
let doc5 = Automerge.clone(doc4)
|
|
assert(Object.isFrozen(doc5))
|
|
assert(Object.isFrozen(doc5.sub))
|
|
|
|
// toJS does not freeze
|
|
let exported = Automerge.toJS(doc5)
|
|
assert(!Object.isFrozen(exported))
|
|
})
|
|
|
|
it("handle basic sets over many changes", () => {
|
|
let doc1 = Automerge.init<any>()
|
|
let timestamp = new Date()
|
|
let counter = new Automerge.Counter(100)
|
|
let bytes = new Uint8Array([10, 11, 12])
|
|
let doc2 = Automerge.change(doc1, d => {
|
|
d.hello = "world"
|
|
})
|
|
let doc3 = Automerge.change(doc2, d => {
|
|
d.counter1 = counter
|
|
})
|
|
let doc4 = Automerge.change(doc3, d => {
|
|
d.timestamp1 = timestamp
|
|
})
|
|
let doc5 = Automerge.change(doc4, d => {
|
|
d.app = null
|
|
})
|
|
let doc6 = Automerge.change(doc5, d => {
|
|
d.bytes1 = bytes
|
|
})
|
|
let doc7 = Automerge.change(doc6, d => {
|
|
d.uint = new Automerge.Uint(1)
|
|
d.int = new Automerge.Int(-1)
|
|
d.float64 = new Automerge.Float64(5.5)
|
|
d.number1 = 100
|
|
d.number2 = -45.67
|
|
d.true = true
|
|
d.false = false
|
|
})
|
|
|
|
assert.deepEqual(doc7, {
|
|
hello: "world",
|
|
true: true,
|
|
false: false,
|
|
int: -1,
|
|
uint: 1,
|
|
float64: 5.5,
|
|
number1: 100,
|
|
number2: -45.67,
|
|
counter1: counter,
|
|
timestamp1: timestamp,
|
|
bytes1: bytes,
|
|
app: null,
|
|
})
|
|
|
|
let changes = Automerge.getAllChanges(doc7)
|
|
let t1 = Automerge.init()
|
|
let [t2] = Automerge.applyChanges(t1, changes)
|
|
assert.deepEqual(doc7, t2)
|
|
})
|
|
|
|
it("handle overwrites to values", () => {
|
|
let doc1 = Automerge.init<any>()
|
|
let doc2 = Automerge.change(doc1, d => {
|
|
d.hello = "world1"
|
|
})
|
|
let doc3 = Automerge.change(doc2, d => {
|
|
d.hello = "world2"
|
|
})
|
|
let doc4 = Automerge.change(doc3, d => {
|
|
d.hello = "world3"
|
|
})
|
|
let doc5 = Automerge.change(doc4, d => {
|
|
d.hello = "world4"
|
|
})
|
|
assert.deepEqual(doc5, { hello: "world4" })
|
|
})
|
|
|
|
it("handle set with object value", () => {
|
|
let doc1 = Automerge.init<any>()
|
|
let doc2 = Automerge.change(doc1, d => {
|
|
d.subobj = { hello: "world", subsubobj: { zip: "zop" } }
|
|
})
|
|
assert.deepEqual(doc2, {
|
|
subobj: { hello: "world", subsubobj: { zip: "zop" } },
|
|
})
|
|
})
|
|
|
|
it("handle simple list creation", () => {
|
|
let doc1 = Automerge.init<any>()
|
|
let doc2 = Automerge.change(doc1, d => (d.list = []))
|
|
assert.deepEqual(doc2, { list: [] })
|
|
})
|
|
|
|
it("handle simple lists", () => {
|
|
let doc1 = Automerge.init<any>()
|
|
let doc2 = Automerge.change(doc1, d => {
|
|
d.list = [1, 2, 3]
|
|
})
|
|
assert.deepEqual(doc2.list.length, 3)
|
|
assert.deepEqual(doc2.list[0], 1)
|
|
assert.deepEqual(doc2.list[1], 2)
|
|
assert.deepEqual(doc2.list[2], 3)
|
|
assert.deepEqual(doc2, { list: [1, 2, 3] })
|
|
// assert.deepStrictEqual(Automerge.toJS(doc2), { list: [1,2,3] })
|
|
|
|
let doc3 = Automerge.change(doc2, d => {
|
|
d.list[1] = "a"
|
|
})
|
|
|
|
assert.deepEqual(doc3.list.length, 3)
|
|
assert.deepEqual(doc3.list[0], 1)
|
|
assert.deepEqual(doc3.list[1], "a")
|
|
assert.deepEqual(doc3.list[2], 3)
|
|
assert.deepEqual(doc3, { list: [1, "a", 3] })
|
|
})
|
|
it("handle simple lists", () => {
|
|
let doc1 = Automerge.init<any>()
|
|
let doc2 = Automerge.change(doc1, d => {
|
|
d.list = [1, 2, 3]
|
|
})
|
|
let changes = Automerge.getChanges(doc1, doc2)
|
|
let docB1 = Automerge.init()
|
|
let [docB2] = Automerge.applyChanges(docB1, changes)
|
|
assert.deepEqual(docB2, doc2)
|
|
})
|
|
it("handle text", () => {
|
|
let doc1 = Automerge.init<any>()
|
|
let doc2 = Automerge.change(doc1, d => {
|
|
d.list = "hello"
|
|
Automerge.splice(d, "list", 2, 0, "Z")
|
|
})
|
|
let changes = Automerge.getChanges(doc1, doc2)
|
|
let docB1 = Automerge.init()
|
|
let [docB2] = Automerge.applyChanges(docB1, changes)
|
|
assert.deepEqual(docB2, doc2)
|
|
})
|
|
|
|
it("handle non-text strings", () => {
|
|
let doc1 = WASM.create(true)
|
|
doc1.put("_root", "text", "hello world")
|
|
let doc2 = Automerge.load<any>(doc1.save())
|
|
assert.throws(() => {
|
|
Automerge.change(doc2, d => {
|
|
Automerge.splice(d, "text", 1, 0, "Z")
|
|
})
|
|
}, /Cannot splice/)
|
|
})
|
|
|
|
it("have many list methods", () => {
|
|
let doc1 = Automerge.from({ list: [1, 2, 3] })
|
|
assert.deepEqual(doc1, { list: [1, 2, 3] })
|
|
let doc2 = Automerge.change(doc1, d => {
|
|
d.list.splice(1, 1, 9, 10)
|
|
})
|
|
assert.deepEqual(doc2, { list: [1, 9, 10, 3] })
|
|
let doc3 = Automerge.change(doc2, d => {
|
|
d.list.push(11, 12)
|
|
})
|
|
assert.deepEqual(doc3, { list: [1, 9, 10, 3, 11, 12] })
|
|
let doc4 = Automerge.change(doc3, d => {
|
|
d.list.unshift(2, 2)
|
|
})
|
|
assert.deepEqual(doc4, { list: [2, 2, 1, 9, 10, 3, 11, 12] })
|
|
let doc5 = Automerge.change(doc4, d => {
|
|
d.list.shift()
|
|
})
|
|
assert.deepEqual(doc5, { list: [2, 1, 9, 10, 3, 11, 12] })
|
|
let doc6 = Automerge.change(doc5, d => {
|
|
d.list.insertAt(3, 100, 101)
|
|
})
|
|
assert.deepEqual(doc6, { list: [2, 1, 9, 100, 101, 10, 3, 11, 12] })
|
|
})
|
|
|
|
it("allows access to the backend", () => {
|
|
let doc = Automerge.init()
|
|
assert.deepEqual(Object.keys(Automerge.getBackend(doc)), ["ptr"])
|
|
})
|
|
|
|
it("lists and text have indexof", () => {
|
|
let doc = Automerge.from({
|
|
list: [0, 1, 2, 3, 4, 5, 6],
|
|
text: "hello world",
|
|
})
|
|
assert.deepEqual(doc.list.indexOf(5), 5)
|
|
assert.deepEqual(doc.text.indexOf("world"), 6)
|
|
})
|
|
})
|
|
|
|
describe("emptyChange", () => {
|
|
it("should generate a hash", () => {
|
|
let doc = Automerge.init()
|
|
doc = Automerge.change<any>(doc, d => {
|
|
d.key = "value"
|
|
})
|
|
Automerge.save(doc)
|
|
let headsBefore = Automerge.getHeads(doc)
|
|
headsBefore.sort()
|
|
doc = Automerge.emptyChange(doc, "empty change")
|
|
let headsAfter = Automerge.getHeads(doc)
|
|
headsAfter.sort()
|
|
assert.notDeepEqual(headsBefore, headsAfter)
|
|
})
|
|
})
|
|
|
|
describe("proxy lists", () => {
|
|
it("behave like arrays", () => {
|
|
let doc = Automerge.from({
|
|
chars: ["a", "b", "c"],
|
|
numbers: [20, 3, 100],
|
|
repeats: [20, 20, 3, 3, 3, 3, 100, 100],
|
|
})
|
|
let r1: Array<number> = []
|
|
doc = Automerge.change(doc, d => {
|
|
assert.deepEqual((d.chars as any[]).concat([1, 2]), [
|
|
"a",
|
|
"b",
|
|
"c",
|
|
1,
|
|
2,
|
|
])
|
|
assert.deepEqual(
|
|
d.chars.map(n => n + "!"),
|
|
["a!", "b!", "c!"]
|
|
)
|
|
assert.deepEqual(
|
|
d.numbers.map(n => n + 10),
|
|
[30, 13, 110]
|
|
)
|
|
assert.deepEqual(d.numbers.toString(), "20,3,100")
|
|
assert.deepEqual(d.numbers.toLocaleString(), "20,3,100")
|
|
assert.deepEqual(
|
|
d.numbers.forEach((n: number) => r1.push(n)),
|
|
undefined
|
|
)
|
|
assert.deepEqual(
|
|
d.numbers.every(n => n > 1),
|
|
true
|
|
)
|
|
assert.deepEqual(
|
|
d.numbers.every(n => n > 10),
|
|
false
|
|
)
|
|
assert.deepEqual(
|
|
d.numbers.filter(n => n > 10),
|
|
[20, 100]
|
|
)
|
|
assert.deepEqual(
|
|
d.repeats.find(n => n < 10),
|
|
3
|
|
)
|
|
assert.deepEqual(
|
|
d.repeats.find(n => n < 10),
|
|
3
|
|
)
|
|
assert.deepEqual(
|
|
d.repeats.find(n => n < 0),
|
|
undefined
|
|
)
|
|
assert.deepEqual(
|
|
d.repeats.findIndex(n => n < 10),
|
|
2
|
|
)
|
|
assert.deepEqual(
|
|
d.repeats.findIndex(n => n < 0),
|
|
-1
|
|
)
|
|
assert.deepEqual(
|
|
d.repeats.findIndex(n => n < 10),
|
|
2
|
|
)
|
|
assert.deepEqual(
|
|
d.repeats.findIndex(n => n < 0),
|
|
-1
|
|
)
|
|
assert.deepEqual(d.numbers.includes(3), true)
|
|
assert.deepEqual(d.numbers.includes(-3), false)
|
|
assert.deepEqual(d.numbers.join("|"), "20|3|100")
|
|
assert.deepEqual(d.numbers.join(), "20,3,100")
|
|
assert.deepEqual(
|
|
d.numbers.some(f => f === 3),
|
|
true
|
|
)
|
|
assert.deepEqual(
|
|
d.numbers.some(f => f < 0),
|
|
false
|
|
)
|
|
assert.deepEqual(
|
|
d.numbers.reduce((sum, n) => sum + n, 100),
|
|
223
|
|
)
|
|
assert.deepEqual(
|
|
d.repeats.reduce((sum, n) => sum + n, 100),
|
|
352
|
|
)
|
|
assert.deepEqual(
|
|
d.chars.reduce((sum, n) => sum + n, "="),
|
|
"=abc"
|
|
)
|
|
assert.deepEqual(
|
|
d.chars.reduceRight((sum, n) => sum + n, "="),
|
|
"=cba"
|
|
)
|
|
assert.deepEqual(
|
|
d.numbers.reduceRight((sum, n) => sum + n, 100),
|
|
223
|
|
)
|
|
assert.deepEqual(d.repeats.lastIndexOf(3), 5)
|
|
assert.deepEqual(d.repeats.lastIndexOf(3, 3), 3)
|
|
})
|
|
doc = Automerge.change(doc, d => {
|
|
assert.deepEqual(d.numbers.fill(-1, 1, 2), [20, -1, 100])
|
|
assert.deepEqual(d.chars.fill("z", 1, 100), ["a", "z", "z"])
|
|
})
|
|
assert.deepEqual(r1, [20, 3, 100])
|
|
assert.deepEqual(doc.numbers, [20, -1, 100])
|
|
assert.deepEqual(doc.chars, ["a", "z", "z"])
|
|
})
|
|
})
|
|
|
|
it("should obtain the same conflicts, regardless of merge order", () => {
|
|
let s1 = Automerge.init<any>()
|
|
let s2 = Automerge.init<any>()
|
|
s1 = Automerge.change(s1, doc => {
|
|
doc.x = 1
|
|
doc.y = 2
|
|
})
|
|
s2 = Automerge.change(s2, doc => {
|
|
doc.x = 3
|
|
doc.y = 4
|
|
})
|
|
const m1 = Automerge.merge(Automerge.clone(s1), Automerge.clone(s2))
|
|
const m2 = Automerge.merge(Automerge.clone(s2), Automerge.clone(s1))
|
|
assert.deepStrictEqual(
|
|
Automerge.getConflicts(m1, "x"),
|
|
Automerge.getConflicts(m2, "x")
|
|
)
|
|
})
|
|
|
|
describe("getObjectId", () => {
|
|
let s1 = Automerge.from({
|
|
string: "string",
|
|
number: 1,
|
|
null: null,
|
|
date: new Date(),
|
|
counter: new Automerge.Counter(),
|
|
bytes: new Uint8Array(10),
|
|
text: "",
|
|
list: [],
|
|
map: {},
|
|
})
|
|
|
|
it("should return null for scalar values", () => {
|
|
assert.equal(Automerge.getObjectId(s1.string), null)
|
|
assert.equal(Automerge.getObjectId(s1.number), null)
|
|
assert.equal(Automerge.getObjectId(s1.null!), null)
|
|
assert.equal(Automerge.getObjectId(s1.date), null)
|
|
assert.equal(Automerge.getObjectId(s1.counter), null)
|
|
assert.equal(Automerge.getObjectId(s1.bytes), null)
|
|
})
|
|
|
|
it("should return _root for the root object", () => {
|
|
assert.equal(Automerge.getObjectId(s1), "_root")
|
|
})
|
|
|
|
it("should return non-null for map, list, text, and objects", () => {
|
|
assert.equal(Automerge.getObjectId(s1.text), null)
|
|
assert.notEqual(Automerge.getObjectId(s1.list), null)
|
|
assert.notEqual(Automerge.getObjectId(s1.map), null)
|
|
})
|
|
})
|
|
})
|