A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
/* Copyright 2026 Marimo. All rights reserved. */
import { act, renderHook } from "@testing-library/react";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import {
useDebounce,
useDebounceControlledState,
useDebouncedCallback,
} from "../useDebounce";
describe("useDebounce", () => {
beforeEach(() => {
vi.useFakeTimers();
});
afterEach(() => {
vi.restoreAllMocks();
vi.useRealTimers();
});
it("should update value after delay", () => {
const { result, rerender } = renderHook(
({ value }) => useDebounce(value, 1000),
{ initialProps: { value: "initial" } },
);
expect(result.current).toBe("initial");
rerender({ value: "updated" });
act(() => {
vi.runAllTimers();
});
act(() => {
vi.runAllTimers();
});
expect(result.current).toBe("updated");
});
it("should cleanup on unmount", () => {
const { result, rerender, unmount } = renderHook(
({ value }) => useDebounce(value, 1000),
{ initialProps: { value: "initial" } },
);
expect(result.current).toBe("initial");
rerender({ value: "updated" });
unmount();
act(() => {
vi.runAllTimers();
});
expect(result.current).toBe("initial");
});
});
describe("useDebounceControlledState", () => {
beforeEach(() => {
vi.useFakeTimers();
});
afterEach(() => {
vi.restoreAllMocks();
vi.useRealTimers();
});
it("should not call onChange with initial value immediately", () => {
const onChange = vi.fn();
renderHook(() =>
useDebounceControlledState({
initialValue: "initial",
onChange,
delay: 1000,
}),
);
expect(onChange).not.toHaveBeenCalled();
});
it("should debounce subsequent onChange calls", () => {
const onChange = vi.fn();
const { result } = renderHook(() =>
useDebounceControlledState({
initialValue: "initial",
onChange,
delay: 1000,
}),
);
onChange.mockClear();
act(() => {
result.current.onChange("updated");
});
act(() => {
vi.runAllTimers();
});
act(() => {
vi.runAllTimers();
});
expect(onChange).toHaveBeenCalledWith("updated");
});
it("should not call onChange if disabled", () => {
const onChange = vi.fn();
renderHook(() =>
useDebounceControlledState({
initialValue: "initial",
onChange,
delay: 1000,
disabled: true,
}),
);
expect(onChange).not.toHaveBeenCalled();
});
it("replaces an uncommitted draft when the external value changes", () => {
const onChange = vi.fn();
const { result, rerender } = renderHook(
({ value }) =>
useDebounceControlledState({
initialValue: value,
onChange,
delay: 1000,
}),
{ initialProps: { value: "initial" } },
);
act(() => result.current.onChange("draft"));
rerender({ value: "external" });
expect(result.current.value).toBe("external");
act(() => vi.runAllTimers());
expect(result.current.debouncedValue).toBe("external");
expect(onChange).not.toHaveBeenCalled();
});
it("handles NaN external values without repeatedly resetting the draft", () => {
const onChange = vi.fn();
const { result, rerender } = renderHook(
({ value }) =>
useDebounceControlledState({ initialValue: value, onChange }),
{ initialProps: { value: Number.NaN } },
);
expect(result.current.value).toBeNaN();
act(() => result.current.onChange(1));
rerender({ value: Number.NaN });
expect(result.current.value).toBe(1);
rerender({ value: 2 });
expect(result.current.value).toBe(2);
rerender({ value: Number.NaN });
expect(result.current.value).toBeNaN();
});
it("resets the draft when the external value changes from zero to negative zero", () => {
const onChange = vi.fn();
const { result, rerender } = renderHook(
({ value }) =>
useDebounceControlledState({ initialValue: value, onChange }),
{ initialProps: { value: 0 } },
);
act(() => result.current.onChange(1));
rerender({ value: -0 });
expect(result.current.value).toBe(-0);
});
});
describe("useDebouncedCallback", () => {
beforeEach(() => {
vi.useFakeTimers();
});
afterEach(() => {
vi.restoreAllMocks();
vi.useRealTimers();
});
it("should debounce the callback", () => {
const callback = vi.fn();
const { result } = renderHook(() => useDebouncedCallback(callback, 1000));
act(() => {
result.current("test");
result.current("test2");
result.current("test3");
});
expect(callback).not.toHaveBeenCalled();
act(() => {
vi.runAllTimers();
});
expect(callback).toHaveBeenCalledTimes(1);
expect(callback).toHaveBeenCalledWith("test3");
});
it("should maintain the same reference when deps don't change", () => {
const callback = vi.fn();
const { result, rerender } = renderHook(() =>
useDebouncedCallback(callback, 1000),
);
const firstRef = result.current;
rerender();
const secondRef = result.current;
expect(firstRef).toBe(secondRef);
});
it("should create new debounced function when delay changes", () => {
const callback = vi.fn();
const { result, rerender } = renderHook(
({ delay }) => useDebouncedCallback(callback, delay),
{ initialProps: { delay: 1000 } },
);
const firstRef = result.current;
rerender({ delay: 2000 });
const secondRef = result.current;
expect(firstRef).not.toBe(secondRef);
});
});