Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

22.7 KB
Raw Blame
/* eslint-disable react/jsx-props-no-spreading */
import { render, fireEvent, act } from '@testing-library/react';
import SubMenu from './SubMenu';
import MenuItem from './MenuItem';
import { hideMenu } from './actions';
import { callIfExists, cssClasses, store } from './helpers';
import listener from './globalEventListener';

// ---------------------------------------------------------------------------
// Mocks
// ---------------------------------------------------------------------------

jest.mock('./actions', () => ({ hideMenu: jest.fn() }));

jest.mock('./helpers', () => ({
  callIfExists: jest.fn((fn, ...args) => fn && fn(...args)),
  hasOwnProp: jest.fn((obj, key) => Object.prototype.hasOwnProperty.call(obj, key)),
  cssClasses: {
    menu: 'react-contextmenu',
    menuVisible: 'react-contextmenu--visible',
    menuItem: 'react-contextmenu-item',
    menuItemActive: 'react-contextmenu-item--active',
    menuItemDisabled: 'react-contextmenu-item--disabled',
    menuItemSelected: 'react-contextmenu-item--selected',
    subMenu: 'react-contextmenu-submenu',
  },
  store: { data: {}, target: null },
}));

jest.mock('./globalEventListener', () => ({
  register: jest.fn(() => 'mock-listen-id'),
  unregister: jest.fn(),
}));

// ---------------------------------------------------------------------------
// Silence React DOM unknown prop warnings
// ---------------------------------------------------------------------------

beforeEach(() => {
  jest.clearAllMocks();
  jest.spyOn(console, 'error').mockImplementation(() => {});
});

afterEach(() => {
  console.error.mockRestore();
  store.data = {};
  store.target = null;
});

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

function renderSubMenu(props = {}) {
  return render(
    <SubMenu title={<span data-testid="title">Submenu</span>} {...props}>
      <MenuItem>Child Item</MenuItem>
    </SubMenu>,
  );
}

function getHideHandler() {
  return listener.register.mock.calls[listener.register.mock.calls.length - 1][1];
}

function openSubMenu(outerNav, delay = 100) {
  fireEvent.mouseEnter(outerNav);
  act(() => jest.advanceTimersByTime(delay));
}

function setupSubMenuRect(subMenuNav, overrides = {}) {
  subMenuNav.getBoundingClientRect = () => ({
    bottom: 100,
    right: 100,
    left: 50,
    width: 100,
    height: 50,
    ...overrides,
  });
}

// ---------------------------------------------------------------------------
// Rendering
// ---------------------------------------------------------------------------

