Improve connection URL handling and add unit tests (#1468)

Author: lukasIO

.changeset/honest-swans-switch.md

@@ -0,0 +1,5 @@
+---
+"livekit-client": patch
+---
+
+Improve connection URL handling and add unit tests

pnpm-lock.yaml

@@ -43,8 +43,9 @@ import log, { LoggerNames, getLogger } from '../logger';
 import { ConnectionError, ConnectionErrorReason } from '../room/errors';
 import CriticalTimers from '../room/timers';
 import type { LoggerOptions } from '../room/types';
-import { getClientInfo, isReactNative, sleep, toWebsocketUrl } from '../room/utils';
+import { getClientInfo, isReactNative, sleep } from '../room/utils';
 import { AsyncQueue } from '../utils/AsyncQueue';
+import { createRtcUrl, createValidateUrl } from './utils';
 
 // internal options
 interface ConnectOpts extends SignalOptions {
@@ -258,17 +259,10 @@ export class SignalClient {
     abortSignal?: AbortSignal,
   ): Promise<JoinResponse | ReconnectResponse | undefined> {
     this.connectOptions = opts;
-    const urlObj = new URL(toWebsocketUrl(url));
-    // strip trailing slash
-    const hasTrailingSlash = urlObj.pathname.endsWith('/');
-    urlObj.pathname += hasTrailingSlash ? 'rtc' : '/rtc';
-
     const clientInfo = getClientInfo();
     const params = createConnectionParams(token, clientInfo, opts);
-
-    for (const [key, value] of params) {
-      urlObj.searchParams.set(key, value);
-    }
+    const rtcUrl = createRtcUrl(url, params);
+    const validateUrl = createValidateUrl(rtcUrl);
 
     return new Promise<JoinResponse | ReconnectResponse | undefined>(async (resolve, reject) => {
       const unlock = await this.connectionLock.lock();
@@ -298,7 +292,7 @@ export class SignalClient {
           abortHandler();
         }
         abortSignal?.addEventListener('abort', abortHandler);
-        const redactedUrl = new URL(urlObj.toString());
+        const redactedUrl = new URL(rtcUrl);
         if (redactedUrl.searchParams.has('access_token')) {
           redactedUrl.searchParams.set('access_token', '<redacted>');
         }
@@ -310,7 +304,7 @@ export class SignalClient {
         if (this.ws) {
           await this.close(false);
         }
-        this.ws = new WebSocket(urlObj.toString());
+        this.ws = new WebSocket(rtcUrl);
         this.ws.binaryType = 'arraybuffer';
 
         this.ws.onopen = () => {
@@ -322,10 +316,7 @@ export class SignalClient {
             this.state = SignalConnectionState.DISCONNECTED;
             clearTimeout(wsTimeout);
             try {
-              const validateURL = new URL(urlObj.toString());
-              validateURL.protocol = `http${validateURL.protocol.substring(2)}`;
-              validateURL.pathname += '/validate';
-              const resp = await fetch(validateURL);
+              const resp = await fetch(validateUrl);
               if (resp.status.toFixed(0).startsWith('4')) {
                 const msg = await resp.text();
                 reject(new ConnectionError(msg, ConnectionErrorReason.NotAllowed, resp.status));

src/api/SignalClient.ts

@@ -0,0 +1,100 @@
+import { describe, expect, it } from 'vitest';
+import { createRtcUrl, createValidateUrl } from './utils';
+
+describe('createRtcUrl', () => {
+  it('should create a basic RTC URL', () => {
+    const url = 'wss://example.com';
+    const searchParams = new URLSearchParams();
+    const result = createRtcUrl(url, searchParams);
+    expect(result.toString()).toBe('wss://example.com/rtc');
+  });
+
+  it('should handle search parameters', () => {
+    const url = 'wss://example.com';
+    const searchParams = new URLSearchParams({
+      token: 'test-token',
+      room: 'test-room',
+    });
+    const result = createRtcUrl(url, searchParams);
+
+    const parsedResult = new URL(result);
+    expect(parsedResult.pathname).toBe('/rtc');
+    expect(parsedResult.searchParams.get('token')).toBe('test-token');
+    expect(parsedResult.searchParams.get('room')).toBe('test-room');
+  });
+
+  it('should handle ws protocol', () => {
+    const url = 'ws://example.com';
+    const searchParams = new URLSearchParams();
+    const result = createRtcUrl(url, searchParams);
+
+    const parsedResult = new URL(result);
+    expect(parsedResult.pathname).toBe('/rtc');
+  });
+
+  it('should handle sub paths', () => {
+    const url = 'wss://example.com/sub/path';
+    const searchParams = new URLSearchParams();
+    const result = createRtcUrl(url, searchParams);
+
+    const parsedResult = new URL(result);
+    expect(parsedResult.pathname).toBe('/sub/path/rtc');
+  });
+
+  it('should handle sub paths with trailing slashes', () => {
+    const url = 'wss://example.com/sub/path/';
+    const searchParams = new URLSearchParams();
+    const result = createRtcUrl(url, searchParams);
+
+    const parsedResult = new URL(result);
+    expect(parsedResult.pathname).toBe('/sub/path/rtc');
+  });
+});
+
+describe('createValidateUrl', () => {
+  it('should create a basic validate URL', () => {
+    const rtcUrl = createRtcUrl('wss://example.com', new URLSearchParams());
+    const result = createValidateUrl(rtcUrl);
+    expect(result.toString()).toBe('https://example.com/rtc/validate');
+  });
+
+  it('should handle search parameters', () => {
+    const rtcUrl = createRtcUrl(
+      'wss://example.com',
+      new URLSearchParams({
+        token: 'test-token',
+        room: 'test-room',
+      }),
+    );
+    const result = createValidateUrl(rtcUrl);
+
+    const parsedResult = new URL(result);
+    expect(parsedResult.pathname).toBe('/rtc/validate');
+    expect(parsedResult.searchParams.get('token')).toBe('test-token');
+    expect(parsedResult.searchParams.get('room')).toBe('test-room');
+  });
+
+  it('should handle ws protocol', () => {
+    const rtcUrl = createRtcUrl('ws://example.com', new URLSearchParams());
+    const result = createValidateUrl(rtcUrl);
+
+    const parsedResult = new URL(result);
+    expect(parsedResult.pathname).toBe('/rtc/validate');
+  });
+
+  it('should preserve the original path', () => {
+    const rtcUrl = createRtcUrl('wss://example.com/some/path', new URLSearchParams());
+    const result = createValidateUrl(rtcUrl);
+
+    const parsedResult = new URL(result);
+    expect(parsedResult.pathname).toBe('/some/path/rtc/validate');
+  });
+
+  it('should handle sub paths with trailing slashes', () => {
+    const rtcUrl = createRtcUrl('wss://example.com/sub/path/', new URLSearchParams());
+    const result = createValidateUrl(rtcUrl);
+
+    const parsedResult = new URL(result);
+    expect(parsedResult.pathname).toBe('/sub/path/rtc/validate');
+  });
+});

src/api/utils.test.ts

@@ -0,0 +1,26 @@
+import { toHttpUrl } from '../room/utils';
+
+export function createRtcUrl(url: string, searchParams: URLSearchParams) {
+  const urlObj = new URL(url);
+  searchParams.forEach((value, key) => {
+    urlObj.searchParams.set(key, value);
+  });
+  return appendUrlPath(urlObj, 'rtc');
+}
+
+export function createValidateUrl(rtcWsUrl: string) {
+  const urlObj = new URL(toHttpUrl(rtcWsUrl));
+  return appendUrlPath(urlObj, 'validate');
+}
+
+function ensureTrailingSlash(url: string) {
+  return url.endsWith('/') ? url : `${url}/`;
+}
+
+function appendUrlPath(urlObj: URL, path: string) {
+  const result = `${urlObj.protocol}//${urlObj.host}${ensureTrailingSlash(urlObj.pathname)}${path}`;
+  if (urlObj.searchParams.size > 0) {
+    return `${result}?${urlObj.searchParams.toString()}`;
+  }
+  return result;
+}