Skip to content

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

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

import {Activity, type ReactNode} from 'react';
import {describe, it, expect, vi} from 'vitest';
import {render, screen, fireEvent} from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import {ClickableCard} from './ClickableCard';
import {LinkProvider} from '../Link';
import {
  afterPaintsPress,
  hasReleaseFade,
  pressArmsShadowedByDefault,
  readsPressStrength,
} from '../__tests__/pressState';

describe('ClickableCard', () => {
  it('renders children', () => {
    render(
      <ClickableCard label="Test card" onClick={() => {}}>
        <span>Card content</span>
      </ClickableCard>,
    );
    expect(screen.getByText('Card content')).toBeInTheDocument();
  });

  it('renders a hidden button for onClick cards', () => {
    render(
      <ClickableCard label="Test card" onClick={() => {}}>
        <span>Content</span>
      </ClickableCard>,
    );
    const button = screen.getByRole('button', {name: 'Test card'});
    expect(button).toBeInTheDocument();
  });

  it('renders a hidden link for href cards', () => {
    render(
      <ClickableCard label="Nav card" href="/settings">
        Content
      </ClickableCard>,
    );
    const link = screen.getByRole('link', {name: 'Nav card'});
    expect(link).toBeInTheDocument();
    expect(link).toHaveAttribute('href', '/settings');
  });

  it('calls onClick when card surface is clicked', () => {
    const handleClick = vi.fn();
    render(
      <ClickableCard label="Test card" onClick={handleClick}>
        <span>Content</span>
      </ClickableCard>,
    );
    // Click the card surface (the text), not the hidden button
    fireEvent.click(screen.getByText('Content'));
    expect(handleClick).toHaveBeenCalledTimes(1);
  });

  it('calls onClick once when the accessible control itself is clicked', () => {
    const handleClick = vi.fn();
    render(
      <ClickableCard label="Test card" onClick={handleClick}>
        <span>Content</span>
      </ClickableCard>,
    );
    // Pointer activation aimed at the element carrying the role — what
    // speech input, assistive technology, and automation dispatch.
    fireEvent.click(screen.getByRole('button', {name: 'Test card'}));
    expect(handleClick).toHaveBeenCalledTimes(1);
  });

  it('passes the card surface as currentTarget for surface clicks', () => {
    const seen: EventTarget[] = [];
    render(
      <ClickableCard
        label="Test card"
        onClick={e => seen.push(e.currentTarget)}>
        <span>Content</span>
      </ClickableCard>,
    );
    fireEvent.click(screen.getByText('Content'));
    expect(seen).toHaveLength(1);
    expect(seen[0]).toBe(screen.getByText('Content').parentElement);
  });

  it('calls onClick exactly once when the surface of an href card is clicked without preventDefault', () => {
    const handleClick = vi.fn();
    render(
      <ClickableCard label="Nav card" href="/settings" onClick={handleClick}>
        <span>Content</span>
      </ClickableCard>,
    );
    // The container hook proxies the surface click to the link with
    // `link.click()`; that synthetic click bubbles back through the card and
    // must not run the consumer callback a second time.
    fireEvent.click(screen.getByText('Content'));
    expect(handleClick).toHaveBeenCalledTimes(1);
  });

  it('does NOT call onClick when a nested button is clicked', () => {
    const handleCardClick = vi.fn();
    const handleButtonClick = vi.fn();
    render(
      <ClickableCard label="Test card" onClick={handleCardClick}>
        <button type="button" onClick={handleButtonClick}>
          Nested
        </button>
      </ClickableCard>,
    );
    fireEvent.click(screen.getByText('Nested'));
    expect(handleButtonClick).toHaveBeenCalledTimes(1);
    // Card's onClick should NOT fire because click was on a nested interactive
    expect(handleCardClick).not.toHaveBeenCalled();
  });

  it('hidden button has correct aria-label', () => {
    render(
      <ClickableCard label="Settings card" onClick={() => {}}>
        Content
      </ClickableCard>,
    );
    const button = screen.getByRole('button', {name: 'Settings card'});
    expect(button).toHaveAttribute('aria-label', 'Settings card');
  });

  it('hidden link passes target attribute', () => {
    render(
      <ClickableCard
        label="External"
        href="https://example.com"
        target="_blank">
        Content
      </ClickableCard>,
    );
    const link = screen.getByRole('link', {name: 'External'});
    expect(link).toHaveAttribute('target', '_blank');
  });

  it('disabled button stays focusable and the surface runs nothing', () => {
    const handleClick = vi.fn();
    render(
      <ClickableCard label="Disabled" onClick={handleClick} isDisabled>
        <span>Content</span>
      </ClickableCard>,
    );
    const button = screen.getByRole('button', {name: 'Disabled'});
    expect(button).not.toHaveAttribute('disabled');
    expect(button).toHaveAttribute('aria-disabled', 'true');
    fireEvent.click(screen.getByText('Content'));
    fireEvent.click(button);
    expect(handleClick).not.toHaveBeenCalled();
  });

  it('disabled link has no live destination, keeps its tab stop, and runs nothing', () => {
    const handleClick = vi.fn();
    render(
      <ClickableCard
        label="Disabled link"
        href="/settings"
        target="_blank"
        onClick={handleClick}
        isDisabled>
        <span>Content</span>
      </ClickableCard>,
    );
    const link = screen.getByRole('link', {name: 'Disabled link'});
    expect(link).toHaveAttribute('aria-disabled', 'true');
    expect(link).toHaveAttribute('tabindex', '0');
    expect(link).not.toHaveAttribute('href');
    expect(link).not.toHaveAttribute('target');
    expect(fireEvent.click(link)).toBe(false);
    fireEvent.click(screen.getByText('Content'));
    expect(handleClick).not.toHaveBeenCalled();
  });

  it('does not render a disabled link through the router link component', () => {
    function RouterLink({
      href,
      children,
    }: {
      href?: string;
      children?: ReactNode;
    }) {
      if (href == null) {
        throw new Error('Router link requires an href');
      }
      return <a href={href}>{children}</a>;
    }

    render(
      <LinkProvider component={RouterLink}>
        <ClickableCard label="Disabled link" href="/settings" isDisabled>
          <span>Content</span>
        </ClickableCard>
      </LinkProvider>,
    );

    const link = screen.getByRole('link', {name: 'Disabled link'});
    expect(link).toHaveAttribute('aria-disabled', 'true');
    expect(link).not.toHaveAttribute('href');
  });

  it('keeps focus when a focused link card toggles its disabled state', async () => {
    const user = userEvent.setup();
    const {rerender} = render(
      <ClickableCard label="Focus card" href="/settings">
        <span>Content</span>
      </ClickableCard>,
    );

    await user.tab();
    expect(screen.getByRole('link', {name: 'Focus card'})).toHaveFocus();

    rerender(
      <ClickableCard label="Focus card" href="/settings" isDisabled>
        <span>Content</span>
      </ClickableCard>,
    );
    expect(screen.getByRole('link', {name: 'Focus card'})).toHaveFocus();

    rerender(
      <ClickableCard label="Focus card" href="/settings">
        <span>Content</span>
      </ClickableCard>,
    );
    expect(screen.getByRole('link', {name: 'Focus card'})).toHaveFocus();
  });

  it('leaves focus where the person put it when a hidden card is revealed', async () => {
    const user = userEvent.setup();
    function Harness({isHidden}: {isHidden: boolean}) {
      return (
        <>
          <Activity mode={isHidden ? 'hidden' : 'visible'}>
            <ClickableCard label="Hidden card" href="/settings">
              <span>Content</span>
            </ClickableCard>
          </Activity>
          <button type="button">Elsewhere</button>
        </>
      );
    }
    const {rerender} = render(<Harness isHidden={false} />);
    await user.tab();
    expect(screen.getByRole('link', {name: 'Hidden card'})).toHaveFocus();
    rerender(<Harness isHidden />);
    screen.getByRole('button', {name: 'Elsewhere'}).focus();
    rerender(<Harness isHidden={false} />);
    expect(screen.getByRole('button', {name: 'Elsewhere'})).toHaveFocus();
  });

  it('takes focus back without scrolling the page', async () => {
    const user = userEvent.setup();
    const {rerender} = render(
      <ClickableCard label="Scroll card" href="/settings">
        <span>Content</span>
      </ClickableCard>,
    );
    await user.tab();
    const focus = vi.spyOn(HTMLElement.prototype, 'focus');
    rerender(
      <ClickableCard label="Scroll card" href="/settings" isDisabled>
        <span>Content</span>
      </ClickableCard>,
    );
    expect(focus).toHaveBeenCalledWith({preventScroll: true});
    focus.mockRestore();
  });

  it('runs onClick once from the keyboard via the hidden button', async () => {
    const user = userEvent.setup();
    const handleClick = vi.fn();
    render(
      <ClickableCard label="Test card" onClick={handleClick}>
        <span>Content</span>
      </ClickableCard>,
    );
    await user.tab();
    expect(screen.getByRole('button', {name: 'Test card'})).toHaveFocus();
    await user.keyboard('{Enter}');
    await user.keyboard(' ');
    expect(handleClick).toHaveBeenCalledTimes(2);
  });

  it('does NOT call onClick when a nested input is clicked', () => {
    const handleCardClick = vi.fn();
    render(
      <ClickableCard label="Test card" onClick={handleCardClick}>
        <input aria-label="Quantity" readOnly value="1" />
      </ClickableCard>,
    );
    fireEvent.click(screen.getByRole('textbox', {name: 'Quantity'}));
    expect(handleCardClick).not.toHaveBeenCalled();
  });

  it('does NOT call onClick when text inside the card is selected', () => {
    const handleClick = vi.fn();
    render(
      <ClickableCard label="Test card" onClick={handleClick}>
        <span>Selectable body text</span>
      </ClickableCard>,
    );
    const text = screen.getByText('Selectable body text');
    const range = document.createRange();
    range.selectNodeContents(text);
    const selection = document.getSelection()!;
    selection.removeAllRanges();
    selection.addRange(range);
    fireEvent.click(text);
    expect(handleClick).not.toHaveBeenCalled();
    selection.removeAllRanges();
  });

  describe('elevation', () => {
    it('forwards a distinct elevation class to the card for each level', () => {
      const classFor = (elevation: 'none' | 'low' | 'med' | 'high') => {
        const {container} = render(
          <ClickableCard label="Card" elevation={elevation}>
            Content
          </ClickableCard>,
        );
        return container.firstElementChild!.className;
      };
      const classes = new Set([
        classFor('none'),
        classFor('low'),
        classFor('med'),
        classFor('high'),
      ]);
      expect(classes.size).toBe(4);
    });

    it('defaults to flat (elevation none)', () => {
      const {container: def} = render(
        <ClickableCard label="Card">Content</ClickableCard>,
      );
      const {container: none} = render(
        <ClickableCard label="Card" elevation="none">
          Content
        </ClickableCard>,
      );
      expect(def.firstElementChild!.className).toBe(
        none.firstElementChild!.className,
      );
    });
  });
});

