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.

17.3 KB
Raw Blame
import {
  PROPERTY_OPTION_IDS,
  SYSTEM_PROPERTY_IDS,
} from '@property/identifiers';
import type { Property } from '@property/types';
import {
  cleanup,
  fireEvent,
  render,
  screen,
  waitFor,
} from '@solidjs/testing-library';
import { createSignal, For, type JSX, type ParentProps } from 'solid-js';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import {
  type ProjectRow,
  type ProjectsContext,
  ProjectsProvider,
} from '../context/projects-context';
import type { ProjectAccess } from '../core/project';
import { createProjectCollection } from '../primitives/project-collection';
import { ProjectsCollection } from './projects-collection';

const toast = vi.hoisted(() => ({ success: vi.fn(), failure: vi.fn() }));
const device = vi.hoisted(() => ({ mobile: false }));
const ganttFlag = vi.hoisted(() => ({
  enabled: (): boolean | undefined => true,
}));
vi.mock('@core/component/Toast/Toast', () => ({ toast }));
vi.mock('@core/mobile/isMobile', () => ({ isMobile: () => device.mobile }));
// Touch timing is covered by the directive; a test event stands in for it.
vi.mock('@core/directive/touchHandler', () => ({
  touchHandler: (
    element: HTMLElement,
    options: () => { onLongPress?: () => void }
  ) =>
    element.addEventListener('test-long-press', () =>
      options().onLongPress?.()
    ),
}));

// The shell, list engine, and row cells have their own coverage; this suite
// exercises what a row's context menu does to the list.
vi.mock('@app/components/view-shell', () => ({
  ViewShell: {
    Header: (props: ParentProps) => props.children,
    Content: (props: ParentProps) => props.children,
  },
  SearchBar: () => null,
  ListSortDropdown: () => null,
  ListGroupDropdown: () => null,
  ListFilterDropdown: () => null,
  ListFilterCountBadge: () => null,
  ViewLayoutDropdown: (props: {
    label: string;
    layouts: ('list' | 'board' | 'gantt')[];
    value: string;
    onChange: (layout: 'list' | 'board' | 'gantt') => void;
  }) => (
    <div role="group" aria-label={props.label}>
      <For each={props.layouts}>
        {(layout) => (
          <button
            type="button"
            aria-pressed={props.value === layout}
            onClick={() => props.onChange(layout)}
          >
            {layout}
          </button>
        )}
      </For>
    </div>
  ),
  useViewControlHotkeys: () => {},
}));
vi.mock('@app/components/view-shell/ListHeader', () => ({
  ListHeader: (props: ParentProps) => props.children,
  ListHeaderSearch: () => null,
}));
vi.mock('@app/components/view-shell/SidebarCreateButton', () => ({
  SidebarCreateButton: () => null,
}));
vi.mock('@app/components/list/ListViewport', () => ({
  ListViewport: <T,>(props: {
    items: readonly T[];
    children: (item: T) => JSX.Element;
  }) => <For each={props.items}>{(item) => props.children(item)}</For>,
}));
vi.mock('@app/components/list', () => ({
  useListInteractions: () => ({
    selection: { set: vi.fn(), toggle: vi.fn(), clear: vi.fn() },
  }),
}));
vi.mock(
  '@app/features/tasks-view/components/task-list/TaskGroupHeader',
  () => ({ TaskGroupHeader: () => null })
);
vi.mock('@entity/EntitySelectionToolbarModal', () => ({
  EntitySelectionToolbarModal: () => null,
}));
vi.mock('@entity', () => ({
  InlineEntity: (props: { entity: { name: string } }) => props.entity.name,
}));
// Rows portal their property editors, as the real cells do.
vi.mock('../components/project-row', async () => {
  const { Portal } = await import('solid-js/web');
  return {
    ProjectListHeader: () => null,
    ProjectRow: (props: {
      rowId: string;
      row: ProjectRow;
      highlighted: boolean;
    }) => (
      <div role="row" id={props.rowId} data-highlighted={props.highlighted}>
        {props.row.project.name}
        <Portal>
          <button type="button">Edit {props.row.project.name}</button>
        </Portal>
      </div>
    ),
  };
});

let animationStyle: HTMLStyleElement;
beforeEach(() => {
  vi.spyOn(window, 'scrollTo').mockImplementation(() => {});
  vi.stubGlobal(
    'ResizeObserver',
    class {
      observe() {}
      unobserve() {}
      disconnect() {}
    }
  );
  Object.defineProperty(HTMLElement.prototype, 'scrollIntoView', {
    configurable: true,
    value: vi.fn(),
  });
  animationStyle = document.createElement('style');
  animationStyle.textContent = '* { animation-name: none !important; }';
  document.head.append(animationStyle);
});
afterEach(() => {
  cleanup();
  device.mobile = false;
  ganttFlag.enabled = () => true;
  vi.unstubAllGlobals();
  animationStyle.remove();
  vi.restoreAllMocks();
  vi.clearAllMocks();
});

