Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

23.8 KB
Raw Blame
import { REDUCED_CHROME_HEADER_HEIGHT } from '@inkeep/open-knowledge-core';
import * as actualLinguiMacro from '@lingui/react/macro';
import { act, cleanup, fireEvent, render, screen } from '@testing-library/react';
import { type ComponentProps, type ReactNode, useEffect, useState } from 'react';
import { renderToStaticMarkup } from 'react-dom/server';
import { afterEach, describe, expect, onTestFinished, test, vi } from 'vitest';
import { TooltipProvider } from '@/components/ui/tooltip';
import type { GitSyncStatus } from '@/hooks/use-git-sync-status';
import { ConfigContext } from '@/lib/config-context';
import { DEFAULT_DOCK_TREE, type DockNode } from '@/lib/dock-tree';
import {
  __resetPaneVisibilityStoreForTests,
  type PaneVisibility,
  paneVisibilityStore,
} from '@/lib/pane-visibility-store';
import {
  configContextWithTerminal,
  type ProjectTerminalSetting,
  TERMINAL_SETTING_UNSET,
} from '@/test-utils/config-context';
import {
  expectVisualClassTokens,
  expectVisualClassTokensAbsent,
} from '@/test-utils/visual-contract';
import { mockHeaderMetrics } from './EditorHeader.layout.test-helper';

vi.doMock('@lingui/react/macro', () => ({
  ...actualLinguiMacro,
  Trans: ({ children }: { children: ReactNode }) => <>{children}</>,
  useLingui: () => ({
    t: (strings: TemplateStringsArray, ...values: unknown[]) =>
      strings.reduce((acc, part, index) => `${acc}${part}${values[index] ?? ''}`, ''),
  }),
}));

let activeDocName: string | null = 'docs/notes';
let sidebarState: 'expanded' | 'collapsed' = 'expanded';
let singleFile = false;
let gitSyncStatus: Partial<GitSyncStatus> | null = null;
const syncToastsHookCalls: unknown[][] = [];
const syncToastsHosts = { mounted: 0 };
const gitSyncStatusReads = { count: 0 };

vi.doMock('@/editor/DocumentContext', () => ({
  useDocumentContext: () => ({
    activeDocName,
  }),
}));

vi.doMock('@/lib/single-file-mode', () => ({
  useSingleFileMode: () => singleFile,
}));

vi.doMock('@/components/ui/sidebar', () => ({
  useSidebar: () => ({ state: sidebarState }),
  SidebarTrigger: ({ className, ...props }: ComponentProps<'button'>) => (
    <button type="button" data-testid="sidebar-trigger" className={className} {...props}>
      sidebar
    </button>
  ),
}));

vi.doMock('@/components/AppMenubar', () => ({
  AppMenubar: () => <div data-testid="app-menubar" />,
}));

vi.doMock('./SyncStatusBadge', async () => ({
  ...(await vi.importActual<typeof import('./SyncStatusBadge')>('./SyncStatusBadge')),
  SyncStatusBadge: () => <div data-testid="sync-status-badge" />,
}));

vi.doMock('@/hooks/use-git-sync-status', () => ({
  useGitSyncStatusDetailed: () => {
    gitSyncStatusReads.count += 1;
    return { status: gitSyncStatus, fetchError: null };
  },
  useGitSyncStatus: () => gitSyncStatus,
}));

vi.doMock('@/presence/use-sync-toasts', () => ({
  useSyncToasts: (...args: unknown[]) => {
    syncToastsHookCalls.push(args);
    useEffect(() => {
      syncToastsHosts.mounted += 1;
      return () => {
        syncToastsHosts.mounted -= 1;
      };
    }, []);
  },
}));

vi.doMock('@/presence/PresenceBar', () => ({
  PresenceBar: () => <div data-testid="presence-bar" />,
}));

vi.doMock('./BetaBadge', () => ({
  BetaBadge: () => <div data-testid="beta-badge" />,
}));

vi.doMock('./HelpPopover', () => ({
  HelpPopover: () => <button type="button">Resources</button>,
}));

vi.doMock('./InstanceBadge', () => ({
  InstanceBadge: ({ className }: { className?: string }) => (
    <span data-testid="instance-badge" className={className} />
  ),
}));

