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 { renderHook } from "@testing-library/react";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { useInterval } from "../useInterval";
describe("useInterval", () => {
beforeEach(() => {
vi.useFakeTimers();
});
afterEach(() => {
vi.restoreAllMocks();
});
it("should call callback after delay", () => {
const callback = vi.fn();
renderHook(() =>
useInterval(callback, { delayMs: 1000, whenVisible: false }),
);
expect(callback).not.toHaveBeenCalled();
vi.advanceTimersByTime(1000);
expect(callback).toHaveBeenCalledTimes(1);
});
it("should not call callback when disabled", () => {
const callback = vi.fn();
renderHook(() =>
useInterval(callback, {
delayMs: 1000,
whenVisible: false,
disabled: true,
}),
);
vi.advanceTimersByTime(1000);
expect(callback).not.toHaveBeenCalled();
});
it("should respect visibility when whenVisible is true", () => {
const callback = vi.fn();
Object.defineProperty(document, "visibilityState", {
value: "hidden",
writable: true,
});
renderHook(() =>
useInterval(callback, { delayMs: 1000, whenVisible: true }),
);
vi.advanceTimersByTime(1000);
expect(callback).not.toHaveBeenCalled();
Object.defineProperty(document, "visibilityState", { value: "visible" });
vi.advanceTimersByTime(1000);
expect(callback).toHaveBeenCalled();
});
it("should cleanup on unmount", () => {
const callback = vi.fn();
const { unmount } = renderHook(() =>
useInterval(callback, { delayMs: 1000, whenVisible: false }),
);
unmount();
vi.advanceTimersByTime(1000);
expect(callback).not.toHaveBeenCalled();
});
describe("skipIfRunning", () => {
it("should allow overlapping async calls by default", async () => {
let concurrentCalls = 0;
let maxConcurrentCalls = 0;
const callback = vi.fn(async () => {
concurrentCalls++;
maxConcurrentCalls = Math.max(maxConcurrentCalls, concurrentCalls);
// Simulate slow async work
await new Promise((resolve) => setTimeout(resolve, 2000));
concurrentCalls--;
});
renderHook(() =>
useInterval(callback, { delayMs: 500, whenVisible: false }),
);
// First call at 500ms
vi.advanceTimersByTime(500);
expect(callback).toHaveBeenCalledTimes(1);
// Second call at 1000ms (while first is still running)
vi.advanceTimersByTime(500);
expect(callback).toHaveBeenCalledTimes(2);
// Third call at 1500ms
vi.advanceTimersByTime(500);
expect(callback).toHaveBeenCalledTimes(3);
// Multiple concurrent calls should have occurred
expect(maxConcurrentCalls).toBeGreaterThan(1);
});
it("should skip calls when skipIfRunning is true", async () => {
let concurrentCalls = 0;
let maxConcurrentCalls = 0;
const callback = vi.fn(async () => {
concurrentCalls++;
maxConcurrentCalls = Math.max(maxConcurrentCalls, concurrentCalls);
// Simulate slow async work (3 seconds)
await new Promise<void>((resolve) => setTimeout(resolve, 3000));
concurrentCalls--;
});
renderHook(() =>
useInterval(callback, {
delayMs: 500,
whenVisible: false,
skipIfRunning: true,
}),
);
// First call at 500ms
await vi.advanceTimersByTimeAsync(500);
expect(callback).toHaveBeenCalledTimes(1);
// Second interval tick at 1000ms - should be skipped since first is still running
await vi.advanceTimersByTimeAsync(500);
expect(callback).toHaveBeenCalledTimes(1); // Still 1, not 2
// Third interval tick at 1500ms - should still be skipped
await vi.advanceTimersByTimeAsync(500);
expect(callback).toHaveBeenCalledTimes(1); // Still 1
// Only one concurrent call should have occurred
expect(maxConcurrentCalls).toBe(1);
// Advance past the 3 second timeout to complete first callback
await vi.advanceTimersByTimeAsync(2000);
// Next interval tick should now be able to run
await vi.advanceTimersByTimeAsync(500);
expect(callback).toHaveBeenCalledTimes(2);
});
it("should allow next call after previous async call completes with skipIfRunning true", async () => {
const callback = vi.fn(async () => {
// Quick async operation
await Promise.resolve();
});
renderHook(() =>
useInterval(callback, {
delayMs: 1000,
whenVisible: false,
skipIfRunning: true,
}),
);
// First call
await vi.advanceTimersByTimeAsync(1000);
expect(callback).toHaveBeenCalledTimes(1);
// Second call - should proceed since first completed
await vi.advanceTimersByTimeAsync(1000);
expect(callback).toHaveBeenCalledTimes(2);
// Third call
await vi.advanceTimersByTimeAsync(1000);
expect(callback).toHaveBeenCalledTimes(3);
});
});
});