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.

11.9 KB
Raw Blame
import { QueryClient, useQuery } from '@tanstack/solid-query';
import { createComputed, createRoot, createSignal, onCleanup } from 'solid-js';
import { afterEach, describe, expect, it, vi } from 'vitest';

const fixture = vi.hoisted(() => ({
  createPreview: undefined as (() => () => unknown) | undefined,
  preview: undefined as (() => unknown) | undefined,
  channelName: undefined as (() => string) | undefined,
  previewMounts: 0,
  previewDisposals: 0,
  channelMounts: 0,
  projectsEnabled: undefined as (() => boolean | undefined) | undefined,
  projectPending: undefined as (() => boolean) | undefined,
  projectMounts: 0,
  projectDisposals: 0,
  projectIdReads: 0,
  userIcons: 0,
  flagMounts: 0,
}));

vi.mock('@app/lib/analytics/posthog', () => ({
  useFeatureFlag: () => {
    fixture.flagMounts++;
    return () => ({
      enabled: fixture.projectsEnabled?.() === true,
      loading: fixture.projectsEnabled?.() === undefined,
    });
  },
}));
vi.mock('@core/constant/featureFlags', () => ({
  enableProjects: { key: 'enable-projects' },
}));
vi.mock('@core/context/user', () => ({ useUserId: () => () => 'user' }));
vi.mock('../../projects/queries/project-identity', () => ({
  useProjectIdentityQuery: (id: () => string) => {
    fixture.projectMounts++;
    onCleanup(() => fixture.projectDisposals++);
    createComputed(() => {
      id();
      fixture.projectIdReads++;
    });
    return {
      isError: false,
      get isPending() {
        return fixture.projectPending?.() === true;
      },
      get data() {
        return fixture.projectPending?.()
          ? undefined
          : { id: 'entity-1', name: 'Launch' };
      },
    };
  },
}));
vi.mock('@core/component/EntityIcon', () => ({ EntityIcon: () => null }));
vi.mock('@core/component/UserIcon', () => ({
  UserIcon: () => {
    fixture.userIcons++;
    return null;
  },
}));
vi.mock('@core/constant/allBlocks', () => ({
  fileTypeToBlockName: (type: string) => type,
}));
vi.mock('../utils', () => ({
  entityTypeToItemType: (type: string) => type.toLowerCase(),
}));
vi.mock('@core/context/channels', () => ({
  useChannelName: () => {
    fixture.channelMounts++;
    return () => fixture.channelName?.() ?? '';
  },
}));
vi.mock('@core/user', () => ({
  getDisplayName: () => '',
  getDisplayNameParts: () => ({ fullName: '', firstName: '' }),
  tryMacroId: () => undefined,
}));
vi.mock('@queries/bots/profiles', () => ({
  useBotProfile: () => ({ isPending: true }),
}));
vi.mock('@queries/preview', () => ({
  useItemPreview: () => {
    fixture.previewMounts++;
    onCleanup(() => fixture.previewDisposals++);
    return [fixture.createPreview?.() ?? (() => fixture.preview?.())];
  },
  isAccessiblePreviewItem: (item: { access?: string }) =>
    item.access === 'access',
}));

import { createLivePreviewBatcher } from '@queries/preview/live-batcher';
import { usePropertyEntityDisplay } from './usePropertyEntityDisplay';

const disposals: Array<() => void> = [];
afterEach(() => {
  for (const dispose of disposals.splice(0)) dispose();
  fixture.createPreview = undefined;
  fixture.preview = undefined;
  vi.useRealTimers();
  fixture.channelName = undefined;
  fixture.previewMounts = 0;
  fixture.previewDisposals = 0;
  fixture.channelMounts = 0;
  fixture.projectsEnabled = undefined;
  fixture.projectPending = undefined;
  fixture.projectMounts = 0;
  fixture.projectDisposals = 0;
  fixture.projectIdReads = 0;
  fixture.userIcons = 0;
  fixture.flagMounts = 0;
});

function setup(
  type: 'DOCUMENT' | 'CHANNEL' | 'INITIATIVE' | 'USER' | 'COMPANY' | 'CONTACT'
) {
  return createRoot((dispose) => {
    disposals.push(dispose);
    return usePropertyEntityDisplay(
      () => 'entity-1',
      () => type
    );
  });
}

