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

8.6 KB
Raw Blame
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { renderHook, act, cleanup, waitFor } from '@testing-library/react';

// Mock the socket module so the test can drive the `image-gen:*` handlers the
// hook registers with `on()`.
const handlers = new Map();
vi.mock('../services/socket', () => ({
  default: {
    on: (event, fn) => { handlers.set(event, fn); },
    off: (event, fn) => { if (handlers.get(event) === fn) handlers.delete(event); },
    emit: () => {},
  },
}));

// Mock the hydrate fetch so mount doesn't hit the network. Default: an
// in-flight (running) job so the spinner state is the starting point.
const getMediaJob = vi.fn(async () => ({ status: 'running' }));
vi.mock('../services/apiMediaJobs', () => ({ getMediaJob: (...a) => getMediaJob(...a) }));

const useMediaJobProgress = (await import('./useMediaJobProgress.js')).default;

const fire = (event, payload) => act(() => { handlers.get(event)?.(payload); });
// Drain the mount hydrate fetch (a pre-resolved mock promise) inside act so its
// setStatus can't land outside it after the test body.
const settle = () => act(async () => {});

describe('useMediaJobProgress — canceled handling (#1791)', () => {
  beforeEach(() => { handlers.clear(); getMediaJob.mockClear(); getMediaJob.mockResolvedValue({ status: 'running' }); });
  afterEach(cleanup);

  it('settles to canceled on a matching image-gen:canceled without re-fetching', async () => {
    const { result } = renderHook(() => useMediaJobProgress('job-1'));
    await waitFor(() => expect(result.current.status).toBe('running'));
    getMediaJob.mockClear();
    fire('image-gen:canceled', { generationId: 'job-1' });
    expect(result.current.status).toBe('canceled');
    // The canceled event is authoritative — no re-fetch needed (unlike :failed).
    expect(getMediaJob).not.toHaveBeenCalled();
  });

  it('does not let an older recovery snapshot overwrite a terminal socket event', async () => {
    let resolveSnapshot;
    getMediaJob.mockReturnValueOnce(new Promise((resolve) => { resolveSnapshot = resolve; }));
    const { result } = renderHook(() => useMediaJobProgress('job-1'));
    fire('image-gen:completed', { generationId: 'job-1', filename: 'finished.png' });
    await act(async () => { resolveSnapshot({ status: 'running' }); });
    expect(result.current.status).toBe('completed');
    expect(result.current.filename).toBe('finished.png');
  });

  it('ignores a canceled event for a different job', async () => {
    const { result } = renderHook(() => useMediaJobProgress('job-1'));
    await waitFor(() => expect(result.current.status).toBe('running'));
    fire('image-gen:canceled', { generationId: 'other-job' });
    expect(result.current.status).toBe('running');
  });

  it('subscribes to the video-gen:canceled event when kind=video', async () => {
    renderHook(() => useMediaJobProgress('job-1', { kind: 'video' }));
    await settle();
    expect(handlers.has('video-gen:canceled')).toBe(true);
    expect(handlers.has('image-gen:canceled')).toBe(false);
  });

  // Audio (first-pass music-bed, #1933) rides the audio-gen:* namespace so the
  // Creative Director detail page can surface a failed background render.
  it('subscribes to audio-gen:* events when kind=audio', async () => {
    renderHook(() => useMediaJobProgress('job-1', { kind: 'audio' }));
    await settle();
    expect(handlers.has('audio-gen:failed')).toBe(true);
    expect(handlers.has('audio-gen:completed')).toBe(true);
    expect(handlers.has('image-gen:failed')).toBe(false);
  });

  it('settles to failed on a matching audio-gen:failed with the error', async () => {
    const { result } = renderHook(() => useMediaJobProgress('job-1', { kind: 'audio' }));
    await waitFor(() => expect(result.current.status).toBe('running'));
    // Re-fetch after :failed returns the still-failed job (not a canceled one).
    getMediaJob.mockResolvedValueOnce({ status: 'failed', error: 'sidecar crashed' });
    fire('audio-gen:failed', { generationId: 'job-1', error: 'sidecar crashed' });
    await waitFor(() => expect(result.current.status).toBe('failed'));
    expect(result.current.error).toBe('sidecar crashed');
  });

  it('a :failed for a user-canceled running job still corrects to canceled via re-fetch', async () => {
    const { result } = renderHook(() => useMediaJobProgress('job-1'));
    await waitFor(() => expect(result.current.status).toBe('running'));
    // The gen module reports a SIGTERM cancel as a failure; the persisted state
    // is 'canceled', so onFailed re-fetches and corrects.
    getMediaJob.mockResolvedValueOnce({ status: 'canceled', error: 'Canceled while running' });
    fire('image-gen:failed', { generationId: 'job-1', error: 'killed' });
    await waitFor(() => expect(result.current.status).toBe('canceled'));
  });
});

