Skip to content

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

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

/**
 * @file TopNavMegaMenu.test.tsx
 * @input Uses vitest, @testing-library/react, TopNavMegaMenu and sub-components
 * @output Unit tests for TopNavMegaMenu slots API and mobile modes
 * @position Testing; validates TopNavMegaMenu behavior
 *
 * SYNC: When TopNavMegaMenu changes, update tests to match new behavior
 */

import {createRef, type ReactNode} from 'react';
import * as stylex from '@stylexjs/stylex';
import {focusOutlineStyles} from '../utils/focusOutline.stylex';
import {describe, it, expect, vi, beforeAll, afterAll, afterEach} from 'vitest';
import {render, screen, act, fireEvent, within} from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import {TopNavMegaMenu} from './TopNavMegaMenu';
import {TopNavMegaMenuItem} from './TopNavMegaMenuItem';
import {TopNavRenderContext} from './TopNavRenderContext';

// =============================================================================
// Popover API mock — jsdom implements no Popover API, so default-mode tests
// that actually open/close the panel install these shims on HTMLElement.
// =============================================================================

let originalMatches: typeof HTMLElement.prototype.matches;

function installPopoverApiMock() {
  originalMatches = HTMLElement.prototype.matches;
  HTMLElement.prototype.showPopover = vi.fn(function (this: HTMLElement) {
    // Model the browser's auto-popover stack: opening one auto popover evicts
    // any currently open auto popover before showing the new one.
    if (this.getAttribute('popover') === 'auto') {
      document
        .querySelectorAll<HTMLElement>('[popover="auto"][popover-open]')
        .forEach(openPopover => {
          if (openPopover === this) {
            return;
          }
          openPopover.removeAttribute('popover-open');
          const closeEvent = new Event('toggle', {bubbles: false});
          Object.defineProperty(closeEvent, 'newState', {value: 'closed'});
          openPopover.dispatchEvent(closeEvent);
        });
    }
    this.setAttribute('popover-open', '');
    const event = new Event('toggle', {bubbles: false});
    Object.defineProperty(event, 'newState', {value: 'open'});
    this.dispatchEvent(event);
  });
  HTMLElement.prototype.hidePopover = vi.fn(function (this: HTMLElement) {
    this.removeAttribute('popover-open');
    const event = new Event('toggle', {bubbles: false});
    Object.defineProperty(event, 'newState', {value: 'closed'});
    this.dispatchEvent(event);
  });
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  (HTMLElement.prototype as any).matches = function (
    selector: string,
  ): boolean {
    if (selector === ':popover-open') {
      return this.hasAttribute('popover-open');
    }
    return originalMatches.call(this, selector);
  };
}

function restorePopoverApiMock() {
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  (HTMLElement.prototype as any).matches = originalMatches;
}

// =============================================================================
// Default (desktop) mode
// =============================================================================

describe('TopNavMegaMenu — default mode', () => {
  it('renders the trigger button with label', () => {
    render(
      <TopNavMegaMenu
        label="Products"
        items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
      />,
    );
    expect(screen.getByRole('button', {name: 'Products'})).toBeInTheDocument();
  });

  it('trigger has aria-haspopup and aria-expanded attributes', () => {
    render(
      <TopNavMegaMenu
        label="Products"
        items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
      />,
    );
    const trigger = screen.getByRole('button', {name: 'Products'});
    expect(trigger).toHaveAttribute('aria-haspopup', 'true');
    expect(trigger).toHaveAttribute('aria-expanded', 'false');
  });

  it('renders with multiple menu items', () => {
    render(
      <TopNavMegaMenu
        label="Products"
        items={
          <>
            <TopNavMegaMenuItem title="Analytics" href="/analytics" />
            <TopNavMegaMenuItem title="Reports" href="/reports" />
          </>
        }
      />,
    );
    expect(screen.getByRole('button', {name: 'Products'})).toBeInTheDocument();
  });

  it('renders with featured content', () => {
    render(
      <TopNavMegaMenu
        label="Products"
        items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
        featured={<span data-testid="featured">Featured content</span>}
      />,
    );
    expect(screen.getByRole('button', {name: 'Products'})).toBeInTheDocument();
  });

  it('renders without items or featured', () => {
    render(<TopNavMegaMenu label="Empty" />);
    expect(screen.getByRole('button', {name: 'Empty'})).toBeInTheDocument();
  });
});

// =============================================================================
// Popup semantics (default mode)
// =============================================================================