function selectProperty(
  id: string,
  displayName: string,
  options: [string, string][],
  value: string[] | null = null
): Property {
  return {
    propertyId: `${id}-value`,
    propertyDefinitionId: id,
    displayName,
    isMultiSelect: false,
    owner: { scope: 'system' },
    createdAt: '',
    updatedAt: '',
    valueType: 'SELECT_STRING',
    value,
    options: options.map(([optionId, label], index) => ({
      id: optionId,
      value: { type: 'string', value: label },
      display_order: index,
      color: null,
      property_definition_id: id,
      created_at: '',
      updated_at: '',
    })),
  };
}

const statusOptions: [string, string][] = [
  [PROPERTY_OPTION_IDS.STATUS.NOT_STARTED, 'Not Started'],
  [PROPERTY_OPTION_IDS.STATUS.COMPLETED, 'Completed'],
];
const status = selectProperty(
  SYSTEM_PROPERTY_IDS.STATUS,
  'Status',
  statusOptions
);
const priority = selectProperty(SYSTEM_PROPERTY_IDS.PRIORITY, 'Priority', [
  [PROPERTY_OPTION_IDS.PRIORITY.HIGH, 'High'],
]);

function project(
  id: string,
  name: string,
  access: ProjectAccess | undefined,
  properties: Property[] = []
): ProjectRow {
  return {
    project: {
      id,
      name,
      updatedAt: '',
      access,
    },
    properties,
  };
}

function commands() {
  return {
    createTask: vi.fn(async () => null),
    pending: () => false,
    create: vi.fn(),
    rename: vi.fn(async (_id: string, _name: string) => {}),
    setMembers: vi.fn(async () => {}),
    assignTasks: vi.fn(async () => []),
    delete: vi.fn(async (_id: string) => {}),
    deleteMany: vi.fn(async (_ids: readonly string[]): Promise<string[]> => []),
    saveProperty: vi.fn(async () => {}),
    saveProperties: vi.fn(async () => {}),
  } satisfies ReturnType<ProjectsContext['createCommands']>;
}

function setup(
  rows: readonly ProjectRow[],
  options: {
    canOpenInNewSplit?: boolean;
    properties?: Property[];
    layout?: 'list' | 'gantt';
  } = {}
) {
  const service = commands();
  const unused = (): never => {
    throw new Error('Unused capability');
  };
  const context: ProjectsContext = {
    userId: () => 'viewer',
    createCollectionSource: () => ({
      rows: () => rows,
      loading: () => false,
      error: () => undefined,
      hasMore: () => false,
      loadingMore: () => false,
      loadMore: async () => {},
      refresh: async () => {},
    }),
    createProjectSource: unused,
    createPropertyDefinitionsSource: () => ({
      properties: () => options.properties ?? [status, priority],
      loading: () => false,
      error: () => undefined,
    }),
    createCommands: () => service,
  };
  const host = {
    onOpen: vi.fn(),
    onCopyLink: vi.fn(),
    onCopyId: vi.fn(),
    onShare: vi.fn(),
  };
  let collection!: ReturnType<typeof createProjectCollection>;
  const view = render(() => {
    collection = createProjectCollection({
      createSource: context.createCollectionSource,
      userId: context.userId,
      initialState: {
        search: '',
        layout: options.layout,
        status: '',
        priority: '',
        dueBefore: '',
        dueAfter: '',
        mine: false,
        sort: 'updated',
        groupBy: 'none',
        scrollOffset: 0,
        collapsedGroupIds: [],
      },
    });
    return (
      <ProjectsProvider context={context}>
        <ProjectsCollection
          {...host}
          onCreate={vi.fn()}
          scopeId="projects"
          isActive={() => true}
          collection={collection}
          ganttEnabled={ganttFlag.enabled() === true}
          createAssigneeName={(id) => id}
          canOpenInNewSplit={() => options.canOpenInNewSplit ?? true}
        />
      </ProjectsProvider>
    );
  });
  const rowKey = (id: string) => {
    const item = collection
      .items()
      .find((row) => row.kind === 'entity' && row.entity.id === id);
    if (!item) throw new Error(`No row for ${id}`);
    return item.id;
  };
  return { ...view, service, host, collection, rowKey };
}

async function openMenu(name: string) {
  expect(
    fireEvent.contextMenu(screen.getByText(name), { clientX: 20, clientY: 20 })
  ).toBe(false);
  await screen.findByRole('menu');
}

