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

13.0 KB
Raw Blame
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { act, render, screen, waitFor, within } from '@testing-library/react';
import { MemoryRouter } from 'react-router';
import userEvent from '@testing-library/user-event';

vi.mock('../../services/api', () => ({
  listImageModels: vi.fn(() => Promise.resolve([])),
  listVideoModels: vi.fn(() => Promise.resolve([])),
  reformatLoomEpisode: vi.fn(),
  updateLoom: vi.fn(),
}));
vi.mock('../../hooks/useProviderModels', () => ({ default: () => ({ providers: [] }) }));
vi.mock('../ProviderModelSelector', () => ({ default: () => null }));
vi.mock('../ui/Toast', () => ({ default: { success: vi.fn(), error: vi.fn() } }));

import { listVideoModels, reformatLoomEpisode, updateLoom } from '../../services/api';
import toast from '../ui/Toast';
import LoomSettingsDrawer from './LoomSettingsDrawer';

const scene = (id, format) => ({ id, title: id, prose: `Prose for ${id}.`, format, transitions: [] });

// Two episodes, all scenes still prose while the loom is pinned to teleplay —
// the state right after an author flips the format select.
const makeLoom = (episodes) => ({
  id: 'loom-1',
  name: 'Example Loom',
  format: 'teleplay',
  playSettings: {},
  episodes,
});

const twoEpisodes = () => makeLoom([
  { id: 'ep-1', title: 'Pilot', nodes: [scene('s1'), scene('s2')] },
  { id: 'ep-2', title: 'Second', nodes: [scene('s3')] },
]);

// Settles the model-catalog reads the drawer starts on mount, so their state
// update lands inside act().
const renderDrawer = async (loom, props = {}) => {
  const onLoomUpdate = vi.fn();
  const onRewritten = vi.fn();
  render(
    <MemoryRouter>
      <LoomSettingsDrawer
        open
        onClose={() => {}}
        loom={loom}
        onLoomUpdate={onLoomUpdate}
        onRewritten={onRewritten}
        {...props}
      />
    </MemoryRouter>,
  );
  await act(async () => {});
  return { onLoomUpdate, onRewritten };
};

const clickRewrite = (user) => user.click(screen.getByRole('button', { name: /^Rewrite \d+ scene/ }));

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