describe('TopNavMegaMenu — popup semantics', () => {
  beforeAll(installPopoverApiMock);
  afterAll(restorePopoverApiMock);

  it('trigger aria-controls resolves to the popup element', async () => {
    const user = userEvent.setup();
    render(
      <TopNavMegaMenu
        label="Products"
        items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
      />,
    );

    const trigger = screen.getByRole('button', {name: 'Products'});
    expect(trigger).toHaveAttribute('aria-expanded', 'false');

    // aria-controls must be present and point at the real popup element.
    const controlsId = trigger.getAttribute('aria-controls');
    expect(controlsId).toBeTruthy();
    const popup = document.getElementById(controlsId as string);
    expect(popup).not.toBeNull();

    await user.click(trigger);

    expect(trigger).toHaveAttribute('aria-expanded', 'true');
    // The referenced element is the popup that contains the panel content.
    expect(popup).toContainElement(
      screen.getByRole('group', {name: 'Products', hidden: true}),
    );
  });

  it('does not wrap the panel in a role="dialog" aria-modal element', async () => {
    const user = userEvent.setup();
    render(
      <TopNavMegaMenu
        label="Products"
        items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
      />,
    );

    await user.click(screen.getByRole('button', {name: 'Products'}));

    // Focus stays on the trigger while the panel is open, so a modal dialog
    // wrapper would tell assistive tech the focused control is inert.
    expect(
      screen.queryByRole('dialog', {hidden: true}),
    ).not.toBeInTheDocument();
    expect(document.querySelector('[aria-modal="true"]')).toBeNull();
  });

  it('does not expose role="menu" — a link grid is not an ARIA menu', async () => {
    const user = userEvent.setup();
    render(
      <TopNavMegaMenu
        label="Products"
        items={
          <>
            <TopNavMegaMenuItem title="Analytics" href="/analytics" />
            <TopNavMegaMenuItem title="Reports" href="/reports" />
          </>
        }
      />,
    );

    await user.click(screen.getByRole('button', {name: 'Products'}));

    // Per the WAI-ARIA APG, mega menu panels of navigation links must not use
    // the menu role (reserved for action menus with menuitem children).
    expect(screen.queryByRole('menu', {hidden: true})).not.toBeInTheDocument();
    expect(screen.queryAllByRole('menuitem', {hidden: true})).toHaveLength(0);
  });

  it('exposes the panel as a labeled group', async () => {
    const user = userEvent.setup();
    render(
      <TopNavMegaMenu
        label="Products"
        items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
      />,
    );

    await user.click(screen.getByRole('button', {name: 'Products'}));

    expect(
      screen.getByRole('group', {name: 'Products', hidden: true}),
    ).toBeInTheDocument();
  });

  it('keeps item links with accessible names inside the panel', async () => {
    const user = userEvent.setup();
    render(
      <TopNavMegaMenu
        label="Products"
        items={
          <>
            <TopNavMegaMenuItem title="Analytics" href="/analytics" />
            <TopNavMegaMenuItem title="Reports" href="/reports" />
          </>
        }
      />,
    );

    await user.click(screen.getByRole('button', {name: 'Products'}));

    const analytics = screen.getByRole('link', {
      name: /Analytics/,
      hidden: true,
    });
    expect(analytics).toHaveAttribute('href', '/analytics');
    expect(
      screen.getByRole('link', {name: /Reports/, hidden: true}),
    ).toHaveAttribute('href', '/reports');
  });
});

// =============================================================================
// Hover → click guard (default mode) — issue #3121
//
// The trigger opens on hover and on click. A hover-open records a timestamp so
// the click that naturally follows a hover confirms and pins the panel for
// CLICK_GUARD_MS (the panel just appeared under the cursor) instead of toggling
// it shut. Deliberate clicks outside that window still toggle.
// =============================================================================