describe('rendering', () => {
  it('renders nav with role menuitem', () => {
    const { getAllByRole } = renderSubMenu();
    expect(getAllByRole('menuitem').length).toBeGreaterThan(0);
  });

  it('renders title', () => {
    const { getByTestId } = renderSubMenu();
    expect(getByTestId('title')).toBeTruthy();
  });

  it('renders children', () => {
    const { getByText } = renderSubMenu();
    expect(getByText('Child Item')).toBeTruthy();
  });

  it('applies menuItem and subMenu classes to outer nav', () => {
    const { getAllByRole } = renderSubMenu();
    const nav = getAllByRole('menuitem')[0];
    expect(nav.className).toContain(cssClasses.menuItem);
    expect(nav.className).toContain(cssClasses.subMenu);
  });

  it('applies custom className to inner nav', () => {
    const { getAllByRole } = renderSubMenu({ className: 'custom' });
    expect(getAllByRole('menu')[0].className).toContain('custom');
  });

  it('applies disabled class when disabled', () => {
    const { getByTestId } = renderSubMenu({ disabled: true });
    expect(getByTestId('title').parentElement.className).toContain(cssClasses.menuItemDisabled);
  });

  it('applies attributes.disabledClassName when disabled', () => {
    const { getByTestId } = renderSubMenu({
      disabled: true,
      attributes: { disabledClassName: 'dis' },
    });
    expect(getByTestId('title').parentElement.className).toContain('dis');
  });

  it('applies selected class when selected', () => {
    const { getByTestId } = renderSubMenu({ selected: true });
    expect(getByTestId('title').parentElement.className).toContain(cssClasses.menuItemSelected);
  });

  it('applies attributes.selectedClassName when selected', () => {
    const { getByTestId } = renderSubMenu({
      selected: true,
      attributes: { selectedClassName: 'sel' },
    });
    expect(getByTestId('title').parentElement.className).toContain('sel');
  });

  it('applies attributes.visibleClassName when visible', () => {
    jest.useFakeTimers();
    const { getAllByRole, getByTestId } = renderSubMenu({
      hoverDelay: 100,
      attributes: { visibleClassName: 'vis' },
    });
    openSubMenu(getAllByRole('menuitem')[0]);
    expect(getByTestId('title').parentElement.className).toContain('vis');
    jest.useRealTimers();
  });

  it('applies attributes.listClassName to outer nav', () => {
    const { getAllByRole } = renderSubMenu({ attributes: { listClassName: 'list' } });
    expect(getAllByRole('menuitem')[0].className).toContain('list');
  });

  it('applies attributes.className to title div', () => {
    const { getByTestId } = renderSubMenu({ attributes: { className: 'attr' } });
    expect(getByTestId('title').parentElement.className).toContain('attr');
  });

  it('forwards onMouseMove to title div', () => {
    const onMouseMove = jest.fn();
    const { getByTestId } = renderSubMenu({ onMouseMove });
    fireEvent.mouseMove(getByTestId('title').parentElement);
    expect(onMouseMove).toHaveBeenCalled();
  });

  it('forwards onMouseOut to title div', () => {
    const onMouseOut = jest.fn();
    const { getByTestId } = renderSubMenu({ onMouseOut });
    fireEvent.mouseOut(getByTestId('title').parentElement);
    expect(onMouseOut).toHaveBeenCalled();
  });
});

// ---------------------------------------------------------------------------
// Lifecycle
// ---------------------------------------------------------------------------

describe('lifecycle', () => {
  it('registers listener on mount', () => {
    renderSubMenu();
    // clearAllMocks runs in beforeEach so count is exactly 1 per test
    expect(listener.register).toHaveBeenCalledTimes(1);
  });

  it('unregisters listener on unmount', () => {
    const { unmount } = renderSubMenu();
    unmount();
    expect(listener.unregister).toHaveBeenCalledWith('mock-listen-id');
  });

  it('does not unregister when listenId is falsy', () => {
    listener.register.mockReturnValueOnce(null);
    const { unmount } = renderSubMenu();
    unmount();
    expect(listener.unregister).not.toHaveBeenCalled();
  });

  it('clears open timer on unmount', () => {
    jest.useFakeTimers();
    const clearSpy = jest.spyOn(global, 'clearTimeout');
    const { getAllByRole, unmount } = renderSubMenu({ hoverDelay: 500 });
    fireEvent.mouseEnter(getAllByRole('menuitem')[0]);
    unmount();
    expect(clearSpy).toHaveBeenCalled();
    clearSpy.mockRestore();
    jest.useRealTimers();
  });

  it('clears close timer on unmount', () => {
    jest.useFakeTimers();
    const clearSpy = jest.spyOn(global, 'clearTimeout');
    const { getAllByRole, unmount } = renderSubMenu({ hoverDelay: 100 });
    openSubMenu(getAllByRole('menuitem')[0]);
    fireEvent.mouseLeave(getAllByRole('menuitem')[0]);
    unmount();
    expect(clearSpy).toHaveBeenCalled();
    clearSpy.mockRestore();
    jest.useRealTimers();
  });
});

// ---------------------------------------------------------------------------
// shouldComponentUpdate
// ---------------------------------------------------------------------------

