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.

7.6 KB
Raw Blame
import { createRoot, createSignal } from 'solid-js';
import { describe, expect, it, vi } from 'vitest';
import type { ProjectRow, ProjectsSource } from '../context/projects-context';
import type { ProjectFilters } from '../core/project';
import { createProjectCollection } from './project-collection';

describe('project collection', () => {
  it('passes filters to the source and follows the current assignee identity', () => {
    createRoot((dispose) => {
      const [userId, setUserId] = createSignal('first-user');
      let filters: () => ProjectFilters = () => ({});
      const collection = createProjectCollection({
        userId,
        createSource: (input = () => ({})) => {
          filters = input;
          return emptySource();
        },
      });
      collection.setMine(true);
      collection.setStatus('status-option');
      collection.setPriority('priority-option');
      collection.setDueBefore('2026-10-04');
      collection.setSort('created');
      expect(filters()).toMatchObject({
        status: 'status-option',
        priority: 'priority-option',
        assignee: 'first-user',
        sort: 'created',
        descending: true,
        dueBefore: new Date('2026-10-04T23:59:59.999').toISOString(),
      });
      setUserId('next-user');
      expect(filters().assignee).toBe('next-user');
      collection.setMine(false);
      collection.setStatus('');
      collection.setPriority('');
      collection.setDueBefore('');
      expect(filters()).toMatchObject({
        assignee: undefined,
        status: undefined,
        priority: undefined,
        dueBefore: undefined,
      });
      dispose();
    });
  });

  it('keeps assigned and created scopes independent of editable filters and follows viewer changes', () => {
    createRoot((dispose) => {
      const [scope, setScope] = createSignal<
        'all' | 'assigned-to-me' | 'created-by-me'
      >('all');
      const [userId, setUserId] = createSignal<string | undefined>(
        'first-user'
      );
      let filters: () => ProjectFilters = () => ({});
      let enabled: () => boolean = () => false;
      const collection = createProjectCollection({
        scope,
        userId,
        createSource: (input = () => ({}), isEnabled = () => true) => {
          filters = input;
          enabled = isEnabled;
          return emptySource();
        },
      });
      expect(filters()).toMatchObject({
        assignee: undefined,
        owner: undefined,
      });
      collection.setStatus('active');
      collection.setPriority('high');
      collection.setSearch('release');
      setScope('assigned-to-me');
      expect(filters()).toMatchObject({
        assignee: 'first-user',
        owner: undefined,
        status: 'active',
        priority: 'high',
      });
      expect(enabled()).toBe(true);
      collection.setMine(false);
      collection.setStatus('');
      collection.setPriority('');
      expect(filters().assignee).toBe('first-user');
      setUserId('next-user');
      expect(filters().assignee).toBe('next-user');
      setScope('created-by-me');
      expect(filters()).toMatchObject({
        owner: 'next-user',
        assignee: undefined,
      });
      collection.setMine(true);
      expect(filters()).toMatchObject({
        owner: 'next-user',
        assignee: 'next-user',
      });
      collection.setMine(false);
      expect(filters().owner).toBe('next-user');
      setUserId(undefined);
      expect(enabled()).toBe(false);
      setUserId('third-user');
      expect(enabled()).toBe(true);
      expect(filters().owner).toBe('third-user');
      setScope('all');
      expect(filters()).toMatchObject({
        owner: undefined,
        assignee: undefined,
      });
      expect(enabled()).toBe(true);
      dispose();
    });
  });

  it('distinguishes initial failure from a failed refresh with usable rows', () => {
    createRoot((dispose) => {
      const [rows, setRows] = createSignal<readonly ProjectRow[]>();
      const [error, setError] = createSignal<Error>();
      const collection = createProjectCollection({
        userId: () => 'user',
        createSource: () => ({ ...emptySource(), rows, error }),
      });
      expect(collection.state().kind).toBe('loading');
      const failure = new Error('offline');
      setError(failure);
      expect(collection.state()).toEqual({ kind: 'error', error: failure });
      const loaded = [
        {
          project: {
            id: 'project',
            name: 'Release',
            updatedAt: '',
          },
          properties: [],
        },
      ];
      setRows(loaded);
      expect(collection.state()).toEqual({
        kind: 'ready',
        rows: loaded,
        backgroundError: failure,
      });
      expect(collection.groups()).toEqual([
        {
          id: '',
          label: 'No status',
          count: 1,
          entities: loaded.map((row) => ({
            ...row,
            id: row.project.id,
            type: 'initiative',
          })),
        },
      ]);
      dispose();
    });
  });

  it('uses unified disclosure, activation, selection and pagination without treating initiatives as folders', () => {
    createRoot((dispose) => {
      const [rows, setRows] = createSignal<readonly ProjectRow[]>([
        row('one'),
        row('two'),
      ]);
      const loadMore = vi.fn(async () => {});
      const open = vi.fn();
      const collection = createProjectCollection({
        userId: () => 'user',
        onOpen: open,
        createSource: () => ({
          ...emptySource(),
          rows,
          hasMore: () => true,
          loadMore,
        }),
      });
      const entities = () =>
        collection.items().filter((item) => item.kind === 'entity');
      const first = entities()[0];
      const second = entities()[1];
      if (first.kind !== 'entity' || second.kind !== 'entity')
        throw new Error('missing rows');
      expect(first.entity.type).toBe('initiative');
      collection.list.selection.selectRange(first.id, second.id);
      expect(collection.list.selection.count()).toBe(2);
      collection.list.activate.key(first.id, { metadata: { newSplit: true } });
      expect(open).toHaveBeenCalledWith('one', { newSplit: true });
      const group = collection
        .items()
        .find((item) => item.kind === 'group-header');
      if (!group || group.kind !== 'group-header')
        throw new Error('missing group');
      collection.list.activate.key(group.id);
      expect(entities()).toHaveLength(0);
      collection.list.activate.key(group.id);
      expect(entities()).toHaveLength(2);
      expect(collection.list.selection.isSelected(first.id)).toBe(true);
      const more = collection.items().find((item) => item.kind === 'load-more');
      if (!more) throw new Error('missing continuation');
      collection.list.activate.key(more.id);
      expect(loadMore).toHaveBeenCalledOnce();
      setRows([row('two'), row('three'), row('two')]);
      expect(entities()).toHaveLength(2);
      expect(
        collection.list.selection
          .items()
          .flatMap((item) => (item.kind === 'entity' ? [item.entity.id] : []))
      ).toEqual(['two']);
      collection.setGroupBy('none');
      expect(
        collection.items().some((item) => item.kind === 'group-header')
      ).toBe(false);
      dispose();
    });
  });
});

function row(id: string): ProjectRow {
  return {
    project: {
      id,
      name: id,
      updatedAt: '',
    },
    properties: [],
  };
}

function emptySource(): ProjectsSource {
  return {
    rows: () => undefined,
    loading: () => false,
    error: () => undefined,
    hasMore: () => false,
    loadingMore: () => false,
    loadMore: vi.fn(async () => {}),
    refresh: vi.fn(async () => {}),
  };
}