function setElectronHost(enabled: boolean) {
  Object.defineProperty(window, 'okDesktop', {
    configurable: true,
    value: enabled ? {} : undefined,
  });
}

function setWindowsHost() {
  Object.defineProperty(window, 'okDesktop', {
    configurable: true,
    value: { menu: {}, platform: 'win32' },
  });
}

function setNoteHost() {
  Object.defineProperty(window, 'okDesktop', {
    configurable: true,
    value: { config: { mode: 'note' }, menu: {}, platform: 'win32' },
  });
}

let projectTerminal: ProjectTerminalSetting = TERMINAL_SETTING_UNSET;

const PANE_HIDDEN: PaneVisibility = { open: false, onScreen: false };
const PANE_SHOWN: PaneVisibility = { open: true, onScreen: true };

function publishPanes({ terminal = true }: { terminal?: boolean } = {}) {
  act(() => {
    paneVisibilityStore.publish({
      editor: null,
      agents: PANE_SHOWN,
      terminal: terminal ? PANE_HIDDEN : null,
    });
  });
}

async function renderHeader(tabs?: ReactNode) {
  const { EditorHeader } = await import('./EditorHeader');
  const tree = (nextTabs?: ReactNode) => (
    <ConfigContext value={configContextWithTerminal(projectTerminal)}>
      <TooltipProvider delayDuration={0}>
        <EditorHeader>{nextTabs}</EditorHeader>
      </TooltipProvider>
    </ConfigContext>
  );
  render(tree(tabs));
  return document.querySelector('header') as HTMLElement;
}

async function renderMeasuredHeader() {
  return await renderHeader(<div>tabs</div>);
}

const RESERVATION_PROPERTIES = [
  '--editor-header-leading-width',
  '--editor-header-trailing-width',
  '--editor-header-leading-offset',
] as const;

function reservationsOn(header: HTMLElement) {
  return RESERVATION_PROPERTIES.map((property) => header.style.getPropertyValue(property));
}

