Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

14.3 KB
Raw Blame
// @vitest-environment jsdom
import { cleanup, render, screen, waitFor } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import { I18nextProvider } from 'react-i18next';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import i18n from '@/i18n';
import { modelsApi } from './modelsApi';
import type {
  SourceMutationLanding,
  SourceMutationLandingReads,
  SourceMutationSettlement,
  TrackSourceMutation,
} from './mutationSettlement';
import { readyRegion, unreadRegion } from './regionRead';
import { SourceTestDialog } from './SourceTestDialog';
import { CONTRACT_VERSION, type Source, type SourceProbeResult } from './types';

const source: Source = {
  id: 'src_test0001', kind: 'api_key', vendor: 'custom', display_name: 'My relay',
  protocol: 'openai_chat', base_url: 'https://relay.example/v1', supply_channel: 'hub',
  billing: 'metered', state: { status: 'standby', retry_at: null, detail_key: null },
  credential_ref: 'cred_test001', verification_pending: 'vp_original', credential_generation: 'vp_original',
  last_discovered_at: null,
  models: ['first-model', 'gpt-5.6-luna', 'manual-model'].map((id) => ({
    id, display_name: null, origin: 'discovered', reasoning_efforts: [], reasoning_efforts_source: null,
  })),
};
const answer = (patch: Partial<SourceProbeResult> = {}): SourceProbeResult => ({
  source_id: source.id, model_id: 'gpt-5.6-luna', protocol: 'openai_chat',
  reachable: true, latency_ms: 123, error: null, ...patch,
});
const landing = (sources: Source[] = [source]): SourceMutationLandingReads => ({
  sources: readyRegion(sources), supply: readyRegion([]), chains: readyRegion({}),
  runtime: readyRegion({
    contract_version: CONTRACT_VERSION,
    manifest: { name: 'cliproxyapi', resolution: 'unresolved', assets: [] },
    status: { verified: false, health: 'not_started' },
  }),
});
const settlement = {
  unread: vi.fn(),
  gone: vi.fn().mockResolvedValue(null),
} as unknown as SourceMutationSettlement;
const track: TrackSourceMutation = (work) => work(source, settlement);
const view = (current = source) => <I18nextProvider i18n={i18n}>
  <SourceTestDialog source={current} onClose={vi.fn()} trackMutation={track} />
</I18nextProvider>;

beforeEach(async () => {
  vi.mocked(settlement.unread).mockReset().mockResolvedValue(landing());
  await i18n.changeLanguage('en');
  vi.stubGlobal('ResizeObserver', class { observe() {} unobserve() {} disconnect() {} });
  Element.prototype.scrollIntoView = vi.fn();
});
afterEach(() => { cleanup(); vi.restoreAllMocks(); vi.unstubAllGlobals(); });