describe('TopNavMegaMenu — hover/click guard (default mode)', () => {
  beforeAll(installPopoverApiMock);
  afterAll(restorePopoverApiMock);
  afterEach(() => {
    vi.useRealTimers();
  });

  function renderMenu() {
    render(
      <TopNavMegaMenu
        label="Products"
        items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
      />,
    );
    return screen.getByRole('button', {name: 'Products'});
  }

  it('keeps the panel open when a hover-open is immediately clicked', async () => {
    vi.useFakeTimers({shouldAdvanceTime: true});
    const user = userEvent.setup({advanceTimers: vi.advanceTimersByTime});
    const trigger = renderMenu();

    // Hover opens the panel after the show delay (150ms).
    await user.hover(trigger);
    act(() => {
      vi.advanceTimersByTime(200);
    });
    expect(trigger).toHaveAttribute('aria-expanded', 'true');

    // The click that naturally follows the hover must NOT toggle it shut.
    await user.click(trigger);
    expect(trigger).toHaveAttribute('aria-expanded', 'true');

    // It is still a click interaction, so it pins the panel just like a
    // click-open. Leaving the trigger must not dismiss it.
    await user.unhover(trigger);
    act(() => {
      vi.advanceTimersByTime(300);
    });
    expect(trigger).toHaveAttribute('aria-expanded', 'true');
  });

  it('closes on a click that lands well after the hover-open (past the guard)', async () => {
    vi.useFakeTimers({shouldAdvanceTime: true});
    const user = userEvent.setup({advanceTimers: vi.advanceTimersByTime});
    const trigger = renderMenu();

    await user.hover(trigger);
    act(() => {
      vi.advanceTimersByTime(200);
    });
    expect(trigger).toHaveAttribute('aria-expanded', 'true');

    // Past the guard window, a click is a deliberate dismissal.
    act(() => {
      vi.advanceTimersByTime(600);
    });
    await user.click(trigger);
    expect(trigger).toHaveAttribute('aria-expanded', 'false');
  });

  it('toggles cleanly for click-only interaction (no hover, no guard)', async () => {
    const user = userEvent.setup();
    const trigger = renderMenu();

    // A click with no preceding hover opens...
    await user.click(trigger);
    expect(trigger).toHaveAttribute('aria-expanded', 'true');

    // ...and the next click closes — the guard only applies after a hover-open.
    await user.click(trigger);
    expect(trigger).toHaveAttribute('aria-expanded', 'false');
  });

  it('closes a hover-opened (transient) panel when the pointer leaves', async () => {
    vi.useFakeTimers({shouldAdvanceTime: true});
    const user = userEvent.setup({advanceTimers: vi.advanceTimersByTime});
    const trigger = renderMenu();

    await user.hover(trigger);
    act(() => {
      vi.advanceTimersByTime(200);
    });
    expect(trigger).toHaveAttribute('aria-expanded', 'true');

    // Leaving closes it after hideDelay (250ms) — hover opens are transient.
    await user.unhover(trigger);
    act(() => {
      vi.advanceTimersByTime(300);
    });
    expect(trigger).toHaveAttribute('aria-expanded', 'false');
  });

  it('keeps a click-opened (pinned) panel open when the pointer leaves', async () => {
    vi.useFakeTimers({shouldAdvanceTime: true});
    const user = userEvent.setup({advanceTimers: vi.advanceTimersByTime});
    const trigger = renderMenu();

    // A click pins the panel open (a deliberate open should persist).
    await user.click(trigger);
    expect(trigger).toHaveAttribute('aria-expanded', 'true');

    await user.unhover(trigger);
    act(() => {
      vi.advanceTimersByTime(400);
    });
    expect(trigger).toHaveAttribute('aria-expanded', 'true');
  });

  it('re-entering the trigger cancels a pending hide', async () => {
    vi.useFakeTimers({shouldAdvanceTime: true});
    const user = userEvent.setup({advanceTimers: vi.advanceTimersByTime});
    const trigger = renderMenu();

    await user.hover(trigger);
    act(() => {
      vi.advanceTimersByTime(200);
    });
    expect(trigger).toHaveAttribute('aria-expanded', 'true');

    // Leave (schedules a hide), then return before hideDelay elapses.
    await user.unhover(trigger);
    act(() => {
      vi.advanceTimersByTime(100);
    });
    await user.hover(trigger);
    act(() => {
      vi.advanceTimersByTime(300);
    });
    expect(trigger).toHaveAttribute('aria-expanded', 'true');
  });

  it('does not reopen when the pointer enters the panel after close', async () => {
    vi.useFakeTimers({shouldAdvanceTime: true});
    const user = userEvent.setup({advanceTimers: vi.advanceTimersByTime});
    const trigger = renderMenu();
    const panel = screen.getByRole('group', {
      name: 'Products',
      hidden: true,
    });

    await user.click(trigger);
    await user.click(trigger);
    expect(trigger).toHaveAttribute('aria-expanded', 'false');

    // The exit transition can leave the closed panel briefly hit-testable.
    fireEvent.mouseEnter(panel);
    act(() => {
      vi.advanceTimersByTime(200);
    });

    expect(trigger).toHaveAttribute('aria-expanded', 'false');
  });

  it('re-hovering an open panel does not refresh the click guard', async () => {
    vi.useFakeTimers({shouldAdvanceTime: true});
    const user = userEvent.setup({advanceTimers: vi.advanceTimersByTime});
    const trigger = renderMenu();

    await user.hover(trigger);
    act(() => {
      vi.advanceTimersByTime(200);
    });
    expect(trigger).toHaveAttribute('aria-expanded', 'true');

    // Wait past the guard window, re-hovering along the way. The re-hover must
    // NOT re-stamp the guard timestamp (only a fresh open may), so the click
    // below is still judged a deliberate close.
    act(() => {
      vi.advanceTimersByTime(600);
    });
    await user.hover(trigger);
    act(() => {
      vi.advanceTimersByTime(200);
    });
    await user.click(trigger);
    expect(trigger).toHaveAttribute('aria-expanded', 'false');
  });

  it('opening a sibling mega menu closes the pinned menu through the native auto-popover stack', async () => {
    vi.useFakeTimers({shouldAdvanceTime: true});
    const user = userEvent.setup({advanceTimers: vi.advanceTimersByTime});
    render(
      <>
        <TopNavMegaMenu
          label="Products"
          items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
        />
        <TopNavMegaMenu
          label="Solutions"
          items={<TopNavMegaMenuItem title="Enterprise" href="/enterprise" />}
        />
      </>,
    );

    const products = screen.getByRole('button', {name: 'Products'});
    const solutions = screen.getByRole('button', {name: 'Solutions'});

    await user.click(products);
    expect(products).toHaveAttribute('aria-expanded', 'true');

    await user.hover(solutions);
    act(() => {
      vi.advanceTimersByTime(200);
    });

    expect(products).toHaveAttribute('aria-expanded', 'false');
    expect(solutions).toHaveAttribute('aria-expanded', 'true');
  });
});