describe('EditorHeader runtime behavior', () => {
  afterEach(() => {
    cleanup();
    setElectronHost(false);
    activeDocName = 'docs/notes';
    sidebarState = 'expanded';
    singleFile = false;
    gitSyncStatus = null;
    syncToastsHookCalls.length = 0;
    syncToastsHosts.mounted = 0;
    gitSyncStatusReads.count = 0;
    projectTerminal = TERMINAL_SETTING_UNSET;
    __resetPaneVisibilityStoreForTests();
  });

  test('exports the EditorHeader component', async () => {
    const mod = await import('./EditorHeader');
    expect(typeof mod.EditorHeader).toBe('function');
  });

  test('a single-file editor card owns document identity and its information control', async () => {
    setElectronHost(true);
    singleFile = true;
    const { EditorHeader } = await import('./EditorHeader');
    render(
      <TooltipProvider delayDuration={0}>
        <EditorHeader trailing={<button type="button">Show document information</button>} />
      </TooltipProvider>,
    );

    const header = document.querySelector('[data-editor-header]') as HTMLElement;
    const tabs = header.querySelector('[data-editor-header-tabs]') as HTMLElement;
    const trailing = header.querySelector('[data-editor-header-trailing]') as HTMLElement;
    expect(tabs.textContent).toContain('docs');
    expect(tabs.textContent).toContain('notes');
    expect(
      trailing.contains(screen.getByRole('button', { name: 'Show document information' })),
    ).toBe(true);
    expect(header.querySelector('[data-editor-header-actions]')).toBeNull();
    expect(header.querySelector('[data-editor-header-leading-actions]')).toBeNull();
    expect(header.querySelector('[data-testid="header-pane-buttons"]')).toBeNull();
    expectVisualClassTokens(header.className, ['h-11']);
  });

  test('a note window alone keeps its reduced titlebar height', async () => {
    setNoteHost();
    const header = await renderHeader();
    expectVisualClassTokens(header.className, ['h-[var(--ok-reduced-chrome-header-height)]']);
    expect(header.style.getPropertyValue('--ok-reduced-chrome-header-height')).toBe(
      REDUCED_CHROME_HEADER_HEIGHT,
    );
  });

  test('a web project window tab row is a plain 44px row without window-drag treatment', async () => {
    setElectronHost(false);
    sidebarState = 'collapsed';
    const header = await renderHeader();

    expect(header.getAttribute('data-electron-drag')).toBeNull();
    expectVisualClassTokens(header.className, [
      'flex',
      'h-11',
      'shrink-0',
      'items-center',
      'bg-background',
    ]);
    expectVisualClassTokensAbsent(header.className, [
      'shadow-[inset_0_-1px_0_var(--border)]',
      'h-[var(--ok-reduced-chrome-header-height)]',
      '[-webkit-app-region:drag]',
      'pl-[var(--ok-titlebar-reserve-left,1rem)]',
    ]);
    expect(screen.queryByTestId('navigation-history-controls')).toBeNull();
  });

  for (const state of ['expanded', 'collapsed'] as const) {
    test(`an Electron project window tab row with the file list ${state} opts into the window drag region and holds only the tab strip`, async () => {
      setElectronHost(true);
      sidebarState = state;
      const header = await renderHeader(<div data-testid="editor-tabs">tabs</div>);
      const tabHost = header.querySelector('[data-editor-header-tabs]') as HTMLElement;

      expect(header.getAttribute('data-electron-drag')).toBe('');
      expectVisualClassTokens(header.className, ['h-11', '[-webkit-app-region:drag]']);
      expect(tabHost.getAttribute('data-electron-drag')).toBe('');
      expectVisualClassTokens(tabHost.className, ['[-webkit-app-region:drag]']);
      expectVisualClassTokensAbsent(tabHost.className, ['[-webkit-app-region:no-drag]']);
      expect(Array.from(header.children)).toEqual([tabHost]);
      expect(tabHost.contains(screen.getByTestId('editor-tabs'))).toBe(true);
      expect(header.querySelector('[data-editor-header-leading-actions]')).toBeNull();
      expect(header.querySelector('[data-editor-header-actions]')).toBeNull();
      expect(
        screen.queryByTestId('sidebar-trigger'),
        'the file list toggle rides in the first pane tab strip, not in header chrome laid over it',
      ).toBeNull();
      expect(screen.queryByRole('group', { name: 'Workspace navigation' })).toBeNull();
      expect(screen.queryByRole('button', { name: /^Search/ })).toBeNull();
      expect(screen.queryByRole('button', { name: 'Back' })).toBeNull();
      expect(screen.queryByRole('button', { name: 'Forward' })).toBeNull();
      expect(reservationsOn(header)).toEqual(['', '', '']);
    });
  }

  test('no window kind publishes leading or trailing width reservations for the tab strip', async () => {
    const restoreMetrics = mockHeaderMetrics({
      header: 1_000,
      leading: 224,
      leadingOffset: 78,
      trailing: 300,
    });
    try {
      for (const kind of ['project', 'single-file'] as const) {
        setElectronHost(true);
        sidebarState = 'collapsed';
        singleFile = kind === 'single-file';
        const header = await renderHeader(<div>tabs</div>);

        expect(reservationsOn(header), `${kind} window`).toEqual(['', '', '']);
        cleanup();
      }
    } finally {
      restoreMetrics();
    }
  });

  test('tabs paint on the first render, with no header chrome to measure first', async () => {
    const { EditorHeader } = await import('./EditorHeader');
    const markup = renderToStaticMarkup(
      <TooltipProvider delayDuration={0}>
        <EditorHeader>
          <div>restored tabs</div>
        </EditorHeader>
      </TooltipProvider>,
    );
    const container = document.createElement('div');
    container.innerHTML = markup;
    const tabHost = container.querySelector('[data-editor-header-tabs]') as HTMLElement;

    expectVisualClassTokensAbsent(tabHost.className, ['invisible']);
    expect(tabHost.hasAttribute('data-editor-header-tabs-suppressed')).toBe(false);
  });

  test('the tab strip is bounded by the editor column width, not padded around header chrome', async () => {
    const header = await renderHeader(<div>tabs</div>);
    const tabHost = header.querySelector('[data-editor-header-tabs]') as HTMLElement;

    expectVisualClassTokens(tabHost.className, [
      'w-[var(--editor-header-tabs-width,100%)]',
      'min-w-0',
      'overflow-hidden',
    ]);
    expectVisualClassTokensAbsent(tabHost.className, ['absolute', 'invisible']);
  });

  test('a Windows project window leaves the app menu to the app header', async () => {
    setWindowsHost();
    const header = await renderHeader();

    await act(async () => {});
    expect(screen.queryByTestId('app-menubar')).toBeNull();
    expect(header.querySelector('[data-editor-header-leading-actions]')).toBeNull();
  });
  test('a project window tab row carries none of the header actions, which moved to the app header', async () => {
    gitSyncStatus = { state: 'idle', conflictCount: 2, hasRemote: true };
    const restoreMetrics = mockHeaderMetrics({ header: 107, leading: 57, trailing: 218 });
    try {
      for (const state of ['expanded', 'collapsed'] as const) {
        sidebarState = state;
        const header = await renderMeasuredHeader();

        expect(header.querySelector('[data-editor-header-actions]')).toBeNull();
        expect(screen.queryByTestId('presence-bar')).toBeNull();
        expect(screen.queryByRole('button', { name: /^Share/ })).toBeNull();
        expect(screen.queryByTestId('sync-status-badge')).toBeNull();
        expect(screen.queryByRole('button', { name: 'Settings' })).toBeNull();
        expect(screen.queryByRole('button', { name: 'Resources' })).toBeNull();
        expect(screen.queryByTestId('beta-badge')).toBeNull();
        expect(screen.queryByTestId('instance-badge')).toBeNull();
        expect(screen.queryByTestId('header-overflow-actions-trigger')).toBeNull();
        expect(syncToastsHosts.mounted).toBe(0);
        expect(reservationsOn(header)).toEqual(['', '', '']);
        cleanup();
      }
    } finally {
      restoreMetrics();
    }
  });

  test('document card headers leave sync status to the shared header', async () => {
    gitSyncStatus = { state: 'idle', conflictCount: 0, hasRemote: true };

    await renderHeader();
    expect(gitSyncStatusReads.count).toBe(0);

    cleanup();
    singleFile = true;
    await renderHeader();
    expect(gitSyncStatusReads.count).toBe(0);
  });

  test('note windows put document context in the titlebar without Resources or sync chrome', async () => {
    setNoteHost();
    sidebarState = 'expanded';
    const restoreMetrics = mockHeaderMetrics({ header: 107, leading: 57, trailing: 218 });
    try {
      const { EditorHeader } = await import('./EditorHeader');
      render(
        <ConfigContext value={configContextWithTerminal(projectTerminal)}>
          <TooltipProvider delayDuration={0}>
            <EditorHeader noteModeToggle={<button type="button">mode switch</button>} />
          </TooltipProvider>
        </ConfigContext>,
      );

      const leadingZone = document.querySelector(
        '[data-editor-header-leading-actions]',
      ) as HTMLElement;
      const header = document.querySelector('header') as HTMLElement;
      expect(leadingZone.textContent).toContain('docs');
      expect(leadingZone.textContent).toContain('notes');
      expect(
        leadingZone.querySelector('[data-slot="breadcrumb-page"][aria-current="page"]')
          ?.textContent,
      ).toBe('notes');
      expectVisualClassTokens(header.className, ['bg-background']);
      expectVisualClassTokensAbsent(header.className, ['shadow-[inset_0_-1px_0_var(--border)]']);
      expectVisualClassTokens(leadingZone.className, [
        'left-[var(--ok-titlebar-reserve-left,1rem)]',
      ]);
      const modeToggle = document.querySelector('[data-note-window-mode-toggle]') as HTMLElement;
      expect(modeToggle.contains(screen.getByRole('button', { name: 'mode switch' }))).toBe(true);
      expectVisualClassTokensAbsent(modeToggle.className, [
        '[&_[data-slot=toggle-group]]:bg-transparent',
        '[&_[data-slot=toggle-group]]:p-0',
        '[&_[data-slot=toggle-group-item]]:size-8',
        '[&_[data-slot=toggle-group-item]]:shadow-none',
      ]);
      expect(screen.queryByRole('button', { name: 'Resources' })).toBeNull();
      expect(screen.queryByTestId('sync-status-badge')).toBeNull();
      expect(screen.queryByTestId('presence-bar')).toBeNull();
      expect(screen.queryByTestId('beta-badge')).toBeNull();
      expect(screen.queryByTestId('app-menubar')).toBeNull();
      expect(
        screen.queryByRole('button', { name: 'More actions' }),
        'a note window has no trailing actions to collapse, so a cramped header must not grow an overflow trigger',
      ).toBeNull();
      expect(document.querySelector('[data-header-overflow-actions]')).toBeNull();
    } finally {
      restoreMetrics();
    }
  });

  test('a note window has no chat or terminal, so it shows no Agents or Terminal buttons even when panes are published', async () => {
    setNoteHost();
    publishPanes();
    const { EditorHeader } = await import('./EditorHeader');
    render(
      <ConfigContext value={configContextWithTerminal(projectTerminal)}>
        <TooltipProvider delayDuration={0}>
          <EditorHeader />
        </TooltipProvider>
      </ConfigContext>,
    );

    expect(document.querySelector('[data-editor-header-actions]')).not.toBeNull();
    expect(screen.queryByRole('group', { name: 'Panels' })).toBeNull();
    expect(screen.queryByTestId('header-pane-divider')).toBeNull();
    expect(screen.queryByRole('button', { name: 'Agents' })).toBeNull();
    expect(screen.queryByRole('button', { name: 'Terminal' })).toBeNull();
  });

  test('a project window tab row leaves the Agents and Terminal buttons to the app header', async () => {
    publishPanes();
    const header = await renderHeader(<div>tabs</div>);

    expect(header.querySelector('[data-testid="header-pane-buttons"]')).toBeNull();
    expect(screen.queryByRole('group', { name: 'Panels' })).toBeNull();
    expect(screen.queryByRole('button', { name: 'Agents' })).toBeNull();
    expect(screen.queryByRole('button', { name: 'Terminal' })).toBeNull();
  });

  test('dragging the tab row onto the middle of the Agents panel trades the editor and the Agents panel', async () => {
    const { DockWorkspace } = await import('./DockWorkspace');
    const { EditorHeader } = await import('./EditorHeader');
    const rects = vi
      .spyOn(HTMLElement.prototype, 'getBoundingClientRect')
      .mockImplementation(function (this: HTMLElement) {
        const [width, height] = this.hasAttribute('data-dock-workspace') ? [1200, 800] : [0, 0];
        return {
          x: 0,
          y: 0,
          top: 0,
          left: 0,
          right: width,
          bottom: height,
          width,
          height,
          toJSON() {},
        } as DOMRect;
      });
    onTestFinished(() => rects.mockRestore());
    function Workspace() {
      const [tree, setTree] = useState<DockNode>(DEFAULT_DOCK_TREE);
      return (
        <ConfigContext value={configContextWithTerminal(projectTerminal)}>
          <TooltipProvider delayDuration={0}>
            <DockWorkspace
              tree={tree}
              visible={{ editor: true, agents: true, terminal: true }}
              units={{
                editor: (
                  <EditorHeader>
                    <div data-testid="editor-tabs">tabs</div>
                  </EditorHeader>
                ),
                agents: <div>Agents</div>,
                terminal: <div>Terminal</div>,
              }}
              gap={8}
              minExtent={() => ({ width: 100, height: 100 })}
              paneLabel={(pane) => pane}
              onTreeChange={setTree}
              redockable
            />
          </TooltipProvider>
        </ConfigContext>
      );
    }
    render(<Workspace />);
    const placed = (pane: string) => {
      const style = document.querySelector<HTMLElement>(`[data-dock-unit="${pane}"]`)?.style;
      return {
        start: Number.parseFloat(style?.insetInlineStart ?? ''),
        top: Number.parseFloat(style?.insetBlockStart ?? ''),
        width: Number.parseFloat(style?.width ?? ''),
        height: Number.parseFloat(style?.height ?? ''),
      };
    };
    const editor = placed('editor');
    const agents = placed('agents');
    expect(editor.width).toBeGreaterThan(0);
    expect(agents.start).toBeGreaterThan(editor.start);
    const middle = {
      clientX: agents.start + agents.width / 2,
      clientY: agents.top + agents.height / 2,
    };
    const tabs = screen.getByTestId('editor-tabs');

    fireEvent.pointerDown(tabs, { button: 0, buttons: 1, pointerId: 3, clientX: 20, clientY: 10 });
    fireEvent.pointerMove(tabs, { buttons: 1, pointerId: 3, ...middle });
    fireEvent.pointerUp(tabs, { pointerId: 3, ...middle });

    expect(placed('editor')).toEqual(agents);
    expect(placed('agents')).toEqual(editor);
  });

  test('renders workspace tabs between the global action zones', async () => {
    await renderHeader(<div data-testid="editor-tabs">tabs</div>);

    const tabHost = document.querySelector('[data-editor-header-tabs]');
    expect(tabHost?.contains(screen.getByTestId('editor-tabs'))).toBe(true);
    expect(screen.queryByTestId('open-in-agent-menu')).toBeNull();
    expect(screen.queryByText('projectName')).toBeNull();
    expect(screen.queryByText('assetFileName')).toBeNull();
  });

  test('a project window tab row holds its trailing slot after the tab strip, a drag region whose controls opt out', async () => {
    setElectronHost(true);
    const { EditorHeader } = await import('./EditorHeader');
    render(
      <TooltipProvider delayDuration={0}>
        <EditorHeader trailing={<button type="button">toggle</button>}>
          <div data-testid="editor-tabs">tabs</div>
        </EditorHeader>
      </TooltipProvider>,
    );
    const header = document.querySelector('header') as HTMLElement;
    const tabHost = header.querySelector('[data-editor-header-tabs]') as HTMLElement;
    const trailing = header.querySelector('[data-editor-header-trailing]') as HTMLElement;

    expect(Array.from(header.children)).toEqual([tabHost, trailing]);
    expect(trailing.contains(screen.getByRole('button', { name: 'toggle' }))).toBe(true);
    expect(trailing.getAttribute('data-electron-drag')).toBe('');
    expectVisualClassTokens(trailing.className, [
      'absolute',
      'inset-y-0',
      'end-0',
      '[-webkit-app-region:drag]',
      '[&_button]:[-webkit-app-region:no-drag]',
      '[&_a]:[-webkit-app-region:no-drag]',
    ]);
    expectVisualClassTokensAbsent(trailing.className, ['pe-9', 'shrink-0']);
    expectVisualClassTokens(tabHost.className, [
      'min-w-0',
      'w-[var(--editor-header-tabs-width,100%)]',
    ]);
  });

  test('a project window tab row shows its trailing slot only while the row is at least 240px wide', async () => {
    const { EditorHeader } = await import('./EditorHeader');
    render(
      <TooltipProvider delayDuration={0}>
        <EditorHeader trailing={<button type="button">toggle</button>}>
          <div data-testid="editor-tabs">tabs</div>
        </EditorHeader>
      </TooltipProvider>,
    );
    const header = document.querySelector('header') as HTMLElement;
    const trailing = header.querySelector('[data-editor-header-trailing]') as HTMLElement;

    expect(trailing.contains(screen.getByRole('button', { name: 'toggle' }))).toBe(true);
    expectVisualClassTokens(header.className, ['@container/editor-header']);
    expectVisualClassTokens(trailing.className, ['hidden', '@[15rem]/editor-header:flex']);
    expectVisualClassTokensAbsent(trailing.className, ['flex']);
  });

  test('a project window tab row tells the last tab group how wide its trailing slot is, only while the slot shows', async () => {
    const { EditorHeader } = await import('./EditorHeader');
    const view = render(
      <TooltipProvider delayDuration={0}>
        <EditorHeader trailing={<button type="button">toggle</button>}>
          <div data-testid="editor-tabs">tabs</div>
        </EditorHeader>
      </TooltipProvider>,
    );
    const header = document.querySelector('header') as HTMLElement;
    const tabHost = header.querySelector('[data-editor-header-tabs]') as HTMLElement;
    expectVisualClassTokens(tabHost.className, [
      '@[15rem]/editor-header:[--editor-header-trailing-width:2rem]',
    ]);
    expect(header.className).not.toContain('--editor-header-trailing-width');
    expect(header.style.getPropertyValue('--editor-header-trailing-width')).toBe('');
    view.unmount();

    render(
      <TooltipProvider delayDuration={0}>
        <EditorHeader>
          <div data-testid="editor-tabs">tabs</div>
        </EditorHeader>
      </TooltipProvider>,
    );
    const bare = document.querySelector('[data-editor-header-tabs]') as HTMLElement;
    expect(bare.className).not.toContain('--editor-header-trailing-width');
  });
});