Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

19.0 KB
Raw Blame
import { describe, it, expect, beforeEach, vi } from 'vitest';
import { render, screen, fireEvent, waitFor, act } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import FableLoomHostedJoin from './FableLoomHostedJoin';

// Mock socket.io-client
const mockSocket = {
  on: vi.fn(),
  emit: vi.fn(),
  disconnect: vi.fn(),
};

vi.mock('socket.io-client', () => ({
  io: vi.fn(() => mockSocket),
}));

describe('FableLoomHostedJoin', () => {
  beforeEach(() => {
    vi.clearAllMocks();
    window.location.hash = '';
  });

  it('renders error when hash credentials are missing', () => {
    window.location.hash = '';
    render(<FableLoomHostedJoin />);
    expect(screen.getByText('Hosted Play Error')).toBeInTheDocument();
    expect(screen.getByText(/Invalid or missing join credentials/i)).toBeInTheDocument();

    const shell = screen.getByRole('main');
    expect(shell).toContainElement(screen.getByRole('heading', { name: 'Hosted Play Error' }));
    expect(shell).toHaveClass('h-dvh-screen');
    expect(shell).not.toHaveClass('min-h-screen');
  });

  it('connects to /fableloom-hosted when hash credentials are provided', async () => {
    window.location.hash = '#session=sess-123&token=tok-abc';
    const { io } = await import('socket.io-client');

    render(<FableLoomHostedJoin />);

    expect(io).toHaveBeenCalledWith('/fableloom-hosted', expect.objectContaining({
      auth: { sessionId: 'sess-123', token: 'tok-abc', role: 'audience' },
    }));

    expect(screen.getByText('FableLoom Play')).toBeInTheDocument();
    expect(screen.getByText('Audience Microphone UI')).toBeInTheDocument();
  });

  it('keeps the transcript as the only inner scroll region of the dynamic shell', () => {
    window.location.hash = '#session=sess-123&token=tok-abc';
    render(<FableLoomHostedJoin />);

    const shell = screen.getByRole('main');
    expect(shell).toHaveClass('h-dvh-screen', 'overflow-y-auto');
    expect(shell).not.toHaveClass('overflow-hidden');
    expect(shell).not.toHaveClass('min-h-screen');

    const scrollRegions = shell.querySelectorAll('.overflow-y-auto');
    expect(scrollRegions).toHaveLength(1);
    expect(scrollRegions[0]).toHaveClass('flex-1', 'min-h-[8rem]');
    const header = shell.querySelector('header');
    expect(header).toHaveClass('shrink-0');
    expect(header.nextElementSibling).toHaveClass('shrink-0');
    expect(screen.getByPlaceholderText('Or type a message…').closest('form').parentElement).toHaveClass('shrink-0');
  });

  it('sends text input fallback when submitted', async () => {
    window.location.hash = '#session=sess-123&token=tok-abc';
    render(<FableLoomHostedJoin />);

    const input = screen.getByPlaceholderText('Or type a message…');
    fireEvent.change(input, { target: { value: '  Look around the room  ' } });

    const sendButton = screen.getByRole('button', { name: 'Send message' });
    expect(sendButton).toBeInTheDocument();
    expect(sendButton).toHaveClass(
      'min-w-[44px]',
      'min-h-[44px]',
      'flex',
      'items-center',
      'justify-center',
    );
    fireEvent.submit(input.closest('form'));

    expect(mockSocket.emit).toHaveBeenCalledWith('hosted:turn:text', { text: '  Look around the room  ' });
  });

  it('preserves an over-limit paste, refuses to send, and lets the guest shorten the message', async () => {
    window.location.hash = '#session=sess-123&token=tok-abc';
    const user = userEvent.setup();
    render(<FableLoomHostedJoin />);
    const input = screen.getByRole('textbox', { name: 'Message protagonist' });
    expect(input).not.toHaveAttribute('maxlength');
    expect(input).toHaveAccessibleDescription('0 / 1,000 characters');
    await user.click(input);
    await user.paste('x'.repeat(1001));
    expect(input).toHaveValue('x'.repeat(1001));
    expect(input).toHaveAccessibleDescription('1,001 / 1,000 characters Message exceeds 1,000 characters. Shorten it before sending.');
    expect(screen.getByRole('alert')).toHaveTextContent('Shorten it before sending.');
    expect(screen.getByRole('button', { name: 'Send message' })).toBeDisabled();
    fireEvent.submit(input.closest('form'));
    expect(mockSocket.emit).not.toHaveBeenCalled();

    input.setSelectionRange(1000, 1001);
    await user.keyboard('{Backspace}');
    expect(input).toHaveValue('x'.repeat(1000));
    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
    expect(input).toHaveAccessibleDescription('1,000 / 1,000 characters');
    await user.click(screen.getByRole('button', { name: 'Send message' }));
    expect(mockSocket.emit).toHaveBeenCalledWith('hosted:turn:text', { text: 'x'.repeat(1000) });
    expect(input).toHaveAccessibleDescription('0 / 1,000 characters');
  });

  it('refuses over-limit typed input without cutting or clearing it', () => {
    window.location.hash = '#session=sess-123&token=tok-abc';
    render(<FableLoomHostedJoin />);
    const input = screen.getByRole('textbox', { name: 'Message protagonist' });
    const text = 'x'.repeat(1001);
    fireEvent.change(input, { target: { value: text } });
    fireEvent.submit(input.closest('form'));
    expect(mockSocket.emit).not.toHaveBeenCalled();
    expect(input).toHaveValue(text);
    expect(input).toHaveAccessibleDescription('1,001 / 1,000 characters Message exceeds 1,000 characters. Shorten it before sending.');
  });

  it('releases a mic opened after push-to-talk was released', async () => {
    window.location.hash = '#session=sess-123&token=tok-abc';
    let resolveMic;
    const track = { stop: vi.fn() };
    const getUserMedia = vi.fn(() => new Promise((resolve) => { resolveMic = resolve; }));
    Object.defineProperty(navigator, 'mediaDevices', { configurable: true, value: { getUserMedia } });
    const recorder = vi.fn();
    vi.stubGlobal('MediaRecorder', recorder);

    render(<FableLoomHostedJoin />);
    const button = screen.getByRole('button', { name: /hold talk/i });
    fireEvent.pointerDown(button);
    fireEvent.pointerUp(button);
    await act(async () => { resolveMic({ getTracks: () => [track] }); });

    expect(track.stop).toHaveBeenCalledOnce();
    expect(recorder).not.toHaveBeenCalled();
    expect(mockSocket.emit).not.toHaveBeenCalledWith('hosted:mic:start');
    vi.unstubAllGlobals();
  });

  it('stops the recorder and tracks on unmount', async () => {
    window.location.hash = '#session=sess-123&token=tok-abc';
    const track = { stop: vi.fn() };
    Object.defineProperty(navigator, 'mediaDevices', {
      configurable: true, value: { getUserMedia: vi.fn().mockResolvedValue({ getTracks: () => [track] }) },
    });
    const recorder = { state: 'recording', start: vi.fn(), stop: vi.fn(), mimeType: 'audio/webm' };
    vi.stubGlobal('MediaRecorder', class { constructor() { return recorder; } });

    const { unmount } = render(<FableLoomHostedJoin />);
    fireEvent.pointerDown(screen.getByRole('button', { name: /hold talk/i }));
    await waitFor(() => expect(recorder.start).toHaveBeenCalledOnce());
    unmount();

    expect(recorder.stop).toHaveBeenCalledOnce();
    expect(track.stop).toHaveBeenCalledOnce();
    vi.unstubAllGlobals();
  });

  it('closes the mic on release while preserving the recorder final chunk', async () => {
    window.location.hash = '#session=sess-123&token=tok-abc';
    const track = { stop: vi.fn() };
    Object.defineProperty(navigator, 'mediaDevices', {
      configurable: true,
      value: { getUserMedia: vi.fn().mockResolvedValue({ getTracks: () => [track] }) },
    });
    let recorder;
    vi.stubGlobal('MediaRecorder', class {
      constructor() { this.state = 'inactive'; this.mimeType = 'audio/webm'; recorder = this; }
      start() { this.state = 'recording'; }
      stop() {
        this.state = 'inactive';
        queueMicrotask(() => {
          this.ondataavailable?.({ data: new Blob(['last']) });
          this.onstop?.();
        });
      }
    });

    render(<FableLoomHostedJoin />);
    const button = screen.getByRole('button', { name: /hold talk/i });
    fireEvent.pointerDown(button);
    await waitFor(() => expect(recorder?.state).toBe('recording'));
    fireEvent.pointerUp(button);

    expect(track.stop).toHaveBeenCalledOnce();
    await waitFor(() => expect(mockSocket.emit).toHaveBeenCalledWith('hosted:mic:stop', expect.any(Uint8Array)));
    const bytes = mockSocket.emit.mock.calls.find(([event]) => event === 'hosted:mic:stop')[1];
    expect(new TextDecoder().decode(bytes)).toBe('last');
    expect(track.stop).toHaveBeenCalledOnce();
    vi.unstubAllGlobals();
  });

  it('shows an over-cap recording refusal, aborts the turn, and keeps the guest connected', async () => {
    const { MAX_VOICE_AUDIO_BYTES, RECORDING_TOO_LONG_MESSAGE } = await import('../lib/audioRecorder.js');
    window.location.hash = '#session=sess-123&token=tok-abc';
    const track = { stop: vi.fn() };
    Object.defineProperty(navigator, 'mediaDevices', {
      configurable: true,
      value: { getUserMedia: vi.fn().mockResolvedValue({ getTracks: () => [track] }) },
    });
    let recorder;
    vi.stubGlobal('MediaRecorder', class {
      constructor() { this.state = 'inactive'; this.mimeType = 'audio/webm'; recorder = this; }
      start() { this.state = 'recording'; }
      stop() { this.state = 'inactive'; this.onstop?.(); }
    });
    try {
      render(<FableLoomHostedJoin />);
      const button = screen.getByRole('button', { name: /hold talk/i });
      fireEvent.pointerDown(button);
      await waitFor(() => expect(recorder?.state).toBe('recording'));
      recorder.ondataavailable({ data: new Blob([new Uint8Array(MAX_VOICE_AUDIO_BYTES + 1)]) });
      fireEvent.pointerUp(button);
      expect(screen.getByRole('alert')).toHaveTextContent(RECORDING_TOO_LONG_MESSAGE);
      expect(mockSocket.emit).not.toHaveBeenCalledWith('hosted:mic:stop', expect.anything());
      expect(mockSocket.emit).toHaveBeenCalledWith('hosted:turn:abort');
      expect(mockSocket.disconnect).not.toHaveBeenCalled();
      expect(track.stop).toHaveBeenCalledOnce();
    } finally {
      vi.unstubAllGlobals();
    }
  });

  it('ignores an old oversized stop callback after a newer recording starts', async () => {
    const { MAX_VOICE_AUDIO_BYTES } = await import('../lib/audioRecorder.js');
    window.location.hash = '#session=sess-123&token=tok-abc';
    Object.defineProperty(navigator, 'mediaDevices', {
      configurable: true,
      value: { getUserMedia: vi.fn(async () => ({ getTracks: () => [{ stop: vi.fn() }] })) },
    });
    const recorders = [];
    vi.stubGlobal('MediaRecorder', class {
      constructor() { this.state = 'inactive'; this.mimeType = 'audio/webm'; recorders.push(this); }
      start() { this.state = 'recording'; }
      stop() { this.state = 'inactive'; }
    });
    try {
      render(<FableLoomHostedJoin />);
      const button = screen.getByRole('button', { name: /hold talk/i });
      fireEvent.pointerDown(button);
      await waitFor(() => expect(recorders).toHaveLength(1));
      recorders[0].ondataavailable({ data: new Blob([new Uint8Array(MAX_VOICE_AUDIO_BYTES + 1)]) });
      fireEvent.pointerUp(button);
      fireEvent.pointerDown(button);
      await waitFor(() => expect(recorders).toHaveLength(2));
      act(() => recorders[0].onstop());
      expect(mockSocket.emit).not.toHaveBeenCalledWith('hosted:turn:abort');
      expect(screen.queryByRole('alert')).not.toBeInTheDocument();
      recorders[1].ondataavailable({ data: new Blob(['new recording']) });
      fireEvent.pointerUp(button);
      act(() => recorders[1].onstop());
      await waitFor(() => expect(mockSocket.emit).toHaveBeenCalledWith('hosted:mic:stop', expect.any(Uint8Array)));
      const bytes = mockSocket.emit.mock.calls.find(([event]) => event === 'hosted:mic:stop')[1];
      expect(new TextDecoder().decode(bytes)).toBe('new recording');
    } finally {
      vi.unstubAllGlobals();
    }
  });

  it('keeps audio chunks separate across two press and release cycles', async () => {
    window.location.hash = '#session=sess-123&token=tok-abc';
    const tracks = [{ stop: vi.fn() }, { stop: vi.fn() }];
    let streamIndex = 0;
    Object.defineProperty(navigator, 'mediaDevices', {
      configurable: true,
      value: { getUserMedia: vi.fn(() => {
        const track = tracks[streamIndex++];
        return Promise.resolve({ getTracks: () => [track] });
      }) },
    });
    const recorders = [];
    vi.stubGlobal('MediaRecorder', class {
      constructor() {
        this.state = 'inactive';
        this.mimeType = 'audio/webm';
        recorders.push(this);
      }
      start() { this.state = 'recording'; }
      stop() { this.state = 'inactive'; this.onstop?.(); }
    });

    render(<FableLoomHostedJoin />);
    const button = screen.getByRole('button', { name: /hold talk/i });
    fireEvent.pointerDown(button);
    await waitFor(() => expect(recorders).toHaveLength(1));
    recorders[0].ondataavailable({ data: new Blob(['first']) });
    fireEvent.pointerUp(button);
    await waitFor(() => expect(mockSocket.emit).toHaveBeenCalledWith('hosted:mic:stop', expect.any(Uint8Array)));

    fireEvent.pointerDown(button);
    await waitFor(() => expect(recorders).toHaveLength(2));
    recorders[1].ondataavailable({ data: new Blob(['second']) });
    fireEvent.pointerUp(button);
    await waitFor(() => expect(mockSocket.emit.mock.calls.filter(([event]) => event === 'hosted:mic:stop')).toHaveLength(2));

    const payloads = mockSocket.emit.mock.calls.filter(([event]) => event === 'hosted:mic:stop').map(([, bytes]) => new TextDecoder().decode(bytes));
    expect(payloads).toEqual(['first', 'second']);
    expect(tracks.every((track) => track.stop.mock.calls.length === 1)).toBe(true);
    vi.unstubAllGlobals();
  });

  const socketHandler = (event) => mockSocket.on.mock.calls.find(([name]) => name === event)?.[1];

  it('discards an in-progress recording and shows the mapped message when the mic is refused', async () => {
    window.location.hash = '#session=sess-123&token=tok-abc';
    const track = { stop: vi.fn() };
    Object.defineProperty(navigator, 'mediaDevices', {
      configurable: true,
      value: { getUserMedia: vi.fn().mockResolvedValue({ getTracks: () => [track] }) },
    });
    let recorder;
    vi.stubGlobal('MediaRecorder', class {
      constructor() { this.state = 'inactive'; this.mimeType = 'audio/webm'; recorder = this; }
      start() { this.state = 'recording'; }
      stop() { this.state = 'inactive'; queueMicrotask(() => this.onstop?.()); }
    });

    render(<FableLoomHostedJoin />);
    fireEvent.pointerDown(screen.getByRole('button', { name: /hold talk/i }));
    await waitFor(() => expect(recorder?.state).toBe('recording'));
    expect(screen.getByText(/release when done/i)).toBeInTheDocument();

    act(() => { socketHandler('hosted:error')({ code: 'PROTAGONIST_ONSCREEN', message: 'raw server text' }); });

    expect(recorder.state).toBe('inactive');
    expect(track.stop).toHaveBeenCalled();
    expect(screen.queryByText(/release when done/i)).not.toBeInTheDocument();
    expect(screen.getByRole('alert')).toHaveTextContent(/protagonist is on screen/i);
    await act(async () => { await Promise.resolve(); });
    expect(mockSocket.emit).not.toHaveBeenCalledWith('hosted:mic:stop', expect.anything());
    vi.unstubAllGlobals();
  });

  it('falls back to the server message and re-enables input after a failed turn returns to idle', () => {
    window.location.hash = '#session=sess-123&token=tok-abc';
    render(<FableLoomHostedJoin />);

    act(() => { socketHandler('hosted:turn:phase')({ phase: 'thinking' }); });
    expect(screen.getByRole('button', { name: /hold talk/i })).toBeDisabled();
    expect(screen.getByPlaceholderText('Or type a message…')).toBeDisabled();

    act(() => {
      socketHandler('hosted:error')({ code: 'TURN_FAILED', message: 'loom read failed' });
      socketHandler('hosted:turn:phase')({ phase: 'idle' });
    });

    expect(screen.getByRole('alert')).toHaveTextContent('loom read failed');
    expect(screen.getByRole('button', { name: /hold talk/i })).not.toBeDisabled();
    expect(screen.getByPlaceholderText('Or type a message…')).not.toBeDisabled();
  });

  it('reports audience playback completion, failure, and cancellation', async () => {
    window.location.hash = '#session=sess-123&token=tok-abc';
    const play = vi.spyOn(HTMLMediaElement.prototype, 'play').mockResolvedValue(undefined);
    render(<FableLoomHostedJoin />);
    const handler = (event) => mockSocket.on.mock.calls.filter(([name]) => name === event).at(-1)?.[1];
    const audio = document.querySelector('audio');
    const audienceTurn = '22222222-2222-4222-8222-222222222222';

    await act(async () => {
      handler('hosted:turn:tts')({
        target: 'host', audio: 'QQ==', mimeType: 'audio/wav', turnId: '11111111-1111-4111-8111-111111111111',
      });
    });
    expect(mockSocket.emit).not.toHaveBeenCalledWith('hosted:speech:done', expect.anything());

    await act(async () => {
      handler('hosted:turn:tts')({ target: 'audience', audio: 'QQ==', mimeType: 'audio/wav', turnId: audienceTurn });
      await Promise.resolve();
    });
    expect(play).toHaveBeenCalled();
    await act(async () => { audio.onended(); });
    expect(mockSocket.emit).toHaveBeenCalledWith('hosted:speech:done', { turnId: audienceTurn, status: 'ended' });

    play.mockRejectedValueOnce(new Error('blocked'));
    const failedTurn = '33333333-3333-4333-8333-333333333333';
    await act(async () => {
      handler('hosted:turn:tts')({ target: 'audience', audio: 'QQ==', mimeType: 'audio/wav', turnId: failedTurn });
      await Promise.resolve();
    });
    expect(mockSocket.emit).toHaveBeenCalledWith('hosted:speech:done', { turnId: failedTurn, status: 'failed' });

    const droppedTurn = '55555555-5555-4555-8555-555555555555';
    play.mockResolvedValue(undefined);
    const pause = vi.spyOn(HTMLMediaElement.prototype, 'pause').mockImplementation(() => {});
    await act(async () => {
      handler('hosted:turn:tts')({ target: 'audience', audio: 'QQ==', mimeType: 'audio/wav', turnId: droppedTurn });
    });
    await act(async () => {
      handler('hosted:turn:phase')({ phase: 'idle', turnId: audienceTurn, reason: 'speech_timeout' });
    });
    expect(mockSocket.emit).not.toHaveBeenCalledWith('hosted:speech:done', { turnId: droppedTurn, status: 'aborted' });
    await act(async () => {
      handler('hosted:turn:phase')({ phase: 'listening', turnId: droppedTurn });
    });
    expect(mockSocket.emit).not.toHaveBeenCalledWith('hosted:speech:done', { turnId: droppedTurn, status: 'aborted' });
    await act(async () => {
      handler('hosted:turn:phase')({ phase: 'idle', turnId: droppedTurn, reason: 'speech_timeout' });
    });
    expect(pause).toHaveBeenCalled();
    expect(mockSocket.emit).toHaveBeenCalledWith('hosted:speech:done', { turnId: droppedTurn, status: 'aborted' });
    pause.mockRestore();

    const cancelledTurn = '44444444-4444-4444-8444-444444444444';
    await act(async () => {
      handler('hosted:turn:tts')({ target: 'audience', audio: 'QQ==', mimeType: 'audio/wav', turnId: cancelledTurn });
    });
    await act(async () => { handler('hosted:session:ended')({ reason: 'host_ended' }); });
    expect(mockSocket.emit).toHaveBeenCalledWith('hosted:speech:done', { turnId: cancelledTurn, status: 'aborted' });
    play.mockRestore();
  });
});