// =============================================================================
// Dismissal (default mode) — issue #3121
//
// The panel stays an *auto* popover for native light dismiss and stack
// exclusivity. `popoverTarget` makes the button its native invoker so trigger
// activation is not treated as an outside click before the guard can run.
// jsdom cannot exercise that native event ordering; these tests lock in the
// required wiring, while the end-to-end interaction is browser-verified in the
// PR's manual test plan.
// =============================================================================

describe('TopNavMegaMenu — dismissal (default mode)', () => {
  beforeAll(installPopoverApiMock);
  afterAll(restorePopoverApiMock);

  function renderAndOpen() {
    render(
      <TopNavMegaMenu
        label="Products"
        items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
      />,
    );
    return screen.getByRole('button', {name: 'Products'});
  }

  it('renders an auto popover and registers the trigger as its native invoker', () => {
    const trigger = renderAndOpen();
    const popup = document.getElementById(
      trigger.getAttribute('aria-controls') as string,
    );
    expect(popup).toHaveAttribute('popover', 'auto');
    expect(trigger).toHaveAttribute('popovertarget', popup?.id);
  });

  it('prevents the native invoker toggle so the click guard owns activation', async () => {
    const trigger = renderAndOpen();

    const clickEvent = new MouseEvent('click', {
      bubbles: true,
      cancelable: true,
      detail: 1,
    });
    fireEvent(trigger, clickEvent);

    expect(clickEvent.defaultPrevented).toBe(true);
    expect(trigger).toHaveAttribute('aria-expanded', 'true');
  });

  it('reconciles a browser-initiated native light dismiss', async () => {
    const user = userEvent.setup();
    const trigger = renderAndOpen();

    await user.click(trigger);
    expect(trigger).toHaveAttribute('aria-expanded', 'true');

    const popup = document.getElementById(
      trigger.getAttribute('aria-controls') as string,
    ) as HTMLElement;
    popup.removeAttribute('popover-open');
    const toggleEvent = new Event('toggle', {bubbles: false});
    Object.defineProperty(toggleEvent, 'newState', {value: 'closed'});
    fireEvent(popup, toggleEvent);

    expect(trigger).toHaveAttribute('aria-expanded', 'false');
  });
});

// =============================================================================
// Keyboard (default mode) — issue #3121
//
// Keyboard activation always OPENS (never toggles the panel closed) and moves
// focus into the panel; Escape closes it and returns focus to the trigger.
// =============================================================================

