Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

12.3 KB
Raw Blame
import React from 'react';
import { RecoilRoot } from 'recoil';
import { useForm } from 'react-hook-form';
import { render, screen, fireEvent } from '@testing-library/react';
import type { SteeringControls } from '@librechat/chat/react';
import type { ShortcutOverride } from '~/store/misc';
import { ComposerHostTestProvider } from 'test/composerHost';
import { WatchedDuringRunSendButton } from '../watched';
import store from '~/store';

jest.mock('@librechat/client', () => ({
  ...jest.requireActual('@librechat/client'),
  useLocalize: () => (key: string) => key,
}));

/**
 * Renders the hovercard eagerly. Ariakit's real show path depends on pointer
 * geometry, which jsdom reports as zeros — driving it from a test asserts
 * Ariakit's hover behavior rather than which rows this component disables.
 */
jest.mock('@ariakit/react', () => ({
  HovercardProvider: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
  HovercardAnchor: ({ render }: { render: React.ReactElement }) => render,
  Hovercard: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
}));

const TEXT = 'stop, do not run that command';

const mockInterruptSteer = jest.fn(() => true);
const mockSteerFromComposer = jest.fn(() => true);
const mockQueueFromComposer = jest.fn(() => true);
const mockInterruptAndSend = jest.fn(() => true);
const mockOnConsumed = jest.fn();

type StubOptions = {
  pausedOnApproval?: boolean;
  canSteer?: boolean;
  canControlGeneration?: boolean;
};

const steeringStub = ({
  pausedOnApproval = false,
  canSteer = true,
  canControlGeneration = true,
  steerInterruptsByDefault = false,
}: StubOptions & { steerInterruptsByDefault?: boolean }) => {
  const preferredAction = steerInterruptsByDefault ? 'interrupt' : 'steer';
  return {
    effectiveAction: canSteer ? preferredAction : 'queue',
    canSteer,
    canControlGeneration,
    pausedOnApproval,
    interruptSteer: mockInterruptSteer,
    steerFromComposer: mockSteerFromComposer,
    queueFromComposer: mockQueueFromComposer,
    interruptAndSend: mockInterruptAndSend,
  } as unknown as SteeringControls;
};

function Harness({
  steering,
  isNewConversation,
  enterToSend,
  disabled = false,
}: {
  steering: SteeringControls;
  isNewConversation: boolean;
  enterToSend: boolean;
  disabled?: boolean;
}) {
  const methods = useForm<{ text: string }>({ defaultValues: { text: TEXT } });
  return (
    <ComposerHostTestProvider>
      <WatchedDuringRunSendButton
        control={methods.control}
        steering={steering}
        isNewConversation={isNewConversation}
        getText={() => TEXT}
        onConsumed={mockOnConsumed}
        enterToSend={enterToSend}
        disabled={disabled}
      />
    </ComposerHostTestProvider>
  );
}

type MenuOptions = StubOptions & {
  enterInterrupts?: boolean;
  enterToSend?: boolean;
  shortcutsEnabled?: boolean;
  customShortcuts?: Record<string, ShortcutOverride>;
  isNewConversation?: boolean;
};

function openMenu(options: MenuOptions = {}) {
  const {
    enterInterrupts = false,
    enterToSend = true,
    shortcutsEnabled = true,
    customShortcuts = {},
    isNewConversation = false,
    ...stub
  } = options;
  render(
    <RecoilRoot
      initializeState={({ set }) => {
        set(store.shortcutsEnabled, shortcutsEnabled);
        set(store.customShortcuts, customShortcuts);
      }}
    >
      <Harness
        steering={steeringStub({ ...stub, steerInterruptsByDefault: enterInterrupts })}
        enterToSend={enterToSend}
        isNewConversation={isNewConversation}
      />
    </RecoilRoot>,
  );
  expect(screen.getByText('com_ui_interrupt_steer')).toBeInTheDocument();
}

beforeEach(() => {
  jest.clearAllMocks();
});