describe('SourceTestDialog', () => {
  it('does no work until the user starts and invokes only the chosen source/model', async () => {
    const probe = vi.spyOn(modelsApi, 'probeSource').mockResolvedValue(answer({ model_id: 'manual-model' }));
    const refresh = vi.spyOn(modelsApi, 'refreshSource');
    render(view());
    expect(screen.getByRole('combobox').textContent).toContain('gpt-5.6-luna');
    expect(probe).not.toHaveBeenCalled();
    const user = userEvent.setup();
    await user.click(screen.getByRole('combobox'));
    await user.click(await screen.findByRole('option', { name: 'manual-model' }));
    await user.click(screen.getByRole('button', { name: 'Run test' }));
    await screen.findByText(/manual-model responded successfully/);
    expect(probe).toHaveBeenCalledExactlyOnceWith(source.id, 'manual-model');
    expect(refresh).not.toHaveBeenCalled();
  });

  it.each([
    ['lifted', 'standby', false],
    ['kept', 'cooldown', true],
  ] as const)('reports a passing test that %s the cooldown', async (_case, landed, warned) => {
    const cooling: Source = { ...source, state: { status: 'cooldown', retry_at: null, detail_key: 'models.source.cooldown.server_error' } };
    vi.mocked(settlement.unread).mockResolvedValue(landing([{ ...cooling, state: { ...cooling.state, status: landed } }]));
    vi.spyOn(modelsApi, 'probeSource').mockResolvedValue(answer());
    render(view(cooling));
    await userEvent.click(screen.getByRole('button', { name: 'Run test' }));
    const reported = await screen.findByText(/responded successfully/);
    expect(reported.textContent?.includes('still marked unavailable')).toBe(warned);
  });

  it('keeps the result when success clears pending verification', async () => {
    vi.spyOn(modelsApi, 'probeSource').mockResolvedValue(answer());
    const rendered = render(view());
    await userEvent.click(screen.getByRole('button', { name: 'Run test' }));
    await screen.findByText(/responded successfully/);
    rendered.rerender(view({ ...source, verification_pending: null }));
    expect(screen.getByText(/responded successfully/)).toBeTruthy();
  });

  it.each([
    ['a replacement credential', { credential_ref: 'cred_new', verification_pending: 'vp_new', credential_generation: 'vp_new' }],
    ['a verified same-handle reauthentication', { verification_pending: null, credential_generation: 'vp_new' }],
  ])('cannot show a late success for %s', async (_name, replacement) => {
    let resolve!: (result: SourceProbeResult) => void;
    vi.spyOn(modelsApi, 'probeSource').mockReturnValue(new Promise((done) => { resolve = done; }));
    const rendered = render(view());
    await userEvent.click(screen.getByRole('button', { name: 'Run test' }));
    rendered.rerender(view({ ...source, ...replacement }));
    resolve(answer());
    await waitFor(() => expect(screen.getByRole('button', { name: 'Run test' }).hasAttribute('disabled')).toBe(false));
    expect(screen.queryByText(/responded successfully/)).toBeNull();
  });

  it('explains unavailable results without losing the selected model or provider', async () => {
    vi.spyOn(modelsApi, 'probeSource').mockRejectedValue(new Error('unavailable'));
    render(view());
    await userEvent.click(screen.getByRole('button', { name: 'Run test' }));
    expect((await screen.findByRole('alert')).textContent).toContain('Your provider is still saved');
    expect(screen.getByRole('combobox').textContent).toContain('gpt-5.6-luna');
    expect(settlement.unread).toHaveBeenCalledTimes(1);
  });

  it.each([true, false])('publishes no result before reconciliation completes: reachable=%s', async (reachable) => {
    vi.spyOn(modelsApi, 'probeSource').mockResolvedValue(answer({ reachable }));
    let resolve!: (value: SourceMutationLanding) => void;
    vi.mocked(settlement.unread).mockReturnValue(new Promise((done) => { resolve = done; }));
    render(view());
    await userEvent.click(screen.getByRole('button', { name: 'Run test' }));
    await waitFor(() => expect(settlement.unread).toHaveBeenCalledTimes(1));
    expect(screen.queryByRole('status')).toBeNull();
    expect(screen.queryByRole('alert')).toBeNull();
    resolve(landing());
    expect((await screen.findByRole('status')).textContent).toContain('gpt-5.6-luna');
    expect(screen.queryByRole('alert')).toBeNull();
  });

  it.each([true, false])('does not retry or publish a result after rejected reconciliation: reachable=%s', async (reachable) => {
    const probe = vi.spyOn(modelsApi, 'probeSource').mockResolvedValue(answer({ reachable }));
    vi.mocked(settlement.unread).mockRejectedValue(new Error('Source list unavailable'));
    render(view());
    await userEvent.click(screen.getByRole('button', { name: 'Run test' }));
    await screen.findByRole('alert');
    expect(screen.queryByRole('status')).toBeNull();
    expect(settlement.unread).toHaveBeenCalledTimes(1);
    expect(probe).toHaveBeenCalledTimes(1);
  });

  it.each(['unread', 'superseded', 'deleted', 'credential', 'reauth', 'verified-reauth', 'base_url', 'protocol', 'model'])('requires a current matching Source after reconciliation: %s', async (change) => {
    vi.spyOn(modelsApi, 'probeSource').mockResolvedValue(answer());
    const current = { ...source };
    if (change === 'credential') current.credential_ref = 'cred_replacement';
    // A same-handle reauthentication keeps the ref and mints a new generation, which verification keeps.
    if (change === 'reauth') Object.assign(current, { verification_pending: 'vp_replacement', credential_generation: 'vp_replacement' });
    if (change === 'verified-reauth') Object.assign(current, { verification_pending: null, credential_generation: 'vp_replacement' });
    if (change === 'base_url') current.base_url = 'https://other.example/v1';
    if (change === 'protocol') current.protocol = 'anthropic';
    if (change === 'model') current.models = [];
    const reads = landing(change === 'deleted' ? [] : [current]);
    if (change === 'unread') reads.sources = unreadRegion();
    // `superseded`: a newer read took the surface over, so this mutation's own
    // read never published one — indistinguishable here from a read it could
    // not complete, and equally unable to confirm the probe.
    const result: SourceMutationLanding = change === 'superseded' ? null : reads;
    vi.mocked(settlement.unread).mockResolvedValue(result);
    render(view());
    await userEvent.click(screen.getByRole('button', { name: 'Run test' }));
    await screen.findByRole('alert');
    expect(screen.queryByRole('status')).toBeNull();
    expect(settlement.unread).toHaveBeenCalledTimes(1);
  });

  it('accepts reconciliation that clears the tested credential marker', async () => {
    vi.spyOn(modelsApi, 'probeSource').mockResolvedValue(answer());
    vi.mocked(settlement.unread).mockResolvedValue(landing([{ ...source, verification_pending: null }]));
    render(view());
    await userEvent.click(screen.getByRole('button', { name: 'Run test' }));
    await screen.findByText(/responded successfully/);
    expect(screen.queryByRole('alert')).toBeNull();
  });

  it('invalidates a reconciliation result when the dialog identity changes while it waits', async () => {
    vi.spyOn(modelsApi, 'probeSource').mockResolvedValue(answer());
    let resolve!: (value: SourceMutationLanding) => void;
    vi.mocked(settlement.unread).mockReturnValue(new Promise((done) => { resolve = done; }));
    const rendered = render(view());
    await userEvent.click(screen.getByRole('button', { name: 'Run test' }));
    await waitFor(() => expect(settlement.unread).toHaveBeenCalledTimes(1));
    rendered.rerender(view({ ...source, credential_ref: 'cred_new', verification_pending: 'vp_new', credential_generation: 'vp_new' }));
    resolve(landing());
    await waitFor(() => expect(screen.getByRole('button', { name: 'Run test' }).hasAttribute('disabled')).toBe(false));
    expect(screen.queryByRole('status')).toBeNull();
    expect(screen.queryByRole('alert')).toBeNull();
  });

  it('replaces an unconfirmed status only after a new explicit test settles', async () => {
    const probe = vi.spyOn(modelsApi, 'probeSource').mockResolvedValue(answer());
    vi.mocked(settlement.unread).mockRejectedValueOnce(new Error('unavailable'));
    render(view());
    await userEvent.click(screen.getByRole('button', { name: 'Run test' }));
    await screen.findByRole('alert');
    expect(probe).toHaveBeenCalledTimes(1);
    await userEvent.click(screen.getByRole('button', { name: 'Run test' }));
    await screen.findByText(/responded successfully/);
    expect(screen.queryByRole('alert')).toBeNull();
    expect(probe).toHaveBeenCalledTimes(2);
    expect(settlement.unread).toHaveBeenCalledTimes(2);
  });

  it.each(['remove', 'retire', 'empty'])('clears a completed result when inventory changes selection: %s', async (change) => {
    vi.spyOn(modelsApi, 'probeSource').mockResolvedValue(answer());
    const rendered = render(view());
    await userEvent.click(screen.getByRole('button', { name: 'Run test' }));
    await screen.findByText(/responded successfully/);
    const models = change === 'empty' ? [] : change === 'remove'
      ? source.models.filter((model) => model.id !== 'gpt-5.6-luna')
      : source.models.map((model) => ({ ...model, retired: model.id === 'gpt-5.6-luna' }));
    rendered.rerender(view({ ...source, models }));
    expect(screen.queryByRole('status')).toBeNull();
    if (change !== 'empty') expect(screen.getByRole('combobox').textContent).toContain('first-model');
  });

  it('rejects a late result after inventory chooses a different model', async () => {
    let resolve!: (result: SourceProbeResult) => void;
    vi.spyOn(modelsApi, 'probeSource').mockReturnValue(new Promise((done) => { resolve = done; }));
    const rendered = render(view());
    await userEvent.click(screen.getByRole('button', { name: 'Run test' }));
    rendered.rerender(view({ ...source, models: source.models.filter((model) => model.id !== 'gpt-5.6-luna') }));
    resolve(answer());
    await waitFor(() => expect(screen.getByRole('button', { name: 'Run test' }).hasAttribute('disabled')).toBe(false));
    expect(screen.getByRole('combobox').textContent).toContain('first-model');
    expect(screen.queryByRole('status')).toBeNull();
  });

  it('preserves a result across inventory updates that retain the selected model', async () => {
    vi.spyOn(modelsApi, 'probeSource').mockResolvedValue(answer());
    const rendered = render(view());
    await userEvent.click(screen.getByRole('button', { name: 'Run test' }));
    await screen.findByText(/responded successfully/);
    rendered.rerender(view({ ...source, models: [...source.models].reverse() }));
    expect(screen.getByRole('combobox').textContent).toContain('gpt-5.6-luna');
    expect(screen.getByText(/responded successfully/)).toBeTruthy();
  });

  it.each([
    [true, 'model-hub-ink-mint', 'text-destructive-ink'],
    [false, 'text-destructive-ink', 'model-hub-ink-mint'],
  ] as const)('colours the result by outcome: reachable=%s', async (reachable, shown, absent) => {
    vi.spyOn(modelsApi, 'probeSource').mockResolvedValue(answer({ reachable }));
    render(view());
    await userEvent.click(screen.getByRole('button', { name: 'Run test' }));
    const reported = await screen.findByRole('status');
    expect(reported.classList.contains(shown)).toBe(true);
    expect(reported.classList.contains(absent)).toBe(false);
    expect(reported.querySelector('svg')?.getAttribute('aria-hidden')).toBe('true');
    expect(reported.textContent).toMatch(reachable ? /responded successfully/ : /did not pass this test/);
  });

  it('lets an empty inventory exit to the existing manual model editor', () => {
    render(view({ ...source, models: [] }));
    expect(screen.getByText(/add a model ID manually/)).toBeTruthy();
    expect(screen.getByRole('button', { name: 'Run test' }).hasAttribute('disabled')).toBe(true);
    expect(screen.getAllByRole('button', { name: 'Close' }).length).toBeGreaterThan(0);
  });
});