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

19.8 KB
Raw Blame
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { render, screen, fireEvent, waitFor, within, act } from '@testing-library/react';
import { awaitEnabled } from '../../../test/enabledBarrier.js';

// ── Mock router — capture navigate calls, no real Router needed ────────────────
const mockNavigate = vi.hoisted(() => vi.fn());
vi.mock('react-router', async (importOriginal) => ({
  ...(await importOriginal()),
  useNavigate: () => mockNavigate,
}));
import { MemoryRouter, useLocation } from 'react-router';

// ── Mock toast ────────────────────────────────────────────────────────────────
const mockToast = vi.hoisted(() => Object.assign(vi.fn(), { success: vi.fn(), error: vi.fn(), loading: vi.fn(), dismiss: vi.fn() }));
vi.mock('../../ui/Toast', () => ({ default: mockToast }));

// ── Mock API ──────────────────────────────────────────────────────────────────
const api = vi.hoisted(() => ({
  getAppTaskTypes: vi.fn(),
  getCosSchedule: vi.fn(),
  getCosStatus: vi.fn(),
  getProviders: vi.fn(),
  updateAppTaskTypeOverride: vi.fn(),
  toggleAllAppTaskTypes: vi.fn(),
  triggerCosOnDemandTask: vi.fn(),
  resumeCos: vi.fn(),
  // Consumed by the nested CustomTasksSection on mount.
  getCosJobs: vi.fn(),
  createCosJob: vi.fn(),
  updateCosJob: vi.fn(),
  toggleCosJob: vi.fn(),
  triggerCosJob: vi.fn(),
  deleteCosJob: vi.fn(),
  getSettings: vi.fn(),
}));
vi.mock('../../../services/api', () => api);

const AutomationTab = (await import('./AutomationTab')).default;

const SCHEDULE = {
  tasks: {
    // Every row honors a per-app provider/model pin (#4783); the task's own pin
    // is what a row inherits when the app pins nothing.
    'layered-intelligence': { type: 'daily', taskMetadata: {}, providerId: 'global-claude' },
    'app-improvement': { type: 'rotation', taskMetadata: {} },
    security: { type: 'weekly', taskMetadata: { fileIssues: false }, fileIssuesCapable: true, defaultFileIssues: false },
  },
};

const PROVIDERS = {
  providers: [
    { id: 'claude-cli', name: 'Claude Code', type: 'cli', enabled: true, models: ['opus', 'sonnet'] },
    { id: 'global-claude', name: 'Global Claude', type: 'api', enabled: true, models: ['gpt-5.5'] },
    { id: 'disabled-one', name: 'Disabled', type: 'api', enabled: false, models: [] },
  ],
};

let currentSearch = '';
const LocationProbe = () => { currentSearch = useLocation().search; return null; };
const mountTab = (entry = '/?show=all') => render(
  <MemoryRouter initialEntries={[entry]}>
    <LocationProbe />
    <AutomationTab appId="app-1" appName="MyApp" />
  </MemoryRouter>
);

const renderTab = async (overrides = {}, entry) => {
  api.getAppTaskTypes.mockResolvedValue({ taskTypeOverrides: overrides });
  api.getCosSchedule.mockResolvedValue(SCHEDULE);
  api.getCosStatus.mockResolvedValue({ paused: false });
  api.getProviders.mockResolvedValue(PROVIDERS);
  api.getCosJobs.mockResolvedValue({ jobs: [] });
  api.getSettings.mockResolvedValue({ timezone: 'UTC' });
  api.updateAppTaskTypeOverride.mockResolvedValue({ success: true });
  mountTab(entry);
  await screen.findByRole('group', { name: 'Task visibility' });
  // Drain the remaining mount fetches (CustomTasksSection's getCosJobs etc.)
  // inside act — the schedule findByText above can win before they land.
  await act(async () => {});
};

// Find the task-row card that contains the given task-type label.
const rowFor = (taskType) => screen.getByText(taskType).closest('.bg-port-card');

beforeEach(() => {
  vi.clearAllMocks();
});

