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.

13.3 KB
Raw Blame
/* @vitest-environment jsdom */
import { act, cleanup, renderHook, waitFor } from '@testing-library/react';
import { afterEach, beforeEach, expect, it, vi } from 'vitest';
import type { ComposerAttachment } from '../components/workbench/Composer';
const mocks = vi.hoisted(() => ({
  create: vi.fn(), upload: vi.fn(), fetch: vi.fn(), events: undefined as undefined | (() => void),
  fastDefault: false, setFastDefault: vi.fn(),
  projects: [
    { id: '中文项目', capabilities: { can_chat: true }, created_at: '2026-09-19T00:00:00Z' },
    { id: '其他项目', capabilities: { can_chat: true }, created_at: '2026-09-18T00:00:00Z' },
  ],
}));
const api = {
  listVibeAgents: async () => ({ agents: [{ id: 'a', name: 'codex', backend: 'codex', enabled: true }], default_agent_name: 'codex' }),
  connectWorkbenchEvents: ({ onAuthorizationChanged }: { onAuthorizationChanged: () => void }) => {
    mocks.events = onAuthorizationChanged;
    return () => {};
  },
  getWorkbenchPrefs: async () => ({ background_work_banner_enabled: true, fast_mode_default: mocks.fastDefault }),
  setFastModeDefault: mocks.setFastDefault,
};
vi.mock('../context/ApiContext', () => ({ useApi: () => api }));
vi.mock('../context/WorkbenchProjectsContext', () => ({ useWorkbenchProjectsTree: () => ({ projects: mocks.projects, projectsError: null, createSessionForProject: mocks.create }) }));
vi.mock('./apiFetch', () => ({ apiFetch: mocks.fetch }));
vi.mock('./workbenchUpload', async (original) => ({ ...await original<typeof import('./workbenchUpload')>(), uploadWorkbenchAttachment: mocks.upload }));
import { useNewSession } from './useNewSession';
import { RouteSurfaceActiveContext } from './routeSurfaceActivity';
const attachment: ComposerAttachment = { localId: 'file-id', file: new File(['内容'], '中文.txt'), token: '', name: '中文.txt', mime: 'text/plain', size: 6, kind: 'file', url: '', status: 'staged' };
const mount = () => renderHook(() => useNewSession({ loadErrorText: 'load failed', createFailedText: 'send failed' }));
beforeEach(() => {
  mocks.create.mockReset().mockImplementation(async () => ({ id: `session-${mocks.create.mock.calls.length}` }));
  mocks.upload.mockReset().mockResolvedValue({ token: 'token', name: '中文.txt', mime: 'text/plain', size: 6, kind: 'file', url: '/api/media/token' });
  mocks.fetch.mockReset().mockResolvedValue(new Response('{}', { status: 201 }));
  mocks.fastDefault = false;
  mocks.setFastDefault.mockReset().mockResolvedValue({});
});
afterEach(cleanup);
it('creates and submits once from a same-tick double send, only after explicit input', async () => {
  const { result } = mount();
  await waitFor(() => expect(result.current.loaded).toBe(true));
  expect(mocks.create).not.toHaveBeenCalled();
  await act(async () => { await Promise.all([result.current.send('', [attachment]), result.current.send('', [attachment])]); });
  expect(mocks.create).toHaveBeenCalledTimes(1);
  expect(mocks.fetch).toHaveBeenCalledTimes(1);
  expect(mocks.upload).toHaveBeenCalledWith('session-1', attachment.file, attachment.localId);
});
it('preserves successful uploads for retry but creates a fresh media scope when the selection changes', async () => {
  const { result } = mount();
  await waitFor(() => expect(result.current.loaded).toBe(true));
  mocks.fetch.mockResolvedValueOnce(new Response('{"state":"retired"}', { status: 502 }));
  await act(async () => { expect(await result.current.send('初稿', [attachment])).toBeNull(); });
  act(() => result.current.setSelected('其他项目'));
  await act(async () => { await result.current.send('初稿', [attachment]); });
  expect(mocks.create).toHaveBeenNthCalledWith(2, '其他项目', {});
  expect(mocks.upload).toHaveBeenNthCalledWith(2, 'session-2', attachment.file, attachment.localId);
});
it('captures the project and Agent at Send rather than reading later live selections', async () => {
  let release!: (session: { id: string }) => void;
  mocks.create.mockReturnValue(new Promise((resolve) => { release = resolve; }));
  const { result } = mount();
  await waitFor(() => expect(result.current.loaded).toBe(true));
  let submission!: ReturnType<typeof result.current.send>;
  act(() => { submission = result.current.send('中文', [attachment]); });
  act(() => result.current.setSelected('其他项目'));
  await act(async () => { release({ id: 'captured-session' }); await submission; });
  expect(mocks.create).toHaveBeenCalledWith('中文项目', {});
  expect(mocks.upload).toHaveBeenCalledWith('captured-session', attachment.file, attachment.localId);
  expect(mocks.fetch.mock.calls[0][0]).toBe('/api/sessions/captured-session/messages');
});
it('authorization changes terminate a pending submission before upload or dispatch', async () => {
  let release!: (session: { id: string }) => void;
  mocks.create.mockReturnValue(new Promise((resolve) => { release = resolve; }));
  const { result } = mount();
  await waitFor(() => expect(result.current.loaded).toBe(true));
  let submission!: ReturnType<typeof result.current.send>;
  act(() => { submission = result.current.send('中文', [attachment]); });
  await act(async () => { mocks.events?.(); });
  await act(async () => { release({ id: 'captured-session' }); expect(await submission).toBeNull(); });
  expect(mocks.upload).not.toHaveBeenCalled();
  expect(mocks.fetch).not.toHaveBeenCalled();
});
it.each(['network', 'pending'])('uncertain %s admission cannot be resubmitted', async (kind) => {
  const { result } = mount();
  await waitFor(() => expect(result.current.loaded).toBe(true));
  if (kind === 'network') mocks.fetch.mockRejectedValue(new Error('lost acknowledgment'));
  else mocks.fetch.mockResolvedValue(new Response('{"dispatch_error":"dispatch_pending"}', { status: 504 }));
  await act(async () => { expect(await result.current.send('中文', [attachment])).toBeNull(); });
  expect(result.current.uncertainSessionId).toBe('session-1');
  await act(async () => { expect(await result.current.send('中文', [attachment])).toBeNull(); });
  expect(mocks.fetch).toHaveBeenCalledTimes(1);
});