describe('shouldComponentUpdate', () => {
  it('always returns true and tracks visibility change', () => {
    jest.useFakeTimers();
    const { getAllByRole, getByTestId } = renderSubMenu({ hoverDelay: 100 });
    openSubMenu(getAllByRole('menuitem')[0]);
    expect(getByTestId('title').parentElement.className).toContain(cssClasses.menuItemActive);
    jest.useRealTimers();
  });

  it('isVisibilityChange is false when visible and forceOpen both true', () => {
    jest.useFakeTimers();
    const { getAllByRole, rerender } = render(
      <SubMenu title={<span>T</span>} forceOpen={false} hoverDelay={100}>
        <MenuItem>C</MenuItem>
      </SubMenu>,
    );
    openSubMenu(getAllByRole('menuitem')[0]);
    const subMenuNav = getAllByRole('menu')[0];
    setupSubMenuRect(subMenuNav);
    rerender(
      <SubMenu title={<span>T</span>} forceOpen hoverDelay={100}>
        <MenuItem>C</MenuItem>
      </SubMenu>,
    );
    act(() => jest.runAllTimers());
    expect(subMenuNav).toBeTruthy();
    jest.useRealTimers();
  });
});

// ---------------------------------------------------------------------------
// componentDidUpdate — show branch
// ---------------------------------------------------------------------------

describe('componentDidUpdate show branch', () => {
  it('adds menuVisible class after opening (LTR, no overflow)', () => {
    jest.useFakeTimers();
    const { getAllByRole } = renderSubMenu({ hoverDelay: 100 });
    const subMenuNav = getAllByRole('menu')[0];
    Object.defineProperty(window, 'innerHeight', { writable: true, value: 800 });
    Object.defineProperty(window, 'innerWidth', { writable: true, value: 800 });
    setupSubMenuRect(subMenuNav, { bottom: 200, right: 200 });
    openSubMenu(getAllByRole('menuitem')[0]);
    act(() => jest.runAllTimers());
    expect(subMenuNav.className).toContain(cssClasses.menuVisible);
    jest.useRealTimers();
  });

  it('positions with bottom/right when overflowing in LTR', () => {
    jest.useFakeTimers();
    const { getAllByRole } = renderSubMenu({ hoverDelay: 100 });
    const subMenuNav = getAllByRole('menu')[0];
    Object.defineProperty(window, 'innerHeight', { writable: true, value: 300 });
    Object.defineProperty(window, 'innerWidth', { writable: true, value: 300 });
    setupSubMenuRect(subMenuNav, { bottom: 500, right: 500 });
    openSubMenu(getAllByRole('menuitem')[0]);
    act(() => jest.runAllTimers());
    expect(subMenuNav.className).toContain(cssClasses.menuVisible);
    jest.useRealTimers();
  });

  it('adds menuVisible class for RTL with no overflow', () => {
    jest.useFakeTimers();
    const { getAllByRole } = renderSubMenu({ hoverDelay: 100, rtl: true });
    const subMenuNav = getAllByRole('menu')[0];
    Object.defineProperty(window, 'innerHeight', { writable: true, value: 800 });
    setupSubMenuRect(subMenuNav, { bottom: 200, left: 100 });
    openSubMenu(getAllByRole('menuitem')[0]);
    act(() => jest.runAllTimers());
    expect(subMenuNav.className).toContain(cssClasses.menuVisible);
    jest.useRealTimers();
  });

  it('adds menuVisible class for RTL with bottom overflow and left < 0', () => {
    jest.useFakeTimers();
    const { getAllByRole } = renderSubMenu({ hoverDelay: 100, rtl: true });
    const subMenuNav = getAllByRole('menu')[0];
    Object.defineProperty(window, 'innerHeight', { writable: true, value: 300 });
    setupSubMenuRect(subMenuNav, { bottom: 500, left: -50 });
    openSubMenu(getAllByRole('menuitem')[0]);
    act(() => jest.runAllTimers());
    expect(subMenuNav.className).toContain(cssClasses.menuVisible);
    jest.useRealTimers();
  });

  it('shows when forceOpen becomes true', () => {
    jest.useFakeTimers();
    const { getAllByRole, rerender } = render(
      <SubMenu title={<span>T</span>} forceOpen={false}>
        <MenuItem>C</MenuItem>
      </SubMenu>,
    );
    const subMenuNav = getAllByRole('menu')[0];
    setupSubMenuRect(subMenuNav);
    rerender(
      <SubMenu title={<span>T</span>} forceOpen>
        <MenuItem>C</MenuItem>
      </SubMenu>,
    );
    act(() => jest.runAllTimers());
    expect(subMenuNav.className).toContain(cssClasses.menuVisible);
    jest.useRealTimers();
  });
});

