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

18.8 KB
Raw Blame
afterEach(() => { vi.useRealTimers(); });

const socketHandlers = vi.hoisted(() => new Map());
vi.mock('../services/socket', () => ({ default: {
  on: (event, fn) => { if (!socketHandlers.has(event)) socketHandlers.set(event, new Set()); socketHandlers.get(event).add(fn); },
  off: (event, fn) => socketHandlers.get(event)?.delete(fn),
} }));
const emitModel = async (event, payload) => act(async () => {
  for (const fn of socketHandlers.get(event) || []) fn(payload);
});

import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { useEffect, useRef } from 'react';
import { act, render, screen, fireEvent, waitFor, within } from '@testing-library/react';
import { MemoryRouter, Routes, Route, useNavigate } from 'react-router';
import Media3DDetail from './Media3DDetail';

const getImageTo3dModel = vi.fn();
const generateImageTo3dModel = vi.fn();
const deleteImageTo3dModel = vi.fn();
vi.mock('../services/api', () => ({
  getImageTo3dModel: (...a) => getImageTo3dModel(...a),
  generateImageTo3dModel: (...a) => generateImageTo3dModel(...a),
  deleteImageTo3dModel: (...a) => deleteImageTo3dModel(...a),
  imageTo3dAssetUrl: (id) => `/api/image-to-3d/models/${id}/asset`,
  imageTo3dFullMeshUrl: (id) => `/api/image-to-3d/models/${id}/full-mesh`,
  imageTo3dUsdzUrl: (id) => `/api/image-to-3d/models/${id}/usdz`,
}));

// GlbViewer wraps a WebGL canvas jsdom can't render — stub to a marker echoing
// src. It also hands the loaded three.js graph up via `onSceneLoaded`, so the
// stub fires that with a marker: the AR export button is disabled until it
// arrives, and dropping that prop is an invisible regression otherwise.
vi.mock('../components/media/GlbViewer', () => ({
  default: ({ src, forceOpaque, onSceneLoaded }) => {
    useEffect(() => { onSceneLoaded?.({ marker: 'loaded-scene' }); }, [onSceneLoaded]);
    return <div data-testid="glb-viewer" data-force-opaque={String(forceOpaque)}>{src}</div>;
  },
}));
// The AR panel owns its own export/upload flow (covered by ArExportPanel.test.jsx);
// stubbing it keeps this suite about the page — but it echoes whether the scene
// reached it, which is the page's half of the contract.
vi.mock('../components/media/ArExportPanel', () => ({
  default: ({ scene, onRecordChange }) => {
    const initialOnRecordChange = useRef(onRecordChange);
    return (
      <>
        <div data-testid="ar-export-panel" data-has-scene={String(Boolean(scene))} />
        <button type="button" onClick={() => initialOnRecordChange.current?.({ id: 'image3d-1', name: 'Stale AR update' })}>
          Simulate stale AR update
        </button>
      </>
    );
  },
}));
vi.mock('../components/MediaImage', () => ({ default: ({ alt, src }) => <img alt={alt} src={src} /> }));
// The rig panel owns its own readiness fetch + feature gate (covered by
// RigPanel.test.jsx); stubbing it keeps this suite about the page.
vi.mock('../components/media/RigPanel', () => ({ default: () => <div data-testid="rig-panel" /> }));
vi.mock('../components/ui/Toast', () => ({ default: { error: vi.fn(), success: vi.fn() } }));

const record = (over = {}) => ({
  id: 'image3d-1',
  name: 'Example Beacon',
  status: 'ready',
  assetPath: '/data/image-to-3d/image3d-1/model.glb',
  error: null,
  runs: [],
  sourceImage: { filename: 'beacon.png', path: '/data/images/beacon.png' },
  updatedAt: new Date(0).toISOString(),
  ...over,
});

function renderAt(id = 'image3d-1') {
  return render(
    <MemoryRouter initialEntries={[`/3d/${id}`]}>
      <Routes>
        <Route path="/3d" element={<div>3D index</div>} />
        <Route path="/3d/:id" element={<Media3DDetail />} />
      </Routes>
    </MemoryRouter>,
  );
}

