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.7 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import type { FoldRequest, FoldResponse } from './protocol';

const workers: FakeWorker[] = [];

class FakeWorker extends EventTarget {
  readonly requests: FoldRequest[] = [];

  constructor() {
    super();
    workers.push(this);
  }

  postMessage(request: FoldRequest): void {
    this.requests.push(request);
  }

  reply(response: FoldResponse): void {
    this.dispatchEvent(new MessageEvent('message', { data: response }));
  }
}

beforeEach(() => {
  vi.resetModules();
  vi.stubGlobal('Worker', FakeWorker);
  vi.stubGlobal('fetch', vi.fn());
});

afterEach(() => {
  vi.restoreAllMocks();
  vi.unstubAllGlobals();
  workers.length = 0;
});

describe('agent fold preloading', () => {
  it('stays lazy until focus and initializes without creating a session or making an API call', async () => {
    const { preloadAgentFold } = await import('./client');
    expect(workers).toHaveLength(0);

    const ready = preloadAgentFold();
    const worker = workers[0]!;
    expect(worker.requests).toEqual([{ id: 0, kind: 'preload' }]);
    expect(fetch).not.toHaveBeenCalled();
    worker.reply({ id: 0, kind: 'preload', ok: true });
    await ready;

    await preloadAgentFold();
    expect(workers).toHaveLength(1);
    expect(worker.requests).toHaveLength(1);
  });

  it('uses the same worker for repeated focus and a prompt that arrives during initialization', async () => {
    const { preloadAgentFold, pushSession } = await import('./client');
    const ready = preloadAgentFold();
    await preloadAgentFold();
    const pushed = pushSession('session', [{ kind: 'snapshot', rows: [] }]);
    const worker = workers[0]!;
    expect(workers).toHaveLength(1);
    expect(worker.requests.map((request) => request.kind)).toEqual([
      'preload',
      'push',
    ]);
    worker.reply({ id: 0, kind: 'preload', ok: true });
    worker.reply({ id: 1, kind: 'push', ok: true, changes: [] });
    await ready;
    await expect(pushed).resolves.toEqual([]);
  });

  it('does no extra work when a real session has already started the worker', async () => {
    const { preloadAgentFold, pushSession } = await import('./client');
    const pushed = pushSession('session', [{ kind: 'snapshot', rows: [] }]);
    await preloadAgentFold();
    const worker = workers[0]!;
    expect(workers).toHaveLength(1);
    expect(worker.requests.map((request) => request.kind)).toEqual(['push']);
    worker.reply({ id: 0, kind: 'push', ok: true, changes: [] });
    await pushed;
  });

  it('contains worker startup errors and lets a later session start a fresh worker', async () => {
    const warning = vi.spyOn(console, 'warn').mockImplementation(() => {});
    const { preloadAgentFold, pushSession } = await import('./client');
    const ready = preloadAgentFold();
    workers[0]!.dispatchEvent(
      new ErrorEvent('error', { message: 'module could not load' })
    );
    await ready;
    expect(warning).toHaveBeenCalledOnce();

    const pushed = pushSession('session', [{ kind: 'snapshot', rows: [] }]);
    expect(workers).toHaveLength(2);
    workers[1]!.reply({ id: 1, kind: 'push', ok: true, changes: [] });
    await expect(pushed).resolves.toEqual([]);
  });

  it('reports an unavailable script with its URL without assuming a stale build', async () => {
    const { AgentFoldWorkerUnavailable, pushSession } = await import(
      './client'
    );
    const pushed = pushSession('session', [{ kind: 'snapshot', rows: [] }]);

    workers[0]!.dispatchEvent(new ErrorEvent('error', { message: '' }));

    const error = await pushed.catch((reason: unknown) => reason);
    expect(error).toBeInstanceOf(AgentFoldWorkerUnavailable);
    expect((error as Error).message).not.toContain('no longer served');
    expect((error as Error).message).toContain('fold.worker');
  });

  it('reports a script that loaded and threw as a startup failure', async () => {
    const { AgentFoldWorkerUnavailable, pushSession } = await import(
      './client'
    );
    const pushed = pushSession('session', [{ kind: 'snapshot', rows: [] }]);

    workers[0]!.dispatchEvent(
      new ErrorEvent('error', { message: 'Uncaught Error: wasm exploded' })
    );

    const error = await pushed.catch((reason: unknown) => reason);
    expect(error).not.toBeInstanceOf(AgentFoldWorkerUnavailable);
    expect((error as Error).message).toContain('wasm exploded');
  });

  it('rejects every fold in flight from one worker failure', async () => {
    const { pushSession } = await import('./client');
    const first = pushSession('a', [{ kind: 'snapshot', rows: [] }]);
    const second = pushSession('b', [{ kind: 'snapshot', rows: [] }]);

    workers[0]!.dispatchEvent(new ErrorEvent('error', { message: '' }));

    // One cause, two reports: why a single failure looks like many in Datadog.
    const [a, b] = await Promise.all([
      first.catch((reason: unknown) => reason),
      second.catch((reason: unknown) => reason),
    ]);
    expect((a as Error).name).toBe('AgentFoldWorkerUnavailable');
    expect((b as Error).name).toBe('AgentFoldWorkerUnavailable');
  });

  it('contains constructor failures without preventing a later real load', async () => {
    vi.spyOn(console, 'warn').mockImplementation(() => {});
    vi.stubGlobal(
      'Worker',
      class {
        constructor() {
          throw new Error('worker unavailable');
        }
      }
    );
    const { preloadAgentFold, pushSession } = await import('./client');
    await expect(preloadAgentFold()).resolves.toBeUndefined();

    vi.stubGlobal('Worker', FakeWorker);
    const pushed = pushSession('session', [{ kind: 'snapshot', rows: [] }]);
    workers[0]!.reply({ id: 1, kind: 'push', ok: true, changes: [] });
    await expect(pushed).resolves.toEqual([]);
  });
});