@dxos/network-manager 0.6.13-main.ed424a1 → 0.6.13

package/src/signal/ice.test.ts

@@ -2,8 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
+import { expect } from 'chai';
 import fetchMock from 'fetch-mock';
-import { afterEach, test, expect, describe } from 'vitest';
+
+import { test, describe } from '@dxos/test';
 
 import { createIceProvider } from './ice';
 

package/src/signal/ice.ts

@@ -24,12 +24,7 @@ export const createIceProvider = (iceProviders: Runtime.Services.IceProvider[]):
           iceProviders.map(({ urls }) =>
             asyncTimeout(fetch(urls, { method: 'GET' }), 10_000)
               .then((response) => response.json())
-              .catch((err) => {
-                const isDev = typeof window !== 'undefined' && window.location.href.includes('localhost');
-                if (!isDev) {
-                  log.error('Failed to fetch ICE servers from provider', { urls, err });
-                }
-              }),
+              .catch((err) => log.error('Failed to fetch ICE servers from provider', { urls, err })),
           ),
         )
       )

package/src/signal/{integration.node.test.ts → integration.test.ts}

@@ -2,11 +2,15 @@
 // Copyright 2022 DXOS.org
 //
 
-import { afterAll, onTestFinished, beforeAll, describe, expect, test } from 'vitest';
+// @dxos/test platform=nodejs
+
+import { expect } from 'earljs';
+import waitForExpect from 'wait-for-expect';
 
 import { PublicKey } from '@dxos/keys';
 import { Messenger, type PeerInfo, WebsocketSignalManager } from '@dxos/messaging';
 import { runTestSignalServer, type SignalServerRunner } from '@dxos/signal';
+import { afterAll, afterTest, beforeAll, describe, test } from '@dxos/test';
 
 import { type SignalMessage } from './signal-messenger';
 import { SwarmMessenger } from './swarm-messenger';
@@ -31,15 +35,13 @@ describe('Signal Integration Test', () => {
   }) => {
     const signalManager = new WebsocketSignalManager([{ server: broker.url() }]);
     await signalManager.open();
-    onTestFinished(async () => {
-      await signalManager.close();
-    });
+    afterTest(() => signalManager.close());
 
     const messenger = new Messenger({
       signalManager,
     });
     messenger.open();
-    onTestFinished(() => messenger.close());
+    afterTest(() => messenger.close());
     await messenger.listen({
       peer,
       onMessage: async (message) => await messageRouter.receiveMessage(message),
@@ -94,7 +96,7 @@ describe('Signal Integration Test', () => {
           offer: {},
         },
       }),
-    ).toEqual(expect.objectContaining({ accept: true }));
+    ).toBeAnObjectWith({ accept: true });
 
     expect(
       await peerNetworking2.messageRouter.offer({
@@ -106,7 +108,7 @@ describe('Signal Integration Test', () => {
           offer: {},
         },
       }),
-    ).toEqual(expect.objectContaining({ accept: true }));
+    ).toBeAnObjectWith({ accept: true });
 
     {
       const message: SignalMessage = {
@@ -121,7 +123,9 @@ describe('Signal Integration Test', () => {
       };
       await peerNetworking1.messageRouter.signal(message);
 
-      await expect.poll(() => peerNetworking2.receivedSignals[0]).toEqual(expect.objectContaining(message));
+      await waitForExpect(() => {
+        expect(peerNetworking2.receivedSignals[0]).toBeAnObjectWith(message);
+      });
     }
 
     {
@@ -137,7 +141,9 @@ describe('Signal Integration Test', () => {
       };
       await peerNetworking2.messageRouter.signal(message);
 
-      await expect.poll(() => peerNetworking1.receivedSignals[0]).toEqual(expect.objectContaining(message));
+      await waitForExpect(() => {
+        expect(peerNetworking1.receivedSignals[0]).toBeAnObjectWith(message);
+      });
     }
   });
 });

package/src/signal/{swarm-messenger.node.test.ts → swarm-messenger.test.ts}

