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.7 KB
Raw Blame
import { StrictMode } from 'react';
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { renderHook, act } from '@testing-library/react';
import useSseJobSlot from './useSseJobSlot.js';
import { MockEventSource, lastEventSource } from '../test/mockEventSource';
import toast from '../components/ui/Toast';

vi.mock('../components/ui/Toast', () => ({ default: { error: vi.fn(), info: vi.fn(), success: vi.fn() } }));

beforeEach(() => {
  vi.clearAllMocks();
  MockEventSource.reset();
  vi.stubGlobal('EventSource', MockEventSource);
});
afterEach(() => { vi.unstubAllGlobals(); vi.restoreAllMocks(); });

// Direct starts in the same React turn uniquely exercise the synchronous guard;
// a rendered disabled button cannot cover a retained callback invoked twice.
it('reserves one slot synchronously and keeps default progress/terminal behavior across successive jobs', async () => {
  let resolveKickoff;
  const startRequest = vi.fn()
    .mockImplementationOnce(() => new Promise((resolve) => { resolveKickoff = resolve; }))
    .mockResolvedValueOnce({ jobId: 'second-job' });
  const onComplete = vi.fn();
  const { result } = renderHook(() => useSseJobSlot({
    startRequest, eventsUrl: (id) => `/events/${id}`, onComplete,
  }), { wrapper: StrictMode });
  act(() => {
    result.current.start('first-target');
    result.current.start('second-target');
  });
  expect(startRequest).toHaveBeenCalledTimes(1);
  expect(result.current).toMatchObject({ active: true, pending: true, context: 'first-target' });
  expect(MockEventSource.instances).toHaveLength(0);
  await act(async () => { resolveKickoff({ jobId: 'first-job' }); });
  expect(lastEventSource().url).toBe('/events/first-job');
  act(() => {
    result.current.start('second-target');
    lastEventSource().emit({ type: 'progress', percent: 42.4, stage: 'download' });
  });
  expect(startRequest).toHaveBeenCalledTimes(1);
  act(() => { lastEventSource().emit({ type: 'metadata' }); });
  expect(result.current).toMatchObject({ percent: 42, stage: 'download' });
  act(() => { lastEventSource().emit({ type: 'complete', filename: 'example.wav' }); });
  expect(onComplete).toHaveBeenCalledWith({ type: 'complete', filename: 'example.wav' }, 'first-target');
  expect(result.current.active).toBe(false);

  // Real useSseProgress retains its prior terminal frame across the idle gap.
  // Starting again must neither replay it nor immediately end the new slot.
  await act(async () => { result.current.start('second-target'); });
  expect(result.current).toMatchObject({ active: true, pending: false, context: 'second-target', percent: 0 });
  expect(lastEventSource().url).toBe('/events/second-job');
  expect(onComplete).toHaveBeenCalledTimes(1);
});

it('re-renders exactly once per progress frame and keeps no frame history', async () => {
  let renders = 0;
  const { result } = renderHook(() => {
    renders += 1;
    return useSseJobSlot({ eventsUrl: (id) => `/events/${id}` });
  });
  act(() => { result.current.attach('job-1', 'target'); });
  const before = renders;
  act(() => { lastEventSource().emit({ type: 'progress', percent: 10, stage: 'a' }); });
  expect(renders - before).toBe(1);
  const mid = renders;
  // One act per frame: frames arrive as separate browser events, never batched.
  for (let i = 0; i < 100; i += 1) {
    act(() => { lastEventSource().emit({ type: 'progress', percent: i, stage: 'b' }); });
  }
  expect(renders - mid).toBe(100);
  expect(result.current).toMatchObject({ percent: 99, stage: 'b' });
});

describe('unmounted kickoff ownership', () => {
  it.each(['resolve', 'reject'])('ignores a late %s and refuses starts through an unmounted callback', async (outcome) => {
    let resolveKickoff;
    let rejectKickoff;
    const startRequest = vi.fn(() => new Promise((resolve, reject) => {
      resolveKickoff = resolve;
      rejectKickoff = reject;
    }));
    const onKickoffSuccess = vi.fn();
    const onKickoffError = vi.fn();
    const { result, unmount } = renderHook(() => useSseJobSlot({
      startRequest, eventsUrl: (id) => `/events/${id}`, onKickoffSuccess, onKickoffError,
    }));
    const start = result.current.start;
    act(() => { start('example-target'); });
    unmount();
    await act(async () => {
      start('stale-target');
      if (outcome === 'resolve') resolveKickoff({ jobId: 'late-job' });
      else rejectKickoff(new Error('Late failure'));
    });
    expect(startRequest).toHaveBeenCalledTimes(1);
    expect(onKickoffSuccess).not.toHaveBeenCalled();
    expect(onKickoffError).not.toHaveBeenCalled();
    expect(toast.error).not.toHaveBeenCalled();
    expect(MockEventSource.instances).toHaveLength(0);
  });
});


it.each(['complete', 'error', 'canceled', 'disconnected'])('settles %s once against the captured project for a persisted-state refresh', async (reason) => {
  const onSettled = vi.fn();
  const { result } = renderHook(() => useSseJobSlot({ eventsUrl: id => `/events/${id}`, onSettled }));
  act(() => result.current.attach('synthetic-render', 'synthetic-project'));
  act(() => { lastEventSource().onopen(); });
  expect(result.current.connected).toBe(true);
  act(() => {
    if (reason === 'disconnected') lastEventSource().fail();
    else lastEventSource().emit({ type: reason });
  });
  expect(result.current.active).toBe(false);
  expect(onSettled).toHaveBeenCalledExactlyOnceWith(reason, 'synthetic-project');
});

// A real terminal SSE frame must release the slot without unmounting its
// consumer even when the consumer's completion follow-up fails.
it.each(['throw', 'reject'])('recovers a completion callback %s and accepts the next job', async (failure) => {
  const error = new Error('Synthetic update failure');
  const onComplete = vi.fn(() => {
    if (failure === 'throw') throw error;
    return Promise.reject(error);
  });
  const log = vi.spyOn(console, 'error').mockImplementation(() => {});
  const { result } = renderHook(() => useSseJobSlot({
    eventsUrl: id => `/events/${id}`, onComplete, successToast: () => 'Finished',
  }), { wrapper: StrictMode });
  act(() => result.current.attach('first-job', 'first-target'));
  await act(async () => { lastEventSource().emit({ type: 'complete' }); });
  expect(result.current.active).toBe(false);
  expect(result.current.jobId).toBeNull();
  expect(onComplete).toHaveBeenCalledExactlyOnceWith({ type: 'complete' }, 'first-target');
  expect(log).toHaveBeenCalledWith('❌ Job completion follow-up failed: Synthetic update failure');
  expect(toast.error).toHaveBeenCalledWith('Finished, but the page could not update — reload to see the result');
  expect(toast.success).not.toHaveBeenCalled();
  act(() => { expect(result.current.attach('next-job', 'next-target')).toBe(true); });
  expect(result.current.active).toBe(true);
  expect(lastEventSource().url).toBe('/events/next-job');
});