describe('TopNavMegaMenu — keyboard (default mode)', () => {
  beforeAll(installPopoverApiMock);
  afterAll(restorePopoverApiMock);

  it('opens on Enter (keyboard activation)', async () => {
    const user = userEvent.setup();
    render(
      <TopNavMegaMenu
        label="Products"
        items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
      />,
    );
    const trigger = screen.getByRole('button', {name: 'Products'});
    trigger.focus();

    await user.keyboard('{Enter}');

    // aria-expanded is the observable signal. Enter also auto-focuses the first
    // link (unlike pointer/hover opens, which keep focus on the trigger), but
    // that focus landing is only verifiable in a real browser — jsdom renders
    // the popover content display:none, so activeElement can't move onto it
    // (browser-verified via the Playwright checks for #3121). Panel content
    // presence is deliberately NOT asserted: useLayer renders it into the DOM
    // even while closed, so such an assertion would be vacuous.
    expect(trigger).toHaveAttribute('aria-expanded', 'true');
  });

  it('opens on Space', async () => {
    const user = userEvent.setup();
    render(
      <TopNavMegaMenu
        label="Products"
        items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
      />,
    );
    const trigger = screen.getByRole('button', {name: 'Products'});
    trigger.focus();

    await user.keyboard(' ');

    expect(trigger).toHaveAttribute('aria-expanded', 'true');
  });

  it('keyboard activation never toggles an open panel closed', async () => {
    const user = userEvent.setup();
    render(
      <TopNavMegaMenu
        label="Products"
        items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
      />,
    );
    const trigger = screen.getByRole('button', {name: 'Products'});

    // Open via pointer (focus stays on the trigger).
    await user.click(trigger);
    expect(trigger).toHaveAttribute('aria-expanded', 'true');

    // Enter on an already-open panel keeps it open — no toggle-close.
    trigger.focus();
    await user.keyboard('{Enter}');
    expect(trigger).toHaveAttribute('aria-expanded', 'true');
  });

  it('closes on Escape and returns focus to the trigger', async () => {
    const user = userEvent.setup();
    render(
      <TopNavMegaMenu
        label="Products"
        items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
      />,
    );
    const trigger = screen.getByRole('button', {name: 'Products'});

    // Pointer open leaves focus on the trigger.
    await user.click(trigger);
    expect(trigger).toHaveAttribute('aria-expanded', 'true');

    await user.keyboard('{Escape}');
    expect(trigger).toHaveAttribute('aria-expanded', 'false');
    expect(trigger).toHaveFocus();
  });
});

// =============================================================================
// Mobile-bar mode — should be hidden
// =============================================================================

describe('TopNavMegaMenu — mobile-bar mode', () => {
  it('returns null in mobile-bar mode', () => {
    const {container} = render(
      <TopNavRenderContext value="mobile-bar">
        <TopNavMegaMenu
          label="Products"
          items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
        />
      </TopNavRenderContext>,
    );
    expect(container.innerHTML).toBe('');
  });
});

// =============================================================================
// Drawer mode — inline collapsible
// =============================================================================

