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.

3.3 KB
Raw Blame
/**
 * @vitest-environment jsdom
 */

import { agentHarnessServiceClient } from '@service-agent-harness/client';
import { QueryClient, QueryClientProvider } from '@tanstack/solid-query';
import { ok } from 'neverthrow';
import type { JSX } from 'solid-js';
import { render } from 'solid-js/web';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { buildAgentModelTargets, useAgentModelsQueries } from './models';

vi.mock('@service-agent-harness/client', () => ({
  agentHarnessServiceClient: {
    loadAgentModels: vi.fn(),
  },
}));

let queryClient: QueryClient;
let dispose: (() => void) | undefined;

function renderHook(factory: () => unknown) {
  dispose = render(
    () => (
      <QueryClientProvider client={queryClient}>
        {(() => {
          factory();
          return null as unknown as JSX.Element;
        })()}
      </QueryClientProvider>
    ),
    document.body
  );
}

beforeEach(() => {
  vi.clearAllMocks();
  queryClient = new QueryClient({
    defaultOptions: { queries: { retry: false } },
  });
});

afterEach(() => {
  dispose?.();
  dispose = undefined;
  queryClient.clear();
});

describe('agent model discovery', () => {
  it('constructs every available target in parallel without waiting for another target', async () => {
    const targets = buildAgentModelTargets(true, [
      { id: 'harness-a' },
      { id: 'harness-b' },
    ]);
    const pending = new Promise<never>(() => {});
    vi.mocked(agentHarnessServiceClient.loadAgentModels).mockReturnValue(
      pending
    );

    renderHook(() => useAgentModelsQueries(() => targets));

    await vi.waitFor(() => {
      expect(agentHarnessServiceClient.loadAgentModels).toHaveBeenCalledTimes(
        4
      );
    });
    expect(
      vi
        .mocked(agentHarnessServiceClient.loadAgentModels)
        .mock.calls.map(([request]) => request)
    ).toEqual([
      { harness: 'in-memory' },
      { harness: 'cursor' },
      { harness: 'macrod', harnessId: 'harness-a' },
      { harness: 'macrod', harnessId: 'harness-b' },
    ]);
  });

  it('omits Cursor when it is not registered', () => {
    expect(buildAgentModelTargets(false, [{ id: 'harness-a' }])).toEqual([
      { harness: 'in-memory' },
      { harness: 'macrod', harnessId: 'harness-a' },
    ]);
  });

  it('keeps a loaded catalog across remounts', async () => {
    vi.mocked(agentHarnessServiceClient.loadAgentModels).mockResolvedValue(
      ok({
        status: 'available',
        models: [],
      })
    );

    renderHook(() =>
      useAgentModelsQueries(() => [
        { harness: 'in-memory' },
        { harness: 'cursor' },
      ])
    );
    await vi.waitFor(() => {
      expect(agentHarnessServiceClient.loadAgentModels).toHaveBeenCalledTimes(
        2
      );
      expect(
        queryClient
          .getQueryCache()
          .getAll()
          .every((query) => query.state.status === 'success')
      ).toBe(true);
    });

    dispose?.();
    renderHook(() =>
      useAgentModelsQueries(() => [
        { harness: 'in-memory' },
        { harness: 'cursor' },
      ])
    );
    await vi.waitFor(() => {
      expect(
        queryClient
          .getQueryCache()
          .getAll()
          .every((query) => query.state.status === 'success')
      ).toBe(true);
    });
    expect(agentHarnessServiceClient.loadAgentModels).toHaveBeenCalledTimes(2);
  });
});