const entries = () =>
  screen
    .getAllByRole('menuitem')
    .map((item) => item.firstChild?.textContent ?? '');

function choose(name: string | RegExp) {
  fireEvent.keyDown(screen.getByRole('menuitem', { name }), { key: 'Enter' });
}

describe('project Gantt rollout', () => {
  it('derives List while loading or disabled without overwriting saved Gantt', () => {
    const [enabled, setEnabled] = createSignal<boolean | undefined>(undefined);
    ganttFlag.enabled = enabled;
    const view = setup([project('launch', 'Launch', 'owner')], {
      layout: 'gantt',
    });
    expect(view.collection.layout()).toBe('gantt');
    expect(screen.getByRole('row', { name: 'Launch' })).toBeTruthy();
    expect(
      screen.getByRole('button', { name: 'list' }).getAttribute('aria-pressed')
    ).toBe('true');
    expect(screen.queryByRole('button', { name: 'gantt' })).toBeNull();

    setEnabled(true);
    expect(
      screen.getByRole('button', { name: 'gantt' }).getAttribute('aria-pressed')
    ).toBe('true');
    setEnabled(false);
    expect(view.collection.layout()).toBe('gantt');
    expect(screen.getByRole('row', { name: 'Launch' })).toBeTruthy();
    expect(screen.queryByRole('button', { name: 'gantt' })).toBeNull();
    setEnabled(true);
    expect(
      screen.getByRole('button', { name: 'gantt' }).getAttribute('aria-pressed')
    ).toBe('true');
  });
});

