Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

20.9 KB
Raw Blame
/** Exercises `render` + `userEvent` under the jsdom substrate (precedent #43). */

import { FileTree } from '@pierre/trees';
import { FileTree as PierreFileTree } from '@pierre/trees/react';
import { act, cleanup, render, screen, waitFor } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import { useRef, useState } from 'react';
import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
import { Input } from '@/components/ui/input';
import { revealActiveRow } from './file-tree-reveal';
import { useSelectionMirror } from './use-selection-mirror';

interface StubItem {
  getPath: () => string;
  isSelected: () => boolean;
  select: () => void;
  deselect: () => void;
  isExpanded: () => boolean;
  expand: () => void;
  focus: () => void;
  isDirectory: () => boolean;
  getFocusCount: () => number;
}

type ExpansionOnlyModel = Omit<StubModel, 'addPath'>;

interface StubModel {
  getItem: (path: string) => StubItem | null;
  getSelectedPaths: () => string[];
  getFocusedPath: () => string | null;
  getFileTreeContainer: () => undefined;
  scrollToPath: () => void;
  addPath: (path: string) => void;
}

function makeStubModel(paths: string[]): StubModel {
  const items = new Map<string, StubItem>();
  let focusedPath: string | null = null;
  const addPath = (p: string) => {
    let selected = false;
    let focusCount = 0;
    items.set(p, {
      getPath: () => p,
      isSelected: () => selected,
      select: () => {
        selected = true;
      },
      deselect: () => {
        selected = false;
      },
      isExpanded: () => false,
      expand: () => {},
      focus: () => {
        focusCount += 1;
        focusedPath = p;
      },
      isDirectory: () => false,
      getFocusCount: () => focusCount,
    });
  };
  for (const p of paths) {
    addPath(p);
  }
  return {
    getItem: (path: string) => items.get(path) ?? null,
    getSelectedPaths: () =>
      Array.from(items.entries())
        .filter(([, it]) => it.isSelected())
        .map(([p]) => p),
    getFocusedPath: () => focusedPath,
    getFileTreeContainer: () => undefined,
    scrollToPath: () => {},
    addPath,
  };
}

interface HarnessModel {
  getItem: (path: string) => unknown;
  getSelectedPaths: () => readonly string[];
  getFocusedPath: () => string | null;
}

function Harness({ initialPath, model }: { initialPath: string | null; model: HarnessModel }) {
  const [activeTreePath, setActiveTreePath] = useState<string | null>(initialPath);
  const [treePathsSignature, setTreePathsSignature] = useState('initial');
  const suppressSelectionRef = useRef(false);

  useSelectionMirror(
    // biome-ignore lint/suspicious/noExplicitAny: Tier-3 stub for the test budget; production callers always pass real Pierre models.
    model as any,
    activeTreePath,
    '',
    suppressSelectionRef,
    treePathsSignature,
    { activeSelectionId: activeTreePath, ready: true },
  );

  return (
    <>
      <button
        type="button"
        data-testid="repopulate"
        onClick={() => setTreePathsSignature((previous) => `${previous}+`)}
      >
        repopulate
      </button>
      <button type="button" data-testid="set-A" onClick={() => setActiveTreePath('A.md')}>
        A
      </button>
      <button type="button" data-testid="set-B" onClick={() => setActiveTreePath('B.md')}>
        B
      </button>
      <button type="button" data-testid="set-null" onClick={() => setActiveTreePath(null)}>
        none
      </button>
      <button
        type="button"
        data-testid="set-absent"
        onClick={() => setActiveTreePath('.hidden/absent.md')}
      >
        absent
      </button>
      <span data-testid="selected">{model.getSelectedPaths().join(',')}</span>
    </>
  );
}

function MountedMirror({
  model,
  activePath,
  revision,
  secondModel,
}: {
  model: FileTree;
  activePath: string;
  revision: string;
  secondModel?: FileTree;
}) {
  const suppressSelectionRef = useRef(false);
  useSelectionMirror(model, activePath, '', suppressSelectionRef, revision, {
    activeSelectionId: activePath,
    ready: true,
  });
  return (
    <>
      <Input aria-label="Editor control" />
      <PierreFileTree model={model} />
      {secondModel && <PierreFileTree model={secondModel} />}
    </>
  );
}

