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
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { render, screen, fireEvent, cleanup, waitFor, within } from '@testing-library/react';
import { MemoryRouter } from 'react-router';
import CodeReviewersTab from './CodeReviewersTab';
import * as api from '../../services/api';
import toast from '../ui/Toast';
vi.mock('../../services/api', () => ({
getCodeReviewDefaults: vi.fn(),
updateSettings: vi.fn(),
getReviewerIdentities: vi.fn(),
}));
const pickerData = vi.hoisted(() => ({ current: { ctxById: {} } }));
vi.mock('../../hooks/useReviewerModelOptions', () => ({ default: () => pickerData.current }));
vi.mock('../ui/Toast', () => ({
default: {
success: vi.fn(),
error: vi.fn(),
},
}));
const renderTab = (ui, path = '/') => render(
<MemoryRouter initialEntries={[path]}>{ui}</MemoryRouter>,
);
const openFollowUp = async () => {
fireEvent.click(await screen.findByRole('tab', { name: 'Follow-up' }));
};
describe('CodeReviewersTab', () => {
beforeEach(() => {
vi.clearAllMocks();
pickerData.current = { ctxById: {} };
api.getReviewerIdentities.mockResolvedValue({ identities: [] });
});
afterEach(() => {
cleanup();
});
it('round-trips configured provider model and effort pins without changing legacy defaults', async () => {
pickerData.current = {
loaded: true,
providers: [
{ id: 'example-gpu', name: 'Example GPU', type: 'cli', command: 'claude', enabled: true, models: ['coder-a', 'coder-b'] },
{ id: 'disabled-api', name: 'Disabled API', type: 'api', enabled: false, models: ['other'] },
],
optionsByReviewer: { 'provider:example-gpu': ['coder-a', 'coder-b'] },
freeText: { 'provider:example-gpu': true },
};
api.getCodeReviewDefaults.mockResolvedValue({ reviewers: ['copilot'], codexModel: 'legacy-model', claudeEffort: 'medium' });
api.updateSettings.mockResolvedValue({});
const view = renderTab(<CodeReviewersTab />);
const provider = await screen.findByLabelText('Add AI provider');
expect(screen.queryByRole('option', { name: 'Disabled API' })).not.toBeInTheDocument();
fireEvent.change(provider, { target: { value: 'example-gpu' } });
fireEvent.change(screen.getByLabelText('Model for Example GPU'), { target: { value: 'coder-b' } });
fireEvent.change(screen.getByLabelText('Reasoning effort for Example GPU'), { target: { value: 'high' } });
fireEvent.click(screen.getByRole('button', { name: 'Save defaults' }));
await waitFor(() => expect(api.updateSettings).toHaveBeenCalledTimes(1));
const saved = api.updateSettings.mock.calls[0][0].codeReview;
expect(saved).toMatchObject({
reviewers: ['provider:example-gpu', 'copilot'],
providerModels: { 'provider:example-gpu': 'coder-b' },
providerEfforts: { 'provider:example-gpu': 'high' },
codexModel: 'legacy-model', claudeEffort: 'medium',
});
view.unmount();
api.getCodeReviewDefaults.mockResolvedValue(saved);
renderTab(<CodeReviewersTab />);
expect(await screen.findByLabelText('Model for Example GPU')).toHaveValue('coder-b');
expect(screen.getByLabelText('Reasoning effort for Example GPU')).toHaveValue('high');
fireEvent.change(screen.getByLabelText('Reasoning effort for Example GPU'), { target: { value: '' } });
fireEvent.click(screen.getByRole('button', { name: 'Save defaults' }));
await waitFor(() => expect(api.updateSettings).toHaveBeenCalledTimes(2));
expect(api.updateSettings.mock.calls[1][0].codeReview).toMatchObject({
providerModels: { 'provider:example-gpu': 'coder-b' }, providerEfforts: {},
codexModel: 'legacy-model', claudeEffort: 'medium',
});
await waitFor(() => expect(screen.getByRole('button', { name: 'Save defaults' })).not.toBeDisabled());
fireEvent.click(screen.getByLabelText('Remove Example GPU'));
fireEvent.click(screen.getByRole('button', { name: 'Save defaults' }));
await waitFor(() => expect(api.updateSettings).toHaveBeenCalledTimes(3));
expect(api.updateSettings.mock.calls[2][0].codeReview).toMatchObject({ reviewers: ['copilot'], providerModels: {}, providerEfforts: {} });
});
it('edits persisted tier priority, shares pins across memberships, and saves only nonempty tiers', async () => {
const token = 'provider:example-gpu';
pickerData.current = {
loaded: true, providers: [{ id: 'example-gpu', name: 'Example GPU', enabled: true, command: 'codex', models: ['custom-coder'] }],
optionsByReviewer: { [token]: ['custom-coder'] },
};
api.getCodeReviewDefaults.mockResolvedValue({
// The active runtime tier is intentionally not the configured Primary.
reviewers: ['codex'], reviewerFallbackGroups: [[token, 'ollama'], ['codex']],
providerModels: { [token]: 'custom-coder' }, providerEfforts: { [token]: 'high' },
optionalReviewers: [token, '@example-bot'], reviewerMaxRounds: { [token]: 1, '@example-bot': 2 },
usernames: ['example-bot'], stopMode: 'consensus', reviewerApplies: true,
});
api.updateSettings.mockResolvedValue({});
const view = renderTab(<CodeReviewersTab />);
const primary = await screen.findByRole('region', { name: 'Primary' });
expect(within(primary).getByLabelText('Model for Example GPU')).toHaveValue('custom-coder');
expect(api.updateSettings).not.toHaveBeenCalled();
expect(screen.queryByLabelText('Fallback reviewer groups')).not.toBeInTheDocument();
const fallback = screen.getByRole('region', { name: 'Fallback 1' });
fireEvent.change(within(fallback).getByLabelText('Add AI provider'), { target: { value: 'example-gpu' } });
expect(screen.getAllByLabelText('Model for Example GPU')).toHaveLength(2);
expect(within(within(fallback).getByLabelText('Add AI provider')).queryByRole('option', { name: 'Example GPU' })).not.toBeInTheDocument();
fireEvent.change(within(fallback).getByLabelText('Reasoning effort for Example GPU'), { target: { value: 'low' } });
expect(within(primary).getByLabelText('Reasoning effort for Example GPU')).toHaveValue('low');
fireEvent.click(within(primary).getByLabelText('Remove Example GPU'));
expect(screen.getByLabelText('Model for Example GPU')).toHaveValue('custom-coder');
fireEvent.change(screen.getByLabelText('Tier for codex in Fallback 1'), { target: { value: 'tier-0' } });
fireEvent.click(screen.getByLabelText('Move Primary later'));
fireEvent.click(screen.getByText('Add tier'));
fireEvent.click(screen.getByText('Save defaults'));
await waitFor(() => expect(toast.success).toHaveBeenCalled());
const saved = api.updateSettings.mock.lastCall[0].codeReview;
expect(saved).toMatchObject({
reviewers: [token], reviewerFallbackGroups: [[token], ['ollama', 'codex']],
providerModels: { [token]: 'custom-coder' }, providerEfforts: { [token]: 'low' },
optionalReviewers: [token, '@example-bot'], reviewerMaxRounds: { [token]: 1, '@example-bot': 2 },
usernames: ['example-bot'], stopMode: 'consensus', reviewerApplies: true,
});
expect(screen.queryByRole('region', { name: 'Fallback 2' })).not.toBeInTheDocument();
view.unmount();
api.getCodeReviewDefaults.mockResolvedValue(saved);
renderTab(<CodeReviewersTab />);
fireEvent.click(await screen.findByText('Save defaults'));
await waitFor(() => expect(api.updateSettings).toHaveBeenCalledTimes(2));
expect(api.updateSettings.mock.lastCall[0].codeReview).toEqual(saved);
await waitFor(() => expect(screen.getByText('Save defaults')).not.toBeDisabled());
fireEvent.click(screen.getByLabelText('Remove Primary'));
expect(screen.queryByLabelText('Model for Example GPU')).not.toBeInTheDocument();
fireEvent.click(screen.getByLabelText('Remove Primary'));
fireEvent.click(screen.getByText('Save defaults'));
await waitFor(() => expect(api.updateSettings).toHaveBeenCalledTimes(3));
expect(api.updateSettings.mock.lastCall[0].codeReview).toMatchObject({
reviewers: [], reviewerFallbackGroups: [], usernames: ['example-bot'], providerModels: {}, providerEfforts: {},
optionalReviewers: ['@example-bot'], reviewerMaxRounds: { '@example-bot': 2 },
});
});
it('respects explicit empty groups despite a legacy roster and gates failed or in-flight saves', async () => {
api.getCodeReviewDefaults.mockResolvedValue({ reviewers: ['codex'], reviewerFallbackGroups: [], usernames: ['example-bot'] });
let rejectSave;
api.updateSettings.mockImplementationOnce(() => new Promise((_, reject) => { rejectSave = reject; }));
renderTab(<CodeReviewersTab />);
fireEvent.click(await screen.findByText('Save defaults'));
expect(screen.getByText('Saving…')).toBeDisabled();
expect(screen.getByText('Add tier')).toBeDisabled();
expect(screen.getByLabelText('Remove @example-bot')).toBeDisabled();
expect(api.updateSettings.mock.lastCall[0].codeReview).toMatchObject({ reviewers: [], reviewerFallbackGroups: [], usernames: ['example-bot'] });
rejectSave(new Error('example failure'));
await waitFor(() => expect(toast.error).toHaveBeenCalledWith(expect.stringContaining('example failure')));
expect(toast.success).not.toHaveBeenCalled();
expect(screen.getByLabelText('Remove @example-bot')).not.toBeDisabled();
api.updateSettings.mockResolvedValue({});
fireEvent.click(screen.getByText('Save defaults'));
await waitFor(() => expect(toast.success).toHaveBeenCalled());
});
it('does not enable save after a malformed defaults response', async () => {
api.getCodeReviewDefaults.mockResolvedValue({ reviewers: ['codex'], reviewerFallbackGroups: [['codex'], null] });
renderTab(<CodeReviewersTab />);
expect(await screen.findByText('Failed to load code review defaults.')).toBeInTheDocument();
expect(screen.getByText('Save defaults')).toBeDisabled();
expect(api.updateSettings).not.toHaveBeenCalled();
});
it('renders loading state initially and populates panel when fetch succeeds', async () => {
api.getCodeReviewDefaults.mockResolvedValue({
reviewers: ['codex'],
usernames: [],
optionalReviewers: [],
reviewerMaxRounds: {},
stopMode: 'consensus',
reviewerApplies: false,
});
renderTab(<CodeReviewersTab />);
expect(screen.getByText('Loading defaults…')).toBeInTheDocument();
expect(await screen.findByText('Save defaults')).toBeInTheDocument();
expect(screen.queryByText('Failed to load code review defaults.')).not.toBeInTheDocument();
expect(screen.getByRole('button', { name: 'Save defaults' })).not.toBeDisabled();
expect(api.getCodeReviewDefaults).toHaveBeenCalledWith({ silent: true });
});
it('shows the last failed review attempt with the settings fix', async () => {
api.getCodeReviewDefaults.mockResolvedValue({
reviewers: ['ollama'],
reviewerConfigFaults: { ollama: { code: 'NO_MODEL', lastFailureAt: 123 } },
});
renderTab(<CodeReviewersTab />);
expect(await screen.findByText(/ollama: the last review attempt failed \(NO_MODEL\)/)).toBeInTheDocument();
expect(screen.getByText(/The next successful review clears this warning/)).toBeInTheDocument();
expect(screen.getByText(/Select a model on Review chain/)).toBeInTheDocument();
});
it('identifies a provider access refusal and its configuration remedy', async () => {
api.getCodeReviewDefaults.mockResolvedValue({
reviewers: ['opencode', 'codex'],
optionalReviewers: ['opencode'],
reviewerConfigFaults: { opencode: { code: 'REVIEWER_ACCESS_DENIED', lastFailureAt: 123 } },
});
renderTab(<CodeReviewersTab />);
expect(await screen.findByText(/opencode: the last review attempt failed/)).toHaveTextContent('Select an accessible service or model, or correct provider access.');
expect(screen.getByText(/The next successful review clears this warning/)).toBeInTheDocument();
});
it('names a headless command refusal and recommends a compatible reviewer without granting permissions', async () => {
api.getCodeReviewDefaults.mockResolvedValue({
reviewers: ['provider:example-cli'], optionalReviewers: ['provider:example-cli'],
reviewerConfigFaults: { 'provider:example-cli': { code: 'REVIEWER_COMMAND_PERMISSION_DENIED', lastFailureAt: 123 } },
});
renderTab(<CodeReviewersTab />);
expect(await screen.findByText(/provider:example-cli: the last review attempt failed/)).toHaveTextContent('Use a compatible non-interactive review transport or supported tool-free vendor configuration; keep command, network and write permissions disabled.');
expect(screen.getByText(/The next successful review clears this warning/)).toBeInTheDocument();
});
it('renders error banner with Retry button and disables Save button when fetch rejects', async () => {
api.getCodeReviewDefaults.mockRejectedValue(new Error('Network error'));
renderTab(<CodeReviewersTab />);
expect(await screen.findByText('Failed to load code review defaults.')).toBeInTheDocument();
const retryBtn = screen.getByRole('button', { name: 'Retry' });
expect(retryBtn).toBeInTheDocument();
const saveBtn = screen.getByRole('button', { name: 'Save defaults' });
expect(saveBtn).toBeDisabled();
});
it('re-fetches defaults when Retry button is clicked and enables Save button on success', async () => {
api.getCodeReviewDefaults
.mockRejectedValueOnce(new Error('Network error'))
.mockResolvedValueOnce({
reviewers: ['codex'],
usernames: [],
optionalReviewers: [],
reviewerMaxRounds: {},
stopMode: 'consensus',
reviewerApplies: false,
});
renderTab(<CodeReviewersTab />);
expect(await screen.findByText('Failed to load code review defaults.')).toBeInTheDocument();
expect(screen.getByRole('button', { name: 'Save defaults' })).toBeDisabled();
const retryBtn = screen.getByRole('button', { name: 'Retry' });
fireEvent.click(retryBtn);
await waitFor(() => {
expect(screen.queryByText('Failed to load code review defaults.')).not.toBeInTheDocument();
});
expect(screen.getByRole('button', { name: 'Save defaults' })).not.toBeDisabled();
expect(api.getCodeReviewDefaults).toHaveBeenCalledTimes(2);
});
// The goal-fidelity gate (#5994) — the second review, which asks whether a
// finished run delivered the objective rather than whether the code is good.
it('round-trips the goal-fidelity gate, and defaults an absent block to on', async () => {
api.getCodeReviewDefaults.mockResolvedValue({
reviewers: ['ollama'],
usernames: [],
optionalReviewers: [],
reviewerMaxRounds: {},
stopMode: 'all',
reviewerApplies: false,
});
api.updateSettings.mockResolvedValue({});
renderTab(<CodeReviewersTab />);
await openFollowUp();
const checkbox = await screen.findByLabelText(/Check finished runs against the task objective/);
// An install that has never saved the block must read as ON — persisting a
// stored `false` here would silently switch off a gate nobody turned off.
expect(checkbox).toBeChecked();
fireEvent.change(screen.getByLabelText('Local model runtime'), { target: { value: 'lmstudio' } });
fireEvent.click(screen.getByRole('button', { name: 'Save defaults' }));
await waitFor(() => expect(api.updateSettings).toHaveBeenCalled());
const [payload] = api.updateSettings.mock.calls[0];
// The scalars are dropped when unset (absent = inherit), and so is the
// trigger while neither action is armed — pinning it would freeze an
// install on today's default forever. The follow-up BOOLEANS always ride:
// false there is the user's OFF, not 'inherit', and dropping one would make
// that switch un-clearable once it had been on.
expect(payload.codeReview.goalFidelity).toEqual({
enabled: true, backend: 'lmstudio', fileIssue: false, queueTask: false,
});
});
it('sends an explicit off switch, and drops the unset pins rather than persisting empty ones', async () => {
api.getCodeReviewDefaults.mockResolvedValue({
reviewers: ['ollama'],
usernames: [],
optionalReviewers: [],
reviewerMaxRounds: {},
stopMode: 'all',
reviewerApplies: false,
goalFidelity: { enabled: true, backend: null, model: null, effort: null },
});
api.updateSettings.mockResolvedValue({});
renderTab(<CodeReviewersTab />);
await openFollowUp();
fireEvent.click(await screen.findByLabelText(/Check finished runs against the task objective/));
fireEvent.click(screen.getByRole('button', { name: 'Save defaults' }));
await waitFor(() => expect(api.updateSettings).toHaveBeenCalled());
expect(api.updateSettings.mock.calls[0][0].codeReview.goalFidelity).toEqual({
enabled: false, fileIssue: false, queueTask: false,
});
});
// The follow-up half (#7690): what happens once the gate HAS a finding.
it('round-trips the follow-up actions and their trigger', async () => {
api.getCodeReviewDefaults.mockResolvedValue({
reviewers: ['ollama'],
usernames: [],
optionalReviewers: [],
reviewerMaxRounds: {},
stopMode: 'all',
reviewerApplies: false,
goalFidelity: { enabled: true, fileIssue: true, queueTask: false, followUpOn: 'any-finding' },
});
api.updateSettings.mockResolvedValue({});
renderTab(<CodeReviewersTab />);
await openFollowUp();
expect(await screen.findByLabelText(/File an issue on the project/)).toBeChecked();
expect(screen.getByLabelText(/Queue an agent to reconcile it/)).not.toBeChecked();
expect(screen.getByLabelText('Act on which verdicts')).toHaveValue('any-finding');
fireEvent.click(screen.getByLabelText(/Queue an agent to reconcile it/));
fireEvent.click(screen.getByRole('button', { name: 'Save defaults' }));
await waitFor(() => expect(api.updateSettings).toHaveBeenCalled());
expect(api.updateSettings.mock.calls[0][0].codeReview.goalFidelity).toMatchObject({
fileIssue: true, queueTask: true, followUpOn: 'any-finding',
});
});
// Filing on someone's tracker and spawning an unattended run are each opt-in,
// so an absent block must read as off — the mirror image of `enabled` above.
it('defaults both follow-up actions to off when the stored block omits them', async () => {
api.getCodeReviewDefaults.mockResolvedValue({
reviewers: ['ollama'],
usernames: [],
optionalReviewers: [],
reviewerMaxRounds: {},
stopMode: 'all',
reviewerApplies: false,
goalFidelity: { enabled: true },
});
renderTab(<CodeReviewersTab />);
await openFollowUp();
expect(await screen.findByLabelText(/File an issue on the project/)).not.toBeChecked();
expect(screen.getByLabelText(/Queue an agent to reconcile it/)).not.toBeChecked();
// The trigger is meaningless until an action is armed.
expect(screen.getByLabelText('Act on which verdicts')).toBeDisabled();
});
// Turning the gate off leaves no verdict for a follow-up to act on, so the
// actions have to go inert with it rather than reading as still armed.
it('disables the follow-up actions when the gate itself is off', async () => {
api.getCodeReviewDefaults.mockResolvedValue({
reviewers: ['ollama'],
usernames: [],
optionalReviewers: [],
reviewerMaxRounds: {},
stopMode: 'all',
reviewerApplies: false,
goalFidelity: { enabled: false, fileIssue: true },
});
renderTab(<CodeReviewersTab />);
await openFollowUp();
expect(await screen.findByLabelText(/File an issue on the project/)).toBeDisabled();
expect(screen.getByLabelText(/Queue an agent to reconcile it/)).toBeDisabled();
});
it('keeps tier instructions in one drawer and splits follow-up onto its own view', async () => {
api.getCodeReviewDefaults.mockResolvedValue({
reviewers: ['codex'],
reviewerFallbackGroups: [['codex'], ['ollama']],
});
renderTab(<CodeReviewersTab />);
expect(await screen.findByRole('region', { name: 'Primary' })).toBeInTheDocument();
expect(screen.getByRole('region', { name: 'Fallback 1' })).toBeInTheDocument();
expect(screen.getAllByText(/One paused reviewer skips that whole tier/)).toHaveLength(1);
expect(screen.queryByText(/Add a configured provider/)).not.toBeInTheDocument();
expect(screen.queryByText(/Tool-free first/)).not.toBeInTheDocument();
expect(screen.queryByText(/The first tier with every member unpaused/)).not.toBeInTheDocument();
expect(screen.queryByLabelText(/Check finished runs against the task objective/)).not.toBeInTheDocument();
fireEvent.click(screen.getByRole('button', { name: 'How this works' }));
const help = await screen.findByRole('dialog', { name: 'How code review works' });
expect(within(help).getByText(/The first tier whose reviewers are all available runs/)).toBeInTheDocument();
expect(within(help).getByText(/Follow-up is a second check/)).toBeInTheDocument();
fireEvent.click(screen.getByRole('button', { name: 'Close how code review works' }));
await waitFor(() => expect(screen.queryByRole('dialog', { name: 'How code review works' })).not.toBeInTheDocument());
await openFollowUp();
expect(screen.queryByRole('region', { name: 'Primary' })).not.toBeInTheDocument();
expect(screen.getByLabelText(/Check finished runs against the task objective/)).toBeInTheDocument();
expect(screen.getByText(/After a run ships, compare its diff/)).toBeInTheDocument();
});
it('sends an unknown task slug back to the review chain', async () => {
api.getCodeReviewDefaults.mockResolvedValue({ reviewers: ['codex'] });
renderTab(<CodeReviewersTab />, '/models/code-reviewers/not-a-view');
expect(await screen.findByRole('region', { name: 'Primary' })).toBeInTheDocument();
expect(screen.getByRole('tab', { name: 'Review chain' })).toHaveAttribute('aria-selected', 'true');
});
it('names a saved reviewer the forge does not know, without touching the roster', async () => {
api.getCodeReviewDefaults.mockResolvedValue({ reviewers: ['codex'], usernames: ['ghost-user', 'flaky-user'] });
api.getReviewerIdentities.mockResolvedValue({ identities: [
{ token: 'ghost-user', kind: 'user', status: 'missing', required: true, reason: 'GitHub user "ghost-user" does not exist' },
{ token: 'flaky-user', kind: 'user', status: 'unavailable', required: true, reason: 'gh command timed out' },
] });
api.updateSettings.mockResolvedValue({});
renderTab(<CodeReviewersTab />);
expect(await screen.findByText(/@ghost-user: GitHub user "ghost-user" does not exist/)).toBeInTheDocument();
expect(screen.getByText(/required reviewer/)).toBeInTheDocument();
// An inconclusive lookup is not a fault to show.
expect(screen.queryByText(/flaky-user:/)).not.toBeInTheDocument();
fireEvent.click(screen.getByRole('button', { name: 'Save defaults' }));
await waitFor(() => expect(api.updateSettings).toHaveBeenCalledTimes(1));
expect(api.updateSettings.mock.calls[0][0].codeReview.usernames).toEqual(['ghost-user', 'flaky-user']);
});
});