describe('DuringRunSendButton — external hold', () => {
  test('holds every open hovercard action and restores them when the hold lifts', () => {
    const controls = steeringStub({});
    const frame = (disabled: boolean) => (
      <RecoilRoot>
        <Harness steering={controls} isNewConversation={false} enterToSend disabled={disabled} />
      </RecoilRoot>
    );
    const view = render(frame(false));
    const labels = ['com_ui_steer', 'com_ui_queue', 'com_ui_interrupt_steer'];
    view.rerender(frame(true));
    expect(screen.getByTestId('during-run-send-button')).toBeDisabled();
    for (const label of labels) {
      const row = screen.getByText(label).closest('button') as HTMLButtonElement;
      expect(row).toHaveAttribute('aria-disabled', 'true');
      expect(row.querySelector('kbd')).toBeNull();
      fireEvent.click(row);
    }
    expect(mockInterruptSteer).not.toHaveBeenCalled();
    expect(mockSteerFromComposer).not.toHaveBeenCalled();
    expect(mockQueueFromComposer).not.toHaveBeenCalled();
    expect(mockInterruptAndSend).not.toHaveBeenCalled();
    expect(mockOnConsumed).not.toHaveBeenCalled();
    view.rerender(frame(false));
    const queue = screen.getByText('com_ui_queue').closest('button') as HTMLButtonElement;
    expect(queue).toHaveAttribute('aria-disabled', 'false');
    fireEvent.click(queue);
    expect(mockQueueFromComposer).toHaveBeenCalledWith(TEXT);
    expect(mockOnConsumed).toHaveBeenCalledTimes(1);
  });
});

describe('DuringRunSendButton — Interrupt & steer availability', () => {
  /**
   * `useSteering.interruptSteer` hard-refuses while a run is paused for tool
   * approval, so a live row would silently do nothing at exactly the moment a
   * user is trying to stop a tool call.
   */
  test('disables Interrupt & steer while the run is paused on tool approval', () => {
    openMenu({ pausedOnApproval: true, canSteer: false });

    const row = screen.getByText('com_ui_interrupt_steer').closest('button');
    expect(row).toHaveAttribute('aria-disabled', 'true');

    fireEvent.click(row as HTMLButtonElement);
    expect(mockInterruptSteer).not.toHaveBeenCalled();
    expect(mockOnConsumed).not.toHaveBeenCalled();
  });

  test('keeps Interrupt disabled until the first conversation can be steered', () => {
    openMenu({ canSteer: false, isNewConversation: true });
    const row = screen.getByText('com_ui_interrupt_steer').closest('button');
    expect(row).toHaveAttribute('aria-disabled', 'true');
    fireEvent.click(row as HTMLButtonElement);
    expect(mockInterruptSteer).not.toHaveBeenCalled();
    expect(mockOnConsumed).not.toHaveBeenCalled();
  });

  test('the ordinary Steer row stays gated on canSteer', () => {
    openMenu({ pausedOnApproval: false, canSteer: false });

    const row = screen.getByText('com_ui_steer').closest('button');
    expect(row).toHaveAttribute('aria-disabled', 'true');

    fireEvent.click(row as HTMLButtonElement);
    expect(mockSteerFromComposer).not.toHaveBeenCalled();
  });

  test('keeps Queue live but disables every generation mutation before the epoch arrives', () => {
    openMenu({ canSteer: false, canControlGeneration: false });

    expect(screen.getByText('com_ui_steer').closest('button')).toHaveAttribute(
      'aria-disabled',
      'true',
    );
    expect(screen.getByText('com_ui_interrupt_steer').closest('button')).toHaveAttribute(
      'aria-disabled',
      'true',
    );

    const queue = screen.getByText('com_ui_queue').closest('button') as HTMLButtonElement;
    expect(queue).toHaveAttribute('aria-disabled', 'false');
    fireEvent.click(queue);
    expect(mockQueueFromComposer).toHaveBeenCalledWith(TEXT);
    expect(mockOnConsumed).toHaveBeenCalled();
    expect(mockInterruptSteer).not.toHaveBeenCalled();
    expect(mockInterruptAndSend).not.toHaveBeenCalled();
  });

  test('both actions are available during a normal run', () => {
    openMenu({ pausedOnApproval: false, canSteer: true });

    expect(screen.getByText('com_ui_interrupt_steer').closest('button')).toHaveAttribute(
      'aria-disabled',
      'false',
    );
    expect(screen.getByText('com_ui_steer').closest('button')).toHaveAttribute(
      'aria-disabled',
      'false',
    );
  });
});

/**
 * With `steerInterruptsByDefault` on, plain Enter routes through
 * `submitDuringRun` and PREEMPTS, while the ordinary Steer row deliberately
 * stays non-preempting when clicked. The ⏎ hint therefore cannot sit on the
 * Steer row — it would advertise a key that does something else.
 */
