@dxos/network-manager 0.6.11 → 0.6.12-main.5cc132e

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

@@ -4,11 +4,10 @@
 
 import * as fc from 'fast-check';
 import { type ModelRunSetup } from 'fast-check';
-import waitForExpect from 'wait-for-expect';
+import { test } from 'vitest';
 
 import { todo } from '@dxos/debug';
 import { PublicKey } from '@dxos/keys';
-import { test } from '@dxos/test';
 import { ComplexMap, ComplexSet, range } from '@dxos/util';
 
 import { type SwarmNetworkManager } from '../network-manager';
@@ -37,29 +36,29 @@ export const propertyTestSuite = () => {
     }
 
     const assertState = async (model: Model, real: Real) => {
-      await waitForExpect(() => {
-        for (const peer of real.peers.values()) {
-          if (peer.presence) {
-            for (const expectedPeerId of model.joinedPeers) {
-              if (expectedPeerId.equals(peer.presence.peerId)) {
-                continue;
-              }
-
-              const actuallyConnectedPeers = peer.presence!.peers;
-              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: any) => key.toString('hex')),
-                };
-
-                throw new Error(`Expected peer to be in the list of joined peers: ${context}`);
-              }
+      // await waitForExpect(() => {
+      for (const peer of real.peers.values()) {
+        if (peer.presence) {
+          for (const expectedPeerId of model.joinedPeers) {
+            if (expectedPeerId.equals(peer.presence.peerId)) {
+              continue;
+            }
+
+            const actuallyConnectedPeers = peer.presence!.peers;
+            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: any) => key.toString('hex')),
+              };
+
+              throw new Error(`Expected peer to be in the list of joined peers: ${context}`);
             }
           }
         }