describe('AutomationTab per-app options', () => {
  it('acknowledges a slow run immediately, prevents duplicate clicks, and retains the queued receipt', async () => {
    await renderTab({ security: { enabled: true } });
    let resolveRun;
    api.triggerCosOnDemandTask.mockReturnValueOnce(new Promise(resolve => { resolveRun = resolve; }));
    mockToast.loading.mockReturnValueOnce('run-toast');
    const row = rowFor('security');
    fireEvent.click(within(row).getByRole('button', { name: 'Run Now' }));
    expect(mockToast.loading).toHaveBeenCalledWith('Sending security request for MyApp…');
    const sending = within(row).getByRole('button', { name: 'Sending…' });
    expect(sending).toBeDisabled();
    fireEvent.click(sending);
    expect(api.triggerCosOnDemandTask).toHaveBeenCalledTimes(1);
    expect(mockToast.success).not.toHaveBeenCalled();
    await act(async () => resolveRun({ success: true, request: { id: 'request-1' } }));
    expect(mockToast.dismiss).toHaveBeenCalledWith('run-toast');
    expect(mockToast.success).toHaveBeenCalledWith(expect.stringContaining('Queued security request for MyApp'));
    expect(within(row).getByText('Request queued')).toBeVisible();
    expect(within(row).getByRole('button', { name: 'Run Now' })).toBeEnabled();
  });

  it('clears sending feedback on rejection without claiming the run was queued', async () => {
    await renderTab({ security: { enabled: true } });
    api.triggerCosOnDemandTask.mockRejectedValueOnce(new Error('CoS unavailable'));
    mockToast.loading.mockReturnValueOnce('failed-run-toast');
    const row = rowFor('security');
    fireEvent.click(within(row).getByRole('button', { name: 'Run Now' }));
    await waitFor(() => expect(mockToast.dismiss).toHaveBeenCalledWith('failed-run-toast'));
    expect(mockToast.error).toHaveBeenCalledWith('CoS unavailable');
    expect(mockToast.success).not.toHaveBeenCalled();
    expect(within(row).queryByText('Request queued')).toBeNull();
    expect(within(row).getByRole('button', { name: 'Run Now' })).toBeEnabled();
  });

  it('lets the task cards use the full desktop width instead of a narrow column', async () => {
    api.getAppTaskTypes.mockResolvedValue({ taskTypeOverrides: {} });
    api.getCosSchedule.mockResolvedValue(SCHEDULE);
    api.getCosStatus.mockResolvedValue({ paused: false });
    api.getProviders.mockResolvedValue(PROVIDERS);
    api.getCosJobs.mockResolvedValue({ jobs: [] });
    api.getSettings.mockResolvedValue({ timezone: 'UTC' });
    const { container } = mountTab();
    await screen.findByText('layered-intelligence');
    await act(async () => {});

    // The tab used to cap itself well below the window, leaving the right of a
    // desktop screen empty. Only the cap is asserted — which breakpoints the
    // card grid uses is a retune anyone should be free to make.
    expect(container.querySelector('.max-w-5xl')).toBeNull();
  });

  it('puts custom automations before the shared schedule cards and shows app cadence', async () => {
    await renderTab({ security: { enabled: true, interval: 'on-demand' } });
    const custom = screen.getByText('Custom Tasks');
    const scheduled = screen.getByText('Scheduled Task Options');
    expect(custom.compareDocumentPosition(scheduled) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
    const row = rowFor('security');
    expect(within(row).getByRole('button', { name: 'Run Now' })).toBeEnabled();
    expect(within(row).queryByText('Never run')).toBeNull();
    expect(within(row).queryByText('App coverage')).toBeNull();
    expect(within(row).getByText('on-demand')).toBeInTheDocument();
  });

  it('saves the selected app toggle before permitting a run and preserves state on failure', async () => {
    await renderTab();
    const row = rowFor('security');
    let rejectSave;
    api.updateAppTaskTypeOverride.mockReturnValueOnce(new Promise((_resolve, reject) => { rejectSave = reject; }));
    fireEvent.click(within(row).getByRole('switch', { name: 'security enabled for this app: off' }));
    expect(api.updateAppTaskTypeOverride).toHaveBeenCalledWith('app-1', 'security', { enabled: true }, { silent: true });
    // In-flight save gates Run Now.
    expect(within(row).getByRole('button', { name: 'Run Now' })).toBeDisabled();
    await act(async () => rejectSave(new Error('Save failed')));
    expect(within(row).getByRole('switch', { name: 'security enabled for this app: off' })).toHaveAttribute('aria-checked', 'false');
    fireEvent.click(within(row).getByRole('switch', { name: 'security enabled for this app: off' }));
    api.updateAppTaskTypeOverride.mockResolvedValue({ success: true });
    await awaitEnabled(() => within(row).getByRole('button', { name: 'Run Now' }));
    api.triggerCosOnDemandTask.mockResolvedValue({ success: true });
    fireEvent.click(within(row).getByRole('button', { name: 'Run Now' }));
    await waitFor(() => expect(api.triggerCosOnDemandTask).toHaveBeenCalledWith('security', 'app-1', { silent: true }));
  });

  it('Run Now sends the app id while the per-app switch stays off', async () => {
    await renderTab();
    const row = rowFor('security');
    expect(within(row).getByRole('switch', { name: 'security enabled for this app: off' })).toBeInTheDocument();
    api.triggerCosOnDemandTask.mockResolvedValue({ success: true });
    const run = within(row).getByRole('button', { name: 'Run Now' });
    expect(run).toBeEnabled();
    fireEvent.click(run);
    await waitFor(() => expect(api.triggerCosOnDemandTask).toHaveBeenCalledWith('security', 'app-1', { silent: true }));
    expect(api.updateAppTaskTypeOverride).not.toHaveBeenCalled();
    expect(within(row).getByRole('switch', { name: 'security enabled for this app: off' })).toBeInTheDocument();
  });

  it('Configure toggle expands the provider override panel', async () => {
    await renderTab();
    const row = rowFor('layered-intelligence');
    const configureBtn = within(row).getByRole('button', { name: /show provider and model options/i });
    expect(configureBtn).toHaveAttribute('aria-expanded', 'false');
    // Provider selector is not rendered until expanded.
    expect(within(row).queryByLabelText('Provider override')).toBeNull();

    fireEvent.click(configureBtn);

    expect(configureBtn).toHaveAttribute('aria-expanded', 'true');
    expect(within(row).getByLabelText('Provider override')).toBeInTheDocument();
  });

  it('flags a provider override that diverges from the schedule pin, collapsed', async () => {
    // Schedule pins layered-intelligence to 'global-claude'; the app overrides
    // it to a DIFFERENT provider — the exact silent-shadowing scenario #4783
    // documents. Must be visible without expanding Configure.
    await renderTab({ 'layered-intelligence': { providerId: 'claude-cli' } });
    const row = rowFor('layered-intelligence');
    expect(within(row).getByText('Provider override')).toBeInTheDocument();
  });

  it('does not flag an override that matches the schedule pin', async () => {
    await renderTab({ 'layered-intelligence': { providerId: 'global-claude' } });
    const row = rowFor('layered-intelligence');
    expect(within(row).queryByText('Provider override')).toBeNull();
  });

  it('does not flag a task type with no app override', async () => {
    await renderTab();
    const row = rowFor('layered-intelligence');
    expect(within(row).queryByText('Provider override')).toBeNull();
  });

  it('changing the provider PATCHes updateAppTaskTypeOverride with providerId + cleared model', async () => {
    await renderTab();
    const row = rowFor('layered-intelligence');
    fireEvent.click(within(row).getByRole('button', { name: /show provider and model options/i }));

    const providerSelect = within(row).getByLabelText('Provider override');
    fireEvent.change(providerSelect, { target: { value: 'claude-cli' } });

    await waitFor(() => expect(api.updateAppTaskTypeOverride).toHaveBeenCalled());
    expect(api.updateAppTaskTypeOverride).toHaveBeenCalledWith(
      'app-1',
      'layered-intelligence',
      { providerId: 'claude-cli', model: null },
      { silent: true }
    );
  });

  it('changing the model PATCHes updateAppTaskTypeOverride with the model', async () => {
    await renderTab({ 'layered-intelligence': { providerId: 'claude-cli' } });
    const row = rowFor('layered-intelligence');
    fireEvent.click(within(row).getByRole('button', { name: /show provider and model options/i }));

    fireEvent.change(within(row).getByLabelText('Model'), { target: { value: 'sonnet' } });

    await waitFor(() => expect(api.updateAppTaskTypeOverride).toHaveBeenCalledWith(
      'app-1',
      'layered-intelligence',
      { providerId: 'claude-cli', model: 'sonnet' },
      { silent: true }
    ));
  });

  it('excludes disabled providers from the picker', async () => {
    await renderTab();
    const row = rowFor('layered-intelligence');
    fireEvent.click(within(row).getByRole('button', { name: /show provider and model options/i }));
    const providerSelect = within(row).getByLabelText('Provider override');
    expect(within(providerSelect).queryByText('Disabled')).toBeNull();
    expect(within(providerSelect).getByText('Claude Code')).toBeInTheDocument();
  });

  it('layered-intelligence row shows a behavior link that deep-links to the Intelligence tab', async () => {
    await renderTab();
    const row = rowFor('layered-intelligence');
    fireEvent.click(within(row).getByRole('button', { name: /show provider and model options/i }));

    const link = within(row).getByRole('button', { name: /configure behavior/i });
    fireEvent.click(link);
    expect(mockNavigate).toHaveBeenCalledWith('/apps/app-1?edit=1&appTab=intelligence');
  });

  // The pin reaches the spawn for EVERY task type now (#4783), so the picker is
  // offered on every row rather than only where a buildTaskInput hook read it.
  it('offers the same provider picker on a task type with no hook', async () => {
    await renderTab();
    const row = rowFor('app-improvement');
    fireEvent.click(within(row).getByRole('button', { name: /show provider and model options/i }));
    expect(within(row).getByLabelText('Provider override')).toBeInTheDocument();
  });

  it('clearing the provider sends explicit nulls, matching the other pin surfaces', async () => {
    await renderTab({ 'app-improvement': { providerId: 'claude-cli', model: 'opus' } });
    const row = rowFor('app-improvement');
    fireEvent.click(within(row).getByRole('button', { name: /show provider and model options/i }));

    fireEvent.change(within(row).getByLabelText('Provider override'), { target: { value: '' } });
    await waitFor(() => expect(api.updateAppTaskTypeOverride).toHaveBeenCalledWith(
      'app-1',
      'app-improvement',
      { providerId: null, model: null },
      { silent: true }
    ));
  });

  it('Iss toggle PATCHes fileIssues on and forces the no-code posture', async () => {
    await renderTab();
    const row = rowFor('security');
    fireEvent.click(within(row).getByRole('button', { name: /File issues only/i }));
    await waitFor(() => expect(api.updateAppTaskTypeOverride).toHaveBeenCalledWith(
      'app-1',
      'security',
      { taskMetadata: { fileIssues: true, useWorktree: false, openPR: false, simplify: false } },
      { silent: true }
    ));
  });
});

describe('AutomationTab task visibility filter', () => {
  const cardOrder = () => ['layered-intelligence', 'app-improvement', 'security']
    .map(t => [t, screen.queryByText(t)])
    .filter(([, el]) => el)
    .sort(([, a], [, b]) => (a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1))
    .map(([t]) => t);

  it('opens on the switched-on tasks when any are on, and keeps the full count on All', async () => {
    await renderTab({ security: { enabled: true } }, '/');
    expect(cardOrder()).toEqual(['security']);
    expect(screen.getByRole('button', { name: 'On for this app (1)' })).toHaveAttribute('aria-pressed', 'true');
    expect(screen.getByRole('button', { name: 'All (3)' })).toBeInTheDocument();
  });

  it('opens on All when nothing is switched on', async () => {
    await renderTab({}, '/');
    expect(cardOrder()).toHaveLength(3);
    expect(screen.getByRole('button', { name: 'All (3)' })).toHaveAttribute('aria-pressed', 'true');
  });

  it('lists switched-on tasks first on All, then alphabetical', async () => {
    await renderTab({ security: { enabled: true } }, '/?show=all');
    expect(cardOrder()).toEqual(['security', 'app-improvement', 'layered-intelligence']);
  });

  it('keeps show and q in the URL, dropping each at its default', async () => {
    await renderTab({ security: { enabled: true } }, '/');
    fireEvent.click(screen.getByRole('button', { name: 'All (3)' }));
    expect(currentSearch).toBe('?show=all');
    fireEvent.change(screen.getByRole('searchbox', { name: 'Search tasks' }), { target: { value: 'app' } });
    expect(currentSearch).toBe('?show=all&q=app');
    expect(cardOrder()).toEqual(['app-improvement']);
    fireEvent.click(screen.getByRole('button', { name: 'On for this app (1)' }));
    fireEvent.change(screen.getByRole('searchbox', { name: 'Search tasks' }), { target: { value: '' } });
    expect(currentSearch).toBe('');
  });

  it('shows a zero-match empty state that resets to all tasks', async () => {
    await renderTab({ security: { enabled: true } }, '/?q=zzz');
    expect(screen.getByText(/No tasks match/)).toHaveTextContent('“On for this app” and “zzz”');
    fireEvent.click(screen.getByRole('button', { name: 'Show all tasks' }));
    expect(currentSearch).toBe('?show=all');
    expect(cardOrder()).toHaveLength(3);
  });
});

describe('AutomationTab read failures', () => {
  const primeOthers = () => {
    api.getCosStatus.mockResolvedValue({ paused: false });
    api.getProviders.mockResolvedValue(PROVIDERS);
    api.getCosJobs.mockResolvedValue({ jobs: [] });
    api.getSettings.mockResolvedValue({ timezone: 'UTC' });
  };

  it('does not render per-app or master switches over an unknown overrides state, and recovers on Retry', async () => {
    primeOthers();
    api.getCosSchedule.mockResolvedValue(SCHEDULE);
    api.getAppTaskTypes.mockRejectedValueOnce(new Error('overrides down'));
    mountTab();

    const alert = await screen.findByText(/Could not load this app's automation settings/);
    expect(alert).toBeInTheDocument();
    expect(screen.queryByRole('switch')).toBeNull();
    expect(screen.queryByRole('group', { name: 'Task visibility' })).toBeNull();
    expect(screen.queryByText('layered-intelligence')).toBeNull();

    api.getAppTaskTypes.mockResolvedValue({ taskTypeOverrides: { security: { enabled: true } } });
    fireEvent.click(screen.getByRole('button', { name: 'Retry' }));
    await screen.findByRole('group', { name: 'Task visibility' });
    expect(screen.queryByText(/Could not load/)).toBeNull();
    expect(screen.getByText('On for this app (1)', { exact: false })).toBeInTheDocument();
  });

  it('shows a schedule error instead of "No task types configured", and recovers on Retry', async () => {
    primeOthers();
    api.getAppTaskTypes.mockResolvedValue({ taskTypeOverrides: {} });
    api.getCosSchedule.mockRejectedValueOnce(new Error('schedule down'));
    mountTab();

    expect(await screen.findByText(/Could not load the task schedule/)).toBeInTheDocument();
    expect(screen.queryByText(/No task types configured/)).toBeNull();

    api.getCosSchedule.mockResolvedValue(SCHEDULE);
    fireEvent.click(screen.getByRole('button', { name: 'Retry' }));
    await screen.findByRole('group', { name: 'Task visibility' });
  });

  it('still renders the empty copy when the schedule loads with no task types', async () => {
    primeOthers();
    api.getAppTaskTypes.mockResolvedValue({ taskTypeOverrides: {} });
    api.getCosSchedule.mockResolvedValue({ tasks: {} });
    mountTab();
    expect(await screen.findByText(/No task types configured/)).toBeInTheDocument();
    expect(screen.queryByText(/Could not load/)).toBeNull();
  });

  it('shows a provider list error row instead of an empty provider catalogue', async () => {
    primeOthers();
    api.getAppTaskTypes.mockResolvedValue({ taskTypeOverrides: {} });
    api.getCosSchedule.mockResolvedValue(SCHEDULE);
    api.getProviders.mockRejectedValueOnce(new Error('providers down'));
    mountTab();
    expect(await screen.findByText(/Could not load the provider list/)).toBeInTheDocument();
  });
});