describe('DuringRunSendButton — Enter hint follows the interrupt preference', () => {
  const kbdFor = (label: string) =>
    screen.getByText(label).closest('button')?.querySelector('kbd')?.textContent ?? null;

  test('Enter is advertised on Steer when the preference is off', () => {
    openMenu({ canSteer: true, enterInterrupts: false });
    expect(kbdFor('com_ui_steer')).toBe('⏎');
    expect(kbdFor('com_ui_interrupt_steer')).not.toBe('⏎');
  });

  test('Enter moves to Interrupt & steer when the preference is on', () => {
    openMenu({ canSteer: true, enterInterrupts: true });
    expect(kbdFor('com_ui_interrupt_steer')).toBe('⏎');
    /** No key reaches the plain Steer row in this mode, so it advertises none. */
    expect(kbdFor('com_ui_steer')).toBeNull();
  });
});

/**
 * Hints come from the same decision table the composer executes
 * (`resolveComposerKeyDown`), so a chord that no longer triggers a row is
 * never advertised on it. Covers codex round 3: a chord rebound to an
 * editing-allowed global shortcut is yielded to the window-level handler,
 * and a submit rebound to Alt+Enter submits instead of interrupting.
 */
describe('DuringRunSendButton — hints follow the effective bindings', () => {
  const kbdFor = (label: string) =>
    screen.getByText(label).closest('button')?.querySelector('kbd')?.textContent ?? null;

  test('defaults advertise every chord', () => {
    openMenu({ canSteer: true });
    expect(kbdFor('com_ui_steer')).toBe('⏎');
    expect(kbdFor('com_ui_queue')).toBe('Ctrl ⏎');
    expect(kbdFor('com_ui_interrupt_steer')).toBe('Ctrl ⇧ ⏎');
    expect(screen.queryByText('com_ui_interrupt_send')).not.toBeInTheDocument();
  });

  test('drops a hint whose chord is rebound to a global shortcut', () => {
    openMenu({
      canSteer: true,
      customShortcuts: {
        focusSearch: { mac: 'Meta+Shift+Enter', other: 'Ctrl+Shift+Enter' },
      },
    });
    expect(kbdFor('com_ui_interrupt_steer')).toBe('Alt ⏎');
    expect(screen.queryByText('com_ui_interrupt_send')).not.toBeInTheDocument();
    expect(kbdFor('com_ui_queue')).toBe('Ctrl ⏎');
  });

  test('drops the Interrupt & send hint when submit is rebound to its chord', () => {
    openMenu({
      canSteer: true,
      customShortcuts: {
        submitMessage: { mac: 'Alt+Enter', other: 'Alt+Enter' },
      },
    });
    expect(screen.queryByText('com_ui_interrupt_send')).not.toBeInTheDocument();
    expect(kbdFor('com_ui_steer')).toBe('⏎');
    expect(kbdFor('com_ui_interrupt_steer')).toBe('Ctrl ⇧ ⏎');
  });

  test('a disabled row never advertises its chord', () => {
    openMenu({ pausedOnApproval: true, canSteer: false });
    /** Its action's own guard refuses the chord while paused on approval. */
    expect(kbdFor('com_ui_interrupt_steer')).toBeNull();
    /** The disabled Steer row drops its alternate-action hint the same way. */
    expect(kbdFor('com_ui_steer')).toBeNull();
    expect(screen.queryByText('com_ui_interrupt_send')).not.toBeInTheDocument();
  });

  test('moves the default-action hint to Ctrl+Enter when Enter-to-send is off', () => {
    openMenu({ canSteer: true, enterToSend: false });
    /** Plain Enter inserts a newline during a run in this mode; ⌘/Ctrl+Enter submits the default. */
    expect(kbdFor('com_ui_steer')).toBe('Ctrl ⏎');
    expect(kbdFor('com_ui_queue')).toBeNull();
    expect(kbdFor('com_ui_interrupt_steer')).toBe('Ctrl ⇧ ⏎');
    expect(screen.queryByText('com_ui_interrupt_send')).not.toBeInTheDocument();
  });

  test('keeps plain Enter but hides shortcut hints when shortcuts are disabled', () => {
    openMenu({ canSteer: true, shortcutsEnabled: false });
    expect(kbdFor('com_ui_steer')).toBe('⏎');
    expect(kbdFor('com_ui_queue')).toBeNull();
    expect(kbdFor('com_ui_interrupt_steer')).toBeNull();
    expect(screen.queryByText('com_ui_interrupt_send')).not.toBeInTheDocument();
  });
});

test('exposes exactly three modes in a stable order', () => {
  openMenu();
  const rows = screen
    .getAllByRole('button')
    .filter((button) => button.getAttribute('type') === 'button');
  expect(rows.map((row) => row.textContent?.replace(/Ctrl.*|Alt.*|⏎.*/g, '').trim())).toEqual([
    'com_ui_steer',
    'com_ui_interrupt_steer',
    'com_ui_queue',
  ]);
});