@dxos/network-manager 0.6.13 → 0.6.14-main.1366248

package/src/swarm/connection.test.ts

@@ -2,78 +2,103 @@
 // 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 { createLibDataChannelTransportFactory, createSimplePeerTransportFactory } from '../transport';
+import { createRtcTransportFactory } from '../transport';
+import { chooseInitiatorPeer } from '../transport/webrtc/utils';
 
 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 peer1 = { peerKey: PublicKey.random().toHex() };
-    const peer2 = { peerKey: PublicKey.random().toHex() };
-    const protocol1 = new TestWireProtocol(PublicKey.from(peer1.peerKey));
-    const connection1 = new Connection(
+    const slowPeer = { peerKey: setup.slowConnectionKey.toHex() };
+    const fastPeer = { peerKey: setup.fastConnectionKey.toHex() };
+
+    const slowPeerProtocol = new TestWireProtocol();
+    const slowConnection = new Connection(
       topic,
-      peer1,
-      peer2,
+      slowPeer,
+      fastPeer,
       sessionId,
       true,
       {
-        offer: async (msg) => {
-          return { accept: true };
-        },
+        offer: async (msg) => ({ accept: true }),
         signal: async (msg) => {
-          await connection2.signal(msg);
+          await fastConnection.signal(msg);
         },
       },
-      protocol1.factory({
+      slowPeerProtocol.factory({
         initiator: true,
-        localPeerId: PublicKey.from(peer1.peerKey),
-        remotePeerId: PublicKey.from(peer2.peerKey),
+        localPeerId: PublicKey.from(slowPeer.peerKey),
+        remotePeerId: PublicKey.from(fastPeer.peerKey),
         topic,
       }),
-      // TODO(nf): configure better
-      process.env.MOCHA_ENV === 'nodejs' ? createLibDataChannelTransportFactory() : createSimplePeerTransportFactory(),
+      createRtcTransportFactory(),
     );
 
-    const protocol2 = new TestWireProtocol(PublicKey.from(peer2.peerKey));
-    const connection2 = new Connection(
+    const fastPeerProtocol = new TestWireProtocol();
+    const fastConnection = new Connection(
       topic,
-      peer2,
-      peer1,
+      fastPeer,
+      slowPeer,
       sessionId,
       false,
       {
-        offer: async (msg) => {
-          return { accept: true };
-        },
+        offer: async (msg) => ({ accept: true }),
         signal: async (msg) => {
-          await connection1.signal(msg);
+          await slowConnection.signal(msg);
         },
       },
-      protocol2.factory({
+      fastPeerProtocol.factory({
         initiator: false,
-        localPeerId: PublicKey.from(peer2.peerKey),
-        remotePeerId: PublicKey.from(peer1.peerKey),
+        localPeerId: PublicKey.from(fastPeer.peerKey),
+        remotePeerId: PublicKey.from(slowPeer.peerKey),
         topic,
       }),
-      // TODO(nf): configure better
-      process.env.MOCHA_ENV === 'nodejs' ? createLibDataChannelTransportFactory() : createSimplePeerTransportFactory(),
+      createRtcTransportFactory(),
     );
 
-    connection2.initiate();
-    await connection2.openConnection();
-    await sleep(100);
+    fastConnection.initiate();
+    await fastConnection.openConnection();
+    await sleep(200);
+
+    slowConnection.initiate();
+    await slowConnection.openConnection();
 
-    connection1.initiate();
-    await connection1.openConnection();
     await Promise.all([
-      protocol1.testConnection(PublicKey.from(peer2.peerKey), 'test message 1'),
-      protocol2.testConnection(PublicKey.from(peer1.peerKey), 'test message 2'),
+      slowPeerProtocol.testConnection(PublicKey.from(fastPeer.peerKey), 'test message 1'),
+      fastPeerProtocol.testConnection(PublicKey.from(slowPeer.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,7 +15,6 @@ import {
   ConnectionResetError,
   ConnectivityError,
   TimeoutError,
-  UnknownProtocolError,
   trace,
 } from '@dxos/protocols';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
@@ -202,14 +201,15 @@ 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();
@@ -234,12 +234,10 @@ export class Connection {
       // TODO(nf): fix ErrorStream so instanceof works here
       if (err instanceof ConnectionResetError) {
         log.info('aborting due to transport ConnectionResetError');
-        this.abort().catch((err) => this.errors.raise(err));
+        this.abort(err).catch((err) => this.errors.raise(err));
       } 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 });
+        this.abort(err).catch((err) => this.errors.raise(err));
       }
 
       if (this._state !== ConnectionState.CLOSED && this._state !== ConnectionState.CLOSING) {
@@ -248,6 +246,8 @@ 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/peer.ts

@@ -285,7 +285,8 @@ export class Peer {
           });
         },
         onClosed: (err) => {
-          log('connection closed', { topic: this.topic, peerId: this.localInfo, remoteId: this.remoteInfo, initiator });
+          const logMeta = { topic: this.topic, peerId: this.localInfo, remoteId: this.remoteInfo, initiator };
+          log('connection closed', logMeta);
 
           // Make sure none of the connections are stuck in the limiter.
           this._connectionLimiter.doneConnecting(sessionId);
@@ -310,11 +311,13 @@ export class Peer {
               this.availableToConnect = false;
               this._availableAfter = increaseInterval(this._availableAfter);
             }
+
             this._callbacks.onDisconnected();
 
             scheduleTask(
               this._connectionCtx!,
               () => {
+                log('peer became available', logMeta);
                 this.availableToConnect = true;
                 this._callbacks.onPeerAvailable();
               },

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 {
@@ -189,8 +189,10 @@ export class Swarm {
       const peer = this._peers.get(swarmEvent.peerLeft.peer);
       if (peer) {
         peer.advertizing = false;
-        if (peer.connection?.state !== ConnectionState.CONNECTED) {
-          // Destroy peer only if there is no p2p-connection established
+        // Destroy peer only if there is no p2p-connection established. Otherwise, let peers go through
+        // the graceful shutdown protocol.
+        if (this._isConnectionEstablishmentInProgress(peer)) {
+          log(`destroying peer, state: ${peer.connection?.state}`);
           void this._destroyPeer(swarmEvent.peerLeft.peer, 'peer left').catch((err) => log.catch(err));
         }
       } else {
@@ -277,6 +279,7 @@ export class Swarm {
           },
           onDisconnected: async () => {
             if (this._isUnregistered(peer)) {
+              log.verbose('ignored onDisconnected for unregistered peer');
               return;
             }
             if (!peer!.advertizing) {
@@ -312,6 +315,7 @@ export class Swarm {
   }
 
   private async _destroyPeer(peerInfo: PeerInfo, reason?: string) {
+    log('destroy peer', { peerKey: peerInfo.peerKey, reason });
     const peer = this._peers.get(peerInfo);
     invariant(peer);
     this._peers.delete(peerInfo);
@@ -399,6 +403,15 @@ export class Swarm {
     await peer.closeConnection();
   }
 
+  private _isConnectionEstablishmentInProgress(peer: Peer) {
+    if (!peer.connection) {
+      return true;
+    }
+    return [ConnectionState.INITIAL, ConnectionState.CREATED, ConnectionState.CONNECTING].includes(
+      peer.connection.state,
+    );
+  }
+
   private _isUnregistered(peer?: Peer): boolean {
     return !peer || this._peers.get(peer.remoteInfo) !== peer;
   }

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,13 @@ 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);
+    this._networkManager.setPeerInfo({ identityKey: peerId.toHex(), peerKey: peerId.toHex() });
   }
 
   // TODO(burdon): Move to TestBuilder.
@@ -110,13 +98,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 +122,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 +204,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,18 +29,17 @@ 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 });
+    const handleDisconnect = () => {
+      this.connections.delete(teleport.remotePeerId);
+      this.disconnected.emit(teleport.remotePeerId);
+    };
     const extension = new TestExtension({
-      onClose: async () => {
-        this.connections.delete(teleport.remotePeerId);
-        this.disconnected.emit(teleport.remotePeerId);
-      },
+      onClose: async () => handleDisconnect(),
+      onAbort: async () => handleDisconnect(),
     });
     this.connections.set(teleport.remotePeerId, extension);
     teleport.addExtension('test', extension);

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';
@@ -34,21 +32,21 @@ 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 () => {
     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 () => {
@@ -75,7 +73,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
       await exchangeMessages(swarm1, swarm2);
       await leaveSwarm([peer1, peer2], topic2);
     }
-  }).tag('flaky');
+  });
 
   test('joins multiple swarms', async () => {
     // TODO(burdon): N peers.
@@ -87,7 +85,7 @@ 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 () => {
     const createSwarm = async () => {
@@ -109,7 +107,7 @@ 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 () => {
     const peer1 = testBuilder.createPeer();
@@ -120,20 +118,20 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     const [swarm1, swarm2] = await joinSwarm([peer1, peer2], topic, () => new FullyConnectedTopology());
     await exchangeMessages(swarm1, swarm2);
 
-    void swarm1.protocol.connections.get(swarm2.peer.peerId)!.closeConnection(new Error('test error'));
+    const disconnectedKeys = new Set();
+    swarm1.protocol.disconnected.on((peerInfo) => disconnectedKeys.add(peerInfo.toHex()));
+    swarm2.protocol.disconnected.on((peerInfo) => disconnectedKeys.add(peerInfo.toHex()));
 
+    void swarm1.protocol.connections.get(swarm2.peer.peerId)!.closeConnection(new Error('test error'));
     // Wait until both peers are disconnected.
-    await Promise.all([
-      swarm1.protocol.disconnected.waitForCondition(() => swarm1.protocol.connections.size === 0),
-      swarm2.protocol.disconnected.waitForCondition(() => swarm2.protocol.connections.size === 0),
-    ]);
+    await expect.poll(() => disconnectedKeys.size).toEqual(2);
 
     await exchangeMessages(swarm1, swarm2);
 
     await leaveSwarm([peer1, peer2], topic);
-  }).tag('flaky');
+  });
 
-  test('going offline and back online', async () => {
+  test('going offline and back online', { timeout: 2_000 }, async () => {
     const peer1 = testBuilder.createPeer();
     const peer2 = testBuilder.createPeer();
     await openAndCloseAfterTest([peer1, peer2]);
@@ -158,25 +156,28 @@ 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 () => {
@@ -207,5 +208,5 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     );
 
     await asyncTimeout(Promise.all(swarmsAllPeersConnected), 2_000);
-  }).tag('stress');
+  });
 };