@automerge/automerge-repo 1.1.1 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automerge/automerge-repo",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "A repository object to manage a collection of automerge documents",
   "repository": "https://github.com/automerge/automerge-repo/tree/master/packages/automerge-repo",
   "author": "Peter van Hardenberg <pvh@pvh.ca>",
@@ -55,5 +55,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "7e0681014b8c5f672e2abc2a653a954ccb6d7aba"
+  "gitHead": "8bcba031ae952b1f3302cd41d1066cd2db5b677f"
 }

package/test/Repo.test.ts

@@ -461,6 +461,80 @@ describe("Repo", () => {
   })
 
   describe("with peers (linear network)", async () => {
+    it("n-peers connected in a line", async () => {
+      const createNConnectedRepos = async (
+        numberOfPeers: number,
+        latency?: number
+      ) => {
+        const networkAdapters: DummyNetworkAdapter[][] = []
+        const repos: Repo[] = []
+        const networkReady: Promise<void>[] = []
+
+        // Create n repos and connect them in a line.
+        for (let idx = 0; idx < numberOfPeers; idx++) {
+          const network = []
+
+          const pair = DummyNetworkAdapter.createConnectedPair({ latency })
+          networkAdapters.push(pair)
+
+          if (idx > 0) {
+            network.push(networkAdapters[idx - 1][1])
+            networkReady.push(
+              eventPromise(networkAdapters[idx - 1][1], "ready")
+            )
+          }
+
+          if (idx < numberOfPeers - 1) {
+            network.push(pair[0])
+            networkReady.push(eventPromise(pair[0], "ready"))
+          }
+
+          const repo = new Repo({
+            network,
+            storage: new DummyStorageAdapter(),
+            peerId: `peer-${idx}` as PeerId,
+            sharePolicy: async () => true,
+          })
+          repos.push(repo)
+        }
+
+        await Promise.all(networkReady)
+
+        const connectedPromise = Promise.all(
+          repos.map(repo => eventPromise(repo.networkSubsystem, "peer"))
+        )
+
+        // Initialize the network.
+        for (let idx = 0; idx < numberOfPeers; idx++) {
+          if (idx > 0) {
+            networkAdapters[idx - 1][1].peerCandidate(
+              `peer-${idx - 1}` as PeerId
+            )
+          }
+          if (idx < numberOfPeers - 1) {
+            networkAdapters[idx][0].peerCandidate(`peer-${idx + 1}` as PeerId)
+          }
+        }
+
+        await connectedPromise
+
+        return { repos }
+      }
+
+      const numberOfPeers = 10
+      const { repos } = await createNConnectedRepos(numberOfPeers, 10)
+
+      const handle0 = repos[0].create()
+      handle0.change((d: any) => {
+        d.foo = "bar"
+      })
+
+      const handleN = repos[numberOfPeers - 1].find<TestDoc>(handle0.url)
+
+      await handleN.whenReady()
+      assert.deepStrictEqual(handleN.docSync(), { foo: "bar" })
+    })
+
     const setup = async ({
       connectAlice = true,
       isCharlieEphemeral = false,
@@ -1023,36 +1097,35 @@ describe("Repo", () => {
     })
   })
 
-
-  it('peer receives a document when connection is recovered', async () => {
-    const alice = "alice" as PeerId;
-    const bob = "bob" as PeerId;
-    const [aliceAdapter, bobAdapter] = DummyNetworkAdapter.createConnectedPair();
+  it("peer receives a document when connection is recovered", async () => {
+    const alice = "alice" as PeerId
+    const bob = "bob" as PeerId
+    const [aliceAdapter, bobAdapter] = DummyNetworkAdapter.createConnectedPair()
     const aliceRepo = new Repo({
       network: [aliceAdapter],
-      peerId: alice
+      peerId: alice,
     })
     const bobRepo = new Repo({
       network: [bobAdapter],
-      peerId: bob
+      peerId: bob,
     })
 
-    const aliceDoc = aliceRepo.create();
-    aliceDoc.change((doc: any) => doc.text = 'Hello world');
+    const aliceDoc = aliceRepo.create()
+    aliceDoc.change((doc: any) => (doc.text = "Hello world"))
 
-    const bobDoc = bobRepo.find(aliceDoc.url);
+    const bobDoc = bobRepo.find(aliceDoc.url)
     bobDoc.unavailable()
-    await bobDoc.whenReady([HandleState.UNAVAILABLE]);
+    await bobDoc.whenReady([HandleState.UNAVAILABLE])
 
-    aliceAdapter.peerCandidate(bob);
+    aliceAdapter.peerCandidate(bob)
     // Bob isn't yet connected to Alice and can't respond to her sync message
-    await pause(100);
-    bobAdapter.peerCandidate(alice);
+    await pause(100)
+    bobAdapter.peerCandidate(alice)
 
-    await bobDoc.whenReady([HandleState.READY]);
+    await bobDoc.whenReady([HandleState.READY])
 
-    assert.equal(bobDoc.isReady(), true);
-  });
+    assert.equal(bobDoc.isReady(), true)
+  })
 
   describe("with peers (mesh network)", () => {
     const setup = async () => {

package/test/helpers/DummyNetworkAdapter.ts

@@ -11,7 +11,8 @@ export class DummyNetworkAdapter extends NetworkAdapter {
     this.#sendMessage = opts.sendMessage;
   }
 
-  connect(_: string) {
+  connect(peerId: PeerId) {
+    this.peerId = peerId;
     if (this.#startReady) {
       this.emit("ready", { network: this })
     }
@@ -31,14 +32,14 @@ export class DummyNetworkAdapter extends NetworkAdapter {
     this.emit('message', message);
   }
 
-  static createConnectedPair() {
+  static createConnectedPair({ latency = 10 }: { latency?: number} = {}) {
     const adapter1: DummyNetworkAdapter = new DummyNetworkAdapter({
       startReady: true,
-      sendMessage: (message: Message) => pause(10).then(() => adapter2.receive(message)),
+      sendMessage: (message: Message) => pause(latency).then(() => adapter2.receive(message)),
     });
     const adapter2: DummyNetworkAdapter = new DummyNetworkAdapter({
       startReady: true,
-      sendMessage: (message: Message) => pause(10).then(() => adapter1.receive(message)),
+      sendMessage: (message: Message) => pause(latency).then(() => adapter1.receive(message)),
     });
 
     return [adapter1, adapter2];