@dxos/echo-pipeline 0.6.5 → 0.6.6-staging.23d123d

package/src/automerge/automerge-repo.test.ts

@@ -7,37 +7,42 @@ import waitForExpect from 'wait-for-expect';
 
 import { asyncTimeout, sleep } from '@dxos/async';
 import {
-  next as A,
-  type Heads,
   change,
   clone,
   equals,
   from,
   getBackend,
   getHeads,
+  type Heads,
+  next as A,
   save,
   saveSince,
 } from '@dxos/automerge/automerge';
 import {
-  type Message,
-  Repo,
-  type PeerId,
+  type AutomergeUrl,
+  type DocHandle,
   type DocumentId,
+  generateAutomergeUrl,
   type HandleState,
-  type AutomergeUrl,
   parseAutomergeUrl,
-  generateAutomergeUrl,
+  type StorageAdapterInterface,
+  type PeerId,
+  Repo,
+  type SharePolicy,
 } from '@dxos/automerge/automerge-repo';
 import { randomBytes } from '@dxos/crypto';
 import { PublicKey } from '@dxos/keys';
 import { createTestLevel } from '@dxos/kv-store/testing';
 import { TestBuilder as TeleportBuilder, TestPeer as TeleportPeer } from '@dxos/teleport/testing';
 import { afterTest, describe, openAndClose, test } from '@dxos/test';
+import { nonNullable, range } from '@dxos/util';
 
 import { EchoNetworkAdapter } from './echo-network-adapter';
 import { LevelDBStorageAdapter } from './leveldb-storage-adapter';
 import { MeshEchoReplicator } from './mesh-echo-replicator';
