@dxos/echo-pipeline 0.3.11-main.ec7a2b3 → 0.3.11-main.ee2b64c

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

@@ -4,16 +4,18 @@
 
 import { randomBytes } from 'crypto';
 import expect from 'expect';
+import waitForExpect from 'wait-for-expect';
 
 import { Trigger, asyncTimeout, sleep } from '@dxos/async';
-import { type Message, NetworkAdapter, type PeerId, Repo } from '@dxos/automerge/automerge-repo';
+import { type Message, NetworkAdapter, type PeerId, Repo, type HandleState } from '@dxos/automerge/automerge-repo';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { StorageType, createStorage } from '@dxos/random-access-storage';
-import { describe, test } from '@dxos/test';
+import { TestBuilder as TeleportBuilder, TestPeer as TeleportPeer } from '@dxos/teleport/testing';
+import { afterTest, describe, test } from '@dxos/test';
 import { arrayToBuffer, bufferToArray } from '@dxos/util';
 
-import { AutomergeHost, AutomergeStorageAdapter } from './automerge-host';
+import { AutomergeHost, AutomergeStorageAdapter, MeshNetworkAdapter } from './automerge-host';
 
 describe('AutomergeHost', () => {
   test('can create documents', () => {
@@ -46,13 +48,12 @@ describe('AutomergeHost', () => {
   });
 
   test('basic networking', async () => {
-    type Context = { client: Trigger<TestAdapter>; host: Trigger<TestAdapter> };
-    const context: Context = {
-      client: new Trigger<TestAdapter>(),
-      host: new Trigger<TestAdapter>(),
-    };
-    const hostAdapter = new TestAdapter(context, 'host');
-    const clientAdapter = new TestAdapter(context, 'client');
+    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],
@@ -62,6 +63,10 @@ describe('AutomergeHost', () => {
     });
     hostAdapter.ready();
     clientAdapter.ready();
+    await hostAdapter.onConnect.wait();
+    await clientAdapter.onConnect.wait();
+    hostAdapter.peerCandidate(clientAdapter.peerId!);
+    clientAdapter.peerCandidate(hostAdapter.peerId!);
 
     const handle = host.create();
     const text = 'Hello world';
@@ -70,11 +75,147 @@ describe('AutomergeHost', () => {
     });
 
     const docOnClient = client.find(handle.url);
-    await asyncTimeout(docOnClient.whenReady(), 3_000);
-    expect(docOnClient.docSync().text).toEqual(text);
+    expect((await asyncTimeout(docOnClient.doc(), 1000)).text).toEqual(text);
   });
 
-  test('doubled connection', async () => {});
+  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 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 handle = host.create();
+    const docOnClient = client.find(handle.url);
+    {
+      const sanityText = 'Hello world';
+      handle.change((doc: any) => {
+        doc.sanityText = sanityText;
+      });
+
+      expect((await asyncTimeout(docOnClient.doc(), 1000)).sanityText).toEqual(sanityText);
+    }
+
+    // Disrupt connection.
+    const offlineText = 'This has been written while the connection was off';
+    {
+      connectionState = 'off';
+
+      handle.change((doc: any) => {
+        doc.offlineText = offlineText;
+      });
+
+      await sleep(100);
+      expect((await asyncTimeout(docOnClient.doc(), 1000)).offlineText).toBeUndefined();
+    }
+
+    // Re-establish connection.
+    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!);
+
+      handle.change((doc: any) => {
+        doc.onlineText = onlineText;
+      });
+      await sleep(100);
+      expect((await asyncTimeout(docOnClient.doc(), 1000)).onlineText).toEqual(onlineText);
+      expect((await asyncTimeout(docOnClient.doc(), 1000)).offlineText).toEqual(offlineText);
+    }
+  });
+
+  test('integration test with teleport', async () => {
+    const createAutomergeRepo = () => {
+      const meshAdapter = new MeshNetworkAdapter();
+      const repo = new Repo({
+        network: [meshAdapter],
+      });
+      meshAdapter.ready();
+      return { repo, meshAdapter };
+    };
+    const peer1 = createAutomergeRepo();
+    const peer2 = 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;
+      });
+      const docOnPeer2 = peer2.repo.find(handle.url);
+      await waitForExpect(async () => expect((await asyncTimeout(docOnPeer2.doc(), 1000)).text).toEqual(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).toBeUndefined();
+    }
+
+    {
+      // 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.
+      const docOnPeer2 = peer2.repo.find(handle.url);
+      await waitForExpect(
+        async () => expect((await asyncTimeout(docOnPeer2.doc(), 1000)).offlineText).toEqual(offlineText),
+        1000,
+      );
+
+      // Test connection.
+      const onlineText = 'This has been written after the connection was re-established';
+      handle.change((doc: any) => {
+        doc.onlineText = onlineText;
+      });
+      await waitForExpect(
+        async () => expect((await asyncTimeout(docOnPeer2.doc(), 1000)).onlineText).toEqual(onlineText),
+        1000,
+      );
+    }
+  });
 
   describe('storage', () => {
     test('load range on node', async () => {
@@ -100,13 +241,196 @@ describe('AutomergeHost', () => {
         ]);
       }
     });
+
+    test('removeRange on node', async () => {
+      const root = `/tmp/${randomBytes(16).toString('hex')}`;
+      {
+        const storage = createStorage({ type: StorageType.NODE, root });
+        const adapter = new AutomergeStorageAdapter(storage.createDirectory());
+        await adapter.save(['test', '1'], bufferToArray(Buffer.from('one')));
+        await adapter.save(['test', '2'], bufferToArray(Buffer.from('two')));
+        await adapter.save(['bar', '1'], bufferToArray(Buffer.from('bar')));
+      }
+
+      {
+        const storage = createStorage({ type: StorageType.NODE, root });
+        const adapter = new AutomergeStorageAdapter(storage.createDirectory());
+        await adapter.removeRange(['test']);
+        const range = await adapter.loadRange(['test']);
+        expect(range.map((chunk) => arrayToBuffer(chunk.data!).toString())).toEqual([]);
+        const range2 = await adapter.loadRange(['bar']);
+        expect(range2.map((chunk) => arrayToBuffer(chunk.data!).toString())).toEqual(['bar']);
+        expect(range2.map((chunk) => chunk.key)).toEqual([['bar', '1']]);
+      }
+    });
   });