it('a fresh sheet open starts a new submission lifetime after an uncertain send', async () => {
  const { result, rerender } = renderHook(({ active }) => useNewSession({ active, loadErrorText: 'load failed', createFailedText: 'send failed' }), { initialProps: { active: true } });
  await waitFor(() => expect(result.current.loaded).toBe(true));
  mocks.fetch.mockRejectedValueOnce(new Error('lost acknowledgment'));
  await act(async () => { await result.current.send('第一条'); });
  expect(result.current.uncertainSessionId).toBe('session-1');
  rerender({ active: false });
  rerender({ active: true });
  await waitFor(() => expect(result.current.loaded).toBe(true));
  expect(result.current.uncertainSessionId).toBeNull();
  await act(async () => { expect(await result.current.send('新的对话')).toEqual({ sessionId: 'session-2' }); });
  expect(mocks.create).toHaveBeenCalledTimes(2);
});

it.each(['create', 'message'])('a response from the closed sheet %s cannot alter a new sheet lifetime', async (stage) => {
  let release!: (value: unknown) => void;
  const held = new Promise((resolve) => { release = resolve; });
  if (stage === 'create') mocks.create.mockReturnValueOnce(held);
  else mocks.fetch.mockReturnValueOnce(held);
  const { result, rerender } = renderHook(({ active }) => useNewSession({ active, loadErrorText: 'load failed', createFailedText: 'send failed' }), { initialProps: { active: true } });
  await waitFor(() => expect(result.current.loaded).toBe(true));
  let prior!: ReturnType<typeof result.current.send>;
  act(() => { prior = result.current.send('旧对话'); });
  await waitFor(() => expect(stage === 'create' ? mocks.create : mocks.fetch).toHaveBeenCalledTimes(1));
  rerender({ active: false });
  rerender({ active: true });
  await waitFor(() => expect(result.current.loaded).toBe(true));
  await act(async () => {
    release(stage === 'create' ? { id: 'old-session' } : new Response('{"dispatch_error":"dispatch_pending"}', { status: 504 }));
    expect(await prior).toBeNull();
  });
  expect(result.current.uncertainSessionId).toBeNull();
  await act(async () => { expect(await result.current.send('新对话')).not.toBeNull(); });
  expect(mocks.create).toHaveBeenCalledTimes(2);
});

it.each([403, 404, 409])('terminal message HTTP %s discards only the invalid scope, preserving the original file for retry', async (status) => {
  const { result } = mount();
  await waitFor(() => expect(result.current.loaded).toBe(true));
  mocks.fetch.mockResolvedValueOnce(new Response('{"error":"session unavailable"}', { status }));
  await act(async () => { expect(await result.current.send('重试', [attachment])).toBeNull(); });
  await act(async () => { expect(await result.current.send('重试', [attachment])).toEqual({ sessionId: 'session-2' }); });
  expect(mocks.upload).toHaveBeenNthCalledWith(2, 'session-2', attachment.file, attachment.localId);
});