@@ -2,18 +2,22 @@
 // Copyright 2022 DXOS.org
 //
 
-import { afterAll, beforeAll, beforeEach, describe, expect, test, onTestFinished } from 'vitest';
+// @dxos/test platform=nodejs
+
+import { expect } from 'earljs';
+import waitForExpect from 'wait-for-expect';
 
 import { type Awaited } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
 import { Messenger, WebsocketSignalManager } from '@dxos/messaging';
 import { type Answer } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { runTestSignalServer } from '@dxos/signal';
+import { afterAll, beforeAll, describe, test, afterTest } from '@dxos/test';
 
 import { type OfferMessage, type SignalMessage } from './signal-messenger';
 import { SwarmMessenger } from './swarm-messenger';
 
-describe('SwarmMessenger', { timeout: 7000 }, () => {
+describe('SwarmMessenger', () => {
   let topic: PublicKey;
 
   let broker1: Awaited<ReturnType<typeof runTestSignalServer>>;
@@ -44,9 +48,7 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
     const peer = { peerKey: PublicKey.random().toHex() };
     const signalManager = new WebsocketSignalManager([{ server: signalApiUrl }]);
     await signalManager.open();
-    onTestFinished(async () => {
-      await signalManager.close();
-    });
+    afterTest(() => signalManager.close());
 
     const messenger = new Messenger({ signalManager });
     await messenger.listen({
@@ -104,8 +106,10 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
     };
     await router2.signal(msg);
 
-    await expect.poll(() => received[0]).toEqual(expect.objectContaining(msg));
-  });
+    await waitForExpect(() => {
+      expect(received[0]).toBeAnObjectWith(msg);
+    }, 4_000);
+  }).timeout(5_000);
 
   test('offer/answer', async () => {
     const {
@@ -135,7 +139,7 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       data: { offer: {} },
     });
     expect(answer.accept).toEqual(true);
-  });
+  }).timeout(5_000);
 
   test('signaling between 3 clients', async () => {
     const received1: SignalMessage[] = [];
@@ -194,7 +198,9 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       data: { signal: { payload: { msg: '1to3' } }, signalBatch: undefined },
     };
     await router1.signal(msg1to3);
-    await expect.poll(() => received3[0]).toEqual(expect.objectContaining(msg1to3));
+    await waitForExpect(() => {
+      expect(received3[0]).toBeAnObjectWith(msg1to3);
+    }, 4_000);
 
     // sending signal from peer2 to peer3.
     const msg2to3: SignalMessage = {
@@ -205,7 +211,9 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       data: { signal: { payload: { msg: '2to3' } }, signalBatch: undefined },
     };
     await router2.signal(msg2to3);
-    await expect.poll(() => received3[1]).toEqual(expect.objectContaining(msg2to3));
+    await waitForExpect(() => {
+      expect(received3[1]).toBeAnObjectWith(msg2to3);
+    }, 4_000);
 
     // sending signal from peer3 to peer1.
     const msg3to1: SignalMessage = {
@@ -216,8 +224,10 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       data: { signal: { payload: { msg: '3to1' } }, signalBatch: undefined },
     };
     await router3.signal(msg3to1);
-    await expect.poll(() => received1[0]).toEqual(expect.objectContaining(msg3to1));
-  });
+    await waitForExpect(() => {
+      expect(received1[0]).toBeAnObjectWith(msg3to1);
+    }, 4_000);
+  }).timeout(5_000);
 
   test('two offers', async () => {
     const {
@@ -263,5 +273,5 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       data: { offer: {} },
     });
     expect(answer2.accept).toEqual(true);
-  });
+  }).timeout(5_000);
 });

package/src/swarm/connection-limiter.test.ts

@@ -1,14 +1,17 @@
 //
 // Copyright 2023 DXOS.org
 //
-
-import { describe, expect, test } from 'vitest';
+import chai, { expect } from 'chai';
+import chaiAsPromised from 'chai-as-promised';
 
 import { asyncTimeout } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