describe('TopNavMegaMenu — drawer mode', () => {
  it('renders a collapsible trigger with label', () => {
    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenu
          label="Products"
          items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
        />
      </TopNavRenderContext>,
    );
    const trigger = screen.getByRole('button', {name: 'Products'});
    expect(trigger).toBeInTheDocument();
    expect(trigger).toHaveAttribute('aria-expanded', 'false');
  });

  it('expands to show items when tapped', async () => {
    const user = userEvent.setup();

    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenu
          label="Products"
          items={
            <>
              <TopNavMegaMenuItem title="Analytics" href="/analytics" />
              <TopNavMegaMenuItem title="Reports" href="/reports" />
            </>
          }
        />
      </TopNavRenderContext>,
    );

    const trigger = screen.getByRole('button', {name: 'Products'});
    expect(trigger).toHaveAttribute('aria-expanded', 'false');

    await user.click(trigger);

    expect(trigger).toHaveAttribute('aria-expanded', 'true');
    expect(screen.getByText('Analytics')).toBeInTheDocument();
    expect(screen.getByText('Reports')).toBeInTheDocument();
  });

  it('collapses when trigger is clicked again', async () => {
    const user = userEvent.setup();

    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenu
          label="Products"
          items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
        />
      </TopNavRenderContext>,
    );

    const trigger = screen.getByRole('button', {name: 'Products'});
    await user.click(trigger);
    expect(trigger).toHaveAttribute('aria-expanded', 'true');
    await user.click(trigger);
    expect(trigger).toHaveAttribute('aria-expanded', 'false');
  });

  it('shows item descriptions when provided', async () => {
    const user = userEvent.setup();

    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenu
          label="Products"
          items={
            <TopNavMegaMenuItem
              title="Analytics"
              description="Track behavior"
              href="/analytics"
            />
          }
        />
      </TopNavRenderContext>,
    );

    await user.click(screen.getByRole('button', {name: 'Products'}));

    expect(screen.getByText('Analytics')).toBeInTheDocument();
    expect(screen.getByText('Track behavior')).toBeInTheDocument();
  });

  it('renders items as links when href is provided', async () => {
    const user = userEvent.setup();

    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenu
          label="Products"
          items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
        />
      </TopNavRenderContext>,
    );

    await user.click(screen.getByRole('button', {name: 'Products'}));

    const link = screen.getByRole('link', {name: 'Analytics'});
    expect(link).toHaveAttribute('href', '/analytics');
  });

  it('renders items as buttons when onClick is provided without href', async () => {
    const user = userEvent.setup();
    const handleClick = vi.fn();

    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenu
          label="Tools"
          items={<TopNavMegaMenuItem title="Export" onClick={handleClick} />}
        />
      </TopNavRenderContext>,
    );

    await user.click(screen.getByRole('button', {name: 'Tools'}));
    await user.click(screen.getByRole('button', {name: 'Export'}));

    expect(handleClick).toHaveBeenCalledTimes(1);
  });

  it('makes collapsed items inert and hidden from assistive technology', async () => {
    const user = userEvent.setup();
    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenu
          label="Products"
          items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
        />
      </TopNavRenderContext>,
    );
    const trigger = screen.getByRole('button', {name: 'Products'});
    const region = document.getElementById(
      trigger.getAttribute('aria-controls') ?? '',
    );

    expect(region).toHaveAttribute('inert');
    expect(region).toHaveAttribute('aria-hidden', 'true');
    expect(screen.queryByRole('link', {name: 'Analytics'})).toBeNull();

    await user.click(trigger);
    expect(region).not.toHaveAttribute('inert');
    expect(region).toHaveAttribute('aria-hidden', 'false');
    expect(screen.getByRole('link', {name: 'Analytics'})).toBeInTheDocument();
  });

  it('clips the drawer section only while it is collapsed', async () => {
    // The ring paints outside the item, so a permanent clip would cut it off.
    const user = userEvent.setup();
    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenu
          label="Products"
          items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
        />
      </TopNavRenderContext>,
    );
    const trigger = screen.getByRole('button', {name: 'Products'});
    const section = document.getElementById(
      trigger.getAttribute('aria-controls') ?? '',
    )!;
    expect(getComputedStyle(section).overflow).toBe('hidden');
    expect(getComputedStyle(section.firstElementChild!).overflow).toBe('');

    await user.click(trigger);
    expect(getComputedStyle(section).overflow).toBe('visible');
  });

  it('renders featured content when expanded', async () => {
    const user = userEvent.setup();

    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenu
          label="Products"
          items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
          featured={<span>Featured: New AI Tools</span>}
        />
      </TopNavRenderContext>,
    );

    await user.click(screen.getByRole('button', {name: 'Products'}));

    expect(screen.getByText('Featured: New AI Tools')).toBeInTheDocument();
  });
});

// =============================================================================
// TopNavMegaMenuItem — standalone rendering
// =============================================================================

describe('TopNavMegaMenuItem', () => {
  it('renders as a desktop item by default', () => {
    render(<TopNavMegaMenuItem title="Analytics" href="/analytics" />);
    expect(screen.getByRole('link', {name: /Analytics/})).toBeInTheDocument();
  });

  it('renders description in desktop mode', () => {
    render(
      <TopNavMegaMenuItem
        title="Analytics"
        description="Track behavior"
        href="/analytics"
      />,
    );
    expect(screen.getByText('Analytics')).toBeInTheDocument();
    expect(screen.getByText('Track behavior')).toBeInTheDocument();
  });

  it('renders as a drawer item in drawer context', () => {
    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenuItem title="Analytics" href="/analytics" />
      </TopNavRenderContext>,
    );
    expect(screen.getByRole('link', {name: /Analytics/})).toBeInTheDocument();
  });
});

// =============================================================================
// The shared focus ring (#4654) — see the note in SideNav.test.tsx: jsdom will
// not derive `:focus-visible` here, so what is pinned is that the focusable
// element composes the shared utility's classes rather than falling back to
// the browser's own outline.
// =============================================================================

const sharedFocusRingClasses = stylex
  .props(focusOutlineStyles.focusVisible)
  .className!.split(' ');

function expectSharedFocusRing(el: Element) {
  const classes = el.className.split(' ');
  for (const c of sharedFocusRingClasses) {
    expect(classes).toContain(c);
  }
}

describe('TopNavMegaMenu — drawer focus ring', () => {
  it('draws the shared ring on the drawer section header', () => {
    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenu
          label="Products"
          items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
        />
      </TopNavRenderContext>,
    );
    expectSharedFocusRing(screen.getByRole('button', {name: 'Products'}));
  });

  it('draws the shared ring on a drawer item', () => {
    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenuItem title="Analytics" href="/analytics" />
      </TopNavRenderContext>,
    );
    expectSharedFocusRing(screen.getByRole('link', {name: /Analytics/}));
  });
});

