@livekit/rtc-node 0.13.32 → 0.13.34

package/src/tests/e2e.test.ts

@@ -1,10 +1,8 @@
 // SPDX-FileCopyrightText: 2026 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
-import { AccessToken } from 'livekit-server-sdk';
-import { randomUUID } from 'node:crypto';
 import { setTimeout as delay } from 'node:timers/promises';
-import { afterAll, describe, expect, it as itRaw } from 'vitest';
+import { afterAll, expect, it as itRaw } from 'vitest';
 import {
   AudioFrame,
   AudioSource,
@@ -12,7 +10,6 @@ import {
   ConnectionState,
   LocalAudioTrack,
   ParticipantKind,
-  Room,
   RoomEvent,
   RpcError,
   SimulateScenarioKind,
@@ -21,134 +18,19 @@ import {
   TrackSource,
   dispose,
 } from '../index.js';
+import {
+  concatUint8,
+  connectTestRooms,
+  describeE2E,
+  testTimeoutMs,
+  waitFor,
+  waitForRoomEvent,
+  withTimeout,
+} from './e2e_common.js';
 
 // use concurrent testing if available on the runner (currently not supported by bun's api)
 const it = typeof itRaw.concurrent === 'function' ? itRaw.concurrent : itRaw;
 
-const hasE2EEnv =
-  !!process.env.LIVEKIT_URL && !!process.env.LIVEKIT_API_KEY && !!process.env.LIVEKIT_API_SECRET;
-const describeE2E = hasE2EEnv ? describe : describe.skip;
-const testTimeoutMs = 10_000;
-
-type TestEnv = {
-  url: string;
-  apiKey: string;
-  apiSecret: string;
-};
-
-function normalizeLiveKitUrl(url: string): string {
-  if (url.startsWith('http://')) return `ws://${url.slice('http://'.length)}`;
-  if (url.startsWith('https://')) return `wss://${url.slice('https://'.length)}`;
-  return url;
-}
-
-function getTestEnv(): TestEnv {
-  if (!hasE2EEnv) {
-    throw new Error(
-      'Missing required env vars for e2e: LIVEKIT_URL, LIVEKIT_API_KEY, LIVEKIT_API_SECRET',
-    );
-  }
-  return {
-    url: normalizeLiveKitUrl(process.env.LIVEKIT_URL!),
-    apiKey: process.env.LIVEKIT_API_KEY!,
-    apiSecret: process.env.LIVEKIT_API_SECRET!,
-  };
-}
-
-async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T> {
-  return await Promise.race([
-    promise,
-    (async () => {
-      await delay(timeoutMs);
-      throw new Error(message);
-    })(),
-  ]);
-}
-
-async function waitFor(
-  condition: () => boolean,
-  opts: { timeoutMs: number; intervalMs?: number; debugName?: string },
-): Promise<void> {
-  const intervalMs = opts.intervalMs ?? 50;
-  const deadline = Date.now() + opts.timeoutMs;
-  while (Date.now() < deadline) {
-    if (condition()) return;
-    await delay(intervalMs);
-  }
-  throw new Error(`Timed out waiting for condition${opts.debugName ? ` (${opts.debugName})` : ''}`);
-}
-
-async function createJoinToken(params: {
-  env: TestEnv;
-  roomName: string;
-  identity: string;
-  name: string;
-}): Promise<string> {
-  const token = new AccessToken(params.env.apiKey, params.env.apiSecret, {
-    identity: params.identity,
-    name: params.name,
-    ttl: '30m',
-  });
-  token.addGrant({
-    room: params.roomName,
-    roomJoin: true,
-    roomCreate: true,
-    canPublish: true,
-    canSubscribe: true,
-  });
-  return await token.toJwt();
-}
-
-async function connectTestRooms(count: number): Promise<{ roomName: string; rooms: Room[] }> {
-  const env = getTestEnv();
-  const roomName = `test_room_${randomUUID()}`;
-  const rooms = await Promise.all(
-    Array.from({ length: count }, async (_, i) => {
-      const token = await createJoinToken({
-        env,
-        roomName,
-        identity: `p${i}`,
-        name: `Participant ${i}`,
-      });
-      const room = new Room();
-      await room.connect(env.url, token, { autoSubscribe: true, dynacast: false });
-      return room;
-    }),
-  );
-
-  const start = Date.now();
-  await waitFor(() => rooms.every((r) => r.remoteParticipants.size === count - 1), {
-    timeoutMs: 5000,
-    debugName: `participant visibility (${Date.now() - start}ms)`,
-  });
-
-  return { roomName, rooms };
-}
-
-function waitForRoomEvent<R>(
-  room: Room,
-  event: RoomEvent,
-  timeoutMs: number,
-  take: (...args: any[]) => R,
-  match?: (...args: unknown[]) => boolean,
-): Promise<R> {
-  return withTimeout(
-    new Promise<R>((resolve) => {
-      const handler = (...args: any[]) => {
-        if (match && !match(...args)) {
-          return;
-        }
-        // typed-emitter doesn't expose `.once` in the type surface, so do manual once+cleanup.
-        room.off(event as any, handler as any);
-        resolve(take(...args));
-      };
-      room.on(event as any, handler as any);
-    }),
-    timeoutMs,
-    `Timed out waiting for ${event}`,
-  );
-}
-
 /**
  * Only tracks published by `identity` are the test's business. Anything else in
  * the room — an agent the project dispatches, a stray participant — publishes
@@ -182,17 +64,6 @@ function expectTimestampFromCall(timestamp: number, calledAt: number, what: stri
   expect(timestamp, detail).toBeLessThanOrEqual(now + clockToleranceMs);
 }
 
-function concatUint8(chunks: Uint8Array[]): Uint8Array {
-  const len = chunks.reduce((acc, c) => acc + c.byteLength, 0);
-  const out = new Uint8Array(len);
-  let offset = 0;
-  for (const c of chunks) {
-    out.set(c, offset);
-    offset += c.byteLength;
-  }
-  return out;
-}
-
 function channelSamples(frame: AudioFrame, channelIndex: number): Int16Array {
   const { data, channels, samplesPerChannel } = frame;
   const out = new Int16Array(samplesPerChannel);
@@ -296,6 +167,46 @@ describeE2E('livekit-rtc e2e', () => {
     testTimeoutMs,
   );
 
+  it(
+    'sends and receives a data message between participants sharing a key',
+    async () => {
+      // A shared-key `keyProviderOptions` with only `sharedKey` set relies on
+      // the SDK filling in the remaining (proto-required) provider defaults;
+      // regression guard for connect failing to encode KeyProviderOptions.
+      const encryption = {
+        keyProviderOptions: { sharedKey: new TextEncoder().encode('test-shared-key') },
+      };
+      const { rooms } = await connectTestRooms(2, { encryption });
+      const [receivingRoom, sendingRoom] = rooms;
+      const senderIdentity = sendingRoom!.localParticipant!.identity;
+      const receiverIdentity = receivingRoom!.localParticipant!.identity;
+
+      const payload = new TextEncoder().encode('e2ee-hello');
+      const received = withTimeout(
+        new Promise<Uint8Array>((resolve) => {
+          receivingRoom!.on(RoomEvent.DataReceived, (data, participant) => {
+            if (participant?.identity !== senderIdentity) return;
+            resolve(data);
+          });
+        }),
+        testTimeoutMs,
+        'Timed out waiting for encrypted data message',
+      );
+
+      await sendingRoom!.localParticipant!.publishData(payload, {
+        reliable: true,
+        destination_identities: [receiverIdentity],
+      });
+
+      // The message round-trips intact only if both sides brought a working
+      // shared-key provider through connect and encrypt/decrypt lined up.
+      expect(await received).toEqual(payload);
+
+      await Promise.all(rooms.map((r) => r.disconnect()));
+    },
+    testTimeoutMs,
+  );
+
   it(
     'emits participantDisconnected when a participant leaves',
     async () => {

package/src/tests/e2e_common.ts

@@ -0,0 +1,163 @@
+// SPDX-FileCopyrightText: 2026 LiveKit, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+import { AccessToken } from 'livekit-server-sdk';
+import { randomUUID } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+import { describe } from 'vitest';
+import { Room, type RoomEvent, type RoomOptions } from '../index.js';
+
+export const hasE2EEnv =
+  !!process.env.LIVEKIT_URL && !!process.env.LIVEKIT_API_KEY && !!process.env.LIVEKIT_API_SECRET;
+// Explicitly typed so declaration emit doesn't reference vitest's
+// non-exported internal suite types (TS4023).
+export const describeE2E: typeof describe = hasE2EEnv
+  ? describe
+  : (describe.skip as typeof describe);
+export const testTimeoutMs = 10_000;
+
+export type TestEnv = {
+  url: string;
+  apiKey: string;
+  apiSecret: string;
+};
+
+function normalizeLiveKitUrl(url: string): string {
+  if (url.startsWith('http://')) return `ws://${url.slice('http://'.length)}`;
+  if (url.startsWith('https://')) return `wss://${url.slice('https://'.length)}`;
+  return url;
+}
+
+export function getTestEnv(): TestEnv {
+  if (!hasE2EEnv) {
+    throw new Error(
+      'Missing required env vars for e2e: LIVEKIT_URL, LIVEKIT_API_KEY, LIVEKIT_API_SECRET',
+    );
+  }
+  return {
+    url: normalizeLiveKitUrl(process.env.LIVEKIT_URL!),
+    apiKey: process.env.LIVEKIT_API_KEY!,
+    apiSecret: process.env.LIVEKIT_API_SECRET!,
+  };
+}
+
+export async function withTimeout<T>(
+  promise: Promise<T>,
+  timeoutMs: number,
+  message: string,
+): Promise<T> {
+  return await Promise.race([
+    promise,
+    (async () => {
+      await delay(timeoutMs);
+      throw new Error(message);
+    })(),
+  ]);
+}
+
+export async function waitFor(
+  condition: () => boolean,
+  opts: { timeoutMs: number; intervalMs?: number; debugName?: string },
+): Promise<void> {
+  const intervalMs = opts.intervalMs ?? 50;
+  const deadline = Date.now() + opts.timeoutMs;
+  while (Date.now() < deadline) {
+    if (condition()) return;
+    await delay(intervalMs);
+  }
+  throw new Error(`Timed out waiting for condition${opts.debugName ? ` (${opts.debugName})` : ''}`);
+}
+
+export async function createJoinToken(params: {
+  env: TestEnv;
+  roomName: string;
+  identity: string;
+  name: string;
+}): Promise<string> {
+  const token = new AccessToken(params.env.apiKey, params.env.apiSecret, {
+    identity: params.identity,
+    name: params.name,
+    ttl: '30m',
+  });
+  token.addGrant({
+    room: params.roomName,
+    roomJoin: true,
+    roomCreate: true,
+    canPublish: true,
+    canSubscribe: true,
+  });
+  return await token.toJwt();
+}
+
+export async function connectTestRooms(
+  count: number,
+  /**
+   * Extra room options applied to every room, e.g. data stream limits or
+   * `encryption` to bring up the whole set with a shared e2ee key.
+   */
+  options?: Partial<RoomOptions>,
+): Promise<{ roomName: string; rooms: Room[] }> {
+  const env = getTestEnv();
+  const roomName = `test_room_${randomUUID()}`;
+  const rooms = await Promise.all(
+    Array.from({ length: count }, async (_, i) => {
+      const token = await createJoinToken({
+        env,
+        roomName,
+        identity: `p${i}`,
+        name: `Participant ${i}`,
+      });
+      const room = new Room();
+      await room.connect(env.url, token, {
+        autoSubscribe: true,
+        dynacast: false,
+        ...options,
+      });
+      return room;
+    }),
+  );
+
+  const start = Date.now();
+  await waitFor(() => rooms.every((r) => r.remoteParticipants.size === count - 1), {
+    timeoutMs: 5000,
+    debugName: `participant visibility (${Date.now() - start}ms)`,
+  });
+
+  return { roomName, rooms };
+}
+
+export function waitForRoomEvent<R>(
+  room: Room,
+  event: RoomEvent,
+  timeoutMs: number,
+  take: (...args: any[]) => R,
+  /** Ignore emissions that don't match, e.g. events for another participant. */
+  match?: (...args: unknown[]) => boolean,
+): Promise<R> {
+  return withTimeout(
+    new Promise<R>((resolve) => {
+      const handler = (...args: any[]) => {
+        if (match && !match(...args)) {
+          return;
+        }
+        // typed-emitter doesn't expose `.once` in the type surface, so do manual once+cleanup.
+        room.off(event as any, handler as any);
+        resolve(take(...args));
+      };
+      room.on(event as any, handler as any);
+    }),
+    timeoutMs,
+    `Timed out waiting for ${event}`,
+  );
+}
+
+export function concatUint8(chunks: Uint8Array[]): Uint8Array {
+  const len = chunks.reduce((acc, c) => acc + c.byteLength, 0);
+  const out = new Uint8Array(len);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.byteLength;
+  }
+  return out;
+}