+import { describe, test } from '@dxos/test';
 
 import { ConnectionLimiter } from './connection-limiter';
 
+chai.use(chaiAsPromised);
+
 describe('ConnectionLimiter', () => {
   function* setupPeers(
     limiter: ConnectionLimiter,
@@ -34,7 +37,7 @@ describe('ConnectionLimiter', () => {
   test('rejects if done is called', async () => {
     const limiter = new ConnectionLimiter({ maxConcurrentInitConnections: 1 });
     const [first] = setupPeers(limiter);
-    const testPromise = expect(first.connecting()).rejects.toBeInstanceOf(Error);
+    const testPromise = expect(first.connecting()).to.be.rejected;
     first.doneConnecting();
     await testPromise;
   });

package/src/swarm/connection.test.ts

@@ -2,103 +2,78 @@
 // Copyright 2023 DXOS.org
 //
 
-import { describe, test } from 'vitest';
-
 import { sleep } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
+import { describe, test } from '@dxos/test';
 
 import { Connection } from './connection';
 import { TestWireProtocol } from '../testing/test-wire-protocol';
-import { createRtcTransportFactory } from '../transport';
-import { chooseInitiatorPeer } from '../transport/webrtc/utils';
+import { createLibDataChannelTransportFactory, createSimplePeerTransportFactory } from '../transport';
 
 describe('Connection', () => {
-  test('responder opens after initiator', async () => {
-    const { initiator, responder } = createPeerKeys();
-    await connectionTest({
-      fastConnectionKey: initiator,
-      slowConnectionKey: responder,
-    });
-  });
-
   test('initiator opens after responder', async () => {
-    const { initiator, responder } = createPeerKeys();
-    await connectionTest({
-      fastConnectionKey: responder,
-      slowConnectionKey: initiator,
-    });
-  });
-
-  const connectionTest = async (setup: { fastConnectionKey: PublicKey; slowConnectionKey: PublicKey }) => {
     const [topic, sessionId] = PublicKey.randomSequence();
-    const slowPeer = { peerKey: setup.slowConnectionKey.toHex() };
-    const fastPeer = { peerKey: setup.fastConnectionKey.toHex() };
-
-    const slowPeerProtocol = new TestWireProtocol();
-    const slowConnection = new Connection(
+    const peer1 = { peerKey: PublicKey.random().toHex() };
+    const peer2 = { peerKey: PublicKey.random().toHex() };
+    const protocol1 = new TestWireProtocol(PublicKey.from(peer1.peerKey));
+    const connection1 = new Connection(
       topic,
-      slowPeer,
-      fastPeer,
+      peer1,
+      peer2,
       sessionId,
       true,
       {
-        offer: async (msg) => ({ accept: true }),
+        offer: async (msg) => {
+          return { accept: true };
+        },
         signal: async (msg) => {
-          await fastConnection.signal(msg);
+          await connection2.signal(msg);
         },
       },
-      slowPeerProtocol.factory({
+      protocol1.factory({
         initiator: true,
-        localPeerId: PublicKey.from(slowPeer.peerKey),
-        remotePeerId: PublicKey.from(fastPeer.peerKey),
+        localPeerId: PublicKey.from(peer1.peerKey),
+        remotePeerId: PublicKey.from(peer2.peerKey),
         topic,
       }),
-      createRtcTransportFactory(),
+      // TODO(nf): configure better
+      process.env.MOCHA_ENV === 'nodejs' ? createLibDataChannelTransportFactory() : createSimplePeerTransportFactory(),
     );
 
-    const fastPeerProtocol = new TestWireProtocol();
-    const fastConnection = new Connection(
+    const protocol2 = new TestWireProtocol(PublicKey.from(peer2.peerKey));
+    const connection2 = new Connection(
       topic,
-      fastPeer,
-      slowPeer,
+      peer2,
+      peer1,
       sessionId,
       false,
       {
-        offer: async (msg) => ({ accept: true }),
+        offer: async (msg) => {
+          return { accept: true };
+        },
         signal: async (msg) => {
-          await slowConnection.signal(msg);
+          await connection1.signal(msg);
         },
       },
-      fastPeerProtocol.factory({
+      protocol2.factory({
         initiator: false,
-        localPeerId: PublicKey.from(fastPeer.peerKey),
-        remotePeerId: PublicKey.from(slowPeer.peerKey),
+        localPeerId: PublicKey.from(peer2.peerKey),
+        remotePeerId: PublicKey.from(peer1.peerKey),
         topic,
       }),
-      createRtcTransportFactory(),
+      // TODO(nf): configure better
+      process.env.MOCHA_ENV === 'nodejs' ? createLibDataChannelTransportFactory() : createSimplePeerTransportFactory(),
     );
 
-    fastConnection.initiate();
-    await fastConnection.openConnection();
-    await sleep(200);
-
-    slowConnection.initiate();
-    await slowConnection.openConnection();
+    connection2.initiate();
+    await connection2.openConnection();
+    await sleep(100);
 
+    connection1.initiate();
+    await connection1.openConnection();
     await Promise.all([
-      slowPeerProtocol.testConnection(PublicKey.from(fastPeer.peerKey), 'test message 1'),
-      fastPeerProtocol.testConnection(PublicKey.from(slowPeer.peerKey), 'test message 2'),
+      protocol1.testConnection(PublicKey.from(peer2.peerKey), 'test message 1'),
+      protocol2.testConnection(PublicKey.from(peer1.peerKey), 'test message 2'),
     ]);
-  };
-
-  const createPeerKeys = () => {
-    const peer1 = PublicKey.random();
-    const peer2 = PublicKey.random();
-    const initiator = PublicKey.fromHex(chooseInitiatorPeer(peer1.toHex(), peer2.toHex()));
-    if (initiator.equals(peer1)) {
-      return { initiator: peer1, responder: peer2 };
-    } else {
-      return { initiator: peer2, responder: peer1 };
-    }
-  };
+  });
 });

package/src/swarm/connection.ts

@@ -15,6 +15,7 @@ import {
   ConnectionResetError,
   ConnectivityError,
   TimeoutError,
+  UnknownProtocolError,
   trace,
 } from '@dxos/protocols';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
@@ -201,15 +202,14 @@ export class Connection {
 
     invariant(!this._transport);
     this._transport = this._transportFactory.createTransport({
-      ownPeerKey: this.localInfo.peerKey,
-      remotePeerKey: this.remoteInfo.peerKey,
-      topic: this.topic.toHex(),
       initiator: this.initiator,
       stream: this._protocol.stream,
       sendSignal: async (signal) => this._sendSignal(signal),
       sessionId: this.sessionId,
     });
 
+    await this._transport.open();
+
     this._transport.connected.once(async () => {
       this._changeState(ConnectionState.CONNECTED);
       await this.connectedTimeoutContext.dispose();
@@ -238,6 +238,8 @@ export class Connection {
       } else if (err instanceof ConnectivityError) {
         log.info('aborting due to transport ConnectivityError');
         this.abort().catch((err) => this.errors.raise(err));
+      } else if (err instanceof UnknownProtocolError) {
+        log.warn('unsure what to do with UnknownProtocolError, will keep on truckin', { err });
       }
 
       if (this._state !== ConnectionState.CLOSED && this._state !== ConnectionState.CLOSING) {
@@ -246,8 +248,6 @@ export class Connection {
       }
     });
 
-    await this._transport.open();
-
     // Replay signals that were received before transport was created.
     for (const signal of this._incomingSignalBuffer) {
       void this._transport.onSignal(signal); // TODO(burdon): Remove async?

package/src/swarm/swarm.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2020 DXOS.org
 //
 
-import { onTestFinished, describe, expect, test } from 'vitest';
+import { expect } from 'chai';
 
 import { asyncTimeout, sleep } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
@@ -13,6 +13,7 @@ import {
   type PeerInfo,
   type SignalManager,
 } from '@dxos/messaging';
+import { afterTest, describe, test } from '@dxos/test';
 import { ComplexSet } from '@dxos/util';
 
 import { ConnectionState } from './connection';
@@ -20,7 +21,7 @@ import { ConnectionLimiter } from './connection-limiter';
 import { Swarm } from './swarm';
 import { TestWireProtocol } from '../testing/test-wire-protocol';
 import { FullyConnectedTopology } from '../topology';
-import { createRtcTransportFactory } from '../transport';
+import { createLibDataChannelTransportFactory, createSimplePeerTransportFactory } from '../transport';
 
 type TestPeer = {
   swarm: Swarm;
@@ -46,20 +47,21 @@ describe('Swarm', () => {
     signalManager?: SignalManager;
     initiationDelay?: number;
   }): Promise<TestPeer> => {
-    const protocol = new TestWireProtocol();
+    const protocol = new TestWireProtocol(PublicKey.from(peer.peerKey));
     const swarm = new Swarm(
       topic,
       peer,
       new FullyConnectedTopology(),
       protocol.factory,
       new Messenger({ signalManager }),
-      createRtcTransportFactory(),
+      // TODO(nf): configure better
+      process.env.MOCHA_ENV === 'nodejs' ? createLibDataChannelTransportFactory() : createSimplePeerTransportFactory(),
       undefined,
       connectionLimiter,
       initiationDelay,
     );
 
-    onTestFinished(async () => {
+    afterTest(async () => {
       await swarm.destroy();
       await signalManager.close();
     });
@@ -79,7 +81,7 @@ describe('Swarm', () => {
     expect(peer2.swarm.connections.length).to.equal(0);
 
     await connectSwarms(peer1, peer2);
-  });
+  }).timeout(5_000);
 
   test('two peers try to originate connections to each other simultaneously', async () => {
     const topic = PublicKey.random();
@@ -91,7 +93,7 @@ describe('Swarm', () => {
     expect(peer2.swarm.connections.length).to.equal(0);
 
     await connectSwarms(peer1, peer2);
-  });
+  }).timeout(5_000);
 
   test('with simultaneous connections one of the peers drops initiated connection', async () => {
     const topic = PublicKey.random();
@@ -109,9 +111,9 @@ describe('Swarm', () => {
 
     await connectSwarms(peer1, peer2);
     await asyncTimeout(connectionDisplaced!, 1000);
-  });
+  }).timeout(5_000);
 
-  test('second peer discovered after delay', { timeout: 10_000 }, async () => {
+  test('second peer discovered after delay', async () => {
     const topic = PublicKey.random();
 
     const peer1 = await setupSwarm({ topic });
@@ -124,7 +126,7 @@ describe('Swarm', () => {
     expect(peer2.swarm.connections.length).to.equal(0);
 
     await connectSwarms(peer1, peer2, () => sleep(15));
-  });
+  }).timeout(10_000);
 
   test('connection limiter', async () => {
     // remotePeer1 <--> peer (connectionLimiter: max = 1) <--> remotePeer2

package/src/swarm/swarm.ts

@@ -29,7 +29,7 @@ const getClassName = (obj: any) => Object.getPrototypeOf(obj).constructor.name;
 
 /**
  * A single peer's view of the swarm.
- * Manages a set of peers subscribed on the same topic.
+ * Manages a set of connections implemented by simple-peer instances.
  * Routes signal events and maintains swarm topology.
  */
 export class Swarm {

package/src/testing/test-builder.ts

@@ -16,12 +16,19 @@ import { type Runtime } from '@dxos/protocols/proto/dxos/config';
 import { createLinkedPorts, createProtoRpcPeer, type ProtoRpcPeer } from '@dxos/rpc';
 import { ComplexMap } from '@dxos/util';
 
-import { TcpTransportFactory } from '#tcp-transport';
 import { type TestTeleportExtensionFactory, TestWireProtocol } from './test-wire-protocol';
 import { SwarmNetworkManager } from '../network-manager';
 import { FullyConnectedTopology } from '../topology';
-import { MemoryTransportFactory, type TransportFactory, TransportKind } from '../transport';
-import { createRtcTransportFactory, RtcTransportProxyFactory, RtcTransportService } from '../transport';
+import {
+  createLibDataChannelTransportFactory,
+  createSimplePeerTransportFactory,
+  MemoryTransportFactory,
+  SimplePeerTransportProxyFactory,
+  SimplePeerTransportService,
+  type TransportFactory,
+  TransportKind,
+} from '../transport';
+import { TcpTransportFactory } from '../transport/tcp-transport';
 
 // Signal server will be started by the setup script.
 const port = process.env.SIGNAL_PORT ?? 4000;
@@ -78,12 +85,18 @@ export class TestPeer {
   constructor(
     private readonly testBuilder: TestBuilder,
     public readonly peerId: PublicKey,
-    public readonly transport: TransportKind = testBuilder.options.signalHosts
-      ? TransportKind.WEB_RTC
-      : TransportKind.MEMORY,
+    public readonly transport?: TransportKind,
   ) {
     this._signalManager = this.testBuilder.createSignalManager();
-    this._networkManager = this.createNetworkManager(this.transport);
+    if (!transport) {
+      if (this.testBuilder.options.signalHosts) {
+        // TODO(nf): configure better
+        transport = process.env.MOCHA_ENV === 'nodejs' ? TransportKind.LIBDATACHANNEL : TransportKind.SIMPLE_PEER;
+      } else {
+        transport = TransportKind.MEMORY;
+      }
+    }
+    this._networkManager = this.createNetworkManager(transport);
   }
 
   // TODO(burdon): Move to TestBuilder.
@@ -97,10 +110,13 @@ export class TestPeer {
         case TransportKind.TCP:
           transportFactory = TcpTransportFactory;
           break;
-        case TransportKind.WEB_RTC:
-          transportFactory = createRtcTransportFactory();
+        case TransportKind.SIMPLE_PEER:
+          transportFactory = createSimplePeerTransportFactory();
+          break;
+        case TransportKind.LIBDATACHANNEL:
+          transportFactory = createLibDataChannelTransportFactory();
           break;
-        case TransportKind.WEB_RTC_PROXY:
+        case TransportKind.SIMPLE_PEER_PROXY:
           {
             // Simulates bridge to shared worker.
             const [proxyPort, servicePort] = createLinkedPorts();
@@ -121,14 +137,14 @@ export class TestPeer {
               exposed: {
                 BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
               },
-              handlers: { BridgeService: new RtcTransportService() },
+              handlers: { BridgeService: new SimplePeerTransportService() },
               noHandshake: true,
               encodingOptions: {
                 preserveAny: true,
               },
             });
 
-            transportFactory = new RtcTransportProxyFactory().setBridgeService(this._proxy.rpc.BridgeService);
+            transportFactory = new SimplePeerTransportProxyFactory().setBridgeService(this._proxy.rpc.BridgeService);
           }
           break;
         default:
@@ -203,7 +219,7 @@ export class TestSwarmConnection {
   ) {
     // TODO(burdon): Configure plugins.
     // TODO(burdon): Prevent reuse?
-    this.protocol = new TestWireProtocol(this.extensionFactory);
+    this.protocol = new TestWireProtocol(this.peer.peerId, this.extensionFactory);
   }
 
   // TODO(burdon): Need to create new plugin instance per swarm?

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

@@ -29,7 +29,10 @@ export class TestWireProtocol {
     ({ remotePeerId, extension }) => remotePeerId.toHex() + extension,
   );
 
-  constructor(private readonly _extensionFactory: TestTeleportExtensionFactory = () => []) {}
+  constructor(
+    public readonly peerId: PublicKey,
+    private readonly _extensionFactory: TestTeleportExtensionFactory = () => [],
+  ) {}
 
   readonly factory = createTeleportProtocolFactory(async (teleport) => {
     log('create', { remotePeerId: teleport.remotePeerId });