it('a missing upload session gets a new scope on explicit retry', async () => {
  const { WorkbenchUploadError } = await import('./workbenchUpload');
  mocks.upload.mockRejectedValueOnce(new WorkbenchUploadError('session_not_found', 'missing', 404));
  const { result } = mount();
  await waitFor(() => expect(result.current.loaded).toBe(true));
  await act(async () => { expect(await result.current.send('', [attachment])).toBeNull(); });
  expect(mocks.fetch).not.toHaveBeenCalled();
  await act(async () => { expect(await result.current.send('', [attachment])).toEqual({ sessionId: 'session-2' }); });
  expect(mocks.upload).toHaveBeenNthCalledWith(2, 'session-2', attachment.file, attachment.localId);
});

it.each(['create', 'upload'])('foreground suspension after %s retains scope and stops before POST until explicit retry', async (stage) => {
  let release!: (value: unknown) => void;
  const held = new Promise((resolve) => { release = resolve; });
  if (stage === 'create') mocks.create.mockReturnValueOnce(held);
  else mocks.upload.mockReturnValueOnce(held);
  let foreground = true;
  const { result, rerender } = renderHook(() => useNewSession({ active: true, loadErrorText: 'load failed', createFailedText: 'send failed' }), {
    wrapper: ({ children }) => <RouteSurfaceActiveContext.Provider value={foreground}>{children}</RouteSurfaceActiveContext.Provider>,
  });
  await waitFor(() => expect(result.current.loaded).toBe(true));
  let attempt!: ReturnType<typeof result.current.send>;
  act(() => { attempt = result.current.send('挂起草稿', [attachment]); });
  await waitFor(() => expect(stage === 'create' ? mocks.create : mocks.upload).toHaveBeenCalledTimes(1));
  foreground = false;
  rerender();
  await act(async () => {
    release(stage === 'create' ? { id: 'session-1' } : { token: 'uploaded', name: attachment.name });
    expect(await attempt).toBeNull();
  });
  expect(mocks.fetch).not.toHaveBeenCalled();
  await act(async () => { expect(await result.current.send('后台禁止发送')).toBeNull(); });
  foreground = true;
  rerender();
  await act(async () => { expect(await result.current.send('挂起草稿', [attachment])).toEqual({ sessionId: 'session-1' }); });
  expect(mocks.create).toHaveBeenCalledTimes(1);
  expect(mocks.upload).toHaveBeenCalledTimes(1);
  expect(mocks.fetch).toHaveBeenCalledTimes(1);
});

it.each(['success', 'uncertain'])('already admitted POST %s survives suspension without resetting the sheet lifetime', async (outcome) => {
  let release!: (value: Response) => void;
  mocks.fetch.mockReturnValueOnce(new Promise<Response>((resolve) => { release = resolve; }));
  let foreground = true;
  const { result, rerender } = renderHook(() => useNewSession({ active: true, loadErrorText: 'load failed', createFailedText: 'send failed' }), {
    wrapper: ({ children }) => <RouteSurfaceActiveContext.Provider value={foreground}>{children}</RouteSurfaceActiveContext.Provider>,
  });
  await waitFor(() => expect(result.current.loaded).toBe(true));
  let attempt!: ReturnType<typeof result.current.send>;
  act(() => { attempt = result.current.send('发送已受理'); });
  await waitFor(() => expect(mocks.fetch).toHaveBeenCalledTimes(1));
  foreground = false;
  rerender();
  await act(async () => {
    release(outcome === 'success' ? new Response('{}', { status: 201 }) : new Response('{"dispatch_error":"dispatch_pending"}', { status: 504 }));
    expect(await attempt).toEqual(outcome === 'success' ? { sessionId: 'session-1' } : null);
  });
  foreground = true;
  rerender();
  if (outcome === 'uncertain') {
    expect(result.current.uncertainSessionId).toBe('session-1');
    await act(async () => { expect(await result.current.send('不能重复')).toBeNull(); });
  }
  expect(mocks.create).toHaveBeenCalledTimes(1);
  expect(mocks.fetch).toHaveBeenCalledTimes(1);
});

it('starts at the remembered fast default, creates with it, and makes a change the next default', async () => {
  mocks.fastDefault = true;
  const { result } = mount();
  await waitFor(() => expect(result.current.speed).toBe('fast'));
  await waitFor(() => expect(result.current.loaded).toBe(true));
  await act(async () => { await result.current.send('快一点'); });
  expect(mocks.create).toHaveBeenLastCalledWith('中文项目', { speed: 'fast' });
  expect(mocks.setFastDefault).not.toHaveBeenCalled();

  act(() => result.current.setSpeed(null));
  expect(mocks.setFastDefault).toHaveBeenLastCalledWith(false);
  await act(async () => { await result.current.send('标准速度'); });
  expect(mocks.create).toHaveBeenLastCalledWith('中文项目', {});
});