describe('TopNavMegaMenu pass-through props', () => {
  it('forwards pass-through props to the trigger button', () => {
    render(
      <TopNavMegaMenu
        label="Products"
        aria-label="Products mega menu"
        id="mega-trigger"
        data-source="nav"
      />,
    );
    const trigger = screen.getByRole('button', {name: 'Products mega menu'});
    expect(trigger).toHaveAttribute('id', 'mega-trigger');
    expect(trigger).toHaveAttribute('data-source', 'nav');
  });

  it('forwards pass-through props to the drawer trigger', () => {
    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenu label="Products" id="mega-drawer" data-source="nav" />
      </TopNavRenderContext>,
    );
    const trigger = screen.getByRole('button', {name: /Products/});
    expect(trigger).toHaveAttribute('id', 'mega-drawer');
    expect(trigger).toHaveAttribute('data-source', 'nav');
  });
});

describe('TopNavMegaMenu — owned handlers on the trigger', () => {
  beforeAll(installPopoverApiMock);
  afterAll(restorePopoverApiMock);
  afterEach(() => {
    vi.useRealTimers();
  });

  it("composes a caller's onClick with the trigger's own open behavior", async () => {
    const user = userEvent.setup();
    const handleClick = vi.fn();
    render(
      <TopNavMegaMenu
        label="Products"
        items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
        onClick={handleClick}
      />,
    );

    const trigger = screen.getByRole('button', {name: 'Products'});
    await user.click(trigger);

    expect(handleClick).toHaveBeenCalledOnce();
    expect(trigger).toHaveAttribute('aria-expanded', 'true');
  });

  it("composes a caller's hover handlers with the trigger's hover-open behavior", async () => {
    vi.useFakeTimers({shouldAdvanceTime: true});
    const user = userEvent.setup({advanceTimers: vi.advanceTimersByTime});
    const handleMouseEnter = vi.fn();
    const handleMouseLeave = vi.fn();
    render(
      <TopNavMegaMenu
        label="Products"
        items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
        onMouseEnter={handleMouseEnter}
        onMouseLeave={handleMouseLeave}
      />,
    );

    const trigger = screen.getByRole('button', {name: 'Products'});
    await user.hover(trigger);
    act(() => {
      vi.advanceTimersByTime(200);
    });
    expect(handleMouseEnter).toHaveBeenCalledOnce();
    expect(trigger).toHaveAttribute('aria-expanded', 'true');

    await user.unhover(trigger);
    act(() => {
      vi.advanceTimersByTime(400);
    });
    expect(handleMouseLeave).toHaveBeenCalledOnce();
    expect(trigger).toHaveAttribute('aria-expanded', 'false');
  });

  it("composes a caller's onClick with the drawer section toggle", async () => {
    const user = userEvent.setup();
    const handleClick = vi.fn();
    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenu
          label="Products"
          items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
          onClick={handleClick}
        />
      </TopNavRenderContext>,
    );

    const trigger = screen.getByRole('button', {name: /Products/});
    expect(trigger).toHaveAttribute('aria-expanded', 'false');

    await user.click(trigger);
    expect(handleClick).toHaveBeenCalledOnce();
    expect(trigger).toHaveAttribute('aria-expanded', 'true');
  });
});