-      }, 5_000);
+      }
+      // }, 5_000);
 
       real.peers.forEach((peer) =>
         peer.networkManager.topics.forEach((topic) => {

package/src/tests/tcp-transport.node.test.ts

@@ -0,0 +1,65 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import { randomBytes } from 'node:crypto';
+import { describe, test } from 'vitest';
+
+import { PublicKey } from '@dxos/keys';
+import { range } from '@dxos/util';
+
+import { basicTestSuite } from './basic-test-suite';
+import { exchangeMessages, joinSwarm, leaveSwarm, openAndCloseAfterTest } from './utils';
+import { TestBuilder } from '../testing';
+import { FullyConnectedTopology } from '../topology';
+import { TransportKind } from '../transport';
+
+describe('Tcp transport', () => {
+  const testBuilder = new TestBuilder({
+    transport: TransportKind.TCP,
+  });
+
+  basicTestSuite(testBuilder);
+
+  test.skip('load', { timeout: 1_000_000 }, async () => {
+    const NUM_PAIRS = 100;
+    const NUM_ROUNDS = 10_000;
+    const PACKET_SIZE = 1_000;
+
+    const pairs = await Promise.all(
+      range(NUM_PAIRS).map(async () => {
+        const peer1 = testBuilder.createPeer();
+        const peer2 = testBuilder.createPeer();
+        await openAndCloseAfterTest([peer1, peer2]);
+
+        const topic = PublicKey.random();
+        const [swarm1, swarm2] = await joinSwarm([peer1, peer2], topic, () => new FullyConnectedTopology());
+
+        return {
+          peer1,
+          peer2,
+          topic,
+          swarm1,
+          swarm2,
+        };
+      }),
+    );
+
+    const message = randomBytes(PACKET_SIZE / 2).toString('hex');
+
+    for (let i = 0; i < NUM_ROUNDS; i++) {
+      // console.log(`Round ${i}/${NUM_ROUNDS}`);
+      await Promise.all(
+        pairs.map(async ({ swarm1, swarm2 }) => {
+          await exchangeMessages(swarm1, swarm2, message);
+        }),
+      );
+    }
+
+    await Promise.all(
+      pairs.map(async ({ peer1, peer2, topic }) => {
+        await leaveSwarm([peer1, peer2], topic);
+      }),
+    );
+  });
+});

package/src/tests/utils.ts

@@ -2,9 +2,10 @@
 // Copyright 2022 DXOS.org
 //
 
+import { onTestFinished } from 'vitest';
+
 import { asyncTimeout } from '@dxos/async';
 import { type PublicKey } from '@dxos/keys';
-import { afterTest } from '@dxos/test';
 import { type Provider } from '@dxos/util';
 
 import { type TestPeer, type TestSwarmConnection } from '../testing';
@@ -19,7 +20,7 @@ import { type Topology } from '../topology';
  */
 export const openAndCloseAfterTest = async (peers: TestPeer[]) => {
   await Promise.all(peers.map((peer) => peer.open()));
-  afterTest(async () => {
+  onTestFinished(async () => {
     await asyncTimeout(Promise.all(peers.map((peer) => peer.close())), 1_000);
   });
 };

package/src/tests/webrtc-transport.test.ts

@@ -2,29 +2,29 @@
 // Copyright 2021 DXOS.org
 //
 
-import { describe } from '@dxos/test';
+import { describe } from 'vitest';
 
 import { basicTestSuite } from './basic-test-suite';
 import { TEST_SIGNAL_HOSTS, TestBuilder } from '../testing';
 
-describe('WebRTC transport', () => {
+describe('WebRTC transport', { timeout: 10_000 }, () => {
   const testBuilder = new TestBuilder();
   basicTestSuite(testBuilder);
-}).timeout(10_000);
+});
 
-describe('WebRTC transport proxy', () => {
+describe('WebRTC transport proxy', { timeout: 10_000 }, () => {
   const testBuilder = new TestBuilder({ bridge: true });
   basicTestSuite(testBuilder);
-}).timeout(10_000);
+});
 
 describe('test with signal server', () => {
-  describe('WebRTC transport', () => {
+  describe('WebRTC transport', { timeout: 10_000 }, () => {
     const testBuilder = new TestBuilder({ signalHosts: TEST_SIGNAL_HOSTS });
     basicTestSuite(testBuilder);
-  }).timeout(10_000);
+  });
 
-  describe('WebRTC transport proxy', () => {
+  describe('WebRTC transport proxy', { timeout: 10_000 }, () => {
     const testBuilder = new TestBuilder({ signalHosts: TEST_SIGNAL_HOSTS, bridge: true });
     basicTestSuite(testBuilder);
-  }).timeout(10_000);
+  });
 });

package/src/transport/{libdatachannel-transport.test.ts → libdatachannel-transport.node.test.ts}

@@ -2,17 +2,17 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Duplex } from 'stream';
+import { Duplex } from 'node:stream';
+import { onTestFinished, describe, test } from 'vitest';
 
 import { sleep, TestStream } from '@dxos/async';
 import { log } from '@dxos/log';
-import { afterTest, describe, test } from '@dxos/test';
 
 import { LibDataChannelTransport } from './libdatachannel-transport';
 import { SimplePeerTransport } from './simplepeer-transport';
 
 describe('LibDataChannelTransport', () => {
-  test('open and close', async () => {
+  test('open and close', { timeout: 1_000 }, async () => {
     const connection = new LibDataChannelTransport({
       initiator: true,
       stream: new Duplex(),
@@ -23,12 +23,9 @@ describe('LibDataChannelTransport', () => {
     const wait = connection.closed.waitForCount(1);
     await connection.close();
     await wait;
-  })
-    .onlyEnvironments('nodejs')
-    .timeout(1_000)
-    .retries(3);
+  });
 
-  test('establish connection and send data through with protocol', async () => {
+  test('establish connection and send data through with protocol', { timeout: 2_000 }, async () => {
     const stream1 = new TestStream();
     const connection1 = new LibDataChannelTransport({
       initiator: true,
@@ -39,8 +36,8 @@ describe('LibDataChannelTransport', () => {
       },
     });
     await connection1.open();
-    afterTest(() => connection1.close());
-    afterTest(() => connection1.errors.assertNoUnhandledErrors());
+    onTestFinished(() => connection1.close());
+    onTestFinished(() => connection1.errors.assertNoUnhandledErrors());
 
     const stream2 = new TestStream();
     const connection2 = new LibDataChannelTransport({
@@ -52,16 +49,13 @@ describe('LibDataChannelTransport', () => {
       },
     });
     await connection2.open();
-    afterTest(() => connection2.close());
-    afterTest(() => connection2.errors.assertNoUnhandledErrors());
+    onTestFinished(() => connection2.close());
+    onTestFinished(() => connection2.errors.assertNoUnhandledErrors());
 
     await TestStream.assertConnectivity(stream1, stream2, { timeout: 2_000 });
-  })
-    .onlyEnvironments('nodejs')
-    .timeout(2_000)
-    .retries(3);
+  });
 
-  test('establish connection between LibDataChannel and SimplePeer', async () => {
+  test('establish connection between LibDataChannel and SimplePeer', { timeout: 2_000 }, async () => {
     const stream1 = new TestStream();
     const connection1 = new LibDataChannelTransport({
       initiator: true,
@@ -74,8 +68,8 @@ describe('LibDataChannelTransport', () => {
       },
     });
     await connection1.open();
-    afterTest(() => connection1.close());
-    afterTest(() => connection1.errors.assertNoUnhandledErrors());
+    onTestFinished(() => connection1.close());
+    onTestFinished(() => connection1.errors.assertNoUnhandledErrors());
 
     const stream2 = new TestStream();
     const connection2 = new SimplePeerTransport({
@@ -89,12 +83,9 @@ describe('LibDataChannelTransport', () => {
       },
     });
     await connection2.open();
-    afterTest(() => connection2.close());
-    afterTest(() => connection2.errors.assertNoUnhandledErrors());
+    onTestFinished(() => connection2.close());
+    onTestFinished(() => connection2.errors.assertNoUnhandledErrors());
 
     await TestStream.assertConnectivity(stream1, stream2, { timeout: 2_000 });
-  })
-    .onlyEnvironments('nodejs')
-    .timeout(2_000)
-    .retries(3);
+  });
 });

package/src/transport/libdatachannel-transport.ts

@@ -73,8 +73,7 @@ export class LibDataChannelTransport implements Transport {
 
     // TODO(burdon): Move to factory?
     /* eslint-disable @typescript-eslint/consistent-type-imports */
-    const { RTCPeerConnection } = (await importESM('node-datachannel/polyfill'))
-      .default as typeof import('node-datachannel/polyfill');
+    const { RTCPeerConnection } = await import('#node-datachannel/polyfill');
 
     const providedIceServers = await this._options.iceProvider?.getIceServers();
 
@@ -174,7 +173,7 @@ export class LibDataChannelTransport implements Transport {
   async close() {
     await this._close();
     if (--LibDataChannelTransport._instanceCount === 0) {
-      (await importESM('node-datachannel')).cleanup();
+      (await import('#node-datachannel')).cleanup();
     }
   }
 
@@ -371,6 +370,3 @@ export class LibDataChannelTransport implements Transport {
     this._options.stream.unpipe?.(this._stream)?.unpipe?.(this._options.stream);
   }
 }
-
-// eslint-disable-next-line no-new-func
-const importESM = Function('path', 'return import(path)');

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

@@ -2,9 +2,10 @@
 // Copyright 2021 DXOS.org
 //
 
+import { onTestFinished, describe, test } from 'vitest';
+
 import { TestStream } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
-import { afterTest, describe, test } from '@dxos/test';
 import { range } from '@dxos/util';
 
 import { MemoryTransport } from './memory-transport';
@@ -28,8 +29,8 @@ const createPair = async () => {
     initiator: true,
   });
 
-  afterTest(() => connection1.close());
-  afterTest(() => connection1.errors.assertNoUnhandledErrors());
+  onTestFinished(() => connection1.close());
+  onTestFinished(() => connection1.errors.assertNoUnhandledErrors());
 
   const stream2 = new TestStream();
   const connection2 = new MemoryTransport({
@@ -40,8 +41,8 @@ const createPair = async () => {
     initiator: false,
   });
 
-  afterTest(() => connection2.close());
-  afterTest(() => connection2.errors.assertNoUnhandledErrors());
+  onTestFinished(() => connection2.close());
+  onTestFinished(() => connection2.errors.assertNoUnhandledErrors());
 
   await connection1.open();
   await connection2.open();

package/src/transport/simplepeer-simple-peer.node.test.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import wrtc from '@koush/wrtc';
+import SimplePeerConstructor from 'simple-peer';
+import { describe, test } from 'vitest';
+
+import { sleep } from '@dxos/async';
+
+describe('Node WebRTC and simple-peer', () => {
+  // Simplest test that reproduces SIGABRT (mac) and SIGSEGV (linux) in wrtc.
+  test.skip('open and close', { timeout: 3_000 }, async () => {
+    const peer = new SimplePeerConstructor({
+      initiator: true,
+      wrtc,
+    });
+
+    await sleep(1);
+    await peer.destroy();
+  });
+});

package/src/transport/{simplepeer-transport-proxy-test.ts → simplepeer-transport-proxy.node.test.ts}

@@ -2,14 +2,13 @@
 // Copyright 2020 DXOS.org
 //
 
-// @dxos/test platform=nodejs
+import { afterAll, onTestFinished, beforeAll, describe, test } from 'vitest';
 
 import { TestStream } from '@dxos/async';
 import { schema } from '@dxos/protocols/proto';
 import { type BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { createLinkedPorts, createProtoRpcPeer, type ProtoRpcPeer } from '@dxos/rpc';
-import { afterAll, afterTest, beforeAll, describe, test } from '@dxos/test';
 
 import { SimplePeerTransportProxy } from './simplepeer-transport-proxy';
 import { SimplePeerTransportService } from './simplepeer-transport-service';
@@ -43,7 +42,7 @@ describe('SimplePeerTransportProxy', () => {
       },
     });
     await rpcService.open();
-    afterTest(() => rpcService.close());
+    onTestFinished(() => rpcService.close());
 
     // Starting RPC client
     const rpcClient = createProtoRpcPeer({
@@ -57,7 +56,7 @@ describe('SimplePeerTransportProxy', () => {
       },
     });
     await rpcClient.open();
-    afterTest(() => rpcClient.close());
+    onTestFinished(() => rpcClient.close());
 
     const simplePeerTransportProxy = new SimplePeerTransportProxy({
       initiator,
@@ -66,21 +65,21 @@ describe('SimplePeerTransportProxy', () => {
       bridgeService: rpcClient.rpc.BridgeService,
     });
     await simplePeerTransportProxy.open();
-    afterTest(async () => await simplePeerTransportProxy.close());
+    onTestFinished(async () => await simplePeerTransportProxy.close());
 
     return { simplePeerService: rpcService, SimplePeerTransportProxy: simplePeerTransportProxy };
   };
 
   // This doesn't clean up correctly and crashes with SIGSEGV / SIGABRT at the end. Probably an issue with wrtc package.
-  test('open and close', async () => {
+  test('open and close', { timeout: 1_000 }, async () => {
     const { SimplePeerTransportProxy: connection } = await setupProxy();
 
     const wait = connection.closed.waitForCount(1);
     await connection.close();
     await wait;
-  }).timeout(1_000);
+  });
 
-  test('establish connection and send data through with protocol', async () => {
+  test('establish connection and send data through with protocol', { timeout: 2_000 }, async () => {
     const stream1 = new TestStream();
     const { SimplePeerTransportProxy: connection1 } = await setupProxy({
       initiator: true,
@@ -89,7 +88,7 @@ describe('SimplePeerTransportProxy', () => {
         await connection2.onSignal(signal);
       },
     });
-    afterTest(() => connection1.errors.assertNoUnhandledErrors());
+    onTestFinished(() => connection1.errors.assertNoUnhandledErrors());
 
     const stream2 = new TestStream();
     const { SimplePeerTransportProxy: connection2 } = await setupProxy({
@@ -99,10 +98,10 @@ describe('SimplePeerTransportProxy', () => {
         await connection1.onSignal(signal);
       },
     });
-    afterTest(() => connection2.errors.assertNoUnhandledErrors());
+    onTestFinished(() => connection2.errors.assertNoUnhandledErrors());
 
     await TestStream.assertConnectivity(stream1, stream2);
-  }).timeout(2_000);
+  });
 
   describe('Multiplexing', () => {
     let service: any;
@@ -143,7 +142,7 @@ describe('SimplePeerTransportProxy', () => {
       await rpcClient?.close();
     });
 
-    test('establish connection and send data through with protocol', async () => {
+    test('establish connection and send data through with protocol', { timeout: 3_000 }, async () => {
       const stream1 = new TestStream();
       const proxy1 = new SimplePeerTransportProxy({
         initiator: true,
@@ -153,7 +152,7 @@ describe('SimplePeerTransportProxy', () => {
         },
         bridgeService: rpcClient.rpc.BridgeService,
       });
-      afterTest(async () => {
+      onTestFinished(async () => {
         proxy1.errors.assertNoUnhandledErrors();
         await proxy1.close();
       });
@@ -167,7 +166,7 @@ describe('SimplePeerTransportProxy', () => {
         },
         bridgeService: rpcClient.rpc.BridgeService,
       });
-      afterTest(async () => {
+      onTestFinished(async () => {
         proxy2.errors.assertNoUnhandledErrors();
         await proxy2.close();
       });
@@ -176,6 +175,6 @@ describe('SimplePeerTransportProxy', () => {
       await proxy2.open();
 
       await TestStream.assertConnectivity(stream1, stream2);
-    }).timeout(3_000);
+    });
   });
 });

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

@@ -2,16 +2,16 @@
 // Copyright 2020 DXOS.org
 //
 
-import { Duplex } from 'stream';
+import { Duplex } from 'node:stream';
+import { onTestFinished, describe, test } from 'vitest';
 
 import { sleep, TestStream } from '@dxos/async';
-import { afterTest, describe, test } from '@dxos/test';
 
 import { SimplePeerTransport } from './simplepeer-transport';
 
 describe('SimplePeerTransport', () => {
   // This doesn't clean up correctly and crashes with SIGSEGV / SIGABRT at the end. Probably an issue with wrtc package.
-  test('open and close', async () => {
+  test('open and close', { timeout: 1_000 }, async () => {
     const connection = new SimplePeerTransport({
       initiator: true,
       stream: new Duplex(),
@@ -22,11 +22,9 @@ describe('SimplePeerTransport', () => {
     const wait = connection.closed.waitForCount(1);
     await connection.close();
     await wait;
-  })
-    .timeout(1_000)
-    .retries(3);
+  });
 
-  test('establish connection and send data through with protocol', async () => {
+  test('establish connection and send data through with protocol', { timeout: 2_000 }, async () => {
     const stream1 = new TestStream();
     const connection1 = new SimplePeerTransport({
       initiator: true,
@@ -36,8 +34,8 @@ describe('SimplePeerTransport', () => {
         await connection2.onSignal(signal);
       },
     });
-    afterTest(() => connection1.close());
-    afterTest(() => connection1.errors.assertNoUnhandledErrors());
+    onTestFinished(() => connection1.close());
+    onTestFinished(() => connection1.errors.assertNoUnhandledErrors());
 
     const stream2 = new TestStream();
     const connection2 = new SimplePeerTransport({
@@ -48,14 +46,12 @@ describe('SimplePeerTransport', () => {
         await connection1.onSignal(signal);
       },
     });
-    afterTest(() => connection2.close());
-    afterTest(() => connection2.errors.assertNoUnhandledErrors());
+    onTestFinished(() => connection2.close());
+    onTestFinished(() => connection2.errors.assertNoUnhandledErrors());
 
     await connection1.open();
     await connection2.open();
 
     await TestStream.assertConnectivity(stream1, stream2);
-  })
-    .timeout(2_000)
-    .retries(3);
+  });
 });

package/src/transport/simplepeer-transport.ts

@@ -4,10 +4,10 @@
 //
 
 import SimplePeerConstructor, { type Instance as SimplePeer } from 'simple-peer';
-import invariant from 'tiny-invariant';
 
 import { Event, synchronized } from '@dxos/async';
 import { ErrorStream, raise } from '@dxos/debug';
+import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { ConnectionResetError, ConnectivityError, ProtocolError, UnknownProtocolError, trace } from '@dxos/protocols';

package/src/typings.d.ts

@@ -3,5 +3,11 @@
 //
 
 declare module '@koush/wrtc';
-declare module 'nanomessage-rpc';
-declare module 'xor-distance';
+
+declare module '#node-datachannel' {
+  export * from 'node-datachannel';
+}
+
+declare module '#node-datachannel/polyfill' {
+  export * from 'node-datachannel/polyfill';
+}