describe('usePropertyEntityDisplay subscription ownership', () => {
  it('subscribes to the project flag only for project values', () => {
    const [type, setType] = createSignal<'USER' | 'INITIATIVE'>('USER');
    createRoot((dispose) => {
      disposals.push(dispose);
      usePropertyEntityDisplay(() => 'entity-1', type);
    });
    expect(fixture.flagMounts).toBe(0);
    setType('INITIATIVE');
    expect(fixture.flagMounts).toBe(1);
  });

  it('builds a person’s avatar only when something shows the icon', () => {
    const display = setup('USER');
    expect(fixture.userIcons).toBe(0);

    display.icon();
    display.icon();

    expect(fixture.userIcons).toBe(1);
  });

  it('only owns project identity queries and links while the rollout is enabled', () => {
    const [enabled, setEnabled] = createSignal(false);
    fixture.projectsEnabled = enabled;
    const display = setup('INITIATIVE');
    expect(fixture.projectMounts).toBe(0);
    expect(display.nativeProjectId()).toBeUndefined();

    setEnabled(true);
    expect(fixture.projectMounts).toBe(1);
    expect(display.nativeProjectId()).toBe('entity-1');
    expect(display.name()).toBe('Launch');

    setEnabled(false);
    expect(fixture.projectDisposals).toBe(1);
    expect(display.nativeProjectId()).toBeUndefined();
    expect(display.blockOrFileType()).toBeNull();
    expect(display.name()).toBe('Project');
  });

  it('keeps one project read while the property value re-emits the same project', () => {
    fixture.projectsEnabled = () => true;
    const [reference, setReference] = createSignal({
      entity_id: 'entity-1',
      entity_type: 'INITIATIVE' as const,
    });
    const display = createRoot((dispose) => {
      disposals.push(dispose);
      return usePropertyEntityDisplay(
        () => reference().entity_id,
        () => reference().entity_type
      );
    });

    setReference({ entity_id: 'entity-1', entity_type: 'INITIATIVE' });

    expect(fixture.flagMounts).toBe(1);
    expect(fixture.projectMounts).toBe(1);
    expect(fixture.projectIdReads).toBe(1);
    expect(display.name()).toBe('Launch');
  });

  it.each(['INITIATIVE', 'DOCUMENT'] as const)(
    'names a %s from the loading name until its own read answers',
    (type) => {
      const [pending, setPending] = createSignal(true);
      fixture.projectsEnabled = () => true;
      fixture.projectPending = pending;
      fixture.preview = () =>
        pending()
          ? { loading: true }
          : { loading: false, access: 'access', name: 'Launch' };
      const display = createRoot((dispose) => {
        disposals.push(dispose);
        return usePropertyEntityDisplay(
          () => 'entity-1',
          () => type,
          { loadingName: () => 'Picked launch' }
        );
      });
      expect(display.name()).toBe('Picked launch');
      setPending(false);
      expect(display.name()).toBe('Launch');
    }
  );

  it('keeps the generic project label, without fetching, until the rollout enables it', () => {
    const [enabled, setEnabled] = createSignal<boolean | undefined>();
    fixture.projectsEnabled = enabled;
    const display = setup('INITIATIVE');
    expect(display.isLoading()).toBe(false);
    expect(display.name()).toBe('Project');
    setEnabled(false);
    expect(display.isLoading()).toBe(false);
    expect(display.name()).toBe('Project');
    expect(fixture.projectMounts).toBe(0);
  });

  it('settles a live GraphQL preview batch without reacquiring itself', () => {
    vi.useFakeTimers();
    let starts = 0;
    const queryClient = new QueryClient();
    const disposeBatch = vi.fn();
    const batcher = createLivePreviewBatcher<string, unknown>({
      start: () => {
        // Bound the synchronous drain: a regression must fail instead of hanging the suite.
        if (++starts > 5) throw new Error('preview subscription feedback loop');
        return {
          value: {
            loading: false,
            access: 'access',
            name: 'Roadmap',
            fileType: 'md',
          },
          dispose: disposeBatch,
        };
      },
    });
    fixture.createPreview = () => {
      const [preview, setPreview] = createSignal<unknown>();
      const subscription = batcher.acquire('entity-1', 'entity-1', setPreview);
      onCleanup(subscription.dispose);
      // The real preview hook also constructs a disabled REST fallback.
      // TanStack reads these options during construction, before any result.
      useQuery(
        () => ({
          queryKey: ['preview-rest-fallback', Boolean(preview())],
          queryFn: async () => null,
          enabled: false,
        }),
        () => queryClient
      );
      return preview;
    };
    const display = setup('DOCUMENT');
    vi.advanceTimersByTime(30);
    expect(display.name()).toBe('Roadmap');
    expect(display.isLoading()).toBe(false);
    expect(starts).toBe(1);
    disposals.pop()?.();
    queryClient.clear();
    expect(disposeBatch).toHaveBeenCalledTimes(1);
  });

  it('keeps the preview subscription while loading and receiving live updates', () => {
    const [preview, setPreview] = createSignal<unknown>({ loading: true });
    fixture.preview = preview;
    const display = setup('DOCUMENT');
    expect(display.isLoading()).toBe(true);
    expect(fixture.previewMounts).toBe(1);

    setPreview({
      loading: false,
      access: 'access',
      name: 'Roadmap',
      fileType: 'md',
    });
    expect(display.name()).toBe('Roadmap');
    expect(display.blockOrFileType()).toBe('md');
    expect(display.isLoading()).toBe(false);
    expect(fixture.previewMounts).toBe(1);
    expect(fixture.previewDisposals).toBe(0);

    setPreview({
      loading: false,
      access: 'access',
      name: 'Updated roadmap',
      fileType: 'pdf',
    });
    expect(display.name()).toBe('Updated roadmap');
    expect(display.blockOrFileType()).toBe('pdf');
    expect(fixture.previewMounts).toBe(1);
    disposals.pop()?.();
    expect(fixture.previewDisposals).toBe(1);
  });

  it('keeps the channel subscription when its name changes', () => {
    const [name, setName] = createSignal('Design');
    fixture.channelName = name;
    const display = setup('CHANNEL');
    expect(display.name()).toBe('Design');
    setName('Product design');
    expect(display.name()).toBe('Product design');
    expect(fixture.channelMounts).toBe(1);
  });
});