// ---------------------------------------------------------------------------
// componentDidUpdate — hide branch
// ---------------------------------------------------------------------------

describe('componentDidUpdate hide branch', () => {
  it('removes menuVisible and resets styles on transitionend', () => {
    jest.useFakeTimers();
    const { getAllByRole } = renderSubMenu({ hoverDelay: 100 });
    const outerNav = getAllByRole('menuitem')[0];
    const subMenuNav = getAllByRole('menu')[0];
    Object.defineProperty(window, 'innerHeight', { writable: true, value: 800 });
    Object.defineProperty(window, 'innerWidth', { writable: true, value: 800 });
    setupSubMenuRect(subMenuNav);
    openSubMenu(outerNav);
    act(() => jest.runAllTimers());
    fireEvent.mouseLeave(outerNav);
    act(() => jest.advanceTimersByTime(100));
    act(() => fireEvent.transitionEnd(subMenuNav));
    expect(subMenuNav.style.top).toBe('0px');
    expect(subMenuNav.style.left).toBe('100%');
    jest.useRealTimers();
  });

  it('does not run update logic when isVisibilityChange is false', () => {
    const { rerender } = render(
      <SubMenu title={<span>T</span>} forceOpen={false}>
        <MenuItem>C</MenuItem>
      </SubMenu>,
    );
    expect(() =>
      rerender(
        <SubMenu title={<span>T</span>} forceOpen={false}>
          <MenuItem>C</MenuItem>
        </SubMenu>,
      ),
    ).not.toThrow();
  });
});

// ---------------------------------------------------------------------------
// handleMouseEnter
// ---------------------------------------------------------------------------

describe('handleMouseEnter', () => {
  it('opens after hoverDelay', () => {
    jest.useFakeTimers();
    const { getAllByRole, getByTestId } = renderSubMenu({ hoverDelay: 100 });
    openSubMenu(getAllByRole('menuitem')[0]);
    expect(getByTestId('title').parentElement.className).toContain(cssClasses.menuItemActive);
    jest.useRealTimers();
  });

  it('does not open when disabled', () => {
    jest.useFakeTimers();
    const { getAllByRole, getByTestId } = renderSubMenu({ disabled: true, hoverDelay: 100 });
    openSubMenu(getAllByRole('menuitem')[0]);
    expect(getByTestId('title').parentElement.className).not.toContain(cssClasses.menuItemActive);
    jest.useRealTimers();
  });

  it('does not open again if already visible', () => {
    jest.useFakeTimers();
    const { getAllByRole } = renderSubMenu({ hoverDelay: 100 });
    const outerNav = getAllByRole('menuitem')[0];
    openSubMenu(outerNav);
    const spy = jest.spyOn(global, 'setTimeout');
    fireEvent.mouseEnter(outerNav);
    expect(spy).not.toHaveBeenCalled();
    spy.mockRestore();
    jest.useRealTimers();
  });

  it('clears close timer on enter', () => {
    jest.useFakeTimers();
    const clearSpy = jest.spyOn(global, 'clearTimeout');
    const { getAllByRole } = renderSubMenu({ hoverDelay: 100 });
    const outerNav = getAllByRole('menuitem')[0];
    openSubMenu(outerNav);
    fireEvent.mouseLeave(outerNav);
    fireEvent.mouseEnter(outerNav);
    expect(clearSpy).toHaveBeenCalled();
    clearSpy.mockRestore();
    jest.useRealTimers();
  });
});

// ---------------------------------------------------------------------------
// handleMouseLeave
// ---------------------------------------------------------------------------