-import { TestAdapter } from '../testing';
+import { TestAdapter, type TestConnectionStateProvider } from '../testing';
+
+const HOST_AND_CLIENT: [string, string] = ['host', 'client'];
 
 describe('AutomergeRepo', () => {
   test('change events', () => {
@@ -58,9 +63,7 @@ describe('AutomergeRepo', () => {
   });
 
   test('flush', async () => {
-    const level = createTestLevel();
-    const storage = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
-    await openAndClose(level, storage);
+    const storage = await createLevelAdapter();
 
     const repo = new Repo({
       network: [],
@@ -78,10 +81,6 @@ describe('AutomergeRepo', () => {
   });
 
   test('getChangeByHash', async () => {
-    const level = createTestLevel();
-    const storage = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
-    await openAndClose(level, storage);
-
     const doc = from({ foo: 'bar' });
     const copy = clone(doc);
     const newDoc = change(copy, 'change', (doc: any) => {
@@ -113,59 +112,27 @@ describe('AutomergeRepo', () => {
   });
 
   test('documents missing from local storage go to requesting state', async () => {
-    const hostAdapter: TestAdapter = new TestAdapter({
-      send: (message: Message) => {
-        console.log('hostAdapter.send', message);
-        clientAdapter.receive(message);
-      },
-    });
-    const clientAdapter: TestAdapter = new TestAdapter({
-      send: (message: Message) => {
-        if (message.type !== 'doc-unavailable' && message.type !== 'sync') {
-          hostAdapter.receive(message);
-        }
-      },
-    });
-
-    const host = new Repo({
-      network: [hostAdapter],
-    });
-    const _client = new Repo({
-      network: [clientAdapter],
-    });
-    hostAdapter.ready();
-    clientAdapter.ready();
-    await hostAdapter.onConnect.wait();
-    await clientAdapter.onConnect.wait();
-    hostAdapter.peerCandidate(clientAdapter.peerId!);
-    clientAdapter.peerCandidate(hostAdapter.peerId!);
-
+    const { repos, adapters } = await createHostClientRepoTopology();
+    const [host] = repos;
+    await connectAdapters(adapters);
     const url = 'automerge:3JN8F3Z4dUWEEKKFN7WE9gEGvVUT';
     const handle = host.find(url as AutomergeUrl);
     await handle.whenReady(['requesting']);
   });
 
   test('documents on disk go to ready state', async () => {
-    const level = createTestLevel();
-    const storage = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
-    await openAndClose(level, storage);
+    const storage = await createLevelAdapter();
 
     let url: AutomergeUrl | undefined;
     {
-      const repo = new Repo({
-        network: [],
-        storage,
-      });
+      const repo = new Repo({ network: [], storage });
       const handle = repo.create<{ field?: string }>();
       url = handle.url;
       await repo.flush();
     }
 
     {
-      const repo = new Repo({
-        network: [],
-        storage,
-      });
+      const repo = new Repo({ network: [], storage });
       const handle = repo.find(url as AutomergeUrl);
 
       let requestingState = false;
@@ -181,25 +148,9 @@ describe('AutomergeRepo', () => {
 
   describe('network', () => {
     test('basic networking', async () => {
-      const hostAdapter: TestAdapter = new TestAdapter({
-        send: (message: Message) => clientAdapter.receive(message),
-      });
-      const clientAdapter: TestAdapter = new TestAdapter({
-        send: (message: Message) => hostAdapter.receive(message),
-      });
-
-      const host = new Repo({
-        network: [hostAdapter],
-      });
-      const client = new Repo({
-        network: [clientAdapter],
-      });
-      hostAdapter.ready();
-      clientAdapter.ready();
-      await hostAdapter.onConnect.wait();
-      await clientAdapter.onConnect.wait();
-      hostAdapter.peerCandidate(clientAdapter.peerId!);
-      clientAdapter.peerCandidate(hostAdapter.peerId!);
+      const { repos, adapters } = await createHostClientRepoTopology();
+      const [host, client] = repos;
+      await connectAdapters(adapters);
 
       const handle = host.create();
       const text = 'Hello world';
@@ -212,25 +163,13 @@ describe('AutomergeRepo', () => {
     });
 
     test('share policy gets enabled afterwards', async () => {
-      const [hostAdapter, clientAdapter] = TestAdapter.createPair();
       let sharePolicy = false;
 
-      const host = new Repo({
-        network: [hostAdapter],
-        peerId: 'host' as PeerId,
-        sharePolicy: async () => sharePolicy,
-      });
-      const client = new Repo({
-        network: [clientAdapter],
-        peerId: 'client' as PeerId,
+      const { repos, adapters } = await createHostClientRepoTopology({
         sharePolicy: async () => sharePolicy,
       });
-      hostAdapter.ready();
-      clientAdapter.ready();
-      await hostAdapter.onConnect.wait();
-      await clientAdapter.onConnect.wait();
-      hostAdapter.peerCandidate(clientAdapter.peerId!);
-      clientAdapter.peerCandidate(hostAdapter.peerId!);
+      const [host, client] = repos;
+      await connectAdapters(adapters);
 
       const handle = host.create();
       const text = 'Hello world';
@@ -253,35 +192,25 @@ describe('AutomergeRepo', () => {
     });
 
     test('two documents and share policy switching', async () => {
-      const [hostAdapter, clientAdapter] = TestAdapter.createPair();
       const allowedDocs: DocumentId[] = [];
 
-      const host: Repo = new Repo({
-        network: [hostAdapter],
-        peerId: 'host' as PeerId,
-        sharePolicy: async (_, docId) => (docId ? allowedDocs.includes(docId) && !!host.handles[docId] : false),
-      });
-
-      const client: Repo = new Repo({
-        network: [clientAdapter],
-        peerId: 'client' as PeerId,
-        sharePolicy: async (_, docId) => (docId ? allowedDocs.includes(docId) && !!client.handles[docId] : false),
+      const { repos, adapters } = await createHostClientRepoTopology({
+        sharePolicy: async (peerId, docId): Promise<boolean> => {
+          if (peerId === 'host') {
+            return docId ? allowedDocs.includes(docId) && !!client.handles[docId] : false;
+          } else {
+            return docId ? allowedDocs.includes(docId) && !!host.handles[docId] : false;
+          }
+        },
       });
+      const [host, client] = repos;
 
       const firstHandle = host.create();
       firstHandle.change((doc: any) => (doc.text = 'Hello world'));
       await host.find(firstHandle.url).whenReady();
       allowedDocs.push(firstHandle.documentId);
 
-      {
-        // Initiate connection.
-        hostAdapter.ready();
-        clientAdapter.ready();
-        await hostAdapter.onConnect.wait();
-        await clientAdapter.onConnect.wait();
-        hostAdapter.peerCandidate(clientAdapter.peerId!);
-        clientAdapter.peerCandidate(hostAdapter.peerId!);
-      }
+      await connectAdapters(adapters);
 
       {
         const firstDocOnClient = client.find(firstHandle.url);
@@ -304,27 +233,11 @@ describe('AutomergeRepo', () => {
     test('recovering from a lost connection', async () => {
       let connectionState: 'on' | 'off' = 'on';
 
-      const hostAdapter: TestAdapter = new TestAdapter({
-        send: (message: Message) => connectionState === 'on' && sleep(10).then(() => clientAdapter.receive(message)),
-      });
-      const clientAdapter: TestAdapter = new TestAdapter({
-        send: (message: Message) => connectionState === 'on' && sleep(10).then(() => hostAdapter.receive(message)),
+      const { repos, adapters } = await createHostClientRepoTopology({
+        connectionStateProvider: () => connectionState,
       });
-
-      const host = new Repo({
-        network: [hostAdapter],
-      });
-      const client = new Repo({
-        network: [clientAdapter],
-      });
-
-      // Establish connection.
-      hostAdapter.ready();
-      clientAdapter.ready();
-      await hostAdapter.onConnect.wait();
-      await clientAdapter.onConnect.wait();
-      hostAdapter.peerCandidate(clientAdapter.peerId!);
-      clientAdapter.peerCandidate(hostAdapter.peerId!);
+      const [host, client] = repos;
+      await connectAdapters(adapters);
 
       const handle = host.create();
       const docOnClient = client.find(handle.url);
@@ -354,10 +267,7 @@ describe('AutomergeRepo', () => {
       const onlineText = 'This has been written after the connection was re-established';
       {
         connectionState = 'on';
-        hostAdapter.peerDisconnected(clientAdapter.peerId!);
-        clientAdapter.peerDisconnected(hostAdapter.peerId!);
-        hostAdapter.peerCandidate(clientAdapter.peerId!);
-        clientAdapter.peerCandidate(hostAdapter.peerId!);
+        await reconnectAdapters(adapters);
 
         handle.change((doc: any) => {
           doc.onlineText = onlineText;
@@ -368,126 +278,17 @@ describe('AutomergeRepo', () => {
       }
     });
 
-    test('integration test with teleport', async () => {
-      const [spaceKey] = PublicKey.randomSequence();
-
-      const createAutomergeRepo = async () => {
-        const meshAdapter = new MeshEchoReplicator();
-        const echoAdapter = new EchoNetworkAdapter({
-          getContainingSpaceForDocument: async () => spaceKey,
-          onCollectionStateQueried: () => {},
-          onCollectionStateReceived: () => {},
-        });
-        const repo = new Repo({
-          network: [echoAdapter],
-        });
-        await echoAdapter.open();
-        await echoAdapter.whenConnected();
-        await echoAdapter.addReplicator(meshAdapter);
-        return { repo, meshAdapter };
-      };
-      const peer1 = await createAutomergeRepo();
-      const peer2 = await createAutomergeRepo();
-
-      const handle = peer1.repo.create();
-
-      const teleportBuilder = new TeleportBuilder();
-      afterTest(() => teleportBuilder.destroy());
-
-      const [teleportPeer1, teleportPeer2] = teleportBuilder.createPeers({ factory: () => new TeleportPeer() });
-      {
-        // Initiate connection.
-        const [connection1, connection2] = await teleportBuilder.connect(teleportPeer1, teleportPeer2);
-        connection1.teleport.addExtension('automerge', peer1.meshAdapter.createExtension());
-        connection2.teleport.addExtension('automerge', peer2.meshAdapter.createExtension());
-
-        // Test connection.
-        const text = 'Hello world';
-        handle.change((doc: any) => {
-          doc.text = text;
-        });
-        await waitForExpect(async () => {
-          const docOnPeer2 = peer2.repo.find(handle.url);
-          const doc = await asyncTimeout(docOnPeer2.doc(), 1000);
-          expect(doc.text).to.eq(text);
-        }, 1000);
-      }
-
-      const offlineText = 'This has been written while the connection was off';
-      {
-        // Disconnect peers.
-        await teleportBuilder.disconnect(teleportPeer1, teleportPeer2);
-
-        // Make offline changes.
-        const offlineText = 'This has been written while the connection was off';
-        handle.change((doc: any) => {
-          doc.offlineText = offlineText;
-        });
-        const docOnPeer2 = peer2.repo.find(handle.url);
-        await sleep(100);
-        expect((await asyncTimeout(docOnPeer2.doc(), 1000)).offlineText).to.be.undefined;
-      }
-
-      {
-        const docOnPeer2 = peer2.repo.find(handle.url);
-        const receivedUpdate = new Promise((resolve, reject) => docOnPeer2.once('heads-changed', resolve));
-
-        // Reconnect peers.
-        const [connection1, connection2] = await teleportBuilder.connect(teleportPeer1, teleportPeer2);
-        connection1.teleport.addExtension('automerge', peer1.meshAdapter.createExtension());
-        connection2.teleport.addExtension('automerge', peer2.meshAdapter.createExtension());
-
-        // Wait for offline changes to be synced.
-        await receivedUpdate;
-        await docOnPeer2.whenReady();
-        expect((await asyncTimeout(docOnPeer2.doc(), 1000)).offlineText).to.eq(offlineText);
-
-        // Test connection.
-        const onlineText = 'This has been written after the connection was re-established';
-        const receivedOnlineUpdate = new Promise((resolve, reject) => docOnPeer2.once('heads-changed', resolve));
-        handle.change((doc: any) => {
-          doc.onlineText = onlineText;
-        });
-        await receivedOnlineUpdate;
-        await docOnPeer2.whenReady();
-        expect((await asyncTimeout(docOnPeer2.doc(), 1000)).onlineText).to.eq(onlineText);
-      }
-    });
-
     test('replication though a 4 peer chain', async () => {
-      const pairAB = TestAdapter.createPair();
-      const pairBC = TestAdapter.createPair();
-      const pairCD = TestAdapter.createPair();
-
-      const repoA = new Repo({
-        peerId: 'A' as any,
-        network: [pairAB[0]],
-        sharePolicy: async () => true,
-      });
-      const _repoB = new Repo({
-        peerId: 'B' as any,
-        network: [pairAB[1], pairBC[0]],
-        sharePolicy: async () => true,
+      const { repos, adapters } = await createRepoTopology({
+        peers: ['A', 'B', 'C', 'D'],
+        connections: [
+          ['A', 'B'],
+          ['B', 'C'],
+          ['C', 'D'],
+        ],
       });
-      const _repoC = new Repo({
-        peerId: 'C' as any,
-        network: [pairBC[1], pairCD[0]],
-        sharePolicy: async () => true,
-      });
-      const repoD = new Repo({
-        peerId: 'D' as any,
-        network: [pairCD[1]],
-        sharePolicy: async () => true,
-      });
-
-      for (const pair of [pairAB, pairBC, pairCD]) {
-        pair[0].ready();
-        pair[1].ready();
-        await pair[0].onConnect.wait();
-        await pair[1].onConnect.wait();
-        pair[0].peerCandidate(pair[1].peerId!);
-        pair[1].peerCandidate(pair[0].peerId!);
-      }
+      const [repoA, _, __, repoD] = repos;
+      await connectAdapters(adapters);
 
       const docA = repoA.create();
       // NOTE: Doesn't work if the doc is empty.
@@ -503,33 +304,15 @@ describe('AutomergeRepo', () => {
     });
 
     test('replication though a 3 peer chain', async () => {
-      const pairAB = TestAdapter.createPair();
-      const pairBC = TestAdapter.createPair();
-
-      const repoA = new Repo({
-        peerId: 'A' as any,
-        network: [pairAB[0]],
-        sharePolicy: async () => true,
-      });
-      const repoB = new Repo({
-        peerId: 'B' as any,
-        network: [pairAB[1], pairBC[0]],
-        sharePolicy: async () => true,
-      });
-      const repoC = new Repo({
-        peerId: 'C' as any,
-        network: [pairBC[1]],
-        sharePolicy: async () => true,
+      const { repos, adapters } = await createRepoTopology({
+        peers: ['A', 'B', 'C'],
+        connections: [
+          ['A', 'B'],
+          ['B', 'C'],
+        ],
       });
-
-      for (const pair of [pairAB, pairBC]) {
-        pair[0].ready();
-        pair[1].ready();
-        await pair[0].onConnect.wait();
-        await pair[1].onConnect.wait();
-        pair[0].peerCandidate(pair[1].peerId!);
-        pair[1].peerCandidate(pair[0].peerId!);
-      }
+      const [repoA, repoB, repoC] = repos;
+      await connectAdapters(adapters);
 
       const docA = repoA.create();
       // NOTE: Doesn't work if the doc is empty.
@@ -537,77 +320,44 @@ describe('AutomergeRepo', () => {
         doc.text = 'Hello world';
       });
 
-      const _docB = repoB.find(docA.url);
+      const _ = repoB.find(docA.url);
       const docC = repoC.find(docA.url);
-
       await docC.whenReady();
     });
 
     test('replicate document after request', async () => {
-      const [adapter1, adapter2] = TestAdapter.createPair();
-      const repoA = new Repo({
-        peerId: 'A' as any,
-        network: [adapter1],
-        sharePolicy: async () => true,
-      });
-      const repoB = new Repo({
-        peerId: 'B' as any,
-        network: [adapter2],
-        sharePolicy: async () => true,
-      });
+      const { repos, adapters } = await createHostClientRepoTopology();
+      const [host, client] = repos;
+      const [[adapter1, adapter2]] = adapters;
 
       const unavailable: HandleState = 'unavailable';
+      await connectAdapters(adapters, { noEmitPeerCandidate: true });
 
-      {
-        // Connect repos.
-        adapter1.ready();
-        adapter2.ready();
-        await adapter1.onConnect.wait();
-        await adapter2.onConnect.wait();
-      }
-
-      const docA = repoA.create();
+      const docA = host.create();
       // NOTE: Doesn't work if the doc is empty.
       docA.change((doc: any) => {
         doc.text = 'Hello world';
       });
 
-      const docB = repoB.find(docA.url);
-      {
-        // Request document from repoB.
-        await asyncTimeout(docB.whenReady([unavailable]), 1_000);
-      }
+      const docB = client.find(docA.url);
 
-      {
-        // Failing to find a document.
-        // await (docB.whenReady([unavailable]), 1_000);
-      }
+      // Request document from repoB.
+      await asyncTimeout(docB.whenReady([unavailable]), 1_000);
 
-      {
-        adapter1.peerCandidate(adapter2.peerId!);
-        await sleep(100);
-        adapter2.peerCandidate(adapter1.peerId!);
-      }
-
-      {
-        await asyncTimeout(docB.whenReady([unavailable]), 1_000);
-      }
+      adapter1.peerCandidate(adapter2.peerId!);
+      await sleep(100);
+      adapter2.peerCandidate(adapter1.peerId!);
 
-      {
-        // Note: Retry hack.
-        adapter1.peerDisconnected(adapter2.peerId!);
-        adapter2.peerDisconnected(adapter1.peerId!);
-        adapter1.peerCandidate(adapter2.peerId!);
-        adapter2.peerCandidate(adapter1.peerId!);
+      // Wait becomes unavailable.
+      await asyncTimeout(docB.whenReady([unavailable]), 1_000);
 
-        await asyncTimeout(docB.whenReady(), 1_000);
-      }
+      // Wait gets loaded after reconnect.
+      await reconnectAdapters(adapters);
+      await asyncTimeout(docB.whenReady(), 1_000);
     });
 
     test('documents loaded from disk get replicated', async () => {
-      const level = createTestLevel();
-      const storage = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
-      await openAndClose(level, storage);
+      const storage = await createLevelAdapter();
 
       let url: AutomergeUrl | undefined;
       {
@@ -619,29 +369,17 @@ describe('AutomergeRepo', () => {
         url = handle.url;
       }
 
-      const [adapter1, adapter2] = TestAdapter.createPair();
-      const peer1 = new Repo({
-        network: [adapter1],
-        storage,
-        sharePolicy: async () => true,
-      });
-      const peer2 = new Repo({
-        network: [adapter2],
-        sharePolicy: async () => true,
-      });
-      adapter1.ready();
-      adapter2.ready();
-      await adapter1.onConnect.wait();
-      await adapter2.onConnect.wait();
-      adapter1.peerCandidate(adapter2.peerId!);
-      adapter2.peerCandidate(adapter1.peerId!);
+      const { repos, adapters } = await createHostClientRepoTopology({ storages: [storage] });
+      const [peer1, peer2] = repos;
+      await connectAdapters(adapters);
 
       // Load doc on peer1
       const hostHandle = peer1.find(url as AutomergeUrl);
 
       // Doc should be pushed to peer2
       await waitForExpect(() => {
-        expect(peer2.handles[hostHandle.documentId]).to.not.be.undefined;
+        expect(hostHandle.docSync().text).not.to.be.undefined;
+        expect(peer2.handles[hostHandle.documentId].docSync()).to.deep.eq(hostHandle.docSync());
       });
     });
 
@@ -716,37 +454,18 @@ describe('AutomergeRepo', () => {
     });
 
     test('two repo sync docs on `update` call', async () => {
-      const [adapter1, adapter2] = TestAdapter.createPair();
-      const repoA = new Repo({
-        peerId: 'A' as any,
-        network: [adapter1],
-        sharePolicy: async () => true,
-      });
-      const repoB = new Repo({
-        peerId: 'B' as any,
-        network: [adapter2],
-        sharePolicy: async () => true,
-      });
-
-      {
-        // Connect repos.
-        adapter1.ready();
-        adapter2.ready();
-        await adapter1.onConnect.wait();
-        await adapter2.onConnect.wait();
-        adapter1.peerCandidate(adapter2.peerId!);
-        adapter2.peerCandidate(adapter1.peerId!);
-      }
+      const { repos, adapters } = await createHostClientRepoTopology();
+      const [repoA, repoB] = repos;
+      await connectAdapters(adapters);
 
       const handleA = repoA.create();
       const handleB = repoB.find(handleA.url);
 
       const text = 'Hello world';
       handleA.update((doc: any) => {
-        const newDoc = A.change(doc, (doc: any) => {
+        return A.change(doc, (doc: any) => {
           doc.text = text;
         });
-        return newDoc;
       });
 
       expect(handleA.docSync().text).to.equal(text);
@@ -755,4 +474,299 @@ describe('AutomergeRepo', () => {
       expect(handleB.docSync().text).to.equal(text);
     });
   });
+
+  describe('teleport', () => {
+    test('integration test with teleport', async () => {
+      const [spaceKey] = PublicKey.randomSequence();
+
+      const teleportBuilder = new TeleportBuilder();
+      afterTest(() => teleportBuilder.destroy());
+
+      const peer1 = await createTeleportTestPeer(teleportBuilder, spaceKey);
+      const peer2 = await createTeleportTestPeer(teleportBuilder, spaceKey);
+
+      const handle = peer1.repo.create();
+      {
+        // Initiate connection and test the connection.
+        await connectPeers(spaceKey, teleportBuilder, peer1, peer2);
+        const text = 'Hello world';
+        handle.change((doc: any) => {
+          doc.text = text;
+        });
+        await waitForExpect(async () => {
+          const docOnPeer2 = peer2.repo.find(handle.url);
+          const doc = await asyncTimeout(docOnPeer2.doc(), 1000);
+          expect(doc.text).to.eq(text);
+        }, 1000);
+      }
+
+      const offlineText = 'This has been written while the connection was off';
+      {
+        // Disconnect peers and make offline changes.
+        await teleportBuilder.disconnect(peer1.teleport, peer2.teleport);
+        const offlineText = 'This has been written while the connection was off';
+        handle.change((doc: any) => {
+          doc.offlineText = offlineText;
+        });
+        const docOnPeer2 = peer2.repo.find(handle.url);
+        await sleep(100);
+        expect((await asyncTimeout(docOnPeer2.doc(), 1000)).offlineText).to.be.undefined;
+      }
+
+      {
+        // Wait for offline changes to be synced after reconnect.
+        const docOnPeer2 = peer2.repo.find(handle.url);
+        await docChangeAfterAction(docOnPeer2, () => connectPeers(spaceKey, teleportBuilder, peer1, peer2));
+        await docOnPeer2.whenReady();
+        expect((await asyncTimeout(docOnPeer2.doc(), 1000)).offlineText).to.eq(offlineText);
+
+        // Test connection.
+        const onlineText = 'This has been written after the connection was re-established';
+        await docChangeAfterAction(docOnPeer2, async () => {
+          handle.change((doc: any) => {
+            doc.onlineText = onlineText;
+          });
+        });
+        await docOnPeer2.whenReady();
+        expect((await asyncTimeout(docOnPeer2.doc(), 1000)).onlineText).to.eq(onlineText);
+      }
+    });
+
+    test('pulls a document if it is in a remote collection', async () => {
+      const [spaceKey] = PublicKey.randomSequence();
+
+      const teleportBuilder = new TeleportBuilder();
+      afterTest(() => teleportBuilder.destroy());
+
+      const peerWithDocs = await createTeleportPeerWithStoredDocs(teleportBuilder, spaceKey, async (repo) => {
+        return range(2, (idx) => {
+          const document = repo.create();
+          document.change((doc: any) => (doc.text = 'hello ' + idx));
+          return document;
+        });
+      });
+      const [docInRemoteCollection, docNotInRemoteCollection] = peerWithDocs.documents;
+
+      // Create a peer that shares one of the collections.
+      const peer2 = await createTeleportTestPeer(teleportBuilder, spaceKey, {
+        localDocuments: [],
+        remoteCollections: { [peerWithDocs.peerId]: [docInRemoteCollection.documentId] },
+      });
+      await connectPeers(spaceKey, teleportBuilder, peerWithDocs.peer, peer2);
+
+      const shouldNotFindDoc = peer2.repo.find(docNotInRemoteCollection.url);
+      const shouldFindDoc = peer2.repo.find(docInRemoteCollection.url);
+      await shouldFindDoc.whenReady();
+      expect(shouldFindDoc.docSync()).to.deep.eq(docInRemoteCollection.docSync());
+      await shouldNotFindDoc.whenReady(['unavailable']);
+    });
+
+    /**
+     * This can happen if there's no local document and sharePolicy returns true to every connected
+     * peer to try getting a document from it. Remote collection check has to be performed.
+     */
+    test('document is not shared with peer who did not request it', async () => {
+      const [spaceKey, anotherSpaceKey] = PublicKey.randomSequence();
+
+      const teleportBuilder = new TeleportBuilder();
+      afterTest(() => teleportBuilder.destroy());
+
+      const peerWithDocs = await createTeleportPeerWithStoredDocs(teleportBuilder, spaceKey, async (repo) => {
+        const document = repo.create();
+        document.change((doc: any) => (doc.text = 'hello'));
+        return [document];
+      });
+      const [document] = peerWithDocs.documents;
+
+      const peer2 = await createTeleportTestPeer(teleportBuilder, spaceKey, {
+        localDocuments: [],
+        remoteCollections: { [peerWithDocs.peerId]: [document.documentId] },
+      });
+      const peerFromAnotherSpace = await createTeleportTestPeer(teleportBuilder, anotherSpaceKey, {
+        localDocuments: [],
+      });
+      await connectPeers(spaceKey, teleportBuilder, peerWithDocs.peer, peer2);
+      await connectPeers(anotherSpaceKey, teleportBuilder, peer2, peerFromAnotherSpace);
+
+      const loadedDocument = peer2.repo.find(document.url);
+      await loadedDocument.whenReady();
+
+      await sleep(200);
+      const doc = peerFromAnotherSpace.repo.find(document.url);
+      await doc.whenReady(['unavailable']);
+    });
+
+    test('collection-sync with chain of peers', async () => {
+      const [spaceKey] = PublicKey.randomSequence();
+
+      const teleportBuilder = new TeleportBuilder();
+      afterTest(() => teleportBuilder.destroy());
+
+      const peerWithDocs = await createTeleportPeerWithStoredDocs(teleportBuilder, spaceKey, async (repo) => {
+        const document = repo.create();
+        document.change((doc: any) => (doc.text = 'hello'));
+        return [document];
+      });
+      const [document] = peerWithDocs.documents;
+
+      const peer2Id = 'peer2';
+      const peer2 = await createTeleportTestPeer(teleportBuilder, spaceKey, {
+        peerId: peer2Id,
+        localDocuments: [],
+        remoteCollections: { [peerWithDocs.peerId]: [document.documentId] },
+      });
+      const peer3 = await createTeleportTestPeer(teleportBuilder, spaceKey, {
+        localDocuments: [],
+        remoteCollections: { [peer2Id]: [document.documentId] },
+      });
+      await connectPeers(spaceKey, teleportBuilder, peerWithDocs.peer, peer2);
+      await connectPeers(spaceKey, teleportBuilder, peer2, peer3);
+
+      const loadedDocument = peer2.repo.find(document.url);
+      await loadedDocument.whenReady();
+
+      const doc = peer3.repo.find(document.url);
+      await doc.whenReady();
+      expect(doc.docSync()).to.deep.eq(document.docSync());
+    });
+  });
+
+  const createLevelAdapter = async () => {
+    const level = createTestLevel();
+    const storage = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
+    await openAndClose(level, storage);
+    return storage;
+  };
+
+  const createTeleportPeerWithStoredDocs = async (
+    teleportBuilder: TeleportBuilder,
+    spaceKey: PublicKey,
+    createDocCallback: (repo: Repo) => Promise<A.Doc<any>[]>,
+  ) => {
+    const peerId = 'A';
+    const storage = await createLevelAdapter();
+    const peer = await createTeleportTestPeer(teleportBuilder, spaceKey, { storage, peerId });
+    const documents = await createDocCallback(peer.repo);
+    await peer.repo.flush();
+    // Reload the first peer so that documents are NOT pushed to the new connection.
+    const reloadedPeer = await createTeleportTestPeer(teleportBuilder, spaceKey, { storage, peerId });
+    return { peer: reloadedPeer, peerId, documents };
+  };
 });
+
+type ConnectedRepoOptions = {
+  storages?: StorageAdapterInterface[];
+  connectionStateProvider?: TestConnectionStateProvider;
+  sharePolicy?: SharePolicy;
+};
+
+const createRepoTopology = async <Peers extends string[], Peer extends string = Peers[number]>(args: {
+  peers: Peers;
+  connections: [Peer, Peer][];
+  options?: ConnectedRepoOptions;
+}) => {
+  const adapters = args.connections.map(
+    () => TestAdapter.createPair(args.options?.connectionStateProvider) as [TestAdapter, TestAdapter],
+  );
+  const repos = args.peers.map((peerId, peerIndex) => {
+    const network = adapters
+      .map((pair, idx) => {
+        return args.connections[idx].includes(peerId as Peer)
+          ? peerId === args.connections[idx][0]
+            ? pair[0]
+            : pair[1]
+          : null;
+      })
+      .filter(nonNullable);
+    return new Repo({
+      peerId: peerId as PeerId,
+      storage: args.options?.storages?.[peerIndex],
+      network,
+      sharePolicy: args.options?.sharePolicy ?? (async () => true),
+    });
+  });
+  return { repos, adapters };
+};
+
+const connectAdapters = async (pairs: [TestAdapter, TestAdapter][], options?: { noEmitPeerCandidate?: boolean }) => {
+  for (const pair of pairs) {
+    pair[0].ready();
+    pair[1].ready();
+    await pair[0].onConnect.wait();
+    await pair[1].onConnect.wait();
+    if (!options?.noEmitPeerCandidate) {
+      pair[0].peerCandidate(pair[1].peerId!);
+      pair[1].peerCandidate(pair[0].peerId!);
+    }
+  }
+};
+
+const createHostClientRepoTopology = (options?: ConnectedRepoOptions) =>
+  createRepoTopology({ peers: HOST_AND_CLIENT, connections: [HOST_AND_CLIENT], options });
+
+const reconnectAdapters = async (pairs: [TestAdapter, TestAdapter][]) => {
+  for (const pair of pairs) {
+    // Note: Retry hack.
+    pair[0].peerDisconnected(pair[1].peerId!);
+    pair[1].peerDisconnected(pair[0].peerId!);
+    pair[0].peerCandidate(pair[1].peerId!);
+    pair[1].peerCandidate(pair[0].peerId!);
+  }
+};
+
+const docChangeAfterAction = async (handle: DocHandle<any>, action: () => Promise<void>) => {
+  const receivedUpdate = new Promise((resolve) => handle.once('heads-changed', resolve));
+  await action();
+  return receivedUpdate;
+};
+
+const createTeleportTestPeer = async (
+  teleportBuilder: TeleportBuilder,
+  spaceKey: PublicKey,
+  options?: {
+    peerId?: string;
+    storage?: StorageAdapterInterface;
+    localDocuments?: string[];
+    remoteCollections?: { [peerId: string]: string[] };
+  },
+): Promise<TeleportTestPeer> => {
+  const meshAdapter = new MeshEchoReplicator();
+  const echoAdapter = new EchoNetworkAdapter({
+    // If a document is in the remote collection we don't have it locally, so can't get spaceKey from it.
+    getContainingSpaceForDocument: async (documentId) => {
+      return options?.localDocuments ? (options.localDocuments.includes(documentId) ? spaceKey : null) : spaceKey;
+    },
+    isDocumentInRemoteCollection: async (params) => {
+      return options?.remoteCollections?.[params.peerId]?.includes(params.documentId) ?? false;
+    },
+    onCollectionStateQueried: () => {},
+    onCollectionStateReceived: () => {},
+  });
+  const repo = new Repo({
+    peerId: options?.peerId as PeerId,
+    network: [echoAdapter],
+    storage: options?.storage,
+    sharePolicy: async (peerId, documentId) =>
+      documentId ? echoAdapter.shouldAdvertise(peerId, { documentId }) : false,
+  });
+  await echoAdapter.open();
+  await echoAdapter.whenConnected();
+  await echoAdapter.addReplicator(meshAdapter);
+  const [teleport] = teleportBuilder.createPeers({ factory: () => new TeleportPeer() });
+  return { repo, meshAdapter, teleport };
+};
+
+const connectPeers = async (
+  spaceKey: PublicKey,
+  builder: TeleportBuilder,
+  peer1: TeleportTestPeer,
+  peer2: TeleportTestPeer,
+) => {
+  const [connection1, connection2] = await builder.connect(peer1.teleport, peer2.teleport);
+  await peer1.meshAdapter.authorizeDevice(spaceKey, peer2.teleport.peerId);
+  connection1.teleport.addExtension('automerge', peer1.meshAdapter.createExtension());
+  await peer2.meshAdapter.authorizeDevice(spaceKey, peer1.teleport.peerId);
+  connection2.teleport.addExtension('automerge', peer2.meshAdapter.createExtension());
+};
+
+type TeleportTestPeer = { repo: Repo; meshAdapter: MeshEchoReplicator; teleport: TeleportPeer };