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.

8.6 KB
Raw Blame
import type { TurnState } from '@service-agent-fold/generated/types';
import { cleanup, render } from '@solidjs/testing-library';
import { createSignal } from 'solid-js';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import type { AgentInputProps } from '../ui/AgentInput';
import type { AgentModelSelectorProps } from '../ui/AgentModelSelector';
import type { QueuedPromptsProps } from '../ui/QueuedPrompts';
import { AgentComposer } from './AgentComposer';

const mocks = vi.hoisted(() => ({
  session: () => ({ canEdit: false as boolean | undefined }),
  turn: () => 'idle' as TurnState,
  issue: vi.fn(),
  selectModel: vi.fn(),
  steer: vi.fn(),
  editQueued: vi.fn(),
  removeQueued: vi.fn(),
  steerQueued: vi.fn(),
  upload: vi.fn(),
  consumeNotes: vi.fn(),
  metadata: () =>
    undefined as { model: string; configOptions: { id: string }[] } | undefined,
  input: undefined as AgentInputProps | undefined,
  model: undefined as AgentModelSelectorProps | undefined,
  queued: undefined as QueuedPromptsProps | undefined,
}));

vi.mock('@app/features/changes/context/changes-controller', () => ({
  useOptionalChanges: () => ({ consumeSendableNotes: mocks.consumeNotes }),
}));
vi.mock('@channel/Input', () => ({
  createInputAttachmentTracker: () => ({
    attachments: () => [],
    clearAttachments: vi.fn(),
    removeAttachment: vi.fn(),
  }),
  uploadInputAttachments: mocks.upload,
}));
vi.mock('@core/component/Toast/Toast', () => ({ toast: { failure: vi.fn() } }));
vi.mock('@core/util/upload', () => ({ uploadFile: vi.fn() }));
vi.mock('../context/AgentSessionContext', () => ({
  useAgentSession: () => ({
    session: () => mocks.session(),
    displayName: (id: string) => id,
    userId: () => 'viewer',
    interactions: { pending: () => [], canAnswer: () => false },
    toolApprovals: { pending: () => [] },
    issue: mocks.issue,
    selectModel: mocks.selectModel,
    loadFailed: () => false,
    messages: () => [],
    metadata: () => mocks.metadata(),
    pending: () => false,
    initialInput: 'Document context',
    queue: {
      entries: () => [
        { actionId: 'queued-1', kind: 'prompt', prompt: 'Queued request' },
      ],
      edit: mocks.editQueued,
      remove: mocks.removeQueued,
      steer: mocks.steerQueued,
    },
    steer: mocks.steer,
    steerFailed: () => new Set(),
    turn: () => mocks.turn(),
    sessionId: () => 'session-1',
    registerQuoteInsert: vi.fn(),
  }),
}));
vi.mock('../ui', () => ({
  AgentInput: (props: AgentInputProps) => {
    mocks.input = props;
    return <div>{props.modelControl}</div>;
  },
  AgentModelSelector: (props: AgentModelSelectorProps) => {
    mocks.model = props;
    return null;
  },
  QueuedPrompts: (props: QueuedPromptsProps) => {
    mocks.queued = props;
    return null;
  },
  ComposerNotice: () => null,
}));
vi.mock('./PermissionRequest', () => ({ PermissionRequest: () => null }));

beforeEach(() => {
  localStorage.clear();
  vi.resetAllMocks();
  mocks.turn = () => 'idle';
  mocks.metadata = () => undefined;
  mocks.session = () => ({ canEdit: false });
  mocks.issue.mockResolvedValue({ isErr: () => false });
});
afterEach(cleanup);

it('passes opening context to the composer without issuing it', () => {
  render(() => <AgentComposer />);
  expect(mocks.input?.initialInput).toBe('Document context');
  expect(mocks.issue).not.toHaveBeenCalled();
});

