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
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
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();
});
});