Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

13.5 KB
Raw Blame
import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest';
import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
import ProviderComposePopover from './ProviderComposePopover';

afterEach(cleanup);

const CATALOG = {
  harnesses: [
    { id: 'pi', label: 'Pi', modes: ['tui'], enabled: true, detected: true },
    { id: 'claude', label: 'Claude Code', modes: ['cli', 'tui'], enabled: true, detected: true },
  ],
  bootstraps: [{ slug: 'chatgpt', label: 'ChatGPT wrapper' }],
  loading: false,
  compatiblePairs: (harnessId) => (harnessId === 'pi'
    ? [{ slug: 'nvidia-nim-free', label: 'NVIDIA NIM', plan: 'free', enabled: true, credentialVia: 'stored', readiness: 'ready', catalog: { models: ['nvidia/example'] } }]
    : [{ slug: 'anthropic', label: 'Anthropic', plan: 'paid', enabled: true, credentialVia: 'bootstrap', readiness: 'needs-credential', catalog: { models: ['claude-sonnet'] } }]),
  methodsFor: (harnessId) => (harnessId === 'pi' ? ['tui'] : ['cli', 'tui']),
  modelsFor: (slug) => (slug === 'nvidia-nim-free' ? ['nvidia/example'] : slug === 'anthropic' ? ['claude-sonnet'] : []),
  effortLevelsFor: (harnessId) => (harnessId === 'pi' ? ['low', 'medium', 'high', 'xhigh', 'max'] : []),
  savePreset: vi.fn(),
};

const mocked = vi.hoisted(() => ({ useProviderCatalog: vi.fn() }));
vi.mock('../../hooks/useProviderCatalog.js', () => ({ default: mocked.useProviderCatalog }));

beforeEach(() => {
  mocked.useProviderCatalog.mockReturnValue(CATALOG);
  CATALOG.savePreset.mockReset();
});

// Composes down harness -> method -> service, asserting each select only
// appears once its predecessor is chosen (the narrowing the issue asks for).
async function composePiTui() {
  fireEvent.change(screen.getByLabelText('Harness'), { target: { value: 'pi' } });
  await waitFor(() => expect(screen.getByLabelText('Method')).toBeTruthy());
  fireEvent.change(screen.getByLabelText('Method'), { target: { value: 'tui' } });
  await waitFor(() => expect(screen.getByLabelText('Service')).toBeTruthy());
  fireEvent.change(screen.getByLabelText('Service'), { target: { value: 'nvidia-nim-free' } });
}

