@dxos/network-manager 0.1.16 → 0.1.18

package/src/swarm/swarm.test.ts

@@ -5,18 +5,16 @@
 // @dxos/test platform=nodejs
 
 import { expect } from 'earljs';
-import waitForExpect from 'wait-for-expect';
 
-import { sleep, asyncTimeout } from '@dxos/async';
+import { asyncTimeout, sleep } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { MemorySignalManager, MemorySignalManagerContext, Messenger } from '@dxos/messaging';
-import { beforeEach, describe, test, afterTest } from '@dxos/test';
+import { afterTest, beforeEach, describe, test } from '@dxos/test';
 
-import { TestProtocolPlugin, testProtocolProvider } from '../testing';
+import { TestWireProtocol } from '../testing/test-wire-protocol';
 import { FullyConnectedTopology } from '../topology';
 import { createWebRTCTransportFactory } from '../transport';
-import { adaptProtocolProvider } from '../wire-protocol';
 import { Swarm } from './swarm';
 
 describe('Swarm', () => {
@@ -29,12 +27,12 @@ describe('Swarm', () => {
   });
 
   const setupSwarm = ({ topic, peerId }: { topic: PublicKey; peerId: PublicKey }) => {
-    const plugin = new TestProtocolPlugin(peerId.asBuffer());
+    const protocol = new TestWireProtocol(peerId);
     const swarm = new Swarm(
       topic,
       peerId,
       new FullyConnectedTopology(),
-      adaptProtocolProvider(testProtocolProvider(topic.asBuffer(), peerId, plugin)),
+      protocol.factory,
       new Messenger({ signalManager }),
       createWebRTCTransportFactory(),
       undefined
@@ -44,25 +42,17 @@ describe('Swarm', () => {
       await swarm.destroy();
     });
 
-    return { swarm, plugin };
+    return { swarm, protocol };
   };
 
   test('connects two peers in a swarm', async () => {
     const topic = PublicKey.random();
     const peerId1 = PublicKey.random();
     const peerId2 = PublicKey.random();
-    const data = 'Hello';
 
-    const { swarm: swarm1, plugin: plugin1 } = setupSwarm({ topic, peerId: peerId1 });
-    let receivedData: string;
-    plugin1.on('receive', async (_, payload) => {
-      receivedData = payload;
-    });
+    const { swarm: swarm1, protocol: protocol1 } = setupSwarm({ topic, peerId: peerId1 });
 
-    const { swarm: swarm2, plugin: plugin2 } = setupSwarm({ topic, peerId: peerId2 });
-    plugin2.on('connect', async () => {
-      await plugin2.send(peerId1.asBuffer(), data);
-    });
+    const { swarm: swarm2 } = setupSwarm({ topic, peerId: peerId2 });
 
     expect(swarm1.connections.length).toEqual(0);
     expect(swarm2.connections.length).toEqual(0);
@@ -91,9 +81,7 @@ describe('Swarm', () => {
     await promise;
     log('Swarms connected');
 
-    await waitForExpect(() => {
-      expect(receivedData).toEqual(data);
-    });
+    await protocol1.testConnection(peerId2);
   }).timeout(5_000);
 
   test('two peers try to originate connections to each other simultaneously', async () => {
@@ -130,18 +118,10 @@ describe('Swarm', () => {
     const topic = PublicKey.random();
     const peerId1 = PublicKey.random();
     const peerId2 = PublicKey.random();
-    const data = 'Hello';
 
-    const { swarm: swarm1, plugin: plugin1 } = setupSwarm({ topic, peerId: peerId1 });
-    let receivedData: string;
-    plugin1.on('receive', async (_, payload) => {
-      receivedData = payload;
-    });
+    const { swarm: swarm1, protocol: protocol1 } = setupSwarm({ topic, peerId: peerId1 });
 
-    const { swarm: swarm2, plugin: plugin2 } = setupSwarm({ topic, peerId: peerId2 });
-    plugin2.on('connect', async () => {
-      await plugin2.send(peerId1.asBuffer(), data);
-    });
+    const { swarm: swarm2 } = setupSwarm({ topic, peerId: peerId2 });
 
     expect(swarm1.connections.length).toEqual(0);
     expect(swarm2.connections.length).toEqual(0);
@@ -164,8 +144,6 @@ describe('Swarm', () => {
 
     await connectPromises;
 
-    await waitForExpect(() => {
-      expect(receivedData).toEqual(data);
-    });
+    await protocol1.testConnection(peerId2);
   }).timeout(10_000);
 });

package/src/testing/index.ts

@@ -3,4 +3,3 @@
 //
 
 export * from './test-builder';
-export * from './test-protocol';

package/src/testing/test-builder.ts

@@ -17,8 +17,7 @@ import {
   WebRTCTransportProxyFactory,
   WebRTCTransportService
 } from '../transport';
-import { adaptProtocolProvider } from '../wire-protocol';
-import { TestProtocolPlugin, testProtocolProvider } from './test-protocol';
+import { TestWireProtocol } from './test-wire-protocol';
 
 // Signal server will be started by the setup script.
 export const TEST_SIGNAL_URL = 'ws://localhost:4000/.well-known/dx/signal';
@@ -152,12 +151,12 @@ export class TestPeer {
 
 // TODO(burdon): Reconcile with new Swarm concept.
 export class TestSwarmConnection {
-  plugin: TestProtocolPlugin;
+  protocol: TestWireProtocol;
 
   constructor(readonly peer: TestPeer, readonly topic: PublicKey) {
     // TODO(burdon): Configure plugins.
     // TODO(burdon): Prevent reuse?
-    this.plugin = new TestProtocolPlugin(this.peer.peerId.asBuffer()); // TODO(burdon): PublicKey.
+    this.protocol = new TestWireProtocol(this.peer.peerId);
   }
 
   // TODO(burdon): Need to create new plugin instance per swarm?
@@ -166,9 +165,7 @@ export class TestSwarmConnection {
     await this.peer._networkManager.joinSwarm({
       topic: this.topic,
       peerId: this.peer.peerId,
-      protocolProvider: adaptProtocolProvider(
-        testProtocolProvider(this.topic.asBuffer(), this.peer.peerId, this.plugin)
-      ),
+      protocolProvider: this.protocol.factory,
       topology
     });
 

package/src/testing/test-wire-protocol.ts

@@ -0,0 +1,44 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { Event } from '@dxos/async';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { TestExtension } from '@dxos/teleport';
+import { ComplexMap } from '@dxos/util';
+
+import { createTeleportProtocolFactory } from '../wire-protocol';
+
+export class TestWireProtocol {
+  public readonly connections = new ComplexMap<PublicKey, TestExtension>(PublicKey.hash);
+  public readonly connected = new Event<PublicKey>();
+
+  constructor(public readonly peerId: PublicKey) {}
+
+  readonly factory = createTeleportProtocolFactory(async (teleport) => {
+    log('create', { remotePeerId: teleport.remotePeerId });
+    const extension = new TestExtension({
+      onClose: async () => {
+        this.connections.delete(teleport.remotePeerId);
+      }
+    });
+    this.connections.set(teleport.remotePeerId, extension);
+    teleport.addExtension('test', extension);
+    this.connected.emit(teleport.remotePeerId);
+  });
+
+  async waitForConnection(peerId: PublicKey) {
+    if (this.connections.has(peerId)) {
+      return this.connections.get(peerId)!;
+    }
+    log('waitForConnection', { peerId });
+    await this.connected.waitFor((connectedId) => connectedId.equals(peerId));
+    return this.connections.get(peerId)!;
+  }
+
+  async testConnection(peerId: PublicKey) {
+    const connection = await this.waitForConnection(peerId);
+    await connection.test();
+  }
+}

package/src/tests/basic-test-suite.ts

@@ -3,12 +3,9 @@
 //
 
 import { expect } from 'chai';
-import waitForExpect from 'wait-for-expect';
 
-import { latch } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { Protocol } from '@dxos/mesh-protocol';
 import { test } from '@dxos/test';
 import { range } from '@dxos/util';
 
@@ -88,11 +85,8 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     expect(topics).to.have.length(numSwarms);
   });
 
-  // TODO(burdon): Fails with WebRTC.
-  // TODO(burdon): This just tests multiple swarms (not peers in the same swarm)?
-  //  Generalize for n swarms and factor into other tests; configure message activity.
-  test.skip('joins multiple swarms concurrently', async () => {
-    const createSwarm = async (messages: any[], label: string) => {
+  test('joins multiple swarms concurrently', async () => {
+    const createSwarm = async () => {
       const topicA = PublicKey.random();
       const peer1a = testBuilder.createPeer();
       const peer2a = testBuilder.createPeer();
@@ -100,33 +94,19 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
       const swarm1a = await peer1a.createSwarm(topicA).join();
       const swarm2a = await peer2a.createSwarm(topicA).join();
 
-      swarm1a.plugin.on('receive', (_, msg: string) => {
-        messages.push(msg);
-      });
-      swarm2a.plugin.on('connect', async () => {
-        await swarm2a.plugin.send(peer1a.peerId.asBuffer(), label);
-      });
+      return { swarm1a, swarm2a, peer1a, peer2a };
     };
 
-    const receivedA: any[] = [];
-    const receivedB: any[] = [];
+    const test1 = await createSwarm();
+    const test2 = await createSwarm();
 
-    void createSwarm(receivedA, 'Swarm A');
-    void createSwarm(receivedB, 'Swarm B');
-
-    // TODO(burdon): Replace with triggers.
-    await waitForExpect(() => {
-      expect(receivedA).to.have.length(1);
-      expect(receivedB).to.have.length(1);
-
-      expect(receivedA[0]).to.eq('Swarm A');
-      expect(receivedB[0]).to.eq('Swarm B');
-    });
+    await Promise.all([
+      test1.swarm1a.protocol.testConnection(test1.peer2a.peerId),
+      test2.swarm1a.protocol.testConnection(test1.peer2a.peerId)
+    ]);
   });
 
-  // TODO(burdon): Fails with WebRTC.
-  // TODO(burdon): Factor out components of test.
-  test.skip('many peers and connections', async () => {
+  test('many peers and connections', async () => {
     const numTopics = 5;
     const peersPerTopic = 5;
 
@@ -138,29 +118,9 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
           range(peersPerTopic).map(async () => {
             const peer = testBuilder.createPeer();
             const swarm = await peer.createSwarm(topic).join();
-
-            const [done, pongReceived] = latch({ count: peersPerTopic - 1 });
-
-            swarm.plugin.on('connect', async (protocol: Protocol) => {
-              const { peerId } = protocol.getSession() ?? {};
-              const remoteId = PublicKey.from(peerId);
-              await swarm.plugin.send(remoteId.asBuffer(), 'ping');
-            });
-
-            swarm.plugin.on('receive', async (protocol: Protocol, data: any) => {
-              const { peerId } = protocol.getSession() ?? {};
-              const remoteId = PublicKey.from(peerId);
-
-              if (data === 'ping') {
-                await swarm.plugin.send(remoteId.asBuffer(), 'pong');
-              } else if (data === 'pong') {
-                pongReceived();
-              } else {
-                throw new Error(`Invalid message: ${data}`);
-              }
-            });
-
-            await done();
+            await swarm.protocol.connected.waitForCondition(
+              () => swarm.protocol.connections.size === peersPerTopic - 1
+            );
           })
         );
       })

package/src/tests/property-test-suite.ts

@@ -6,15 +6,13 @@ import * as fc from 'fast-check';
 import { ModelRunSetup } from 'fast-check';
 import waitForExpect from 'wait-for-expect';
 
+import { todo } from '@dxos/debug';
 import { PublicKey } from '@dxos/keys';
-import { PresencePlugin } from '@dxos/protocol-plugin-presence';
-import { afterTest, test } from '@dxos/test';
-import { range, ComplexMap, ComplexSet } from '@dxos/util';
+import { test } from '@dxos/test';
+import { ComplexMap, ComplexSet, range } from '@dxos/util';
 
 import { NetworkManager } from '../network-manager';
-import { createProtocolFactory } from '../protocol-factory';
 import { FullyConnectedTopology } from '../topology';
-import { adaptProtocolProvider } from '../wire-protocol';
 
 /**
  * Performs random actions in the real system and compares its state with a simplified model.
@@ -35,7 +33,7 @@ export const propertyTestSuite = () => {
      * The real system being tested.
      */
     interface Real {
-      peers: ComplexMap<PublicKey, { networkManager: NetworkManager; presence?: PresencePlugin }>;
+      peers: ComplexMap<PublicKey, { networkManager: NetworkManager; presence?: any }>;
     }
 
     const assertState = async (model: Model, real: Real) => {
@@ -48,12 +46,12 @@ export const propertyTestSuite = () => {
               }
 
               const actuallyConnectedPeers = peer.presence!.peers;
-              if (!actuallyConnectedPeers.some((peer) => PublicKey.equals(expectedPeerId, peer))) {
+              if (!actuallyConnectedPeers.some((peer: any) => PublicKey.equals(expectedPeerId, peer))) {
                 // TODO(burdon): More concise error.
                 const context = {
                   peerId: peer.presence.peerId,
                   expectedPeerId: expectedPeerId.truncate(),
-                  connectedPeerIds: actuallyConnectedPeers.map((key) => key.toString('hex'))
+                  connectedPeerIds: actuallyConnectedPeers.map((key: any) => key.toString('hex'))
                 };
 
                 throw new Error(`Expected peer to be in the list of joined peers: ${context}`);
@@ -118,19 +116,19 @@ export const propertyTestSuite = () => {
 
         const peer = real.peers.get(this.peerId)!;
 
-        const presence = new PresencePlugin(this.peerId.asBuffer());
-        afterTest(() => presence.stop());
-        const protocol = createProtocolFactory(model.topic, this.peerId, [presence]);
+        // const presence = new PresencePlugin(this.peerId.asBuffer());
+        // afterTest(() => presence.stop());
+        // const protocol = createProtocolFactory(model.topic, this.peerId, [presence]);
 
         await peer.networkManager.joinSwarm({
           peerId: this.peerId, // TODO(burdon): `this`?
           topic: model.topic,
-          protocolProvider: adaptProtocolProvider(protocol),
-          topology: new FullyConnectedTopology(),
-          presence
+          protocolProvider: todo(),
+          topology: new FullyConnectedTopology()
+          // presence
         });
 
-        peer.presence = presence;
+        // peer.presence = presence;
 
         await assertState(model, real);
       }

package/src/tests/utils.ts

@@ -2,9 +2,6 @@
 // Copyright 2022 DXOS.org
 //
 
-import { expect } from 'chai';
-
-import { latch, Trigger } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
 import { afterTest } from '@dxos/test';
 import { Provider } from '@dxos/util';
@@ -30,15 +27,11 @@ export const openAndCloseAfterTest = async (peers: TestPeer[]) => {
  * Join and cleanly leave swarm.
  */
 export const joinSwarm = async (peers: TestPeer[], topic: PublicKey, topology?: Provider<Topology>) => {
-  const [connected, connect] = latch({ count: peers.length });
-  const swarms = peers.map((peer) => {
-    const swarm = peer.createSwarm(topic);
-    swarm.plugin.once('connect', connect);
-    return swarm;
-  });
-
+  const swarms = peers.map((peer) => peer.createSwarm(topic));
   await Promise.all(swarms.map((swarm) => swarm.join(topology?.())));
-  await connected();
+  await Promise.all(
+    swarms.map((swarm) => swarm.protocol.connected.waitForCondition(() => swarm.protocol.connections.size >= 0))
+  );
   return swarms;
 };
 
@@ -46,15 +39,11 @@ export const joinSwarm = async (peers: TestPeer[], topic: PublicKey, topology?:
  * Cleanly leave swarm.
  */
 export const leaveSwarm = async (peers: TestPeer[], topic: PublicKey) => {
-  const [disconnected, disconnect] = latch({ count: peers.length });
-  const swarms = peers.map((peer) => {
-    const swarm = peer.getSwarm(topic);
-    swarm.plugin.once('disconnect', disconnect);
-    return swarm;
-  });
-
+  const swarms = peers.map((peer) => peer.getSwarm(topic));
   await Promise.all(swarms.map((swarm) => swarm.leave()));
-  await disconnected();
+  await Promise.all(
+    swarms.map((swarm) => swarm.protocol.connected.waitForCondition(() => swarm.protocol.connections.size === 0))
+  );
   return swarms;
 };
 
@@ -64,22 +53,6 @@ export const leaveSwarm = async (peers: TestPeer[], topic: PublicKey) => {
 // TODO(burdon): Based on plugin instance.
 // TODO(burdon): Configure to send more messages.
 export const exchangeMessages = async (swarm1: TestSwarmConnection, swarm2: TestSwarmConnection) => {
-  {
-    const peer2Received = new Trigger<any>();
-    swarm2.plugin.on('receive', (peer, message) => peer2Received.wake(message));
-
-    // TODO(burdon): Message encoding?
-    await swarm1.plugin.send(swarm2.peer.peerId.asBuffer(), JSON.stringify({ message: 'ping' }));
-    const { message } = JSON.parse(await peer2Received.wait());
-    expect(message).to.eq('ping');
-  }
-
-  {
-    const peer1Received = new Trigger<any>();
-    swarm1.plugin.on('receive', (peer, message) => peer1Received.wake(message));
-
-    await swarm2.plugin.send(swarm1.peer.peerId.asBuffer(), JSON.stringify({ message: 'pong' }));
-    const { message } = JSON.parse(await peer1Received.wait());
-    expect(message).to.eq('pong');
-  }
+  await swarm1.protocol.testConnection(swarm2.peer.peerId);
+  await swarm2.protocol.testConnection(swarm1.peer.peerId);
 };

package/src/transport/memory-transport.test.ts

@@ -2,16 +2,11 @@
 // Copyright 2021 DXOS.org
 //
 
-import expect from 'expect';
-import waitForExpect from 'wait-for-expect';
-
-import { discoveryKey } from '@dxos/crypto';
+import { TestStream } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
-import { Protocol } from '@dxos/mesh-protocol';
-import { describe, test, afterTest } from '@dxos/test';
+import { afterTest, describe, test } from '@dxos/test';
 import { range } from '@dxos/util';
 
-import { TestProtocolPlugin, testProtocolProvider } from '../testing';
 import { MemoryTransport } from './memory-transport';
 
 // TODO(burdon): Flaky test.
@@ -24,10 +19,9 @@ const createPair = () => {
   const peer1Id = PublicKey.random();
   const peer2Id = PublicKey.random();
 
-  const plugin1 = new TestProtocolPlugin(peer1Id.asBuffer());
-  const protocolProvider1 = testProtocolProvider(topic.asBuffer(), peer1Id, plugin1);
+  const stream1 = new TestStream();
   const connection1 = new MemoryTransport({
-    stream: protocolProvider1({ channel: discoveryKey(topic), initiator: true }).stream,
+    stream: stream1,
     sendSignal: async (signal) => {
       await connection2.signal(signal);
     },
@@ -37,10 +31,9 @@ const createPair = () => {
   afterTest(() => connection1.destroy());
   afterTest(() => connection1.errors.assertNoUnhandledErrors());
 
-  const plugin2 = new TestProtocolPlugin(peer2Id.asBuffer());
-  const protocolProvider2 = testProtocolProvider(topic.asBuffer(), peer2Id, plugin2);
+  const stream2 = new TestStream();
   const connection2 = new MemoryTransport({
-    stream: protocolProvider2({ channel: discoveryKey(topic), initiator: false }).stream,
+    stream: stream2,
     sendSignal: async (signal) => {
       await connection1.signal(signal);
     },
@@ -53,8 +46,8 @@ const createPair = () => {
   return {
     connection1,
     connection2,
-    plugin1,
-    plugin2,
+    stream1,
+    stream2,
     peer1Id,
     peer2Id,
     topic
@@ -63,47 +56,15 @@ const createPair = () => {
 
 describe('MemoryTransport', () => {
   test('establish connection and send data through with protocol', async () => {
-    const { plugin1, plugin2, peer1Id } = createPair();
-
-    const received: any[] = [];
-    const mockReceive = (p: Protocol, s: string) => {
-      received.push(p, s);
-      return undefined;
-    };
-    plugin1.on('receive', mockReceive);
-
-    plugin2.on('connect', async (protocol) => {
-      await plugin2.send(peer1Id.asBuffer(), '{"message": "Hello"}');
-    });
-
-    await waitForExpect(() => {
-      expect(received.length).toBe(2);
-      expect(received[0]).toBeInstanceOf(Protocol);
-      expect(received[1]).toBe('{"message": "Hello"}');
-    });
+    const { stream1, stream2 } = createPair();
+    await TestStream.assertConnectivity(stream1, stream2);
   });
 
-  test.skip('10 pairs of peers connecting at the same time', async () => {
+  test('10 pairs of peers connecting at the same time', async () => {
     await Promise.all(
       range(10).map(async () => {
-        const { plugin1, plugin2, peer1Id } = createPair();
-
-        const received: any[] = [];
-        const mockReceive = (p: Protocol, s: string) => {
-          received.push(p, s);
-          return undefined;
-        };
-        plugin1.on('receive', mockReceive);
-
-        plugin2.on('connect', async (protocol) => {
-          await plugin2.send(peer1Id.asBuffer(), '{"message": "Hello"}');
-        });
-
-        await waitForExpect(() => {
-          expect(received.length).toBe(2);
-          expect(received[0]).toBeInstanceOf(Protocol);
-          expect(received[1]).toBe('{"message": "Hello"}');
-        });
+        const { stream1, stream2 } = createPair();
+        await TestStream.assertConnectivity(stream1, stream2);
       })
     );
   });