describe('handleMouseLeave', () => {
  it('closes after hoverDelay', () => {
    jest.useFakeTimers();
    const { getAllByRole, getByTestId } = renderSubMenu({ hoverDelay: 100 });
    const outerNav = getAllByRole('menuitem')[0];
    openSubMenu(outerNav);
    fireEvent.mouseLeave(outerNav);
    act(() => jest.advanceTimersByTime(100));
    expect(getByTestId('title').parentElement.className).not.toContain(cssClasses.menuItemActive);
    jest.useRealTimers();
  });

  it('does not set close timer when not visible', () => {
    jest.useFakeTimers();
    const spy = jest.spyOn(global, 'setTimeout');
    const { getAllByRole } = renderSubMenu({ hoverDelay: 100 });
    fireEvent.mouseLeave(getAllByRole('menuitem')[0]);
    expect(spy).not.toHaveBeenCalled();
    spy.mockRestore();
    jest.useRealTimers();
  });

  it('clears open timer on leave', () => {
    jest.useFakeTimers();
    const clearSpy = jest.spyOn(global, 'clearTimeout');
    const { getAllByRole } = renderSubMenu({ hoverDelay: 500 });
    fireEvent.mouseEnter(getAllByRole('menuitem')[0]);
    fireEvent.mouseLeave(getAllByRole('menuitem')[0]);
    expect(clearSpy).toHaveBeenCalled();
    clearSpy.mockRestore();
    jest.useRealTimers();
  });
});

// ---------------------------------------------------------------------------
// handleClick
// ---------------------------------------------------------------------------

describe('handleClick', () => {
  it('does not call onClick when disabled', () => {
    const onClick = jest.fn();
    const { getByTestId } = renderSubMenu({ disabled: true, onClick });
    fireEvent.click(getByTestId('title').parentElement);
    expect(onClick).not.toHaveBeenCalled();
  });

  it('calls callIfExists with onClick when not disabled', () => {
    const onClick = jest.fn();
    const { getByTestId } = renderSubMenu({ onClick });
    fireEvent.click(getByTestId('title').parentElement);
    expect(callIfExists).toHaveBeenCalledWith(
      onClick,
      expect.anything(),
      expect.anything(),
      store.target,
    );
  });

  it('calls hideMenu when onClick provided and not preventCloseOnClick', () => {
    const onClick = jest.fn();
    const { getByTestId } = renderSubMenu({ onClick });
    fireEvent.click(getByTestId('title').parentElement);
    expect(hideMenu).toHaveBeenCalled();
  });

  it('does not call hideMenu when onClick not provided', () => {
    // clearAllMocks in beforeEach ensures clean state
    const { getByTestId } = renderSubMenu();
    fireEvent.click(getByTestId('title').parentElement);
    expect(hideMenu).not.toHaveBeenCalled();
  });

  it('does not call hideMenu when preventCloseOnClick is true', () => {
    const onClick = jest.fn();
    const { getByTestId } = renderSubMenu({ onClick, preventCloseOnClick: true });
    fireEvent.click(getByTestId('title').parentElement);
    expect(hideMenu).not.toHaveBeenCalled();
  });

  it('merges props.data and store.data', () => {
    // Set store.data directly on the mock object
    const mockStore = require('./helpers').store;
    mockStore.data = { sk: 'sv' };

    const onClick = jest.fn();
    const { getByTestId } = renderSubMenu({ onClick, data: { ik: 'iv' } });
    fireEvent.click(getByTestId('title').parentElement);

    // callIfExists is called once in this test (mocks cleared in beforeEach)
    const arg = callIfExists.mock.calls[0][2];
    expect(arg.sk).toBe('sv');
    expect(arg.ik).toBe('iv');
    mockStore.data = {};
  });

  it('passes store.target as third arg', () => {
    const mockStore = require('./helpers').store;
    const t = document.createElement('div');
    mockStore.target = t;

    const onClick = jest.fn();
    const { getByTestId } = renderSubMenu({ onClick });
    fireEvent.click(getByTestId('title').parentElement);

    expect(callIfExists.mock.calls[0][3]).toBe(t);
    mockStore.target = null;
  });
});

// ---------------------------------------------------------------------------
// hideSubMenu
// ---------------------------------------------------------------------------