describe('ProviderComposePopover', () => {
  it('alphabetizes custom-combination model options by displayed name', async () => {
    const models = Object.freeze(['Zulu', { id: 'z-id', name: 'alpha' }, 'Beta']);
    mocked.useProviderCatalog.mockReturnValue({ ...CATALOG, modelsFor: () => models });
    render(<ProviderComposePopover open onClose={vi.fn()} onCompose={vi.fn()} />);
    await composePiTui();
    expect([...screen.getByLabelText('Model').options].map(option => option.textContent))
      .toEqual(['Default model', 'alpha', 'Beta', 'Zulu']);
  });

  it('renders nothing while closed', () => {
    const { container } = render(<ProviderComposePopover open={false} onClose={vi.fn()} onCompose={vi.fn()} />);
    expect(container.textContent).toBe('');
  });

  it('renders the dialog panel on an opaque card surface, so page content cannot bleed through', () => {
    render(<ProviderComposePopover open onClose={vi.fn()} onCompose={vi.fn()} />);
    const dialog = screen.getByRole('dialog');
    expect(dialog.className).toMatch('bg-port-card');
  });

  it('renders only the Harness select until a harness is chosen, then narrows step by step', async () => {
    render(<ProviderComposePopover open onClose={vi.fn()} onCompose={vi.fn()} />);
    expect(screen.getByLabelText('Harness')).toBeTruthy();
    expect(screen.queryByLabelText('Method')).toBeNull();
    expect(screen.queryByLabelText('Service')).toBeNull();

    await composePiTui();
    expect(screen.getByLabelText('Model')).toBeTruthy();
    expect(screen.getByLabelText('Thinking effort')).toBeTruthy();
  });

  it('emits the composed composite id on "Use once" and closes', async () => {
    const onCompose = vi.fn();
    const onClose = vi.fn();
    render(<ProviderComposePopover open onClose={onClose} onCompose={onCompose} />);
    await composePiTui();

    fireEvent.click(screen.getByRole('button', { name: 'Use once' }));
    expect(onCompose).toHaveBeenCalledWith('pi.tui@nvidia-nim-free', { model: '', effort: '' });
    expect(onClose).toHaveBeenCalledTimes(1);
  });

  it('includes the picked model and effort in the emitted composite', async () => {
    const onCompose = vi.fn();
    render(<ProviderComposePopover open onClose={vi.fn()} onCompose={onCompose} />);
    await composePiTui();
    fireEvent.change(screen.getByLabelText('Model'), { target: { value: 'nvidia/example' } });
    fireEvent.change(screen.getByLabelText('Thinking effort'), { target: { value: 'high' } });

    fireEvent.click(screen.getByRole('button', { name: 'Use once' }));
    expect(onCompose).toHaveBeenCalledWith('pi.tui@nvidia-nim-free', { model: 'nvidia/example', effort: 'high' });
  });

  it('clearing the method resets the now-hidden service/model/effort rather than leaving them orphaned', async () => {
    render(<ProviderComposePopover open onClose={vi.fn()} onCompose={vi.fn()} />);
    await composePiTui();
    fireEvent.change(screen.getByLabelText('Model'), { target: { value: 'nvidia/example' } });

    // Method select's blank option clears back to "Choose a method…", which
    // hides Service (gated on harnessId && method) — but Model/Thinking effort
    // are gated on serviceSlug alone, so a stale serviceSlug would leave them
    // rendered with a selection for a service the user can no longer see.
    fireEvent.change(screen.getByLabelText('Method'), { target: { value: '' } });
    expect(screen.queryByLabelText('Service')).toBeNull();
    expect(screen.queryByLabelText('Model')).toBeNull();
    expect(screen.queryByLabelText('Thinking effort')).toBeNull();
  });

  it('clears a stale effort when a newly-picked model no longer offers it', async () => {
    const onCompose = vi.fn();
    // Give this harness+service a model whose effort ladder narrows to []
    // when picked, so the previously-selected 'max' has nowhere to live.
    mocked.useProviderCatalog.mockReturnValue({
      ...CATALOG,
      compatiblePairs: () => [{ slug: 'nvidia-nim-free', label: 'NVIDIA NIM', plan: 'free', enabled: true, credentialVia: 'stored', readiness: 'ready', catalog: { models: ['nvidia/example', 'tierless-model'] } }],
      modelsFor: () => ['nvidia/example', 'tierless-model'],
      effortLevelsFor: (_harnessId, model) => (model === 'tierless-model' ? [] : ['low', 'medium', 'high', 'xhigh', 'max']),
    });
    render(<ProviderComposePopover open onClose={vi.fn()} onCompose={onCompose} />);
    await composePiTui();
    fireEvent.change(screen.getByLabelText('Model'), { target: { value: 'nvidia/example' } });
    fireEvent.change(screen.getByLabelText('Thinking effort'), { target: { value: 'max' } });

    fireEvent.change(screen.getByLabelText('Model'), { target: { value: 'tierless-model' } });
    expect(screen.queryByLabelText('Thinking effort')).toBeNull();

    fireEvent.click(screen.getByRole('button', { name: 'Use once' }));
    expect(onCompose).toHaveBeenCalledWith('pi.tui@nvidia-nim-free', { model: 'tierless-model', effort: '' });
  });

  it('disables "Use once" until harness, method and service are all chosen', () => {
    render(<ProviderComposePopover open onClose={vi.fn()} onCompose={vi.fn()} />);
    expect(screen.getByRole('button', { name: 'Use once' })).toBeDisabled();
  });

  it('requires a credential bootstrap for a service that authenticates via one, and appends its slug', async () => {
    const onCompose = vi.fn();
    render(<ProviderComposePopover open onClose={vi.fn()} onCompose={onCompose} />);
    fireEvent.change(screen.getByLabelText('Harness'), { target: { value: 'claude' } });
    await waitFor(() => expect(screen.getByLabelText('Method')).toBeTruthy());
    fireEvent.change(screen.getByLabelText('Method'), { target: { value: 'cli' } });
    await waitFor(() => expect(screen.getByLabelText('Service')).toBeTruthy());
    fireEvent.change(screen.getByLabelText('Service'), { target: { value: 'anthropic' } });

    const useOnce = screen.getByRole('button', { name: 'Use once' });
    expect(useOnce).toBeDisabled();
    expect(screen.getByLabelText(/Credential bootstrap \(required\)/)).toBeTruthy();

    fireEvent.change(screen.getByLabelText(/Credential bootstrap/), { target: { value: 'chatgpt' } });
    expect(useOnce).not.toBeDisabled();
    fireEvent.click(useOnce);
    expect(onCompose).toHaveBeenCalledWith('claude.cli@anthropic+chatgpt', { model: '', effort: '' });
  });

  it('offers the bootstrap select as OPTIONAL for a service that stores its own credential', async () => {
    render(<ProviderComposePopover open onClose={vi.fn()} onCompose={vi.fn()} />);
    await composePiTui();
    // nvidia-nim-free's credentialVia is 'stored', not 'bootstrap': the select
    // still renders (method is tui and a bootstrap app is configured) but is
    // never marked required, unlike the anthropic/credentialVia:'bootstrap' case.
    expect(screen.getByLabelText('Credential bootstrap')).toBeTruthy();
    expect(screen.queryByText(/required/)).toBeNull();
    expect(screen.getByRole('button', { name: 'Use once' })).not.toBeDisabled();
  });

  it('restricts harnesses and methods to allowedMethods (caller mode policy)', () => {
    render(<ProviderComposePopover open onClose={vi.fn()} onCompose={vi.fn()} allowedMethods={['tui']} />);
    const harnessSelect = screen.getByLabelText('Harness');
    const optionLabels = Array.from(harnessSelect.querySelectorAll('option')).map((o) => o.textContent);
    // Both fixture harnesses support tui, so both remain offered.
    expect(optionLabels).toEqual(expect.arrayContaining(['Pi', 'Claude Code']));
  });

  it('saves the composed combination as a preset and reports it to the caller', async () => {
    CATALOG.savePreset.mockResolvedValue({ id: 'pi-tui-nvidia-nim-free' });
    const onPresetSaved = vi.fn();
    const onClose = vi.fn();
    render(<ProviderComposePopover open onClose={onClose} onCompose={vi.fn()} onPresetSaved={onPresetSaved} />);
    await composePiTui();

    fireEvent.click(screen.getByRole('button', { name: 'Save as preset…' }));
    expect(screen.getByLabelText('Preset name')).toBeTruthy();
    fireEvent.change(screen.getByLabelText('Preset name'), { target: { value: 'My Pi NIM' } });

    await act(async () => {
      fireEvent.click(screen.getByRole('button', { name: 'Confirm save' }));
    });

    expect(CATALOG.savePreset).toHaveBeenCalledWith({
      compositeId: 'pi.tui@nvidia-nim-free', name: 'My Pi NIM', model: null, effort: null,
    });
    expect(onPresetSaved).toHaveBeenCalledWith({ id: 'pi-tui-nvidia-nim-free' });
    expect(onClose).toHaveBeenCalledTimes(1);
  });

  it('offers only enabled services from the compatible pair list', async () => {
    mocked.useProviderCatalog.mockReturnValue({
      ...CATALOG,
      compatiblePairs: () => [
        { slug: 'nvidia-nim-free', label: 'NVIDIA NIM', enabled: true, credentialVia: 'stored', readiness: 'ready', catalog: { models: [] } },
        { slug: 'off', label: 'Switched off', enabled: false, credentialVia: 'stored', readiness: 'disabled', catalog: { models: [] } },
      ],
    });
    render(<ProviderComposePopover open onClose={vi.fn()} onCompose={vi.fn()} />);
    fireEvent.change(screen.getByLabelText('Harness'), { target: { value: 'pi' } });
    fireEvent.change(await screen.findByLabelText('Method'), { target: { value: 'tui' } });
    const labels = Array.from((await screen.findByLabelText('Service')).querySelectorAll('option')).map((option) => option.textContent);
    expect(labels).toContain('NVIDIA NIM');
    expect(labels).not.toContain('Switched off');
  });

  it('restores a service seed after a compatible harness and method, and leaves an incompatible one unselected', async () => {
    const initial = { serviceSlug: 'nvidia-nim-free' };
    render(<ProviderComposePopover open initial={initial} onClose={vi.fn()} onCompose={vi.fn()} />);
    expect(screen.queryByLabelText('Model')).toBeNull();

    fireEvent.change(screen.getByLabelText('Harness'), { target: { value: 'pi' } });
    expect(screen.queryByLabelText('Service')).toBeNull();
    fireEvent.change(await screen.findByLabelText('Method'), { target: { value: 'tui' } });
    expect(await screen.findByLabelText('Service')).toHaveValue('nvidia-nim-free');

    // Clearing the method hides the seeded service's model; choosing it again
    // puts the same service back.
    fireEvent.change(screen.getByLabelText('Method'), { target: { value: '' } });
    expect(screen.queryByLabelText('Model')).toBeNull();
    fireEvent.change(screen.getByLabelText('Method'), { target: { value: 'tui' } });
    expect(screen.getByLabelText('Service')).toHaveValue('nvidia-nim-free');

    fireEvent.change(screen.getByLabelText('Harness'), { target: { value: 'claude' } });
    fireEvent.change(await screen.findByLabelText('Method'), { target: { value: 'cli' } });
    expect(screen.getByLabelText('Service')).toHaveValue('');
    fireEvent.change(screen.getByLabelText('Service'), { target: { value: 'anthropic' } });
    fireEvent.change(screen.getByLabelText('Method'), { target: { value: 'tui' } });
    expect(screen.getByLabelText('Service')).toHaveValue('anthropic');
  });

  it('resets its fields every time it is reopened', async () => {
    const { rerender } = render(<ProviderComposePopover open onClose={vi.fn()} onCompose={vi.fn()} />);
    await composePiTui();
    expect(screen.getByLabelText('Service')).toHaveValue('nvidia-nim-free');

    rerender(<ProviderComposePopover open={false} onClose={vi.fn()} onCompose={vi.fn()} />);
    rerender(<ProviderComposePopover open onClose={vi.fn()} onCompose={vi.fn()} />);
    expect(screen.getByLabelText('Harness')).toHaveValue('');
    expect(screen.queryByLabelText('Method')).toBeNull();
  });
});