describe('useMediaJobProgress — render ETA (#3801)', () => {
  beforeEach(() => { handlers.clear(); getMediaJob.mockClear(); getMediaJob.mockResolvedValue({ status: 'running' }); });
  afterEach(cleanup);

  it('starts with no estimate', async () => {
    const { result } = renderHook(() => useMediaJobProgress('job-1', { kind: 'video' }));
    await settle();
    expect(result.current.etaMs).toBeNull();
  });

  it('picks up the estimate from the started event and repeats it on progress', async () => {
    const { result } = renderHook(() => useMediaJobProgress('job-1', { kind: 'video' }));
    await waitFor(() => expect(handlers.has('video-gen:started')).toBe(true));
    fire('video-gen:started', { generationId: 'job-1', totalSteps: 30, etaMs: 1_800_000 });
    expect(result.current.etaMs).toBe(1_800_000);
    fire('video-gen:progress', { generationId: 'job-1', progress: 0.5, etaMs: 1_800_000 });
    expect(result.current.etaMs).toBe(1_800_000);
  });

  it('keeps the last estimate when a progress frame omits the key', async () => {
    const { result } = renderHook(() => useMediaJobProgress('job-1', { kind: 'video' }));
    await waitFor(() => expect(handlers.has('video-gen:started')).toBe(true));
    fire('video-gen:started', { generationId: 'job-1', etaMs: 600_000 });
    fire('video-gen:progress', { generationId: 'job-1', progress: 0.2 });
    expect(result.current.etaMs).toBe(600_000);
  });

  it('treats an explicit null estimate as "unknown", not as a stale value to keep', async () => {
    const { result } = renderHook(() => useMediaJobProgress('job-1', { kind: 'video' }));
    await waitFor(() => expect(handlers.has('video-gen:started')).toBe(true));
    fire('video-gen:started', { generationId: 'job-1', etaMs: 600_000 });
    fire('video-gen:started', { generationId: 'job-1', etaMs: null });
    expect(result.current.etaMs).toBeNull();
  });

  it('hydrates the estimate from the queue snapshot on reload', async () => {
    getMediaJob.mockResolvedValue({ status: 'running', progress: 0.3, etaMs: 900_000 });
    const { result } = renderHook(() => useMediaJobProgress('job-1', { kind: 'video' }));
    await waitFor(() => expect(result.current.etaMs).toBe(900_000));
  });

  it('ignores events for a different job', async () => {
    const { result } = renderHook(() => useMediaJobProgress('job-1', { kind: 'video' }));
    await waitFor(() => expect(handlers.has('video-gen:started')).toBe(true));
    fire('video-gen:started', { generationId: 'job-2', etaMs: 600_000 });
    expect(result.current.etaMs).toBeNull();
  });
});

describe('useMediaJobProgress — socket reconnect (#8426)', () => {
  beforeEach(() => { handlers.clear(); getMediaJob.mockClear(); getMediaJob.mockResolvedValue({ status: 'running' }); });
  afterEach(cleanup);

  it('re-fetches on reconnect and settles a job that finished while disconnected', async () => {
    const { result } = renderHook(() => useMediaJobProgress('job-1'));
    await waitFor(() => expect(result.current.status).toBe('running'));
    getMediaJob.mockResolvedValue({ status: 'completed', progress: 1, result: { filename: 'output.png' } });
    fire('connect');
    await waitFor(() => expect(result.current.status).toBe('completed'));
    expect(result.current.filename).toBe('output.png');
  });

  it.each(['completed', 'failed', 'canceled'])('does not re-fetch a %s job on reconnect', async (status) => {
    getMediaJob.mockResolvedValue({ status });
    const { result } = renderHook(() => useMediaJobProgress('job-1'));
    await waitFor(() => expect(result.current.status).toBe(status));
    getMediaJob.mockClear();
    fire('connect');
    await settle();
    expect(getMediaJob).not.toHaveBeenCalled();
  });

  it('removes the connect listener on unmount', async () => {
    const { unmount } = renderHook(() => useMediaJobProgress('job-1'));
    await settle();
    expect(handlers.has('connect')).toBe(true);
    unmount();
    expect(handlers.has('connect')).toBe(false);
  });
});