function mountedRow(model: FileTree, path: string): HTMLElement {
  const row = model
    .getFileTreeContainer()
    ?.shadowRoot?.querySelector<HTMLElement>(`[role="treeitem"][data-item-path="${path}"]`);
  if (!row) throw new Error(`Tree row is not mounted: ${path}`);
  return row;
}

async function focusMountedRow(model: FileTree, path: string): Promise<void> {
  await waitFor(() => mountedRow(model, path));
  await act(async () => mountedRow(model, path).focus());
  expect(model.getFileTreeContainer()?.shadowRoot?.activeElement).toBe(mountedRow(model, path));
}

describe('FileTree selection-mirror (Tier-3 mount)', () => {
  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;

  beforeEach(() => {
    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
  });

  afterEach(() => {
    cleanup();
    consoleErrorSpy.mockRestore();
  });

  test('initial mount selects the active path', () => {
    const model = makeStubModel(['A.md', 'B.md', 'C.md']);
    render(<Harness initialPath="A.md" model={model} />);

    expect(model.getSelectedPaths()).toEqual(['A.md']);
  });

  test('userEvent.click → singleton-mirror invariant on activeTreePath switch', async () => {
    const model = makeStubModel(['A.md', 'B.md', 'C.md']);
    render(<Harness initialPath="A.md" model={model} />);

    expect(model.getSelectedPaths()).toEqual(['A.md']);

    const user = userEvent.setup();
    await user.click(screen.getByTestId('set-B'));

    expect(model.getSelectedPaths()).toEqual(['B.md']);
  });

  test('clicking the null-button clears all selection', async () => {
    const model = makeStubModel(['A.md', 'B.md', 'C.md']);
    render(<Harness initialPath="A.md" model={model} />);

    expect(model.getSelectedPaths()).toEqual(['A.md']);

    const user = userEvent.setup();
    await user.click(screen.getByTestId('set-null'));

    expect(model.getSelectedPaths()).toEqual([]);
  });

  test('navigating to a doc with no visible tree row deselects the previous row', async () => {
    const model = makeStubModel(['A.md', 'B.md', 'C.md']);
    render(<Harness initialPath="A.md" model={model} />);

    expect(model.getSelectedPaths()).toEqual(['A.md']);

    const user = userEvent.setup();
    await user.click(screen.getByTestId('set-absent'));

    expect(model.getSelectedPaths()).toEqual([]);
  });

  test('absent active row still expands visible ancestors while clearing stale selection', () => {
    let parentExpanded = false;
    let parentExpandCallCount = 0;
    let otherSelected = true;
    const items = new Map<string, StubItem>([
      [
        'parent/',
        {
          getPath: () => 'parent/',
          isSelected: () => false,
          select: () => {},
          deselect: () => {},
          isExpanded: () => parentExpanded,
          expand: () => {
            parentExpanded = true;
            parentExpandCallCount += 1;
          },
          focus: () => {},
          isDirectory: () => true,
          getFocusCount: () => 0,
        },
      ],
      [
        'other.md',
        {
          getPath: () => 'other.md',
          isSelected: () => otherSelected,
          select: () => {
            otherSelected = true;
          },
          deselect: () => {
            otherSelected = false;
          },
          isExpanded: () => false,
          expand: () => {},
          focus: () => {},
          isDirectory: () => false,
          getFocusCount: () => 0,
        },
      ],
    ]);
    const model: ExpansionOnlyModel = {
      getItem: (path: string) => items.get(path) ?? null,
      getSelectedPaths: () =>
        Array.from(items.entries())
          .filter(([, it]) => it.isSelected())
          .map(([p]) => p),
      getFocusedPath: () => null,
      getFileTreeContainer: () => undefined,
      scrollToPath: () => {},
    };
    function PartiallyHiddenHarness() {
      const suppressSelectionRef = useRef(false);
      useSelectionMirror(
        // biome-ignore lint/suspicious/noExplicitAny: Tier-3 stub for the test budget; production callers always pass real Pierre models.
        model as any,
        'parent/.hidden-child.md',
        'parent/',
        suppressSelectionRef,
        '',
        { activeSelectionId: 'parent/child', ready: true },
      );
      return null;
    }
    render(<PartiallyHiddenHarness />);

    expect(parentExpandCallCount).toBe(1);
    expect(parentExpanded).toBe(true);
    expect(model.getSelectedPaths()).toEqual([]);
  });

  test('non-empty activeAncestorTreePathsSignature expands every collapsed ancestor', () => {
    let parentExpanded = false;
    let parentExpandCallCount = 0;
    const items = new Map<string, StubItem>([
      [
        'parent/',
        {
          getPath: () => 'parent/',
          isSelected: () => false,
          select: () => {},
          deselect: () => {},
          isExpanded: () => parentExpanded,
          expand: () => {
            parentExpanded = true;
            parentExpandCallCount += 1;
          },
          focus: () => {},
          isDirectory: () => true,
          getFocusCount: () => 0,
        },
      ],
      [
        'parent/child.md',
        {
          getPath: () => 'parent/child.md',
          isSelected: () => false,
          select: () => {},
          deselect: () => {},
          isExpanded: () => false,
          expand: () => {},
          focus: () => {},
          isDirectory: () => false,
          getFocusCount: () => 0,
        },
      ],
    ]);
    const model: ExpansionOnlyModel = {
      getItem: (path: string) => items.get(path) ?? null,
      getSelectedPaths: () => [],
      getFocusedPath: () => null,
      getFileTreeContainer: () => undefined,
      scrollToPath: () => {},
    };
    function AncestorHarness() {
      const suppressSelectionRef = useRef(false);
      useSelectionMirror(
        // biome-ignore lint/suspicious/noExplicitAny: Tier-3 stub for the test budget; production callers always pass real Pierre models.
        model as any,
        'parent/child.md',
        'parent/',
        suppressSelectionRef,
        '',
        { activeSelectionId: 'parent/child', ready: true },
      );
      return null;
    }
    render(<AncestorHarness />);

    expect(parentExpandCallCount).toBe(1);
    expect(parentExpanded).toBe(true);
  });

  test('preserves deliberate multi-selection when activeTreePath is already among the selected paths', () => {
    const model = makeStubModel(['A.md', 'B.md', 'C.md']);
    model.getItem('A.md')?.select();
    model.getItem('B.md')?.select();
    model.getItem('C.md')?.select();

    render(<Harness initialPath="A.md" model={model} />);

    expect(model.getSelectedPaths()).toContain('A.md');
    expect(model.getSelectedPaths()).toContain('B.md');
    expect(model.getSelectedPaths()).toContain('C.md');
    expect(model.getItem('A.md')?.getFocusCount()).toBe(1);
  });

  test('singleton-collapse still fires when activeTreePath is absent from a multi-selection (true navigation)', async () => {
    const model = makeStubModel(['A.md', 'B.md', 'C.md']);
    model.getItem('B.md')?.select();
    model.getItem('C.md')?.select();

    render(<Harness initialPath="A.md" model={model} />);

    expect(model.getSelectedPaths()).toEqual(['A.md']);
  });

  test('a repopulation re-run leaves keyboard focus on the row the user focused', async () => {
    const user = userEvent.setup();
    const model = makeStubModel(['A.md', 'B.md', 'folder/']);
    render(<Harness initialPath="A.md" model={model} />);

    model.getItem('folder/')?.focus();
    expect(model.getFocusedPath()).toBe('folder/');
    const activeFocusCountBefore = model.getItem('A.md')?.getFocusCount();

    await user.click(screen.getByTestId('repopulate'));

    expect(model.getFocusedPath()).toBe('folder/');
    expect(model.getItem('A.md')?.getFocusCount()).toBe(activeFocusCountBefore);
    expect(model.getSelectedPaths()).toEqual(['A.md']);
  });

  test('a true activation still claims focus even while another row holds it', async () => {
    const user = userEvent.setup();
    const model = makeStubModel(['A.md', 'B.md', 'folder/']);
    render(<Harness initialPath="A.md" model={model} />);

    model.getItem('folder/')?.focus();
    expect(model.getFocusedPath()).toBe('folder/');

    await user.click(screen.getByTestId('set-B'));

    expect(model.getFocusedPath()).toBe('B.md');
  });

  test('a real drop of the focused row leaves focus where @pierre/trees resolves it', async () => {
    const user = userEvent.setup();
    const model = new FileTree({ paths: ['A.md', 'afolder/x.md', 'zfolder/sibling.md'] });
    model.getItem('zfolder/')?.expand();
    render(<Harness initialPath="A.md" model={model} />);

    model.getItem('zfolder/sibling.md')?.focus();
    expect(model.getFocusedPath()).toBe('zfolder/sibling.md');

    model.resetPaths(['A.md', 'afolder/x.md']);
    const fallback = model.getFocusedPath();
    expect(fallback).not.toBeNull();
    expect(fallback).not.toBe('A.md');

    await user.click(screen.getByTestId('repopulate'));

    expect(model.getFocusedPath()).toBe(fallback);
    expect(model.getSelectedPaths()).toEqual(['A.md']);
  });

  test('a late open row is selected without taking focus from the file tree', async () => {
    const model = new FileTree({ paths: ['folder/', 'B.md'] });
    const { rerender } = render(
      <MountedMirror model={model} activePath="A.md" revision="before-arrival" />,
    );
    await focusMountedRow(model, 'folder/');
    expect(model.getFocusedPath()).toBe('folder/');
    expect(model.getSelectedPaths()).toEqual([]);

    await act(async () => model.resetPaths(['folder/', 'A.md', 'B.md']));
    rerender(<MountedMirror model={model} activePath="A.md" revision="after-arrival" />);

    await waitFor(() => expect(model.getSelectedPaths()).toEqual(['A.md']));
    expect(model.getFocusedPath()).toBe('folder/');
    expect(model.getFileTreeContainer()?.shadowRoot?.activeElement).toBe(
      mountedRow(model, 'folder/'),
    );
  });

  test('a returning open row leaves keyboard focus on the file row in use', async () => {
    const model = new FileTree({ paths: ['folder/', 'A.md', 'B.md'] });
    const { rerender } = render(
      <MountedMirror model={model} activePath="A.md" revision="initial" />,
    );
    await waitFor(() => expect(model.getSelectedPaths()).toEqual(['A.md']));
    await act(async () => model.resetPaths(['folder/', 'B.md']));
    rerender(<MountedMirror model={model} activePath="A.md" revision="missing" />);
    await focusMountedRow(model, 'folder/');

    await act(async () => model.resetPaths(['folder/', 'A.md', 'B.md']));
    rerender(<MountedMirror model={model} activePath="A.md" revision="returned" />);

    await waitFor(() => expect(model.getSelectedPaths()).toEqual(['A.md']));
    expect(model.getFocusedPath()).toBe('folder/');
    expect(model.getFileTreeContainer()?.shadowRoot?.activeElement).toBe(
      mountedRow(model, 'folder/'),
    );
  });

  test('a late open row becomes the entry point while editor focus stays outside', async () => {
    const model = new FileTree({ paths: ['folder/', 'B.md'] });
    const { rerender } = render(
      <MountedMirror model={model} activePath="A.md" revision="before-arrival" />,
    );
    await focusMountedRow(model, 'folder/');
    const editor = screen.getByRole('textbox', { name: 'Editor control' });
    await act(async () => editor.focus());

    await act(async () => model.resetPaths(['folder/', 'A.md', 'B.md']));
    rerender(<MountedMirror model={model} activePath="A.md" revision="after-arrival" />);

    await waitFor(() => expect(model.getSelectedPaths()).toEqual(['A.md']));
    expect(model.getFocusedPath()).toBe('A.md');
    expect(document.activeElement).toBe(editor);
  });

  test('a late open row leaves a second tree in control of DOM focus', async () => {
    const model = new FileTree({ paths: ['folder/', 'B.md'] });
    const secondModel = new FileTree({ paths: ['Project/skill.md'] });
    const { rerender } = render(
      <MountedMirror
        model={model}
        activePath="A.md"
        revision="before-arrival"
        secondModel={secondModel}
      />,
    );
    await focusMountedRow(secondModel, 'Project/');

    await act(async () => model.resetPaths(['folder/', 'A.md', 'B.md']));
    rerender(
      <MountedMirror
        model={model}
        activePath="A.md"
        revision="after-arrival"
        secondModel={secondModel}
      />,
    );

    await waitFor(() => expect(model.getSelectedPaths()).toEqual(['A.md']));
    expect(model.getFocusedPath()).toBe('A.md');
    expect(document.activeElement).toBe(secondModel.getFileTreeContainer());
    expect(secondModel.getFileTreeContainer()?.shadowRoot?.activeElement).toBe(
      mountedRow(secondModel, 'Project/'),
    );
  });

  test('a true activation focuses its row while the file tree owns DOM focus', async () => {
    const model = new FileTree({ paths: ['folder/', 'A.md', 'B.md'] });
    const { rerender } = render(
      <MountedMirror model={model} activePath="A.md" revision="initial" />,
    );
    await focusMountedRow(model, 'folder/');

    rerender(<MountedMirror model={model} activePath="B.md" revision="initial" />);

    await waitFor(() => expect(model.getSelectedPaths()).toEqual(['B.md']));
    expect(model.getFocusedPath()).toBe('B.md');
    await waitFor(() =>
      expect(model.getFileTreeContainer()?.shadowRoot?.activeElement).toBe(
        mountedRow(model, 'B.md'),
      ),
    );
  });

  test('re-activating a document after the active path was cleared claims keyboard focus', async () => {
    const user = userEvent.setup();
    const model = makeStubModel(['folder/', 'A.md', 'B.md']);
    render(<Harness initialPath="A.md" model={model} />);

    await user.click(screen.getByTestId('set-null'));
    expect(model.getSelectedPaths()).toEqual([]);

    model.getItem('folder/')?.focus();
    expect(model.getFocusedPath()).toBe('folder/');

    await user.click(screen.getByTestId('set-A'));

    expect(model.getFocusedPath()).toBe('A.md');
    expect(model.getSelectedPaths()).toEqual(['A.md']);
  });

  test('a real drop of a nested focused row leaves focus on the surviving folder, not the first row', async () => {
    const user = userEvent.setup();
    const model = new FileTree({
      paths: ['A.md', 'afolder/x.md', 'zfolder/nested.md', 'zfolder/sibling.md'],
    });
    model.getItem('afolder/')?.expand();
    model.getItem('zfolder/')?.expand();
    render(<Harness initialPath="A.md" model={model} />);

    model.getItem('zfolder/nested.md')?.focus();
    expect(model.getFocusedPath()).toBe('zfolder/nested.md');

    model.resetPaths(['A.md', 'afolder/x.md', 'zfolder/sibling.md']);
    const fallback = model.getFocusedPath();
    expect(fallback).toBe('zfolder/');

    await user.click(screen.getByTestId('repopulate'));

    expect(model.getFocusedPath()).toBe(fallback);
    expect(model.getSelectedPaths()).toEqual(['A.md']);
  });

  test('returning to a document after one with no tree row claims keyboard focus', async () => {
    const user = userEvent.setup();
    const model = makeStubModel(['A.md', 'B.md', 'folder/']);
    render(<Harness initialPath="A.md" model={model} />);

    model.getItem('folder/')?.focus();
    expect(model.getFocusedPath()).toBe('folder/');

    await user.click(screen.getByTestId('set-absent'));
    await user.click(screen.getByTestId('set-A'));

    expect(model.getFocusedPath()).toBe('A.md');
    expect(model.getSelectedPaths()).toEqual(['A.md']);
  });

  test('a suppressed claim also withholds the active row reveal, and an activation restores it', async () => {
    const user = userEvent.setup();
    const model = makeStubModel(['A.md', 'B.md', 'folder/']);
    render(<Harness initialPath="A.md" model={model} />);

    model.getItem('folder/')?.focus();
    await user.click(screen.getByTestId('repopulate'));

    const scrollAfterRepopulation = vi.fn();
    revealActiveRow(
      { getFocusedPath: () => model.getFocusedPath(), scrollToPath: scrollAfterRepopulation },
      'A.md',
    );
    expect(scrollAfterRepopulation).not.toHaveBeenCalled();

    await user.click(screen.getByTestId('set-B'));

    const scrollAfterActivation = vi.fn();
    revealActiveRow(
      { getFocusedPath: () => model.getFocusedPath(), scrollToPath: scrollAfterActivation },
      'B.md',
    );
    expect(scrollAfterActivation).toHaveBeenCalledTimes(1);
  });

  test('unmount drains the queueMicrotask cleanup without React post-unmount warning', async () => {
    const model = makeStubModel(['A.md', 'B.md', 'C.md']);
    const { unmount } = render(<Harness initialPath="A.md" model={model} />);

    expect(model.getSelectedPaths()).toEqual(['A.md']);

    unmount();
    await Promise.resolve();
    await Promise.resolve();

    const sawPostUnmountWarning = consoleErrorSpy.mock.calls.some((call: unknown[]) => {
      const message = call[0];
      return typeof message === 'string' && /unmount(ed)? component/i.test(message);
    });
    expect(sawPostUnmountWarning).toBe(false);
  });
});