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.

20.1 KB
Raw Blame
import type { DatabaseOpsError } from '@service-storage/databases';
import {
  cleanup,
  fireEvent,
  render,
  screen,
  waitFor,
} from '@solidjs/testing-library';
import { err, errAsync, okAsync, type Result, ResultAsync } from 'neverthrow';
import { createSignal } from 'solid-js';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import type { CreateTable, TableCreationResult } from '../core/table-creation';
import { TableNavigation } from './table-navigation';

vi.mock('../../../lib/core/mobile/isMobile', () => ({ isMobile: () => false }));
class ResizeObserverMock implements ResizeObserver {
  static instances: ResizeObserverMock[] = [];
  readonly targets = new Set<Element>();
  constructor(private readonly callback: ResizeObserverCallback) {
    ResizeObserverMock.instances.push(this);
  }
  observe(target: Element) {
    this.targets.add(target);
  }
  unobserve(target: Element) {
    this.targets.delete(target);
  }
  disconnect() {
    this.targets.clear();
  }
  resize(target: Element) {
    const contentRect = target.getBoundingClientRect();
    const size = {
      inlineSize: contentRect.width,
      blockSize: contentRect.height,
    };
    this.callback(
      [
        {
          target,
          contentRect,
          borderBoxSize: [size],
          contentBoxSize: [size],
          devicePixelContentBoxSize: [size],
        },
      ],
      this
    );
  }
}
let menuStyles: HTMLStyleElement;
beforeEach(() => {
  vi.stubGlobal('scrollTo', vi.fn());
  vi.stubGlobal('ResizeObserver', ResizeObserverMock);
  ResizeObserverMock.instances = [];
  // JSDOM reports an empty animation name; presence expects CSS's default none.
  menuStyles = document.createElement('style');
  menuStyles.textContent = '[role=menu] { animation-name: none; }';
  document.head.append(menuStyles);
});
afterEach(() => {
  cleanup();
  menuStyles.remove();
  vi.restoreAllMocks();
  vi.unstubAllGlobals();
});

function navigation(onCreate: CreateTable, onSelect = vi.fn()) {
  render(() => (
    <TableNavigation
      tables={[{ id: 'tasks', name: 'Tasks' }]}
      activeTableId="tasks"
      canCreate
      onCreate={onCreate}
      onSelect={onSelect}
    />
  ));
  return onSelect;
}

async function openNewTable() {
  fireEvent.keyDown(screen.getByRole('button', { name: 'Add table or form' }), {
    key: 'Enter',
  });
  fireEvent.keyDown(
    await screen.findByRole('menuitem', { name: 'New table' }),
    { key: 'Enter' }
  );
}

