Skip to content

An open source design system that's fully customizable and agent ready

TypeScript
7.3 KB
Raw Blame
// Copyright (c) Meta Platforms, Inc. and affiliates.

/**
 * @file useCollapsible.test.tsx
 * @input Uses vitest, @testing-library/react, CollapsibleGroupContext
 * @output Unit tests for useCollapsible hook
 * @position Testing; validates config parsing and the three-mode state
 *   machine (group-controlled / controlled / uncontrolled)
 */

import {describe, it, expect, vi} from 'vitest';
import type {ReactNode} from 'react';
import {act, renderHook} from '@testing-library/react';
import {useCollapsible} from './useCollapsible';
import {
  CollapsibleGroupContext,
  type CollapsibleGroupContextValue,
} from './CollapsibleGroupContext';

// =============================================================================
// Helpers
// =============================================================================

function withGroup(group: CollapsibleGroupContextValue) {
  return function GroupWrapper({children}: {children: ReactNode}) {
    return (
      <CollapsibleGroupContext value={group}>
        {children}
      </CollapsibleGroupContext>
    );
  };
}

// =============================================================================
// Config parsing
// =============================================================================

describe('useCollapsible — config parsing', () => {
  it('treats isCollapsible=true as an enabled config that starts open', () => {
    const {result} = renderHook(() => useCollapsible({isCollapsible: true}));

    expect(result.current.isEnabled).toBe(true);
    expect(result.current.isOpen).toBe(true);
  });

  it('is disabled when isCollapsible is undefined', () => {
    const {result} = renderHook(() => useCollapsible({}));

    expect(result.current.isEnabled).toBe(false);
  });

  it('is disabled when isCollapsible is false', () => {
    const {result} = renderHook(() => useCollapsible({isCollapsible: false}));

    expect(result.current.isEnabled).toBe(false);
  });

  it('treats an object config as enabled', () => {
    const {result} = renderHook(() => useCollapsible({isCollapsible: {}}));

    expect(result.current.isEnabled).toBe(true);
    expect(result.current.isOpen).toBe(true);
  });

  it('starts closed when defaultIsOpen is false', () => {
    const {result} = renderHook(() =>
      useCollapsible({isCollapsible: {defaultIsOpen: false}}),
    );

    expect(result.current.isEnabled).toBe(true);
    expect(result.current.isOpen).toBe(false);
  });
});

// =============================================================================
// Uncontrolled mode
// =============================================================================

describe('useCollapsible — uncontrolled mode', () => {
  it('toggle flips the state open → closed → open', () => {
    const {result} = renderHook(() => useCollapsible({isCollapsible: true}));

    act(() => {
      result.current.toggle();
    });
    expect(result.current.isOpen).toBe(false);

    act(() => {
      result.current.toggle();
    });
    expect(result.current.isOpen).toBe(true);
  });

  it('toggle updates internal state AND notifies onOpenChange', () => {
    // onOpenChange without isOpen is a notification callback, not a signal
    // that the component is controlled.
    const onOpenChange = vi.fn();
    const {result} = renderHook(() =>
      useCollapsible({isCollapsible: {onOpenChange}}),
    );

    act(() => {
      result.current.toggle();
    });
    expect(result.current.isOpen).toBe(false);
    expect(onOpenChange).toHaveBeenNthCalledWith(1, false);

    act(() => {
      result.current.toggle();
    });
    expect(result.current.isOpen).toBe(true);
    expect(onOpenChange).toHaveBeenNthCalledWith(2, true);
  });
});

// =============================================================================
// Controlled mode
// =============================================================================

describe('useCollapsible — controlled mode', () => {
  it('renders the isOpen prop and only notifies on toggle, never self-toggles', () => {
    const onOpenChange = vi.fn();
    const {result} = renderHook(() =>
      useCollapsible({isCollapsible: {isOpen: true, onOpenChange}}),
    );

    expect(result.current.isOpen).toBe(true);

    act(() => {
      result.current.toggle();
    });

    expect(onOpenChange).toHaveBeenCalledTimes(1);
    expect(onOpenChange).toHaveBeenCalledWith(false);
    // The parent owns the state — nothing changed internally.
    expect(result.current.isOpen).toBe(true);
  });

  it('reports the inverse of a closed controlled state', () => {
    const onOpenChange = vi.fn();
    const {result} = renderHook(() =>
      useCollapsible({isCollapsible: {isOpen: false, onOpenChange}}),
    );

    expect(result.current.isOpen).toBe(false);

    act(() => {
      result.current.toggle();
    });

    expect(onOpenChange).toHaveBeenCalledWith(true);
    expect(result.current.isOpen).toBe(false);
  });

  it('tolerates a controlled config without onOpenChange', () => {
    const {result} = renderHook(() =>
      useCollapsible({isCollapsible: {isOpen: true}}),
    );

    act(() => {
      result.current.toggle(); // must not throw
    });

    expect(result.current.isOpen).toBe(true);
  });
});

// =============================================================================
// Group mode
// =============================================================================

describe('useCollapsible — group mode', () => {
  it('reads isOpen from the group for its own value', () => {
    const group: CollapsibleGroupContextValue = {
      isOpen: vi.fn((value: string) => value === 'a'),
      toggle: vi.fn(),
    };

    const {result: itemA} = renderHook(
      () => useCollapsible({isCollapsible: true, value: 'a'}),
      {wrapper: withGroup(group)},
    );
    const {result: itemB} = renderHook(
      () => useCollapsible({isCollapsible: true, value: 'b'}),
      {wrapper: withGroup(group)},
    );

    expect(itemA.current.isOpen).toBe(true);
    expect(itemB.current.isOpen).toBe(false);
    expect(group.isOpen).toHaveBeenCalledWith('a');
    expect(group.isOpen).toHaveBeenCalledWith('b');
  });

  it('toggle defers to the group and skips local state and onOpenChange', () => {
    const onOpenChange = vi.fn();
    const group: CollapsibleGroupContextValue = {
      isOpen: vi.fn(() => true),
      toggle: vi.fn(),
    };
    const {result} = renderHook(
      () => useCollapsible({isCollapsible: {onOpenChange}, value: 'a'}),
      {wrapper: withGroup(group)},
    );

    act(() => {
      result.current.toggle();
    });

    expect(group.toggle).toHaveBeenCalledTimes(1);
    expect(group.toggle).toHaveBeenCalledWith('a');
    // Group owns the state: the config callback is not invoked and the open
    // state still comes from the group.
    expect(onOpenChange).not.toHaveBeenCalled();
    expect(result.current.isOpen).toBe(true);
  });

  it('falls back to standalone state inside a group when no value is given', () => {
    const group: CollapsibleGroupContextValue = {
      isOpen: vi.fn(() => false),
      toggle: vi.fn(),
    };
    const {result} = renderHook(() => useCollapsible({isCollapsible: true}), {
      wrapper: withGroup(group),
    });

    // Standalone default: open.
    expect(result.current.isOpen).toBe(true);

    act(() => {
      result.current.toggle();
    });

    expect(result.current.isOpen).toBe(false);
    expect(group.toggle).not.toHaveBeenCalled();
  });
});