describe('TopNavMegaMenuItem pass-through props', () => {
  it('forwards pass-through props in default mode', () => {
    render(
      <TopNavMegaMenuItem
        title="Analytics"
        aria-label="Open analytics"
        id="mega-analytics"
        data-tracking="mega-item"
        data-testid="item"
      />,
    );
    const item = screen.getByTestId('item');
    expect(item).toHaveAttribute('aria-label', 'Open analytics');
    expect(item).toHaveAttribute('id', 'mega-analytics');
    expect(item).toHaveAttribute('data-tracking', 'mega-item');
  });

  it('forwards event handlers in default mode', () => {
    const handleMouseEnter = vi.fn();
    render(
      <TopNavMegaMenuItem
        title="Analytics"
        onMouseEnter={handleMouseEnter}
        data-testid="item"
      />,
    );
    fireEvent.mouseEnter(screen.getByTestId('item'));
    expect(handleMouseEnter).toHaveBeenCalledOnce();
  });

  it('forwards pass-through props in drawer mode', () => {
    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenuItem
          title="Analytics"
          data-tracking="mega-item"
          data-testid="item"
        />
      </TopNavRenderContext>,
    );
    expect(screen.getByTestId('item')).toHaveAttribute(
      'data-tracking',
      'mega-item',
    );
  });

  it('composes consumer styling and forwards tabIndex in drawer mode', () => {
    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenuItem
          title="Analytics"
          className="consumer-item"
          style={{outlineColor: 'red'}}
          tabIndex={-1}
          data-testid="item"
        />
      </TopNavRenderContext>,
    );
    const item = screen.getByTestId('item');
    expect(item).toHaveClass('consumer-item');
    expect(item.style.outlineColor).toBe('red');
    expect(item).toHaveAttribute('tabindex', '-1');
  });

  it('composes consumer styling in default mode', () => {
    render(
      <TopNavMegaMenuItem
        title="Analytics"
        className="consumer-item"
        style={{outlineColor: 'red'}}
        data-testid="item"
      />,
    );
    const item = screen.getByTestId('item');
    expect(item).toHaveClass('consumer-item');
    // The internal classes are still applied alongside the consumer's.
    expect(item.className.split(' ').length).toBeGreaterThan(1);
    expect(item.style.outlineColor).toBe('red');
  });

  it('applies xstyle as extra classes in both modes', () => {
    const xstyleTestStyles = stylex.create({
      custom: {marginInlineEnd: '7px'},
    });
    const renderBoth = (xstyle?: (typeof xstyleTestStyles)['custom']) => (
      <>
        <TopNavMegaMenuItem
          title="Analytics"
          xstyle={xstyle}
          data-testid="default-item"
        />
        <TopNavRenderContext value="drawer">
          <TopNavMegaMenuItem
            title="Analytics"
            xstyle={xstyle}
            data-testid="drawer-item"
          />
        </TopNavRenderContext>
      </>
    );
    const {rerender} = render(renderBoth());
    const defaultWithout = screen
      .getByTestId('default-item')
      .getAttribute('class');
    const drawerWithout = screen
      .getByTestId('drawer-item')
      .getAttribute('class');

    // xstyle values are compiled StyleX styles; passing one adds classes.
    rerender(renderBoth(xstyleTestStyles.custom));
    expect(
      screen.getByTestId('default-item').getAttribute('class'),
    ).not.toEqual(defaultWithout);
    expect(screen.getByTestId('drawer-item').getAttribute('class')).not.toEqual(
      drawerWithout,
    );
  });
});

describe('TopNavMegaMenu ref', () => {
  const items = <TopNavMegaMenuItem title="Analytics" href="/analytics" />;

  it('forwards its ref to the trigger button', () => {
    const ref = createRef<HTMLButtonElement>();
    render(<TopNavMegaMenu ref={ref} label="Products" items={items} />);
    expect(ref.current).toBe(screen.getByRole('button', {name: 'Products'}));
  });

  it('forwards its ref to the drawer trigger', () => {
    const ref = createRef<HTMLButtonElement>();
    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenu ref={ref} label="Products" items={items} />
      </TopNavRenderContext>,
    );
    expect(ref.current).toBe(screen.getByRole('button', {name: /Products/}));
  });
});

// A slot is empty for exactly the values React renders as nothing.
describe('TopNavMegaMenu empty slots', () => {
  it.each([
    ['an empty string', ''],
    ['false', false],
    ['true', true],
    ['null', null],
  ])('renders no featured wrapper in the drawer for %s', (_name, featured) => {
    const section = (element: HTMLElement) => {
      const trigger = within(element).getByRole('button', {name: 'Products'});
      // Both renders share an id, so look the group up inside this render.
      return element
        .querySelector(`[id="${trigger.getAttribute('aria-controls')}"]`)!
        .innerHTML.replace(/(id|aria-[a-z]+)="[^"]*"/g, '$1');
    };
    const {container: withFeatured} = render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenu
          label="Products"
          items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
          featured={featured as ReactNode}
        />
      </TopNavRenderContext>,
    );
    const {container: without} = render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenu
          label="Products"
          items={<TopNavMegaMenuItem title="Analytics" href="/analytics" />}
        />
      </TopNavRenderContext>,
    );
    expect(section(withFeatured)).toBe(section(without));
  });

  it('renders 0 as featured content, as React does', async () => {
    const user = userEvent.setup();
    render(
      <TopNavRenderContext value="drawer">
        <TopNavMegaMenu label="Products" featured={0} />
      </TopNavRenderContext>,
    );
    await user.click(screen.getByRole('button', {name: 'Products'}));
    expect(screen.getByText('0')).toBeInTheDocument();
  });
});