@dxos/network-manager 2.33.9-dev.002e8917 → 2.33.9-dev.227ba79d

package/src/signal/message-router.test.ts

@@ -10,9 +10,8 @@ import { Awaited } from '@dxos/async';
 import { PublicKey } from '@dxos/protocols';
 import { createTestBroker } from '@dxos/signal';
 import { afterTest } from '@dxos/testutils';
-import { randomInt } from '@dxos/util';
 
-import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
+import { Answer, SignalMessage } from '../proto/gen/dxos/mesh/signalMessage';
 import { MessageRouter } from './message-router';
 import { SignalClient } from './signal-client';
 
@@ -22,11 +21,9 @@ describe('MessageRouter', () => {
   let peer2: PublicKey;
 
   let broker1: Awaited<ReturnType<typeof createTestBroker>>;
-  const signalApiPort1 = randomInt(10000, 50000);
-  const signalApiUrl1 = 'http://0.0.0.0:' + signalApiPort1;
 
   before(async () => {
-    broker1 = await createTestBroker(signalApiPort1);
+    broker1 = await createTestBroker();
   });
 
   beforeEach(() => {
@@ -35,9 +32,8 @@ describe('MessageRouter', () => {
     peer2 = PublicKey.random();
   });
 
-  after(async function () {
-    this.timeout(0);
-    await broker1.stop();
+  after(() => {
+    broker1.stop();
   });
 
   const createSignalClientAndMessageRouter = async ({
@@ -46,15 +42,15 @@ describe('MessageRouter', () => {
     onOffer = async () => ({ accept: true })
   }: {
     signalApiUrl: string;
-    onSignal?: (msg: Message) => Promise<void>;
-    onOffer?: (msg: Message) => Promise<Answer>;
+    onSignal?: (msg: SignalMessage) => Promise<void>;
+    onOffer?: (msg: SignalMessage) => Promise<Answer>;
   }) => {
 
     // eslint-disable-next-line prefer-const
     let api: SignalClient;
     const router: MessageRouter = new MessageRouter({
       // todo(mykola): added catch to avoid not finished request.
-      sendMessage: (msg: Message) => api.signal(msg).catch((_) => { }),
+      sendMessage: (msg: SignalMessage) => api.signal(msg).catch((_) => { }),
       onSignal: onSignal,
       onOffer: onOffer
     });
@@ -62,8 +58,7 @@ describe('MessageRouter', () => {
 
     api = new SignalClient(
       signalApiUrl,
-      (async () => {}) as any,
-      async (msg: Message) => router.receiveMessage(msg)
+      async (msg: SignalMessage) => router.receiveMessage(msg)
     );
 
     afterTest(() => api.close());
@@ -74,19 +69,19 @@ describe('MessageRouter', () => {
   };
 
   test('signaling between 2 clients', async () => {
-    const signalMock1 = mockFn<(msg: Message) => Promise<void>>().resolvesTo();
-    const { api: api1 } = await createSignalClientAndMessageRouter({ signalApiUrl: signalApiUrl1, onSignal: signalMock1 });
-    const { api: api2, router: router2 } = await createSignalClientAndMessageRouter({ signalApiUrl: signalApiUrl1 });
+    const signalMock1 = mockFn<(msg: SignalMessage) => Promise<void>>().resolvesTo();
+    const { api: api1 } = await createSignalClientAndMessageRouter({ signalApiUrl: broker1.url(), onSignal: signalMock1 });
+    const { api: api2, router: router2 } = await createSignalClientAndMessageRouter({ signalApiUrl: broker1.url() });
 
     await api1.join(topic, peer1);
     await api2.join(topic, peer2);
 
-    const msg: Message = {
+    const msg: SignalMessage = {
       id: peer2,
       remoteId: peer1,
       sessionId: PublicKey.random(),
       topic,
-      data: { signal: { json: '{"asd": "asd"}' } }
+      data: { signal: { json: JSON.stringify({ 'asd': 'asd' }) } }
     };
     await router2.signal(msg);
 
@@ -98,14 +93,14 @@ describe('MessageRouter', () => {
   test('offer/answer', async () => {
     const { api: api1, router: router1 } = await createSignalClientAndMessageRouter(
       {
-        signalApiUrl: signalApiUrl1,
+        signalApiUrl: broker1.url(),
         onSignal: (async () => { }) as any,
         onOffer:
           async () => ({ accept: true })
       });
     const { api: api2 } = await createSignalClientAndMessageRouter(
       {
-        signalApiUrl: signalApiUrl1,
+        signalApiUrl: broker1.url(),
         onSignal: (async () => { }) as any,
         onOffer:
           async () => ({ accept: true })
@@ -125,26 +120,26 @@ describe('MessageRouter', () => {
   }).timeout(5_000);
 
   test('signaling between 3 clients', async () => {
-    const signalMock1 = mockFn<(msg: Message) => Promise<void>>().resolvesTo();
+    const signalMock1 = mockFn<(msg: SignalMessage) => Promise<void>>().resolvesTo();
     const { api: api1, router: router1 } = await createSignalClientAndMessageRouter(
       {
-        signalApiUrl: signalApiUrl1,
+        signalApiUrl: broker1.url(),
         onSignal: signalMock1,
         onOffer:
           async () => ({ accept: true })
       });
-    const signalMock2 = mockFn<(msg: Message) => Promise<void>>().resolvesTo();
+    const signalMock2 = mockFn<(msg: SignalMessage) => Promise<void>>().resolvesTo();
     const { api: api2, router: router2 } = await createSignalClientAndMessageRouter(
       {
-        signalApiUrl: signalApiUrl1,
+        signalApiUrl: broker1.url(),
         onSignal: signalMock2,
         onOffer:
           async () => ({ accept: true })
       });
-    const signalMock3 = mockFn<(msg: Message) => Promise<void>>().resolvesTo();
+    const signalMock3 = mockFn<(msg: SignalMessage) => Promise<void>>().resolvesTo();
     const { api: api3, router: router3 } = await createSignalClientAndMessageRouter(
       {
-        signalApiUrl: signalApiUrl1,
+        signalApiUrl: broker1.url(),
         onSignal: signalMock3,
         onOffer:
           async () => ({ accept: true })
@@ -156,7 +151,7 @@ describe('MessageRouter', () => {
     await api3.join(topic, peer3);
 
     // sending signal from peer1 to peer3.
-    const msg1to3: Message = {
+    const msg1to3: SignalMessage = {
       id: peer1,
       remoteId: peer3,
       sessionId: PublicKey.random(),
@@ -169,7 +164,7 @@ describe('MessageRouter', () => {
     }, 4_000);
 
     // sending signal from peer2 to peer3.
-    const msg2to3: Message = {
+    const msg2to3: SignalMessage = {
       id: peer2,
       remoteId: peer3,
       sessionId: PublicKey.random(),
@@ -182,7 +177,7 @@ describe('MessageRouter', () => {
     }, 4_000);
 
     // sending signal from peer3 to peer1.
-    const msg3to1: Message = {
+    const msg3to1: SignalMessage = {
       id: peer3,
       remoteId: peer1,
       sessionId: PublicKey.random(),
@@ -198,14 +193,14 @@ describe('MessageRouter', () => {
   test('two offers', async () => {
     const { api: api1, router: router1 } = await createSignalClientAndMessageRouter(
       {
-        signalApiUrl: signalApiUrl1,
+        signalApiUrl: broker1.url(),
         onSignal: (async () => { }) as any,
         onOffer:
           async () => ({ accept: true })
       });
     const { api: api2, router: router2 } = await createSignalClientAndMessageRouter(
       {
-        signalApiUrl: signalApiUrl1,
+        signalApiUrl: broker1.url(),
         onSignal: (async () => { }) as any,
         onOffer:
           async () => ({ accept: true })
@@ -242,9 +237,9 @@ describe('MessageRouter', () => {
       // Imitates signal network disruptions (e. g. message doubling, ).
       messageDisruption = msg => [msg]
     }: {
-      onSignal1?: (msg: Message) => Promise<void>;
-      onSignal2?: (msg: Message) => Promise<void>;
-      messageDisruption?: (msg: Message) => Message[];
+      onSignal1?: (msg: SignalMessage) => Promise<void>;
+      onSignal2?: (msg: SignalMessage) => Promise<void>;
+      messageDisruption?: (msg: SignalMessage) => SignalMessage[];
     }): {mr1: MessageRouter; mr2: MessageRouter} => {
 
       const mr1: MessageRouter = new MessageRouter({
@@ -268,7 +263,7 @@ describe('MessageRouter', () => {
       // Simulate unreliable connection.
       // Only each 3rd message is sent.
       let i = 0;
-      const unreliableConnection = (msg: Message): Message[] => {
+      const unreliableConnection = (msg: SignalMessage): SignalMessage[] => {
         i++;
         if (i % 3 !== 0) {
           return [msg];
@@ -276,8 +271,8 @@ describe('MessageRouter', () => {
         return [];
       };
 
-      const received: Message[] = [];
-      const signalMock1 = async (msg: Message) => {
+      const received: SignalMessage[] = [];
+      const signalMock1 = async (msg: SignalMessage) => {
         received.push(msg);
       };
 
@@ -294,7 +289,7 @@ describe('MessageRouter', () => {
           remoteId: PublicKey.random(),
           sessionId: PublicKey.random(),
           topic: PublicKey.random(),
-          data: { signal: { json: 'asd' } }
+          data: { signal: { json: JSON.stringify({ 'asd': 'asd' }) } }
         });
       });
       // expect to receive 3 messages.
@@ -305,10 +300,10 @@ describe('MessageRouter', () => {
 
     test('ignoring doubled messages', async () => {
       // Message got doubled going through signal network.
-      const doublingMessage = (msg: Message) => [msg, msg];
+      const doublingMessage = (msg: SignalMessage) => [msg, msg];
 
-      const received: Message[] = [];
-      const signalMock1 = async (msg: Message) => {
+      const received: SignalMessage[] = [];
+      const signalMock1 = async (msg: SignalMessage) => {
         received.push(msg);
       };
 

package/src/signal/message-router.ts

@@ -8,7 +8,7 @@ import debug from 'debug';
 import { PublicKey } from '@dxos/protocols';
 import { ComplexMap, ComplexSet, exponentialBackoffInterval, SubscriptionGroup } from '@dxos/util';
 
-import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
+import { Answer, SignalMessage } from '../proto/gen/dxos/mesh/signalMessage';
 import { SignalMessaging } from './signal-manager';
 
 interface OfferRecord {
@@ -17,9 +17,9 @@ interface OfferRecord {
 }
 
 interface MessageRouterOptions {
-  onSignal?: (message: Message) => Promise<void>;
-  sendMessage?: (message: Message) => Promise<void>;
-  onOffer?: (message: Message) => Promise<Answer>;
+  sendMessage?: (message: SignalMessage) => Promise<void>;
+  onOffer?: (message: SignalMessage) => Promise<Answer>;
+  onSignal?: (message: SignalMessage) => Promise<void>;
   retryDelay?: number;
   timeout?: number;
 }
@@ -31,9 +31,9 @@ const log = debug('dxos:network-manager:message-router');
 // TODO(mykola): https://github.com/dxos/protocols/issues/1316
 export class MessageRouter implements SignalMessaging {
   private readonly _offerRecords: ComplexMap<PublicKey, OfferRecord> = new ComplexMap(key => key.toHex());
-  private readonly _onSignal: (message: Message) => Promise<void>;
-  private readonly _sendMessage: (message: Message) => Promise<void>;
-  private readonly _onOffer: (message: Message) => Promise<Answer>;
+  private readonly _onSignal: (message: SignalMessage) => Promise<void>;
+  private readonly _sendMessage: (message: SignalMessage) => Promise<void>;
+  private readonly _onOffer: (message: SignalMessage) => Promise<Answer>;
 
   private readonly _onAckCallbacks = new ComplexMap<PublicKey, () => void>(key => key.toHex());
   private readonly _receivedMessages = new ComplexSet<PublicKey>(key => key.toHex());
@@ -59,7 +59,7 @@ export class MessageRouter implements SignalMessaging {
     this._timeout = timeout;
   }
 
-  async receiveMessage (message: Message): Promise<void> {
+  async receiveMessage (message: SignalMessage): Promise<void> {
     log(`receive message: ${JSON.stringify(message)}`);
     if (!message.data?.ack) {
       if (this._receivedMessages.has(message.messageId!)) {
@@ -81,12 +81,12 @@ export class MessageRouter implements SignalMessaging {
     }
   }
 
-  async signal (message: Message): Promise<void> {
+  async signal (message: SignalMessage): Promise<void> {
     assert(message.data?.signal);
     await this._sendReliableMessage(message);
   }
 
-  async offer (message: Message): Promise<Answer> {
+  async offer (message: SignalMessage): Promise<Answer> {
     message.messageId = PublicKey.random();
     const promise = new Promise<Answer>((resolve, reject) => {
       this._offerRecords.set(message.messageId!, { resolve, reject });
@@ -95,7 +95,7 @@ export class MessageRouter implements SignalMessaging {
     return promise;
   }
 
-  private async _sendReliableMessage (message: Message): Promise<PublicKey> {
+  private async _sendReliableMessage (message: SignalMessage): Promise<PublicKey> {
     // Setting unique messageId if it not specified yet.
     message.messageId = message.messageId ?? PublicKey.random();
     log(`sent message: ${JSON.stringify(message)}`);
@@ -103,7 +103,11 @@ export class MessageRouter implements SignalMessaging {
     // Setting retry interval if signal was not acknowledged.
     const cancelRetry = exponentialBackoffInterval(async () => {
       log(`retrying message: ${JSON.stringify(message)}`);
-      await this._sendMessage(message);
+      try {
+        await this._sendMessage(message);
+      } catch (error) {
+        log(`ERROR failed to send message: ${error}`);
+      }
     }, this._retryDelay);
 
     const timeout = setTimeout(() => {
@@ -125,7 +129,7 @@ export class MessageRouter implements SignalMessaging {
     return message.messageId;
   }
 
-  private async _resolveAnswers (message: Message): Promise<void> {
+  private async _resolveAnswers (message: SignalMessage): Promise<void> {
     assert(message.data?.answer?.offerMessageId, 'No offerMessageId');
     const offerRecord = this._offerRecords.get(message.data.answer.offerMessageId);
     if (offerRecord) {
@@ -136,10 +140,10 @@ export class MessageRouter implements SignalMessaging {
     }
   }
 
-  private async _handleOffer (message: Message): Promise<void> {
+  private async _handleOffer (message: SignalMessage): Promise<void> {
     const answer = await this._onOffer(message);
     answer.offerMessageId = message.messageId;
-    const answerMessage: Message = {
+    const answerMessage: SignalMessage = {
       id: message.remoteId,
       remoteId: message.id,
       topic: message.topic,
@@ -149,17 +153,17 @@ export class MessageRouter implements SignalMessaging {
     await this._sendReliableMessage(answerMessage);
   }
 
-  private async _handleSignal (message: Message): Promise<void> {
+  private async _handleSignal (message: SignalMessage): Promise<void> {
     assert(message.messageId);
     await this._onSignal(message);
   }
 
-  private async _handleAcknowledgement (message: Message): Promise<void> {
+  private async _handleAcknowledgement (message: SignalMessage): Promise<void> {
     assert(message.data?.ack?.messageId);
     this._onAckCallbacks.get(message.data.ack.messageId)?.();
   }
 
-  private async _sendAcknowledgement (message: Message): Promise<void> {
+  private async _sendAcknowledgement (message: SignalMessage): Promise<void> {
     assert(message.messageId);
     const ackMessage = {
       id: message.remoteId,

package/src/signal/signal-client.test.ts

@@ -6,166 +6,144 @@ import { expect, mockFn } from 'earljs';
 import { it as test, describe } from 'mocha';
 import waitForExpect from 'wait-for-expect';
 
-import { Awaited, sleep } from '@dxos/async';
+import { sleep } from '@dxos/async';
 import { PublicKey } from '@dxos/protocols';
-import { createTestBroker } from '@dxos/signal';
-import { randomInt } from '@dxos/util';
+import { createTestBroker, TestBroker } from '@dxos/signal';
+import { afterTest } from '@dxos/testutils';
 
-import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
+import { SignalMessage } from '../proto/gen/dxos/mesh/signalMessage';
 import { SignalClient } from './signal-client';
 
-describe('SignalApi', () => {
-  let topic: PublicKey;
-  let peer1: PublicKey;
-  let peer2: PublicKey;
-  let api1: SignalClient;
-  let api2: SignalClient;
+describe('SignalClient', () => {
+  let broker1: TestBroker;
 
-  let broker1: Awaited<ReturnType<typeof createTestBroker>>;
-  const signalApiPort1 = randomInt(10000, 50000);
-  const signalApiUrl1 = 'http://0.0.0.0:' + signalApiPort1;
-
-  // code let broker2: ReturnType<typeof createBroker>;
-  const signalApiPort2 = randomInt(10000, 50000);
-  const signalApiUrl2 = 'http://0.0.0.0:' + signalApiPort2;
+  let broker2: TestBroker;
 
   before(async () => {
-    broker1 = await createTestBroker(signalApiPort1);
-    // broker2 = await createTestBroker(signalApiPort2);
-  });
-
-  beforeEach(() => {
-    topic = PublicKey.random();
-    peer1 = PublicKey.random();
-    peer2 = PublicKey.random();
+    broker1 = await createTestBroker();
+    // broker2 = await await createTestBroker(signalApiPort2);
   });
 
-  after(async function () {
-    this.timeout(0);
-    await api1.close();
-    await broker1.stop();
+  after(() => {
+    broker1.stop();
     // code await broker2.stop();
   });
 
   test('message between 2 clients', async () => {
-    const signalMock1 = mockFn<(msg: Message) => Promise<void>>()
+    const topic = PublicKey.random();
+    const peer1 = PublicKey.random();
+    const peer2 = PublicKey.random();
+    const signalMock1 = mockFn<(msg: SignalMessage) => Promise<void>>()
       .resolvesTo();
-    api1 = new SignalClient(signalApiUrl1, (async () => {}) as any, signalMock1);
-    api2 = new SignalClient(signalApiUrl1, (async () => {}) as any, (async () => {}) as any);
+    const api1 = new SignalClient(broker1.url(), signalMock1);
+    afterTest(() => api1.close());
+    const api2 = new SignalClient(broker1.url(), (async () => {}) as any);
+    afterTest(() => api2.close());
 
     await api1.join(topic, peer1);
     await api2.join(topic, peer2);
 
-    const msg: Message = {
+    const msg: SignalMessage = {
       id: peer2,
       remoteId: peer1,
       sessionId: PublicKey.random(),
       topic,
-      data: { signal: { json: "foo: 'bar'" } },
-      messageId: undefined
+      data: { signal: { json: JSON.stringify({ 'asd': 'asd' }) } }
     };
     await api2.signal(msg);
-
     await waitForExpect(() => {
       expect(signalMock1).toHaveBeenCalledWith([msg]);
     }, 4_000);
-  }).timeout(5_000);
+  }).timeout(500);
 
   test('join', async () => {
-    api1 = new SignalClient(signalApiUrl1, (async () => {}) as any, async () => {});
+    const topic = PublicKey.random();
+    const peer1 = PublicKey.random();
+    const peer2 = PublicKey.random();
+    const api1 = new SignalClient(broker1.url(), async () => {});
+    afterTest(() => api1.close());
+    const api2 = new SignalClient(broker1.url(), async () => {});
+    afterTest(() => api2.close());
 
-    const join = await api1.join(topic, peer1);
-    expect(join).toEqual([peer1]);
-
-    const join2 = await api1.join(topic, peer2);
-    expect(join2).toEqual([peer1, peer2]);
-  }).timeout(1_000);
-
-  test('offer', async () => {
-    const offerMock = mockFn<(msg: Message) => Promise<Answer>>()
-      .resolvesTo({ accept: true });
-    api1 = new SignalClient(signalApiUrl1, offerMock, async () => {});
+    const promise1 = api1.swarmEvent.waitFor(([, swarmEvent]) => !!swarmEvent.peerAvailable && peer2.equals(swarmEvent.peerAvailable.peer));
+    const promise2 = api2.swarmEvent.waitFor(([, swarmEvent]) => !!swarmEvent.peerAvailable && peer1.equals(swarmEvent.peerAvailable.peer));
 
     await api1.join(topic, peer1);
+    await api2.join(topic, peer2);
 
-    const offer: Message = {
-      data: { offer: {} },
-      id: peer2,
-      remoteId: peer1,
-      sessionId: PublicKey.random(),
-      topic
-    };
-    const offerResult = await api1.offer(offer);
-    expect(offerResult).toEqual({ accept: true });
-    expect(offerMock).toHaveBeenCalledWith([offer]);
-  }).timeout(5_000);
+    await promise1;
+    await promise2;
+  }).timeout(500);
 
-  test('signal', async () => {
-    const signalMock = mockFn<(msg: Message) => Promise<void>>()
+  test('signal to self', async () => {
+    const topic = PublicKey.random();
+    const peer1 = PublicKey.random();
+    const peer2 = PublicKey.random();
+    const signalMock = mockFn<(msg: SignalMessage) => Promise<void>>()
       .resolvesTo();
-    api1 = new SignalClient(signalApiUrl1, (async () => {}) as any, signalMock);
+    const api1 = new SignalClient(broker1.url(), signalMock);
+    afterTest(() => api1.close());
 
     await api1.join(topic, peer1);
 
-    const msg: Message = {
+    const msg: SignalMessage = {
       id: peer2,
       remoteId: peer1,
       sessionId: PublicKey.random(),
       topic,
-      data: { signal: { json: 'bar' } },
-      messageId: undefined
+      data: { signal: { json: JSON.stringify({ 'asd': 'asd' }) } }
     };
     await api1.signal(msg);
 
     await waitForExpect(() => {
       expect(signalMock).toHaveBeenCalledWith([msg]);
     }, 4_000);
-  }).timeout(5_000);
+  }).timeout(500);
 
   test.skip('join across multiple signal servers', async () => {
+    const topic = PublicKey.random();
+    const peer1 = PublicKey.random();
+    const peer2 = PublicKey.random();
     // This feature is not implemented yet.
-    api1 = new SignalClient(signalApiUrl1, (async () => {}) as any, async () => {});
-    api2 = new SignalClient(signalApiUrl2, (async () => {}) as any, async () => {});
+    const api1 = new SignalClient(broker1.url(), async () => {});
+    afterTest(() => api1.close());
+    const api2 = new SignalClient(broker2.url(), async () => {});
+    afterTest(() => api2.close());
 
     await api1.join(topic, peer1);
     await api2.join(topic, peer2);
 
-    await waitForExpect(async () => {
-      const peers = await api2.lookup(topic);
-      expect(peers.length).toEqual(2);
-    }, 4_000);
+    // await waitForExpect(async () => {
+    //   const peers = await api2.lookup(topic);
+    //   expect(peers.length).toEqual(2);
+    // }, 4_000);
 
-    await waitForExpect(async () => {
-      const peers = await api1.lookup(topic);
-      expect(peers.length).toEqual(2);
-    }, 4_000);
+    // await waitForExpect(async () => {
+    //   const peers = await api1.lookup(topic);
+    //   expect(peers.length).toEqual(2);
+    // }, 4_000);
   }).timeout(5_000);
 
   // Skip because communication between signal servers is not yet implemented.
   test.skip('newly joined peer can receive signals from other signal servers', async () => {
-    const offerMock = mockFn<(msg: Message) => Promise<Answer>>()
-      .resolvesTo({ accept: true });
-    const signalMock = mockFn<(msg: Message) => Promise<void>>()
+    const topic = PublicKey.random();
+    const peer1 = PublicKey.random();
+    const peer2 = PublicKey.random();
+    const signalMock = mockFn<(msg: SignalMessage) => Promise<void>>()
       .resolvesTo();
 
-    api1 = new SignalClient(signalApiUrl1, offerMock, async () => {});
-    api2 = new SignalClient(signalApiUrl2, (async () => {}) as any, signalMock);
+    const api1 = new SignalClient(broker1.url(), async () => {});
+    afterTest(() => api1.close());
+    const api2 = new SignalClient(broker2.url(), signalMock);
+    afterTest(() => api2.close());
 
     await api1.join(topic, peer1);
     await sleep(3000);
     await api2.join(topic, peer2);
 
     const sessionId = PublicKey.random();
-    const answer = await api2.offer({
-      remoteId: peer1,
-      id: peer2,
-      topic,
-      sessionId,
-      data: { offer: {} }
-    });
-    expect(answer).toEqual({ accept: true });
 
-    const msg: Message = {
+    const msg: SignalMessage = {
       id: peer2,
       remoteId: peer1,
       sessionId,
@@ -178,4 +156,4 @@ describe('SignalApi', () => {
       expect(signalMock).toHaveBeenCalledWith([msg]);
     }, 4_000);
   }).timeout(5_000);
-}).timeout(10_000);
+});