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

6.2 KB
Raw Blame
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { fireEvent, render, screen, waitFor } from '@testing-library/react';

vi.mock('../../services/api', () => ({
  probePeer: vi.fn(),
  updatePeer: vi.fn(),
}));

import { probePeer, updatePeer } from '../../services/api';
import PeerMediaProviderPanel from './PeerMediaProviderPanel';

const basePeer = {
  id: 'peer-example',
  name: 'Example Provider',
  enabled: true,
  status: 'online',
};

const capability = (overrides) => ({
  ready: true,
  unavailableReason: null,
  ...overrides,
});

const readyStatus = {
  state: 'ready',
  reason: null,
  checkedAt: '2026-08-17T12:00:00.000Z',
  freshUntil: '2026-08-17T12:01:00.000Z',
  snapshot: {
    queue: { running: 1, queued: 2, totalActive: 3, maxQueuedJobs: 4, accepting: true },
    capabilities: [capability({
      kind: 'audio',
      engine: 'minimax-music3',
      engineName: 'MiniMax Music 3',
      modelId: 'minimax-music3',
      modelName: 'MiniMax Music 3',
    })],
  },
};

// Every write sends the full per-kind shape, so the expected payload is verbose
// by design — a patch that omitted a list would only read as "unchanged" by luck.
const emptyLists = { audioModels: [], imageModels: [], videoModels: [] };

const withQueue = (queue) => ({
  ...readyStatus,
  snapshot: { ...readyStatus.snapshot, queue: { ...readyStatus.snapshot.queue, ...queue } },
});

beforeEach(() => {
  vi.clearAllMocks();
  updatePeer.mockResolvedValue({ id: basePeer.id });
  probePeer.mockResolvedValue({ id: basePeer.id });
});

describe('PeerMediaProviderPanel', () => {
  it('opts in explicitly and probes before refreshing the card', async () => {
    const onRefresh = vi.fn();
    render(<PeerMediaProviderPanel peer={basePeer} onRefresh={onRefresh} />);

    fireEvent.click(screen.getByRole('button', { name: /Remote media provider/i }));
    fireEvent.click(screen.getByLabelText(/Use this peer for remote media/i));

    await waitFor(() => expect(updatePeer).toHaveBeenCalledWith('peer-example', {
      mediaProvider: { enabled: true, ...emptyLists },
    }));
    await waitFor(() => expect(probePeer).toHaveBeenCalledWith('peer-example'));
    expect(onRefresh).toHaveBeenCalled();
  });

  it('reports how fast the peer drains its queue and which kinds are occupying it', () => {
    const peer = {
      ...basePeer,
      mediaProvider: { enabled: true, audioModels: [] },
      mediaProviderStatus: withQueue({
        concurrency: 2,
        byKind: { audio: { running: 1, queued: 2 } },
      }),
    };
    render(<PeerMediaProviderPanel peer={peer} onRefresh={vi.fn()} />);

    fireEvent.click(screen.getByRole('button', { name: /Remote media provider/i }));
    expect(screen.getByText(/runs 2 at a time · audio 1 running, 2 queued · federated 1 running, 2 queued/i)).toBeInTheDocument();
    // An idle kind is omitted, not rendered as a zero.
    expect(screen.queryByText(/(image|video) \d/i)).not.toBeInTheDocument();
  });

  it('shows queue capacity and persists an allowlisted model without dropping future config fields', async () => {
    const onRefresh = vi.fn();
    const peer = {
      ...basePeer,
      mediaProvider: { enabled: true, audioModels: [], futureField: 'keep' },
      mediaProviderStatus: readyStatus,
    };
    render(<PeerMediaProviderPanel peer={peer} onRefresh={onRefresh} />);

    fireEvent.click(screen.getByRole('button', { name: /Remote media provider/i }));
    expect(screen.getByText(/3\/4 shared slots active · federated 1 running, 2 queued/i)).toBeInTheDocument();
    fireEvent.click(screen.getByLabelText('Allow audio model MiniMax Music 3'));

    await waitFor(() => expect(updatePeer).toHaveBeenCalledWith('peer-example', {
      mediaProvider: {
        enabled: true,
        futureField: 'keep',
        ...emptyLists,
        audioModels: [{ engine: 'minimax-music3', modelId: 'minimax-music3' }],
      },
    }));
    expect(probePeer).not.toHaveBeenCalled();
  });

  // #4348 — image and video landed on the wire before they had any surface to
  // be allowlisted from, which left federated renders unreachable from the UI.
  it('allowlists an image model into its own list, leaving the audio list alone', async () => {
    const peer = {
      ...basePeer,
      mediaProvider: {
        enabled: true,
        audioModels: [{ engine: 'minimax-music3', modelId: 'minimax-music3' }],
      },
      mediaProviderStatus: {
        ...readyStatus,
        snapshot: {
          ...readyStatus.snapshot,
          capabilities: [
            ...readyStatus.snapshot.capabilities,
            capability({
              kind: 'image', engine: 'comfy', engineName: 'ComfyUI',
              modelId: 'sdxl-base', modelName: 'SDXL Base',
            }),
          ],
        },
      },
    };
    render(<PeerMediaProviderPanel peer={peer} onRefresh={vi.fn()} />);

    fireEvent.click(screen.getByRole('button', { name: /Remote media provider/i }));
    fireEvent.click(screen.getByLabelText('Allow image model SDXL Base'));

    await waitFor(() => expect(updatePeer).toHaveBeenCalledWith('peer-example', {
      mediaProvider: {
        enabled: true,
        audioModels: [{ engine: 'minimax-music3', modelId: 'minimax-music3' }],
        imageModels: [{ engine: 'comfy', modelId: 'sdxl-base' }],
        videoModels: [],
      },
    }));
  });

  it('keeps a selected model visible after the peer stops advertising it, so it can be removed', () => {
    render(<PeerMediaProviderPanel peer={{
      ...basePeer,
      mediaProvider: { enabled: true, videoModels: [{ engine: 'wan', modelId: 'wan-2.2' }] },
      mediaProviderStatus: readyStatus,
    }} onRefresh={vi.fn()} />);

    fireEvent.click(screen.getByRole('button', { name: /Remote media provider/i }));
    expect(screen.getByLabelText('Allow video model wan-2.2')).toBeChecked();
    expect(screen.getByText(/not-advertised/)).toBeInTheDocument();
  });

  it('explains that stale capacity blocks new work', () => {
    render(<PeerMediaProviderPanel peer={{
      ...basePeer,
      mediaProvider: { enabled: true, audioModels: [] },
      mediaProviderStatus: { ...readyStatus, state: 'stale', reason: 'stale' },
    }} onRefresh={vi.fn()} />);

    fireEvent.click(screen.getByRole('button', { name: /Remote media provider/i }));
    expect(screen.getByText(/capacity snapshot expired/i)).toBeInTheDocument();
  });
});