@dxos/network-manager 0.6.13 → 0.6.14-main.2b6a0f3

package/src/transport/webrtc/rtc-transport.test.ts

@@ -0,0 +1,198 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import { onTestFinished, describe, expect, test } from 'vitest';
+
+import { sleep, TestStream } from '@dxos/async';
+import { PublicKey } from '@dxos/keys';
+
+import { getRtcConnectionFactory } from './rtc-connection-factory';
+import { RtcPeerConnection } from './rtc-peer-connection';
+import { type RtcTransportChannel } from './rtc-transport-channel';
+import { chooseInitiatorPeer } from './utils';
+import { type TransportOptions } from '../transport';
+
+const connectionFactory = getRtcConnectionFactory();
+
+describe('RtcTransport', () => {
+  test('channel open and close', async () => {
+    const peer = await createConnection();
+    const channel = createChannel(peer);
+
+    await channel.open();
+    const wait = channel.closed.waitForCount(1);
+    await channel.close();
+    await wait;
+
+    expect(peer.connection.transportChannelCount).to.eq(0);
+    await expect.poll(() => channel.isRtcChannelCreationInProgress).toBeFalsy();
+  });
+
+  test('establish connection and send data through with protocol', async () => {
+    const { initiator, another } = await createConnectedPeers();
+    const initiatorChannel = createChannel(initiator);
+    const anotherChannel = createChannel(another);
+
+    await initiatorChannel.open();
+    await anotherChannel.open();
+
+    await TestStream.assertConnectivity(initiator.stream, another.stream, { timeout: 1500 });
+  });
+
+  test('initiator opens a channel before another peer', async () => {
+    const { initiator, another } = await createConnectedPeers();
+    const initiatorChannel = createChannel(initiator);
+    const anotherChannel = createChannel(another);
+
+    await initiatorChannel.open();
+    await sleep(50);
+    await anotherChannel.open();
+
+    await TestStream.assertConnectivity(initiator.stream, another.stream, { timeout: 1500 });
+  });
+
+  test('initiator opens a channel after another peer', async () => {
+    const { initiator, another } = await createConnectedPeers();
+    const initiatorChannel = createChannel(initiator);
+    const anotherChannel = createChannel(another);
+
+    await anotherChannel.open();
+    await sleep(50);
+    await initiatorChannel.open();
+
+    await TestStream.assertConnectivity(initiator.stream, another.stream, { timeout: 1500 });
+  });
+
+  test('signal delivery idempotency', async () => {
+    const { initiator, another } = await createConnectedPeers({ duplicateSignals: true });
+    const initiatorChannel = createChannel(initiator);
+    const anotherChannel = createChannel(another);
+
+    await anotherChannel.open();
+    await sleep(50);
+    await initiatorChannel.open();
+
+    await TestStream.assertConnectivity(initiator.stream, another.stream, { timeout: 1500 });
+  });
+
+  test('initiator closes before connectivity is established', async () => {
+    const { initiator, another } = await createConnectedPeers();
+    const initiatorChannel = createChannel(initiator);
+    const anotherChannel = createChannel(another);
+
+    await initiatorChannel.open();
+    await sleep(20);
+    await anotherChannel.open();
+    await initiatorChannel.close();
+
+    initiatorChannel.errors.assertNoUnhandledErrors();
+    anotherChannel.errors.assertNoUnhandledErrors();
+  });
+
+  test('initiator opens a channel after another peer closed it', async () => {
+    const { initiator, another } = await createConnectedPeers({ duplicateSignals: true });
+    const initiatorChannel = createChannel(initiator);
+    const anotherChannel = createChannel(another);
+
+    await anotherChannel.open();
+    await sleep(20);
+    await anotherChannel.close();
+    await initiatorChannel.open();
+    await initiatorChannel.close();
+
+    await expect.poll(() => anotherChannel.isRtcChannelCreationInProgress).toBeFalsy();
+    initiatorChannel.errors.assertNoUnhandledErrors();
+    anotherChannel.errors.assertNoUnhandledErrors();
+  });
+
+  const createConnectedPeers = async (options?: { duplicateSignals?: boolean }) => {
+    const peer1Signal = createSignalSender(options);
+    const peer2Signal = createSignalSender(options);
+
+    const peer1 = await createConnection({ sendSignal: peer1Signal.sendSignal }, peer2Signal.onChannelCreated);
+    const peer2 = await createConnection(
+      {
+        ownPeerKey: peer1.options.remotePeerKey,
+        remotePeerKey: peer1.options.ownPeerKey,
+        topic: peer1.options.topic,
+        sendSignal: peer2Signal.sendSignal,
+      },
+      peer1Signal.onChannelCreated,
+    );
+
+    return chooseInitiator(peer1, peer2);
+  };
+
+  const createSignalSender = (options?: { duplicateSignals?: boolean }) => {
+    const deliverSignal = (channel: RtcTransportChannel, signal: any) => {
+      void channel.onSignal(signal);
+      if (options?.duplicateSignals) {
+        void channel.onSignal(signal);
+      }
+    };
+    let remoteChannel: RtcTransportChannel | undefined;
+    const signalBuffer: any[] = [];
+    const sendSignal = async (signal: any) => {
+      await sleep(10);
+      if (remoteChannel) {
+        deliverSignal(remoteChannel, signal);
+      } else {
+        signalBuffer.push(signal);
+      }
+    };
+    const onChannelCreated = (channel: RtcTransportChannel): void => {
+      remoteChannel = channel;
+      for (const signal of signalBuffer) {
+        deliverSignal(channel, signal);
+      }
+    };
+    return { sendSignal, onChannelCreated };
+  };
+
+  const createConnection = async (
+    optionOverrides?: Partial<TransportOptions>,
+    onChannelCreated: (channel: RtcTransportChannel) => void = () => {},
+  ): Promise<TestSetup> => {
+    const stream = new TestStream();
+    const options: TransportOptions = {
+      initiator: false,
+      stream,
+      sendSignal: async () => {},
+      remotePeerKey: PublicKey.random().toHex(),
+      ownPeerKey: PublicKey.random().toHex(),
+      topic: PublicKey.random().toHex(),
+      ...optionOverrides,
+    };
+    const connection = new RtcPeerConnection(connectionFactory, options);
+    return { options, connection, stream, onChannelOpen: onChannelCreated };
+  };
+
+  const chooseInitiator = (peer1: TestSetup, peer2: TestSetup) => {
+    const [initiator, another] =
+      chooseInitiatorPeer(peer1.options.ownPeerKey, peer2.options.ownPeerKey) === peer1.options.ownPeerKey
+        ? [peer1, peer2]
+        : [peer2, peer1];
+    return { initiator, another };
+  };
+
+  const createChannel = (args: TestSetup) => {
+    const channel = args.connection.createTransportChannel(args.options);
+    const originalOpen = channel.open.bind(channel);
+    (channel as any).open = async () => {
+      await originalOpen();
+      args.onChannelOpen(channel);
+    };
+    onTestFinished(async () => {
+      await channel.close();
+    });
+    return channel;
+  };
+});
+
+type TestSetup = {
+  stream: TestStream;
+  connection: RtcPeerConnection;
+  options: TransportOptions;
+  onChannelOpen: (channel: RtcTransportChannel) => void;
+};