describe('ClickableCard pressed state (touch)', () => {
  it('fades the touch press out on the card, whose overlay layer reads its strength', () => {
    const {container} = render(
      <ClickableCard label="Test card" onClick={() => {}}>
        <span>Content</span>
      </ClickableCard>,
    );
    const card = container.querySelector('[data-astryx-pressable]');
    if (card == null) {
      throw new Error('the card carries no pressable marker');
    }
    // The controller writes the card; the card owns the strength and its
    // release, and its `::after` paints the pressed token at that strength
    // as its image on both arms, its hover and mouse colour yielding.
    expect(hasReleaseFade(card)).toBe(true);
    expect(readsPressStrength(card, '[data-astryx-press="on"]')).toBe(true);
    expect(readsPressStrength(card)).toBe(true);
    expect(afterPaintsPress(card, '[data-astryx-press="on"]')).toBe(true);
    expect(afterPaintsPress(card)).toBe(true);
    // No press arm sits on a custom property the card also declares without
    // it: in a layered stylesheet that declaration wins and the press never
    // paints.
    expect(pressArmsShadowedByDefault(card)).toEqual([]);
  });

  it('carries none of it when disabled', () => {
    const {container} = render(
      <ClickableCard label="Test card" onClick={() => {}} isDisabled>
        <span>Content</span>
      </ClickableCard>,
    );
    expect(container.querySelector('[data-astryx-pressable]')).toBeNull();
  });
});