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.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
/* @vitest-environment jsdom */
import { act, cleanup, renderHook, waitFor } from '@testing-library/react';
import { afterEach, describe, expect, it, vi } from 'vitest';
import type { DependenciesResult, DependencyItem, DependencyReadOptions } from '@/context/ApiContext';
import { DEPENDENCY_CHECK_GROUPS, useDependencyChecks } from './useDependencyChecks';
const row = (id: string, overrides: Partial<DependencyItem> = {}): DependencyItem => ({
id, kind: 'runtime', required: true, installed: true, status: 'ready', version: '1.2.3', ...overrides,
});
const ready = ({ ids = [] }: DependencyReadOptions = {}): DependenciesResult => ({
ok: true, deps: ids.map((id) => row(id)),
});
const deferred = () => {
let resolve!: (value: DependenciesResult) => void;
const promise = new Promise<DependenciesResult>((done) => { resolve = done; });
return { promise, resolve };
};
afterEach(cleanup);
describe('independent dependency checks', () => {
it('publishes completed groups while another group is still waiting', async () => {
const slow = deferred();
const read = vi.fn(async (options: DependencyReadOptions = {}) => (
options.ids?.includes('askill') ? slow.promise : ready(options)
));
const { result } = renderHook(() => useDependencyChecks(read));
act(() => { void result.current.refresh(); });
await waitFor(() => expect(result.current.checks.avault.data?.status).toBe('ready'));
expect(result.current.checks.askill).toEqual({ data: null, checking: true, error: null });
for (const ids of DEPENDENCY_CHECK_GROUPS) {
expect(read).toHaveBeenCalledWith({ ids, signal: expect.any(AbortSignal) });
}
expect(read).toHaveBeenCalledTimes(DEPENDENCY_CHECK_GROUPS.length);
await act(async () => slow.resolve(ready({ ids: ['askill'] })));
expect(result.current.checking).toBe(false);
});
it('rechecks only the owner of a repaired dependency and rejects an older result', async () => {
const old = deferred();
const read = vi.fn(async (options: DependencyReadOptions = {}) => ready(options));
const { result } = renderHook(() => useDependencyChecks(read));
read.mockImplementationOnce(() => old.promise);
act(() => { void result.current.refresh('node'); });
const oldSignal = read.mock.calls[0][0]?.signal;
await act(async () => result.current.refresh('node'));
expect(oldSignal?.aborted).toBe(true);
const current = result.current.checks['node'];
expect(read.mock.calls.map(([options]) => options?.ids)).toEqual([
['show-runtime', 'node'], ['show-runtime', 'node'],
]);
await act(async () => old.resolve({
ok: true,
deps: ['show-runtime', 'node'].map((id) => row(id, { installed: false, status: 'error' })),
}));
expect(result.current.checks['node']).toEqual(current);
});
it('keeps prior raw failure evidence when the latest inspection fails', async () => {
const source = Object.freeze(row('show-runtime', {
installed: false, status: 'error', readiness: 'not_ready', action_class: 'operator_only',
reason: 'runtime_inspection_failed',
}));
const failure = Object.freeze(row('node', {
installed: false, status: 'error', reason: 'runtime_timeout',
}));
const read = vi.fn().mockResolvedValue({ ok: true, deps: [source, failure] });
const { result } = renderHook(() => useDependencyChecks(read));
await act(async () => result.current.refresh('node'));
read.mockRejectedValue(new Error('unavailable'));
await act(async () => result.current.refresh('node'));
expect(result.current.checks['show-runtime']).toEqual({ data: source, checking: false, error: 'failed' });
expect(result.current.checks['node']).toEqual({ data: failure, checking: false, error: 'failed' });
});
it.each([{ ok: false, deps: [] }, { ok: true, deps: [] }, { ok: true, deps: [row('show-runtime')] }])(
'never treats an incomplete group response as checked: %j', async (response) => {
const { result } = renderHook(() => useDependencyChecks(vi.fn().mockResolvedValue(response)));
await act(async () => result.current.refresh('node'));
for (const id of ['show-runtime', 'node']) {
expect(result.current.checks[id]).toEqual({ data: null, checking: false, error: 'failed' });
}
},
);
it('refreshes a startup repair until settled without waiting on another group', async () => {
vi.useFakeTimers();
try {
const slow = deferred();
let repairing = true;
const read = vi.fn(async (options: DependencyReadOptions = {}) => (
options.ids?.includes('askill') ? slow.promise : {
...ready(options), reconciling: repairing,
reconciling_dependencies: repairing ? ['show-runtime'] : [],
}
));
const { result, unmount } = renderHook(() => useDependencyChecks(read));
act(() => { void result.current.refresh(); });
await act(async () => { await Promise.resolve(); });
expect(result.current.checks.askill.checking).toBe(true);
expect(result.current.checks['show-runtime'].reconciling).toBe(true);
repairing = false;
await act(async () => { await vi.advanceTimersByTimeAsync(1_500); });
expect(result.current.checks['show-runtime'].reconciling).toBe(false);
const calls = read.mock.calls.length;
await act(async () => { await vi.advanceTimersByTimeAsync(3_000); });
expect(read).toHaveBeenCalledTimes(calls);
unmount();
await act(async () => slow.resolve(ready({ ids: ['askill'] })));
} finally {
vi.useRealTimers();
}
});
it('cancels every owned request on unmount', async () => {
const slow = deferred();
const read = vi.fn((_options?: DependencyReadOptions) => slow.promise);
const { result, unmount } = renderHook(() => useDependencyChecks(read));
act(() => { void result.current.refresh(); });
unmount();
for (const [options] of read.mock.calls) expect(options?.signal?.aborted).toBe(true);
await act(async () => slow.resolve({ ok: true, deps: [] }));
});
});