describe('table creation and navigation', () => {
  it('renames an inactive tab by double click even when the first click refreshes table objects', async () => {
    const [tables, setTables] = createSignal([
      { id: 'tasks', name: 'Tasks' },
      { id: 'people', name: 'People' },
    ]);
    const [active, setActive] = createSignal('tasks');
    const rename = vi.fn(() => okAsync(undefined));
    render(() => (
      <TableNavigation
        tables={tables()}
        activeTableId={active()}
        canCreate
        onCreate={vi.fn<CreateTable>()}
        onSelect={(id) => {
          setActive(id);
          setTables((current) => current.map((table) => ({ ...table })));
        }}
        onRename={rename}
      />
    ));
    const tab = screen.getByRole('tab', { name: 'People' });
    fireEvent.click(tab, { detail: 1 });
    expect(screen.getByRole('tab', { name: 'People' })).toBe(tab);
    fireEvent.click(tab, { detail: 2 });
    fireEvent.dblClick(tab);
    const name = await screen.findByLabelText('Table name');
    expect((name as HTMLInputElement).value).toBe('People');
    fireEvent.input(name, { target: { value: 'Members' } });
    expect(screen.queryByRole('dialog')).toBeNull();
    expect(name.closest('[role=tablist]')).toBeTruthy();
    fireEvent.keyDown(name, { key: 'Enter' });
    await waitFor(() =>
      expect(rename).toHaveBeenCalledExactlyOnceWith(
        'people',
        'Members',
        'People'
      )
    );
  });

  it('opens the targeted table menu without selecting it and restores focus after rename cancellation', async () => {
    const select = vi.fn();
    render(() => (
      <TableNavigation
        tables={[
          { id: 'tasks', name: 'Tasks' },
          { id: 'people', name: 'People' },
        ]}
        activeTableId="tasks"
        canCreate
        onCreate={vi.fn<CreateTable>()}
        onSelect={select}
        onRename={vi.fn(() => okAsync(undefined))}
      />
    ));
    const tab = screen.getByRole('tab', { name: 'People' });
    fireEvent.contextMenu(tab, { clientX: 100, clientY: 40 });
    fireEvent(
      await screen.findByRole('menuitem', { name: /Rename table/ }),
      new MouseEvent('pointerup', { button: 0, bubbles: true })
    );
    const name = await screen.findByLabelText('Table name');
    await waitFor(() => expect(document.activeElement).toBe(name));
    await waitFor(() =>
      expect(screen.queryByRole('menu', { hidden: true })).toBeNull()
    );
    expect((name as HTMLInputElement).value).toBe('People');
    expect(select).not.toHaveBeenCalled();
    fireEvent.keyDown(name, { key: 'Escape' });
    await waitFor(() => expect(document.activeElement).toBe(tab));
    expect(select).not.toHaveBeenCalled();
    expect(screen.queryByRole('menuitem', { name: /Delete/ })).toBeNull();
  });

  it('supports keyboard context menus and F2 on the focused table', async () => {
    render(() => (
      <TableNavigation
        tables={[{ id: 'tasks', name: 'Tasks' }]}
        activeTableId="tasks"
        canCreate
        onCreate={vi.fn<CreateTable>()}
        onSelect={vi.fn()}
        onRename={vi.fn(() => okAsync(undefined))}
      />
    ));
    const tab = screen.getByRole('tab', { name: 'Tasks' });
    tab.focus();
    fireEvent.keyDown(tab, { key: 'F10', shiftKey: true });
    const rename = await screen.findByRole('menuitem', {
      name: /Rename table/,
    });
    fireEvent.keyDown(rename, { key: 'Enter' });
    const name = await screen.findByLabelText('Table name');
    fireEvent.keyDown(name, { key: 'Escape' });
    await waitFor(() => expect(document.activeElement).toBe(tab));
    fireEvent.keyDown(tab, { key: 'F2' });
    expect(await screen.findByLabelText('Table name')).toBeTruthy();
  });

  it('saves a renamed table on blur without taking focus back', async () => {
    const rename = vi.fn(() => okAsync(undefined));
    render(() => (
      <>
        <TableNavigation
          tables={[{ id: 'tasks', name: 'Tasks' }]}
          activeTableId="tasks"
          canCreate
          onCreate={vi.fn<CreateTable>()}
          onSelect={vi.fn()}
          onRename={rename}
        />
        <button type="button">Next control</button>
      </>
    ));
    fireEvent.dblClick(screen.getByRole('tab', { name: 'Tasks' }));
    const name = await screen.findByLabelText('Table name');
    await waitFor(() => expect(document.activeElement).toBe(name));
    expect((name as HTMLInputElement).selectionStart).toBe(0);
    expect((name as HTMLInputElement).selectionEnd).toBe('Tasks'.length);
    fireEvent.input(name, { target: { value: 'Projects' } });
    expect(fireEvent.keyDown(name, { key: 'Tab' })).toBe(true);
    const next = screen.getByRole('button', { name: 'Next control' });
    next.focus();
    await waitFor(() =>
      expect(rename).toHaveBeenCalledExactlyOnceWith(
        'tasks',
        'Projects',
        'Tasks'
      )
    );
    await waitFor(() =>
      expect(screen.queryByLabelText('Table name')).toBeNull()
    );
    expect(document.activeElement).toBe(next);
    expect(screen.queryByRole('button', { name: /Rename table/ })).toBeNull();
  });

  it('keeps a failed rename draft for retry through refreshed table data', async () => {
    const [tables, setTables] = createSignal([
      { id: 'tasks', name: 'Tasks' },
      { id: 'people', name: 'People' },
    ]);
    const rename = vi
      .fn()
      .mockReturnValueOnce(
        errAsync([{ code: 'NETWORK_ERROR', message: 'Offline' }])
      )
      .mockReturnValueOnce(okAsync(undefined));
    render(() => (
      <TableNavigation
        tables={tables()}
        activeTableId="tasks"
        canCreate
        onCreate={vi.fn<CreateTable>()}
        onSelect={vi.fn()}
        onRename={rename}
      />
    ));
    const tab = screen.getByRole('tab', { name: 'People' });
    fireEvent.dblClick(tab);
    const name = await screen.findByLabelText('Table name');
    fireEvent.input(name, { target: { value: 'Team' } });
    fireEvent.keyDown(name, { key: 'Enter' });
    expect((await screen.findByRole('alert')).textContent).toBe(
      'Could not rename this table. Its name may have changed. Check your connection, or reopen Rename table and try again.'
    );
    setTables((current) => current.map((table) => ({ ...table })));
    expect(screen.getByLabelText('Table name')).toBe(name);
    expect((name as HTMLInputElement).value).toBe('Team');
    fireEvent.keyDown(name, { key: 'Enter' });
    await waitFor(() =>
      expect(screen.queryByLabelText('Table name')).toBeNull()
    );
    expect(rename).toHaveBeenNthCalledWith(2, 'people', 'Team', 'People');
    await waitFor(() => expect(document.activeElement).toBe(tab));
  });

  it('rejects duplicate names and lets Escape discard the inline draft', async () => {
    const rename = vi.fn(() => okAsync(undefined));
    render(() => (
      <TableNavigation
        tables={[
          { id: 'tasks', name: 'Tasks' },
          { id: 'people', name: 'People' },
        ]}
        activeTableId="tasks"
        canCreate
        onCreate={vi.fn<CreateTable>()}
        onSelect={vi.fn()}
        onRename={rename}
      />
    ));
    const tab = screen.getByRole('tab', { name: 'Tasks' });
    fireEvent.keyDown(tab, { key: 'F2' });
    const name = await screen.findByLabelText('Table name');
    fireEvent.input(name, { target: { value: ' people ' } });
    fireEvent.keyDown(name, { key: 'Enter' });
    expect((await screen.findByRole('alert')).textContent).toContain(
      'A table with this name already exists.'
    );
    expect(rename).not.toHaveBeenCalled();
    fireEvent.keyDown(name, { key: 'Escape' });
    expect(screen.queryByLabelText('Table name')).toBeNull();
    await waitFor(() => expect(document.activeElement).toBe(tab));
    expect(rename).not.toHaveBeenCalled();
  });

  it('keeps restored, selected, and newly created tabs visible when the rail narrows', async () => {
    const [tables, setTables] = createSignal([
      { id: 'people', name: 'People' },
      { id: 'tasks', name: 'Tasks' },
    ]);
    const [active, setActive] = createSignal('tasks');
    render(() => (
      <TableNavigation
        tables={tables()}
        activeTableId={active()}
        canCreate
        onCreate={vi.fn<CreateTable>()}
        onSelect={setActive}
      />
    ));
    const rail = screen.getByRole('tablist', { name: 'Database tables' });
    let width = 100;
    vi.spyOn(rail, 'getBoundingClientRect').mockImplementation(
      () => new DOMRect(0, 0, width, 36)
    );
    const positionTab = (name: string, left: number) => {
      const tab = screen.getByRole('tab', { name });
      vi.spyOn(tab, 'getBoundingClientRect').mockImplementation(
        () => new DOMRect(left - rail.scrollLeft, 0, 70, 32)
      );
      return tab;
    };
    const people = positionTab('People', 0);
    positionTab('Tasks', 120);
    await waitFor(() => expect(rail.scrollLeft).toBe(90));

    fireEvent.click(people);
    await waitFor(() => expect(rail.scrollLeft).toBe(0));
    setTables((current) => [...current, { id: 'projects', name: 'Projects' }]);
    await screen.findByRole('tab', { name: 'Projects' });
    positionTab('Projects', 240);
    setActive('projects');
    await waitFor(() => expect(rail.scrollLeft).toBe(210));

    width = 80;
    const observer = ResizeObserverMock.instances.find((entry) =>
      entry.targets.has(rail)
    );
    expect(observer).toBeDefined();
    for (const entry of ResizeObserverMock.instances) {
      if (entry.targets.has(rail)) entry.resize(rail);
    }
    expect(rail.scrollLeft).toBe(230);
    expect(
      screen.getByRole('button', { name: 'Add table or form' })
    ).toBeTruthy();
  });

  it('focuses the name, validates duplicates, creates the named table and opens it', async () => {
    const create = vi.fn<CreateTable>(() =>
      okAsync({ tableId: 'projects', ready: true })
    );
    const select = navigation(create);
    expect(
      screen.getByRole('tab', { name: 'Tasks' }).getAttribute('aria-selected')
    ).toBe('true');
    await openNewTable();
    const name = await screen.findByLabelText('Table name');
    await waitFor(() => expect(document.activeElement).toBe(name));
    fireEvent.input(name, { target: { value: ' tasks ' } });
    fireEvent.submit(name.closest('form')!);
    expect(create).not.toHaveBeenCalled();
    expect(
      screen.getByText(
        'A table with this name already exists. Try another name.'
      )
    ).toBeTruthy();
    fireEvent.input(name, { target: { value: ' Projects ' } });
    fireEvent.submit(name.closest('form')!);
    await waitFor(() => expect(select).toHaveBeenCalledWith('projects'));
    expect(create).toHaveBeenCalledWith('Projects', undefined);
    await waitFor(() =>
      expect(screen.queryByLabelText('Table name')).toBeNull()
    );
  });

  it('saves an inline table draft on blur and cancels an empty one', async () => {
    const create = vi.fn<CreateTable>(() =>
      okAsync({ tableId: 'projects', ready: true })
    );
    const select = navigation(create);
    await openNewTable();
    fireEvent.blur(await screen.findByLabelText('Table name'));
    expect(screen.queryByLabelText('Table name')).toBeNull();
    expect(create).not.toHaveBeenCalled();
    await openNewTable();
    const name = await screen.findByLabelText('Table name');
    fireEvent.input(name, { target: { value: 'Projects' } });
    fireEvent.blur(name);
    await waitFor(() => expect(select).toHaveBeenCalledWith('projects'));
    expect(create).toHaveBeenCalledExactlyOnceWith('Projects', undefined);
  });

  it('keeps the draft after a failed create and prevents double submission', async () => {
    let settle: (
      result: Result<TableCreationResult, DatabaseOpsError>
    ) => void = () => {};
    const create = vi.fn<CreateTable>(
      () =>
        new ResultAsync(
          new Promise((resolve) => {
            settle = resolve;
          })
        )
    );
    navigation(create);
    await openNewTable();
    const name = await screen.findByLabelText('Table name');
    fireEvent.input(name, { target: { value: 'Projects' } });
    fireEvent.submit(name.closest('form')!);
    fireEvent.submit(name.closest('form')!);
    expect(create).toHaveBeenCalledTimes(1);
    settle(err({ code: 'NETWORK_ERROR', message: 'Offline', refusal: null }));
    expect((await screen.findByRole('alert')).textContent).toBe(
      'Could not create this table. Check your connection and try again.'
    );
    expect((name as HTMLInputElement).value).toBe('Projects');
    expect((name as HTMLInputElement).readOnly).toBe(false);
  });

  it('resumes setup for the already-created table instead of creating another', async () => {
    const create = vi
      .fn<CreateTable>()
      .mockReturnValueOnce(
        okAsync({
          tableId: 'projects',
          ready: false,
          message: 'Your table was created. Retry setup.',
        })
      )
      .mockReturnValueOnce(okAsync({ tableId: 'projects', ready: true }));
    const select = navigation(create);
    await openNewTable();
    const name = await screen.findByLabelText('Table name');
    fireEvent.input(name, { target: { value: 'Projects' } });
    fireEvent.submit(name.closest('form')!);
    await screen.findByRole('alert');
    expect((name as HTMLInputElement).readOnly).toBe(true);
    expect(select).not.toHaveBeenCalled();
    fireEvent.submit(name.closest('form')!);
    await waitFor(() => expect(select).toHaveBeenCalledWith('projects'));
    expect(create).toHaveBeenLastCalledWith('Projects', 'projects');
  });

  it('restores focus on cancel and focuses the name when reopening', async () => {
    navigation(vi.fn<CreateTable>());
    const trigger = screen.getByRole('button', { name: 'Add table or form' });
    await openNewTable();
    const draft = await screen.findByLabelText('Table name');
    expect(draft.closest('[role=tablist]')).toBeTruthy();
    expect(screen.queryByRole('dialog')).toBeNull();
    fireEvent.keyDown(draft, { key: 'Escape' });
    await waitFor(() => expect(document.activeElement).toBe(trigger));
    await openNewTable();
    const name = await screen.findByLabelText('Table name');
    await waitFor(() => expect(document.activeElement).toBe(name));
  });
});