describe('project row context menu', () => {
  it('focuses the row and offers an owner every project action', async () => {
    const view = setup([project('launch', 'Launch', 'owner')]);
    await openMenu('Launch');
    expect(
      screen.getByText('Launch').closest<HTMLElement>('[role="row"]')?.dataset
        .highlighted
    ).toBe('true');
    expect(view.collection.list.focus.key()).toBe(view.rowKey('launch'));
    expect(entries()).toEqual([
      'Open in new split',
      'Rename',
      'Set status',
      'Set priority',
      'Copy Link',
      'Copy ID',
      'Share',
      'Delete',
    ]);
  });

  it('keeps view access to navigation and links', async () => {
    setup([project('launch', 'Launch', 'view')]);
    await openMenu('Launch');
    expect(entries()).toEqual([
      'Open in new split',
      'Copy Link',
      'Copy ID',
      'Share',
    ]);
  });

  it('hands navigation, links, and sharing to the host', async () => {
    const view = setup([project('launch', 'Launch', 'edit')]);
    for (const [entry, callback] of [
      ['Copy Link', view.host.onCopyLink],
      ['Copy ID', view.host.onCopyId],
      ['Share', view.host.onShare],
    ] as const) {
      await openMenu('Launch');
      choose(entry);
      await waitFor(() => expect(callback).toHaveBeenCalledWith('launch'));
    }
    await openMenu('Launch');
    choose(/Open in new split/);
    await waitFor(() =>
      expect(view.host.onOpen).toHaveBeenCalledWith('launch', {
        newSplit: true,
      })
    );
  });

  it('disables opening beside the list when no split fits', async () => {
    setup([project('launch', 'Launch', 'owner')], {
      canOpenInNewSplit: false,
    });
    await openMenu('Launch');
    expect(
      screen
        .getByRole('menuitem', { name: /Open in new split/ })
        .getAttribute('aria-disabled')
    ).toBe('true');
  });

  it('renames through a dialog that keeps a failed name for retry', async () => {
    const view = setup([project('launch', 'Launch', 'edit')]);
    view.service.rename.mockRejectedValueOnce(new Error('Name taken'));
    await openMenu('Launch');
    choose('Rename');
    const input = await screen.findByRole('textbox', { name: 'Name' });
    expect((input as HTMLInputElement).value).toBe('Launch');
    const save = screen.getByRole('button', { name: 'Save name' });
    expect(save.hasAttribute('disabled')).toBe(true);
    fireEvent.input(input, { target: { value: '  Launch v2 ' } });
    fireEvent.click(save);
    expect(await screen.findByRole('alert')).toHaveProperty(
      'textContent',
      'Could not rename project. Please try again.'
    );
    fireEvent.click(save);
    await waitFor(() =>
      expect(screen.queryByRole('textbox', { name: 'Name' })).toBeNull()
    );
    expect(view.service.rename).toHaveBeenCalledTimes(2);
    expect(view.service.rename).toHaveBeenLastCalledWith('launch', 'Launch v2');
  });

  it('deletes a project after confirmation', async () => {
    const view = setup([project('launch', 'Launch', 'owner')]);
    await openMenu('Launch');
    choose('Delete');
    expect(await screen.findByText('Delete project?')).toBeTruthy();
    fireEvent.click(screen.getByRole('button', { name: 'Delete project' }));
    await waitFor(() =>
      expect(screen.queryByText('Delete project?')).toBeNull()
    );
    expect(view.service.deleteMany).toHaveBeenCalledWith(['launch']);
    expect(toast.success).toHaveBeenCalledWith('Project deleted');
  });

  it('leaves right-clicks in a row’s portaled editors to them', () => {
    setup([project('launch', 'Launch', 'owner')]);
    expect(fireEvent.contextMenu(screen.getByText('Edit Launch'))).toBe(true);
    expect(screen.queryByRole('menu')).toBeNull();
  });

  it('adds the property submenus once their definitions load', async () => {
    const view = setup(
      [
        project('launch', 'Launch', 'owner'),
        project('roadmap', 'Roadmap', 'owner'),
      ],
      { properties: [] }
    );
    view.collection.list.selection.select(view.rowKey('launch'));
    view.collection.list.selection.select(view.rowKey('roadmap'));
    await openMenu('Launch');
    expect(entries()).toEqual(['Delete']);
    expect(screen.queryByRole('separator')).toBeNull();
  });

  it('opens the same actions in a long-press drawer on mobile', async () => {
    device.mobile = true;
    const view = setup([project('launch', 'Launch', 'owner')]);
    screen
      .getByText('Launch')
      .closest('[role="row"]')
      ?.parentElement?.dispatchEvent(new Event('test-long-press'));
    expect(view.collection.list.focus.key()).toBe(view.rowKey('launch'));
    const drawer = await screen.findByRole('dialog', {
      name: 'Entity actions',
    });
    expect(
      [...drawer.querySelectorAll('button')].map((item) => item.textContent)
    ).toEqual([
      'Rename',
      'Status: Not Started',
      'Status: Completed',
      'Priority: High',
      'Copy Link',
      'Copy ID',
      'Share',
      'Delete',
    ]);
    fireEvent.click(screen.getByRole('button', { name: 'Copy ID' }));
    await waitFor(() =>
      expect(view.host.onCopyId).toHaveBeenCalledWith('launch')
    );
  });

  it('acts on the selection and keeps failed deletions for retry', async () => {
    const launchStatus: Property = {
      ...selectProperty(SYSTEM_PROPERTY_IDS.STATUS, 'Status', statusOptions, [
        PROPERTY_OPTION_IDS.STATUS.NOT_STARTED,
      ]),
      propertyId: 'launch-status',
    };
    const view = setup([
      project('launch', 'Launch', 'owner', [launchStatus]),
      project('roadmap', 'Roadmap', 'owner'),
      project('hiring', 'Hiring', 'owner'),
    ]);
    view.collection.list.selection.select(view.rowKey('launch'));
    view.collection.list.selection.select(view.rowKey('roadmap'));

    await openMenu('Hiring');
    expect(entries()).toContain('Rename');

    await openMenu('Roadmap');
    expect(entries()).toEqual(['Set status', 'Set priority', 'Delete']);
    fireEvent.keyDown(screen.getByRole('menuitem', { name: 'Set status' }), {
      key: 'ArrowRight',
    });
    await screen.findByRole('menuitem', { name: 'Completed' });
    choose('Completed');
    await waitFor(() =>
      expect(view.service.saveProperties).toHaveBeenCalledOnce()
    );
    const value = {
      valueType: 'SELECT_STRING',
      values: [PROPERTY_OPTION_IDS.STATUS.COMPLETED],
    };
    // A row's own value saves like its cell; a missing one uses the definition.
    expect(view.service.saveProperties).toHaveBeenCalledWith([
      { id: 'launch', property: launchStatus, value },
      { id: 'roadmap', property: status, value },
    ]);

    view.service.deleteMany.mockResolvedValueOnce(['roadmap']);
    await openMenu('Launch');
    choose('Delete');
    fireEvent.click(
      await screen.findByRole('button', { name: 'Delete 2 projects' })
    );
    expect(await screen.findByRole('alert')).toHaveProperty(
      'textContent',
      'Deleted 1 of 2. The rest could not be deleted.'
    );
    expect(screen.getByText('Delete project?')).toBeTruthy();
    expect(view.collection.list.selection.isKeySelected('launch')).toBe(false);
    expect(view.collection.list.selection.isKeySelected('roadmap')).toBe(true);

    fireEvent.click(screen.getByRole('button', { name: 'Delete project' }));
    await waitFor(() =>
      expect(screen.queryByText('Delete project?')).toBeNull()
    );
    expect(view.service.deleteMany).toHaveBeenCalledTimes(2);
    expect(view.service.deleteMany).toHaveBeenLastCalledWith(['roadmap']);
  });
});