@automerge/automerge-repo 1.0.17 → 1.0.19

package/test/Repo.test.ts

@@ -1,9 +1,10 @@
+import { next as A } from "@automerge/automerge"
 import { MessageChannelNetworkAdapter } from "@automerge/automerge-repo-network-messagechannel"
 import assert from "assert"
 import * as Uuid from "uuid"
 import { describe, it } from "vitest"
+import { DocHandleRemoteHeadsPayload, READY } from "../src/DocHandle.js"
 import { parseAutomergeUrl } from "../src/AutomergeUrl.js"
-import { READY } from "../src/DocHandle.js"
 import {
   generateAutomergeUrl,
   stringifyAutomergeUrl,
@@ -425,24 +426,31 @@ describe("Repo", () => {
 
       const aliceNetworkAdapter = new MessageChannelNetworkAdapter(ab)
 
+      const alice = "alice" as PeerId
       const aliceRepo = new Repo({
         network: connectAlice ? [aliceNetworkAdapter] : [],
-        peerId: "alice" as PeerId,
+        peerId: alice,
         sharePolicy,
       })
 
+      const bob = "bob" as PeerId
+      const bobStorage = new DummyStorageAdapter()
       const bobRepo = new Repo({
+        storage: bobStorage,
         network: [
           new MessageChannelNetworkAdapter(ba),
           new MessageChannelNetworkAdapter(bc),
         ],
-        peerId: "bob" as PeerId,
+        peerId: bob,
         sharePolicy,
       })
 
+      const charlie = "charlie" as PeerId
+      const charlieStorage = new DummyStorageAdapter()
       const charlieRepo = new Repo({
+        storage: charlieStorage,
         network: [new MessageChannelNetworkAdapter(cb)],
-        peerId: "charlie" as PeerId,
+        peerId: charlie,
       })
 
       const teardown = () => {
@@ -488,8 +496,13 @@ describe("Repo", () => {
       ])
 
       return {
+        alice,
         aliceRepo,
+        bob,
+        bobStorage,
         bobRepo,
+        charlie,
+        charlieStorage,
         charlieRepo,
         aliceHandle,
         notForCharlie,
@@ -541,6 +554,9 @@ describe("Repo", () => {
       const handle = charlieRepo.find<TestDoc>(
         stringifyAutomergeUrl({ documentId: notForCharlie })
       )
+
+      await pause(50)
+
       const doc = await handle.doc()
 
       assert.deepStrictEqual(doc, { foo: "baz" })
@@ -554,6 +570,9 @@ describe("Repo", () => {
       const handle = charlieRepo.find<TestDoc>(
         stringifyAutomergeUrl({ documentId: notForBob })
       )
+
+      await pause(50)
+
       const doc = await handle.doc()
       assert.deepStrictEqual(doc, { foo: "bap" })
 
@@ -768,6 +787,142 @@ describe("Repo", () => {
       await charliePromise
       teardown()
     })
+
+    it("should save sync state of other peers", async () => {
+      const { bobRepo, teardown, charlie } = await setup({
+        connectAlice: false,
+      })
+
+      const bobHandle = bobRepo.create<TestDoc>()
+      bobHandle.change(d => {
+        d.foo = "bar"
+      })
+
+      await pause(200)
+
+      // bob should store the sync state of charlie
+      const storedSyncState = await bobRepo.storageSubsystem.loadSyncState(
+        bobHandle.documentId,
+        charlie
+      )
+      const docHeads = A.getHeads(bobHandle.docSync())
+      assert.deepStrictEqual(storedSyncState.sharedHeads, docHeads)
+
+      teardown()
+    })
+
+    it("should load sync state from storage", async () => {
+      const { bobRepo, teardown, charlie, charlieRepo, bobStorage, bob } =
+        await setup({
+          connectAlice: false,
+        })
+
+      // create a new doc and count sync messages
+      const bobHandle = bobRepo.create<TestDoc>()
+      bobHandle.change(d => {
+        d.foo = "bar"
+      })
+      let bobSyncMessages = 0
+      bobRepo.networkSubsystem.on("message", () => {
+        bobSyncMessages++
+      })
+      await pause(500)
+
+      // repo has no stored sync state for charlie so we should see two sync messages
+      assert.strictEqual(bobSyncMessages, 2)
+
+      // setup new repo which uses bob's storage
+      const bob2Repo = new Repo({
+        storage: bobStorage,
+        network: [],
+        peerId: "bob-2" as PeerId,
+      })
+
+      // connnect it with charlie
+      const channel = new MessageChannel()
+      bob2Repo.networkSubsystem.addNetworkAdapter(
+        new MessageChannelNetworkAdapter(channel.port2)
+      )
+      charlieRepo.networkSubsystem.addNetworkAdapter(
+        new MessageChannelNetworkAdapter(channel.port1)
+      )
+
+      // lookup doc we've previously created and count the messages
+      bob2Repo.find(bobHandle.documentId)
+      let bob2SyncMessages = 0
+      bob2Repo.networkSubsystem.on("message", m => {
+        bob2SyncMessages++
+      })
+      await pause(100)
+
+      // repo has stored sync state for charlie so we should see one sync messages
+      assert.strictEqual(bob2SyncMessages, 1)
+
+      channel.port1.close()
+      teardown()
+    })
+
+    it("should report the remote heads when they change", async () => {
+      const { bobRepo, charlieRepo, teardown } = await setup({
+        connectAlice: false,
+      })
+
+      const handle = bobRepo.create<TestDoc>()
+      handle.change(d => {
+        d.foo = "bar"
+      })
+
+      // pause to let the sync happen
+      await pause(50)
+
+      const nextRemoteHeadsPromise = new Promise<{
+        peerId: PeerId
+        heads: A.Heads
+      }>(resolve => {
+        handle.on("remote-heads", ({ peerId, heads }) => {
+          resolve({ peerId, heads })
+        })
+      })
+
+      const charlieHandle = charlieRepo.find<TestDoc>(handle.url)
+      await charlieHandle.whenReady()
+
+      // make a change on charlie
+      charlieHandle.change(d => {
+        d.foo = "baz"
+      })
+
+      // pause to let the sync happen
+      await pause(100)
+
+      const charlieHeads = A.getHeads(charlieHandle.docSync())
+      const bobHeads = A.getHeads(handle.docSync())
+
+      assert.deepStrictEqual(charlieHeads, bobHeads)
+
+      const nextRemoteHeads = await nextRemoteHeadsPromise
+      assert.deepStrictEqual(nextRemoteHeads.peerId, "charlie")
+      assert.deepStrictEqual(nextRemoteHeads.heads, charlieHeads)
+
+      assert.deepStrictEqual(
+        handle.getRemoteHeads("charlie" as PeerId),
+        A.getHeads(charlieHandle.docSync())
+      )
+
+      teardown()
+    })
+
+    it("can report the connected peers", async () => {
+      const { bobRepo, charlieRepo, teardown } = await setup()
+
+      // pause to let the connections happen
+      await pause(1)
+
+      assert.deepStrictEqual(bobRepo.peers, ["alice", "charlie"])
+      assert.deepStrictEqual(charlieRepo.peers, ["bob"])
+
+      teardown()
+    })
   })
 
   describe("with peers (mesh network)", () => {

package/test/StorageSubsystem.test.ts

@@ -6,10 +6,9 @@ import os from "os"
 import path from "path"
 import { describe, it } from "vitest"
 import { generateAutomergeUrl, parseAutomergeUrl } from "../src/AutomergeUrl.js"
+import { PeerId, cbor } from "../src/index.js"
 import { StorageSubsystem } from "../src/storage/StorageSubsystem.js"
 import { DummyStorageAdapter } from "./helpers/DummyStorageAdapter.js"
-import { cbor } from "../src/index.js"
-import { pause } from "../src/helpers/pause.js"
 
 const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "automerge-repo-tests"))
 
@@ -176,6 +175,35 @@ describe("StorageSubsystem", () => {
           assert.equal(reloadedValue2, undefined)
         })
       })
+
+      describe("sync state", () => {
+        it("stores and retrieve sync state", async () => {
+          const storage = new StorageSubsystem(adapter)
+
+          const { documentId } = parseAutomergeUrl(generateAutomergeUrl())
+          const syncState = A.initSyncState()
+          const bob = "bob" as PeerId
+
+          const rawSyncState = A.decodeSyncState(A.encodeSyncState(syncState))
+
+          await storage.saveSyncState(documentId, bob, syncState)
+          const loadedSyncState = await storage.loadSyncState(documentId, bob)
+          assert.deepStrictEqual(loadedSyncState, rawSyncState)
+        })
+
+        it("delete sync state if document is deleted", async () => {
+          const storage = new StorageSubsystem(adapter)
+
+          const { documentId } = parseAutomergeUrl(generateAutomergeUrl())
+          const syncState = A.initSyncState()
+          const bob = "bob" as PeerId
+
+          await storage.saveSyncState(documentId, bob, syncState)
+          await storage.removeDoc(documentId)
+          const loadedSyncState = await storage.loadSyncState(documentId, bob)
+          assert.strictEqual(loadedSyncState, undefined)
+        })
+      })
     })
   })
 })