livekit-client 2.18.10 → 2.19.0

package/src/room/rpc.test.ts

@@ -1,301 +0,0 @@
-import { DataPacket, DataPacket_Kind } from '@livekit/protocol';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import type { InternalRoomOptions } from '../options';
-import type RTCEngine from './RTCEngine';
-import Room from './Room';
-import LocalParticipant from './participant/LocalParticipant';
-import { ParticipantKind } from './participant/Participant';
-import RemoteParticipant from './participant/RemoteParticipant';
-import { RpcError } from './rpc';
-
-describe('LocalParticipant', () => {
-  describe('registerRpcMethod', () => {
-    let room: Room;
-    let mockSendDataPacket: ReturnType<typeof vi.fn>;
-
-    beforeEach(() => {
-      mockSendDataPacket = vi.fn();
-
-      room = new Room();
-      room.engine.client = {
-        sendUpdateLocalMetadata: vi.fn(),
-      };
-      room.engine.on = vi.fn().mockReturnThis();
-      room.engine.sendDataPacket = mockSendDataPacket;
-
-      room.localParticipant.sid = 'test-sid';
-      room.localParticipant.identity = 'test-identity';
-    });
-
-    it('should register an RPC method handler', async () => {
-      const methodName = 'testMethod';
-      const handler = vi.fn().mockResolvedValue('test response');
-
-      room.registerRpcMethod(methodName, handler);
-
-      const mockCaller = new RemoteParticipant(
-        {} as any,
-        'remote-sid',
-        'remote-identity',
-        'Remote Participant',
-        '',
-        undefined,
-        undefined,
-        ParticipantKind.STANDARD,
-      );
-
-      await room.handleIncomingRpcRequest(
-        mockCaller.identity,
-        'test-request-id',
-        methodName,
-        'test payload',
-        5000,
-        1,
-      );
-
-      expect(handler).toHaveBeenCalledWith({
-        requestId: 'test-request-id',
-        callerIdentity: mockCaller.identity,
-        payload: 'test payload',
-        responseTimeout: 5000,
-      });
-
-      // Check if sendDataPacket was called twice (once for ACK and once for response)
-      expect(mockSendDataPacket).toHaveBeenCalledTimes(2);
-
-      // Check if the first call was for ACK
-      expect(mockSendDataPacket.mock.calls[0][0].value.case).toBe('rpcAck');
-      expect(mockSendDataPacket.mock.calls[0][1]).toBe(DataPacket_Kind.RELIABLE);
-
-      // Check if the second call was for response
-      expect(mockSendDataPacket.mock.calls[1][0].value.case).toBe('rpcResponse');
-      expect(mockSendDataPacket.mock.calls[1][1]).toBe(DataPacket_Kind.RELIABLE);
-    });
-
-    it('should catch and transform unhandled errors in the RPC method handler', async () => {
-      const methodName = 'errorMethod';
-      const errorMessage = 'Test error';
-      const handler = vi.fn().mockRejectedValue(new Error(errorMessage));
-
-      room.registerRpcMethod(methodName, handler);
-
-      const mockCaller = new RemoteParticipant(
-        {} as any,
-        'remote-sid',
-        'remote-identity',
-        'Remote Participant',
-        '',
-        undefined,
-        undefined,
-        ParticipantKind.STANDARD,
-      );
-
-      await room.handleIncomingRpcRequest(
-        mockCaller.identity,
-        'test-error-request-id',
-        methodName,
-        'test payload',
-        5000,
-        1,
-      );
-
-      expect(handler).toHaveBeenCalledWith({
-        requestId: 'test-error-request-id',
-        callerIdentity: mockCaller.identity,
-        payload: 'test payload',
-        responseTimeout: 5000,
-      });
-
-      // Check if sendDataPacket was called twice (once for ACK and once for error response)
-      expect(mockSendDataPacket).toHaveBeenCalledTimes(2);
-
-      // Check if the second call was for error response
-      const errorResponse = mockSendDataPacket.mock.calls[1][0].value.value.value.value;
-      expect(errorResponse.code).toBe(RpcError.ErrorCode.APPLICATION_ERROR);
-    });
-
-    it('should pass through RpcError thrown by the RPC method handler', async () => {
-      const methodName = 'rpcErrorMethod';
-      const errorCode = 101;
-      const errorMessage = 'some-error-message';
-      const handler = vi.fn().mockRejectedValue(new RpcError(errorCode, errorMessage));
-
-      room.localParticipant.registerRpcMethod(methodName, handler);
-
-      const mockCaller = new RemoteParticipant(
-        {} as any,
-        'remote-sid',
-        'remote-identity',
-        'Remote Participant',
-        '',
-        undefined,
-        undefined,
-        ParticipantKind.STANDARD,
-      );
-
-      await room.handleIncomingRpcRequest(
-        mockCaller.identity,
-        'test-rpc-error-request-id',
-        methodName,
-        'test payload',
-        5000,
-        1,
-      );
-
-      expect(handler).toHaveBeenCalledWith({
-        requestId: 'test-rpc-error-request-id',
-        callerIdentity: mockCaller.identity,
-        payload: 'test payload',
-        responseTimeout: 5000,
-      });
-
-      // Check if sendDataPacket was called twice (once for ACK and once for error response)
-      expect(mockSendDataPacket).toHaveBeenCalledTimes(2);
-
-      // Check if the second call was for error response
-      const errorResponse = mockSendDataPacket.mock.calls[1][0].value.value.value.value;
-      expect(errorResponse.code).toBe(errorCode);
-      expect(errorResponse.message).toBe(errorMessage);
-    });
-  });
-
-  describe('performRpc', () => {
-    let localParticipant: LocalParticipant;
-    let mockRemoteParticipant: RemoteParticipant;
-    let mockEngine: RTCEngine;
-    let mockRoomOptions: InternalRoomOptions;
-    let mockSendDataPacket: ReturnType<typeof vi.fn>;
-
-    beforeEach(() => {
-      mockSendDataPacket = vi.fn();
-      mockEngine = {
-        client: {
-          sendUpdateLocalMetadata: vi.fn(),
-        },
-        on: vi.fn().mockReturnThis(),
-        sendDataPacket: mockSendDataPacket,
-      } as unknown as RTCEngine;
-
-      mockRoomOptions = {} as InternalRoomOptions;
-
-      localParticipant = new LocalParticipant(
-        'local-sid',
-        'local-identity',
-        mockEngine,
-        mockRoomOptions,
-      );
-
-      mockRemoteParticipant = new RemoteParticipant(
-        {} as any,
-        'remote-sid',
-        'remote-identity',
-        'Remote Participant',
-        '',
-        undefined,
-        undefined,
-        ParticipantKind.STANDARD,
-      );
-    });
-
-    it('should send RPC request and receive successful response', async () => {
-      const method = 'testMethod';
-      const payload = 'testPayload';
-      const responsePayload = 'responsePayload';
-
-      mockSendDataPacket.mockImplementationOnce((packet: DataPacket) => {
-        const requestId = packet.value.value.id;
-        setTimeout(() => {
-          localParticipant.handleIncomingRpcAck(requestId);
-          setTimeout(() => {
-            localParticipant.handleIncomingRpcResponse(requestId, responsePayload, null);
-          }, 10);
-        }, 10);
-      });
-
-      const result = await localParticipant.performRpc({
-        destinationIdentity: mockRemoteParticipant.identity,
-        method,
-        payload,
-      });
-
-      expect(mockSendDataPacket).toHaveBeenCalledTimes(1);
-      expect(result).toBe(responsePayload);
-    });
-
-    it('should handle RPC request timeout', async () => {
-      const method = 'timeoutMethod';
-      const payload = 'timeoutPayload';
-
-      const timeout = 50;
-
-      const resultPromise = localParticipant.performRpc({
-        destinationIdentity: mockRemoteParticipant.identity,
-        method,
-        payload,
-        responseTimeout: timeout,
-      });
-
-      mockSendDataPacket.mockImplementationOnce(() => {
-        return new Promise((resolve) => {
-          setTimeout(resolve, timeout + 10);
-        });
-      });
-
-      const startTime = Date.now();
-
-      await expect(resultPromise).rejects.toThrow('Response timeout');
-
-      const elapsedTime = Date.now() - startTime;
-      expect(elapsedTime).toBeGreaterThanOrEqual(timeout);
-      expect(elapsedTime).toBeLessThan(timeout + 50); // Allow some margin for test execution
-
-      expect(mockSendDataPacket).toHaveBeenCalledTimes(1);
-    });
-
-    it('should handle RPC error response', async () => {
-      const method = 'errorMethod';
-      const payload = 'errorPayload';
-      const errorCode = 101;
-      const errorMessage = 'Test error message';
-
-      mockSendDataPacket.mockImplementationOnce((packet: DataPacket) => {
-        const requestId = packet.value.value.id;
-        setTimeout(() => {
-          localParticipant.handleIncomingRpcAck(requestId);
-          localParticipant.handleIncomingRpcResponse(
-            requestId,
-            null,
-            new RpcError(errorCode, errorMessage),
-          );
-        }, 10);
-      });
-
-      await expect(
-        localParticipant.performRpc({
-          destinationIdentity: mockRemoteParticipant.identity,
-          method,
-          payload,
-        }),
-      ).rejects.toThrow(errorMessage);
-    });
-
-    it('should handle participant disconnection during RPC request', async () => {
-      const method = 'disconnectMethod';
-      const payload = 'disconnectPayload';
-
-      mockSendDataPacket.mockImplementationOnce(() => Promise.resolve());
-
-      const resultPromise = localParticipant.performRpc({
-        destinationIdentity: mockRemoteParticipant.identity,
-        method,
-        payload,
-      });
-
-      // Simulate a small delay before disconnection
-      await new Promise((resolve) => setTimeout(resolve, 200));
-      localParticipant.handleParticipantDisconnected(mockRemoteParticipant.identity);
-
-      await expect(resultPromise).rejects.toThrow('Recipient disconnected');
-    });
-  });
-});