describe('LoomSettingsDrawer rewrite', () => {
  it('walks the episodes one request at a time instead of one request for the loom', async () => {
    const user = userEvent.setup();
    const loom = twoEpisodes();
    reformatLoomEpisode
      .mockResolvedValueOnce({ loom, rewritten: 2, episodeRemaining: 0, remaining: 1, capped: false })
      .mockResolvedValueOnce({ loom, rewritten: 1, episodeRemaining: 0, remaining: 0, capped: false });
    const { onLoomUpdate } = await renderDrawer(loom);

    // The count is the scenes that still need converting, not every scene.
    expect(screen.getByRole('button', { name: 'Rewrite 3 scenes as teleplay' })).toBeInTheDocument();
    await clickRewrite(user);

    await waitFor(() => expect(reformatLoomEpisode).toHaveBeenCalledTimes(2));
    expect(reformatLoomEpisode.mock.calls.map((c) => c[1])).toEqual(['ep-1', 'ep-2']);
    expect(reformatLoomEpisode.mock.calls[0][2]).toEqual({ format: 'teleplay' });
    // Each response folds back in as it lands rather than after the whole walk.
    expect(onLoomUpdate).toHaveBeenCalledTimes(2);
    await waitFor(() => expect(toast.success).toHaveBeenCalledWith('Rewrote 3 scenes as teleplay'));
  });

  it('names the episode in flight', async () => {
    const user = userEvent.setup();
    const loom = twoEpisodes();
    // Both calls stay pending until released, so each episode's line is
    // observable rather than a frame that flashes past.
    const release = [];
    reformatLoomEpisode.mockImplementation(() => new Promise((resolve) => { release.push(resolve); }));
    await renderDrawer(loom);
    await clickRewrite(user);

    expect(await screen.findByText('Rewriting episode 1 of 2 — Pilot…')).toBeInTheDocument();
    release[0]({ loom, rewritten: 2, episodeRemaining: 0, remaining: 1, capped: false });
    expect(await screen.findByText('Rewriting episode 2 of 2 — Second…')).toBeInTheDocument();

    release[1]({ loom, rewritten: 1, episodeRemaining: 0, remaining: 0, capped: false });
    await waitFor(() => expect(toast.success).toHaveBeenCalled());
    expect(screen.queryByText(/Rewriting episode/)).not.toBeInTheDocument();
  });

  it('says how much of a long episode is left while it re-asks', async () => {
    const user = userEvent.setup();
    const loom = makeLoom([{ id: 'ep-1', title: 'Pilot', nodes: [scene('s1')] }]);
    const release = [];
    reformatLoomEpisode.mockImplementation(() => new Promise((resolve) => { release.push(resolve); }));
    await renderDrawer(loom);
    await clickRewrite(user);

    expect(await screen.findByText('Rewriting episode 1 of 1 — Pilot…')).toBeInTheDocument();
    release[0]({ loom, rewritten: 20, episodeRemaining: 5, remaining: 5, capped: true });
    expect(await screen.findByText('Rewriting episode 1 of 1 — Pilot… 5 scenes left in it.')).toBeInTheDocument();
    release[1]({ loom, rewritten: 5, episodeRemaining: 0, remaining: 0, capped: false });
    await waitFor(() => expect(toast.success).toHaveBeenCalled());
  });

  it('asks the same episode again while the server says it stopped at its ceiling', async () => {
    const user = userEvent.setup();
    const loom = makeLoom([{ id: 'ep-1', title: 'Pilot', nodes: [scene('s1')] }]);
    reformatLoomEpisode
      .mockResolvedValueOnce({ loom, rewritten: 20, episodeRemaining: 5, remaining: 5, capped: true })
      .mockResolvedValueOnce({ loom, rewritten: 5, episodeRemaining: 0, remaining: 0, capped: false });
    await renderDrawer(loom);
    await clickRewrite(user);

    await waitFor(() => expect(reformatLoomEpisode).toHaveBeenCalledTimes(2));
    expect(reformatLoomEpisode.mock.calls.map((c) => c[1])).toEqual(['ep-1', 'ep-1']);
    await waitFor(() => expect(toast.success).toHaveBeenCalledWith('Rewrote 25 scenes as teleplay'));
  });

  it('does NOT re-ask an episode the model merely dropped scenes in', async () => {
    const user = userEvent.setup();
    const loom = makeLoom([{ id: 'ep-1', title: 'Pilot', nodes: [scene('s1'), scene('s2')] }]);
    // Not capped: nothing went unsent, so asking again would only re-send a
    // refusal. The leftover rides the toast instead.
    reformatLoomEpisode.mockResolvedValue({ loom, rewritten: 1, episodeRemaining: 1, remaining: 1, capped: false });
    await renderDrawer(loom);
    await clickRewrite(user);

    await waitFor(() => expect(toast.success).toHaveBeenCalledWith(
      'Rewrote 1 scene — 1 left, run it again to finish',
    ));
    expect(reformatLoomEpisode).toHaveBeenCalledTimes(1);
  });

  it('stops the walk when an episode fails, keeping what the earlier ones wrote', async () => {
    const user = userEvent.setup();
    const loom = twoEpisodes();
    reformatLoomEpisode
      .mockResolvedValueOnce({ loom, rewritten: 2, episodeRemaining: 0, remaining: 1, capped: false })
      .mockRejectedValueOnce(new Error('provider unreachable'));
    const { onRewritten } = await renderDrawer(loom);
    await clickRewrite(user);

    await waitFor(() => expect(toast.error).toHaveBeenCalledWith('provider unreachable'));
    expect(reformatLoomEpisode).toHaveBeenCalledTimes(2);
    // The selection is cleared up front AND the record re-read afterwards — the
    // failed walk still changed scene text on the server.
    expect(onRewritten).toHaveBeenNthCalledWith(1, { refetch: false });
    expect(onRewritten).toHaveBeenCalledTimes(2);
    expect(screen.queryByText(/Rewriting episode/)).not.toBeInTheDocument();
  });

  it('offers no rewrite at all once every scene is already in the target format', async () => {
    await renderDrawer(makeLoom([{ id: 'ep-1', title: 'Pilot', nodes: [scene('s1', 'teleplay')] }]));
    expect(screen.queryByRole('button', { name: /^Rewrite/ })).not.toBeInTheDocument();
    expect(screen.getByText(/Every scene you have is already written as teleplay/)).toBeInTheDocument();
  });
});

