@dxos/network-manager 0.6.12 → 0.6.13-main.09887cd

package/src/swarm/swarm.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2020 DXOS.org
 //
 
-import { expect } from 'chai';
+import { onTestFinished, describe, expect, test } from 'vitest';
 
 import { asyncTimeout, sleep } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
@@ -13,7 +13,6 @@ import {
   type PeerInfo,
   type SignalManager,
 } from '@dxos/messaging';
-import { afterTest, describe, test } from '@dxos/test';
 import { ComplexSet } from '@dxos/util';
 
 import { ConnectionState } from './connection';
@@ -21,7 +20,7 @@ import { ConnectionLimiter } from './connection-limiter';
 import { Swarm } from './swarm';
 import { TestWireProtocol } from '../testing/test-wire-protocol';
 import { FullyConnectedTopology } from '../topology';
-import { createLibDataChannelTransportFactory, createSimplePeerTransportFactory } from '../transport';
+import { createRtcTransportFactory } from '../transport';
 
 type TestPeer = {
   swarm: Swarm;
@@ -47,21 +46,20 @@ describe('Swarm', () => {
     signalManager?: SignalManager;
     initiationDelay?: number;
   }): Promise<TestPeer> => {
-    const protocol = new TestWireProtocol(PublicKey.from(peer.peerKey));
+    const protocol = new TestWireProtocol();
     const swarm = new Swarm(
       topic,
       peer,
       new FullyConnectedTopology(),
       protocol.factory,
       new Messenger({ signalManager }),
-      // TODO(nf): configure better
-      process.env.MOCHA_ENV === 'nodejs' ? createLibDataChannelTransportFactory() : createSimplePeerTransportFactory(),
+      createRtcTransportFactory(),
       undefined,
       connectionLimiter,
       initiationDelay,
     );
 
-    afterTest(async () => {
+    onTestFinished(async () => {
       await swarm.destroy();
       await signalManager.close();
     });
@@ -81,7 +79,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();
@@ -93,7 +91,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();
@@ -111,9 +109,9 @@ describe('Swarm', () => {
 
     await connectSwarms(peer1, peer2);
     await asyncTimeout(connectionDisplaced!, 1000);
-  }).timeout(5_000);
+  });
 
-  test('second peer discovered after delay', async () => {
+  test('second peer discovered after delay', { timeout: 10_000 }, async () => {
     const topic = PublicKey.random();
 
     const peer1 = await setupSwarm({ topic });
@@ -126,7 +124,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 connections implemented by simple-peer instances.
+ * Manages a set of peers subscribed on the same topic.
  * Routes signal events and maintains swarm topology.
  */
 export class Swarm {

package/src/testing/test-builder.ts

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

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

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

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

@@ -2,13 +2,11 @@
 // Copyright 2021 DXOS.org
 //
 
-import { expect } from 'chai';
-import waitForExpect from 'wait-for-expect';
+import { onTestFinished, expect, test } from 'vitest';
 
 import { asyncTimeout } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { afterTest, test } from '@dxos/test';
 import { range } from '@dxos/util';
 
 import { exchangeMessages, joinSwarm, leaveSwarm, openAndCloseAfterTest } from './utils';
@@ -25,7 +23,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     return;
   }
 
-  test('joins swarm, sends messages, and cleanly exits', async () => {
+  test.skip('joins swarm, sends messages, and cleanly exits', async () => {
     const peer1 = testBuilder.createPeer();
     const peer2 = testBuilder.createPeer();
     await openAndCloseAfterTest([peer1, peer2]);
@@ -34,24 +32,24 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     const [swarm1, swarm2] = await joinSwarm([peer1, peer2], topic, () => new FullyConnectedTopology());
     await exchangeMessages(swarm1, swarm2);
     await leaveSwarm([peer1, peer2], topic);
-  }).tag('flaky');
+  });
 
   // TODO(burdon): Test with more peers (configure and test messaging).
-  test('joins swarm with star topology', async () => {
+  test.skip('joins swarm with star topology', async () => {
     const peer1 = testBuilder.createPeer();
-    afterTest(() => peer1.close());
+    onTestFinished(() => peer1.close());
     const peer2 = testBuilder.createPeer();
-    afterTest(() => peer2.close());
+    onTestFinished(() => peer2.close());
     await openAndCloseAfterTest([peer1, peer2]);
 
     const topic = PublicKey.random();
     const [swarm1, swarm2] = await joinSwarm([peer1, peer2], topic, () => new StarTopology(peer1.peerId)); // NOTE: Same peer.
     await exchangeMessages(swarm1, swarm2);
     await leaveSwarm([peer1, peer2], topic);
-  }).tag('flaky');
+  });
 
   // TODO(burdon): Fails when trying to reconnect to same topic.
-  test('joins swarm multiple times', async () => {
+  test.skip('joins swarm multiple times', async () => {
     const peer1 = testBuilder.createPeer();
     const peer2 = testBuilder.createPeer();
     await openAndCloseAfterTest([peer1, peer2]);
@@ -75,9 +73,9 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
       await exchangeMessages(swarm1, swarm2);
       await leaveSwarm([peer1, peer2], topic2);
     }
-  }).tag('flaky');
+  });
 
-  test('joins multiple swarms', async () => {
+  test.skip('joins multiple swarms', async () => {
     // TODO(burdon): N peers.
     // TODO(burdon): Merge with test below.
     const peer1 = testBuilder.createPeer();
@@ -87,9 +85,9 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     const numSwarms = 5;
     const topics = Array.from(Array(numSwarms)).map(() => PublicKey.random());
     expect(topics).to.have.length(numSwarms);
-  }).tag('flaky');
+  });
 
-  test('joins multiple swarms concurrently', async () => {
+  test.skip('joins multiple swarms concurrently', async () => {
     const createSwarm = async () => {
       const topicA = PublicKey.random();
       const peer1a = testBuilder.createPeer();
@@ -109,9 +107,9 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
       test1.swarm1a.protocol.testConnection(test1.peer2a.peerId),
       test2.swarm1a.protocol.testConnection(test2.peer2a.peerId),
     ]);
-  }).tag('flaky');
+  });
 
-  test('peers reconnect after and error in connection', async () => {
+  test.skip('peers reconnect after and error in connection', async () => {
     const peer1 = testBuilder.createPeer();
     const peer2 = testBuilder.createPeer();
     await openAndCloseAfterTest([peer1, peer2]);
@@ -131,9 +129,9 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     await exchangeMessages(swarm1, swarm2);
 
     await leaveSwarm([peer1, peer2], topic);
-  }).tag('flaky');
+  });
 
-  test('going offline and back online', async () => {
+  test.skip('going offline and back online', { timeout: 2_000 }, async () => {
     const peer1 = testBuilder.createPeer();
     const peer2 = testBuilder.createPeer();
     await openAndCloseAfterTest([peer1, peer2]);
@@ -158,28 +156,31 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     await peerLeft;
 
     // Wait for peer to be removed from the swarm.
-    await waitForExpect(() => {
-      expect(!!peer2._networkManager.getSwarm(topic)!._peers.get({ peerKey: peer1.peerId.toHex() })?.advertizing).to.be
-        .false;
-    }, 1_000);
+    await expect
+      .poll(() => !!peer2._networkManager.getSwarm(topic)!._peers.get({ peerKey: peer1.peerId.toHex() })?.advertizing, {
+        timeout: 1_000,
+      })
+      .toBe(false);
 
     await peer1.goOnline();
 
-    await waitForExpect(() => {
-      expect(peer1._networkManager.getSwarm(topic)?._peers.get({ peerKey: peer2.peerId.toHex() })?.advertizing).to.be
-        .true;
-      expect(peer2._networkManager.getSwarm(topic)?._peers.get({ peerKey: peer1.peerId.toHex() })?.advertizing).to.be
-        .true;
-    }, 2_000);
+    await expect
+      .poll(() => peer1._networkManager.getSwarm(topic)?._peers.get({ peerKey: peer2.peerId.toHex() })?.advertizing, {
+        timeout: 2_000,
+      })
+      .toBe(true);
+    await expect
+      .poll(() => peer2._networkManager.getSwarm(topic)?._peers.get({ peerKey: peer1.peerId.toHex() })?.advertizing, {
+        timeout: 2_000,
+      })
+      .toBe(true);
 
     await exchangeMessages(swarm1, swarm2);
     await leaveSwarm([peer1, peer2], topic);
-  })
-    .tag('flaky')
-    .timeout(2_000);
+  });
 
   // TODO(mykola): Fails with large amount of peers ~10.
-  test('many peers and connections', async () => {
+  test.skip('many peers and connections', async () => {
     const numTopics = 2;
     const peersPerTopic = 3;
     const swarmsAllPeersConnected: Promise<any>[] = [];
@@ -207,5 +208,5 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     );
 
     await asyncTimeout(Promise.all(swarmsAllPeersConnected), 2_000);
-  }).tag('stress');
+  });
 };

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

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

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/index.ts

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

package/src/transport/memory-transport.ts

@@ -123,6 +123,7 @@ export class MemoryTransport implements Transport {
           this.errors.raise(err);
         });
     }
+    return this;
   }
 
   async close() {
@@ -155,6 +156,7 @@ export class MemoryTransport implements Transport {
 
     this.closed.emit();
     log('closed');
+    return this;
   }
 
   async onSignal({ payload }: Signal) {