package/src/transport/webrtc/test-utils.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { expect } from 'vitest';
+
+import { sleep } from '@dxos/async';
+
+import { type Transport } from '../transport';
+
+export const handleChannelErrors = (channel: Transport) => {
+  let handled = false;
+  channel.errors.handle(() => (handled = true));
+  return {
+    expectErrorRaised: async () => {
+      if (!handled) {
+        await sleep(5);
+      }
+      expect(handled).toBeTruthy();
+    },
+  };
+};

package/src/transport/webrtc/utils.ts

@@ -0,0 +1,36 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export const chooseInitiatorPeer = (peer1Key: string, peer2Key: string) => (peer1Key < peer2Key ? peer1Key : peer2Key);
+
+export const areSdpEqual = (sdp1: string, sdp2: string) => {
+  const sdp1Lines = deduplicatedSdpLines(sdp1);
+  const sdp2Lines = deduplicatedSdpLines(sdp2);
+  if (sdp1Lines.length !== sdp2Lines.length) {
+    return false;
+  }
+  return sdp1Lines.every((line, idx) => line === sdp2Lines[idx]);
+};
+
+/**
+ * For some reason libdatachannel duplicates some attributes after an sdp is set.
+ * So the following test might fail:
+ * conn.setRemoteDescription(sdp);
+ * expect(conn.remoteDescription.sdp).toEqual(sdp);
+ */
+const deduplicatedSdpLines = (sdp: string) => {
+  const deduplicatedLines: string[] = [];
+  const seenLines: string[] = [];
+  for (const line of sdp.split('\r\n')) {
+    if (line.startsWith('m')) {
+      seenLines.length = 0;
+    }
+    if (seenLines.includes(line)) {
+      continue;
+    }
+    seenLines.push(line);
+    deduplicatedLines.push(line);
+  }
+  return deduplicatedLines;
+};

package/src/typings.d.ts

@@ -3,5 +3,11 @@
 //
 
 declare module '@koush/wrtc';
-declare module 'nanomessage-rpc';
-declare module 'xor-distance';
+
+declare module '#node-datachannel' {
+  export * from 'node-datachannel';
+}
+
+declare module '#node-datachannel/polyfill' {
+  export * from 'node-datachannel/polyfill';
+}