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.

5.2 KB
Raw Blame
/** @vitest-environment jsdom */
import { queryClient } from '@queries/client';
import { handlePullRequestUpdated } from '@queries/storage/pr-mention-sync';
import { storageServiceClient } from '@service-storage/client';
import type { ForeignEntity } from '@service-storage/generated/schemas';
import {
  cleanup,
  fireEvent,
  render,
  screen,
  waitFor,
} from '@solidjs/testing-library';
import { QueryClient, QueryClientProvider } from '@tanstack/solid-query';
import { err } from 'neverthrow';
import { Suspense } from 'solid-js';
import { afterEach, expect, it, vi } from 'vitest';
import { AgentPullRequestChip } from './AgentPullRequestChip';

vi.mock('@queries/agent-session/list-sync', () => ({
  refreshAgentSessionLists: vi.fn(async () => {}),
}));

const { openWithSplit } = vi.hoisted(() => {
  class FakeWebSocket {
    url: string;
    readyState = 1;
    constructor(url: string) {
      this.url = url;
    }
    close() {}
    addEventListener() {}
    removeEventListener() {}
    send() {}
  }
  vi.stubGlobal('WebSocket', FakeWebSocket);
  return { openWithSplit: vi.fn() };
});

vi.mock('@queries/client', async () => {
  const { QueryClient } = await import('@tanstack/solid-query');
  return {
    queryClient: new QueryClient({
      defaultOptions: { queries: { retry: false } },
    }),
  };
});

vi.mock('@service-storage/client', () => ({
  storageServiceClient: { getForeignEntityBySource: vi.fn() },
}));
vi.mock('@service-connection/websocket', () => ({
  ws: { addEventListener: vi.fn(), removeEventListener: vi.fn() },
  createConnectionWebsocketEffect: vi.fn(),
  parseWebsocketPayload: vi.fn(),
}));
vi.mock('@components/app/split-layout/layout', () => ({
  useSplitLayout: () => ({ openWithSplit }),
}));
vi.mock('@core/util/useSplitNavigationHandler', () => ({
  useSplitNavigationHandler: (onClick: (event: MouseEvent) => void) => ({
    onClick,
  }),
}));
vi.mock('@core/component/HoverCard', () => ({
  HoverCard: (props: { trigger: import('solid-js').JSX.Element }) =>
    props.trigger,
}));
vi.mock(
  '@core/component/LexicalMarkdown/component/decorator/PullRequestMention',
  () => ({
    PullRequestPreviewCard: () => null,
  })
);

const url = 'https://github.com/macro-inc/macro/pull/6303';

function entity(status: string): ForeignEntity {
  return {
    id: '019f0000-0000-7000-8000-000000000001',
    foreignEntityId: 'macro-inc/macro/pull/6303',
    foreignEntitySource: 'github_pull_request',
    metadata: { status, name: 'Add the header chip', number: 6303 },
    storedForId: 'macro|[email protected]',
    storedForAuthEntity: 'user',
    createdAt: '2026-09-11T00:00:00Z',
    updatedAt: '2026-09-11T00:00:00Z',
  };
}

afterEach(() => {
  cleanup();
  queryClient.clear();
  vi.useRealTimers();
  vi.clearAllMocks();
});

it('shows a GitHub fallback without suspending while the webhook mapping is pending', async () => {
  type Lookup = ReturnType<
    typeof storageServiceClient.getForeignEntityBySource
  >;
  let resolve!: (value: Awaited<Lookup>) => void;
  vi.mocked(storageServiceClient.getForeignEntityBySource).mockReturnValue(
    new Promise((done) => {
      resolve = done;
    }) as Lookup
  );
  const client = new QueryClient();
  render(() => (
    <QueryClientProvider client={client}>
      <Suspense fallback={<span>Loading chip</span>}>
        <AgentPullRequestChip url={url} />
      </Suspense>
    </QueryClientProvider>
  ));
  const link = screen.getByRole('link');
  expect(link.getAttribute('href')).toBe(url);
  expect(link.textContent).toContain('#6303');
  expect(link.textContent).toContain('Open');
  expect(screen.queryByText('Loading chip')).toBeNull();
  resolve(
    err([{ code: 'NOT_FOUND', message: 'Not synced' }]) as Awaited<Lookup>
  );
  await waitFor(() =>
    expect(client.getQueryCache().getAll()[0].state.status).toBe('success')
  );
  expect(screen.getByRole('link').getAttribute('href')).toBe(url);
  client.clear();
});

it('opens the PR entity once synced and follows later status changes', async () => {
  vi.useFakeTimers();
  const lookup = vi.mocked(storageServiceClient.getForeignEntityBySource);
  type Lookup = ReturnType<
    typeof storageServiceClient.getForeignEntityBySource
  >;
  lookup.mockResolvedValue(
    err([{ code: 'NOT_FOUND', message: 'Not synced' }]) as Awaited<Lookup>
  );
  const client = queryClient;
  const rendered = render(() => (
    <QueryClientProvider client={client}>
      <AgentPullRequestChip url={url} />
    </QueryClientProvider>
  ));
  await vi.advanceTimersByTimeAsync(1);
  expect(screen.getByRole('link')).toBeTruthy();
  await handlePullRequestUpdated(entity('open'));
  await vi.advanceTimersByTimeAsync(1);
  expect(screen.getByRole('button').textContent).toContain('#6303');
  expect(screen.getByRole('button').textContent).toContain('Open');
  fireEvent.click(screen.getByRole('button'));
  expect(openWithSplit).toHaveBeenCalledWith(
    { type: 'pr', id: entity('open').id },
    { preferNewSplit: true }
  );
  await handlePullRequestUpdated({
    ...entity('merged'),
    metadata: { status: 'merged', name: 'Add the header chip', number: 6303 },
    updatedAt: '2026-09-11T00:01:00Z',
  });
  await vi.advanceTimersByTimeAsync(1);
  expect(screen.getByRole('button').textContent).toContain('Merged');
  rendered.unmount();
  client.clear();
});