@dxos/network-manager 0.6.12-staging.e11e696 → 0.6.12

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

@@ -2,10 +2,10 @@
 // Copyright 2021 DXOS.org
 //
 
-import { randomBytes } from 'node:crypto';
-import { describe, test } from 'vitest';
+import { randomBytes } from 'crypto';
 
 import { PublicKey } from '@dxos/keys';
+import { test } from '@dxos/test';
 import { range } from '@dxos/util';
 
 import { basicTestSuite } from './basic-test-suite';
@@ -17,45 +17,47 @@ describe('Memory transport', () => {
   const testBuilder = new TestBuilder();
   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}`);
+  test
+    .skip('load', 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 ({ swarm1, swarm2 }) => {
-          await exchangeMessages(swarm1, swarm2, message);
+        pairs.map(async ({ peer1, peer2, topic }) => {
+          await leaveSwarm([peer1, peer2], topic);
         }),
       );
-    }
-
-    await Promise.all(
-      pairs.map(async ({ peer1, peer2, topic }) => {
-        await leaveSwarm([peer1, peer2], topic);
-      }),
-    );
-  });
+    })
+    .timeout(1_000_000);
 });

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

@@ -4,10 +4,11 @@
 
 import * as fc from 'fast-check';
 import { type ModelRunSetup } from 'fast-check';
-import { test } from 'vitest';
+import waitForExpect from 'wait-for-expect';
 
 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';
@@ -36,29 +37,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.test.ts

@@ -0,0 +1,67 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import { randomBytes } from 'crypto';
+
+import { PublicKey } from '@dxos/keys';
+import { test } from '@dxos/test';
+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', 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);
+        }),
+      );
+    })
+    .timeout(1_000_000);
+});

package/src/tests/utils.ts

@@ -2,10 +2,9 @@
 // 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';
@@ -20,7 +19,7 @@ import { type Topology } from '../topology';
  */
 export const openAndCloseAfterTest = async (peers: TestPeer[]) => {
   await Promise.all(peers.map((peer) => peer.open()));
-  onTestFinished(async () => {
+  afterTest(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 'vitest';
+import { describe } from '@dxos/test';
 
 import { basicTestSuite } from './basic-test-suite';
 import { TEST_SIGNAL_HOSTS, TestBuilder } from '../testing';
 
-describe('WebRTC transport', { timeout: 10_000 }, () => {
+describe('WebRTC transport', () => {
   const testBuilder = new TestBuilder();
   basicTestSuite(testBuilder);
-});
+}).timeout(10_000);
 
-describe('WebRTC transport proxy', { timeout: 10_000 }, () => {
+describe('WebRTC transport proxy', () => {
   const testBuilder = new TestBuilder({ bridge: true });
   basicTestSuite(testBuilder);
-});
+}).timeout(10_000);
 
 describe('test with signal server', () => {
-  describe('WebRTC transport', { timeout: 10_000 }, () => {
+  describe('WebRTC transport', () => {
     const testBuilder = new TestBuilder({ signalHosts: TEST_SIGNAL_HOSTS });
     basicTestSuite(testBuilder);
-  });
+  }).timeout(10_000);
 
-  describe('WebRTC transport proxy', { timeout: 10_000 }, () => {
+  describe('WebRTC transport proxy', () => {
     const testBuilder = new TestBuilder({ signalHosts: TEST_SIGNAL_HOSTS, bridge: true });
     basicTestSuite(testBuilder);
-  });
+  }).timeout(10_000);
 });

package/src/transport/index.ts

@@ -4,4 +4,8 @@
 
 export * from './memory-transport';
 export * from './transport';
-export * from './webrtc';
+export * from './simplepeer-transport';
+export * from './simplepeer-transport-service';
+export * from './simplepeer-transport-proxy';
+export * from './libdatachannel-transport';
+export * from './tcp-transport';

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

@@ -0,0 +1,100 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Duplex } from 'stream';
+
+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 () => {
+    const connection = new LibDataChannelTransport({
+      initiator: true,
+      stream: new Duplex(),
+      sendSignal: async () => {},
+    });
+
+    await connection.open();
+    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 () => {
+    const stream1 = new TestStream();
+    const connection1 = new LibDataChannelTransport({
+      initiator: true,
+      stream: stream1,
+      sendSignal: async (signal) => {
+        await sleep(10);
+        await connection2.onSignal(signal);
+      },
+    });
+    await connection1.open();
+    afterTest(() => connection1.close());
+    afterTest(() => connection1.errors.assertNoUnhandledErrors());
+
+    const stream2 = new TestStream();
+    const connection2 = new LibDataChannelTransport({
+      initiator: false,
+      stream: stream2,
+      sendSignal: async (signal) => {
+        await sleep(10);
+        await connection1.onSignal(signal);
+      },
+    });
+    await connection2.open();
+    afterTest(() => connection2.close());
+    afterTest(() => 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 () => {
+    const stream1 = new TestStream();
+    const connection1 = new LibDataChannelTransport({
+      initiator: true,
+      stream: stream1,
+      sendSignal: async (signal) => {
+        log.debug('signal', signal);
+
+        await sleep(10);
+        await connection2.onSignal(signal);
+      },
+    });
+    await connection1.open();
+    afterTest(() => connection1.close());
+    afterTest(() => connection1.errors.assertNoUnhandledErrors());
+
+    const stream2 = new TestStream();
+    const connection2 = new SimplePeerTransport({
+      initiator: false,
+      stream: stream2,
+      sendSignal: async (signal) => {
+        log.debug('signal', signal);
+
+        await sleep(10);
+        await connection1.onSignal(signal);
+      },
+    });
+    await connection2.open();
+    afterTest(() => connection2.close());
+    afterTest(() => connection2.errors.assertNoUnhandledErrors());
+
+    await TestStream.assertConnectivity(stream1, stream2, { timeout: 2_000 });
+  })
+    .onlyEnvironments('nodejs')
+    .timeout(2_000)
+    .retries(3);
+});