function RouteSwitcher() {
  const navigate = useNavigate();
  return (
    <>
      <button type="button" onClick={() => navigate('/3d/image3d-2')}>Switch model</button>
      <Media3DDetail />
    </>
  );
}

function renderWithSwitcher(id = 'image3d-1') {
  return render(
    <MemoryRouter initialEntries={[`/3d/${id}`]}>
      <Routes>
        <Route path="/3d" element={<div>3D index</div>} />
        <Route path="/3d/:id" element={<RouteSwitcher />} />
      </Routes>
    </MemoryRouter>,
  );
}

function deferred() {
  let resolve;
  let reject;
  const promise = new Promise((res, rej) => {
    resolve = res;
    reject = rej;
  });
  return { promise, resolve, reject };
}

describe('Media3DDetail', () => {
  beforeEach(() => vi.clearAllMocks());

  it('renders lifecycle progress and terminal updates without polling, with reconnect and visibility recovery', async () => {
    getImageTo3dModel.mockResolvedValue(record({ status: 'generating', runs: [{ percent: 10 }] }));
    renderAt();
    await screen.findByText('Example Beacon');
    vi.useFakeTimers();
    await act(async () => { vi.advanceTimersByTime(60_000); });
    await emitModel('image-to-3d:changed', { id: 'other' });
    expect(getImageTo3dModel).toHaveBeenCalledTimes(1);
    getImageTo3dModel.mockResolvedValue(record({ status: 'failed', error: 'Example render failure' }));
    await emitModel('image-to-3d:changed', { id: 'image3d-1' });
    expect(screen.getByText('Example render failure')).toBeInTheDocument();
    await emitModel('connect');
    expect(getImageTo3dModel).toHaveBeenCalledTimes(3);
    Object.defineProperty(document, 'visibilityState', { configurable: true, value: 'hidden' });
    await act(async () => { document.dispatchEvent(new Event('visibilitychange')); });
    Object.defineProperty(document, 'visibilityState', { configurable: true, value: 'visible' });
    getImageTo3dModel.mockResolvedValue(record());
    await act(async () => { document.dispatchEvent(new Event('visibilitychange')); });
    expect(screen.getByTestId('glb-viewer')).toBeInTheDocument();
    expect(getImageTo3dModel).toHaveBeenCalledTimes(4);
    vi.useRealTimers();
  });

  it('renders the mesh viewer and source image for a ready record', async () => {
    getImageTo3dModel.mockResolvedValue(record({ generatedAt: '2026-07-25T12:34:56.000Z' }));
    renderAt();
    expect(await screen.findByText('Example Beacon')).toBeInTheDocument();
    expect(screen.getByTestId('glb-viewer')).toHaveTextContent(
      '/data/image-to-3d/image3d-1/model.glb?v=2026-07-25T12%3A34%3A56.000Z',
    );
    expect(screen.getByTestId('glb-viewer')).toHaveAttribute('data-force-opaque', 'true');
    expect(screen.getByAltText('Source image')).toBeInTheDocument();
    // The viewer's loaded scene has to reach the AR panel or its export button
    // stays permanently disabled — a prop chain no other assertion touches.
    // The panel mounts before the scene reaches it, so wait on the ATTRIBUTE:
    // findByTestId resolves on the node and leaves the prop still in flight.
    await waitFor(() =>
      expect(screen.getByTestId('ar-export-panel')).toHaveAttribute('data-has-scene', 'true'),
    );
  });

  it('surfaces the render error for a failed record', async () => {
    getImageTo3dModel.mockResolvedValue(record({ status: 'failed', assetPath: null, error: 'Accept the Hugging Face terms first.' }));
    renderAt();
    expect(await screen.findByText(/Accept the Hugging Face terms first/i)).toBeInTheDocument();
    expect(screen.queryByTestId('glb-viewer')).toBeNull();
  });

  it('shows a not-found fallback for a stale id', async () => {
    getImageTo3dModel.mockRejectedValue(Object.assign(new Error('nope'), { status: 404 }));
    renderAt('gone');
    expect(await screen.findByText(/no longer exists/i)).toBeInTheDocument();
  });

  it('ignores a slower response from the previous routed model', async () => {
    const first = deferred();
    const second = deferred();
    getImageTo3dModel.mockImplementation((id) => (id === 'image3d-1' ? first.promise : second.promise));
    renderWithSwitcher();

    await waitFor(() => expect(getImageTo3dModel).toHaveBeenCalledWith('image3d-1', expect.objectContaining({ silent: true })));
    fireEvent.click(screen.getByRole('button', { name: /switch model/i }));
    await waitFor(() => expect(getImageTo3dModel).toHaveBeenCalledWith('image3d-2', expect.objectContaining({ silent: true })));

    second.resolve(record({ id: 'image3d-2', name: 'Second Beacon' }));
    expect(await screen.findByText('Second Beacon')).toBeInTheDocument();
    first.resolve(record({ id: 'image3d-1', name: 'First Beacon' }));

    await waitFor(() => expect(screen.getByText('Second Beacon')).toBeInTheDocument());
    expect(screen.queryByText('First Beacon')).toBeNull();
  });

  it('does not let a previous route 404 the newly selected model', async () => {
    const first = deferred();
    const second = deferred();
    getImageTo3dModel.mockImplementation((id) => (id === 'image3d-1' ? first.promise : second.promise));
    renderWithSwitcher();

    await waitFor(() => expect(getImageTo3dModel).toHaveBeenCalledWith('image3d-1', expect.objectContaining({ silent: true })));
    fireEvent.click(screen.getByRole('button', { name: /switch model/i }));
    await waitFor(() => expect(getImageTo3dModel).toHaveBeenCalledWith('image3d-2', expect.objectContaining({ silent: true })));

    second.resolve(record({ id: 'image3d-2', name: 'Second Beacon' }));
    expect(await screen.findByText('Second Beacon')).toBeInTheDocument();
    first.reject(Object.assign(new Error('gone'), { status: 404 }));

    await waitFor(() => expect(screen.getByText('Second Beacon')).toBeInTheDocument());
    expect(screen.queryByText(/no longer exists/i)).toBeNull();
  });

  it('ignores async panel updates started for the previous routed model', async () => {
    getImageTo3dModel.mockImplementation((id) => Promise.resolve(record({
      id,
      name: id === 'image3d-1' ? 'First Beacon' : 'Second Beacon',
    })));
    renderWithSwitcher();

    expect(await screen.findByText('First Beacon')).toBeInTheDocument();
    fireEvent.click(screen.getByRole('button', { name: /switch model/i }));
    expect(await screen.findByText('Second Beacon')).toBeInTheDocument();
    fireEvent.click(screen.getByRole('button', { name: /simulate stale ar update/i }));

    expect(screen.getByText('Second Beacon')).toBeInTheDocument();
    expect(screen.queryByText('Stale AR update')).toBeNull();
  });

  it('clears and reseeds render options for the active routed model', async () => {
    getImageTo3dModel.mockImplementation((id) => Promise.resolve(record({
      id,
      name: id === 'image3d-1' ? 'First Beacon' : 'Second Beacon',
      runs: [{ steps: id === 'image3d-1' ? 48 : 24 }],
    })));
    renderWithSwitcher();

    expect(await screen.findByText('First Beacon')).toBeInTheDocument();
    await waitFor(() => expect(screen.getByLabelText(/quality/i)).toHaveValue('48'));
    fireEvent.click(screen.getByRole('button', { name: /switch model/i }));

    expect(await screen.findByText('Second Beacon')).toBeInTheDocument();
    await waitFor(() => expect(screen.getByLabelText(/quality/i)).toHaveValue('24'));
  });

  it('deletes and navigates back to the index', async () => {
    getImageTo3dModel.mockResolvedValue(record());
    deleteImageTo3dModel.mockResolvedValue({ ok: true });
    renderAt();
    fireEvent.click(await screen.findByRole('button', { name: /delete/i }));
    // The inline confirm row appears; click its Confirm button.
    const confirmRow = await screen.findByText(/Delete "Example Beacon"\?/i);
    fireEvent.click(within(confirmRow.parentElement).getByRole('button', { name: /^delete$/i }));
    await waitFor(() => expect(deleteImageTo3dModel).toHaveBeenCalledWith('image3d-1', { silent: true }));
    expect(await screen.findByText('3D index')).toBeInTheDocument();
  });

  it('re-render sends the chosen per-run options (blank seed omitted → server rolls fresh)', async () => {
    getImageTo3dModel.mockResolvedValue(record());
    generateImageTo3dModel.mockResolvedValue(record({ status: 'generating' }));
    renderAt();
    await screen.findByText('Example Beacon');
    // `findByText` resolves on the DOM mutation, not on effects settling, and the
    // page seeds its option fields from the record in an effect that has NOT run
    // at that point — probed directly: a run carrying `steps: 48` still reads back
    // an empty quality field there, which is why the seeding tests below wait for
    // the value explicitly. A field changed inside that window is overwritten when
    // the seed lands. Sub-paint, so no user can hit it; it is a test-ordering
    // hazard only (#7448). A record with no runs seeds to the values the form
    // already holds, so there is nothing in the DOM to wait for.
    await act(async () => {});

    fireEvent.change(screen.getByLabelText(/quality/i), { target: { value: '24' } });
    fireEvent.click(screen.getByRole('button', { name: /re-render/i }));

    await waitFor(() => expect(generateImageTo3dModel).toHaveBeenCalledWith(
      'image3d-1',
      // normalMap is sent explicitly rather than omitted. It defaults OFF (the bake
      // can lose a render outright), and stating it keeps the body honest about what
      // the run asked for even if that default ever moves.
      { steps: 24, keyBackground: false, normalMap: false, subjectScale: 1 },
      { silent: true },
    ));
  });

  it('seeds steps/keying from the latest run but leaves the seed blank (stays random)', async () => {
    getImageTo3dModel.mockResolvedValue(record({
      runs: [{ operationId: 'op-1', status: 'completed', percent: 100, steps: 48, seed: 1234, keyBackground: false }],
    }));
    generateImageTo3dModel.mockResolvedValue(record({ status: 'generating' }));
    renderAt();
    await screen.findByText('Example Beacon');

    // The seeding effect commits one render after the record lands — wait for it.
    await waitFor(() => expect(screen.getByLabelText(/quality/i)).toHaveValue('48'));
    // Blank by design — echoing the run's concrete seed back would silently pin
    // it, reintroducing the deterministic-re-render trap.
    expect(screen.getByLabelText(/seed/i)).toHaveValue(null);
    expect(screen.getByLabelText(/key out flat backdrop/i)).not.toBeChecked();

    fireEvent.click(screen.getByRole('button', { name: /re-render/i }));
    await waitFor(() => expect(generateImageTo3dModel).toHaveBeenCalledWith(
      'image3d-1',
      { steps: 48, keyBackground: false, normalMap: false, subjectScale: 1 },
      { silent: true },
    ));
  });

  it('carries the detail tier and normal-map choice over from the latest run', async () => {
    // Deliberate quality choices, so they inherit like steps does — unlike seed,
    // which must stay blank.
    getImageTo3dModel.mockResolvedValue(record({
      runs: [{
        operationId: 'op-1', status: 'completed', percent: 100,
        detail: 'fast', alphaMode: 'auto', normalMap: false,
      }],
    }));
    generateImageTo3dModel.mockResolvedValue(record({ status: 'generating' }));
    renderAt();
    await screen.findByText('Example Beacon');

    await waitFor(() => expect(screen.getByLabelText(/detail/i)).toHaveValue('fast'));
    expect(screen.getByLabelText(/transparency/i)).toHaveValue('auto');
    expect(screen.getByLabelText(/bake normal map/i)).not.toBeChecked();

    fireEvent.click(screen.getByRole('button', { name: /re-render/i }));
    await waitFor(() => expect(generateImageTo3dModel).toHaveBeenCalledWith(
      'image3d-1',
      { keyBackground: false, detail: 'fast', alphaMode: 'auto', normalMap: false, subjectScale: 1 },
      { silent: true },
    ));
  });

  it('carries the subject framing over and reports it on the finished run', async () => {
    // A framing that produced a good mesh is exactly what a re-render wants to keep;
    // and the meta line has to say the render was reframed, or the user cannot tell
    // whether the last result came from the source's own framing or this knob.
    getImageTo3dModel.mockResolvedValue(record({
      runs: [{
        operationId: 'op-1', status: 'completed', percent: 100,
        subjectScale: 0.65, sourceFramed: true,
      }],
    }));
    generateImageTo3dModel.mockResolvedValue(record({ status: 'generating' }));
    renderAt();
    await screen.findByText('Example Beacon');

    await waitFor(() => expect(screen.getByLabelText(/subject framing — 65%/i)).toHaveValue('0.65'));
    expect(screen.getByText(/framed at 65%/i)).toBeInTheDocument();

    fireEvent.click(screen.getByRole('button', { name: /re-render/i }));
    await waitFor(() => expect(generateImageTo3dModel).toHaveBeenCalledWith(
      'image3d-1',
      { keyBackground: false, normalMap: false, subjectScale: 0.65 },
      { silent: true },
    ));
  });

  it('offers the full-resolution mesh download, labelled as geometry only', async () => {
    // ~1 GB of untextured v/f OBJ. The label has to say so, or someone downloads it
    // expecting a textured model.
    getImageTo3dModel.mockResolvedValue(record());
    renderAt();
    await screen.findByText('Example Beacon');
    const link = screen.getByRole('link', { name: /full-resolution mesh/i });
    expect(link).toHaveAttribute('href', '/api/image-to-3d/models/image3d-1/full-mesh');
    expect(link.textContent).toMatch(/geometry only/i);
  });

  describe('viewer transparency', () => {
    // The viewer is the third layer able to flatten alpha, after the exporter's
    // alpha_mode and PortOS's GLB rewrite. If it keeps forcing opaque, a mesh
    // exported as BLEND still renders solid and reads as a broken exporter.
    it('forces opaque when the run asked for no transparency', async () => {
      getImageTo3dModel.mockResolvedValue(record({
        runs: [{ operationId: 'op-1', status: 'completed', percent: 100 }],
      }));
      renderAt();
      await screen.findByText('Example Beacon');
      expect(screen.getByTestId('glb-viewer')).toHaveAttribute('data-force-opaque', 'true');
    });

    it('stops forcing opaque when the run requested a transparent material', async () => {
      getImageTo3dModel.mockResolvedValue(record({
        runs: [{ operationId: 'op-1', status: 'completed', percent: 100, alphaMode: 'BLEND' }],
      }));
      renderAt();
      await screen.findByText('Example Beacon');
      expect(screen.getByTestId('glb-viewer')).toHaveAttribute('data-force-opaque', 'false');
    });

    it('still forces opaque when the run explicitly asked for OPAQUE', async () => {
      getImageTo3dModel.mockResolvedValue(record({
        runs: [{ operationId: 'op-1', status: 'completed', percent: 100, alphaMode: 'OPAQUE' }],
      }));
      renderAt();
      await screen.findByText('Example Beacon');
      expect(screen.getByTestId('glb-viewer')).toHaveAttribute('data-force-opaque', 'true');
    });
  });

  it('shows the latest run’s seed, steps, and keyed-background badge in the meta line', async () => {
    getImageTo3dModel.mockResolvedValue(record({
      runs: [{ operationId: 'op-1', status: 'completed', percent: 100, seed: 777, steps: 24, sourceKeyed: true }],
    }));
    renderAt();
    await screen.findByText('Example Beacon');
    // Scope to the meta paragraph — the quality <select> also mentions "24 steps".
    const meta = screen.getByText(/seed 777/);
    expect(meta.textContent).toContain('24 steps');
    expect(meta.textContent).toContain('background keyed');
  });
});