describe('LoomSettingsDrawer audience participation', () => {
  it('saves the helper role together with its required communication medium', async () => {
    updateLoom.mockResolvedValue({
      ...makeLoom([]),
      participationMode: 'helper',
      audienceCommunicationMedium: 'A silver mirror.',
    });
    const user = userEvent.setup();
    await renderDrawer({ ...makeLoom([]), participationMode: 'protagonist' });

    await user.selectOptions(screen.getByLabelText('Audience role'), 'helper');
    expect(screen.getByText(/need a communication medium before the role can be saved/i)).toBeInTheDocument();
    await user.type(screen.getByLabelText('Communication medium'), 'A silver mirror.');
    await user.tab();

    await waitFor(() => expect(updateLoom).toHaveBeenCalledWith('loom-1', {
      participationMode: 'helper',
      audienceCommunicationMedium: 'A silver mirror.',
    }, { silent: true }));
  });

  it('resets an unsaved helper selection when the drawer closes', async () => {
    const user = userEvent.setup();
    const loom = { ...makeLoom([]), participationMode: 'protagonist' };
    const props = {
      loom,
      onClose: () => {},
      onLoomUpdate: vi.fn(),
      onRewritten: vi.fn(),
    };
    const { rerender } = render(<LoomSettingsDrawer open {...props} />);
    await act(async () => {});

    await user.selectOptions(screen.getByLabelText('Audience role'), 'helper');
    expect(updateLoom).not.toHaveBeenCalled();
    rerender(<LoomSettingsDrawer open={false} {...props} />);
    rerender(<LoomSettingsDrawer open {...props} />);
    await act(async () => {});

    expect(screen.getByLabelText('Audience role')).toHaveValue('protagonist');
  });
});

describe('LoomSettingsDrawer character continuity', () => {
  it('associates the canonical protagonist with a Universe wardrobe and locks it by default', async () => {
    const user = userEvent.setup();
    const loom = makeLoom([]);
    updateLoom.mockResolvedValue({
      ...loom,
      protagonistCharacterId: 'char-1',
      protagonistWardrobeId: 'coat',
      protagonistWardrobeLocked: true,
    });
    await renderDrawer(loom, {
      universe: {
        id: 'universe-1',
        characters: [{
          id: 'char-1',
          name: 'Aria',
          referenceSheetImageRef: 'aria-sheet.png',
          wardrobes: [{ id: 'coat', name: 'Travel coat' }],
          identityPack: { assets: [] },
        }],
      },
    });

    await user.selectOptions(screen.getByLabelText('Canonical protagonist'), 'char-1');
    await user.selectOptions(screen.getByLabelText('Canonical protagonist wardrobe'), 'coat');

    await waitFor(() => expect(updateLoom).toHaveBeenLastCalledWith('loom-1', {
      protagonistWardrobeId: 'coat',
      protagonistWardrobeLocked: true,
    }, { silent: true }));
    expect(screen.getByRole('status')).toHaveTextContent('1 character sheet');
    expect(screen.getByRole('status')).toHaveTextContent('Identity pack missing neutral, profile, full-body');
    expect(screen.getByRole('checkbox', { name: /Lock this wardrobe across on-screen scenes/ })).toBeChecked();
  });
});

describe('LoomSettingsDrawer model catalogs', () => {
  it('shows a load error with Retry when the video model read fails, instead of an empty model picker', async () => {
    listVideoModels.mockRejectedValueOnce(new Error('Models unavailable'));
    await renderDrawer(makeLoom([]));

    expect(screen.getByRole('alert')).toHaveTextContent('Could not load video models — Models unavailable');

    listVideoModels.mockResolvedValueOnce([{ id: 'video-model-a', name: 'Video Model A' }]);
    await act(async () => { screen.getByRole('button', { name: 'Retry' }).click(); });
    expect(screen.queryByRole('alert')).toBeNull();
    expect(screen.getByRole('option', { name: 'Video Model A' })).toBeInTheDocument();
  });
});

describe('LoomSettingsDrawer rendering defaults', () => {
  it('shows the saved aspect ratio, renderers, models, and effort', async () => {
    await renderDrawer({
      ...makeLoom([]),
      renderSettings: {
        formatId: 'portrait-9-16',
        imageMode: 'local',
        imageModel: 'image-model',
        videoMode: 'grok',
        effort: 'high',
      },
    });

    expect(screen.getByLabelText('Aspect ratio')).toHaveValue('portrait-9-16');
    expect(screen.getByLabelText('Local image model')).toHaveValue('image-model');
    expect(screen.getByLabelText('Codex image effort')).toHaveValue('high');
    expect(within(screen.getByRole('group', { name: 'Story image renderer' }))
      .getByRole('button', { name: 'Local' })).toHaveClass('bg-port-accent');
    expect(within(screen.getByRole('group', { name: 'Story video renderer' }))
      .getByRole('button', { name: 'Grok' })).toHaveClass('bg-port-accent');
  });

  it('saves rendering defaults as one story-level pin', async () => {
    const user = userEvent.setup();
    await renderDrawer(makeLoom([]));

    await user.selectOptions(screen.getByLabelText('Aspect ratio'), 'square-1-1');

    await waitFor(() => expect(updateLoom).toHaveBeenCalledWith('loom-1', {
      renderSettings: {
        formatId: 'square-1-1',
        imageMode: null,
        imageModel: null,
        videoMode: null,
        videoModel: null,
        effort: null,
      },
    }, { silent: true }));
  });
});