describe('dragging tabs', () => {
  function tabGeometry() {
    const lefts: Record<string, number> = {
      Tasks: 0,
      People: 100,
      Notes: 200,
    };
    vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(
      function (this: HTMLElement) {
        if (this.getAttribute('role') === 'tablist')
          return new DOMRect(0, 0, 300, 32);
        const name = this.querySelector('[role=tab]')?.textContent ?? '';
        const left = lefts[name];
        return left === undefined
          ? new DOMRect(0, 0, 0, 0)
          : new DOMRect(left, 0, 100, 32);
      }
    );
  }
  const tables = [
    { id: 'tasks', name: 'Tasks' },
    { id: 'people', name: 'People' },
    { id: 'notes', name: 'Notes' },
  ];

  it('drops a dragged tab after the one under the pointer, showing where it lands', async () => {
    tabGeometry();
    const reorder = vi.fn();
    render(() => (
      <TableNavigation
        tables={tables}
        activeTableId="tasks"
        canCreate
        onCreate={vi.fn<CreateTable>()}
        onSelect={vi.fn()}
        onRename={vi.fn(() => okAsync(undefined))}
        onReorder={reorder}
      />
    ));
    const tasks = screen.getByRole('tab', { name: 'Tasks' });
    fireEvent.mouseDown(tasks, { button: 0, clientX: 40, clientY: 16 });
    // The near half of the next tab is still the original slot.
    fireEvent.mouseMove(document, { clientX: 130, clientY: 16 });
    expect(document.querySelector('[data-tab-drop-indicator]')).toBeNull();
    fireEvent.mouseMove(document, { clientX: 180, clientY: 16 });
    await waitFor(() => {
      const line = document.querySelector<HTMLElement>(
        '[data-tab-drop-indicator]'
      );
      expect(line?.dataset.dropTarget).toBe('people');
      expect(line?.dataset.dropEdge).toBe('after');
      expect(line?.style.left).toBe('200px');
    });
    fireEvent.mouseUp(document, { button: 0, clientX: 180, clientY: 16 });
    expect(reorder).toHaveBeenCalledExactlyOnceWith([
      'people',
      'tasks',
      'notes',
    ]);
    expect(document.querySelector('[data-tab-drop-indicator]')).toBeNull();
  });

  it('cancels a tab drag on Escape without reordering', async () => {
    tabGeometry();
    const reorder = vi.fn();
    render(() => (
      <TableNavigation
        tables={tables}
        activeTableId="tasks"
        canCreate
        onCreate={vi.fn<CreateTable>()}
        onSelect={vi.fn()}
        onReorder={reorder}
      />
    ));
    const notes = screen.getByRole('tab', { name: 'Notes' });
    fireEvent.mouseDown(notes, { button: 0, clientX: 240, clientY: 16 });
    fireEvent.mouseMove(document, { clientX: 20, clientY: 16 });
    await waitFor(() =>
      expect(
        document.querySelector<HTMLElement>('[data-tab-drop-indicator]')
          ?.dataset.dropEdge
      ).toBe('before')
    );
    fireEvent.keyDown(document, { key: 'Escape' });
    expect(document.querySelector('[data-tab-drop-indicator]')).toBeNull();
    fireEvent.mouseUp(document, { button: 0, clientX: 20, clientY: 16 });
    expect(reorder).not.toHaveBeenCalled();
  });

  it('does not start a drag for viewers who cannot edit', () => {
    tabGeometry();
    const reorder = vi.fn();
    render(() => (
      <TableNavigation
        tables={tables}
        activeTableId="tasks"
        canCreate={false}
        onCreate={vi.fn<CreateTable>()}
        onSelect={vi.fn()}
        onReorder={reorder}
      />
    ));
    const tasks = screen.getByRole('tab', { name: 'Tasks' });
    fireEvent.mouseDown(tasks, { button: 0, clientX: 40, clientY: 16 });
    fireEvent.mouseMove(document, { clientX: 180, clientY: 16 });
    fireEvent.mouseUp(document, { button: 0, clientX: 180, clientY: 16 });
    expect(document.querySelector('[data-tab-drop-indicator]')).toBeNull();
    expect(reorder).not.toHaveBeenCalled();
  });
});