-});
 
-type Context = { client: Trigger<TestAdapter>; host: Trigger<TestAdapter> };
+  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 _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 docA = repoA.create();
+    // NOTE: Doesn't work if the doc is empty.
+    docA.change((doc: any) => {
+      doc.text = 'Hello world';
+    });
+
+    // If we wait here for replication to finish naturally, the test will pass.
+
+    const docD = repoD.find(docA.url);
+
+    await docD.whenReady();
+  });
+
+  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,
+    });
+
+    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 docA = repoA.create();
+    // NOTE: Doesn't work if the doc is empty.
+    docA.change((doc: any) => {
+      doc.text = 'Hello world';
+    });
+
+    const _docB = 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 unavailable: HandleState = 'unavailable';
+
+    {
+      // Connect repos.
+      adapter1.ready();
+      adapter2.ready();
+      await adapter1.onConnect.wait();
+      await adapter2.onConnect.wait();
+    }
+
+    const docA = repoA.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);
+    }
+
+    {
+      // Failing to find a document.
+      // await (docB.whenReady([unavailable]), 1_000);
+    }
+
+    {
+      adapter1.peerCandidate(adapter2.peerId!);
+      await sleep(100);
+      adapter2.peerCandidate(adapter1.peerId!);
+    }
+
+    {
+      await asyncTimeout(docB.whenReady([unavailable]), 1_000);
+    }
+
+    {
+      // Note: Retry hack.
+      adapter1.peerDisconnected(adapter2.peerId!);
+      adapter2.peerDisconnected(adapter1.peerId!);
+      adapter1.peerCandidate(adapter2.peerId!);
+      adapter2.peerCandidate(adapter1.peerId!);
+
+      await asyncTimeout(docB.whenReady(), 1_000);
+    }
+  });
+});
 
 class TestAdapter extends NetworkAdapter {
-  constructor(public readonly context: Context, public readonly role: 'host' | 'client') {
+  static createPair() {
+    const adapter1: TestAdapter = new TestAdapter({
+      send: (message: Message) => sleep(10).then(() => adapter2.receive(message)),
+    });
+    const adapter2: TestAdapter = new TestAdapter({
+      send: (message: Message) => sleep(10).then(() => adapter1.receive(message)),
+    });
+
+    return [adapter1, adapter2];
+  }
+
+  public onConnect = new Trigger();
+
+  constructor(private readonly _params: { send: (message: Message) => void }) {
     super();
   }
 
@@ -118,32 +442,26 @@ class TestAdapter extends NetworkAdapter {
 
   override connect(peerId: PeerId) {
     this.peerId = peerId;
-    this.context[this.role].wake(this);
-    this.context[this.role === 'host' ? 'client' : 'host']
-      .wait()
-      .then((adapter) => {
-        invariant(adapter.peerId, 'Peer id is not set');
-        this.emit('peer-candidate', { peerId: adapter.peerId });
-      })
-      .catch((error) => {
-        log.catch(error);
-      });
+    this.onConnect.wake();
+  }
+
+  peerCandidate(peerId: PeerId) {
+    invariant(peerId, 'PeerId is required');
+    this.emit('peer-candidate', { peerId, peerMetadata: {} });
+  }
+
+  peerDisconnected(peerId: PeerId) {
+    invariant(peerId, 'PeerId is required');
+    this.emit('peer-disconnected', { peerId });
   }
 
   override send(message: Message) {
-    this.context[this.role === 'host' ? 'client' : 'host']
-      .wait()
-      .then((adapter) => {
-        adapter.receive(message);
-      })
-      .catch((error) => {
-        log.catch(error);
-      });
+    log('send', { from: message.senderId, to: message.targetId, type: message.type });
+    this._params.send(message);
   }
 
   override disconnect() {
     this.peerId = undefined;
-    this.context[this.role].reset();
   }
 
   receive(message: Message) {