describe('view-only session controls', () => {
  it('disables and guards prompt, model, stop, queue, and attachment actions', () => {
    render(() => <AgentComposer />);

    expect(mocks.input?.disabled).toBe(true);
    expect(mocks.input?.readOnly).toBe(true);
    expect(mocks.input?.placeholder).toBe(
      'You have view-only access to this agent session'
    );
    expect(mocks.model?.disabled).toBe(true);
    expect(mocks.queued?.disabled).toBe(true);

    mocks.input?.onSend('A new prompt', []);
    mocks.input?.onStop?.();
    mocks.input?.onAttachFiles?.([new File(['text'], 'note.txt')]);
    mocks.model?.onSelect('new-model');
    mocks.queued?.onEdit('queued-1', 'Edited prompt');
    mocks.queued?.onRemove('queued-1');

    expect(mocks.issue).not.toHaveBeenCalled();
    expect(mocks.selectModel).not.toHaveBeenCalled();
    expect(mocks.upload).not.toHaveBeenCalled();
    expect(mocks.consumeNotes).not.toHaveBeenCalled();
    mocks.queued?.onSteer?.('queued-1');
    expect(mocks.editQueued).not.toHaveBeenCalled();
    expect(mocks.removeQueued).not.toHaveBeenCalled();
    expect(mocks.steer).not.toHaveBeenCalled();
    expect(mocks.queued?.onSteer).toBeUndefined();
  });

  it('steers one queued message while a turn is in flight', () => {
    mocks.session = () => ({ canEdit: true });
    mocks.turn = () => 'running';
    render(() => <AgentComposer />);

    expect(mocks.queued?.onSteer).toEqual(expect.any(Function));
    mocks.queued?.onSteer?.('queued-1');
    expect(mocks.steer).toHaveBeenCalledWith('queued-1');
  });

  it('reacts to a permission downgrade without remounting', () => {
    const [canEdit, setCanEdit] = createSignal(true);
    mocks.session = () => ({ canEdit: canEdit() });
    render(() => <AgentComposer />);
    expect(mocks.input?.disabled).toBe(false);
    expect(mocks.model?.disabled).toBe(false);

    setCanEdit(false);

    expect(mocks.input?.readOnly).toBe(true);
    expect(mocks.model?.disabled).toBe(true);
    expect(mocks.queued?.disabled).toBe(true);
    mocks.input?.onSend('Cannot send now', []);
    expect(mocks.issue).not.toHaveBeenCalled();
    expect(mocks.selectModel).not.toHaveBeenCalled();
  });

  it.each([true, undefined])(
    'preserves editable drafts before a read-only result (%s)',
    (canEdit) => {
      mocks.session = () => ({ canEdit });
      render(() => <AgentComposer />);

      expect(mocks.input?.disabled).toBe(false);
      expect(mocks.input?.readOnly).toBe(false);
      expect(mocks.queued?.disabled).toBe(false);
      mocks.input?.onSend('A permitted prompt', []);
      expect(mocks.issue).toHaveBeenCalledWith({
        type: 'prompt',
        prompt: 'A permitted prompt',
      });
    }
  );
});

it('keeps steering queued messages while the turn transitions', () => {
  const [turn, setTurn] = createSignal<TurnState>('running');
  mocks.turn = turn;
  mocks.session = () => ({ canEdit: true });
  render(() => <AgentComposer />);
  expect(mocks.queued?.onSteer).toEqual(expect.any(Function));
  for (const next of ['stopping', 'starting'] as const) {
    setTurn(next);
    expect(mocks.queued?.onSteer).toEqual(expect.any(Function));
  }
});

it('retains an unsent draft when speed configuration is rejected', async () => {
  mocks.session = () => ({ canEdit: true });
  mocks.metadata = () => ({
    model: 'openai/gpt-6-astra',
    configOptions: [{ id: 'speed' }],
  });
  mocks.selectModel.mockRejectedValue(new Error('Unavailable'));
  render(() => <AgentComposer />);
  mocks.input?.onDraftChange?.('Keep this draft');
  mocks.input?.onDraftChange?.('');
  mocks.input?.onSend('Keep this draft', []);
  await vi.waitFor(() => expect(mocks.input?.draft).toBe('Keep this draft'));
  expect(mocks.issue).not.toHaveBeenCalled();
  expect(mocks.consumeNotes).not.toHaveBeenCalled();
});

it('leaves external agent speed settings alone', () => {
  mocks.session = () => ({ canEdit: true });
  mocks.metadata = () => ({
    model: 'external/model',
    configOptions: [{ id: 'speed' }],
  });
  render(() => <AgentComposer />);
  mocks.input?.onSend('Use external settings', []);
  expect(mocks.selectModel).not.toHaveBeenCalled();
  expect(mocks.issue).toHaveBeenCalledWith({
    type: 'prompt',
    prompt: 'Use external settings',
  });
});

it('retains the draft if editing access is revoked while applying speed', async () => {
  const [canEdit, setCanEdit] = createSignal(true);
  mocks.session = () => ({ canEdit: canEdit() });
  mocks.metadata = () => ({
    model: 'openai/gpt-6-astra',
    configOptions: [{ id: 'speed' }],
  });
  let finish!: () => void;
  mocks.selectModel.mockImplementation(
    () =>
      new Promise<void>((resolve) => {
        finish = resolve;
      })
  );
  render(() => <AgentComposer />);
  mocks.input?.onSend('Keep after permission change', []);
  setCanEdit(false);
  finish();
  await vi.waitFor(() =>
    expect(mocks.input?.draft).toBe('Keep after permission change')
  );
  expect(mocks.issue).not.toHaveBeenCalled();
  expect(mocks.consumeNotes).not.toHaveBeenCalled();
});

it('allows another prompt after a failed turn', () => {
  mocks.session = () => ({ canEdit: true });
  mocks.turn = () => 'failed';
  render(() => <AgentComposer />);

  expect(mocks.input?.busy).toBe(false);
  mocks.input?.onSend('Try again', []);
  expect(mocks.issue).toHaveBeenCalledWith({
    type: 'prompt',
    prompt: 'Try again',
  });
});