automerge/javascript/test/basic_test.ts
Alex Good 9271b20cf5 Correct logic when skip = B and fix formatting
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.
2023-02-14 17:21:59 +00:00

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)
})
})
})