describe('usePropertyEntityDisplay CRM references', () => {
  it.each(['COMPANY', 'CONTACT'] as const)(
    'tracks authorized preview access for %s without resubscribing',
    (type) => {
      const [preview, setPreview] = createSignal<unknown>({ loading: true });
      fixture.preview = preview;
      const display = setup(type);
      expect(display.hasPreviewAccess()).toBe(false);
      setPreview({ loading: false, access: 'access', name: 'Example record' });
      expect(display.hasPreviewAccess()).toBe(true);
      setPreview({ loading: false, access: 'no_access' });
      expect(display.hasPreviewAccess()).toBe(false);
      setPreview({ loading: false, access: 'does_not_exist' });
      expect(display.hasPreviewAccess()).toBe(false);
      setPreview({ loading: false, access: 'access', name: 'Restored record' });
      expect(display.hasPreviewAccess()).toBe(true);
      expect(fixture.previewMounts).toBe(1);
    }
  );
  it.each([
    ['COMPANY', 'Acme', 'company'],
    ['CONTACT', 'Ada Lovelace', 'contact'],
  ] as const)(
    'names %s references from their preview and links to the record',
    (type, name, block) => {
      fixture.preview = () => ({ loading: false, access: 'access', name });
      const display = setup(type);
      expect(fixture.previewMounts).toBe(1);
      expect(display.name()).toBe(name);
      expect(display.blockOrFileType()).toBe(block);
    }
  );
});

it('retains exact message navigation when the source changes within one channel', () => {
  const [messageId, setMessageId] = createSignal<string | undefined>('reply');
  const display = createRoot((dispose) => {
    disposals.push(dispose);
    return usePropertyEntityDisplay(
      () => 'channel',
      () => 'CHANNEL',
      {
        specificMessageId: messageId,
      }
    );
  });
  expect(display.linkParams()).toEqual({ channel_message_id: 'reply' });
  setMessageId('other-reply');
  expect(display.linkParams()).toEqual({ channel_message_id: 'other-reply' });
  setMessageId(undefined);
  expect(display.linkParams()).toBeUndefined();
});