describe('hideSubMenu', () => {
  it('hides the menu', () => {
    jest.useFakeTimers();
    const { getAllByRole, getByTestId } = renderSubMenu({ hoverDelay: 100 });
    openSubMenu(getAllByRole('menuitem')[0]);
    act(() => getHideHandler()({ detail: null }));
    expect(getByTestId('title').parentElement.className).not.toContain(cssClasses.menuItemActive);
    jest.useRealTimers();
  });

  it('calls forceClose when forceOpen is true', () => {
    const forceClose = jest.fn();
    renderSubMenu({ forceOpen: true, forceClose });
    act(() => getHideHandler()({ detail: null }));
    expect(forceClose).toHaveBeenCalled();
  });

  it('does not hide when detail.id does not match menu id', () => {
    jest.useFakeTimers();
    const { getAllByRole, getByTestId } = renderSubMenu({ hoverDelay: 100 });
    const subMenuNav = getAllByRole('menu')[0];
    setupSubMenuRect(subMenuNav);
    openSubMenu(getAllByRole('menuitem')[0]);
    act(() => jest.runAllTimers());
    act(() => getHideHandler()({ detail: { id: 'other' } }));
    expect(getByTestId('title').parentElement.className).toContain(cssClasses.menuItemActive);
    jest.useRealTimers();
  });

  it('does not throw with empty detail', () => {
    renderSubMenu();
    expect(() => act(() => getHideHandler()({ detail: null }))).not.toThrow();
  });

  it('does not throw with detail but no id', () => {
    renderSubMenu();
    expect(() => act(() => getHideHandler()({ detail: {} }))).not.toThrow();
  });
});

// ---------------------------------------------------------------------------
// registerHandlers / unregisterHandlers
// ---------------------------------------------------------------------------

describe('registerHandlers / unregisterHandlers', () => {
  it('swaps keydown handlers on register', () => {
    jest.useFakeTimers();
    const removeSpy = jest.spyOn(document, 'removeEventListener');
    const addSpy = jest.spyOn(document, 'addEventListener');
    const { getAllByRole } = renderSubMenu({ hoverDelay: 100 });
    openSubMenu(getAllByRole('menuitem')[0]);
    act(() => jest.runAllTimers());
    expect(removeSpy).toHaveBeenCalledWith('keydown', expect.any(Function));
    expect(addSpy).toHaveBeenCalledWith('keydown', expect.any(Function));
    removeSpy.mockRestore();
    addSpy.mockRestore();
    jest.useRealTimers();
  });

  it('restores keydown handler on close via transitionend (not dismounting)', () => {
    jest.useFakeTimers();
    const { getAllByRole } = renderSubMenu({ hoverDelay: 100 });
    const outerNav = getAllByRole('menuitem')[0];
    const subMenuNav = getAllByRole('menu')[0];
    Object.defineProperty(window, 'innerHeight', { writable: true, value: 800 });
    Object.defineProperty(window, 'innerWidth', { writable: true, value: 800 });
    setupSubMenuRect(subMenuNav);

    openSubMenu(outerNav);
    act(() => jest.runAllTimers());

    // Close the submenu
    fireEvent.mouseLeave(outerNav);
    act(() => jest.advanceTimersByTime(100));

    // Spy AFTER close timer fires but BEFORE transitionend
    const addSpy = jest.spyOn(document, 'addEventListener');

    // transitionend triggers cleanup which calls unregisterHandlers(false)
    act(() => fireEvent.transitionEnd(subMenuNav));

    expect(addSpy).toHaveBeenCalledWith('keydown', expect.any(Function));
    addSpy.mockRestore();
    jest.useRealTimers();
  });

  it('does not restore keydown handler when dismounting', () => {
    jest.useFakeTimers();
    const { getAllByRole, unmount } = renderSubMenu({ hoverDelay: 100 });
    const subMenuNav = getAllByRole('menu')[0];
    setupSubMenuRect(subMenuNav);
    openSubMenu(getAllByRole('menuitem')[0]);
    act(() => jest.runAllTimers());

    // Spy before unmount
    const addSpy = jest.spyOn(document, 'addEventListener');
    unmount();

    // unregisterHandlers(true) must NOT re-add keydown
    expect(addSpy.mock.calls.filter(([e]) => e === 'keydown').length).toBe(0);
    addSpy.mockRestore();
    jest.useRealTimers();
  });
});