Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

5.4 KB
Raw Blame
import { Telemetry } from '@macro-inc/observability';
import type { CallTokenResponse } from '@service-call/client';
import type { Room, RoomOptions } from 'livekit-client';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';

const roomOptions = vi.fn();
const connectRoom = vi.fn<() => Promise<void>>();

vi.mock('livekit-client', () => ({
  Room: class {
    constructor(options: RoomOptions) {
      roomOptions(options);
    }
    remoteParticipants = new Map();
    on() {}
    removeAllListeners() {}
    connect = connectRoom;
    disconnect = vi.fn(async () => undefined);
  },
  RoomEvent: {},
  Track: { Source: { ScreenShare: 'screen_share' } },
}));
vi.mock('../call-audio-receiver-stats', () => ({
  startReceiverStatsSampling: () => () => undefined,
}));

const { createLivekitJsCallController } = await import(
  '../LivekitJsCallController'
);

const token = {
  callId: 'call-1',
  channelId: null,
  serverUrl: 'wss://example.com',
  token: 'rtc-token',
} as unknown as CallTokenResponse;

function track() {
  return { stop: vi.fn() } as unknown as MediaStreamTrack & {
    stop: ReturnType<typeof vi.fn>;
  };
}

function setup(state?: { connectionState: string; room?: Room }) {
  let room: Room | null = state?.room ?? null;
  const setInitialMediaState = vi.fn();
  const finishLocalMediaSetup = vi.fn(async () => undefined);
  const controller = createLivekitJsCallController({
    room: () => room,
    setRoom: (next) => {
      room = next;
    },
    state: () =>
      ({
        activeChannelId: null,
        activeCallId: 'call-1',
        connectionState: state?.connectionState ?? 'disconnected',
      }) as never,
    currentMicrophoneCaptureOptions: () => ({}),
    isActiveConnectionState: (value) => value === 'connected',
    cancelPendingMediaSetup: () => undefined,
    nextMediaSetupVersion: () => 1,
    finishLocalMediaSetup,
    destroyProcessors: () => undefined,
    resetState: () => undefined,
    setConnectionState: () => undefined,
    setActiveCall: () => undefined,
    setDuplicateConnectCallId: () => undefined,
    setInitialMediaState,
    setRemoteParticipants: () => undefined,
    clearOptimisticJoin: () => undefined,
    bumpTrackVersion: () => undefined,
    bumpSpeakerVersion: () => undefined,
    setScreenSharing: () => undefined,
  });
  return { controller, finishLocalMediaSetup, setInitialMediaState };
}

describe('livekit call controller prejoin tracks', () => {
  afterEach(() => vi.restoreAllMocks());

  beforeEach(() => {
    connectRoom.mockReset();
    connectRoom.mockResolvedValue(undefined);
  });

  it('carries selected devices and background into the connected room', async () => {
    const { controller, setInitialMediaState } = setup();
    const preferences = {
      microphoneDeviceId: 'mic-2',
      cameraDeviceId: 'camera-2',
      speakerDeviceId: 'speaker-2',
      backgroundEffect: { type: 'blur' as const, intensity: 'medium' as const },
    };
    await controller.connect(token, preferences);
    expect(roomOptions).toHaveBeenLastCalledWith(
      expect.objectContaining({
        audioCaptureDefaults: { deviceId: { exact: 'mic-2' } },
        videoCaptureDefaults: { deviceId: { exact: 'camera-2' } },
        audioOutput: { deviceId: 'speaker-2' },
      })
    );
    expect(setInitialMediaState).toHaveBeenCalledWith(preferences);
  });

  it('hands prejoin tracks to media setup instead of stopping them', async () => {
    const { controller, finishLocalMediaSetup } = setup();
    const localTracks = { microphone: track(), camera: track() };
    await controller.connect(token, { localTracks });
    expect(finishLocalMediaSetup).toHaveBeenCalledWith(
      expect.anything(),
      1,
      localTracks,
      expect.objectContaining({ span: expect.any(Function) })
    );
    expect(localTracks.microphone.stop).not.toHaveBeenCalled();
    expect(localTracks.camera.stop).not.toHaveBeenCalled();
  });

  it('explicitly parents background media after the asynchronous room connection', async () => {
    const connectionSpan = Telemetry.span('test');
    const phases = vi.spyOn(connectionSpan, 'span');
    vi.spyOn(Telemetry, 'span').mockReturnValue(connectionSpan);
    const { controller, finishLocalMediaSetup } = setup();

    await controller.connect(token);

    expect(phases).toHaveBeenCalledWith(
      'call.media.setup',
      expect.any(Function)
    );
    expect(finishLocalMediaSetup).toHaveBeenCalledWith(
      expect.anything(),
      1,
      undefined,
      expect.objectContaining({ span: expect.any(Function) })
    );
  });

  it('stops prejoin tracks when the room fails to connect', async () => {
    connectRoom.mockRejectedValue(new Error('offline'));
    const { controller, finishLocalMediaSetup } = setup();
    const localTracks = { microphone: track(), camera: track() };
    await expect(controller.connect(token, { localTracks })).rejects.toThrow(
      'offline'
    );
    expect(finishLocalMediaSetup).not.toHaveBeenCalled();
    expect(localTracks.microphone.stop).toHaveBeenCalledOnce();
    expect(localTracks.camera.stop).toHaveBeenCalledOnce();
  });

  it('stops prejoin tracks on a duplicate connect to the active room', async () => {
    const { controller, finishLocalMediaSetup } = setup({
      connectionState: 'connected',
      room: {} as Room,
    });
    const localTracks = { camera: track() };
    await controller.connect(token, { localTracks });
    expect(finishLocalMediaSetup).not.toHaveBeenCalled();
    expect(localTracks.camera.stop).toHaveBeenCalledOnce();
  });
});