@dxos/messaging 0.5.8 → 0.5.9-main.079a532

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

@@ -2,14 +2,16 @@
 // Copyright 2020 DXOS.org
 //
 
-import { expect, mockFn } from 'earljs';
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+import { expect } from 'earljs';
 
-import { sleep, Event, Trigger, asyncTimeout } from '@dxos/async';
-import { type Any, type TaggedType } from '@dxos/codec-protobuf';
+import { Trigger, asyncTimeout, waitForCondition } from '@dxos/async';
+import { type TaggedType } from '@dxos/codec-protobuf';
 import { PublicKey } from '@dxos/keys';
 import { type TYPES } from '@dxos/protocols';
 import { runTestSignalServer, type SignalServerRunner } from '@dxos/signal';
 import { afterAll, beforeAll, describe, test, afterTest } from '@dxos/test';
+import { ComplexSet, range } from '@dxos/util';
 
 import { SignalClient } from './signal-client';
 
@@ -22,307 +24,157 @@ const PAYLOAD: TaggedType<TYPES, 'google.protobuf.Any'> = {
 describe('SignalClient', () => {
   let broker1: SignalServerRunner;
 
-  let broker2: SignalServerRunner;
-
   beforeAll(async () => {
     broker1 = await runTestSignalServer();
-    // broker2 = await await createTestBroker(signalApiPort2);
   });
 
-  afterAll(() => {
-    void broker1.stop();
-    // code await broker2.stop();
+  afterAll(async () => {
+    await broker1.stop();
   });
 
-  const waitForSubscription = async (signal: SignalClient, peerId: PublicKey) => {
-    await asyncTimeout(
-      signal._reconciled.waitForCondition(() => signal._messageStreams.has(peerId)),
-      500,
-    );
-  };
-
   test('message between 2 clients', async () => {
-    const peer1 = PublicKey.random();
-    const peer2 = PublicKey.random();
-    const received = new Trigger<any>();
-    const api1 = new SignalClient(
-      broker1.url(),
-      async (msg) => {
-        received.wake(msg);
-      },
-      async () => {},
-    );
-    void api1.open();
-    afterTest(() => api1.close());
-    const api2 = new SignalClient(broker1.url(), (async () => {}) as any, async () => {});
-    void api2.open();
-    afterTest(() => api2.close());
-
-    await api1.subscribeMessages(peer1);
-    await waitForSubscription(api1, peer1);
-
-    const message = {
-      author: peer2,
-      recipient: peer1,
-      payload: PAYLOAD,
-    };
-    await api2.sendMessage(message);
-    expect(await received.wait()).toEqual(message);
-  })
-    .timeout(500)
-    .retries(2);
+    const [peer1, peer2] = setupPeers({ peerCount: 2 });
+
+    await peer1.client.subscribeMessages(peer1.id);
+    await waitForSubscription(peer1.client, peer1.id);
+
+    const message = createMessage(peer2, peer1);
+    await peer2.client.sendMessage(message);
+    expect(await peer1.waitForNextMessage()).toEqual(message);
+  }).timeout(500);
 
   test('join', async () => {
     const topic = PublicKey.random();
-    const peer1 = PublicKey.random();
-    const peer2 = PublicKey.random();
-
-    const trigger1 = new Trigger();
-    const api1 = new SignalClient(
-      broker1.url(),
-      async () => {},
-      async ({ swarmEvent }) => {
-        if (!!swarmEvent.peerAvailable && peer2.equals(swarmEvent.peerAvailable.peer)) {
-          trigger1.wake();
-        }
-      },
-    );
-    void api1.open();
-    afterTest(() => api1.close());
-
-    const trigger2 = new Trigger();
-    const api2 = new SignalClient(
-      broker1.url(),
-      async () => {},
-      async ({ swarmEvent }) => {
-        if (!!swarmEvent.peerAvailable && peer1.equals(swarmEvent.peerAvailable.peer)) {
-          trigger2.wake();
-        }
-      },
-    );
-    void api2.open();
-    afterTest(() => api2.close());
-    await api1.join({ topic, peerId: peer1 });
-    await api2.join({ topic, peerId: peer2 });
+    const [peer1, peer2] = setupPeers({ peerCount: 2 });
 
-    await trigger1.wait();
-    await trigger2.wait();
-  })
-    .timeout(500)
-    .retries(2);
+    await peer1.client.join({ topic, peerId: peer1.id });
+    await peer2.client.join({ topic, peerId: peer2.id });
 
-  test('signal to self', async () => {
-    const peer1 = PublicKey.random();
-    const peer2 = PublicKey.random();
-    const received = new Trigger<any>();
-    const api1 = new SignalClient(
-      broker1.url(),
-      async (msg) => {
-        received.wake(msg);
-      },
-      async () => {},
-    );
-    void api1.open();
-    afterTest(() => api1.close());
+    await peer1.waitForPeer(peer2.id);
+    await peer2.waitForPeer(peer1.id);
+  }).timeout(500);
 
-    await api1.subscribeMessages(peer1);
-    await waitForSubscription(api1, peer1);
+  test('signal to self', async () => {
+    const [peer1, peer2] = setupPeers({ peerCount: 2 });
 
-    const message = {
-      author: peer2,
-      recipient: peer1,
-      payload: PAYLOAD,
-    };
-    await api1.sendMessage(message);
+    await peer1.client.subscribeMessages(peer1.id);
+    await waitForSubscription(peer1.client, peer1.id);
 
-    expect(await received.wait()).toEqual(message);
+    const message = createMessage(peer2, peer1);
+    await peer1.client.sendMessage(message);
+    expect(await peer1.waitForNextMessage()).toEqual(message);
   }).timeout(500);
 
   test('unsubscribe from messages', async () => {
-    const peer1 = PublicKey.random();
-    const peer2 = PublicKey.random();
-
-    const received = new Event<any>();
-    const client1 = new SignalClient(
-      broker1.url(),
-      async (msg) => {
-        received.emit(msg);
-      },
-      async () => {},
-    );
-    void client1.open();
-    afterTest(() => client1.close());
+    const [peer1, peer2] = setupPeers({ peerCount: 2 });
 
-    const client2 = new SignalClient(broker1.url(), (async () => {}) as any, async () => {});
-    void client2.open();
-    afterTest(() => client2.close());
+    await peer1.client.subscribeMessages(peer1.id);
+    await peer2.client.subscribeMessages(peer2.id);
+    await waitForSubscription(peer1.client, peer1.id);
 
-    await client1.subscribeMessages(peer1);
-    await client2.subscribeMessages(peer2);
-    await waitForSubscription(client2, peer2);
-
-    const message = {
-      author: peer2,
-      recipient: peer1,
-      payload: PAYLOAD,
-    };
+    const message = createMessage(peer2, peer1);
 
     {
-      const promise = received.waitFor((msg) => {
-        expect(msg).toEqual(message);
-        return true;
-      });
-      await client2.sendMessage(message);
-      await promise;
+      await peer2.client.sendMessage(message);
+      expect(await peer1.waitForNextMessage()).toEqual(message);
     }
 
     // unsubscribing.
-    await client1.unsubscribeMessages(peer1);
+    await peer1.client.unsubscribeMessages(peer1.id);
 
     {
-      const promise = received.waitFor((msg) => {
-        expect(msg).toEqual(message);
-        return true;
-      });
-      await client2.sendMessage(message);
-      await expect(asyncTimeout(promise, 200)).toBeRejected();
+      await peer2.client.sendMessage(message);
+      await expect(peer1.waitForNextMessage({ timeout: 200 })).toBeRejected();
     }
-  })
-    .timeout(1_000)
-    .retries(2);
+  }).timeout(1_500);
 
   test('signal after re-entrance', async () => {
-    const peer1 = PublicKey.random();
-    const peer2 = PublicKey.random();
-
-    const received = new Event<any>();
-    const client1 = new SignalClient(
-      broker1.url(),
-      async (msg) => {
-        received.emit(msg);
-      },
-      async () => {},
-    );
-    void client1.open();
-    afterTest(() => client1.close());
+    const [peer1, peer2] = setupPeers({ peerCount: 2 });
 
-    const client2 = new SignalClient(broker1.url(), (async () => {}) as any, async () => {});
-    void client2.open();
-    afterTest(() => client2.close());
-
-    const message = {
-      author: peer2,
-      recipient: peer1,
-      payload: PAYLOAD,
-    };
+    const message = createMessage(peer2, peer1);
 
-    await client1.subscribeMessages(peer1);
-    await waitForSubscription(client1, peer1);
+    await peer1.client.subscribeMessages(peer1.id);
+    await waitForSubscription(peer1.client, peer1.id);
 
     {
-      const promise = received.waitFor((msg) => {
-        expect(msg).toEqual(message);
-        return true;
-      });
-      await client2.sendMessage(message);
-      await promise;
+      await peer2.client.sendMessage(message);
+      expect(await peer1.waitForNextMessage()).toEqual(message);
     }
 
     //
     // close and reopen first client
     //
 
-    await client1.close();
-    void client1.open();
-    await waitForSubscription(client1, peer1);
+    await peer1.client.close();
+    await peer1.client.open();
+    await waitForSubscription(peer1.client, peer1.id);
 
     {
-      const promise = received.waitFor((msg) => {
-        expect(msg).toEqual(message);
-        return true;
-      });
-      await client2.sendMessage(message);
-      await promise;
+      await peer2.client.sendMessage(message);
+      expect(await peer1.waitForNextMessage()).toEqual(message);
     }
-  })
-    .timeout(1_000)
-    .retries(2);
-
-  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.
-      const api1 = new SignalClient(
-        broker1.url(),
-        async () => {},
-        async () => {},
-      );
-      void api1.open();
-      afterTest(() => api1.close());
-      const api2 = new SignalClient(
-        broker2.url(),
-        async () => {},
-        async () => {},
-      );
-      void api2.open();
-      afterTest(() => api2.close());
-
-      await api1.join({ topic, peerId: peer1 });
-      await api2.join({ topic, peerId: peer2 });
-
-      // 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);
-    })
-    .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 topic = PublicKey.random();
-      const peer1 = PublicKey.random();
-      const peer2 = PublicKey.random();
-      const signalMock =
-        mockFn<
-          ({ author, recipient, payload }: { author: PublicKey; recipient: PublicKey; payload: Any }) => Promise<void>
-        >().resolvesTo();
-
-      const api1 = new SignalClient(
-        broker1.url(),
-        async () => {},
-        async () => {},
+  }).timeout(1_000);
+
+  const setupPeers = (options?: { broker?: SignalServerRunner; peerCount?: number }): TestPeer[] => {
+    return range(options?.peerCount ?? 1, () => {
+      const peers = new ComplexSet(PublicKey.hash);
+      let nextMessage: any | null = null;
+      const nextMessageTrigger = new Trigger();
+      const id = PublicKey.random();
+      const client = new SignalClient(
+        (options?.broker ?? broker1).url(),
+        async (msg) => {
+          nextMessage = msg;
+          nextMessageTrigger.wake();
+        },
+        async (event) => {
+          if (event.swarmEvent.peerAvailable) {
+            peers.add(PublicKey.from(event.swarmEvent.peerAvailable.peer));
+          } else if (event.swarmEvent.peerLeft) {
+            peers.delete(PublicKey.from(event.swarmEvent.peerLeft.peer));
+          }
+        },
       );
-      void api1.open();
-      afterTest(() => api1.close());
-      const api2 = new SignalClient(broker2.url(), signalMock, async () => {});
-      void api2.open();
-      afterTest(() => api2.close());
-
-      await api1.join({ topic, peerId: peer1 });
-      await sleep(3000);
-      await api2.join({ topic, peerId: peer2 });
-
-      const message = {
-        author: peer2,
-        recipient: peer1,
-        payload: {
-          type_url: 'something',
-          value: Buffer.from('0'),
+      void client.open();
+      afterTest(async () => {
+        await client.close();
+      });
+      return {
+        id,
+        client,
+        waitForNextMessage: async (options?: { timeout?: number }) => {
+          if (nextMessage == null) {
+            await nextMessageTrigger.wait(options);
+          }
+          const result = nextMessage!;
+          nextMessageTrigger.reset();
+          nextMessage = null;
+          return result;
         },
+        waitForPeer: (peerId: PublicKey) => waitForCondition({ condition: () => peers.has(peerId) }),
       };
-      await api1.sendMessage(message);
+    });
+  };
+
+  const createMessage = (from: TestPeer, to: TestPeer, payload: any = PAYLOAD) => {
+    return {
+      author: from.id,
+      recipient: to.id,
+      payload: PAYLOAD,
+    };
+  };
 
-      // await waitForExpect(() => {
-      // expect(signalMock).toHaveBeenCalledWith([message]);
-      // }, 4_000);
-    })
-    .timeout(5_000);
+  const waitForSubscription = async (signal: SignalClient, peerId: PublicKey) => {
+    await asyncTimeout(
+      signal.localState.reconciled.waitForCondition(() => signal.localState.messageStreams.has(peerId)),
+      500,
+    );
+  };
 });
+
+interface TestPeer {
+  id: PublicKey;
+  client: SignalClient;
+  waitForNextMessage: (options?: { timeout?: number }) => Promise<any>;
+  waitForPeer: (peerId: PublicKey) => Promise<boolean>;
+}