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.5 KB
Raw Blame
import { describe, it, expect, vi } from 'vitest';
import { act, render, screen, fireEvent } from '@testing-library/react';

import ProgressSlider from './ProgressSlider';

const GOAL = { id: 'goal-1', progress: 20 };

const renderSlider = (onCommit, goal = GOAL) => {
  const view = render(<ProgressSlider goal={goal} onCommit={onCommit} />);
  return { ...view, slider: screen.getByRole('slider') };
};

// Drag = the onChange stream a real pointer produces, then the release that commits.
const drag = (slider, value) => fireEvent.change(slider, { target: { value: String(value) } });

describe('ProgressSlider commit', () => {
  it('sends the released value to onCommit', async () => {
    const onCommit = vi.fn(() => Promise.resolve(true));
    const { slider } = renderSlider(onCommit);

    drag(slider, 85);
    await act(async () => { fireEvent.mouseUp(slider); });

    expect(onCommit).toHaveBeenCalledWith(85);
  });

  it('does not commit when the value lands back on the stored percentage', async () => {
    const onCommit = vi.fn(() => Promise.resolve(true));
    const { slider } = renderSlider(onCommit);

    drag(slider, 85);
    drag(slider, 20);
    await act(async () => { fireEvent.mouseUp(slider); });

    expect(onCommit).not.toHaveBeenCalled();
  });

  // Issue #3520: a rejected update left `draft` on the dragged value, so the panel
  // advertised a percentage the database never took.
  it('snaps back to the stored percentage when the commit reports failure', async () => {
    const onCommit = vi.fn(() => Promise.resolve(false));
    const { slider } = renderSlider(onCommit);

    drag(slider, 85);
    expect(screen.getByText('85%')).toBeTruthy();

    await act(async () => { fireEvent.mouseUp(slider); });

    expect(screen.getByText('20%')).toBeTruthy();
    expect(slider.value).toBe('20');
  });

  it('snaps back when the commit rejects', async () => {
    const onCommit = vi.fn(() => Promise.reject(new Error('server exploded')));
    const { slider } = renderSlider(onCommit);

    drag(slider, 85);
    await act(async () => { fireEvent.mouseUp(slider); });

    expect(screen.getByText('20%')).toBeTruthy();
  });

  // A bare `.catch()` never gets attached when the handler throws before returning a
  // promise, which would latch `saving` on and freeze the slider on an unsaved value.
  it('snaps back when the commit throws synchronously', async () => {
    const onCommit = vi.fn(() => { throw new Error('threw before returning a promise'); });
    const { slider } = renderSlider(onCommit);

    drag(slider, 85);
    await act(async () => { fireEvent.mouseUp(slider); });

    expect(screen.getByText('20%')).toBeTruthy();
  });

  it('can be retried after a failed commit', async () => {
    const onCommit = vi.fn()
      .mockResolvedValueOnce(false)
      .mockResolvedValueOnce(true);
    const { slider } = renderSlider(onCommit);

    drag(slider, 85);
    await act(async () => { fireEvent.mouseUp(slider); });
    expect(screen.getByText('20%')).toBeTruthy();

    drag(slider, 85);
    await act(async () => { fireEvent.mouseUp(slider); });

    expect(onCommit).toHaveBeenCalledTimes(2);
    expect(screen.getByText('85%')).toBeTruthy();
  });

  // A handler that returns nothing keeps the pre-#3520 optimistic behavior.
  it('keeps the dragged value when the commit resolves with no outcome', async () => {
    const onCommit = vi.fn(() => Promise.resolve());
    const { slider } = renderSlider(onCommit);

    drag(slider, 85);
    await act(async () => { fireEvent.mouseUp(slider); });

    expect(screen.getByText('85%')).toBeTruthy();
  });

  it('holds the dragged value while the commit is in flight', async () => {
    let release;
    const onCommit = vi.fn(() => new Promise((resolve) => { release = resolve; }));
    const { slider } = renderSlider(onCommit);

    drag(slider, 85);
    await act(async () => { fireEvent.mouseUp(slider); });
    // The pre-fix effect reset draft the moment dragging flipped false.
    expect(screen.getByText('85%')).toBeTruthy();

    await act(async () => { release(true); });
    expect(screen.getByText('85%')).toBeTruthy();
  });

  it('sends one request when a touch release also fires a synthesized mouseup', async () => {
    let release;
    const onCommit = vi.fn(() => new Promise((resolve) => { release = resolve; }));
    const { slider } = renderSlider(onCommit);

    drag(slider, 85);
    // Both events land in the same task, with no re-render in between — a `useState`
    // in-flight flag would still read stale in the second handler and double-send.
    await act(async () => {
      fireEvent.touchEnd(slider);
      fireEvent.mouseUp(slider);
    });

    expect(onCommit).toHaveBeenCalledTimes(1);

    await act(async () => { release(true); });
    expect(onCommit).toHaveBeenCalledTimes(1);
  });

  // Dropping the second value would leave the slider showing a percentage that was
  // never sent — the same lie as the bug this issue is about.
  it('sends a value set while a commit is in flight once that commit resolves', async () => {
    let release;
    const onCommit = vi.fn(() => new Promise((resolve) => { release = resolve; }));
    const { slider } = renderSlider(onCommit);

    drag(slider, 85);
    await act(async () => { fireEvent.mouseUp(slider); });
    expect(onCommit).toHaveBeenCalledTimes(1);

    // Second interaction lands before the first request is answered.
    drag(slider, 90);
    await act(async () => { fireEvent.mouseUp(slider); });
    expect(onCommit).toHaveBeenCalledTimes(1);

    await act(async () => { release(true); });

    expect(onCommit).toHaveBeenNthCalledWith(1, 85);
    expect(onCommit).toHaveBeenNthCalledWith(2, 90);
    expect(screen.getByText('90%')).toBeTruthy();
  });

  // The queued value replaces the failed one instead of being rolled back over.
  it('sends a value queued behind a commit that fails', async () => {
    let release;
    const onCommit = vi.fn(() => new Promise((resolve) => { release = resolve; }));
    const { slider } = renderSlider(onCommit);

    drag(slider, 85);
    await act(async () => { fireEvent.mouseUp(slider); });
    drag(slider, 90);
    await act(async () => { fireEvent.mouseUp(slider); });

    await act(async () => { release(false); });

    expect(onCommit).toHaveBeenCalledTimes(2);
    expect(onCommit).toHaveBeenNthCalledWith(2, 90);
    expect(screen.getByText('90%')).toBeTruthy();
  });

  it('does not re-send a release that lands on the percentage already in flight', async () => {
    let release;
    const onCommit = vi.fn(() => new Promise((resolve) => { release = resolve; }));
    const { slider } = renderSlider(onCommit);

    drag(slider, 85);
    await act(async () => { fireEvent.mouseUp(slider); });
    drag(slider, 90);
    drag(slider, 85);
    await act(async () => { fireEvent.mouseUp(slider); });

    await act(async () => { release(true); });

    expect(onCommit).toHaveBeenCalledTimes(1);
  });

  // Arrow/Home/End move a range input without ever firing mouseup.
  it('commits a keyboard-driven change on key release', async () => {
    const onCommit = vi.fn(() => Promise.resolve(true));
    const { slider } = renderSlider(onCommit);

    drag(slider, 21);
    await act(async () => { fireEvent.keyUp(slider, { key: 'ArrowRight' }); });

    expect(onCommit).toHaveBeenCalledWith(21);
  });

  // The parent refetch lands after the commit resolves, so a saved value has to
  // survive a render that still carries the pre-commit goal snapshot.
  it('keeps the saved value while the refreshed goal is still in flight', async () => {
    const onCommit = vi.fn(() => Promise.resolve(true));
    const { slider, rerender } = renderSlider(onCommit);

    drag(slider, 85);
    await act(async () => { fireEvent.mouseUp(slider); });
    await act(async () => { rerender(<ProgressSlider goal={GOAL} onCommit={onCommit} />); });
    expect(screen.getByText('85%')).toBeTruthy();

    await act(async () => { rerender(<ProgressSlider goal={{ ...GOAL, progress: 85 }} onCommit={onCommit} />); });
    expect(screen.getByText('85%')).toBeTruthy();
  });

  it('pairs the Progress label with the slider', () => {
    const { slider } = renderSlider(vi.fn());

    expect(screen.getByLabelText('Progress')).toBe(slider);
  });

  it('adopts an externally changed progress value', async () => {
    const onCommit = vi.fn(() => Promise.resolve(true));
    const { rerender } = renderSlider(onCommit);

    await act(async () => { rerender(<ProgressSlider goal={{ ...GOAL, progress: 60 }} onCommit={onCommit} />); });

    expect(screen.getByText('60%')).toBeTruthy();
    expect(onCommit).not.toHaveBeenCalled();
  });
});